6 files changed, 342 insertions, 21 deletions

diff --git a/OpenSim/Framework/Servers/BaseOpenSimServer.cs b/OpenSim/Framework/Servers/BaseOpenSimServer.cs
index 14d8b0c..9a2cd0e 100644
--- a/OpenSim/Framework/Servers/BaseOpenSimServer.cs
+++ b/OpenSim/Framework/Servers/BaseOpenSimServer.cs
@@ -308,7 +308,7 @@ namespace OpenSim.Framework.Servers
 
             EnhanceVersionInformation();
             
-            m_log.Info("[STARTUP]: OpenSimulator version: " + m_version + Environment.NewLine);
+            m_log.Info("[STARTUP]: Careminster version: " + m_version + Environment.NewLine);
             // clr version potentially is more confusing than helpful, since it doesn't tell us if we're running under Mono/MS .NET and
             // the clr version number doesn't match the project version number under Mono.
             //m_log.Info("[STARTUP]: Virtual machine runtime version: " + Environment.Version + Environment.NewLine);
diff --git a/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs b/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs
index 3de7f9c..24f986a 100644
--- a/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs
+++ b/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs
@@ -1447,10 +1447,34 @@ 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 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"];
+                    responseString = (string)responsedata["str_response_string"];
+                    contentType = (string)responsedata["content_type"];
+                }
+                catch
+                {
+                    responsecode = 500;
+                    responseString = "No response could be obtained";
+                    contentType = "text/plain";
+                    responsedata = new Hashtable();
+                }
+            }
 
             if (responsedata.ContainsKey("error_status_text"))
             {
@@ -1627,7 +1651,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)
             {
diff --git a/OpenSim/Framework/Servers/HttpServer/PollServiceEventArgs.cs b/OpenSim/Framework/Servers/HttpServer/PollServiceEventArgs.cs
index 3089351..bb43cd2 100644
--- a/OpenSim/Framework/Servers/HttpServer/PollServiceEventArgs.cs
+++ b/OpenSim/Framework/Servers/HttpServer/PollServiceEventArgs.cs
@@ -45,17 +45,27 @@ namespace OpenSim.Framework.Servers.HttpServer
         public NoEventsMethod NoEvents;
         public RequestMethod Request;
         public UUID Id;
+        public int TimeOutms;
+        public EventType Type;
+
+        public enum EventType : int
+        {
+            Normal = 0,
+            LslHttp = 1
+        }
 
         public PollServiceEventArgs(
             RequestMethod pRequest,
             HasEventsMethod pHasEvents, GetEventsMethod pGetEvents, NoEventsMethod pNoEvents,
-            UUID pId)
+            UUID pId, int pTimeOutms)
         {
             Request = pRequest;
             HasEvents = pHasEvents;
             GetEvents = pGetEvents;
             NoEvents = pNoEvents;
             Id = pId;
+            TimeOutms = pTimeOutms;
+            Type = EventType.Normal;
         }
     }
-}
\ No newline at end of file
+}
diff --git a/OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs b/OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs
index 3252251..a3bd330 100644
--- a/OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs
+++ b/OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs
@@ -33,14 +33,18 @@ using log4net;
 using HttpServer;
 using OpenSim.Framework;
 
