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();
}));
}
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();
}
}
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 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);
}
private SocketTransportFactory CreatSocketTransportFactory(ApplicationLifetime lifeTime,
LoggerFactory loggerFactory)
{
var configureOptions = new ConfigureOptions <SocketTransportOptions>(transportOptions =>
transportOptions.IOQueueCount = _serverSettings.IOQueueCount);
var optionsFactory = new OptionsFactory <SocketTransportOptions>(new[] { configureOptions },
new List <IPostConfigureOptions <SocketTransportOptions> >());
var optionsManager = new OptionsManager <SocketTransportOptions>(optionsFactory);
var socketTransportFactory = new SocketTransportFactory(optionsManager, lifeTime, loggerFactory);
return(socketTransportFactory);
}
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);
}
private SocketTransportFactory GetSocketTransportFactory()
{
var transportFactory = new SocketTransportFactory(
Options.Create(new SocketTransportOptions
{
IOQueueCount = 42
}),
this,
this
);
return(transportFactory);
}
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);
}
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 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 Task Start()
{
IHttpApplication <HostingApplication.Context> app;
try
{
if (_handler == null)
{
throw new Exception("Missing Handler - Call SetHandler()");
}
ILoggerFactory loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(new KestrelLoggerProvider());
var services = new ServiceCollection();
services.AddSingleton(loggerFactory);
services.AddLogging();
var serviceProvider = GetProviderFromFactory(services);
var kestrelServerOptions = Options.Create(new KestrelServerOptions());
kestrelServerOptions.Value.ApplicationServices = serviceProvider;
foreach (uint httpPort in _setting.HttpPorts)
{
kestrelServerOptions.Value.ListenAnyIP((int)httpPort);
}
if (_setting.HttpsEnabled)
{
kestrelServerOptions.Value.ListenAnyIP(_setting.HttpsPort,
listenOptions =>
{
var cert = new X509Certificate2(_setting.HttpsCertPath,
_setting.HttpsCertPw);
listenOptions.UseHttps(new HttpsConnectionAdapterOptions
{
ServerCertificate = cert
// SslProtocols = SslProtocols.Tls12 | SslProtocols.Tls11 | SslProtocols.Tls
});
});
}
// kestrelServerOptions.Value.ListenAnyIP(_setting.WebSetting.HttpsPort);
kestrelServerOptions.Value.AddServerHeader = false;
var socketTransportOptions = Options.Create(new SocketTransportOptions());
_applicationLifetime = new ApplicationLifetime(
loggerFactory.CreateLogger <ApplicationLifetime>()
);
ITransportFactory transportFactory = new SocketTransportFactory(
socketTransportOptions, _applicationLifetime, loggerFactory
);
_server = new KestrelServer(kestrelServerOptions, transportFactory, loggerFactory);
var diagnosticListener = new DiagnosticListener("a");
var formOptions = Options.Create(new FormOptions());
IHttpContextFactory httpContextFactory = new HttpContextFactory(formOptions);
app = new HostingApplication(
RequestDelegate,
loggerFactory.CreateLogger <KestrelWebServer>(),
diagnosticListener,
httpContextFactory
);
}
catch (Exception ex)
{
Logger.Exception(ex);
return;
}
var kestrelStartup = _server.StartAsync(app, _cancellationTokenSource.Token);
await kestrelStartup;
_cancellationTokenSource.Token.Register(
state => ((IApplicationLifetime)state).StopApplication(),
_applicationLifetime
);
var completionSource = new TaskCompletionSource <object>(
TaskCreationOptions.RunContinuationsAsynchronously
);
_applicationLifetime.ApplicationStopping.Register(
obj => ((TaskCompletionSource <object>)obj).TrySetResult(null),
completionSource
);
var kestrelCompleted = completionSource.Task;
var kestrelCompletedResult = await kestrelCompleted;
var kestrelShutdown = _server.StopAsync(new CancellationToken());
await kestrelShutdown;
}
public LibraryModeServer(Protocol.IProcessorFactory processorFactory, SocketTransportFactory transportFactory) :
base(processorFactory, transportFactory)
{
}
public async Task ThrowsNotImplementedExceptionWhenBindingToUriEndPoint()
{
var socketTransportFactory = new SocketTransportFactory(Options.Create(new SocketTransportOptions()), new LoggerFactory());
await Assert.ThrowsAsync <NotImplementedException>(async() => await socketTransportFactory.BindAsync(new UriEndPoint(new Uri("http://127.0.0.1:5554"))));
}
public async ValueTask <IConnectionListener> BindAsync(EndPoint endpoint, CancellationToken cancellationToken = default)
{
IPEndPoint iPEndPoint = null;
var path = "";
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);
path = uriEndPoint.Uri.LocalPath != "/" ? uriEndPoint.Uri.LocalPath : "";
break;
case IPEndPoint ip:
iPEndPoint = ip;
break;
default:
throw new NotSupportedException($"{endpoint} not supported");
}
var services = new ServiceCollection();
services.AddOptions();
services.AddSingleton(_loggerFactory);
services.AddLogging();
services.AddConnections();
services.AddSingleton <IHostApplicationLifetime>(this);
var diagnosticListener = new DiagnosticListener("WebSocketServer");
services.AddSingleton(diagnosticListener);
var serverOptions = Options.Create(new KestrelServerOptions()
{
ApplicationServices = services.BuildServiceProvider()
});;
var socketOptions = Options.Create(new SocketTransportOptions());
IConnectionListenerFactory transportFactories = new SocketTransportFactory(socketOptions, _loggerFactory);
var server = new KestrelServer(serverOptions, transportFactories, _loggerFactory);
ListenOptions listenOptions = null;
// Bind an HTTP/1 endpoint
server.Options.Listen(iPEndPoint, o =>
{
o.UseHttps();
o.Protocols = HttpProtocols.Http1;
// Storing the options so we can get the resolved EndPoint later
listenOptions = o;
});
var listener = new WebSocketConnectionListener(server, _configure, serverOptions.Value.ApplicationServices, path);
await listener.BindAsync(cancellationToken);
listener.EndPoint = listenOptions.IPEndPoint;
return(listener);
}
public TrialSocketTransportFactory(SocketTransportFactory factory)
{
_factory = factory;
}
public async Task ThrowsNotSupportedExceptionWhenBindingToFileHandleEndPoint()
{
var socketTransportFactory = new SocketTransportFactory(Options.Create(new SocketTransportOptions()), Mock.Of <ILoggerFactory>());
await Assert.ThrowsAsync <NotSupportedException>(async() => await socketTransportFactory.BindAsync(new FileHandleEndPoint(0, FileHandleType.Auto)));
}
