5 files changed, 342 insertions, 205 deletions

diff --git a/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs b/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs
index f252bd5..cd14212 100644
--- a/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs
+++ b/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs
@@ -403,6 +403,7 @@ namespace OpenSim.Framework.Servers.HttpServer
                         StreamReader reader = new StreamReader(requestStream, encoding);
 
                         string requestBody = reader.ReadToEnd();
+                        reader.Close();
 
                         Hashtable keysvals = new Hashtable();
                         Hashtable headervals = new Hashtable();
@@ -460,7 +461,7 @@ namespace OpenSim.Framework.Servers.HttpServer
             }
             
             OSHttpResponse resp = new OSHttpResponse(new HttpResponse(context, request),context);
-            resp.ReuseContext = true;
+            resp.ReuseContext = false;
             HandleRequest(req, resp);           
 
             // !!!HACK ALERT!!!
@@ -759,7 +760,7 @@ namespace OpenSim.Framework.Servers.HttpServer
                 // Every month or so this will wrap and give bad numbers, not really a problem
                 // since its just for reporting
                 int tickdiff = requestEndTick - requestStartTick;
-                if (tickdiff > 3000 && requestHandler != null && requestHandler.Name != "GetTexture")
+                if (tickdiff > 3000 && (requestHandler == null || requestHandler.Name == null || requestHandler.Name != "GetTexture"))
                 {
                     m_log.InfoFormat(
                         "[LOGHTTP] Slow handling of {0} {1} {2} {3} {4} from {5} took {6}ms",
@@ -1024,6 +1025,19 @@ namespace OpenSim.Framework.Servers.HttpServer
             string responseString = String.Empty;
             XmlRpcRequest xmlRprcRequest = null;
 
+            bool gridproxy = false;
+            if (requestBody.Contains("encoding=\"utf-8"))
+            {
+                int channelindx = -1;
+                int optionsindx = requestBody.IndexOf(">options<");
+                if(optionsindx >0)
+                {
+                    channelindx = requestBody.IndexOf(">channel<");
+                    if (optionsindx < channelindx)
+                        gridproxy = true;
+                }
+            }
+
             try
             {
                 xmlRprcRequest = (XmlRpcRequest) (new XmlRpcRequestDeserializer()).Deserialize(requestBody);
@@ -1081,6 +1095,8 @@ namespace OpenSim.Framework.Servers.HttpServer
                         }
                         xmlRprcRequest.Params.Add(request.Headers.Get(xff)); // Param[3]
 
+                        if (gridproxy)
+                            xmlRprcRequest.Params.Add("gridproxy");  // Param[4]
                         try
                         {
                             xmlRpcResponse = method(xmlRprcRequest, request.RemoteIPEndPoint);
@@ -1254,7 +1270,8 @@ namespace OpenSim.Framework.Servers.HttpServer
             requestStream.Close();
 
             //m_log.DebugFormat("[OGP]: {0}:{1}", request.RawUrl, requestBody);
-            response.KeepAlive = true;
+            // response.KeepAlive = true;
+            response.KeepAlive = false;
 
             OSD llsdRequest = null;
             OSD llsdResponse = null;
@@ -1732,10 +1749,40 @@ namespace OpenSim.Framework.Servers.HttpServer
 
         internal byte[] DoHTTPGruntWork(Hashtable responsedata, OSHttpResponse response)
         {
-            //m_log.Info("[BASE HTTP SERVER]: Doing HTTP Grunt work with response");
-            int responsecode = (int)responsedata["int_response_code"];
-            string responseString = (string)responsedata["str_response_string"];
-            string contentType = (string)responsedata["content_type"];
+            int responsecode;
+            string responseString = String.Empty;
+            byte[] responseData = null;
+            string contentType;
+
+            if (responsedata == null)
+            {
+                responsecode = 500;
+                responseString = "No response could be obtained";
+                contentType = "text/plain";
+                responsedata = new Hashtable();
+            }
+            else
+            {
+                try
+                {
+                    //m_log.Info("[BASE HTTP SERVER]: Doing HTTP Grunt work with response");
+                    responsecode = (int)responsedata["int_response_code"];
+                    if (responsedata["bin_response_data"] != null)
+                        responseData = (byte[])responsedata["bin_response_data"];
+                    else
+                        responseString = (string)responsedata["str_response_string"];
+                    contentType = (string)responsedata["content_type"];
+                    if (responseString == null)
+                        responseString = String.Empty;
+                }
+                catch
+                {
+                    responsecode = 500;
+                    responseString = "No response could be obtained";
+                    contentType = "text/plain";
+                    responsedata = new Hashtable();
+                }
+            }
 
             if (responsedata.ContainsKey("error_status_text"))
             {
@@ -1745,16 +1792,19 @@ namespace OpenSim.Framework.Servers.HttpServer
             {
                 response.ProtocolVersion = (string)responsedata["http_protocol_version"];
             }
-
+/*
             if (responsedata.ContainsKey("keepalive"))
             {
                 bool keepalive = (bool)responsedata["keepalive"];
                 response.KeepAlive = keepalive;
-
             }
 
             if (responsedata.ContainsKey("reusecontext"))
                 response.ReuseContext = (bool) responsedata["reusecontext"];
+*/
+            // disable this things
+            response.KeepAlive = false;
+            response.ReuseContext = false;
 
             // Cross-Origin Resource Sharing with simple requests
             if (responsedata.ContainsKey("access_control_allow_origin"))
@@ -1768,8 +1818,11 @@ namespace OpenSim.Framework.Servers.HttpServer
                 contentType = "text/html";
             }
 
+
+
             // The client ignores anything but 200 here for web login, so ensure that this is 200 for that
 
+
             response.StatusCode = responsecode;
 
             if (responsecode == (int)OSHttpStatusCode.RedirectMovedPermanently)
@@ -1780,25 +1833,40 @@ namespace OpenSim.Framework.Servers.HttpServer
 
             response.AddHeader("Content-Type", contentType);
 
+            if (responsedata.ContainsKey("headers"))
+            {
+                Hashtable headerdata = (Hashtable)responsedata["headers"];
+
+                foreach (string header in headerdata.Keys)
+                    response.AddHeader(header, (string)headerdata[header]);
+            }
+
             byte[] buffer;
 
-            if (!(contentType.Contains("image")
-                || contentType.Contains("x-shockwave-flash")
-                || contentType.Contains("application/x-oar")
-                || contentType.Contains("application/vnd.ll.mesh")))
+            if (responseData != null)
             {
-                // Text
-                buffer = Encoding.UTF8.GetBytes(responseString);
+                buffer = responseData;
             }
             else
             {
-                // Binary!
-                buffer = Convert.FromBase64String(responseString);
-            }
+                if (!(contentType.Contains("image")
+                    || contentType.Contains("x-shockwave-flash")
+                    || contentType.Contains("application/x-oar")
+                    || contentType.Contains("application/vnd.ll.mesh")))
+                {
+                    // Text
+                    buffer = Encoding.UTF8.GetBytes(responseString);
+                }
+                else
+                {
+                    // Binary!
+                    buffer = Convert.FromBase64String(responseString);
+                }
 
-            response.SendChunked = false;
-            response.ContentLength64 = buffer.Length;
-            response.ContentEncoding = Encoding.UTF8;
+                response.SendChunked = false;
+                response.ContentLength64 = buffer.Length;
+                response.ContentEncoding = Encoding.UTF8;
+            }
 
             return buffer;
         }
@@ -1886,6 +1954,7 @@ namespace OpenSim.Framework.Servers.HttpServer
                 m_httpListener2.Start(64);
 
                 // Long Poll Service Manager with 3 worker threads a 25 second timeout for no events
+
                 PollServiceRequestManager = new PollServiceRequestManager(this, performPollResponsesAsync, 3, 25000);
                 PollServiceRequestManager.Start();
 
@@ -1937,7 +2006,9 @@ namespace OpenSim.Framework.Servers.HttpServer
 
         public void httpServerException(object source, Exception exception)
         {
-            m_log.Error(String.Format("[BASE HTTP SERVER]: {0} had an exception: {1} ", source.ToString(), exception.Message), exception);
+            if (source.ToString() == "HttpServer.HttpListener" && exception.ToString().StartsWith("Mono.Security.Protocol.Tls.TlsException"))
+                return;
+            m_log.ErrorFormat("[BASE HTTP SERVER]: {0} had an exception {1}", source.ToString(), exception.ToString());
            /*
             if (HTTPDRunning)// && NotSocketErrors > 5)
             {
@@ -1984,6 +2055,7 @@ namespace OpenSim.Framework.Servers.HttpServer
 
         public void RemoveHTTPHandler(string httpMethod, string path)
         {
+            if (path == null) return; // Caps module isn't loaded, tries to remove handler where path = null
             lock (m_HTTPHandlers)
             {
                 if (httpMethod != null && httpMethod.Length == 0)
diff --git a/OpenSim/Framework/Servers/HttpServer/OSHttpResponse.cs b/OpenSim/Framework/Servers/HttpServer/OSHttpResponse.cs
index 89fb5d4..17e9dc2 100644
--- a/OpenSim/Framework/Servers/HttpServer/OSHttpResponse.cs
+++ b/OpenSim/Framework/Servers/HttpServer/OSHttpResponse.cs
@@ -148,6 +148,7 @@ namespace OpenSim.Framework.Servers.HttpServer
                     _httpResponse.Connection = ConnectionType.Close;
                     _httpResponse.KeepAlive = 0;
                 }
+
                 else
                 {
                     _httpResponse.Connection = ConnectionType.KeepAlive;
@@ -320,6 +321,11 @@ namespace OpenSim.Framework.Servers.HttpServer
         public void Send()
         {
             _httpResponse.Body.Flush();
+
+            // disable this till they are safe to use
+            _httpResponse.Connection = ConnectionType.Close;
+            _httpResponse.Chunked = false;
+
             _httpResponse.Send();
         }
 
diff --git a/OpenSim/Framework/Servers/HttpServer/PollServiceEventArgs.cs b/OpenSim/Framework/Servers/HttpServer/PollServiceEventArgs.cs
index 9477100..3fd3bf7 100644
--- a/OpenSim/Framework/Servers/HttpServer/PollServiceEventArgs.cs
+++ b/OpenSim/Framework/Servers/HttpServer/PollServiceEventArgs.cs
@@ -52,7 +52,9 @@ namespace OpenSim.Framework.Servers.HttpServer
         {
             LongPoll = 0,
             LslHttp = 1,
-            Inventory = 2
+            Inventory = 2,
+            Texture = 3, 
+            Mesh = 4
         }
 
         public string Url { get; set; }
diff --git a/OpenSim/Framework/Servers/HttpServer/PollServiceHttpRequest.cs b/OpenSim/Framework/Servers/HttpServer/PollServiceHttpRequest.cs
index caf0e98..49cd110 100644
--- a/OpenSim/Framework/Servers/HttpServer/PollServiceHttpRequest.cs
+++ b/OpenSim/Framework/Servers/HttpServer/PollServiceHttpRequest.cs
@@ -27,6 +27,7 @@
 
 using System;
 using System.Collections;
+using System.Collections.Generic;
 using System.Reflection;
 using System.Text;
 using HttpServer;
@@ -44,6 +45,24 @@ namespace OpenSim.Framework.Servers.HttpServer
         public readonly IHttpRequest Request;
         public readonly int RequestTime;
         public readonly UUID RequestID;
+        public int  contextHash;
+
+        private void GenContextHash()
+        {
+            Random rnd = new Random();
+            contextHash = 0;
+            if (Request.Headers["remote_addr"] != null)
+                contextHash = (Request.Headers["remote_addr"]).GetHashCode() << 16;
+            else
+                contextHash = rnd.Next() << 16;
+            if (Request.Headers["remote_port"] != null)
+            {
+                string[] strPorts = Request.Headers["remote_port"].Split(new char[] { ',' });
+                contextHash += Int32.Parse(strPorts[0]);
+            }
+            else
+                contextHash += rnd.Next() & 0xffff;
+        }
 
         public PollServiceHttpRequest(
             PollServiceEventArgs pPollServiceArgs, IHttpClientContext pHttpContext, IHttpRequest pRequest)
@@ -53,6 +72,7 @@ namespace OpenSim.Framework.Servers.HttpServer
             Request = pRequest;
             RequestTime = System.Environment.TickCount;
             RequestID = UUID.Random();
+            GenContextHash();
         }
 
         internal void DoHTTPGruntWork(BaseHttpServer server, Hashtable responsedata)
@@ -65,6 +85,7 @@ namespace OpenSim.Framework.Servers.HttpServer
             response.SendChunked = false;
             response.ContentLength64 = buffer.Length;
             response.ContentEncoding = Encoding.UTF8;
+            response.ReuseContext = false;
 
             try
             {
@@ -93,5 +114,44 @@ namespace OpenSim.Framework.Servers.HttpServer
                 PollServiceArgs.RequestsHandled++;
             }
         }
+
+        internal void DoHTTPstop(BaseHttpServer server)
+        {
+            OSHttpResponse response
+                = new OSHttpResponse(new HttpResponse(HttpContext, Request), HttpContext);
+
+            response.SendChunked = false;
+            response.ContentLength64 = 0;
+            response.ContentEncoding = Encoding.UTF8;
+            response.ReuseContext = false;
+            response.KeepAlive = false;
+            response.SendChunked = false;
+            response.StatusCode = 503;
+
+            try
+            {
+                response.OutputStream.Flush();
+                response.Send();
+            }
+            catch (Exception e)
+            {
+            }
+        }
+    }
+
+    class PollServiceHttpRequestComparer : IEqualityComparer<PollServiceHttpRequest>
+    {
+        public bool Equals(PollServiceHttpRequest b1, PollServiceHttpRequest b2)
+        {
+            if (b1.contextHash != b2.contextHash)
+                return false;
+            bool b = Object.ReferenceEquals(b1.HttpContext, b2.HttpContext);
+            return b;
+        }
+
+        public int GetHashCode(PollServiceHttpRequest b2)
+        {
+            return (int)b2.contextHash;
+        }
     }
 }
\ No newline at end of file
diff --git a/OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs b/OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs
index 28bba70..0e4323a 100644
--- a/OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs
+++ b/OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs
@@ -44,183 +44,199 @@ namespace OpenSim.Framework.Servers.HttpServer
     {
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
-        /// <summary>
-        /// Is the poll service request manager running?
-        /// </summary>
-        /// <remarks>
-        /// Can be running either synchronously or asynchronously
-        /// </remarks>
-        public bool IsRunning { get; private set; }
-
-        /// <summary>
-        /// Is the poll service performing responses asynchronously (with its own threads) or synchronously (via
-        /// external calls)?
-        /// </summary>
-        public bool PerformResponsesAsync { get; private set; }
-
-        /// <summary>
-        /// Number of responses actually processed and sent to viewer (or aborted due to error).
-        /// </summary>
-        public int ResponsesProcessed { get; private set; }
-
         private readonly BaseHttpServer m_server;
 
+        private Dictionary<PollServiceHttpRequest, Queue<PollServiceHttpRequest>> m_bycontext;
         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_retrysThread;
+
+        private bool m_running = false;
+        private int slowCount = 0;
 
-        private SmartThreadPool m_threadPool = new SmartThreadPool(20000, 12, 2);
+        private SmartThreadPool m_threadPool;
 
-//        private int m_timeout = 1000;   //  increase timeout 250; now use the event one
 
         public PollServiceRequestManager(
             BaseHttpServer pSrv, bool performResponsesAsync, uint pWorkerThreadCount, int pTimeout)
         {
             m_server = pSrv;
-            PerformResponsesAsync = performResponsesAsync;
             m_WorkerThreadCount = pWorkerThreadCount;
             m_workerThreads = new Thread[m_WorkerThreadCount];
 
-            StatsManager.RegisterStat(
-                new Stat(
-                    "QueuedPollResponses",
-                    "Number of poll responses queued for processing.",
-                    "",
-                    "",
-                    "httpserver",
-                    m_server.Port.ToString(),
-                    StatType.Pull,
-                    MeasuresOfInterest.AverageChangeOverTime,
-                    stat => stat.Value = m_requests.Count(),
-                    StatVerbosity.Debug));
-
-            StatsManager.RegisterStat(
-                new Stat(
-                    "ProcessedPollResponses",
-                    "Number of poll responses processed.",
-                    "",
-                    "",
-                    "httpserver",
-                    m_server.Port.ToString(),
-                    StatType.Pull,
-                    MeasuresOfInterest.AverageChangeOverTime,
-                    stat => stat.Value = ResponsesProcessed,
-                    StatVerbosity.Debug));
+            PollServiceHttpRequestComparer preqCp = new PollServiceHttpRequestComparer();
+            m_bycontext = new Dictionary<PollServiceHttpRequest, Queue<PollServiceHttpRequest>>(preqCp);
+
+            STPStartInfo startInfo = new STPStartInfo();
+            startInfo.IdleTimeout = 30000;
+            startInfo.MaxWorkerThreads = 15;
+            startInfo.MinWorkerThreads = 1;
+            startInfo.ThreadPriority = ThreadPriority.Normal;
+            startInfo.StartSuspended = true;
+            startInfo.ThreadPoolName = "PoolService";
+
+            m_threadPool = new SmartThreadPool(startInfo);
+                
         }
 
         public void Start()
         {
-            IsRunning = true;
-
-            if (PerformResponsesAsync)
+            m_running = true;
+            m_threadPool.Start();
+            //startup worker threads
+            for (uint i = 0; i < m_WorkerThreadCount; i++)
             {
-                //startup worker threads
-                for (uint i = 0; i < m_WorkerThreadCount; i++)
-                {
-                    m_workerThreads[i]
-                        = WorkManager.StartThread(
-                            PoolWorkerJob,
-                            string.Format("PollServiceWorkerThread{0}:{1}", i, m_server.Port),
-                            ThreadPriority.Normal,
-                            false,
-                            false,
-                            null,
-                            int.MaxValue);
-                }
-
-                WorkManager.StartThread(
-                    this.CheckLongPollThreads,
-                    string.Format("LongPollServiceWatcherThread:{0}", m_server.Port),
-                    ThreadPriority.Normal,
-                    false,
-                    true,
-                    null,
-                    1000 * 60 * 10);
+                m_workerThreads[i]
+                    = WorkManager.StartThread(
+                        PoolWorkerJob,
+                        string.Format("PollServiceWorkerThread {0}:{1}", i, m_server.Port),
+                        ThreadPriority.Normal,
+                        false,
+                        false,
+                        null,
+                        int.MaxValue);
             }
+
+            m_retrysThread = WorkManager.StartThread(
+                this.CheckRetries,
+                string.Format("PollServiceWatcherThread:{0}", m_server.Port),
+                ThreadPriority.Normal,
+                false,
+                true,
+                null,
+                1000 * 60 * 10);
+                                
+
         }
 
         private void ReQueueEvent(PollServiceHttpRequest req)
         {
-            if (IsRunning)
+            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);
             }
         }
 
         public void Enqueue(PollServiceHttpRequest req)
         {
-            if (IsRunning)
+            lock (m_bycontext)
             {
-                if (req.PollServiceArgs.Type == PollServiceEventArgs.EventType.LongPoll)
+                Queue<PollServiceHttpRequest> ctxQeueue;
+                if (m_bycontext.TryGetValue(req, out ctxQeueue))
                 {
-                    lock (m_longPollRequests)
-                        m_longPollRequests.Add(req);
+                    ctxQeueue.Enqueue(req);
                 }
                 else
-                    m_requests.Enqueue(req);
+                {
+                    ctxQeueue = new Queue<PollServiceHttpRequest>();
+                    m_bycontext[req] = ctxQeueue;
+                    EnqueueInt(req);
+                }
             }
         }
 
-        private void CheckLongPollThreads()
+        public void byContextDequeue(PollServiceHttpRequest req)
         {
-            // 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 (IsRunning)
+            Queue<PollServiceHttpRequest> ctxQeueue;
+            lock (m_bycontext)
             {
-                Thread.Sleep(500); 
-                Watchdog.UpdateThread();
-
-//                List<PollServiceHttpRequest> not_ready = new List<PollServiceHttpRequest>();
-                lock (m_longPollRequests)
+                if (m_bycontext.TryGetValue(req, out ctxQeueue))
                 {
-                    if (m_longPollRequests.Count > 0 && IsRunning)
+                    if (ctxQeueue.Count > 0)
                     {
-                        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
-                            );
+                        PollServiceHttpRequest newreq = ctxQeueue.Dequeue();
+                        EnqueueInt(newreq);
+                    }
+                    else
+                    {
+                        m_bycontext.Remove(req);
+                    }
+                }
+            }
+        }
 
-                        ready.ForEach(req =>
-                            {
-                                m_requests.Enqueue(req);
-                                m_longPollRequests.Remove(req);
-                            });
 
-                    }
+        public void EnqueueInt(PollServiceHttpRequest req)
+        {
+            if (m_running)
+            {
+                if (req.PollServiceArgs.Type != PollServiceEventArgs.EventType.LongPoll)
+                {
+                    m_requests.Enqueue(req);
+                }
+                else
+                {
+                    lock (m_slowRequests)
+                        m_slowRequests.Enqueue(req);
+                }
+            }
+        }
+
+        private void CheckRetries()
+        {
+            while (m_running)
+
+            {
+                Thread.Sleep(100); // let the world move  .. back to faster rate
+                Watchdog.UpdateThread();
+                lock (m_retryRequests)
+                {
+                    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());
+                    }
                 }
             }
         }
 
         public void Stop()
         {
-            IsRunning = false;
-//            m_timeout = -10000; // cause all to expire
+            m_running = false;
+
             Thread.Sleep(1000); // let the world move
 
             foreach (Thread t in m_workerThreads)
                 Watchdog.AbortThread(t.ManagedThreadId);
 
+            // any entry in m_bycontext should have a active request on the other queues
+            // so just delete contents to easy GC
+            foreach (Queue<PollServiceHttpRequest> qu in m_bycontext.Values)
+                qu.Clear();
+            m_bycontext.Clear();
+
+            try
+            {
+                foreach (PollServiceHttpRequest req in m_retryRequests)
+                {
+                    req.DoHTTPstop(m_server);
+                }
+            }
+            catch
+            {
+            }
+
             PollServiceHttpRequest wreq;
+            m_retryRequests.Clear();
 
-            lock (m_longPollRequests)
+            lock (m_slowRequests)
             {
-                if (m_longPollRequests.Count > 0 && IsRunning)
-                    m_longPollRequests.ForEach(req => m_requests.Enqueue(req));
+                while (m_slowRequests.Count > 0)
+                    m_requests.Enqueue(m_slowRequests.Dequeue());
+
             }
 
             while (m_requests.Count() > 0)
@@ -228,16 +244,14 @@ namespace OpenSim.Framework.Servers.HttpServer
                 try
                 {
                     wreq = m_requests.Dequeue(0);
-                    ResponsesProcessed++;
-                    wreq.DoHTTPGruntWork(
-                        m_server, wreq.PollServiceArgs.NoEvents(wreq.RequestID, wreq.PollServiceArgs.Id));
+                    wreq.DoHTTPstop(m_server);
+
                 }
                 catch
                 {
                 }
             }
 
-            m_longPollRequests.Clear();
             m_requests.Clear();
         }
 
@@ -245,87 +259,70 @@ namespace OpenSim.Framework.Servers.HttpServer
 
         private void PoolWorkerJob()
         {
-            while (IsRunning)
+            while (m_running)
             {
-                Watchdog.UpdateThread();
-                WaitPerformResponse();
-            }
-        }
-
-        public void WaitPerformResponse()
-        {
-            PollServiceHttpRequest req = m_requests.Dequeue(5000);
-//            m_log.DebugFormat("[YYY]: Dequeued {0}", (req == null ? "null" : req.PollServiceArgs.Type.ToString()));
+                PollServiceHttpRequest req = m_requests.Dequeue(5000);
 
-            if (req != null)
-            {
-                try
+                Watchdog.UpdateThread();
+                if (req != null)
                 {
-                    if (req.PollServiceArgs.HasEvents(req.RequestID, req.PollServiceArgs.Id))
+                    try
                     {
-                        Hashtable responsedata = req.PollServiceArgs.GetEvents(req.RequestID, req.PollServiceArgs.Id);
-
-                        if (responsedata == null)
-                            return;
-
-                        // This is the event queue.
-                        // Even if we're not running we can still perform responses by explicit request.
-                        if (req.PollServiceArgs.Type == PollServiceEventArgs.EventType.LongPoll 
-                            || !PerformResponsesAsync) 
+                        if (req.PollServiceArgs.HasEvents(req.RequestID, req.PollServiceArgs.Id))
                         {
-                            try
-                            {
-                                ResponsesProcessed++;
-                                req.DoHTTPGruntWork(m_server, responsedata);
-                            }
-                            catch (ObjectDisposedException e) // Browser aborted before we could read body, server closed the stream
-                            {
-                                // Ignore it, no need to reply
-                                m_log.Error(e);
-                            }
-                        }
-                        else
-                        {
-                            m_threadPool.QueueWorkItem(x =>
+                            Hashtable responsedata = req.PollServiceArgs.GetEvents(req.RequestID, req.PollServiceArgs.Id);
+
+                            if (req.PollServiceArgs.Type == PollServiceEventArgs.EventType.LongPoll) // This is the event queue
                             {
                                 try
                                 {
-                                    ResponsesProcessed++;
                                     req.DoHTTPGruntWork(m_server, responsedata);
+                                    byContextDequeue(req);
                                 }
-                                catch (ObjectDisposedException e) // Browser aborted before we could read body, server closed the stream
+                                catch (ObjectDisposedException) // Browser aborted before we could read body, server closed the stream
                                 {
                                     // Ignore it, no need to reply
-                                    m_log.Error(e);
                                 }
-                                catch (Exception e)
+                            }
+                            else
+                            {
+                                m_threadPool.QueueWorkItem(x =>
                                 {
-                                    m_log.Error(e);
-                                }
-
-                                return null;
-                            }, null);
-                        }
-                    }
-                    else
-                    {
-                        if ((Environment.TickCount - req.RequestTime) > req.PollServiceArgs.TimeOutms)
-                        {
-                            ResponsesProcessed++;
-                            req.DoHTTPGruntWork(
-                                m_server, req.PollServiceArgs.NoEvents(req.RequestID, req.PollServiceArgs.Id));
+                                    try
+                                    {
+                                        req.DoHTTPGruntWork(m_server, responsedata);
+                                        byContextDequeue(req);
+                                    }
+                                    catch (ObjectDisposedException) // Browser aborted before we could read body, server closed the stream
+                                    {
+                                        // Ignore it, no need to reply
+                                    }
+
+                                    return null;
+                                }, null);
+                            }
                         }
                         else
                         {
-                            ReQueueEvent(req);
+                            if ((Environment.TickCount - req.RequestTime) > req.PollServiceArgs.TimeOutms)
+                            {
+                                req.DoHTTPGruntWork(m_server,
+                                    req.PollServiceArgs.NoEvents(req.RequestID, req.PollServiceArgs.Id));
+                                byContextDequeue(req);
+                            }
+                            else
+                            {
+                                ReQueueEvent(req);
+                            }
                         }
                     }
-                }
-                catch (Exception e)
-                {
-                    m_log.ErrorFormat("Exception in poll service thread: " + e.ToString());
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat("Exception in poll service thread: " + e.ToString());
+                    }
                 }
             }
         }
+
     }
-}
\ No newline at end of file
+}