Add regression test for http inventory fetch.

Involved some restructuring to allow regression tests to dequeue inventory requests and perform poll responses synchronously rather than async

3 files changed, 122 insertions, 397 deletions

diff --git a/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs b/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs
index e1ae74e..e243002 100644
--- a/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs
+++ b/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs
@@ -113,7 +113,7 @@ namespace OpenSim.Framework.Servers.HttpServer
 
         protected IPAddress m_listenIPAddress = IPAddress.Any;
 
-        private PollServiceRequestManager m_PollServiceManager;
+        public PollServiceRequestManager PollServiceRequestManager { get; private set; }
 
         public uint SSLPort
         {
@@ -374,7 +374,7 @@ namespace OpenSim.Framework.Servers.HttpServer
             return true;
         }
 
-        private void OnRequest(object source, RequestEventArgs args)
+        public void OnRequest(object source, RequestEventArgs args)
         {
             RequestNumber++;
 
@@ -429,7 +429,7 @@ namespace OpenSim.Framework.Servers.HttpServer
                         psEvArgs.Request(psreq.RequestID, keysvals);
                     }
 
-                    m_PollServiceManager.Enqueue(psreq);
+                    PollServiceRequestManager.Enqueue(psreq);
                 }
                 else
                 {
@@ -1781,10 +1781,17 @@ namespace OpenSim.Framework.Servers.HttpServer
 
         public void Start()
         {
-            StartHTTP();
+            Start(true);
         }
 
-        private void StartHTTP()
+        /// <summary>
+        /// Start the http server
+        /// </summary>
+        /// <param name='processPollRequestsAsync'>
+        /// If true then poll responses are performed asynchronsly.
+        /// Option exists to allow regression tests to perform processing synchronously.
+        /// </param>
+        public void Start(bool performPollResponsesAsync)
         {
             m_log.InfoFormat(
                 "[BASE HTTP SERVER]: Starting {0} server on port {1}", UseSSL ? "HTTPS" : "HTTP", Port);
@@ -1822,8 +1829,9 @@ 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.Start();
+                PollServiceRequestManager = new PollServiceRequestManager(this, performPollResponsesAsync, 3, 25000);
+                PollServiceRequestManager.Start();
+
                 HTTPDRunning = true;
 
                 //HttpListenerContext context;
@@ -1892,7 +1900,7 @@ namespace OpenSim.Framework.Servers.HttpServer
 
             try
             {
-                m_PollServiceManager.Stop();
+                PollServiceRequestManager.Stop();
 
                 m_httpListener2.ExceptionThrown -= httpServerException;
                 //m_httpListener2.DisconnectHandler = null;
diff --git a/OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs b/OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs
index 6aa5907..456acb0 100644
--- a/OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs
+++ b/OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs
@@ -44,6 +44,20 @@ 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; }
+
         private readonly BaseHttpServer m_server;
 
         private BlockingQueue<PollServiceHttpRequest> m_requests = new BlockingQueue<PollServiceHttpRequest>();
@@ -52,48 +66,53 @@ namespace OpenSim.Framework.Servers.HttpServer
         private uint m_WorkerThreadCount = 0;
         private Thread[] m_workerThreads;
 
-        private bool m_running = true;
-
         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)
+        public PollServiceRequestManager(
+            BaseHttpServer pSrv, bool performResponsesAsync, uint pWorkerThreadCount, int pTimeout)
         {
             m_server = pSrv;
+            PerformResponsesAsync = performResponsesAsync;
             m_WorkerThreadCount = pWorkerThreadCount;
             m_workerThreads = new Thread[m_WorkerThreadCount];
         }
 
         public void Start()
         {
-            //startup worker threads
-            for (uint i = 0; i < m_WorkerThreadCount; i++)
+            IsRunning = true;
+
+            if (PerformResponsesAsync)
             {
-                m_workerThreads[i]
-                    = Watchdog.StartThread(
-                        PoolWorkerJob,
-                        string.Format("PollServiceWorkerThread{0}:{1}", i, m_server.Port),
-                        ThreadPriority.Normal,
-                        false,
-                        false,
-                        null,
-                        int.MaxValue);
-            }
+                //startup worker threads
+                for (uint i = 0; i < m_WorkerThreadCount; i++)
+                {
+                    m_workerThreads[i]
+                        = Watchdog.StartThread(
+                            PoolWorkerJob,
+                            string.Format("PollServiceWorkerThread{0}:{1}", i, m_server.Port),
+                            ThreadPriority.Normal,
+                            false,
+                            false,
+                            null,
+                            int.MaxValue);
+                }
 
-            Watchdog.StartThread(
-                this.CheckLongPollThreads,
-                string.Format("LongPollServiceWatcherThread:{0}", m_server.Port),
-                ThreadPriority.Normal,
-                false,
-                true,
-                null,
-                1000 * 60 * 10);
+                Watchdog.StartThread(
+                    this.CheckLongPollThreads,
+                    string.Format("LongPollServiceWatcherThread:{0}", m_server.Port),
+                    ThreadPriority.Normal,
+                    false,
+                    true,
+                    null,
+                    1000 * 60 * 10);
+            }
         }
 
         private void ReQueueEvent(PollServiceHttpRequest req)
         {
-            if (m_running)
+            if (IsRunning)
             {
                 // delay the enqueueing for 100ms. There's no need to have the event
                 // actively on the queue
@@ -109,7 +128,7 @@ namespace OpenSim.Framework.Servers.HttpServer
 
         public void Enqueue(PollServiceHttpRequest req)
         {
-            if (m_running)
+            if (IsRunning)
             {
                 if (req.PollServiceArgs.Type == PollServiceEventArgs.EventType.LongPoll)
                 {
@@ -129,7 +148,7 @@ namespace OpenSim.Framework.Servers.HttpServer
             // All other types of tasks (Inventory handlers, http-in, etc) don't have the long-poll nature,
             // so if they aren't ready to be served by a worker thread (no events), they are placed 
             // directly back in the "ready-to-serve" queue by the worker thread.
-            while (m_running)
+            while (IsRunning)
             {
                 Thread.Sleep(500); 
                 Watchdog.UpdateThread();
@@ -137,7 +156,7 @@ namespace OpenSim.Framework.Servers.HttpServer
 //                List<PollServiceHttpRequest> not_ready = new List<PollServiceHttpRequest>();
                 lock (m_longPollRequests)
                 {
-                    if (m_longPollRequests.Count > 0 && m_running)
+                    if (m_longPollRequests.Count > 0 && IsRunning)
                     {
                         List<PollServiceHttpRequest> ready = m_longPollRequests.FindAll(req =>
                             (req.PollServiceArgs.HasEvents(req.RequestID, req.PollServiceArgs.Id) || // there are events in this EQ
@@ -158,7 +177,7 @@ namespace OpenSim.Framework.Servers.HttpServer
 
         public void Stop()
         {
-            m_running = false;
+            IsRunning = false;
 //            m_timeout = -10000; // cause all to expire
             Thread.Sleep(1000); // let the world move
 
@@ -169,7 +188,7 @@ namespace OpenSim.Framework.Servers.HttpServer
 
             lock (m_longPollRequests)
             {
-                if (m_longPollRequests.Count > 0 && m_running)
+                if (m_longPollRequests.Count > 0 && IsRunning)
                     m_longPollRequests.ForEach(req => m_requests.Enqueue(req));
             }
 
@@ -194,68 +213,82 @@ namespace OpenSim.Framework.Servers.HttpServer
 
         private void PoolWorkerJob()
         {
-            while (m_running)
+            while (IsRunning)
             {
-                PollServiceHttpRequest req = m_requests.Dequeue(5000);
-                //m_log.WarnFormat("[YYY]: Dequeued {0}", (req == null ? "null" : req.PollServiceArgs.Type.ToString()));
-
                 Watchdog.UpdateThread();
-                if (req != null)
+                WaitPerformResponse();
+            }
+        }
+
+        public void WaitPerformResponse()
+        {
+            PollServiceHttpRequest req = m_requests.Dequeue(5000);
+//            m_log.DebugFormat("[YYY]: Dequeued {0}", (req == null ? "null" : req.PollServiceArgs.Type.ToString()));
+
+            if (req != null)
+            {
+                try
                 {
-                    try
+                    if (req.PollServiceArgs.HasEvents(req.RequestID, req.PollServiceArgs.Id))
                     {
-                        if (req.PollServiceArgs.HasEvents(req.RequestID, req.PollServiceArgs.Id))
-                        {
-                            Hashtable responsedata = req.PollServiceArgs.GetEvents(req.RequestID, req.PollServiceArgs.Id);
+                        Hashtable responsedata = req.PollServiceArgs.GetEvents(req.RequestID, req.PollServiceArgs.Id);
 
-                            if (responsedata == null)
-                                continue;
+                        if (responsedata == null)
+                            return;
 
-                            if (req.PollServiceArgs.Type == PollServiceEventArgs.EventType.LongPoll) // This is the event queue
+                        // 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) 
+                        {
+                            try
+                            {
+                                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 =>
                             {
                                 try
                                 {
                                     req.DoHTTPGruntWork(m_server, responsedata);
                                 }
-                                catch (ObjectDisposedException) // Browser aborted before we could read body, server closed the stream
+                                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 =>
+                                catch (Exception e)
                                 {
-                                    try
-                                    {
-                                        req.DoHTTPGruntWork(m_server, responsedata);
-                                    }
-                                    catch (ObjectDisposedException) // Browser aborted before we could read body, server closed the stream
-                                    {
-                                        // Ignore it, no need to reply
-                                    }
-
-                                    return null;
-                                }, null);
-                            }
+                                    m_log.Error(e);
+                                }
+
+                                return null;
+                            }, null);
+                        }
+                    }
+                    else
+                    {
+                        if ((Environment.TickCount - req.RequestTime) > req.PollServiceArgs.TimeOutms)
+                        {
+                            req.DoHTTPGruntWork(
+                                m_server, req.PollServiceArgs.NoEvents(req.RequestID, req.PollServiceArgs.Id));
                         }
                         else
                         {
-                            if ((Environment.TickCount - req.RequestTime) > req.PollServiceArgs.TimeOutms)
-                            {
-                                req.DoHTTPGruntWork(
-                                    m_server, req.PollServiceArgs.NoEvents(req.RequestID, req.PollServiceArgs.Id));
-                            }
-                            else
-                            {
-                                ReQueueEvent(req);
-                            }
+                            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());
                 }
             }
         }
diff --git a/OpenSim/Framework/Servers/Tests/OSHttpTests.cs b/OpenSim/Framework/Servers/Tests/OSHttpTests.cs
index 5b912b4..5c0e0df 100644
--- a/OpenSim/Framework/Servers/Tests/OSHttpTests.cs
+++ b/OpenSim/Framework/Servers/Tests/OSHttpTests.cs
@@ -41,323 +41,7 @@ namespace OpenSim.Framework.Servers.Tests
 {
     [TestFixture]
     public class OSHttpTests : OpenSimTestCase
-    {
-        // we need an IHttpClientContext for our tests
-        public class TestHttpClientContext: IHttpClientContext
-        {
-            private bool _secured;
-            public bool IsSecured
-            {
-                get { return _secured; }
-            }
-            public bool Secured
-            {
-                get { return _secured; }
-            }
-
-            public TestHttpClientContext(bool secured)
-            {
-                _secured = secured;
-            }
-
-            public void Disconnect(SocketError error) {}
-            public void Respond(string httpVersion, HttpStatusCode statusCode, string reason, string body) {}
-            public void Respond(string httpVersion, HttpStatusCode statusCode, string reason) {}
-            public void Respond(string body) {}
-            public void Send(byte[] buffer) {}
-            public void Send(byte[] buffer, int offset, int size) {}
-            public void Respond(string httpVersion, HttpStatusCode statusCode, string reason, string body, string contentType) {}
-            public void Close() { }
-            public bool EndWhenDone { get { return false;} set { return;}}
-
-            public HTTPNetworkContext GiveMeTheNetworkStreamIKnowWhatImDoing()
-            {
-                return new HTTPNetworkContext();
-            }
-
-            public event EventHandler<DisconnectedEventArgs> Disconnected = delegate { };
-            /// <summary>
-            /// A request have been received in the context.
-            /// </summary>
-            public event EventHandler<RequestEventArgs> RequestReceived = delegate { };
-
-        }
-
-        public class TestHttpRequest: IHttpRequest
-        {
-            private string _uriPath;
-            public bool BodyIsComplete 
-            { 
-                get { return true; } 
-            }
-            public string[] AcceptTypes 
-            { 
-                get {return _acceptTypes; }
-            }
-            private string[] _acceptTypes;
-            public Stream Body 
-            { 
-                get { return _body; } 
-                set { _body = value;} 
-            }
-            private Stream _body;
-            public ConnectionType Connection 
-            { 
-                get { return _connection; }
-                set { _connection = value; }
-            }
-            private ConnectionType _connection;
-            public int ContentLength 
-            { 
-                get { return _contentLength; }
-                set { _contentLength = value; }
-            }
-            private int _contentLength;
-            public NameValueCollection Headers 
-            { 
-                get { return _headers; }
-            }
-            private NameValueCollection _headers = new NameValueCollection();
-            public string HttpVersion 
-            { 
-                get { return _httpVersion; }
-                set { _httpVersion = value; }
-            }
-            private string _httpVersion = null;
-            public string Method 
-            { 
-                get { return _method; }
-                set { _method = value; }
-            }
-            private string _method = null;
-            public HttpInput QueryString 
-            { 
-                get { return _queryString;  }
-            }
-            private HttpInput _queryString = null;
-            public Uri Uri 
-            { 
-                get { return _uri; }
-                set { _uri = value; } 
-            }
-            private Uri _uri = null;
-            public string[] UriParts 
-            { 
-                get { return _uri.Segments; }
-            }
-            public HttpParam Param 
-            { 
-                get { return null; } 
-            }
-            public HttpForm Form 
-            { 
-                get { return null; } 
-            }
-            public bool IsAjax 
-            { 
-                get { return false; } 
-            }
-            public RequestCookies Cookies 
-            { 
-                get { return null; } 
-            }
-
-            public TestHttpRequest() {}
-
-            public TestHttpRequest(string contentEncoding, string contentType, string userAgent, 
-                                   string remoteAddr, string remotePort, string[] acceptTypes,
-                                   ConnectionType connectionType, int contentLength, Uri uri) 
-            {
-                _headers["content-encoding"] = contentEncoding;
-                _headers["content-type"] = contentType;
-                _headers["user-agent"] = userAgent;
-                _headers["remote_addr"] = remoteAddr;
-                _headers["remote_port"] = remotePort;
-
-                _acceptTypes = acceptTypes;
-                _connection = connectionType;
-                _contentLength = contentLength;
-                _uri = uri;
-            }
-
-            public void DecodeBody(FormDecoderProvider providers) {}
-            public void SetCookies(RequestCookies cookies) {}
-            public void AddHeader(string name, string value)
-            {
-                _headers.Add(name, value);
-            }
-            public int AddToBody(byte[] bytes, int offset, int length) 
-            {
-                return 0;
-            }
-            public void Clear() {}
-
-            public object Clone()
-            {
-                TestHttpRequest clone = new TestHttpRequest();
-                clone._acceptTypes = _acceptTypes;
-                clone._connection = _connection;
-                clone._contentLength = _contentLength;
-                clone._uri = _uri;
-                clone._headers = new NameValueCollection(_headers);
-
-                return clone;
-            }
-            public IHttpResponse CreateResponse(IHttpClientContext context)
-            {
-                return new HttpResponse(context, this);
-            }
-            /// <summary>
-            /// Path and query (will be merged with the host header) and put in Uri
-            /// </summary>
-            /// <see cref="Uri"/>
-            public string UriPath
-            {
-                get { return _uriPath; }
-                set
-                {
-                    _uriPath = value;
-                   
-                }
-            }
-
-        }
-
-        public class TestHttpResponse: IHttpResponse
-        {
-            public Stream Body 
-            {
-                get { return _body; }
-
-                set { _body = value; }
-            }
-            private Stream _body;
-
-            public string ProtocolVersion 
-            { 
-                get { return _protocolVersion; }
-                set { _protocolVersion = value; }
-            }
-            private string _protocolVersion;
-
-            public bool Chunked 
-            {
-                get { return _chunked; }
-
-                set { _chunked = value; }
-            }
-            private bool _chunked;
-
-            public ConnectionType Connection 
-            {
-                get { return _connection; }
-
-                set { _connection = value; }
-            }
-            private ConnectionType _connection;
-
-            public Encoding Encoding 
-            {
-                get { return _encoding; }
-
-                set { _encoding = value; }
-            }
-            private Encoding _encoding;
-
-            public int KeepAlive 
-            {
-                get { return _keepAlive; }
-
-                set { _keepAlive = value; }
-            }
-            private int _keepAlive;
-
-            public HttpStatusCode Status 
-            {
-                get { return _status; }
-
-                set { _status = value; }
-            }
-            private HttpStatusCode _status;
-
-            public string Reason 
-            {
-                get { return _reason; }
-
-                set { _reason = value; }
-            }
-            private string _reason;
-
-            public long ContentLength 
-            {
-                get { return _contentLength; }
-
-                set { _contentLength = value; }
-            }
-            private long _contentLength;
-
-            public string ContentType 
-            {
-                get { return _contentType; }
-
-                set { _contentType = value; }
-            }
-            private string _contentType;
-
-            public bool HeadersSent 
-            {
-                get { return _headersSent; }
-            }
-            private bool _headersSent;
-
-            public bool Sent 
-            {
-                get { return _sent; }
-            }
-            private bool _sent;
-
-            public ResponseCookies Cookies 
-            {
-                get { return _cookies; }
-            }
-            private ResponseCookies _cookies = null;
-
-            public TestHttpResponse()
-            {
-                _headersSent = false;
-                _sent = false;
-            }
-
-            public void AddHeader(string name, string value) {}
-            public void Send() 
-            {
-                if (!_headersSent) SendHeaders();
-                if (_sent) throw new InvalidOperationException("stuff already sent");
-                _sent = true;
-            }
-
-            public void SendBody(byte[] buffer, int offset, int count) 
-            {
-                if (!_headersSent) SendHeaders();
-                _sent = true;
-            }
-            public void SendBody(byte[] buffer) 
-            {
-                if (!_headersSent) SendHeaders();
-                _sent = true;
-            }
-
-            public void SendHeaders() 
-            {
-                if (_headersSent) throw new InvalidOperationException("headers already sent");
-                _headersSent = true;
-            }
-
-            public void Redirect(Uri uri) {}
-            public void Redirect(string url) {}
-        }
-
-        
+    {       
         public OSHttpRequest req0;
         public OSHttpRequest req1;
 
@@ -429,4 +113,4 @@ namespace OpenSim.Framework.Servers.Tests
             Assert.That(rsp0.ContentType, Is.EqualTo("text/xml"));
         }
     }
-}
+}
\ No newline at end of file