4 files changed, 383 insertions, 20 deletions

diff --git a/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs b/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs
index eb7c578..74954cc 100644
--- a/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs
+++ b/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs
@@ -395,6 +395,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();
@@ -736,7 +737,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",
@@ -1657,10 +1658,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"))
             {
@@ -1705,25 +1736,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;
         }
@@ -1804,7 +1850,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;
@@ -1838,7 +1885,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 3079a7e..c19ac32 100644
--- a/OpenSim/Framework/Servers/HttpServer/PollServiceEventArgs.cs
+++ b/OpenSim/Framework/Servers/HttpServer/PollServiceEventArgs.cs
@@ -52,7 +52,9 @@ namespace OpenSim.Framework.Servers.HttpServer
         {
             Normal = 0,
             LslHttp = 1,
-            Inventory = 2
+            Inventory = 2,
+            Texture = 3, 
+            Mesh = 4
         }
 
         public PollServiceEventArgs(
diff --git a/OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs b/OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs
index a5380c1..7628e23 100644
--- a/OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs
+++ b/OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs
@@ -34,6 +34,143 @@ 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;
+        private volatile bool m_running = true;
+        private int m_pollTimeout;
+
+        public PollServiceRequestManager(BaseHttpServer pSrv, uint pWorkerThreadCount, int pTimeout)
+        {
+            m_server = pSrv;
+            m_WorkerThreadCount = pWorkerThreadCount;
+            m_pollTimeout = pTimeout;
+        }
+
+        public void Start()
+        {
+            m_running = true;
+            m_workerThreads = new Thread[m_WorkerThreadCount];
+            m_PollServiceWorkerThreads = new PollServiceWorkerThread[m_WorkerThreadCount];
+
+            //startup worker threads
+            for (uint i = 0; i < m_WorkerThreadCount; i++)
+            {
+                m_PollServiceWorkerThreads[i] = new PollServiceWorkerThread(m_server, m_pollTimeout);
+                m_PollServiceWorkerThreads[i].ReQueue += ReQueueEvent;
+
+                m_workerThreads[i]
+                    = Watchdog.StartThread(
+                        m_PollServiceWorkerThreads[i].ThreadStart,
+                        String.Format("PollServiceWorkerThread{0}", i),
+                        ThreadPriority.Normal,
+                        false,
+                        true,
+                        int.MaxValue);
+            }
+
+            Watchdog.StartThread(
+                this.ThreadStart,
+                "PollServiceWatcherThread",
+                ThreadPriority.Normal,
+                false,
+                true,
+                1000 * 60 * 10);
+        }
+
+        internal void ReQueueEvent(PollServiceHttpRequest req)
+        {
+            // Do accounting stuff here
+            Enqueue(req);
+        }
+
+        public void Enqueue(PollServiceHttpRequest req)
+        {
+            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();
+            }
+        }
+
+        private void ProcessQueuedRequests()
+        {
+            lock (m_requests)
+            {
+                if (m_requests.Count == 0)
+                    return;
+
+//                m_log.DebugFormat("[POLL SERVICE REQUEST MANAGER]: Processing {0} requests", m_requests.Count);
+
+                int reqperthread = (int) (m_requests.Count/m_WorkerThreadCount) + 1;
+
+                // For Each WorkerThread
+                for (int tc = 0; tc < m_WorkerThreadCount && m_requests.Count > 0; tc++)
+                {
+                    //Loop over number of requests each thread handles.
+                    for (int i = 0; i < reqperthread && m_requests.Count > 0; i++)
+                    {
+                        try
+                        {
+                            m_PollServiceWorkerThreads[tc].Enqueue((PollServiceHttpRequest)m_requests.Dequeue());
+                        }
+                        catch (InvalidOperationException)
+                        {
+                            // The queue is empty, we did our calculations wrong!
+                            return;
+                        }
+                        
+                    }
+                }
+            }
+            
+        }
+
+        public void Stop()
+        {
+            m_running = false;
+
+            foreach (object o in m_requests)
+            {
+                PollServiceHttpRequest req = (PollServiceHttpRequest) o;
+                m_server.DoHTTPGruntWork(
+                    req.PollServiceArgs.NoEvents(req.RequestID, req.PollServiceArgs.Id),
+                    new OSHttpResponse(new HttpResponse(req.HttpContext, req.Request), req.HttpContext));
+            }
+
+            m_requests.Clear();
+
+            foreach (Thread t in m_workerThreads)
+            {
+                t.Abort();
+            }
+        }
+    }
+}
+ */
+
 using System.IO;
 using System.Text;
 using System.Collections.Generic;
diff --git a/OpenSim/Framework/Servers/HttpServer/PollServiceWorkerThread.cs b/OpenSim/Framework/Servers/HttpServer/PollServiceWorkerThread.cs
new file mode 100644
index 0000000..1c529b6
--- /dev/null
+++ b/OpenSim/Framework/Servers/HttpServer/PollServiceWorkerThread.cs
@@ -0,0 +1,175 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* Ubit work moved to PollServiceRequestManager
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using HttpServer;
+using OpenMetaverse;
+using System.Reflection;
+using log4net;
+using OpenSim.Framework.Monitoring;
+
+namespace OpenSim.Framework.Servers.HttpServer
+{
+    public delegate void ReQueuePollServiceItem(PollServiceHttpRequest req);
+    
+    public class PollServiceWorkerThread
+    {
+        private static readonly ILog m_log =
+                LogManager.GetLogger(
+                MethodBase.GetCurrentMethod().DeclaringType);
+
+        public event ReQueuePollServiceItem ReQueue;
+
+        private readonly BaseHttpServer m_server;
+        private BlockingQueue<PollServiceHttpRequest> m_request;
+        private bool m_running = true;
+        private int m_timeout = 250;
+
+        public PollServiceWorkerThread(BaseHttpServer pSrv, int pTimeout)
+        {
+            m_request = new BlockingQueue<PollServiceHttpRequest>();
+            m_server = pSrv;
+            m_timeout = pTimeout;
+        }
+
+        public void ThreadStart()
+        {
+            Run();
+        }
+
+        public void Run()
+        {
+            while (m_running)
+            {
+                PollServiceHttpRequest req = m_request.Dequeue();
+
+                Watchdog.UpdateThread();
+                
+                try
+                {
+                    if (req.PollServiceArgs.HasEvents(req.RequestID, req.PollServiceArgs.Id))
+                    {
+                        StreamReader str;
+                        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
+                        }
+                    }
+                    else
+                    {
+                        if ((Environment.TickCount - req.RequestTime) > m_timeout)
+                        {
+                            DoHTTPGruntWork(
+                                m_server,
+                                req,
+                                req.PollServiceArgs.NoEvents(req.RequestID, req.PollServiceArgs.Id));
+                        }
+                        else
+                        {
+                            ReQueuePollServiceItem reQueueItem = ReQueue;
+                            if (reQueueItem != null)
+                                reQueueItem(req);
+                        }
+                    }
+                }
+                catch (Exception e)
+                {
+                    m_log.ErrorFormat("Exception in poll service thread: " + e.ToString());
+                }
+            }
+        }
+
+        internal void Enqueue(PollServiceHttpRequest pPollServiceHttpRequest)
+        {
+            m_request.Enqueue(pPollServiceHttpRequest);
+        }
+
+        /// <summary>
+        /// FIXME: This should be part of BaseHttpServer
+        /// </summary>
+        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));
+                }
+            }
+        }
+    }
+}
+*/
\ No newline at end of file