Move SoubleQueu to Util. Change HTTP inv to prioritize COF. Determine COF for SP

OpenSim/Capabilities/Handlers/WebFetchInventoryDescendents/WebFetchInvDescHandler.cs

@@ -435,4 +435,4 @@ namespace OpenSim.Capabilities.Handlers
             return llsdItem;
         }
     }
-}
+}

OpenSim/Framework/Util.cs

@@ -2097,4 +2097,112 @@ namespace OpenSim.Framework
         }
         #endregion
     }
+
+    public class DoubleQueue<T> where T:class
+    {
+        private Queue<T> m_lowQueue = new Queue<T>();
+        private Queue<T> m_highQueue = new Queue<T>();
+
+        private object m_syncRoot = new object();
+        private Semaphore m_s = new Semaphore(0, 1);
+
+        public DoubleQueue()
+        {
+        }
+
+        public virtual int Count
+        {
+            get { return m_highQueue.Count + m_lowQueue.Count; }
+        }
+
+        public virtual void Enqueue(T data)
+        {
+            Enqueue(m_lowQueue, data);
+        }
+
+        public virtual void EnqueueLow(T data)
+        {
+            Enqueue(m_lowQueue, data);
+        }
+
+        public virtual void EnqueueHigh(T data)
+        {
+            Enqueue(m_highQueue, data);
+        }
+
+        private void Enqueue(Queue<T> q, T data)
+        {
+            lock (m_syncRoot)
+            {
+                m_lowQueue.Enqueue(data);
+                m_s.WaitOne(0);
+                m_s.Release();
+            }
+        }
+
+        public virtual T Dequeue()
+        {
+            return Dequeue(Timeout.Infinite);
+        }
+
+        public virtual T Dequeue(int tmo)
+        {
+            return Dequeue(TimeSpan.FromMilliseconds(tmo));
+        }
+
+        public virtual T Dequeue(TimeSpan wait)
+        {
+            T res = null;
+
+            if (!Dequeue(wait, ref res))
+                return null;
+
+            return res;
+        }
+
+        public bool Dequeue(int timeout, ref T res)
+        {
+            return Dequeue(TimeSpan.FromMilliseconds(timeout), ref res);
+        }
+
+        public bool Dequeue(TimeSpan wait, ref T res)
+        {
+            if (!m_s.WaitOne(wait))
+                return false;
+
+            lock (m_syncRoot)
+            {
+                if (m_highQueue.Count > 0)
+                    res = m_highQueue.Dequeue();
+                else
+                    res = m_lowQueue.Dequeue();
+
+                if (m_highQueue.Count == 0 && m_lowQueue.Count == 0)
+                    return true;
+
+                try
+                {
+                    m_s.Release();
+                }
+                catch
+                {
+                }
+
+                return true;
+            }
+        }
+
+        public virtual void Clear()
+        {
+
+            lock (m_syncRoot)
+            {
+                // Make sure sem count is 0
+                m_s.WaitOne(0);
+
+                m_lowQueue.Clear();
+                m_highQueue.Clear();
+            }
+        }
+    }
 }

OpenSim/Region/ClientStack/Linden/Caps/WebFetchInvDescModule.cs

@@ -39,10 +39,13 @@ using OpenSim.Framework.Servers;
 using OpenSim.Framework.Servers.HttpServer;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
