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);
}
