C# HttpServer.StopListening方法代码示例

        public void TestAbortedEndReceive()
        {
            var instance = new HttpServer(ProgramServersTests.Port)
            {
                Handler = new UrlResolver(
                    new UrlMapping(req => HttpResponse.PlainText("bunch of text"), path: "/static")
                ).Handle
            };
            try
            {
                instance.StartListening();

                TcpClient cl = new TcpClient();
                cl.Connect("localhost", ProgramServersTests.Port);
                cl.ReceiveTimeout = 1000; // 1 sec
                Socket sck = cl.Client;
                sck.Send("GET /static HTTP/1.1\r\nHost: localhost\r\n".ToUtf8());
                Thread.Sleep(500);
                instance.StopListening(true); // server must not throw after this; that’s the point of the test
                Assert.IsTrue(instance.ShutdownComplete.WaitOne(TimeSpan.FromSeconds(1))); // must shut down within at most 1 second
                sck.Close();
            }
            finally
            {
                instance.StopListening(brutal: true);
            }
        }

        public void TestClientIPAddress()
        {
            HttpRequest request = null;
            var instance = new HttpServer(ProgramServersTests.Port)
            {
                Handler = new UrlResolver(
                    new UrlMapping(req => { request = req; return HttpResponse.PlainText("blah"); }, path: "/static")
                ).Handle
            };
            try
            {
                instance.StartListening();

                TcpClient cl = new TcpClient();
                cl.Connect("localhost", ProgramServersTests.Port);
                cl.ReceiveTimeout = 1000; // 1 sec
                Socket sck = cl.Client;

                sck.Send("GET /static HTTP/1.1\r\nHost: localhost\r\nConnection: keep-alive\r\n\r\n".ToUtf8());
                TestUtil.ReadResponseUntilContent(sck);
                Assert.IsTrue(IPAddress.IsLoopback(request.ClientIPAddress));
                Assert.IsTrue(IPAddress.IsLoopback(request.SourceIP.Address));
                Assert.IsNull(request.Headers["X-Forwarded-For"]);

                sck.Send("GET /static HTTP/1.1\r\nHost: localhost\r\nConnection: keep-alive\r\nX-Forwarded-For: 12.34.56.78\r\n\r\n".ToUtf8());
                TestUtil.ReadResponseUntilContent(sck);
                Assert.AreEqual(IPAddress.Parse("12.34.56.78"), request.ClientIPAddress);
                Assert.IsTrue(IPAddress.IsLoopback(request.SourceIP.Address));
                Assert.IsNotNull(request.Headers["X-Forwarded-For"]);

                sck.Send("GET /static HTTP/1.1\r\nHost: localhost\r\nConnection: keep-alive\r\nX-Forwarded-For: 12.34.56.78:63125\r\n\r\n".ToUtf8());
                TestUtil.ReadResponseUntilContent(sck);
                Assert.AreEqual(IPAddress.Parse("12.34.56.78"), request.ClientIPAddress);
                Assert.IsTrue(IPAddress.IsLoopback(request.SourceIP.Address));
                Assert.IsNotNull(request.Headers["X-Forwarded-For"]);

                sck.Send("GET /static HTTP/1.1\r\nHost: localhost\r\nConnection: keep-alive\r\nX-Forwarded-For: 2a00:1450:400c:c01::93, 12.34.56.78\r\n\r\n".ToUtf8());
                TestUtil.ReadResponseUntilContent(sck);
                Assert.AreEqual(IPAddress.Parse("2a00:1450:400c:c01::93"), request.ClientIPAddress);
                Assert.AreEqual(IPAddress.Parse("2a00:1450:400c:c01::93"), request.Headers.XForwardedFor[0]);
                Assert.AreEqual(IPAddress.Parse("12.34.56.78"), request.Headers.XForwardedFor[1]);
                Assert.IsTrue(IPAddress.IsLoopback(request.SourceIP.Address));

                sck.Send("GET /static HTTP/1.1\r\nHost: localhost\r\nConnection: keep-alive\r\nX-Forwarded-For: [2a00:1450:400c:c01::93]:63125, 12.34.56.78:63125\r\n\r\n".ToUtf8());
                TestUtil.ReadResponseUntilContent(sck);
                Assert.AreEqual(IPAddress.Parse("2a00:1450:400c:c01::93"), request.ClientIPAddress);
                Assert.AreEqual(IPAddress.Parse("2a00:1450:400c:c01::93"), request.Headers.XForwardedFor[0]);
                Assert.AreEqual(IPAddress.Parse("12.34.56.78"), request.Headers.XForwardedFor[1]);
                Assert.IsTrue(IPAddress.IsLoopback(request.SourceIP.Address));

                sck.Close();
                instance.StopListening(true); // server must not throw after this; that’s the point of the test
            }
            finally
            {
                instance.StopListening(brutal: true);
            }
        }

        public void TestMidResponseSocketClosure()
        {
            var instance = new HttpServer(ProgramServersTests.Port)
            {
                Handler = new UrlResolver(
                    new UrlMapping(req => { return HttpResponse.Create(enumInfinite(), "text/plain"); }, path: "/infinite-and-slow")
                ).Handle
            };
            try
            {
                instance.StartListening();

                ThreadStart thread = () =>
                {
                    for (int i = 0; i < 20; i++)
                    {
                        TcpClient cl = new TcpClient();
                        cl.Connect("localhost", ProgramServersTests.Port);
                        cl.ReceiveTimeout = 1000; // 1 sec
                        Socket sck = cl.Client;
                        sck.Send("GET /infinite-and-slow HTTP/1.1\r\nHost: localhost\r\nConnection: keep-alive\r\n\r\n".ToUtf8());
                        Thread.Sleep(100);
                        sck.Close();
                        GC.Collect();
                    }
                };
                var threads = Enumerable.Range(0, 10).Select(_ => new Thread(thread)).ToList();
                foreach (var t in threads)
                    t.Start();
                foreach (var t in threads)
                    t.Join();

                instance.StopListening(true); // server must not throw after this; that’s the point of the test
            }
            finally
            {
                instance.StopListening(brutal: true);
            }
        }

        public void TestKeepaliveShutdownGentle()
        {
            var instance = new HttpServer(ProgramServersTests.Port)
            {
                Handler = new UrlResolver(
                    new UrlMapping(req => HttpResponse.PlainText("bunch of text"), path: "/static")
                ).Handle
            };
            try
            {
                instance.StartListening();

                TcpClient cl = new TcpClient();
                cl.Connect("localhost", ProgramServersTests.Port);
                cl.ReceiveTimeout = 1000; // 1 sec
                Socket sck = cl.Client;
                sck.Send("GET /static HTTP/1.1\r\nHost: localhost\r\n".ToUtf8());
                Thread.Sleep(500);
                Assert.AreEqual(1, instance.Stats.ActiveHandlers);
                sck.Send("Connection: keep-alive\r\n\r\n".ToUtf8());

                TestUtil.ReadResponseUntilContent(sck);
                Thread.Sleep(500);
                Assert.AreEqual(0, instance.Stats.ActiveHandlers);
                Assert.AreEqual(1, instance.Stats.KeepAliveHandlers);
                instance.StopListening();
                Assert.IsTrue(instance.ShutdownComplete.WaitOne(TimeSpan.FromSeconds(1))); // must shut down within at most 1 second
                Assert.AreEqual(0, instance.Stats.ActiveHandlers);
                Assert.AreEqual(0, instance.Stats.KeepAliveHandlers);
                sck.Close();
            }
            finally
            {
                instance.StopListening(brutal: true);
            }
        }

