Add OnQueueEmpty event to the packet layers. No user functinality yet

3 files changed, 66 insertions, 2 deletions

diff --git a/OpenSim/Region/ClientStack/LindenUDP/ILLPacketHandler.cs b/OpenSim/Region/ClientStack/LindenUDP/ILLPacketHandler.cs
index 09edc94..5658dba 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/ILLPacketHandler.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/ILLPacketHandler.cs
@@ -31,9 +31,10 @@ using OpenMetaverse.Packets;
 using OpenSim.Framework;
 
 namespace OpenSim.Region.ClientStack.LindenUDP
-{        
+{
     public delegate void PacketStats(int inPackets, int outPackets, int unAckedBytes);
     public delegate void PacketDrop(Packet pack, Object id);
+    public delegate void QueueEmpty(ThrottleOutPacketType queue);
     public delegate bool SynchronizeClientHandler(IScene scene, Packet packet, UUID agentID, ThrottleOutPacketType throttlePacketType);
 
     /// <summary>
@@ -44,6 +45,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
     {
         event PacketStats OnPacketStats;
         event PacketDrop OnPacketDrop;
+        event QueueEmpty OnQueueEmpty;
         SynchronizeClientHandler SynchronizeClient { set; }
 
         int PacketsReceived { get; }
@@ -61,7 +63,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// <summary>
         /// Take action depending on the type and contents of an received packet.
         /// </summary>
-        /// <param name="item"></param>        
+        /// <param name="item"></param>
         void ProcessInPacket(LLQueItem item);
         
         void ProcessOutPacket(LLQueItem item);
diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLPacketHandler.cs b/OpenSim/Region/ClientStack/LindenUDP/LLPacketHandler.cs
index 67ece75..801e0c5 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLPacketHandler.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/LLPacketHandler.cs
@@ -129,6 +129,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         //
         public event PacketStats OnPacketStats;
         public event PacketDrop OnPacketDrop;
+        public event QueueEmpty OnQueueEmpty;
 
         
         //private SynchronizeClientHandler m_SynchronizeClient = null;
@@ -172,6 +173,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             m_PacketQueue = new LLPacketQueue(client.AgentId, userSettings);
 
+            m_PacketQueue.OnQueueEmpty += TriggerOnQueueEmpty;
+
             m_AckTimer.Elapsed += AckTimerElapsed;
             m_AckTimer.Start();
         }
@@ -769,6 +772,16 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             handlerPacketDrop(packet, id);
         }
 
+        private void TriggerOnQueueEmpty(ThrottleOutPacketType queue)
+        {
+            QueueEmpty handlerQueueEmpty = OnQueueEmpty;
+
+            if (handlerQueueEmpty == null)
+                return;
+
+            handlerQueueEmpty(queue);
+        }
+
         // Convert the packet to bytes and stuff it onto the send queue
         //
         public void ProcessOutPacket(LLQueItem item)
diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLPacketQueue.cs b/OpenSim/Region/ClientStack/LindenUDP/LLPacketQueue.cs
index 6dd0697..f08f1b6 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLPacketQueue.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/LLPacketQueue.cs
@@ -105,6 +105,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         private UUID m_agentId;
 
+        public event QueueEmpty OnQueueEmpty;
+
         public LLPacketQueue(UUID agentId, ClientStackUserSettings userSettings)
         {
             // While working on this, the BlockingQueue had me fooled for a bit.
@@ -293,30 +295,42 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     if (LandOutgoingPacketQueue.Count > 0)
                     {
                         SendQueue.Enqueue(LandOutgoingPacketQueue.Dequeue());
+                        TriggerOnQueueEmpty(ThrottleOutPacketType.Land);
                     }
                     if (WindOutgoingPacketQueue.Count > 0)
                     {
                         SendQueue.Enqueue(WindOutgoingPacketQueue.Dequeue());
+                        TriggerOnQueueEmpty(ThrottleOutPacketType.Wind);
                     }
                     if (CloudOutgoingPacketQueue.Count > 0)
                     {
                         SendQueue.Enqueue(CloudOutgoingPacketQueue.Dequeue());
+                        TriggerOnQueueEmpty(ThrottleOutPacketType.Cloud);
                     }
+                    bool tasksSent = false;
                     if (TaskOutgoingPacketQueue.Count > 0)
                     {
+                        tasksSent = true;
                         SendQueue.PriorityEnqueue(TaskOutgoingPacketQueue.Dequeue());
                     }
                     if (TaskLowpriorityPacketQueue.Count > 0)
                     {
+                        tasksSent = true;
                         SendQueue.Enqueue(TaskLowpriorityPacketQueue.Dequeue());
                     }
+                    if (tasksSent)
+                    {
+                        TriggerOnQueueEmpty(ThrottleOutPacketType.Task);
+                    }
                     if (TextureOutgoingPacketQueue.Count > 0)
                     {
                         SendQueue.Enqueue(TextureOutgoingPacketQueue.Dequeue());
+                        TriggerOnQueueEmpty(ThrottleOutPacketType.Texture);
                     }
                     if (AssetOutgoingPacketQueue.Count > 0)
                     {
                         SendQueue.Enqueue(AssetOutgoingPacketQueue.Dequeue());
+                        TriggerOnQueueEmpty(ThrottleOutPacketType.Asset);
                     }
                 }
                 // m_log.Info("[THROTTLE]: Processed " + throttleLoops + " packets");
@@ -405,6 +419,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 bool qchanged = true;
                 
                 ResetCounters();
+
+                List<ThrottleOutPacketType> Empty = new List<ThrottleOutPacketType>();
                 // m_log.Info("[THROTTLE]: Entering Throttle");
                 while (TotalThrottle.UnderLimit() && qchanged && throttleLoops <= MaxThrottleLoops)
                 {
@@ -431,6 +447,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         TotalThrottle.AddBytes(qpack.Length);
                         LandThrottle.AddBytes(qpack.Length);
                         qchanged = true;
+
+                        if (LandOutgoingPacketQueue.Count == 0)
+                            Empty.Add(ThrottleOutPacketType.Land);
                     }
                     
                     if ((WindOutgoingPacketQueue.Count > 0) && WindThrottle.UnderLimit())
@@ -441,6 +460,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         TotalThrottle.AddBytes(qpack.Length);
                         WindThrottle.AddBytes(qpack.Length);
                         qchanged = true;
+
+                        if (WindOutgoingPacketQueue.Count == 0)
+                            Empty.Add(ThrottleOutPacketType.Wind);
                     }
                     
                     if ((CloudOutgoingPacketQueue.Count > 0) && CloudThrottle.UnderLimit())
