8 files changed, 278 insertions, 143 deletions

diff --git a/OpenSim/Framework/ClientManager.cs b/OpenSim/Framework/ClientManager.cs
index 094a3ff..367bc6a 100644
--- a/OpenSim/Framework/ClientManager.cs
+++ b/OpenSim/Framework/ClientManager.cs
@@ -28,193 +28,183 @@
 using System;
 using System.Collections.Generic;
 using System.Reflection;
-using log4net;
+using System.Net;
+using BclExtras.Collections;
 using OpenMetaverse;
 using OpenMetaverse.Packets;
 
 namespace OpenSim.Framework
 {
-    public delegate void ForEachClientDelegate(IClientAPI client);
-
+    /// <summary>
+    /// Maps from client AgentID and RemoteEndPoint values to IClientAPI
+    /// references for all of the connected clients
+    /// </summary>
     public class ClientManager
     {
-        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
-
-        private Dictionary<uint, IClientAPI> m_clients;
+        #region IComparers
 
-        public ClientManager()
+        private sealed class UUIDComparer : IComparer<UUID>
         {
-            m_clients = new Dictionary<uint, IClientAPI>();
-        }
-
-        public void ForEachClient(ForEachClientDelegate whatToDo)
-        {
-            IClientAPI[] LocalClients;
-            lock (m_clients)
-            {
-                LocalClients = new IClientAPI[m_clients.Count];
-                m_clients.Values.CopyTo(LocalClients, 0);
-            }
-
-            for (int i = 0; i < LocalClients.Length; i++)
+            public int Compare(UUID x, UUID y)
             {
-                try
-                {
-                    whatToDo(LocalClients[i]);
-                }
-                catch (Exception e)
-                {
-                    m_log.Warn("[CLIENT]: Unable to do ForEachClient for one of the clients" + "\n Reason: " + e.ToString());
-                }
+                return x.CompareTo(y);
             }
         }
 
-        public void Remove(uint id)
+        private sealed class IPEndPointComparer : IComparer<IPEndPoint>
         {
-            lock (m_clients)
+            public int Compare(IPEndPoint x, IPEndPoint y)
             {
-                m_clients.Remove(id);
-            }
-        }
+                if (x == null && y == null)
+                    return 0;
+                else if (x == null)
+                    return -1;
+                else if (y == null)
+                    return 1;
 
-        public void Add(uint id, IClientAPI client)
-        {
-            lock (m_clients)
-            {
-                m_clients.Add(id, client);
+                int result = x.Address.Address.CompareTo(y.Address.Address);
+                if (result == 0) result = x.Port.CompareTo(y.Port);
+
+                return result;
             }
         }
 
+        #endregion IComparers
+
+        /// <summary>An immutable dictionary mapping from <seealso cref="UUID"/>
+        /// to <seealso cref="IClientAPI"/> references</summary>
+        private ImmutableMap<UUID, IClientAPI> m_dict;
+        /// <summary>An immutable dictionary mapping from <seealso cref="IPEndPoint"/>
+        /// to <seealso cref="IClientAPI"/> references</summary>
+        private ImmutableMap<IPEndPoint, IClientAPI> m_dict2;
+        /// <summary>Immutability grants thread safety for concurrent reads and
+        /// read-writes, but not concurrent writes</summary>
+        private object m_writeLock = new object();
+
+        /// <summary>Number of clients in the collection</summary>
+        public int Count { get { return m_dict.Count; } }
+
         /// <summary>
-        /// Pass incoming packet to client.
+        /// Default constructor
         /// </summary>
-        /// <param name="circuitCode">uint identifying the connection/client.</param>
-        /// <param name="packet">object containing the packet.</param>
-        public void InPacket(uint circuitCode, object packet)
+        public ClientManager()
         {
-            IClientAPI client;
-            bool tryGetRet = false;
-            
-            lock (m_clients)
-                tryGetRet = m_clients.TryGetValue(circuitCode, out client);
-            
-            if (tryGetRet)
-            {
-                client.InPacket(packet);
-            }
+            m_dict = new ImmutableMap<UUID, IClientAPI>(new UUIDComparer());
+            m_dict2 = new ImmutableMap<IPEndPoint, IClientAPI>(new IPEndPointComparer());
         }
 
-        public void CloseAllAgents(uint circuitCode)
-        {
-            IClientAPI client;
-            bool tryGetRet = false;
-            lock (m_clients)
-                tryGetRet = m_clients.TryGetValue(circuitCode, out client);
-            if (tryGetRet)
-            {
-                CloseAllCircuits(client.AgentId);
-            }
-        }
-
-        public void CloseAllCircuits(UUID agentId)
+        /// <summary>
+        /// Add a client reference to the collection if it does not already
+        /// exist
+        /// </summary>
+        /// <param name="value">Reference to the client object</param>
+        /// <returns>True if the client reference was successfully added,
+        /// otherwise false if the given key already existed in the collection</returns>
+        public bool Add(IClientAPI value)
         {
-            uint[] circuits = GetAllCircuits(agentId);
-            // We're using a for loop here so changes to the circuits don't cause it to completely fail.
-
-            for (int i = 0; i < circuits.Length; i++)
+            lock (m_writeLock)
             {
-                IClientAPI client;
-                try
+                if (!m_dict.ContainsKey(value.AgentId) && !m_dict2.ContainsKey(value.RemoteEndPoint))
                 {
-                    bool tryGetRet = false;
-                    lock (m_clients)
-                        tryGetRet = m_clients.TryGetValue(circuits[i], out client);
-                    if (tryGetRet)
-                    {
-                        Remove(client.CircuitCode);
-                        client.Close(false);
-                    }
+                    m_dict = m_dict.Add(value.AgentId, value);
+                    m_dict2 = m_dict2.Add(value.RemoteEndPoint, value);
+
+                    return true;
                 }
-                catch (Exception e)
+                else
                 {
-                    m_log.Error(string.Format("[CLIENT]: Unable to shutdown circuit for: {0}\n Reason: {1}", agentId, e));
+                    return false;
                 }
             }
         }
 
-        // [Obsolete("Using Obsolete to drive development is invalid.  Obsolete presumes that something new has already been created to replace this.")]
-        public uint[] GetAllCircuits(UUID agentId)
+        /// <summary>
+        /// Remove a client from the collection
+        /// </summary>
+        /// <param name="key">UUID of the client to remove</param>
+        /// <returns>True if a client was removed, or false if the given UUID
+        /// was not present in the collection</returns>
+        public bool Remove(UUID key)
         {
-            List<uint> circuits = new List<uint>();
-            // Wasteful, I know
-            IClientAPI[] LocalClients = new IClientAPI[0];
-            lock (m_clients)
+            lock (m_writeLock)
             {
-                LocalClients = new IClientAPI[m_clients.Count];
-                m_clients.Values.CopyTo(LocalClients, 0);
-            }
+                IClientAPI client;
 
-            for (int i = 0; i < LocalClients.Length; i++)
-            {
-                if (LocalClients[i].AgentId == agentId)
+                if (m_dict.TryGetValue(key, out client))
                 {
-                    circuits.Add(LocalClients[i].CircuitCode);
+                    m_dict = m_dict.Delete(key);
+                    m_dict2 = m_dict2.Delete(client.RemoteEndPoint);
+                    return true;
+                }
+                else
+                {
+                    return false;
                 }
             }
-            return circuits.ToArray();
         }
 
-        public List<uint> GetAllCircuitCodes()
+        /// <summary>
+        /// Resets the client collection
+        /// </summary>
+        public void Clear()
         {
-            List<uint> circuits;
-
-            lock (m_clients)
+            lock (m_writeLock)
             {
-                circuits = new List<uint>(m_clients.Keys);
+                m_dict = new ImmutableMap<UUID, IClientAPI>(new UUIDComparer());
+                m_dict2 = new ImmutableMap<IPEndPoint, IClientAPI>(new IPEndPointComparer());
             }
+        }
 
-            return circuits;
+        /// <summary>
+        /// Checks if a UUID is in the collection
+        /// </summary>
+        /// <param name="key">UUID to check for</param>
+        /// <returns>True if the UUID was found in the collection, otherwise false</returns>
+        public bool ContainsKey(UUID key)
+        {
+            return m_dict.ContainsKey(key);
         }
 
-        public void ViewerEffectHandler(IClientAPI sender, List<ViewerEffectEventHandlerArg> args)
+        /// <summary>
+        /// Checks if an endpoint is in the collection
+        /// </summary>
+        /// <param name="key">Endpoint to check for</param>
+        /// <returns>True if the endpoint was found in the collection, otherwise false</returns>
+        public bool ContainsKey(IPEndPoint key)
         {
-            // TODO: don't create new blocks if recycling an old packet
-            List<ViewerEffectPacket.EffectBlock> effectBlock = new List<ViewerEffectPacket.EffectBlock>();
-            for (int i = 0; i < args.Count; i++)
-            {
-                ViewerEffectPacket.EffectBlock effect = new ViewerEffectPacket.EffectBlock();
-                effect.AgentID = args[i].AgentID;
-                effect.Color = args[i].Color;
-                effect.Duration = args[i].Duration;
-                effect.ID = args[i].ID;
-                effect.Type = args[i].Type;
-                effect.TypeData = args[i].TypeData;
-                effectBlock.Add(effect);
-            }
-            ViewerEffectPacket.EffectBlock[] effectBlockArray = effectBlock.ToArray();
+            return m_dict2.ContainsKey(key);
+        }
 
-            IClientAPI[] LocalClients;
-            lock (m_clients)
-            {
-                LocalClients = new IClientAPI[m_clients.Count];
-                m_clients.Values.CopyTo(LocalClients, 0);
-            }
+        /// <summary>
+        /// Attempts to fetch a value out of the collection
+        /// </summary>
+        /// <param name="key">UUID of the client to retrieve</param>
+        /// <param name="value">Retrieved client, or null on lookup failure</param>
+        /// <returns>True if the lookup succeeded, otherwise false</returns>
+        public bool TryGetValue(UUID key, out IClientAPI value)
+        {
+            return m_dict.TryGetValue(key, out value);
+        }
 
-            for (int i = 0; i < LocalClients.Length; i++)
-            {
-                if (LocalClients[i].AgentId != sender.AgentId)
-                {
-                    LocalClients[i].SendViewerEffect(effectBlockArray);
-                }
-            }
+        /// <summary>
+        /// Attempts to fetch a value out of the collection
+        /// </summary>
+        /// <param name="key">Endpoint of the client to retrieve</param>
+        /// <param name="value">Retrieved client, or null on lookup failure</param>
+        /// <returns>True if the lookup succeeded, otherwise false</returns>
+        public bool TryGetValue(IPEndPoint key, out IClientAPI value)
+        {
+            return m_dict2.TryGetValue(key, out value);
         }
 
-        public bool TryGetClient(uint circuitId, out IClientAPI user)
+        /// <summary>
+        /// Performs a given task in parallel for each of the elements in the
+        /// collection
+        /// </summary>
+        /// <param name="action">Action to perform on each element</param>
+        public void ForEach(Action<IClientAPI> action)
         {
-            lock (m_clients)
-            {
-                return m_clients.TryGetValue(circuitId, out user);
-            }
+            Parallel.ForEach<IClientAPI>(m_dict.Values, action);
         }
     }
 }
