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 KestrelStackTransportFactory(
IOptions <SocketTransportOptions> options,
IApplicationLifetime applicationLifetime,
ILoggerFactory loggerFactory)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (applicationLifetime == null)
{
throw new ArgumentNullException(nameof(applicationLifetime));
}
if (loggerFactory == null)
{
throw new ArgumentNullException(nameof(loggerFactory));
}
Options = options.Value;
AppLifeTime = applicationLifetime;
var logger = loggerFactory.CreateLogger("Microsoft.AspNetCore.Server.Kestrel.Transport.Sockets");
Trace = new SocketsTrace(logger);
}
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 SocketConnectionFactory(IOptions <SocketTransportOptions> options, ILoggerFactory loggerFactory)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (loggerFactory == null)
{
throw new ArgumentNullException(nameof(loggerFactory));
}
_options = options.Value;
_memoryPool = options.Value.MemoryPoolFactory();
_trace = loggerFactory.CreateLogger("Microsoft.AspNetCore.Server.Kestrel.Transport.Sockets.Client");
var maxReadBufferSize = _options.MaxReadBufferSize ?? 0;
var maxWriteBufferSize = _options.MaxWriteBufferSize ?? 0;
// These are the same, it's either the thread pool or inline
var applicationScheduler = _options.UnsafePreferInlineScheduling ? PipeScheduler.Inline : PipeScheduler.ThreadPool;
var transportScheduler = applicationScheduler;
// https://github.com/aspnet/KestrelHttpServer/issues/2573
var awaiterScheduler = OperatingSystem.IsWindows() ? transportScheduler : PipeScheduler.Inline;
_inputOptions = new PipeOptions(_memoryPool, applicationScheduler, transportScheduler, maxReadBufferSize, maxReadBufferSize / 2, useSynchronizationContext: false);
_outputOptions = new PipeOptions(_memoryPool, transportScheduler, applicationScheduler, maxWriteBufferSize, maxWriteBufferSize / 2, useSynchronizationContext: false);
_socketSenderPool = new SocketSenderPool(awaiterScheduler);
}
public static IOptions <SocketTransportOptions> GetSocketTransportOptions()
{
var socketTransportOptions = new SocketTransportOptions();
var optionFactory = Options.Create <SocketTransportOptions>(socketTransportOptions);
return(optionFactory);
}
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();
}
private static IOptions <SocketTransportOptions> GetSocketTransportOptions(JObject config)
{
var socketTransportOptions = new SocketTransportOptions();
IOptions <SocketTransportOptions> optionFactory = Microsoft.Extensions.Options.Options.Create(socketTransportOptions);
return(optionFactory);
}
public RegisteredSocketTransportFactory(IOptions <SocketTransportOptions> options)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
_options = options.Value;
}
internal SocketConnectionFactoryOptions(SocketTransportOptions transportOptions)
{
IOQueueCount = transportOptions.IOQueueCount;
WaitForDataBeforeAllocatingBuffer = transportOptions.WaitForDataBeforeAllocatingBuffer;
MaxReadBufferSize = transportOptions.MaxReadBufferSize;
MaxWriteBufferSize = transportOptions.MaxWriteBufferSize;
UnsafePreferInlineScheduling = transportOptions.UnsafePreferInlineScheduling;
MemoryPoolFactory = transportOptions.MemoryPoolFactory;
}
public void CreateDefaultBoundListenSocket_PreservesLocalEndpointFromFileHandleEndpoint()
{
using var fileHandleSocket = CreateBoundSocket();
var endpoint = new FileHandleEndPoint((ulong)fileHandleSocket.Handle, FileHandleType.Auto);
using var listenSocket = SocketTransportOptions.CreateDefaultBoundListenSocket(endpoint);
Assert.NotNull(fileHandleSocket.LocalEndPoint);
Assert.Equal(fileHandleSocket.LocalEndPoint, listenSocket.LocalEndPoint);
}
internal SocketConnectionListener(
EndPoint endpoint,
SocketTransportOptions options,
ILoggerFactory loggerFactory)
{
EndPoint = endpoint;
_options = options;
var logger = loggerFactory.CreateLogger("Microsoft.AspNetCore.Server.Kestrel.Transport.Sockets");
_logger = logger;
_factory = new SocketConnectionContextFactory(new SocketConnectionFactoryOptions(options), logger);
}
public SocketTransportFactory(
IOptions <SocketTransportOptions> options,
ILoggerFactory loggerFactory)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (loggerFactory == null)
{
throw new ArgumentNullException(nameof(loggerFactory));
}
_options = options.Value;
_logger = loggerFactory;
}
public SocketConnectionFactory(IOptions <SocketTransportOptions> options, ILoggerFactory loggerFactory)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (loggerFactory == null)
{
throw new ArgumentNullException(nameof(loggerFactory));
}
_options = options.Value;
_memoryPool = options.Value.MemoryPoolFactory();
var logger = loggerFactory.CreateLogger("Microsoft.AspNetCore.Server.Kestrel.Transport.Sockets.Client");
_trace = new SocketsTrace(logger);
}
public SocketConnectionFactory(IOptions <SocketTransportOptions> options, ILoggerFactory loggerFactory)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (loggerFactory == null)
{
throw new ArgumentNullException(nameof(loggerFactory));
}
_options = options.Value;
_memoryPool = options.Value.MemoryPoolFactory();
var logger = loggerFactory.CreateLogger("Tmds.LinuxAsync.Transport.Client");
_trace = new SocketsTrace(logger);
}
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);
}
/// <summary>
/// Adds AirDrop services to the specified <see cref="IServiceCollection" />.
/// </summary>
/// <param name="services">The <see cref="IServiceCollection" /> to add services to.</param>
/// <param name="setupAction">An <see cref="Action{AirDropOptions}"/> to configure the provided <see cref="AirDropOptions"/>.</param>
public static IServiceCollection AddAirDrop(this IServiceCollection services, Action <AirDropOptions>?setupAction = null)
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
Utils.AssertPlatform();
Utils.AssertNetworkInterfaces();
services.AddScoped <AirDropRouteHandler>();
services.AddSingleton <AirDropService>();
services.AddSingleton <IHostedService>(s => s.GetService <AirDropService>() !);
services.AddOptions <AirDropOptions>().ValidateDataAnnotations();
services.Configure <SocketTransportOptions>(
x =>
{
// on macOS, ensure we listen on the awdl0 interface
// by setting the SO_RECV_ANYIF socket option
if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
{
x.CreateBoundListenSocket = endpoint =>
{
var socket = SocketTransportOptions.CreateDefaultBoundListenSocket(endpoint);
if (endpoint is IPEndPoint)
{
socket.SetAwdlSocketOption();
}
return(socket);
};
}
});
if (setupAction != null)
{
services.Configure(setupAction);
}
return(services);
}
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();
}
}
private async Task VerifySocketTransportCallsCreateBoundListenSocketAsync(EndPoint endpointToTest)
{
var wasCalled = false;
Socket CreateListenSocket(EndPoint endpoint)
{
wasCalled = true;
return(SocketTransportOptions.CreateDefaultBoundListenSocket(endpoint));
}
using var host = CreateWebHost(
endpointToTest,
options =>
{
options.CreateBoundListenSocket = CreateListenSocket;
}
);
await host.StartAsync();
Assert.True(wasCalled, $"Expected {nameof(SocketTransportOptions.CreateBoundListenSocket)} to be called.");
await host.StopAsync();
}
public RegisteredSocketConnectionListener(SocketTransportOptions options, AddressFamily addressFamily)
{
_options = options;
_listener = new RegisteredSocketListener(_multiplexer, addressFamily, SocketType.Stream, ProtocolType.Tcp);
}
private static void SetSocketOptions(SocketTransportOptions socketTransportOptions)
{
Console.WriteLine($"Using Sockets with {socketTransportOptions.IOQueueCount} threads");
}
public void CreateDefaultBoundListenSocket_BindsForNewEndPoints(EndPoint endpoint)
{
using var listenSocket = SocketTransportOptions.CreateDefaultBoundListenSocket(endpoint);
Assert.NotNull(listenSocket.LocalEndPoint);
}
public KestrelStackConnectionListener(KestrelServerWithStack server, EndPoint endpoint, SocketTransportOptions options)
{
this.Server = server;
this.EndPoint = endpoint;
this._options = options;
}