+using OpenSim.Framework.Capabilities;
 using OpenSim.Services.Interfaces;
 using Caps = OpenSim.Framework.Capabilities.Caps;
 using OpenSim.Capabilities.Handlers;
 using OpenSim.Framework.Monitoring;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
 
 namespace OpenSim.Region.ClientStack.Linden
 {
@@ -52,11 +55,13 @@ namespace OpenSim.Region.ClientStack.Linden
     [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "WebFetchInvDescModule")]
     public class WebFetchInvDescModule : INonSharedRegionModule
     {
-        struct aPollRequest
+        class aPollRequest
         {
             public PollServiceInventoryEventArgs thepoll;
             public UUID reqID;
             public Hashtable request;
+            public ScenePresence presence;
+            public List<UUID> folders;
         }
 
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
@@ -71,8 +76,8 @@ namespace OpenSim.Region.ClientStack.Linden
         private Dictionary<UUID, string> m_capsDict = new Dictionary<UUID, string>();
         private static Thread[] m_workerThreads = null;
 
-        private static OpenMetaverse.BlockingQueue<aPollRequest> m_queue =
+        private static DoubleQueue<aPollRequest> m_queue =
-                new OpenMetaverse.BlockingQueue<aPollRequest>();
+                new DoubleQueue<aPollRequest>();
 
         #region ISharedRegionModule Members
 
@@ -143,12 +148,18 @@ namespace OpenSim.Region.ClientStack.Linden
 
         private class PollServiceInventoryEventArgs : PollServiceEventArgs
         {
+            private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
             private Dictionary<UUID, Hashtable> responses =
                     new Dictionary<UUID, Hashtable>();
 
-            public PollServiceInventoryEventArgs(UUID pId) :
+            private Scene m_scene;
+
+            public PollServiceInventoryEventArgs(Scene scene, UUID pId) :
                     base(null, null, null, null, pId, int.MaxValue)
             {
+                m_scene = scene;
+
                 HasEvents = (x, y) => { lock (responses) return responses.ContainsKey(x); };
                 GetEvents = (x, y) =>
                 {
@@ -167,12 +178,64 @@ namespace OpenSim.Region.ClientStack.Linden
 
                 Request = (x, y) =>
                 {
+                    ScenePresence sp = m_scene.GetScenePresence(Id);
+                    if (sp == null)
+                    {
+                        m_log.ErrorFormat("[INVENTORY]: Unable to find ScenePresence for {0}", Id);
+                        return;
+                    }
+
                     aPollRequest reqinfo = new aPollRequest();
                     reqinfo.thepoll = this;
                     reqinfo.reqID = x;
                     reqinfo.request = y;
+                    reqinfo.presence = sp;
+                    reqinfo.folders = new List<UUID>();
 
-                    m_queue.Enqueue(reqinfo);
+                    // Decode the request here
+                    string request = y["body"].ToString();
+
+                    request = request.Replace("<string>00000000-0000-0000-0000-000000000000</string>", "<uuid>00000000-0000-0000-0000-000000000000</uuid>");
+
+                    request = request.Replace("<key>fetch_folders</key><integer>0</integer>", "<key>fetch_folders</key><boolean>0</boolean>");
+                    request = request.Replace("<key>fetch_folders</key><integer>1</integer>", "<key>fetch_folders</key><boolean>1</boolean>");
+
+                    Hashtable hash = new Hashtable();
+                    try
+                    {
+                        hash = (Hashtable)LLSD.LLSDDeserialize(Utils.StringToBytes(request));
+                    }
+                    catch (LLSD.LLSDParseException e)
+                    {
+                        m_log.ErrorFormat("[INVENTORY]: Fetch error: {0}{1}" + e.Message, e.StackTrace);
+                        m_log.Error("Request: " + request);
+                        return;
+                    }
+
+                    ArrayList foldersrequested = (ArrayList)hash["folders"];
+
+                    bool highPriority = false;
+
+                    for (int i = 0; i < foldersrequested.Count; i++)
+                    {
+                        Hashtable inventoryhash = (Hashtable)foldersrequested[i];
+                        string folder = inventoryhash["folder_id"].ToString();
+                        UUID folderID;
+                        if (UUID.TryParse(folder, out folderID))
+                        {
+                            if (!reqinfo.folders.Contains(folderID))
+                            {
+                                if (sp.COF != UUID.Zero && sp.COF == folderID)
+                                    highPriority = true;
+                                reqinfo.folders.Add(folderID);
+                            }
+                        }
+                    }
+
+                    if (highPriority)
+                        m_queue.EnqueueHigh(reqinfo);
+                    else
+                        m_queue.EnqueueLow(reqinfo);
                 };
 
                 NoEvents = (x, y) =>
@@ -208,7 +271,7 @@ namespace OpenSim.Region.ClientStack.Linden
                 response["reusecontext"] = false;
 
                 response["str_response_string"] = m_webFetchHandler.FetchInventoryDescendentsRequest(
-                    requestinfo.request["body"].ToString(), String.Empty, String.Empty, null, null);
+                        requestinfo.request["body"].ToString(), String.Empty, String.Empty, null, null);
 
                 lock (responses)
                     responses[requestID] = response; 
@@ -220,7 +283,7 @@ namespace OpenSim.Region.ClientStack.Linden
             string capUrl = "/CAPS/" + UUID.Random() + "/";
 
             // Register this as a poll service          
-            PollServiceInventoryEventArgs args = new PollServiceInventoryEventArgs(agentID);
+            PollServiceInventoryEventArgs args = new PollServiceInventoryEventArgs(m_scene, agentID);
             
             args.Type = PollServiceEventArgs.EventType.Inventory;
             MainServer.Instance.AddPollServiceHTTPHandler(capUrl, args);

OpenSim/Region/ClientStack/Linden/UDP/LLUDPServer.cs

@@ -1903,112 +1903,4 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
         }
     }
-
-    internal class DoubleQueue<T> where T:class
-    {
-        private Queue<T> m_lowQueue = new Queue<T>();
-        private Queue<T> m_highQueue = new Queue<T>();
-
-        private object m_syncRoot = new object();
-        private Semaphore m_s = new Semaphore(0, 1);
-
-        public DoubleQueue()
-        {
-        }
-
-        public virtual int Count
-        {
-            get { return m_highQueue.Count + m_lowQueue.Count; }
-        }
-
-        public virtual void Enqueue(T data)
-        {
-            Enqueue(m_lowQueue, data);
-        }
-
-        public virtual void EnqueueLow(T data)
-        {
-            Enqueue(m_lowQueue, data);
-        }
-
-        public virtual void EnqueueHigh(T data)
-        {
-            Enqueue(m_highQueue, data);
-        }
-
-        private void Enqueue(Queue<T> q, T data)
-        {
-            lock (m_syncRoot)
-            {
-                m_lowQueue.Enqueue(data);
-                m_s.WaitOne(0);
-                m_s.Release();
-            }
-        }
-
-        public virtual T Dequeue()
-        {
-            return Dequeue(Timeout.Infinite);
-        }
-
-        public virtual T Dequeue(int tmo)
-        {
-            return Dequeue(TimeSpan.FromMilliseconds(tmo));
-        }
-
-        public virtual T Dequeue(TimeSpan wait)
-        {
-            T res = null;
-
-            if (!Dequeue(wait, ref res))
-                return null;
-
-            return res;
-        }
-
-        public bool Dequeue(int timeout, ref T res)
-        {
-            return Dequeue(TimeSpan.FromMilliseconds(timeout), ref res);
-        }
-
-        public bool Dequeue(TimeSpan wait, ref T res)
-        {
-            if (!m_s.WaitOne(wait))
-                return false;
-            
-            lock (m_syncRoot)
-            {
-                if (m_highQueue.Count > 0)
-                    res = m_highQueue.Dequeue();
-                else
-                    res = m_lowQueue.Dequeue();
-
-                if (m_highQueue.Count == 0 && m_lowQueue.Count == 0)
-                    return true;
-
-                try
-                {
-                    m_s.Release();
-                }
-                catch
-                {
-                }
-
-                return true;
-            }
-        }
-
-        public virtual void Clear()
-        {
-
-            lock (m_syncRoot)
-            {
-                // Make sure sem count is 0
-                m_s.WaitOne(0);
-
-                m_lowQueue.Clear();
-                m_highQueue.Clear();
-            }
-        }
-    }
 }

