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 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 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);
}
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 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();
}
/// <summary>
/// Shuts down the server
/// </summary>
public async Task StopAsync()
{
if (IsListening)
{
IsListening = false;
_stopSource.Cancel();
var cts = new CancellationTokenSource(500);
await _server.StopAsync(cts.Token);
_stopSource.Dispose();
_server.Dispose();
}
}
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 void Run()
{
var serviceCollection = new ServiceCollection();
serviceCollection.AddTransient <IHttpContextFactory, DefaultHttpContextFactory>();
serviceCollection.AddTransient <ILogger, Logger <KestrelServer> >();
var listener = new DiagnosticListener("HtcSharpServer");
serviceCollection.AddSingleton <DiagnosticListener>(listener);
serviceCollection.AddSingleton <DiagnosticSource>(listener);
serviceCollection.AddOptions();
serviceCollection.AddLogging();
var serviceProvider = serviceCollection.BuildServiceProvider();
var loggerFactory = LoggerFactory.Create(DoSomething);
var socketListener = new SocketTransportFactory(GetSocketTransportOptions(), loggerFactory);
var kestrelServer = new KestrelServer(GetKestrelServerOptions(serviceProvider), socketListener, loggerFactory);
while (true)
{
Console.Write(@"> ");
var msg = Console.ReadLine();
if (msg == null)
{
continue;
}
if (msg.Equals("exit", StringComparison.CurrentCultureIgnoreCase))
{
kestrelServer.StopAsync(CancellationToken.None).GetAwaiter().GetResult();
return;
}
else if (msg.Equals("start", StringComparison.CurrentCultureIgnoreCase))
{
Start(kestrelServer, serviceProvider, loggerFactory);
}
}
}
public async ValueTask UnbindAsync(CancellationToken cancellationToken = default)
{
await _server.StopAsync(cancellationToken);
}
public async ValueTask UnbindAsync(CancellationToken cancellationToken = default)
{
await _server.StopAsync(cancellationToken).ConfigureAwait(false);
_acceptQueue.Writer.TryComplete();
}
public async Task Stop()
{
_stopCancellationToken = new CancellationTokenSource();
await _kestrelServer.StopAsync(_stopCancellationToken.Token);
}
public async Task StopAsync(CancellationToken cancellationToken)
{
await _server.StopAsync(cancellationToken);
}
