1 files changed, 88 insertions, 57 deletions

diff --git a/OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs b/OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs
index d83daab..44f7045 100644
--- a/OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs
+++ b/OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs
@@ -47,19 +47,18 @@ namespace OpenSim.Framework.Servers.HttpServer
         private readonly BaseHttpServer m_server;
 
         private BlockingQueue<PollServiceHttpRequest> m_requests = new BlockingQueue<PollServiceHttpRequest>();
-        private static List<PollServiceHttpRequest> m_longPollRequests = new List<PollServiceHttpRequest>();
+        private static Queue<PollServiceHttpRequest> m_slowRequests = new Queue<PollServiceHttpRequest>();
+        private static Queue<PollServiceHttpRequest> m_retryRequests = new Queue<PollServiceHttpRequest>();
 
         private uint m_WorkerThreadCount = 0;
         private Thread[] m_workerThreads;
-        private Thread m_longPollThread;
+        private Thread m_retrysThread;
 
         private bool m_running = true;
         private int slowCount = 0;
 
         private SmartThreadPool m_threadPool = new SmartThreadPool(20000, 12, 2);
 
-//        private int m_timeout = 1000;   //  increase timeout 250; now use the event one
-
         public PollServiceRequestManager(BaseHttpServer pSrv, uint pWorkerThreadCount, int pTimeout)
         {
             m_server = pSrv;
@@ -83,9 +82,9 @@ namespace OpenSim.Framework.Servers.HttpServer
                         int.MaxValue);
             }
 