OpenSim/Region/Framework/Scenes/Scene.cs

@@ -2970,6 +2970,13 @@ namespace OpenSim.Region.Framework.Scenes
                     SubscribeToClientEvents(client);
     
                     sp = m_sceneGraph.CreateAndAddChildScenePresence(client, aCircuit.Appearance, type);
+                    InventoryFolderBase cof = InventoryService.GetFolderForType(client.AgentId, (AssetType)46);
+                    if (cof == null)
+                        sp.COF = UUID.Zero;
+                    else
+                        sp.COF = cof.ID;
+
+                    m_log.DebugFormat("[SCENE]: COF for {0} is {1}", client.AgentId, sp.COF);
                     m_eventManager.TriggerOnNewPresence(sp);
     
                     sp.TeleportFlags = (TPFlags)aCircuit.teleportFlags;

OpenSim/Region/Framework/Scenes/ScenePresence.cs

@@ -443,6 +443,8 @@ namespace OpenSim.Region.Framework.Scenes
             get { return (IClientCore)ControllingClient; }
         }
 
+        public UUID COF { get; set; }
+
 //        public Vector3 ParentPosition { get; set; }
 
         /// <summary>

prebuild.xml

@@ -1597,9 +1597,10 @@
       <Reference name="System.Drawing"/>
       <Reference name="System.Xml"/>
       <Reference name="System.Web"/>
+      <Reference name="OpenMetaverse" path="../../../../../bin/"/>
       <Reference name="OpenMetaverseTypes" path="../../../../../bin/"/>
       <Reference name="OpenMetaverse.StructuredData" path="../../../../../bin/"/>
-      <Reference name="OpenMetaverse" path="../../../../../bin/"/>
+
       <Reference name="OpenSim.Region.Framework"/>
       <Reference name="OpenSim.Capabilities"/>
       <Reference name="OpenSim.Capabilities.Handlers"/>