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