7 files changed, 348 insertions, 59 deletions

diff --git a/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs b/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs
index 7427c59..4fd81fa 100644
--- a/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs
@@ -817,8 +817,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             OutPacket(mov, ThrottleOutPacketType.Unknown);
         }
 
-        public void SendChatMessage(string message, byte type, Vector3 fromPos, string fromName,
-                                    UUID fromAgentID, byte source, byte audible)
+        public void SendChatMessage(
+            string message, byte type, Vector3 fromPos, string fromName,
+            UUID fromAgentID, UUID ownerID, byte source, byte audible)
         {
             ChatFromSimulatorPacket reply = (ChatFromSimulatorPacket)PacketPool.Instance.GetPacket(PacketType.ChatFromSimulator);
             reply.ChatData.Audible = audible;
@@ -827,7 +828,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             reply.ChatData.SourceType = source;
             reply.ChatData.Position = fromPos;
             reply.ChatData.FromName = Util.StringToBytes256(fromName);
-            reply.ChatData.OwnerID = fromAgentID;
+            reply.ChatData.OwnerID = ownerID;
             reply.ChatData.SourceID = fromAgentID;
 
             OutPacket(reply, ThrottleOutPacketType.Task);
@@ -5218,8 +5219,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             AddLocalPacketHandler(PacketType.MultipleObjectUpdate, HandleMultipleObjUpdate, false);
             AddLocalPacketHandler(PacketType.MoneyTransferRequest, HandleMoneyTransferRequest, false);
             AddLocalPacketHandler(PacketType.ParcelBuy, HandleParcelBuyRequest, false);
-            AddLocalPacketHandler(PacketType.UUIDGroupNameRequest, HandleUUIDGroupNameRequest, false);
-            AddLocalPacketHandler(PacketType.ObjectGroup, HandleObjectGroupRequest, false);
+            AddLocalPacketHandler(PacketType.UUIDGroupNameRequest, HandleUUIDGroupNameRequest);
+            AddLocalPacketHandler(PacketType.ObjectGroup, HandleObjectGroupRequest);
             AddLocalPacketHandler(PacketType.GenericMessage, HandleGenericMessage);
             AddLocalPacketHandler(PacketType.AvatarPropertiesRequest, HandleAvatarPropertiesRequest);
             AddLocalPacketHandler(PacketType.ChatFromViewer, HandleChatFromViewer);
@@ -5319,9 +5320,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             AddLocalPacketHandler(PacketType.RemoveTaskInventory, HandleRemoveTaskInventory);
             AddLocalPacketHandler(PacketType.MoveTaskInventory, HandleMoveTaskInventory);
             AddLocalPacketHandler(PacketType.RezScript, HandleRezScript);
-            AddLocalPacketHandler(PacketType.MapLayerRequest, HandleMapLayerRequest, false);
-            AddLocalPacketHandler(PacketType.MapBlockRequest, HandleMapBlockRequest, false);
-            AddLocalPacketHandler(PacketType.MapNameRequest, HandleMapNameRequest, false);
+            AddLocalPacketHandler(PacketType.MapLayerRequest, HandleMapLayerRequest);
+            AddLocalPacketHandler(PacketType.MapBlockRequest, HandleMapBlockRequest);
+            AddLocalPacketHandler(PacketType.MapNameRequest, HandleMapNameRequest);
             AddLocalPacketHandler(PacketType.TeleportLandmarkRequest, HandleTeleportLandmarkRequest);
             AddLocalPacketHandler(PacketType.TeleportCancel, HandleTeleportCancel);
             AddLocalPacketHandler(PacketType.TeleportLocationRequest, HandleTeleportLocationRequest);
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/LLUDPServer.cs b/OpenSim/Region/ClientStack/Linden/UDP/LLUDPServer.cs
index 419de66..a7628d2 100644
--- a/OpenSim/Region/ClientStack/Linden/UDP/LLUDPServer.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/LLUDPServer.cs
@@ -70,6 +70,19 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         public void AddScene(IScene scene)
         {
             m_udpServer.AddScene(scene);
+
+            StatsManager.RegisterStat(
+                new Stat(
+                    "IncomingPacketsProcessedCount",
+                    "Number of inbound UDP packets processed",
+                    "Number of inbound UDP packets processed",
+                    "",
+                    "clientstack",
+                    scene.Name,
+                    StatType.Pull,
+                    MeasuresOfInterest.AverageChangeOverTime,
+                    stat => stat.Value = m_udpServer.IncomingPacketsProcessed,
+                    StatVerbosity.Debug));
         }
 
         public bool HandlesRegion(Location x)
@@ -170,6 +183,16 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         private Pool<IncomingPacket> m_incomingPacketPool;
 
+        /// <summary>
+        /// Stat for number of packets in the main pool awaiting use.
+        /// </summary>
+        private Stat m_poolCountStat;
+
+        /// <summary>
+        /// Stat for number of packets in the inbound packet pool awaiting use.
+        /// </summary>
+        private Stat m_incomingPacketPoolStat;
+
         private int m_defaultRTO = 0;
         private int m_maxRTO = 0;
         private int m_ackTimeout = 0;
@@ -214,6 +237,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             m_circuitManager = circuitManager;
             int sceneThrottleBps = 0;
+            bool usePools = false;
 
             IConfig config = configSource.Configs["ClientStack.LindenUDP"];
             if (config != null)
@@ -246,7 +270,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             {
                 PacketPool.Instance.RecyclePackets = packetConfig.GetBoolean("RecyclePackets", true);
                 PacketPool.Instance.RecycleDataBlocks = packetConfig.GetBoolean("RecycleDataBlocks", true);
-                UsePools = packetConfig.GetBoolean("RecycleBaseUDPPackets", false);
+                usePools = packetConfig.GetBoolean("RecycleBaseUDPPackets", usePools);
             }
 
             #region BinaryStats
@@ -277,8 +301,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             m_throttle = new TokenBucket(null, sceneThrottleBps);
             ThrottleRates = new ThrottleRates(configSource);
 
-            if (UsePools)
-                m_incomingPacketPool = new Pool<IncomingPacket>(() => new IncomingPacket(), 500);
+            if (usePools)
+                EnablePools();
         }
 
         public void Start()