diff --git a/OpenSim/Framework/Communications/GenericAsyncResult.cs b/OpenSim/Framework/Communications/GenericAsyncResult.cs
index efd2f43..8e3f62b 100644
--- a/OpenSim/Framework/Communications/GenericAsyncResult.cs
+++ b/OpenSim/Framework/Communications/GenericAsyncResult.cs
@@ -146,6 +146,7 @@ namespace OpenSim.Framework.Communications
                 // If the operation isn't done, wait for it
                 AsyncWaitHandle.WaitOne();
                 AsyncWaitHandle.Close();
+                m_waitHandle.Close();
                 m_waitHandle = null; // Allow early GC
             }
 
diff --git a/OpenSim/Framework/Communications/RestClient.cs b/OpenSim/Framework/Communications/RestClient.cs
index d98f47d..a74169e 100644
--- a/OpenSim/Framework/Communications/RestClient.cs
+++ b/OpenSim/Framework/Communications/RestClient.cs
@@ -105,7 +105,7 @@ namespace OpenSim.Framework.Communications
         /// <summary>
         /// This flag will help block the main synchroneous method, in case we run in synchroneous mode
         /// </summary>
-        public static ManualResetEvent _allDone = new ManualResetEvent(false);
+        //public static ManualResetEvent _allDone = new ManualResetEvent(false);
 
         /// <summary>
         /// Default time out period
