7 files changed, 383 insertions, 36 deletions

diff --git a/OpenSim/Framework/Servers/BaseOpenSimServer.cs b/OpenSim/Framework/Servers/BaseOpenSimServer.cs
index aac9c45..a8f3a9e 100644
--- a/OpenSim/Framework/Servers/BaseOpenSimServer.cs
+++ b/OpenSim/Framework/Servers/BaseOpenSimServer.cs
@@ -294,7 +294,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 b018e57..b3e31a6 100644
--- a/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs
+++ b/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs
@@ -334,6 +334,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();
@@ -648,7 +649,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(
                         "[BASE HTTP SERVER]: Slow handling of {0} {1} {2} {3} {4} from {5} took {6}ms",
@@ -1532,10 +1533,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"))
             {
@@ -1580,25 +1611,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;
         }
@@ -1678,7 +1724,8 @@ namespace OpenSim.Framework.Servers.HttpServer
                 m_httpListener2.Start(64);
 
                 // Long Poll Service Manager with 3 worker threads a 25 second timeout for no events
-                m_PollServiceManager = new PollServiceRequestManager(this, 3, 25000);
+//                m_PollServiceManager = new PollServiceRequestManager(this, 3, 25000);
+                m_PollServiceManager = new PollServiceRequestManager(this, 4, 25000);
                 HTTPDRunning = true;
 
                 //HttpListenerContext context;
@@ -1712,7 +1759,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..d0a37d0 100644
--- a/OpenSim/Framework/Servers/HttpServer/PollServiceEventArgs.cs
+++ b/OpenSim/Framework/Servers/HttpServer/PollServiceEventArgs.cs
@@ -34,7 +34,7 @@ namespace OpenSim.Framework.Servers.HttpServer
     public delegate void RequestMethod(UUID requestID, Hashtable request);
     public delegate bool HasEventsMethod(UUID requestID, UUID pId);
 
-    public delegate Hashtable GetEventsMethod(UUID requestID, UUID pId, string request);
+    public delegate Hashtable GetEventsMethod(UUID requestID, UUID pId);
 
     public delegate Hashtable NoEventsMethod(UUID requestID, UUID pId);
 
@@ -45,17 +45,29 @@ 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,
+            Inventory = 2,
+            Texture = 3
+        }
 
         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 8d50151..4be8bf4 100644
--- a/OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs
+++ b/OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs
@@ -33,15 +33,20 @@ using log4net;
 using HttpServer;
 using OpenSim.Framework;
 using OpenSim.Framework.Monitoring;
+using Amib.Threading;
 
+
+/*
 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;
@@ -67,7 +72,6 @@ namespace OpenSim.Framework.Servers.HttpServer
                         ThreadPriority.Normal,
                         false,
                         true,
-                        null,
                         int.MaxValue);
             }
 
@@ -77,7 +81,6 @@ namespace OpenSim.Framework.Servers.HttpServer
                 ThreadPriority.Normal,
                 false,
                 true,
-                null,
                 1000 * 60 * 10);
         }
 
@@ -91,15 +94,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);
             }
         }
 
@@ -141,8 +146,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();
@@ -151,8 +157,274 @@ 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 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;
+            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,
+                        false,
+                        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.Normal)
+                {
+                    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)
+                    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_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()
+        {
+            while (m_running)
+            {
+                PollServiceHttpRequest req = m_requests.Dequeue(5000);
+
+                Watchdog.UpdateThread();
+                if (req != null)
+                {
+                    try
+                    {
+                        if (req.PollServiceArgs.HasEvents(req.RequestID, req.PollServiceArgs.Id))
+                        {
+                            Hashtable responsedata = req.PollServiceArgs.GetEvents(req.RequestID, req.PollServiceArgs.Id);
+
+                            if (responsedata == null)
+                                continue;
+
+                            if (req.PollServiceArgs.Type == PollServiceEventArgs.EventType.Normal)
+                            {
+                                try
+                                {
+                                    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
+                            {
+                                m_threadPool.QueueWorkItem(x =>
+                                {
+                                    try
+                                    {
+                                        DoHTTPGruntWork(m_server, req, responsedata);
+                                    }
+                                    catch (ObjectDisposedException) // Browser aborted before we could read body, server closed the stream
+                                    {
+                                        // Ignore it, no need to reply
+                                    }
+
+                                    return null;
+                                }, null);
+                            }
+                        }
+                        else
+                        {
+                            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 5adbcd1..1c529b6 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;
@@ -90,8 +92,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
                     {
@@ -162,4 +171,5 @@ namespace OpenSim.Framework.Servers.HttpServer
             }
         }
     }
-}
\ No newline at end of file
+}
+*/
\ No newline at end of file
diff --git a/OpenSim/Framework/Servers/Tests/OSHttpTests.cs b/OpenSim/Framework/Servers/Tests/OSHttpTests.cs
index dc4eb8f..4c2f586 100644
--- a/OpenSim/Framework/Servers/Tests/OSHttpTests.cs
+++ b/OpenSim/Framework/Servers/Tests/OSHttpTests.cs
@@ -75,6 +75,10 @@ namespace OpenSim.Framework.Servers.Tests
             /// </summary>
             public event EventHandler<RequestEventArgs> RequestReceived = delegate { };
 
+            public bool CanSend { get { return true; } }
+            public string RemoteEndPoint { get { return ""; } }
+            public string RemoteEndPointAddress { get { return ""; } }
+            public string RemoteEndPointPort { get { return ""; } }
         }
 
         public class TestHttpRequest: IHttpRequest
diff --git a/OpenSim/Framework/Servers/VersionInfo.cs b/OpenSim/Framework/Servers/VersionInfo.cs
index c9d9770..bb094ed 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.5";
+        private const string VERSION_NUMBER = "0.7.5CM";
         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);
         }