-            m_longPollThread = Watchdog.StartThread(
-                this.CheckLongPollThreads,
-                string.Format("LongPollServiceWatcherThread:{0}", m_server.Port),
+            m_retrysThread = Watchdog.StartThread(
+                this.CheckRetries,
+                string.Format("PollServiceWatcherThread:{0}", m_server.Port),
                 ThreadPriority.Normal,
                 false,
                 true,
@@ -97,15 +96,8 @@ namespace OpenSim.Framework.Servers.HttpServer
         {
             if (m_running)
             {
-                // delay the enqueueing for 100ms. There's no need to have the event
-                // actively on the queue
-                Timer t = new Timer(self => {
-                    ((Timer)self).Dispose();
-                    m_requests.Enqueue(req);
-                });
-
-                t.Change(100, Timeout.Infinite);
-
+                lock (m_retryRequests)
+                    m_retryRequests.Enqueue(req);
             }
         }
 
@@ -113,47 +105,39 @@ namespace OpenSim.Framework.Servers.HttpServer
         {
             if (m_running)
             {
-                if (req.PollServiceArgs.Type == PollServiceEventArgs.EventType.LongPoll)
+                if (req.PollServiceArgs.Type != PollServiceEventArgs.EventType.LongPoll)
                 {
-                    lock (m_longPollRequests)
-                        m_longPollRequests.Add(req);
+                    m_requests.Enqueue(req);
                 }
                 else
-                    m_requests.Enqueue(req);
+                {
+                    lock (m_slowRequests)
+                        m_slowRequests.Enqueue(req);
+                }
             }
         }
 
-        private void CheckLongPollThreads()
+        private void CheckRetries()
         {
-            // The only purpose of this thread is to check the EQs for events.
-            // If there are events, that thread will be placed in the "ready-to-serve" queue, m_requests.
-            // If there are no events, that thread will be back to its "waiting" queue, m_longPollRequests.
-            // All other types of tasks (Inventory handlers, http-in, etc) don't have the long-poll nature,
-            // so if they aren't ready to be served by a worker thread (no events), they are placed 
-            // directly back in the "ready-to-serve" queue by the worker thread.
             while (m_running)
             {
-                Thread.Sleep(1000); 
+                Thread.Sleep(100); // let the world move  .. back to faster rate
                 Watchdog.UpdateThread();
-
-                List<PollServiceHttpRequest> not_ready = new List<PollServiceHttpRequest>();
-                lock (m_longPollRequests)
+                lock (m_retryRequests)
                 {
-                    if (m_longPollRequests.Count > 0 && m_running)
-                    {
-                        List<PollServiceHttpRequest> ready = m_longPollRequests.FindAll(req =>
-                            (req.PollServiceArgs.HasEvents(req.RequestID, req.PollServiceArgs.Id) || // there are events in this EQ
-                            (Environment.TickCount - req.RequestTime) > req.PollServiceArgs.TimeOutms) // no events, but timeout
-                            );
-
-                        ready.ForEach(req =>
-                            {
-                                m_requests.Enqueue(req);
-                                m_longPollRequests.Remove(req);
-                            });
+                    while (m_retryRequests.Count > 0 && m_running)
+                        m_requests.Enqueue(m_retryRequests.Dequeue());
+                }
+                slowCount++;
+                if (slowCount >= 10)
+                {
+                    slowCount = 0;
 
+                    lock (m_slowRequests)
+                    {
+                        while (m_slowRequests.Count > 0 && m_running)
+                            m_requests.Enqueue(m_slowRequests.Dequeue());
                     }
-
                 }
             }
         }
@@ -161,18 +145,30 @@ namespace OpenSim.Framework.Servers.HttpServer
         public void Stop()
         {
             m_running = false;
-//            m_timeout = -10000; // cause all to expire
             Thread.Sleep(1000); // let the world move
 
             foreach (Thread t in m_workerThreads)
                 Watchdog.AbortThread(t.ManagedThreadId);
 
+            try
+            {
+                foreach (PollServiceHttpRequest req in m_retryRequests)
+                {
+                   DoHTTPGruntWork(m_server,req,
+                        req.PollServiceArgs.NoEvents(req.RequestID, req.PollServiceArgs.Id));
+                }
+            }
+            catch
+            {
+            }
+
             PollServiceHttpRequest wreq;
+            m_retryRequests.Clear();
 
-            lock (m_longPollRequests)
+            lock (m_slowRequests)
             {
-                if (m_longPollRequests.Count > 0 && m_running)
-                    m_longPollRequests.ForEach(req => m_requests.Enqueue(req));
+                while (m_slowRequests.Count > 0 && m_running)
+                    m_requests.Enqueue(m_slowRequests.Dequeue());
             }
 
             while (m_requests.Count() > 0)
@@ -180,15 +176,14 @@ namespace OpenSim.Framework.Servers.HttpServer
                 try
                 {
                     wreq = m_requests.Dequeue(0);
-                    wreq.DoHTTPGruntWork(
-                        m_server, wreq.PollServiceArgs.NoEvents(wreq.RequestID, wreq.PollServiceArgs.Id));
+                    DoHTTPGruntWork(m_server,wreq,
+                        wreq.PollServiceArgs.NoEvents(wreq.RequestID, wreq.PollServiceArgs.Id));
                 }
                 catch
                 {
                 }
             }
 
-            m_longPollRequests.Clear();
             m_requests.Clear();
         }
 
@@ -199,7 +194,6 @@ namespace OpenSim.Framework.Servers.HttpServer
             while (m_running)
             {
                 PollServiceHttpRequest req = m_requests.Dequeue(5000);
-                //m_log.WarnFormat("[YYY]: Dequeued {0}", (req == null ? "null" : req.PollServiceArgs.Type.ToString()));
 
                 Watchdog.UpdateThread();
                 if (req != null)
@@ -217,7 +211,7 @@ namespace OpenSim.Framework.Servers.HttpServer
                             {
                                 try
                                 {
-                                    req.DoHTTPGruntWork(m_server, responsedata);
+                                    DoHTTPGruntWork(m_server, req, responsedata);
                                 }
                                 catch (ObjectDisposedException) // Browser aborted before we could read body, server closed the stream
                                 {
@@ -230,7 +224,7 @@ namespace OpenSim.Framework.Servers.HttpServer
                                 {
                                     try
                                     {
-                                        req.DoHTTPGruntWork(m_server, responsedata);
+                                        DoHTTPGruntWork(m_server, req, responsedata);
                                     }
                                     catch (ObjectDisposedException) // Browser aborted before we could read body, server closed the stream
                                     {
@@ -245,8 +239,8 @@ namespace OpenSim.Framework.Servers.HttpServer
                         {
                             if ((Environment.TickCount - req.RequestTime) > req.PollServiceArgs.TimeOutms)
                             {
-                                req.DoHTTPGruntWork(
-                                    m_server, req.PollServiceArgs.NoEvents(req.RequestID, req.PollServiceArgs.Id));
+                                DoHTTPGruntWork(m_server, req, 
+                                    req.PollServiceArgs.NoEvents(req.RequestID, req.PollServiceArgs.Id));
                             }
                             else
                             {
@@ -261,5 +255,42 @@ namespace OpenSim.Framework.Servers.HttpServer
                 }
             }
         }
+
+        // DoHTTPGruntWork  changed, not sending response
+        // do the same work around as core
+
+        internal static void DoHTTPGruntWork(BaseHttpServer server, PollServiceHttpRequest req, Hashtable responsedata)
+        {
+            OSHttpResponse response
+                = new OSHttpResponse(new HttpResponse(req.HttpContext, req.Request), req.HttpContext);
+
+            byte[] buffer = server.DoHTTPGruntWork(responsedata, response);
+
+            response.SendChunked = false;
+            response.ContentLength64 = buffer.Length;
+            response.ContentEncoding = Encoding.UTF8;
+
+            try
+            {
+                response.OutputStream.Write(buffer, 0, buffer.Length);
+            }
+            catch (Exception ex)
+            {
+                m_log.Warn(string.Format("[POLL SERVICE WORKER THREAD]: Error ", ex));
+            }
+            finally
+            {
+                try
+                {
+                    response.OutputStream.Flush();
+                    response.Send();
+                }
+                catch (Exception e)
+                {
+                    m_log.Warn(String.Format("[POLL SERVICE WORKER THREAD]: Error ", e));
+                }
+            }
+        }
     }
-}
\ No newline at end of file
+}
+