@@ -282,12 +282,12 @@ namespace OpenSim.Framework.Communications
                 else
                 {
                     s.Close();
-                    _allDone.Set();
+                    //_allDone.Set();
                 }
             }
             catch (Exception e)
             {
-                _allDone.Set();
+                //_allDone.Set();
                 _asyncException = e;
             }
         }
diff --git a/OpenSim/Framework/IClientAPI.cs b/OpenSim/Framework/IClientAPI.cs
index d3bd9e7..29846f5 100644
--- a/OpenSim/Framework/IClientAPI.cs
+++ b/OpenSim/Framework/IClientAPI.cs
@@ -561,6 +561,8 @@ namespace OpenSim.Framework
         // [Obsolete("LLClientView Specific - Circuits are unique to LLClientView")]
         uint CircuitCode { get; }
 
+        IPEndPoint RemoteEndPoint { get; }
+
         event GenericMessage OnGenericMessage;
 
         // [Obsolete("LLClientView Specific - Replace with more bare-bones arguments.")]
@@ -802,7 +804,7 @@ namespace OpenSim.Framework
 
         void InPacket(object NewPack);
         void ProcessInPacket(Packet NewPack);
-        void Close(bool ShutdownCircuit);
+        void Close();
         void Kick(string message);
         
         /// <summary>