@@ -331,6 +355,83 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             base.StopInbound();
         }
 
+        protected override bool EnablePools()
+        {
+            if (!UsePools)
+            {
+                base.EnablePools();
+
+                m_incomingPacketPool = new Pool<IncomingPacket>(() => new IncomingPacket(), 500);
+
+                return true;
+            }
+
+            return false;
+        }
+
+        protected override bool DisablePools()
+        {
+            if (UsePools)
+            {
+                base.DisablePools();
+
+                StatsManager.DeregisterStat(m_incomingPacketPoolStat);
+
+                // We won't null out the pool to avoid a race condition with code that may be in the middle of using it.
+
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// This is a seperate method so that it can be called once we have an m_scene to distinguish different scene
+        /// stats.
+        /// </summary>
+        private void EnablePoolStats()
+        {
+            m_poolCountStat
+                = new Stat(
+                    "UDPPacketBufferPoolCount",
+                    "Objects within the UDPPacketBuffer pool",
+                    "The number of objects currently stored within the UDPPacketBuffer pool",
+                    "",
+                    "clientstack",
+                    m_scene.Name,
+                    StatType.Pull,
+                    stat => stat.Value = Pool.Count,
+                    StatVerbosity.Debug);
+
+            StatsManager.RegisterStat(m_poolCountStat);
+
+            m_incomingPacketPoolStat
+                = new Stat(
+                    "IncomingPacketPoolCount",
+                    "Objects within incoming packet pool",
+                    "The number of objects currently stored within the incoming packet pool",
+                    "",
+                    "clientstack",
+                    m_scene.Name,
+                    StatType.Pull,
+                    stat => stat.Value = m_incomingPacketPool.Count,
+                    StatVerbosity.Debug);
+
+            StatsManager.RegisterStat(m_incomingPacketPoolStat);
+        }
+
+        /// <summary>
+        /// Disables pool stats.
+        /// </summary>
+        private void DisablePoolStats()
+        {
+            StatsManager.DeregisterStat(m_poolCountStat);
+            m_poolCountStat = null;
+
+            StatsManager.DeregisterStat(m_incomingPacketPoolStat);
+            m_incomingPacketPoolStat = null;
+        }
+
         /// <summary>
         /// If the outgoing UDP thread times out, then return client that was being processed to help with debugging.
         /// </summary>
@@ -370,6 +471,65 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             m_scene = (Scene)scene;
             m_location = new Location(m_scene.RegionInfo.RegionHandle);
 
+            // XXX: These stats are also pool stats but we register them separately since they are currently not
+            // turned on and off by EnablePools()/DisablePools()
+            StatsManager.RegisterStat(
+                new PercentageStat(
+                    "PacketsReused",
+                    "Packets reused",
+                    "Number of packets reused out of all requests to the packet pool",
+                    "clientstack",
+                    m_scene.Name,
+                    StatType.Pull,
+                    stat => 
+                        { PercentageStat pstat = (PercentageStat)stat; 
+                          pstat.Consequent = PacketPool.Instance.PacketsRequested; 
+                          pstat.Antecedent = PacketPool.Instance.PacketsReused; },
+                    StatVerbosity.Debug));
+
+            StatsManager.RegisterStat(
+                new PercentageStat(
+                    "PacketDataBlocksReused",
+                    "Packet data blocks reused",
+                    "Number of data blocks reused out of all requests to the packet pool",
+                    "clientstack",
+                    m_scene.Name,
+                    StatType.Pull,
+                    stat =>
+                        { PercentageStat pstat = (PercentageStat)stat; 
+                          pstat.Consequent = PacketPool.Instance.BlocksRequested; 
+                          pstat.Antecedent = PacketPool.Instance.BlocksReused; },
+                    StatVerbosity.Debug));
+
+            StatsManager.RegisterStat(
+                new Stat(
+                    "PacketsPoolCount",
+                    "Objects within the packet pool",
+                    "The number of objects currently stored within the packet pool",
+                    "",
+                    "clientstack",
+                    m_scene.Name,
+                    StatType.Pull,
+                    stat => stat.Value = PacketPool.Instance.PacketsPooled,
+                    StatVerbosity.Debug));
+
+            StatsManager.RegisterStat(
+                new Stat(
+                    "PacketDataBlocksPoolCount",
+                    "Objects within the packet data block pool",
+                    "The number of objects currently stored within the packet data block pool",
+                    "",
+                    "clientstack",
+                    m_scene.Name,
+                    StatType.Pull,
+                    stat => stat.Value = PacketPool.Instance.BlocksPooled,
+                    StatVerbosity.Debug));
+        
+            // We delay enabling pool stats to AddScene() instead of Initialize() so that we can distinguish pool stats by
+            // scene name
+            if (UsePools)
+                EnablePoolStats();
+
             MainConsole.Instance.Commands.AddCommand(
                 "Debug",
                 false,
@@ -397,6 +557,14 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             MainConsole.Instance.Commands.AddCommand(
                 "Debug",
                 false,
+                "debug lludp pool",
+                "debug lludp pool <on|off>",
+                "Turn object pooling within the lludp component on or off.",
+                HandlePoolCommand);
+
+            MainConsole.Instance.Commands.AddCommand(
+                "Debug",
+                false,
                 "debug lludp status",
                 "debug lludp status",
                 "Return status of LLUDP packet processing.",
@@ -437,6 +605,38 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 StopOutbound();
         }
 
+        private void HandlePoolCommand(string module, string[] args)
+        {
+            if (args.Length != 4)
+            {
+                MainConsole.Instance.Output("Usage: debug lludp pool <on|off>");
+                return;
+            }
+
+            string enabled = args[3];
+
+            if (enabled == "on")
+            {
+                if (EnablePools())
+                {
+                    EnablePoolStats();
+                    MainConsole.Instance.OutputFormat("Packet pools enabled on {0}", m_scene.Name);
+                }
+            }
+            else if (enabled == "off")
+            {
+                if (DisablePools())
+                {
+                    DisablePoolStats();
+                    MainConsole.Instance.OutputFormat("Packet pools disabled on {0}", m_scene.Name);
+                }
+            }
+            else
+            {
+                MainConsole.Instance.Output("Usage: debug lludp pool <on|off>");
+            }
+        }
+
         private void HandleStatusCommand(string module, string[] args)
         {
             MainConsole.Instance.OutputFormat(
@@ -444,6 +644,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             MainConsole.Instance.OutputFormat(
                 "OUT LLUDP packet processing for {0} is {1}", m_scene.Name, IsRunningOutbound ? "enabled" : "disabled");
+
+            MainConsole.Instance.OutputFormat("LLUDP pools in {0} are {1}", m_scene.Name, UsePools ? "on" : "off");
         }
 
         public bool HandlesRegion(Location x)
@@ -1473,6 +1675,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         private int npacksSent = 0;
         private int npackNotSent = 0;
 
+        /// <summary>
+        /// Number of inbound packets processed since startup.
+        /// </summary>
+        public long IncomingPacketsProcessed { get; private set; }
+
         private void MonitoredClientOutgoingPacketHandler(IClientAPI client)
         {
             nticks++;
@@ -1532,7 +1739,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                             npacksSent++;
                         }
                         else
+                        {
                             npackNotSent++;
+                        }
 
                         watch2.Stop();
                         avgDequeueTicks = (nticks - 1) / (float)nticks * avgDequeueTicks + (watch2.ElapsedTicks / (float)nticks);
@@ -1540,7 +1749,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
                     }
                     else
+                    {
                         m_log.WarnFormat("[LLUDPSERVER]: Client is not connected");
+                    }
                 }
             }
             catch (Exception ex)
@@ -1604,6 +1815,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     "[LLUDPSERVER]: Dropped incoming {0} for dead client {1} in {2}",
                     packet.Type, client.Name, m_scene.RegionInfo.RegionName);
             }