+
+/*
 namespace OpenSim.Framework.Servers.HttpServer
 {
+
     public class PollServiceRequestManager
     {
 //        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
         private readonly BaseHttpServer m_server;
         private static Queue m_requests = Queue.Synchronized(new Queue());
+        private static ManualResetEvent m_ev = new ManualResetEvent(false);
         private uint m_WorkerThreadCount = 0;
         private Thread[] m_workerThreads;
         private PollServiceWorkerThread[] m_PollServiceWorkerThreads;
@@ -66,7 +70,6 @@ namespace OpenSim.Framework.Servers.HttpServer
                         ThreadPriority.Normal,
                         false,
                         true,
-                        null,
                         int.MaxValue);
             }
 
@@ -76,7 +79,6 @@ namespace OpenSim.Framework.Servers.HttpServer
                 ThreadPriority.Normal,
                 false,
                 true,
-                null,
                 1000 * 60 * 10);
         }
 
@@ -90,15 +92,17 @@ namespace OpenSim.Framework.Servers.HttpServer
         {
             lock (m_requests)
                 m_requests.Enqueue(req);
+            m_ev.Set();
         }
 
         public void ThreadStart()
         {
             while (m_running)
             {
+                m_ev.WaitOne(1000);
+                m_ev.Reset();
                 Watchdog.UpdateThread();
                 ProcessQueuedRequests();
-                Thread.Sleep(1000);
             }
         }
 
@@ -140,8 +144,9 @@ namespace OpenSim.Framework.Servers.HttpServer
             foreach (object o in m_requests)
             {
                 PollServiceHttpRequest req = (PollServiceHttpRequest) o;
-                PollServiceWorkerThread.DoHTTPGruntWork(
-                    m_server, req, req.PollServiceArgs.NoEvents(req.RequestID, req.PollServiceArgs.Id));
+                m_server.DoHTTPGruntWork(
+                    req.PollServiceArgs.NoEvents(req.RequestID, req.PollServiceArgs.Id),
+                    new OSHttpResponse(new HttpResponse(req.HttpContext, req.Request), req.HttpContext));
             }
 
             m_requests.Clear();
@@ -150,8 +155,278 @@ namespace OpenSim.Framework.Servers.HttpServer
             {
                 t.Abort();
             }
-            
             m_running = false;
         }
     }
-}
\ No newline at end of file
+}
+ */
+
+using System.IO;
+using System.Text;
+using System.Collections.Generic;
+
+namespace OpenSim.Framework.Servers.HttpServer
+{
+    public class PollServiceRequestManager
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private readonly BaseHttpServer m_server;
+
+        private BlockingQueue<PollServiceHttpRequest> m_requests = new BlockingQueue<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 = true;
+        private int slowCount = 0;
+
+//        private int m_timeout = 1000;   //  increase timeout 250; now use the event one
+
+        public PollServiceRequestManager(BaseHttpServer pSrv, uint pWorkerThreadCount, int pTimeout)
+        {
+            m_server = pSrv;
+            m_WorkerThreadCount = pWorkerThreadCount;
+            m_workerThreads = new Thread[m_WorkerThreadCount];
+
+            //startup worker threads
+            for (uint i = 0; i < m_WorkerThreadCount; i++)
+            {
+                m_workerThreads[i]
+                    = Watchdog.StartThread(
+                        PoolWorkerJob,
+                        String.Format("PollServiceWorkerThread{0}", i),
+                        ThreadPriority.Normal,
+                        false,
+                        true,
+                        null,
+                        int.MaxValue);
+            }
+
+            m_retrysThread = Watchdog.StartThread(
+                this.CheckRetries,
+                "PollServiceWatcherThread",
+                ThreadPriority.Normal,
+                false,
+                true,
+                null,
+                1000 * 60 * 10);
+        }
+
+
+        private void ReQueueEvent(PollServiceHttpRequest req)
+        {
+            if (m_running)
+            {
+                lock (m_retryRequests)
+                    m_retryRequests.Enqueue(req);
+            }
+        }
+
+        public void Enqueue(PollServiceHttpRequest req)
+        {
+            if (m_running)
+            {
+                if (req.PollServiceArgs.Type == PollServiceEventArgs.EventType.LslHttp)
+                {
+                    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());
+                    }
+                }
+            }
+        }
+
+        ~PollServiceRequestManager()
+        {
+            m_running = false;
+//            m_timeout = -10000; // cause all to expire
+            Thread.Sleep(1000); // let the world move
+
+            foreach (Thread t in m_workerThreads)
+            {
+                try
+                {
+                    t.Abort();
+                }
+                catch
+                {
+                }
+            }
+
+            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_slowRequests)
+            {
+                while (m_slowRequests.Count > 0 && m_running)
+                    m_requests.Enqueue(m_slowRequests.Dequeue());
+            }
+
+            while (m_requests.Count() > 0)
+            {
+                try
+                {
+                    wreq = m_requests.Dequeue(0);
+                    DoHTTPGruntWork(m_server,wreq,
+                        wreq.PollServiceArgs.NoEvents(wreq.RequestID, wreq.PollServiceArgs.Id));
+                }
+                catch
+                {
+                }
+            }
+
+            m_requests.Clear();
+        }
+
+        // work threads
+
+        private void PoolWorkerJob()
+        {
+            PollServiceHttpRequest req;
+            StreamReader str;
+
+//            while (true)
+            while (m_running)
+            {
+                req = m_requests.Dequeue(5000);
+
+                Watchdog.UpdateThread();
+                if (req != null)
+                {
+                    try
+                    {
+                        if (req.PollServiceArgs.HasEvents(req.RequestID, req.PollServiceArgs.Id))
+                        {
+                            try
+                            {
+                                str = new StreamReader(req.Request.Body);
+                            }
+                            catch (System.ArgumentException)
+                            {
+                                // Stream was not readable means a child agent
+                                // was closed due to logout, leaving the
+                                // Event Queue request orphaned.
+                                continue;
+                            }
+
+                            try
+                            {
+                                Hashtable responsedata = req.PollServiceArgs.GetEvents(req.RequestID, req.PollServiceArgs.Id, str.ReadToEnd());
+                                DoHTTPGruntWork(m_server, req, responsedata);
+                            }
+                            catch (ObjectDisposedException) // Browser aborted before we could read body, server closed the stream
+                            {
+                                // Ignore it, no need to reply
+                            }
+
+                            str.Close();
+
+                        }
+                        else
+                        {
+//                            if ((Environment.TickCount - req.RequestTime) > m_timeout)
+
+                            if ((Environment.TickCount - req.RequestTime) > req.PollServiceArgs.TimeOutms)
+                            {
+                                DoHTTPGruntWork(m_server, req, 
+                                    req.PollServiceArgs.NoEvents(req.RequestID, req.PollServiceArgs.Id));
+                            }
+                            else
+                            {
+                                ReQueueEvent(req);
+                            }
+                        }
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat("Exception in poll service thread: " + e.ToString());
+                    }
+                }
+            }
+        }
+
+        // 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
+            {
+                //response.OutputStream.Close();
+                try
+                {
+                    response.OutputStream.Flush();
+                    response.Send();
+
+                    //if (!response.KeepAlive && response.ReuseContext)
+                    //    response.FreeContext();
+                }
+                catch (Exception e)
+                {
+                    m_log.Warn(String.Format("[POLL SERVICE WORKER THREAD]: Error ", e));
+                }
+            }
+        }
+    }
+}
+
diff --git a/OpenSim/Framework/Servers/HttpServer/PollServiceWorkerThread.cs b/OpenSim/Framework/Servers/HttpServer/PollServiceWorkerThread.cs
index 35a8dee..1e3fbf0 100644
--- a/OpenSim/Framework/Servers/HttpServer/PollServiceWorkerThread.cs
+++ b/OpenSim/Framework/Servers/HttpServer/PollServiceWorkerThread.cs
@@ -25,6 +25,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+/* Ubit work moved to PollServiceRequestManager
+
 using System;
 using System.Collections;
 using System.Collections.Generic;
@@ -89,8 +91,15 @@ namespace OpenSim.Framework.Servers.HttpServer
                             continue;
                         }
 
-                        Hashtable responsedata = req.PollServiceArgs.GetEvents(req.RequestID, req.PollServiceArgs.Id, str.ReadToEnd());
-                        DoHTTPGruntWork(m_server, req, responsedata);
+                        try
+                        {
+                            Hashtable responsedata = req.PollServiceArgs.GetEvents(req.RequestID, req.PollServiceArgs.Id, str.ReadToEnd());
+                            DoHTTPGruntWork(m_server, req, responsedata);
+                        }
+                        catch (ObjectDisposedException) // Browser aborted before we could read body, server closed the stream
+                        {
+                            // Ignore it, no need to reply
+                        }
                     }
                     else
                     {
@@ -161,4 +170,5 @@ namespace OpenSim.Framework.Servers.HttpServer
             }
         }
     }
-}
\ No newline at end of file
+}
+*/
\ No newline at end of file
diff --git a/OpenSim/Framework/Servers/VersionInfo.cs b/OpenSim/Framework/Servers/VersionInfo.cs
index 5f01788..016a174 100644
--- a/OpenSim/Framework/Servers/VersionInfo.cs
+++ b/OpenSim/Framework/Servers/VersionInfo.cs
@@ -29,11 +29,11 @@ namespace OpenSim
 {
     public class VersionInfo
     {
-        private const string VERSION_NUMBER = "0.7.4";
+        private const string VERSION_NUMBER = "0.7.4CM";
         private const Flavour VERSION_FLAVOUR = Flavour.Dev;
 
         public enum Flavour
-        {
+        { 
             Unknown,
             Dev,
             RC1,
@@ -50,7 +50,7 @@ namespace OpenSim
 
         public static string GetVersionString(string versionNumber, Flavour flavour)
         {
-            string versionString = "OpenSim " + versionNumber + " " + flavour;
+            string versionString = "Careminster " + versionNumber + " " + flavour;
             return versionString.PadRight(VERSIONINFO_VERSION_LENGTH);
         }