diff --git a/OpenSim/Framework/IScene.cs b/OpenSim/Framework/IScene.cs
index 489653f..f34027d 100644
--- a/OpenSim/Framework/IScene.cs
+++ b/OpenSim/Framework/IScene.cs
@@ -71,7 +71,6 @@ namespace OpenSim.Framework
 
         void AddNewClient(IClientAPI client);
         void RemoveClient(UUID agentID);
-        void CloseAllAgents(uint circuitcode);
 
         void Restart(int seconds);
         //RegionInfo OtherRegionUp(RegionInfo thisRegion);
diff --git a/OpenSim/Framework/LocklessQueue.cs b/OpenSim/Framework/LocklessQueue.cs
new file mode 100644
index 0000000..dd3d201
--- /dev/null
+++ b/OpenSim/Framework/LocklessQueue.cs
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 2009, openmetaverse.org
+ * All rights reserved.
+ *
+ * - Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ * - Neither the name of the openmetaverse.org nor the names
+ *   of its contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Threading;
+
+namespace OpenSim.Framework
+{
+    public sealed class LocklessQueue<T>
+    {
+        private sealed class SingleLinkNode
+        {
+            public SingleLinkNode Next;
+            public T Item;
+        }
+
+        SingleLinkNode head;
+        SingleLinkNode tail;
+        int count;
+
+        public int Count { get { return count; } }
+
+        public LocklessQueue()
+        {
+            Init();
+        }
+
+        public void Enqueue(T item)
+        {
+            SingleLinkNode oldTail = null;
+            SingleLinkNode oldTailNext;
+
+            SingleLinkNode newNode = new SingleLinkNode();
+            newNode.Item = item;
+
+            bool newNodeWasAdded = false;
+
+            while (!newNodeWasAdded)
+            {
+                oldTail = tail;
+                oldTailNext = oldTail.Next;
+
+                if (tail == oldTail)
+                {
+                    if (oldTailNext == null)
+                        newNodeWasAdded = CAS(ref tail.Next, null, newNode);
+                    else
+                        CAS(ref tail, oldTail, oldTailNext);
+                }
+            }
+
+            CAS(ref tail, oldTail, newNode);
+            Interlocked.Increment(ref count);
+        }
+
+        public bool Dequeue(out T item)
+        {
+            item = default(T);
+            SingleLinkNode oldHead = null;
+            bool haveAdvancedHead = false;
+
+            while (!haveAdvancedHead)
+            {
+                oldHead = head;
+                SingleLinkNode oldTail = tail;
+                SingleLinkNode oldHeadNext = oldHead.Next;
+
+                if (oldHead == head)
+                {
+                    if (oldHead == oldTail)
+                    {
+                        if (oldHeadNext == null)
+                            return false;
+
+                        CAS(ref tail, oldTail, oldHeadNext);
+                    }
+                    else
+                    {
+                        item = oldHeadNext.Item;
+                        haveAdvancedHead = CAS(ref head, oldHead, oldHeadNext);
+                    }
+                }
+            }
+
+            Interlocked.Decrement(ref count);
+            return true;
+        }
+
+        public void Clear()
+        {
+            Init();
+        }
+
+        private void Init()
+        {
+            count = 0;
+            head = tail = new SingleLinkNode();
+        }
+
+        private static bool CAS(ref SingleLinkNode location, SingleLinkNode comparand, SingleLinkNode newValue)
+        {
+            return
+                (object)comparand ==
+                (object)Interlocked.CompareExchange<SingleLinkNode>(ref location, newValue, comparand);
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Framework/Parallel.cs b/OpenSim/Framework/Parallel.cs
index 74537ba..6efdad0 100644
--- a/OpenSim/Framework/Parallel.cs
+++ b/OpenSim/Framework/Parallel.cs
@@ -89,6 +89,7 @@ namespace OpenSim.Framework
             }
 
             threadFinishEvent.WaitOne();
+            threadFinishEvent.Close();
 
             if (exception != null)
                 throw new Exception(exception.Message, exception);
@@ -148,6 +149,7 @@ namespace OpenSim.Framework
             }
 
             threadFinishEvent.WaitOne();
+            threadFinishEvent.Close();
 
             if (exception != null)
                 throw new Exception(exception.Message, exception);
@@ -199,6 +201,7 @@ namespace OpenSim.Framework
             }
 
             threadFinishEvent.WaitOne();
