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(); }
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 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); }
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); }
/// <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(); })); }
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); }
// 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); }
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 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); }
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 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 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 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 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 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); }
static async Task Main(string[] args) { var serverOptions = new KestrelServerOptions(); serverOptions.ListenAnyIP(8080); var transportOptions = new SocketTransportOptions(); var loggerFactory = new NullLoggerFactory(); var applicationLifetime = new ApplicationLifetime(); var transportFactory = new SocketTransportFactory( new OptionsWrapper <SocketTransportOptions>(transportOptions), applicationLifetime, loggerFactory); using (var server = new KestrelServer(new OptionsWrapper <KestrelServerOptions>(serverOptions), transportFactory, loggerFactory)) { await server.StartAsync(new Application(), CancellationToken.None); Console.ReadLine(); } }
public void Start() { RegisterCVars(); if (!_configurationManager.GetCVar <bool>("status.enabled")) { return; } ConfigureSawmills(); _ctxFactory = CreateHttpContextFactory(); var kestrelOpts = new KestrelServerOptions { AllowSynchronousIO = true, ApplicationSchedulingMode = SchedulingMode.ThreadPool }; kestrelOpts.Listen(GetBinding()); _server = new KestrelServer( Options.Create( kestrelOpts ), GetSocketTransportFactory(), this ); RegisterHandlers(); _server.StartAsync(this, ApplicationStopping); _syncCtx = SynchronizationContext.Current !; if (_syncCtx == null) { SynchronizationContext.SetSynchronizationContext(_syncCtx = new SynchronizationContext()); } }
public async Task StopAsyncDispatchesSubsequentStopAsyncContinuations() { var options = new KestrelServerOptions { ListenOptions = { new ListenOptions(new IPEndPoint(IPAddress.Loopback, 0)) } }; var unbindTcs = new TaskCompletionSource <object>(TaskCreationOptions.RunContinuationsAsynchronously); var mockTransport = new Mock <ITransport>(); mockTransport .Setup(transport => transport.BindAsync()) .Returns(Task.CompletedTask); mockTransport .Setup(transport => transport.UnbindAsync()) .Returns(unbindTcs.Task); 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(), default); var stopTask1 = server.StopAsync(default);
public static async Task Main(string[] args) { TaskScheduler.UnobservedTaskException += (sender, e) => { Console.WriteLine("Unobserved exception: {0}", e.Exception); }; if (args.Length != 2) { Console.WriteLine("Usage: PerfViewJS portNumber DataRoot"); return; } string defaultAuthorizationHeaderForSourceLink = Environment.GetEnvironmentVariable("PerfViewJS_DefaultAuthorizationHeaderForSourceLink"); var defaultEventSourceLoggerFactory = new DefaultEventSourceLoggerFactory(); var startup = new Startup(Directory.GetCurrentDirectory(), args[1], defaultAuthorizationHeaderForSourceLink); var server = new KestrelServer(new KestrelServerOptionsConfig(int.Parse(args[0])), new SocketTransportFactory(new SocketTransportOptionsConfig(), defaultEventSourceLoggerFactory), defaultEventSourceLoggerFactory); await server.StartAsync(new HttpApplication(startup.HandleRequest), CancellationToken.None); Thread.Sleep(Timeout.Infinite); }
public async void Start(KestrelServer kestrelServer, IServiceProvider serviceProvider, ILoggerFactory loggerFactory) { var logger = loggerFactory.CreateLogger("ConsoleRequester"); await kestrelServer.StartAsync(new HostingApplication(logger, serviceProvider.GetRequiredService <IHttpContextFactory>()), CancellationToken.None); }
public Task BindAsync(CancellationToken cancellationToken) { return(_server.StartAsync(this, cancellationToken)); }
public async Task Start() { _startCancellationToken = new CancellationTokenSource(); var logger = _loggerFactory.CreateLogger("HtcLogger"); await _kestrelServer.StartAsync(new HostingApplication(this, logger, _serviceProvider.GetRequiredService <IHttpContextFactory>()), _startCancellationToken.Token); }