public async Task StopAsyncCallsCompleteWhenFirstCallCompletes() { var options = new KestrelServerOptions { ListenOptions = { new ListenOptions(new IPEndPoint(IPAddress.Loopback, 0)) } }; var unbind = new SemaphoreSlim(0); var stop = new SemaphoreSlim(0); var mockTransport = new Mock <ITransport>(); mockTransport .Setup(transport => transport.BindAsync()) .Returns(Task.CompletedTask); mockTransport .Setup(transport => transport.UnbindAsync()) .Returns(async() => await unbind.WaitAsync()); mockTransport .Setup(transport => transport.StopAsync()) .Returns(async() => await stop.WaitAsync()); var mockTransportFactory = new Mock <ITransportFactory>(); mockTransportFactory .Setup(transportFactory => transportFactory.Create(It.IsAny <IEndPointInformation>(), It.IsAny <IConnectionHandler>())) .Returns(mockTransport.Object); var server = new KestrelServer(Options.Create(options), mockTransportFactory.Object, Mock.Of <LoggerFactory>()); await server.StartAsync(new DummyApplication(), CancellationToken.None); var stopTask1 = server.StopAsync(default(CancellationToken)); var stopTask2 = server.StopAsync(default(CancellationToken)); var stopTask3 = server.StopAsync(default(CancellationToken)); Assert.False(stopTask1.IsCompleted); Assert.False(stopTask2.IsCompleted); Assert.False(stopTask3.IsCompleted); unbind.Release(); stop.Release(); await Task.WhenAll(new[] { stopTask1, stopTask2, stopTask3 }).TimeoutAfter(TimeSpan.FromSeconds(10)); mockTransport.Verify(transport => transport.UnbindAsync(), Times.Once); mockTransport.Verify(transport => transport.StopAsync(), Times.Once); }
public static AddressBindContext CreateAddressBindContext( ServerAddressesFeature serverAddressesFeature, KestrelServerOptions serverOptions, ILogger logger, Func <ListenOptions, CancellationToken, Task> createBinding) { var context = new AddressBindContext( serverAddressesFeature, serverOptions, logger, createBinding); return(context); }
public ServerKestrel() { var options = new KestrelServerOptions { AddServerHeader = false, }; var optionsWrapper = new OptionsWrapper <KestrelServerOptions>(options); var loggerFactory = new LoggerFactory(); var lifeTime = new ApplicationLifetime(loggerFactory.CreateLogger <ApplicationLifetime>()); server = new KestrelServer(optionsWrapper, new LibuvTransportFactory(new OptionsManager <LibuvTransportOptions>( new OptionsFactory <LibuvTransportOptions>( new List <IConfigureOptions <LibuvTransportOptions> >(), new List <IPostConfigureOptions <LibuvTransportOptions> >())), lifeTime, loggerFactory), loggerFactory); }
private KestrelServerOptions CreateServerOptions() { var serverOptions = new KestrelServerOptions(); var env = new HostingEnvironment { ApplicationName = "TestApplication" }; serverOptions.ApplicationServices = new ServiceCollection() .AddLogging() .AddSingleton <IWebHostEnvironment>(env) .AddSingleton <IHostEnvironment>(env) .BuildServiceProvider(); return(serverOptions); }
public async Task WrapsAddressInUseExceptionAsIOException() { var addresses = new ServerAddressesFeature(); addresses.Addresses.Add("http://localhost:5000"); var options = new KestrelServerOptions(); await Assert.ThrowsAsync <IOException>(() => AddressBinder.BindAsync(addresses, options, NullLogger.Instance, Mock.Of <IDefaultHttpsProvider>(), endpoint => throw new AddressInUseException("already in use"))); }
public static void ConfigureEndpoints(this KestrelServerOptions options, int port) { IPAddress address = IPAddress.Loopback; options.Listen(address, port, listenOptions => { HttpsConnectionAdapterOptions httpOptions = new HttpsConnectionAdapterOptions { ServerCertificate = GetHttpsCertificate(), ClientCertificateMode = ClientCertificateMode.NoCertificate }; listenOptions.UseHttps(httpOptions); }); }
private static void SetupCommonProperties(IConfiguration configuration, KestrelServerOptions options) { _ = long.TryParse(configuration["devonfw:Kestrel:ExtraSettings:MaxConcurrentConnections"], out long maxConcurrentConnections); _ = long.TryParse(configuration["devonfw:Kestrel:ExtraSettings:MaxConcurrentUpgradedConnections"], out long maxConcurrentUpgradedConnections); _ = long.TryParse(configuration["devonfw:Kestrel:ExtraSettings:KeepAliveTimeout"], out long keepAliveTimeout); _ = double.TryParse(configuration["devonfw:Kestrel:ExtraSettings:MaxRequestBodySize"], out double maxRequestBodySize); _ = int.TryParse(configuration["devonfw:Kestrel:ExtraSettings:Http2MaxStreamsPerConnection"], out int http2MaxStreamsPerConnection); _ = int.TryParse(configuration["devonfw:Kestrel:ExtraSettings:Http2InitialConnectionWindowSize"], out int Http2InitialConnectionWindowSize); _ = int.TryParse(configuration["devonfw:Kestrel:ExtraSettings:Http2InitialStreamWindowSize"], out int http2InitialStreamWindowSize); _ = bool.TryParse(configuration["devonfw:Kestrel:ExtraSettings:AllowSynchronousIO"], out bool allowSynchronousIO); if (maxConcurrentConnections > 0) { options.Limits.MaxConcurrentConnections = maxConcurrentConnections; } if (maxConcurrentUpgradedConnections > 0) { options.Limits.MaxConcurrentUpgradedConnections = maxConcurrentUpgradedConnections; } if (keepAliveTimeout > 0) { options.Limits.KeepAliveTimeout = TimeSpan.FromSeconds(keepAliveTimeout); } if (maxRequestBodySize >= 1 && maxRequestBodySize <= 28.6) { options.Limits.MaxRequestBodySize = (long?)(maxRequestBodySize * 1048576); } if (http2MaxStreamsPerConnection > 0) { options.Limits.Http2.MaxStreamsPerConnection = http2MaxStreamsPerConnection; } if (Http2InitialConnectionWindowSize >= 65535 && Http2InitialConnectionWindowSize <= Math.Pow(2, 31)) { options.Limits.Http2.InitialConnectionWindowSize = Http2InitialConnectionWindowSize; } if (http2InitialStreamWindowSize >= 65535 && http2InitialStreamWindowSize <= Math.Pow(2, 31)) { options.Limits.Http2.InitialStreamWindowSize = http2InitialStreamWindowSize; } if (allowSynchronousIO) { options.AllowSynchronousIO = true; } }
// David Fowler would really like us not to do this // https://github.com/aspnet/KestrelHttpServer/issues/2306#issuecomment-364478486 public EndpointDetailsViewModel HackEndpointDetails() { var model = new EndpointDetailsViewModel(); try { KestrelServer kestrel = server as KestrelServer; if (kestrel == null) { model.NotKestrel = true; return(model); } KestrelServerOptions options = kestrel.Options; // reflection voodoo Type kestrelServerOptionsType = typeof(KestrelServerOptions); PropertyInfo listenOptionsProp = kestrelServerOptionsType.GetProperty("ListenOptions", BindingFlags.Instance | BindingFlags.NonPublic); PropertyInfo isTlsProp = typeof(ListenOptions).GetProperty("IsTls", BindingFlags.Instance | BindingFlags.NonPublic); List <ListenOptions> listenOptions = (List <ListenOptions>)listenOptionsProp.GetValue(options); foreach (ListenOptions listenOption in listenOptions) { bool isTls = (bool)isTlsProp.GetValue(listenOption); // Grab all the details for this endpoint EndpointDetail endpointDetail = new EndpointDetail { Address = listenOption.IPEndPoint.Address.ToString(), Port = listenOption.IPEndPoint.Port, IsHttps = isTls }; model.EndpointDetails.Add(endpointDetail); if (isTls) { // it appears all middleware is configured for all listenOptions even if they aren't https endpointDetail.Certificate = GetCertificateFromOptions(listenOption); } } // Reflect the dev cert model.IsDevCertLoaded = (bool)(kestrelServerOptionsType.GetProperty("IsDevCertLoaded", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(options)); model.DefaultCertificate = kestrelServerOptionsType.GetProperty("DefaultCertificate", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(options) as X509Certificate2; } catch (Exception ex) { // because this is hacky enough that it'll likely fall down easily model.Exception = ex.Message; } return(model); }
public static void ConfigureCashFlowService(this KestrelServerOptions ksoOptions) { var vCashFlowSrvConfig = ksoOptions.ApplicationServices.GetRequiredService <IConfiguration>(); var vCashFlowServerEnvironment = ksoOptions.ApplicationServices.GetRequiredService <IHostingEnvironment>(); var vCashFlowSrvConfigItems = vCashFlowSrvConfig.GetSection("HttpServer:vCashFlowSrvConfigItems") .GetChildren() .ToDictionary(cfsSection => cfsSection.Key, cfsSection => { var vCashFlowSrvConfigItem = new CashFlowServiceConfigurationDefinition(); cfsSection.Bind(vCashFlowSrvConfigItem); return(vCashFlowSrvConfigItem); }); foreach (var vCashFlowSrvConfigItem in vCashFlowSrvConfigItems) { var vCashFlowSrvconfig = vCashFlowSrvConfigItem.Value; var vCashFlowSrvPort = vCashFlowSrvconfig.iPort ?? (vCashFlowSrvconfig.strScheme == "https" ? 443 : 80); //var vCashFlowSrvPort = vCashFlowSrvconfig.iPort; var vIpAddresses = new List <IPAddress>(); if (vCashFlowSrvconfig.strHost == "localhost") { vIpAddresses.Add(IPAddress.IPv6Loopback); vIpAddresses.Add(IPAddress.Loopback); } else if (IPAddress.TryParse(vCashFlowSrvconfig.strHost, out var vCurrentIpAddress)) { vIpAddresses.Add(vCurrentIpAddress); } else { vIpAddresses.Add(IPAddress.IPv6Any); } foreach (var vAddress in vIpAddresses) { ksoOptions.Listen(vAddress, vCashFlowSrvPort, listenOptions => { if (vCashFlowSrvconfig.strScheme == "https") { var vCashFlowSrvCertificate = LoadCashFlowSrvCertificate(vCashFlowSrvconfig, vCashFlowServerEnvironment); listenOptions.UseHttps(vCashFlowSrvCertificate); } }); } } }
public KestrelOwinServer(KestrelServerOptions options) { if (options == null) { throw new ArgumentNullException(nameof(options)); } var wrappedOptions = Options.Create(options); var lifetime = new ApplicationLifetime(); var loggerFactory = new LoggerFactory(); Server = new KestrelServer(wrappedOptions, lifetime, loggerFactory); }
public void KestrelServerDoesNotThrowIfNoDefaultHttpsProviderButManualListenOptions() { var mockDefaultHttpsProvider = new Mock <IDefaultHttpsProvider>(); var serverOptions = new KestrelServerOptions(); serverOptions.Listen(new IPEndPoint(IPAddress.Loopback, 0)); using (var server = CreateServer(serverOptions, defaultHttpsProvider: null)) { server.Features.Get <IServerAddressesFeature>().Addresses.Add("https://127.0.0.1:0"); StartDummyApplication(server); } }
public static void ConfigureEndpoints(this KestrelServerOptions options, int port) { IPAddress address = IPAddress.Loopback; options.Listen(address, port, listenOptions => { IOptions <CranSettingsDto> settings = (IOptions <CranSettingsDto>)options.ApplicationServices.GetService(typeof(IOptions <CranSettingsDto>)); HttpsConnectionAdapterOptions httpOptions = new HttpsConnectionAdapterOptions { ServerCertificate = GetHttpsCertificate(settings.Value.DevelopmentCertStorePath, settings.Value?.DevelopmentCertStorePw), ClientCertificateMode = ClientCertificateMode.NoCertificate }; listenOptions.UseHttps(httpOptions); }); }
private void Initialize(ILoggerFactory loggerFactory, IKestrelTrace kestrelTrace) { LoggerFactory = loggerFactory; Log = kestrelTrace; Scheduler = PipeScheduler.ThreadPool; MockSystemClock = new MockSystemClock(); SystemClock = MockSystemClock; DateHeaderValueManager = new DateHeaderValueManager(MockSystemClock); ConnectionManager = new ConnectionManager(Log, ResourceCounter.Unlimited); HttpParser = new HttpParser <Http1ParsingHandler>(Log.IsEnabled(LogLevel.Information)); ServerOptions = new KestrelServerOptions { AddServerHeader = false }; }
private static void ConfigureKestrel(WebHostBuilderContext builderContext, KestrelServerOptions options) { options.AddServerHeader = false; options.Limits.MaxRequestLineSize = 1024; options.Limits.MaxRequestBodySize = 1 << 20; options.Limits.MaxRequestHeadersTotalSize = 8192; var kestrelSection = builderContext.Configuration.GetSection("Kestrel"); options.Configure(kestrelSection); if (kestrelSection.Get <KestrelServerOptions>() is { } kestrelOptions) { options.Limits.MaxConcurrentConnections = kestrelOptions.Limits.MaxConcurrentConnections; }
public static KestrelServerOptions ListenHttpAndGrpcProtocols( this KestrelServerOptions options, IConfiguration config, string appId) { options.Limits.MinRequestBodyDataRate = null; options.Listen(IPAddress.Any, config.GetHttpPort(appId)); options.Listen(IPAddress.Any, config.GetGrpcPort(appId), listenOptions => { listenOptions.Protocols = HttpProtocols.Http2; }); return(options); }
public static void ConfigureEndpoints(this KestrelServerOptions options) { var configuration = options.ApplicationServices.GetRequiredService <IConfiguration>(); var environment = options.ApplicationServices.GetRequiredService <IHostingEnvironment>(); var endpoints = configuration.GetSection("HttpServer:Endpoints") .GetChildren() .ToDictionary(section => section.Key, section => { var endpoint = new EndpointConfiguration(); section.Bind(endpoint); return(endpoint); }); foreach (var endpoint in endpoints) { var config = endpoint.Value; var port = config.Port ?? (config.Scheme == "https" ? 443 : 80); var ipAddresses = new List <IPAddress>(); if (config.Host == "localhost") { ipAddresses.Add(IPAddress.IPv6Loopback); ipAddresses.Add(IPAddress.Loopback); } else if (IPAddress.TryParse(config.Host, out var address)) { ipAddresses.Add(address); } else { ipAddresses.Add(IPAddress.IPv6Any); } foreach (var address in ipAddresses) { options.Listen(address, port, listenOptions => { if (config.Scheme == "https") { var certificate = LoadCertificate(config, environment); listenOptions.UseHttps(certificate); } }); } } }
internal static ListenOptions ParseAddress(string address, KestrelServerOptions serverOptions, IDefaultHttpsProvider defaultHttpsProvider) { var parsedAddress = ServerAddress.FromUrl(address); var https = false; if (parsedAddress.Scheme.Equals("https", StringComparison.OrdinalIgnoreCase)) { https = true; } else if (!parsedAddress.Scheme.Equals("http", StringComparison.OrdinalIgnoreCase)) { throw new InvalidOperationException(CoreStrings.FormatUnsupportedAddressScheme(address)); } if (!string.IsNullOrEmpty(parsedAddress.PathBase)) { throw new InvalidOperationException(CoreStrings.FormatConfigurePathBaseFromMethodCall($"{nameof(IApplicationBuilder)}.UsePathBase()")); } ListenOptions options = null; if (parsedAddress.IsUnixPipe) { options = new ListenOptions(parsedAddress.UnixPipePath); } else if (string.Equals(parsedAddress.Host, "localhost", StringComparison.OrdinalIgnoreCase)) { // "localhost" for both IPv4 and IPv6 can't be represented as an IPEndPoint. options = new LocalhostListenOptions(parsedAddress.Port); } else if (TryCreateIPEndPoint(parsedAddress, out var endpoint)) { options = new ListenOptions(endpoint); } else { // when address is 'http://hostname:port', 'http://*:port', or 'http://+:port' options = new AnyIPListenOptions(parsedAddress.Port); } if (https) { options.KestrelServerOptions = serverOptions; defaultHttpsProvider.ConfigureHttps(options); } return(options); }
/// <summary> /// Configure the <see cref="KestrelServerOptions"/> with the specified URL. /// </summary> private bool Listen(KestrelServerOptions options, string url) { BindingAddress address = null; try { address = BindingAddress.Parse(url); } catch (Exception ex) { // Record the exception; it will be logged later through ILogger. Errors.Add(new AddressListenResult(url, ex)); return(false); } Action <ListenOptions> configureListenOptions = (listenOptions) => { if (address.Scheme.Equals(Uri.UriSchemeHttps, StringComparison.OrdinalIgnoreCase)) { listenOptions.UseHttps(); } }; try { if (address.Host.Equals("localhost", StringComparison.OrdinalIgnoreCase)) { options.ListenLocalhost(address.Port, configureListenOptions); } else if (IPAddress.TryParse(address.Host, out IPAddress ipAddress)) { options.Listen(ipAddress, address.Port, configureListenOptions); } else { options.ListenAnyIP(address.Port, configureListenOptions); } } catch (InvalidOperationException ex) { // This binding failure is typically due to missing default certificate. // Record the exception; it will be logged later through ILogger. Errors.Add(new AddressListenResult(url, ex)); return(false); } return(true); }
public async Task WrapsAddressInUseExceptionAsIOException() { var addresses = new ServerAddressesFeature(); addresses.InternalCollection.Add("http://localhost:5000"); var options = new KestrelServerOptions(); var addressBindContext = TestContextFactory.CreateAddressBindContext( addresses, options, NullLogger.Instance, endpoint => throw new AddressInUseException("already in use")); await Assert.ThrowsAsync <IOException>(() => AddressBinder.BindAsync(options.ListenOptions, addressBindContext, CancellationToken.None)); }
static void Main(string[] args) { var options = new KestrelServerOptions(); options.NoDelay = true; options.ThreadCount = 2; var applicationLifetime = new ApplicationLifetime(); var server = new KestrelServer(new OptionsWrapper <KestrelServerOptions>(options), applicationLifetime, new LoggerFactory()); server.Features.Get <IServerAddressesFeature>().Addresses.Add("http://localhost:8888"); server.Start(new HttpApp()); Console.WriteLine("Listening on 8888. Press Enter to stop."); Console.ReadLine(); server.Dispose(); }
private static void AddDevelopmentPorts( KestrelServerOptions options, int?httpPort, int?httpsPort, X509Certificate2?certificate) { if (httpPort.HasValue) { AddListener(options, httpPort.Value, null); } if (httpsPort.HasValue && certificate != null) { AddListener(options, httpsPort.Value, certificate); } }
private static void ConfigureKestrel(KestrelServerOptions options, SettingsModel settings) { options.AddServerHeader = false; var(httpPorts, httpsPorts) = GetPorts(settings); foreach (var port in httpPorts) { options.Listen(IPAddress.Any, port); } foreach (var port in httpsPorts) { options.Listen(IPAddress.Any, port, listenOptions => listenOptions.UseHttps(settings.Web.PfxPath, settings.Web.PfxPassword)); } }
private static void AddListener( KestrelServerOptions options, int port, X509Certificate2 certificate) { options.Listen( new IPEndPoint(IPAddress.Loopback, port), listenOptions => { listenOptions.UseConnectionLogging(); if (null != certificate) { listenOptions.UseHttps(certificate); } }); }
/// <summary> /// Configures AirDrop defaults for Kestrel. /// </summary> /// <param name="options">A <see cref="KestrelServerOptions"/> instance to configure.</param> /// <param name="cert">An <see cref="X509Certificate2"/> representing the certificate to use for the AirDrop HTTPS endpoint.</param> public static void ConfigureAirDropDefaults(this KestrelServerOptions options, X509Certificate2 cert) { if (cert == null) { throw new ArgumentNullException(nameof(cert)); } var airDropOptions = options.ApplicationServices.GetRequiredService <IOptions <AirDropOptions> >(); options.ConfigureEndpointDefaults( endpointDefaults => { endpointDefaults.UseHttps(cert); }); options.ListenAnyIP(airDropOptions.Value.ListenPort); }
public static void ConfigureEndpoints(this KestrelServerOptions options) { var configuration = options.ApplicationServices.GetRequiredService <IConfiguration>(); var endpoints = configuration.GetSection("HttpServer:Endpoints") .GetChildren() .ToDictionary(section => section.Key, section => { var endpoint = new EndpointConfigurationSettings(); section.Bind(endpoint); return(endpoint); }); foreach (var endpoint in endpoints) { CreateEndPoint(options, endpoint.Value); } }
private static void ConfigureKestrel(WebHostBuilderContext context, KestrelServerOptions serverOptions) { Log.Debug("ConfigureKestrel"); var config = context.Configuration.Get <StartUpConfiguration>(); config.SetDefaultSettings(); var listenIp = IPAddress.Parse(config.ListeningIP); if (config.HttpPort.HasValue && config.HttpPort.Value != 0) { serverOptions.Listen(listenIp, config.HttpPort.Value, listenOptions => { listenOptions.Protocols = HttpProtocols.Http1AndHttp2; }); } if (config.HttpsPort.HasValue && config.HttpsPort.Value != 0) { var certPath = PathHelper.GetFullPath(config.HttpsCertPath); Log.Debug(certPath); serverOptions.Listen(listenIp, config.HttpsPort.Value, listenOptions => { listenOptions.Protocols = HttpProtocols.Http1AndHttp2; listenOptions.UseHttps(PathHelper.GetFullPath(config.HttpsCertPath), config.HttpsCertPassword); }); } var adminListenIp = IPAddress.Parse(config.AdminSettings.ListeningIP); serverOptions.Listen(adminListenIp, config.AdminSettings.HttpsPort, options => { options.Protocols = HttpProtocols.Http1AndHttp2; options.UseHttps(PathHelper.GetFullPath(config.AdminSettings.HttpsCertPath), config.AdminSettings.HttpsCertPassword); }); var idpListenIp = IPAddress.Parse(config.IdpSettings.ListeningIP); serverOptions.Listen(idpListenIp, config.IdpSettings.HttpsPort, options => { options.Protocols = HttpProtocols.Http1AndHttp2; options.UseHttps(PathHelper.GetFullPath(config.IdpSettings.HttpsCertPath), config.IdpSettings.HttpsCertPassword); }); }
public static void UseSslAuth(this KestrelServerOptions options) { var serviceProvider = options.ApplicationServices; var kvClient = serviceProvider.GetRequiredService <IKeyVaultClient>(); var configuration = serviceProvider.GetRequiredService <IConfiguration>(); var httpsSettings = configuration.GetConfiguredSettings <HttpsSettings>(); if (httpsSettings != null) { Console.WriteLine( $"serving web request... port: {httpsSettings.PortNumber}, cert: {httpsSettings.SslCertSecretName}"); var vaultSettings = configuration.GetConfiguredSettings <VaultSettings>(); var x509 = kvClient.GetX509CertificateAsync(vaultSettings.VaultUrl, httpsSettings.SslCertSecretName) .GetAwaiter().GetResult(); options.ListenAnyIP(httpsSettings.PortNumber, listenOptions => { listenOptions.UseHttps(x509); }); } }
public void StartWarnsWhenIgnoringIServerAddressesFeature(string ignoredAddress) { var testLogger = new TestApplicationErrorLogger(); var kestrelOptions = new KestrelServerOptions(); // Directly configuring an endpoint using Listen causes the IServerAddressesFeature to be ignored. kestrelOptions.Listen(IPAddress.Loopback, 0); using (var server = CreateServer(kestrelOptions, testLogger)) { server.Features.Get <IServerAddressesFeature>().Addresses.Add(ignoredAddress); StartDummyApplication(server); var warning = testLogger.Messages.Single(log => log.LogLevel == LogLevel.Warning); Assert.Contains("Overriding", warning.Message); } }
public async Task StopAsyncCallsCompleteWhenFirstCallCompletes() { var options = new KestrelServerOptions { CodeBackedListenOptions = { new ListenOptions(new IPEndPoint(IPAddress.Loopback, 0)) } }; var unbind = new SemaphoreSlim(0); var stop = new SemaphoreSlim(0); var mockTransport = new Mock <IConnectionListener>(); var mockTransportFactory = new Mock <IConnectionListenerFactory>(); mockTransportFactory .Setup(transportFactory => transportFactory.BindAsync(It.IsAny <EndPoint>(), It.IsAny <CancellationToken>())) .Returns <EndPoint, CancellationToken>((e, token) => { mockTransport .Setup(transport => transport.AcceptAsync(It.IsAny <CancellationToken>())) .Returns(new ValueTask <ConnectionContext>((ConnectionContext)null)); mockTransport .Setup(transport => transport.UnbindAsync(It.IsAny <CancellationToken>())) .Returns(() => new ValueTask(unbind.WaitAsync())); mockTransport .Setup(transport => transport.DisposeAsync()) .Returns(() => new ValueTask(stop.WaitAsync())); mockTransport .Setup(transport => transport.EndPoint).Returns(e); return(new ValueTask <IConnectionListener>(mockTransport.Object)); }); var mockLoggerFactory = new Mock <ILoggerFactory>(); var mockLogger = new Mock <ILogger>(); mockLoggerFactory.Setup(m => m.CreateLogger(It.IsAny <string>())).Returns(mockLogger.Object); var server = new KestrelServer(Options.Create(options), new List <IConnectionListenerFactory>() { mockTransportFactory.Object }, mockLoggerFactory.Object); await server.StartAsync(new DummyApplication(), CancellationToken.None); var stopTask1 = server.StopAsync(default);
private static void ConfigureKestrel(WebHostBuilderContext builderContext, KestrelServerOptions options) { options.AddServerHeader = false; options.Limits.MaxRequestBodySize = 0; options.Limits.MaxRequestHeadersTotalSize = 4096; // To match all single-chunk files options.Limits.MaxResponseBufferSize = 257 << 10; var kestrelSection = builderContext.Configuration.GetSection("Kestrel"); options.Configure(kestrelSection); if (kestrelSection.Get <KestrelServerOptions>() is { } kestrelOptions) { options.Limits.MaxConcurrentConnections = kestrelOptions.Limits.MaxConcurrentConnections; }