+            threadFinishEvent.Close();
 
             if (exception != null)
                 throw new Exception(exception.Message, exception);
diff --git a/OpenSim/Framework/ThrottleOutPacketType.cs b/OpenSim/Framework/ThrottleOutPacketType.cs
index fd490a5..eb42fea 100644
--- a/OpenSim/Framework/ThrottleOutPacketType.cs
+++ b/OpenSim/Framework/ThrottleOutPacketType.cs
@@ -31,13 +31,23 @@ namespace OpenSim.Framework
 {
     public enum ThrottleOutPacketType : int
     {
-        Unknown = -1, // Also doubles as 'do not throttle'
+        /// <summary>Unthrottled packets</summary>
+        Unknown = -1,
+        /// <summary>Packets that are being resent</summary>
         Resend = 0,
+        /// <summary>Terrain data</summary>
         Land = 1,
+        /// <summary>Wind data</summary>
         Wind = 2,
+        /// <summary>Cloud data</summary>
         Cloud = 3,
-        Task = 4,
-        Texture = 5,
-        Asset = 6,
+        /// <summary>Texture assets</summary>
+        Texture = 4,
+        /// <summary>Non-texture assets</summary>
+        Asset = 5,
+        /// <summary>Avatar and primitive data</summary>
+        State = 6,
+        /// <summary>Any packets that do not fit into the other throttles</summary>
+        Task = 7,
     }
 }