public static async Task Main(string[] args) { TaskScheduler.UnobservedTaskException += (sender, e) => { Console.WriteLine("Unobserved exception: {0}", e.Exception); }; var container = new QuickInjectContainer(); var hostingEnvironment = new HostingEnvironment { ContentRootPath = Directory.GetCurrentDirectory() }; var defaultEventSourceLoggerFactory = new DefaultEventSourceLoggerFactory(); var startup = new Startup(); startup.SetupQuickInjectContainer(container); startup.Configure(null, hostingEnvironment); var requestDelegate = new RequestDelegate(startup.HandleRequest); var server = new KestrelServer(new KestrelServerOptionsConfig(container, 5000), new SocketTransportFactory(new SocketTransportOptionsConfig(), new ApplicationLifetime(), defaultEventSourceLoggerFactory), defaultEventSourceLoggerFactory); await server.StartAsync(new HttpApplication(requestDelegate), CancellationToken.None); Thread.Sleep(Timeout.Infinite); }
// MARK: - Construction public KestrelServerDecorator( IOptions <KestrelServerOptions> options, ITransportFactory transportFactory, ILoggerFactory loggerFactory) { _server = new KestrelServer(options, transportFactory, loggerFactory); }
static async Task Main(string[] args) { NullLoggerFactory nullLoggerFactory = new NullLoggerFactory(); SocketTransportOptions socketTransportOptions = new SocketTransportOptions(); SocketTransportFactory socketTransportFactory = new SocketTransportFactory( new OptionsWrapper <SocketTransportOptions>(socketTransportOptions), nullLoggerFactory); KestrelServerOptions kestrelServerOptions = new KestrelServerOptions(); //kestrelServerOptions.AllowSynchronousIO = true; kestrelServerOptions.ListenLocalhost(5000); kestrelServerOptions.ApplicationServices = new ServiceProvider(); kestrelServerOptions.ListenLocalhost(5001, listenOptions => { X509Certificate2 serverCertificate = new X509Certificate2("certificate.pfx", "xxxx"); listenOptions.UseHttps(serverCertificate); }); using (KestrelServer kestrelServer = new KestrelServer(new OptionsWrapper <KestrelServerOptions>(kestrelServerOptions), socketTransportFactory, nullLoggerFactory ) ) { await kestrelServer.StartAsync(new HttpApplication(), CancellationToken.None); Console.ReadLine(); } }
public static async Task Main(string[] args) { shutdown = new ManualResetEventSlim(); Console.CancelKeyPress += Console_CancelKeyPress; var options = new KestrelServerOptions(); options.ListenAnyIP(5000, c => { c.UseHttpApplication <Application>(); }); var server = new KestrelServer( Options.Create(options), new SocketTransportFactory( Options.Create(new SocketTransportOptions()), NullLoggerFactory.Instance), NullLoggerFactory.Instance); var application = new HostingApplication((context) => Task.CompletedTask, new DefaultHttpContextFactory(new ServiceProvider())); await server.StartAsync(application, CancellationToken.None); Console.WriteLine("Application started."); shutdown.Wait(); Console.WriteLine("Shutting down..."); server.Dispose(); await server.StopAsync(CancellationToken.None); }
static async Task Main(string[] args) { var socketTransportOptions = new SocketTransportOptions(); var socketTransportFactory = new SocketTransportFactory(Options.Create(socketTransportOptions), NullLoggerFactory.Instance); var kestrelServerOptions = new KestrelServerOptions(); kestrelServerOptions.Listen(IPAddress.Any, 8080); kestrelServerOptions.AddServerHeader = false; using var kestrelServer = new KestrelServer(Options.Create(kestrelServerOptions), socketTransportFactory, NullLoggerFactory.Instance); await kestrelServer.StartAsync(new HttpApplication(), CancellationToken.None); Console.WriteLine("Listening on:"); foreach (var address in kestrelServer.Features.Get <IServerAddressesFeature>().Addresses) { Console.WriteLine(" - " + address); } Console.WriteLine("Process CTRL+C to quit"); var wh = new ManualResetEventSlim(); Console.CancelKeyPress += (sender, e) => wh.Set(); wh.Wait(); }
public override int GetHashCode() { unchecked { int hashCode = AutoRestart.GetHashCode(); hashCode = (hashCode * 397) ^ AutoUpdates.GetHashCode(); hashCode = (hashCode * 397) ^ EnableConfigWatcher.GetHashCode(); hashCode = (hashCode * 397) ^ UpdateIntervalInHours; hashCode = (hashCode * 397) ^ KestrelServer.GetHashCode(); hashCode = (hashCode * 397) ^ GPIOSafeMode.GetHashCode(); hashCode = (hashCode * 397) ^ (RelayPins != null ? RelayPins.GetHashCode() : 0); hashCode = (hashCode * 397) ^ (IRSensorPins != null ? IRSensorPins.GetHashCode() : 0); hashCode = (hashCode * 397) ^ DisplayStartupMenu.GetHashCode(); hashCode = (hashCode * 397) ^ EnableGpioControl.GetHashCode(); hashCode = (hashCode * 397) ^ Debug.GetHashCode(); hashCode = (hashCode * 397) ^ EnableFirstChanceLog.GetHashCode(); hashCode = (hashCode * 397) ^ EnableTextToSpeech.GetHashCode(); hashCode = (hashCode * 397) ^ MuteAssistant.GetHashCode(); hashCode = (hashCode * 397) ^ CloseRelayOnShutdown.GetHashCode(); hashCode = (hashCode * 397) ^ ServerAuthCode; hashCode = (hashCode * 397) ^ (OwnerEmailAddress != null ? StringComparer.OrdinalIgnoreCase.GetHashCode(OwnerEmailAddress) : 0); hashCode = (hashCode * 397) ^ (AssistantEmailId != null ? StringComparer.OrdinalIgnoreCase.GetHashCode(AssistantEmailId) : 0); hashCode = (hashCode * 397) ^ (AssistantEmailPassword != null ? StringComparer.OrdinalIgnoreCase.GetHashCode(AssistantEmailPassword) : 0); hashCode = (hashCode * 397) ^ ProgramLastStartup.GetHashCode(); hashCode = (hashCode * 397) ^ ProgramLastShutdown.GetHashCode(); return(hashCode); } }
public async Task StopAsyncCallsCompleteWithThrownException() { var options = new KestrelServerOptions { ListenOptions = { new ListenOptions(new IPEndPoint(IPAddress.Loopback, 0)) } }; var unbind = new SemaphoreSlim(0); var unbindException = new InvalidOperationException(); var mockTransport = new Mock <ITransport>(); mockTransport .Setup(transport => transport.BindAsync()) .Returns(Task.CompletedTask); mockTransport .Setup(transport => transport.UnbindAsync()) .Returns(async() => { await unbind.WaitAsync(); throw unbindException; }); mockTransport .Setup(transport => transport.StopAsync()) .Returns(Task.CompletedTask); var mockTransportFactory = new Mock <ITransportFactory>(); mockTransportFactory .Setup(transportFactory => transportFactory.Create(It.IsAny <IEndPointInformation>(), It.IsAny <IConnectionDispatcher>())) .Returns(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), mockTransportFactory.Object, mockLoggerFactory.Object); 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(); var timeout = TestConstants.DefaultTimeout; Assert.Same(unbindException, await Assert.ThrowsAsync <InvalidOperationException>(() => stopTask1.TimeoutAfter(timeout))); Assert.Same(unbindException, await Assert.ThrowsAsync <InvalidOperationException>(() => stopTask2.TimeoutAfter(timeout))); Assert.Same(unbindException, await Assert.ThrowsAsync <InvalidOperationException>(() => stopTask3.TimeoutAfter(timeout))); mockTransport.Verify(transport => transport.UnbindAsync(), Times.Once); }
public async Task RunAsync(int port, int threadCount) { var lifetime = new ApplicationLifetime(NullLoggerFactory.Instance.CreateLogger <ApplicationLifetime>()); Console.CancelKeyPress += (sender, e) => lifetime.StopApplication(); var libuvOptions = new LibuvTransportOptions { ThreadCount = threadCount }; var libuvTransport = new LibuvTransportFactory( Options.Create(libuvOptions), lifetime, NullLoggerFactory.Instance); var serverOptions = new KestrelServerOptions(); serverOptions.Listen(IPAddress.Any, port); var server = new KestrelServer(Options.Create(serverOptions), libuvTransport, NullLoggerFactory.Instance); await server.StartAsync(this, CancellationToken.None); Console.WriteLine($"Server listening on http://*:{port} with {libuvOptions.ThreadCount} thread(s)"); lifetime.ApplicationStopping.WaitHandle.WaitOne(); await server.StopAsync(CancellationToken.None); }
static async Task RunHttpApplication(HttpApplication application, int port) { var socketTransportOptions = new SocketTransportOptions(); var socketTransportFactory = new SocketTransportFactory(Options.Create(socketTransportOptions), NullLoggerFactory.Instance); var kestrelServerOptions = new KestrelServerOptions(); kestrelServerOptions.ListenLocalhost(port); kestrelServerOptions.ApplicationServices = new ServiceProvider(); using var kestrelServer = new KestrelServer(Options.Create(kestrelServerOptions), socketTransportFactory, NullLoggerFactory.Instance); await kestrelServer.StartAsync(application, CancellationToken.None); Console.WriteLine("Listening on:"); foreach (var address in kestrelServer.Features.Get <IServerAddressesFeature>().Addresses) { Console.WriteLine(" - " + address); } Console.WriteLine("Process CTRL+C to quit"); var wh = new ManualResetEventSlim(); Console.CancelKeyPress += (sender, e) => wh.Set(); wh.Wait(); }
/// <summary> /// Starts listening for new Websocket stream connections /// </summary> /// <param name="endpoint">The endpoint to listen to</param> /// <param name="connectionAdded">A connection delegate that is called when a new client is connected</param> /// <param name="bufferSize">Buffer sized used for receiving</param> /// <param name="defaultPage">Default response to clients like browsers</param> /// <returns></returns> public Task StartAsync(IPEndPoint endpoint, Func <WsStream, Task> connectionAdded, int bufferSize = Config.InternalBufferSize, string defaultPage = Config.Version) { if (IsListening) { throw new InvalidOperationException("WsServer is already running!"); } _stopSource = new CancellationTokenSource(); IsListening = true; // setup kestrel parameters var logger = new NullLoggerFactory(); var kestrelOptions = new KestrelServerOptions(); var lifetime = new ApplicationLifetime(logger.CreateLogger <ApplicationLifetime>()); var socketTransportFactory = new SocketTransportFactory(Options.Create(new SocketTransportOptions()), lifetime, logger); // start kestrel _server = new KestrelServer(Options.Create(kestrelOptions), socketTransportFactory, logger); _server.Options.Listen(endpoint); return(_server .StartAsync(new KestrelRequestHandler(connectionAdded, bufferSize, _stopSource.Token, defaultPage), CancellationToken.None).ContinueWith( x => { var addr = _server.Features.Get <IServerAddressesFeature>(); ListeningAddresses = addr.Addresses.ToArray(); })); }
// Add support for reading raw http bytes // Pass Ctrl+C Cancellation Tokens and Server Shutdown stuff // Setup Kestrel server limits // Add SSL support with certificate file path public static async Task Main(string[] args) { Console.CancelKeyPress += new ConsoleCancelEventHandler(Console_CancelKeyPress); TaskScheduler.UnobservedTaskException += new EventHandler <UnobservedTaskExceptionEventArgs>(TaskScheduler_UnobservedTaskException); if (args.Length < 1) { Console.WriteLine("Usage: MinimalKestrelApp PortNumber"); return; } int portNumber = int.Parse(args[0]); var defaultEventSourceLoggerFactory = new DefaultEventSourceLoggerFactory(); var requestHandler = new RequestHandler(); var requestDelegate = new RequestDelegate(requestHandler.HandleRequest); var server = new KestrelServer(new KestrelServerOptionsConfig(new NotImplementedServiceProvider(), portNumber), new SocketTransportFactory(new SocketTransportOptionsConfig(), new ApplicationLifetime(), defaultEventSourceLoggerFactory), defaultEventSourceLoggerFactory); await server.StartAsync(new HttpApplication(requestDelegate), CancellationToken.None); Console.WriteLine($"Running on port {portNumber} ..."); Thread.Sleep(Timeout.Infinite); }
public async ValueTask <IConnectionListener> BindAsync(EndPoint endpoint, CancellationToken cancellationToken = default) { IPEndPoint iPEndPoint = null; switch (endpoint) { // Kestrel doesn't natively support UriEndpoints as yet case UriEndPoint uriEndPoint: IPAddress address = null; if (uriEndPoint.Uri.Host == "localhost") { address = IPAddress.Loopback; } else { IPAddress.Parse(uriEndPoint.Uri.Host); } iPEndPoint = new IPEndPoint(address, uriEndPoint.Uri.Port); break; case IPEndPoint ip: iPEndPoint = ip; break; default: throw new NotSupportedException($"{endpoint} not supported"); } var services = new ServiceCollection(); services.AddSingleton(_loggerFactory); services.AddLogging(); var serverOptions = Options.Create(new KestrelServerOptions() { ApplicationServices = services.BuildServiceProvider() });; var socketOptions = Options.Create(new SocketTransportOptions()); var socketTransportFactory = new SocketTransportFactory(socketOptions, _loggerFactory); var server = new KestrelServer(serverOptions, socketTransportFactory, _loggerFactory); ListenOptions listenOptions = null; // Bind an HTTP/2 endpoint server.Options.Listen(iPEndPoint, options => { options.UseHttps(); options.Protocols = HttpProtocols.Http2; // Storing the options so we can get the resolved EndPoint later listenOptions = options; }); var listener = new Http2ConnectionListener(server); await listener.BindAsync(cancellationToken).ConfigureAwait(false); listener.EndPoint = listenOptions.IPEndPoint; return(listener); }
// David Fouler 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; // reflect out the ListenOptions array Type kestrelServerOptionsType = typeof(KestrelServerOptions); PropertyInfo listenOptionsProp = kestrelServerOptionsType.GetProperty("ListenOptions", BindingFlags.Instance | BindingFlags.NonPublic); List <ListenOptions> listenOptions = (List <ListenOptions>)listenOptionsProp.GetValue(options); foreach (ListenOptions listenOption in listenOptions) { if (listenOption.ConnectionAdapters?.Count > 0) { foreach (IConnectionAdapter connectionAdapter in listenOption.ConnectionAdapters) { // Grab all the details for this endpoint EndpointDetail endpointDetail = new EndpointDetail { Address = listenOption.IPEndPoint.Address.ToString(), Port = listenOption.IPEndPoint.Port, IsHttps = connectionAdapter.IsHttps }; if (connectionAdapter is HttpsConnectionAdapter) { endpointDetail.Certificate = typeof(HttpsConnectionAdapter).GetField("_serverCertificate", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(connectionAdapter) as X509Certificate2; } model.EndpointDetails.Add(endpointDetail); } } else { model.EndpointDetails.Add(new EndpointDetail { Address = listenOption.IPEndPoint.Address.ToString(), Port = listenOption.IPEndPoint.Port, IsHttps = false }); } } // 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); }
/// <summary> /// Patches the <see cref="KestrelServer"/> instance by replacing the HttpParser. /// </summary> /// <param name="server"></param> /// <returns></returns> static KestrelServer PatchKestrel(KestrelServer server) { var ctxType = typeof(KestrelServer).Assembly.GetType("Microsoft.AspNetCore.Server.Kestrel.Core.Internal.ServiceContext"); var hndType = typeof(KestrelServer).Assembly.GetType("Microsoft.AspNetCore.Server.Kestrel.Core.Internal.Http.Http1ParsingHandler"); var prsType = typeof(HttpParserWithPatch <>).MakeGenericType(hndType); var ctxProp = typeof(KestrelServer).GetProperty("ServiceContext", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(server); ctxType.GetProperty("HttpParser").SetValue(ctxProp, Activator.CreateInstance(prsType)); return(server); }
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 <IConnectionDispatcher>())) .Returns(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), mockTransportFactory.Object, mockLoggerFactory.Object); 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 }).DefaultTimeout(); mockTransport.Verify(transport => transport.UnbindAsync(), Times.Once); mockTransport.Verify(transport => transport.StopAsync(), Times.Once); }
public KestrelWebServer(int port, List <IKoobooMiddleWare> middlewares, bool forcessl = false) { var life = new ApplicationLifetime(null); var log = new Microsoft.Extensions.Logging.Abstractions.NullLoggerFactory(); SocketTransportFactory usesocket = new SocketTransportFactory(new koobooSocketOption(), life, log); _server = new KestrelServer(new KoobooServerOption(port, forcessl), usesocket, log); SetMiddleWares(middlewares); }
public void StartWithMultipleTransportFactoriesDoesNotThrow() { using var server = new KestrelServer( Options.Create(CreateServerOptions()), new List <IConnectionListenerFactory>() { new ThrowingTransportFactory(), new MockTransportFactory() }, new LoggerFactory(new[] { new KestrelTestLoggerProvider() })); StartDummyApplication(server); }
// 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 Main(string[] args) { var loggerFactory = new NoOpLoggerFactory(); var kestrelServer = new KestrelServer(new ConfigureKestrelServerOptions(), new SocketTransportFactory(new ConfigureSocketTransportOptions(), loggerFactory), loggerFactory); kestrelServer.Options.ListenLocalhost(8080); kestrelServer.StartAsync(new HttpApp(), CancellationToken.None).GetAwaiter().GetResult(); // todo: you can update this code to do some other processing on this thread, and you can remove the call to StopAsync() if you don't need it. Thread.Sleep(60000); Console.WriteLine("shutting down"); kestrelServer.StopAsync(CancellationToken.None).GetAwaiter().GetResult(); }
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); }
public Task Load(JObject config, Core.Logging.Abstractions.ILogger logger) { _logger = logger; Configure(config); UrlMapper.RegisterIndexFile("index.html"); UrlMapper.RegisterIndexFile("index.htm"); _serviceProvider = SetupServiceCollection().BuildServiceProvider(); _loggerFactory = LoggerFactory.Create(builder => { builder.AddProvider(new HtcLoggerProvider(_logger)); }); _socketTransportFactory = new SocketTransportFactory(GetSocketTransportOptions(config), _loggerFactory); _kestrelServer = new KestrelServer(GetKestrelServerOptions(config, _serviceProvider), _socketTransportFactory, _loggerFactory); return(Task.CompletedTask); }
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); }
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(); }
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);
public void Stop() { lock (_syncObject) { if (!IsRunning) { return; } _cts.Cancel(); _kestrelServer.Dispose(); _kestrelServer = null; IsRunning = false; } _log.Info("Http server stopped"); }
public async Task StartAsync(CancellationToken cancellationToken) { var transportOptions = new SocketTransportOptions { }; _server = new KestrelServer( Options.Create(_options), new SocketTransportFactory(Options.Create(transportOptions), _loggerFactory), _loggerFactory); var app = new ApplicationBuilderFactory(_provider).CreateBuilder(_server.Features); _pipeline.Configure(app); var requestDelegate = app.Build(); await _server.StartAsync(new GrpcApplication(requestDelegate, _provider), cancellationToken); }
public void Start(string prefix) { lock (_syncObject) { if (IsRunning) { return; } _kestrelServer = CreateKestrelServer(prefix); _kestrelServer.Features.Get <IServerAddressesFeature>().Addresses.Add(prefix); _cts = new CancellationTokenSource(); _kestrelServer.StartAsync(new HttpApplication(_handler.Handle, _log), _cts.Token).Wait(); IsRunning = true; _log.Info($"Http server started on {prefix}"); } }
public async Task RunAsync(ITransportFactory transportFactory, IEndPointInformation endPointInformation, ApplicationLifetime lifetime) { Console.CancelKeyPress += (sender, e) => lifetime.StopApplication(); var serverOptions = new KestrelServerOptions(); serverOptions.Listen(endPointInformation.IPEndPoint); var server = new KestrelServer(Options.Create(serverOptions), transportFactory, NullLoggerFactory.Instance); await server.StartAsync(this, CancellationToken.None); Console.WriteLine($"Server ({nameof(PlainTextApplication)}) listening on http://{endPointInformation.IPEndPoint}"); lifetime.ApplicationStopping.WaitHandle.WaitOne(); await server.StopAsync(CancellationToken.None); }
public WebSocketConnectionListener(KestrelServer server, IServiceProvider serviceProvider, string path) { _server = server; var builder = new ApplicationBuilder(serviceProvider); builder.UseRouting(); builder.UseEndpoints(routes => { routes.MapConnections(path, cb => cb.Run(inner => { var connection = new WebSocketConnectionContext(inner); _acceptQueue.Writer.TryWrite(connection); return(connection.ExecutionTask); })); }); _application = builder.Build(); }
public KestrelOwinServer(KestrelServerOptions options) { if (options == null) { throw new ArgumentNullException(nameof(options)); } var wrappedOptions = Options.Create(options); var loggerFactory = new LoggerFactory(); loggerFactory.AddProvider(new ConsoleLogProvider()); var transport = new LibuvTransportFactory( Options.Create(new LibuvTransportOptions()), new ApplicationLifetime(loggerFactory.CreateLogger <ApplicationLifetime>()), loggerFactory); Server = new KestrelServer(wrappedOptions, transport, loggerFactory); }