+
+            IncomingPacketsProcessed++;
         }
 
         protected void LogoutHandler(IClientAPI client)
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/OpenSimUDPBase.cs b/OpenSim/Region/ClientStack/Linden/UDP/OpenSimUDPBase.cs
index 6e6b3ef..3f7ca2b 100644
--- a/OpenSim/Region/ClientStack/Linden/UDP/OpenSimUDPBase.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/OpenSimUDPBase.cs
@@ -31,6 +31,7 @@ using System.Net.Sockets;
 using System.Threading;
 using log4net;
 using OpenSim.Framework;
+using OpenSim.Framework.Monitoring;
 
 namespace OpenMetaverse
 {
@@ -60,14 +61,14 @@ namespace OpenMetaverse
         private bool m_asyncPacketHandling;
 
         /// <summary>
-        /// Pool to use for handling data.  May be null if UsePools = false;
+        /// Are we to use object pool(s) to reduce memory churn when receiving data?
         /// </summary>
-        protected OpenSim.Framework.Pool<UDPPacketBuffer> m_pool;
+        public bool UsePools { get; protected set; }
 
         /// <summary>
-        /// Are we to use object pool(s) to reduce memory churn when receiving data?
+        /// Pool to use for handling data.  May be null if UsePools = false;
         /// </summary>
-        public bool UsePools { get; protected set; }
+        protected OpenSim.Framework.Pool<UDPPacketBuffer> Pool { get; private set; }
 
         /// <summary>Returns true if the server is currently listening for inbound packets, otherwise false</summary>
         public bool IsRunningInbound { get; private set; }
@@ -106,11 +107,6 @@ namespace OpenMetaverse
         /// necessary</remarks>
         public void StartInbound(int recvBufferSize, bool asyncPacketHandling)
         {
-            if (UsePools)
-                m_pool = new Pool<UDPPacketBuffer>(() => new UDPPacketBuffer(), 500);
-            else
-                m_pool = null;
-
             m_asyncPacketHandling = asyncPacketHandling;
 
             if (!IsRunningInbound)
@@ -180,12 +176,40 @@ namespace OpenMetaverse
             IsRunningOutbound = false;
         }
 
+        protected virtual bool EnablePools()
+        {
+            if (!UsePools)
+            {
+                Pool = new Pool<UDPPacketBuffer>(() => new UDPPacketBuffer(), 500);
+
+                UsePools = true;
+
+                return true;
+            }
+
+            return false;
+        }
+
+        protected virtual bool DisablePools()
+        {
+            if (UsePools)
+            {
+                UsePools = false;
+
+                // We won't null out the pool to avoid a race condition with code that may be in the middle of using it.
+
+                return true;
+            }
+
+            return false;
+        }
+
         private void AsyncBeginReceive()
         {
             UDPPacketBuffer buf;
 
             if (UsePools)
-                buf = m_pool.GetObject();
+                buf = Pool.GetObject();
             else
                 buf = new UDPPacketBuffer();
 
@@ -268,7 +292,7 @@ namespace OpenMetaverse
                 finally
                 {
                     if (UsePools)
-                        m_pool.ReturnObject(buffer);
+                        Pool.ReturnObject(buffer);
 
                     // Synchronous mode waits until the packet callback completes
                     // before starting the receive to fetch another packet
@@ -310,4 +334,4 @@ namespace OpenMetaverse
             catch (ObjectDisposedException) { }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/PacketPool.cs b/OpenSim/Region/ClientStack/Linden/UDP/PacketPool.cs
index 2a3d14f..1fdc410 100644
--- a/OpenSim/Region/ClientStack/Linden/UDP/PacketPool.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/PacketPool.cs
@@ -41,25 +41,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         private static readonly PacketPool instance = new PacketPool();
 
-        private bool packetPoolEnabled = true;
-        private bool dataBlockPoolEnabled = true;
-
-        private PercentageStat m_packetsReusedStat = new PercentageStat(
-            "PacketsReused",
-            "Packets reused",
-            "clientstack",
-            "packetpool",
-            StatVerbosity.Debug,
-            "Number of packets reused out of all requests to the packet pool");
-
-        private PercentageStat m_blocksReusedStat = new PercentageStat(
-            "BlocksReused",
-            "Blocks reused",
-            "clientstack",
-            "packetpool",
-            StatVerbosity.Debug,
-            "Number of data blocks reused out of all requests to the packet pool");
-
         /// <summary>
         /// Pool of packets available for reuse.
         /// </summary>
@@ -72,22 +53,59 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             get { return instance; }
         }
 
-        public bool RecyclePackets
+        public bool RecyclePackets { get; set; }
+
+        public bool RecycleDataBlocks { get; set; }
+
+        /// <summary>
+        /// The number of packets pooled
+        /// </summary>
+        public int PacketsPooled
         {
-            set { packetPoolEnabled = value; }
-            get { return packetPoolEnabled; }
+            get 
+            {
+                lock (pool)
+                    return pool.Count;
+            }
         }
 
-        public bool RecycleDataBlocks
+        /// <summary>
+        /// The number of blocks pooled.
+        /// </summary>
+        public int BlocksPooled
         {
-            set { dataBlockPoolEnabled = value; }
-            get { return dataBlockPoolEnabled; }
+            get 
+            {
+                lock (DataBlocks) 
+                    return DataBlocks.Count;
+            }
         }
 
+        /// <summary>
+        /// Number of packets requested.
+        /// </summary>
+        public long PacketsRequested { get; private set; }
+
+        /// <summary>
+        /// Number of packets reused.
+        /// </summary>
+        public long PacketsReused { get; private set; }
+
+        /// <summary>
+        /// Number of packet blocks requested.
+        /// </summary>
+        public long BlocksRequested { get; private set; }
+
+        /// <summary>
+        /// Number of packet blocks reused.
+        /// </summary>
+        public long BlocksReused { get; private set; }
+
         private PacketPool()
         {
-            StatsManager.RegisterStat(m_packetsReusedStat);
-            StatsManager.RegisterStat(m_blocksReusedStat);
+            // defaults
+            RecyclePackets = true;
+            RecycleDataBlocks = true;
         }
 
         /// <summary>
@@ -97,11 +115,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <returns>Guaranteed to always return a packet, whether from the pool or newly constructed.</returns>
         public Packet GetPacket(PacketType type)
         {
-            m_packetsReusedStat.Consequent++;
+            PacketsRequested++;
 
             Packet packet;
 
-            if (!packetPoolEnabled)
+            if (!RecyclePackets)
                 return Packet.BuildPacket(type);
 
             lock (pool)
@@ -118,7 +136,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 //                    m_log.DebugFormat("[PACKETPOOL]: Pulling {0} packet", type);
 
                     // Recycle old packages
-                    m_packetsReusedStat.Antecedent++;
+                    PacketsReused++;
 
                     packet = pool[type].Pop();
                 }
@@ -187,7 +205,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <param name="packet"></param>
         public void ReturnPacket(Packet packet)
         {
-            if (dataBlockPoolEnabled)
+            if (RecycleDataBlocks)
             {
                 switch (packet.Type)
                 {
@@ -211,7 +229,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 }
             }
 
-            if (packetPoolEnabled)
+            if (RecyclePackets)
             {
                 switch (packet.Type)
                 {
@@ -249,7 +267,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         {
             lock (DataBlocks)
             {
-                m_blocksReusedStat.Consequent++;
+                BlocksRequested++;
 
                 Stack<Object> s;
 
@@ -257,7 +275,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 {
                     if (s.Count > 0)
                     {
-                        m_blocksReusedStat.Antecedent++;
+                        BlocksReused++;
                         return (T)s.Pop();
                     }
                 }
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/Properties/AssemblyInfo.cs b/OpenSim/Region/ClientStack/Linden/UDP/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..af2f6f8
--- /dev/null
+++ b/OpenSim/Region/ClientStack/Linden/UDP/Properties/AssemblyInfo.cs
@@ -0,0 +1,33 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("OpenSim.Region.ClientStack.LindenUDP")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("http://opensimulator.org")]
+[assembly: AssemblyProduct("OpenSim")]
+[assembly: AssemblyCopyright("OpenSimulator developers")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("9d3dbc6b-9d85-483b-af48-c1dfc261b7ac")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+[assembly: AssemblyVersion("0.7.5.*")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/Tests/LLImageManagerTests.cs b/OpenSim/Region/ClientStack/Linden/UDP/Tests/LLImageManagerTests.cs
index 5fcf376..7d9f581 100644
--- a/OpenSim/Region/ClientStack/Linden/UDP/Tests/LLImageManagerTests.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/Tests/LLImageManagerTests.cs
@@ -43,7 +43,7 @@ using OpenSim.Tests.Common.Mock;
 namespace OpenSim.Region.ClientStack.LindenUDP.Tests
 {
     [TestFixture]
-    public class LLImageManagerTests
+    public class LLImageManagerTests : OpenSimTestCase
     {
         private AssetBase m_testImageAsset;
         private Scene scene;
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/Tests/PacketHandlerTests.cs b/OpenSim/Region/ClientStack/Linden/UDP/Tests/PacketHandlerTests.cs
index 0f88ec6..5f73a94 100644
--- a/OpenSim/Region/ClientStack/Linden/UDP/Tests/PacketHandlerTests.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/Tests/PacketHandlerTests.cs
@@ -39,7 +39,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP.Tests
     /// Tests for the LL packet handler
     /// </summary>
     [TestFixture]
-    public class PacketHandlerTests
+    public class PacketHandlerTests : OpenSimTestCase
     {
 //        [Test]
 //        /// <summary>