public async Task Server_SetConnectionLimitInfinite_Success() { // This is just to get a dynamic port string address; using (Utilities.CreateHttpServer(out address, httpContext => Task.FromResult(0))) { } var server = Utilities.CreatePump(); server.Listener.Options.UrlPrefixes.Add(UrlPrefix.Create(address)); server.Listener.Options.MaxConnections = -1; // infinite using (server) { await server.StartAsync(new DummyApplication(), CancellationToken.None); using (var client1 = await SendHungRequestAsync("GET", address)) using (var client2 = await SendHungRequestAsync("GET", address)) using (var client3 = await SendHungRequestAsync("GET", address)) { // Doesn't max out string responseText = await SendRequestAsync(address); Assert.Equal(string.Empty, responseText); } } }
public void PathBaseIsNotNormalized() { var urlPrefix = UrlPrefix.Create("http://localhost:8080/p\u0041\u030Athbase"); Assert.False(urlPrefix.Path.IsNormalized(NormalizationForm.FormC)); Assert.Equal("/p\u0041\u030Athbase/", urlPrefix.Path); }
public async Task Server_SetConnectionLimit_Success() { // This is just to get a dynamic port string address; using (Utilities.CreateHttpServer(out address, httpContext => Task.FromResult(0))) { } var server = Utilities.CreatePump(); server.Listener.Options.UrlPrefixes.Add(UrlPrefix.Create(address)); Assert.Null(server.Listener.Options.MaxConnections); server.Listener.Options.MaxConnections = 3; using (server) { await server.StartAsync(new DummyApplication(), CancellationToken.None); using (var client1 = await SendHungRequestAsync("GET", address)) using (var client2 = await SendHungRequestAsync("GET", address)) { using (var client3 = await SendHungRequestAsync("GET", address)) { // Maxed out, refuses connection and throws await Assert.ThrowsAsync <HttpRequestException>(() => SendRequestAsync(address)); } // A connection has been closed, try again. string responseText = await SendRequestAsync(address); Assert.Equal(string.Empty, responseText); } } }
internal static IServer CreateDynamicHttpServer(string basePath, out string root, out string baseAddress, Action <HttpSysOptions> configureOptions, RequestDelegate app) { lock (PortLock) { while (NextPort < MaxPort) { var port = NextPort++; var prefix = UrlPrefix.Create("http", "localhost", port, basePath); root = prefix.Scheme + "://" + prefix.Host + ":" + prefix.Port; baseAddress = prefix.ToString(); var server = CreatePump(); server.Features.Get <IServerAddressesFeature>().Addresses.Add(baseAddress); configureOptions(server.Listener.Options); try { server.StartAsync(new DummyApplication(app), CancellationToken.None).Wait(); return(server); } catch (HttpSysException) { } } NextPort = BasePort; } throw new Exception("Failed to locate a free port."); }
internal static IWebHost CreateDynamicHost(string basePath, out string root, out string baseAddress, Action <HttpSysOptions> configureOptions, RequestDelegate app) { lock (PortLock) { while (NextPort < MaxPort) { var port = NextPort++; var prefix = UrlPrefix.Create("http", "localhost", port, basePath); root = prefix.Scheme + "://" + prefix.Host + ":" + prefix.Port; baseAddress = prefix.ToString(); var builder = new WebHostBuilder() .UseHttpSys(options => { options.UrlPrefixes.Add(prefix); configureOptions(options); }) .Configure(appBuilder => appBuilder.Run(app)); var host = builder.Build(); try { host.Start(); return(host); } catch (HttpSysException) { } } NextPort = BasePort; } throw new Exception("Failed to locate a free port."); }
internal static IHost CreateDynamicHost(string basePath, out string root, out string baseAddress, Action <HttpSysOptions> configureOptions, RequestDelegate app) { var prefix = UrlPrefix.Create("http", "localhost", "0", basePath); var builder = new HostBuilder() .ConfigureWebHost(webHostBuilder => { webHostBuilder .UseHttpSys(options => { options.UrlPrefixes.Add(prefix); configureOptions(options); }) .Configure(appBuilder => appBuilder.Run(app)); }); var host = builder.Build(); host.Start(); var options = host.Services.GetRequiredService <IOptions <HttpSysOptions> >(); prefix = options.Value.UrlPrefixes.First(); // Has new port root = prefix.Scheme + "://" + prefix.Host + ":" + prefix.Port; baseAddress = prefix.ToString(); return(host); }
internal static IServer CreateServer(string scheme, string host, int port, string path, RequestDelegate app) { var server = CreatePump(); server.Features.Get <IServerAddressesFeature>().Addresses.Add(UrlPrefix.Create(scheme, host, port, path).ToString()); server.StartAsync(new DummyApplication(app), CancellationToken.None).Wait(); return(server); }
/// <summary> /// http://msdn.microsoft.com/en-us/library/windows/desktop/aa364698(v=vs.85).aspx /// </summary> /// <param name="scheme">http or https. Will be normalized to lower case.</param> /// <param name="host">+, *, IPv4, [IPv6], or a dns name. Http.Sys does not permit punycode (xn--), use Unicode instead.</param> /// <param name="port">If empty, the default port for the given scheme will be used (80 or 443).</param> /// <param name="path">Should start and end with a '/', though a missing trailing slash will be added. This value must be un-escaped.</param> public static UrlPrefix Create(string scheme, string host, string port, string path) { int?portValue = null; if (!string.IsNullOrWhiteSpace(port)) { portValue = int.Parse(port, NumberStyles.None, CultureInfo.InvariantCulture); } return(UrlPrefix.Create(scheme, host, portValue, path)); }
public void UrlsAreParsedCorrectly(string url, string scheme, string host, string port, string pathBase, string toString) { var urlPrefix = UrlPrefix.Create(url); Assert.Equal(scheme, urlPrefix.Scheme); Assert.Equal(host, urlPrefix.Host); Assert.Equal(port, urlPrefix.Port); Assert.Equal(pathBase, urlPrefix.Path); Assert.Equal(toString ?? url, urlPrefix.ToString()); }
internal RequestQueue(string requestQueueName, string urlPrefix, ILogger logger, bool receiver) : this(urlGroup : null, requestQueueName, RequestQueueMode.Attach, logger, receiver) { try { UrlGroup = new UrlGroup(this, UrlPrefix.Create(urlPrefix)); } catch { Dispose(); throw; } }
internal unsafe UrlGroup(RequestQueue requestQueue, UrlPrefix url) { ulong urlGroupId = 0; var statusCode = HttpApi.HttpFindUrlGroupId( url.FullPrefix, requestQueue.Handle, &urlGroupId); if (statusCode != UnsafeNclNativeMethods.ErrorCodes.ERROR_SUCCESS) { throw new HttpSysException((int)statusCode); } Debug.Assert(urlGroupId != 0, "Invalid id returned by HttpCreateUrlGroup"); Id = urlGroupId; }
internal static IServer CreateDynamicHttpServer(string basePath, out string root, out string baseAddress, Action <HttpSysOptions> configureOptions, RequestDelegate app) { var prefix = UrlPrefix.Create("http", "localhost", "0", basePath); var server = CreatePump(configureOptions); server.Features.Get <IServerAddressesFeature>().Addresses.Add(prefix.ToString()); server.StartAsync(new DummyApplication(app), CancellationToken.None).Wait(); prefix = server.Listener.Options.UrlPrefixes.First(); // Has new port root = prefix.Scheme + "://" + prefix.Host + ":" + prefix.Port; baseAddress = prefix.ToString(); return(server); }
private IServer CreateServer(out string root, RequestDelegate app) { // TODO: We're just doing this to get a dynamic port. This can be removed later when we add support for hot-adding prefixes. var dynamicServer = Utilities.CreateHttpServerReturnRoot("/", out root, app); dynamicServer.Dispose(); var rootUri = new Uri(root); var server = Utilities.CreatePump(); foreach (string path in new[] { "/", "/11", "/2/3", "/2", "/11/2" }) { server.Listener.Options.UrlPrefixes.Add(UrlPrefix.Create(rootUri.Scheme, rootUri.Host, rootUri.Port, path)); } server.StartAsync(new DummyApplication(app), CancellationToken.None).Wait(); return(server); }
public async Task Server_SetQueueLimit_Success() { // This is just to get a dynamic port string address; using (Utilities.CreateHttpServer(out address, httpContext => Task.FromResult(0))) { } var server = Utilities.CreatePump(); server.Listener.Options.UrlPrefixes.Add(UrlPrefix.Create(address)); server.Listener.Options.RequestQueueLimit = 1001; using (server) { await server.StartAsync(new DummyApplication(), CancellationToken.None); string response = await SendRequestAsync(address); Assert.Equal(string.Empty, response); } }
public async Task Server_SetHttp503VebosittHittingThrottle_Success() { // This is just to get a dynamic port string address; using (Utilities.CreateHttpServer(out address, httpContext => Task.FromResult(0))) { } var server = Utilities.CreatePump(); server.Listener.Options.UrlPrefixes.Add(UrlPrefix.Create(address)); Assert.Null(server.Listener.Options.MaxConnections); server.Listener.Options.MaxConnections = 3; server.Listener.Options.Http503Verbosity = Http503VerbosityLevel.Limited; using (server) { await server.StartAsync(new DummyApplication(), CancellationToken.None); using (var client1 = await SendHungRequestAsync("GET", address)) using (var client2 = await SendHungRequestAsync("GET", address)) { using (var client3 = await SendHungRequestAsync("GET", address)) { using (HttpClient client4 = new HttpClient()) { // Maxed out, refuses connection should return 503 HttpResponseMessage response = await client4.GetAsync(address); Assert.Equal(HttpStatusCode.ServiceUnavailable, response.StatusCode); } } // A connection has been closed, try again. string responseText = await SendRequestAsync(address); Assert.Equal(string.Empty, responseText); } } }
public void CreateThrowsForUrlsWithoutSchemeDelimiter(string url) { Assert.Throws <FormatException>(() => UrlPrefix.Create(url)); }
public void CreateThrowsForUrlsWithoutHost(string url) { Assert.Throws <ArgumentNullException>(() => UrlPrefix.Create(url)); }
public void CreateThrowsForUrlsWithEmptyScheme(string url) { Assert.Throws <ArgumentOutOfRangeException>(() => UrlPrefix.Create(url)); }
public void CreateThrowsForUrlsWithInvalidPorts(string url) { Assert.Throws <FormatException>(() => UrlPrefix.Create(url)); }