//.........这里部分代码省略.........
                testRequest("GET test #8", store, "GET /64kfile HTTP/1.1\r\nHost: localhost\r\nRange: bytes=65-65,67-67\r\n\r\n", (headers, content) =>
                {
                    Assert.AreEqual("HTTP/1.1 206 Partial Content", headers[0]);
                    Assert.IsTrue(headers.Contains("Accept-Ranges: bytes"));
                    Assert.IsTrue(headers.Any(x => Regex.IsMatch(x, @"^Content-Type: multipart/byteranges; boundary=[0-9A-F]+$")));
                    string boundary = headers.First(x => Regex.IsMatch(x, @"^Content-Type: multipart/byteranges; boundary=[0-9A-F]+$")).Substring(45);
                    Assert.IsTrue(headers.Contains("Content-Length: 284"));
                    byte[] expectedContent = ("--" + boundary + "\r\nContent-Range: bytes 65-65/65536\r\n\r\nA\r\n--" + boundary + "\r\nContent-Range: bytes 67-67/65536\r\n\r\nC\r\n--" + boundary + "--\r\n").ToUtf8();
                    Assert.AreEqual(expectedContent.Length, content.Length);
                    for (int i = 0; i < expectedContent.Length; i++)
                        Assert.AreEqual(expectedContent[i], content[i]);
                });

                testRequest("GET test #9", store, "GET /64kfile HTTP/1.1\r\nHost: localhost\r\nAccept-Encoding: gzip\r\n\r\n", (headers, content) =>
                {
                    Assert.AreEqual("HTTP/1.1 200 OK", headers[0]);
                    Assert.IsTrue(headers.Contains("Accept-Ranges: bytes"));
                    Assert.IsTrue(headers.Contains("Content-Type: application/octet-stream"));
                    Assert.IsTrue(headers.Contains("Content-Encoding: gzip"));
                    Assert.IsTrue(headers.Any(h => h.StartsWith("Content-Length")));
                    GZipStream gz = new GZipStream(new MemoryStream(content), CompressionMode.Decompress);
                    for (int i = 0; i < 65536; i++)
                        Assert.AreEqual(i % 256, gz.ReadByte());
                    Assert.AreEqual(-1, gz.ReadByte());
                });

                testRequest("GET test #10", store, "GET /dynamic HTTP/1.1\r\n\r\n", (headers, content) => Assert.AreEqual("HTTP/1.1 400 Bad Request", headers[0]));
                testRequest("GET test #11", store, "INVALID /request HTTP/1.1\r\n\r\n", (headers, content) => Assert.AreEqual("HTTP/1.1 400 Bad Request", headers[0]));
                testRequest("GET test #12", store, "GET  HTTP/1.1\r\n\r\n", (headers, content) => Assert.AreEqual("HTTP/1.1 400 Bad Request", headers[0]));
                testRequest("GET test #13", store, "!\r\n\r\n", (headers, content) => Assert.AreEqual("HTTP/1.1 400 Bad Request", headers[0]));
            }
            finally
            {
                instance.StopListening();
            }

            foreach (var storeFileUploadInFileAtSize in new[] { 5, 1024 })
            {
                instance = new HttpServer(ProgramServersTests.Port, new HttpServerOptions { StoreFileUploadInFileAtSize = storeFileUploadInFileAtSize })
                {
                    Handler = new UrlResolver(
                        new UrlMapping(handlerStatic, path: "/static"),
                        new UrlMapping(handlerDynamic, path: "/dynamic")
                    ).Handle
                };
                try
                {
                    instance.StartListening();

                    testRequest("POST test #1", storeFileUploadInFileAtSize, "POST /static HTTP/1.1\r\nHost: localhost\r\nContent-Length: 48\r\nContent-Type: application/x-www-form-urlencoded\r\n\r\nx=y&z=%20&zig=%3D%3d&a[]=1&a%5B%5D=2&%61%5b%5d=3", (headers, content) =>
                    {
                        Assert.AreEqual("HTTP/1.1 200 OK", headers[0]);
                        Assert.IsTrue(headers.Contains("Content-Type: text/plain; charset=utf-8"));
                        Assert.IsTrue(headers.Contains("Content-Length: 66"));
                        Assert.AreEqual("\nPOST:\nx => [\"y\"]\nz => [\" \"]\nzig => [\"==\"]\na[] => [\"1\", \"2\", \"3\"]\n", content.FromUtf8());
                    });

                    testRequest("POST test #2", storeFileUploadInFileAtSize, "POST /dynamic HTTP/1.1\r\nHost: localhost\r\nContent-Length: 20\r\nContent-Type: application/x-www-form-urlencoded\r\n\r\nx=y&z=%20&zig=%3D%3d", (headers, content) =>
                    {
                        Assert.AreEqual("HTTP/1.1 200 OK", headers[0]);
                        Assert.IsTrue(headers.Contains("Content-Type: text/plain; charset=utf-8"));
                        Assert.IsFalse(headers.Any(x => x.ToLowerInvariant().StartsWith("content-length:")));
                        Assert.IsFalse(headers.Any(x => x.ToLowerInvariant().StartsWith("accept-ranges:")));
                        Assert.AreEqual("\nPOST:\nx => [\"y\"]\nz => [\" \"]\nzig => [\"==\"]\n", content.FromUtf8());
                    });

        public void TestKeepaliveAndChunked()
        {
            HttpServer instance = new HttpServer(ProgramServersTests.Port) { Handler = handlerDynamic };
            try
            {
                instance.StartListening();
                Thread.Sleep(100);
                Assert.AreEqual(0, instance.Stats.ActiveHandlers);
                Assert.AreEqual(0, instance.Stats.KeepAliveHandlers);

                TcpClient cl = new TcpClient();
                cl.Connect("localhost", ProgramServersTests.Port);
                cl.ReceiveTimeout = 1000; // 1 sec
                Socket sck = cl.Client;

                // Run three consecutive requests within the same connection using Connection: Keep-alive
                keepaliveAndChunkedPrivate(sck);
                Thread.Sleep(300);
                Assert.AreEqual(0, instance.Stats.ActiveHandlers);
                Assert.AreEqual(1, instance.Stats.KeepAliveHandlers);
                keepaliveAndChunkedPrivate(sck);
                Thread.Sleep(300);
                Assert.AreEqual(0, instance.Stats.ActiveHandlers);
                Assert.AreEqual(1, instance.Stats.KeepAliveHandlers);
                keepaliveAndChunkedPrivate(sck);
                Thread.Sleep(300);
                Assert.AreEqual(0, instance.Stats.ActiveHandlers);
                Assert.AreEqual(1, instance.Stats.KeepAliveHandlers);

                instance.StopListening();
                Assert.IsTrue(instance.ShutdownComplete.WaitOne(TimeSpan.FromSeconds(1)));
                Assert.AreEqual(0, instance.Stats.ActiveHandlers);
                Assert.AreEqual(0, instance.Stats.KeepAliveHandlers);

                sck.Close();
                cl.Close();
            }
            finally
            {
                instance.StopListening(true);
            }
        }

        public void TestDomainCase()
        {
            var instance = new HttpServer(ProgramServersTests.Port, new HttpServerOptions { OutputExceptionInformation = true });
            try
            {
                bool ok;
                instance.Handler = new UrlResolver(
                    new UrlMapping(domain: "example.com", handler: req => { ok = true; return HttpResponse.Empty(); })
                ).Handle;

                var getResponse = Ut.Lambda((string host) =>
                {
                    TcpClient cl = new TcpClient();
                    cl.Connect("localhost", ProgramServersTests.Port);
                    cl.ReceiveTimeout = 1000; // 1 sec
                    cl.Client.Send(("GET /static HTTP/1.1\r\nHost: " + host + "\r\nConnection: close\r\n\r\n").ToUtf8());
                    var response = Encoding.UTF8.GetString(cl.Client.ReceiveAllBytes());
                    cl.Close();
                    var code = (HttpStatusCode) int.Parse(response.Substring("HTTP/1.1 ".Length, 3));
                    var parts = response.Split("\r\n\r\n");
                    return Tuple.Create(code, parts[1]);
                });

                instance.StartListening();

                ok = false;
                getResponse("blah.com");
                Assert.IsFalse(ok);

                ok = false;
                getResponse("www.example.com");
                Assert.IsTrue(ok);

                ok = false;
                getResponse("WWW.EXAMPLE.COM");
                Assert.IsTrue(ok);

                ok = false;
                getResponse("www.exAmple.com");
                Assert.IsTrue(ok);
            }
            finally
            {
                instance.StopListening(brutal: true);
            }
        }

//.........这里部分代码省略.........
                    var parts = response.Split("\r\n\r\n");
                    return Tuple.Create(code, parts[1]);
                });

                // Test that we get a 404 response with no handlers
                var resp = getResponse();
                Assert.AreEqual(HttpStatusCode._404_NotFound, resp.Item1);

                // Test that having only an error handler works as expected
                instance.ErrorHandler = (req, err) => { return HttpResponse.Create("blah", "text/plain", HttpStatusCode._407_ProxyAuthenticationRequired); };
                resp = getResponse();
                Assert.AreEqual(HttpStatusCode._407_ProxyAuthenticationRequired, resp.Item1);
                Assert.AreEqual("blah", resp.Item2);

                // Test that having no error handler uses the default one
                instance.ErrorHandler = null;
                instance.Handler = req => { throw new HttpException(HttpStatusCode._305_UseProxy); };
                resp = getResponse();
                Assert.AreEqual(HttpStatusCode._305_UseProxy, resp.Item1);

                // Test that the exception and request are passed on to the error handler
                HttpRequest storedReq = null;
                Exception storedEx = null;
                bool ok = false;
                instance.Handler = req => { storedEx = new HttpException(HttpStatusCode._402_PaymentRequired); storedReq = req; throw storedEx; };
                instance.ErrorHandler = (req, ex) => { ok = object.ReferenceEquals(req, storedReq) && object.ReferenceEquals(ex, storedEx); return HttpResponse.Create("blah", "text/plain"); };
                resp = getResponse();
                Assert.IsTrue(ok);

                // Test that exception in error handler invokes the default one, and uses the *original* status code
                instance.Handler = req => { throw new HttpException(HttpStatusCode._201_Created); };
                instance.ErrorHandler = (req, ex) => { throw new HttpException(HttpStatusCode._403_Forbidden); };
                resp = getResponse();
                Assert.AreEqual(HttpStatusCode._201_Created, resp.Item1);

                // Test that a non-HttpException is properly handled
                ok = false;
                instance.Handler = req => { throw storedEx = new Exception("Blah!"); };
                instance.ErrorHandler = (req, ex) => { ok = object.ReferenceEquals(ex, storedEx); return HttpResponse.Create("blah", "text/plain"); };
                resp = getResponse();
                Assert.IsTrue(ok);
                Assert.AreEqual(HttpStatusCode._200_OK, resp.Item1);
                Assert.AreEqual("blah", resp.Item2);
                instance.ErrorHandler = null;
                resp = getResponse();
                Assert.AreEqual(HttpStatusCode._500_InternalServerError, resp.Item1);

                // Test that the main handler returning null results in a 500 error (via InvalidOperationException)
                instance.Handler = req => { return null; };
                instance.ErrorHandler = (req, ex) => { storedEx = ex; throw new HttpException(HttpStatusCode._203_NonAuthoritativeInformation); };
                resp = getResponse();
                Assert.IsTrue(storedEx is InvalidOperationException);
                Assert.AreEqual(HttpStatusCode._500_InternalServerError, resp.Item1);

                // Test that the error handler returning null invokes the default error handler
                instance.Handler = req => { throw new HttpException(HttpStatusCode._201_Created); };
                instance.ErrorHandler = (req, ex) => { return null; };
                resp = getResponse();
                Assert.AreEqual(HttpStatusCode._201_Created, resp.Item1);

                // Test that a malformed request passes through the error handler
                instance.ErrorHandler = (req, ex) => { storedEx = ex; throw new HttpException(HttpStatusCode._204_NoContent); };
                {
                    TcpClient cl = new TcpClient();
                    cl.Connect("localhost", ProgramServersTests.Port);
                    cl.ReceiveTimeout = 1000; // 1 sec
                    cl.Client.Send("xz\r\n\r\n".ToUtf8());
                    var response = Encoding.UTF8.GetString(cl.Client.ReceiveAllBytes());
                    cl.Close();
                    var code = (HttpStatusCode) int.Parse(response.Substring("HTTP/1.1 ".Length, 3));
                    var body = response.Split("\r\n\r\n")[1];
                    Assert.AreEqual(HttpStatusCode._400_BadRequest, code);
                    Assert.IsTrue(storedEx is HttpRequestParseException);
                    Assert.AreEqual(HttpStatusCode._400_BadRequest, (storedEx as HttpRequestParseException).StatusCode);
                }

                // Test that an exception in the response stream is sent to the response exception handler
                var excp = new Exception("Blam!");
                HttpResponse storedRsp1 = null, storedRsp2 = null;
                instance.Handler = req => { return storedRsp1 = HttpResponse.Create(new DynamicContentStream(enumerableWithException(excp)), "text/plain"); };
                bool ok1 = true, ok2 = false;
                instance.ErrorHandler = (req, ex) => { ok1 = false; return null; };
                instance.ResponseExceptionHandler = (req, ex, rsp) => { ok2 = true; storedEx = ex; storedRsp2 = rsp; };
                resp = getResponse();
                Assert.IsTrue(ok1 && ok2);
                Assert.IsTrue(object.ReferenceEquals(excp, storedEx));
                Assert.IsTrue(object.ReferenceEquals(storedRsp1, storedRsp2));

                // Test that an exception in the response stream didn't bring down the server
                ok = false;
                instance.Handler = req => { ok = true; throw new HttpException(HttpStatusCode._201_Created); };
                resp = getResponse();
                Assert.IsTrue(ok);
                Assert.AreEqual(HttpStatusCode._201_Created, resp.Item1);
            }
            finally
            {
                instance.StopListening(brutal: true);
            }
        }

        public void TestErrorHandlerAndCleanUp()
        {
            var instance = new HttpServer(ProgramServersTests.Port);
            try
            {
                bool errorHandlerCalled = false;
                bool cleanUpCalled = false;

                instance.StartListening();
                instance.Handler = req =>
                {
                    req.CleanUpCallback = () =>
                    {
                        Assert.IsTrue(errorHandlerCalled);
                        cleanUpCalled = true;
                    };
                    throw new InvalidOperationException();
                };
                instance.ErrorHandler = (req, exc) =>
                {
                    Assert.IsFalse(cleanUpCalled);
                    errorHandlerCalled = true;
                    return HttpResponse.PlainText("Error");
                };

                TcpClient cl = new TcpClient();
                cl.Connect("localhost", ProgramServersTests.Port);
                cl.ReceiveTimeout = 1000000; // 1000 sec
                cl.Client.Send("GET / HTTP/1.1\r\nHost: localhost\r\n\r\n".ToUtf8());
                var response = Encoding.UTF8.GetString(cl.Client.ReceiveAllBytes());
                cl.Close();
                Assert.IsTrue(errorHandlerCalled);
                Assert.IsTrue(cleanUpCalled);
                Assert.IsTrue(response.EndsWith("\r\n\r\nError"));
            }
            finally
            {
                instance.StopListening(brutal: true);
            }
        }

        public void TestHalfOpenConnection()
        {
            var instance = new HttpServer(ProgramServersTests.Port, new HttpServerOptions { OutputExceptionInformation = true });
            instance.Handler = req => HttpResponse.PlainText(" thingy stuff ");
            try
            {
                instance.StartListening();

                // A proper request ending in a half closed connection
                using (var cl = new TcpClient())
                {
                    cl.ReceiveTimeout = 1000; // 1 sec
                    cl.Connect("localhost", ProgramServersTests.Port);
                    cl.Client.Send("GET /static HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n".ToUtf8());
                    cl.Client.Shutdown(SocketShutdown.Send);
                    var response = Encoding.UTF8.GetString(cl.Client.ReceiveAllBytes());
                    var code = (HttpStatusCode) int.Parse(response.Substring("HTTP/1.1 ".Length, 3));
                    var parts = response.Split("\r\n\r\n");
                    Assert.AreEqual(HttpStatusCode._200_OK, code);
                    Assert.AreEqual(" thingy stuff ", parts[1]);
                }

                // An incomplete request ending in a half closed connection
                using (var cl = new TcpClient())
                {
                    cl.Connect("localhost", ProgramServersTests.Port);
                    cl.Client.Send("GET /static HTTP/1.1\r\nHost: localhost\r\nConnection: close".ToUtf8());
                    cl.Client.Shutdown(SocketShutdown.Send);
                    var response = Encoding.UTF8.GetString(cl.Client.ReceiveAllBytes());
                    // the test is that it doesn't wait forever
                }

                // A malformed request ending in a half closed connection
                using (var cl = new TcpClient())
                {
                    cl.Connect("localhost", ProgramServersTests.Port);
                    cl.Client.Send("xz".ToUtf8());
                    cl.Client.Shutdown(SocketShutdown.Send);
                    var response = Encoding.UTF8.GetString(cl.Client.ReceiveAllBytes());
                    // the test is that it doesn't wait forever
                }
            }
            finally
            {
                instance.StopListening(brutal: true);
            }
        }