@@ -451,6 +473,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         TotalThrottle.AddBytes(qpack.Length);
                         CloudThrottle.AddBytes(qpack.Length);
                         qchanged = true;
+
+                        if (CloudOutgoingPacketQueue.Count == 0)
+                            Empty.Add(ThrottleOutPacketType.Cloud);
                     }
                     
                     if ((TaskOutgoingPacketQueue.Count > 0 || TaskLowpriorityPacketQueue.Count > 0) && TaskThrottle.UnderLimit())
@@ -470,6 +495,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         TotalThrottle.AddBytes(qpack.Length);
                         TaskThrottle.AddBytes(qpack.Length);
                         qchanged = true;
+
+                        if (TaskOutgoingPacketQueue.Count == 0 && TaskLowpriorityPacketQueue.Count == 0)
+                            Empty.Add(ThrottleOutPacketType.Task);
                     }
                     
                     if ((TextureOutgoingPacketQueue.Count > 0) && TextureThrottle.UnderLimit())
@@ -480,6 +508,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         TotalThrottle.AddBytes(qpack.Length);
                         TextureThrottle.AddBytes(qpack.Length);
                         qchanged = true;
+
+                        if (TextureOutgoingPacketQueue.Count == 0)
+                            Empty.Add(ThrottleOutPacketType.Texture);
                     }
                     
                     if ((AssetOutgoingPacketQueue.Count > 0) && AssetThrottle.UnderLimit())
@@ -490,12 +521,30 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                         TotalThrottle.AddBytes(qpack.Length);
                         AssetThrottle.AddBytes(qpack.Length);
                         qchanged = true;
+
+                        if (AssetOutgoingPacketQueue.Count == 0)
+                            Empty.Add(ThrottleOutPacketType.Asset);
                     }
                 }
                 // m_log.Info("[THROTTLE]: Processed " + throttleLoops + " packets");
+
+                foreach (ThrottleOutPacketType t in Empty)
+                {
+                    TriggerOnQueueEmpty(t);
+                }
             }
         }
 
+        private void TriggerOnQueueEmpty(ThrottleOutPacketType queue)
+        {
+            QueueEmpty handlerQueueEmpty = OnQueueEmpty;
+
+            if (handlerQueueEmpty == null)
+                return;
+
+            handlerQueueEmpty(queue);
+        }
+
         private void ThrottleTimerElapsed(object sender, ElapsedEventArgs e)
         {
             // just to change the signature, and that ProcessThrottle