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