internal SocketTransport( IEndPointInformation endPointInformation, IConnectionDispatcher dispatcher, IApplicationLifetime applicationLifetime, int ioQueueCount, ISocketsTrace trace) { Debug.Assert(endPointInformation != null); Debug.Assert(endPointInformation.Type == ListenType.IPEndPoint); Debug.Assert(dispatcher != null); Debug.Assert(applicationLifetime != null); Debug.Assert(trace != null); _endPointInformation = endPointInformation; _dispatcher = dispatcher; _appLifetime = applicationLifetime; _trace = trace; if (ioQueueCount > 0) { _numSchedulers = ioQueueCount; _schedulers = new IOQueue[_numSchedulers]; for (var i = 0; i < _numSchedulers; i++) { _schedulers[i] = new IOQueue(); } } else { _numSchedulers = ThreadPoolSchedulerArray.Length; _schedulers = ThreadPoolSchedulerArray; } }
internal SocketConnection(Socket socket, MemoryPool <byte> memoryPool, PipeScheduler scheduler, ISocketsTrace trace) { Debug.Assert(socket != null); Debug.Assert(memoryPool != null); Debug.Assert(trace != null); _socket = socket; MemoryPool = memoryPool; _scheduler = scheduler; _trace = trace; var localEndPoint = (IPEndPoint)_socket.LocalEndPoint; var remoteEndPoint = (IPEndPoint)_socket.RemoteEndPoint; LocalAddress = localEndPoint.Address; LocalPort = localEndPoint.Port; RemoteAddress = remoteEndPoint.Address; RemotePort = remoteEndPoint.Port; // On *nix platforms, Sockets already dispatches to the ThreadPool. var awaiterScheduler = IsWindows ? _scheduler : PipeScheduler.Inline; _receiver = new SocketReceiver(_socket, awaiterScheduler); _sender = new SocketSender(_socket, awaiterScheduler); }
internal SocketConnection(Socket socket, MemoryPool <byte> memoryPool, PipeScheduler scheduler, ISocketsTrace trace) { Debug.Assert(socket != null); Debug.Assert(memoryPool != null); Debug.Assert(trace != null); _socket = socket; MemoryPool = memoryPool; _scheduler = scheduler; _trace = trace; var localEndPoint = (IPEndPoint)_socket.LocalEndPoint; var remoteEndPoint = (IPEndPoint)_socket.RemoteEndPoint; LocalAddress = localEndPoint.Address; LocalPort = localEndPoint.Port; RemoteAddress = remoteEndPoint.Address; RemotePort = remoteEndPoint.Port; ConnectionClosed = _connectionClosedTokenSource.Token; _receiver = new SocketReceiver(_socket, _scheduler); _sender = new SocketSender(_socket, _scheduler); }
internal SocketConnection(Socket socket, MemoryPool <byte> memoryPool, PipeScheduler scheduler, ISocketsTrace trace) { Debug.Assert(socket != null); Debug.Assert(memoryPool != null); Debug.Assert(trace != null); _socket = socket; MemoryPool = memoryPool; _scheduler = scheduler; _trace = trace; var localEndPoint = (IPEndPoint)_socket.LocalEndPoint; var remoteEndPoint = (IPEndPoint)_socket.RemoteEndPoint; LocalAddress = localEndPoint.Address; LocalPort = localEndPoint.Port; RemoteAddress = remoteEndPoint.Address; RemotePort = remoteEndPoint.Port; ConnectionClosed = _connectionClosedTokenSource.Token; // On *nix platforms, Sockets already dispatches to the ThreadPool. // Yes, the IOQueues are still used for the PipeSchedulers. This is intentional. // https://github.com/aspnet/KestrelHttpServer/issues/2573 var awaiterScheduler = IsWindows ? _scheduler : PipeScheduler.Inline; _receiver = new SocketReceiver(_socket, awaiterScheduler); _sender = new SocketSender(_socket, awaiterScheduler); }
internal SocketConnectionListener( EndPoint endpoint, SocketTransportOptions options, ISocketsTrace trace) { EndPoint = endpoint; _trace = trace; _options = options; _memoryPool = _options.MemoryPoolFactory(); var ioQueueCount = options.IOQueueCount; if (ioQueueCount > 0) { _numSchedulers = ioQueueCount; _schedulers = new IOQueue[_numSchedulers]; for (var i = 0; i < _numSchedulers; i++) { _schedulers[i] = new IOQueue(); } } else { var directScheduler = new PipeScheduler[] { PipeScheduler.ThreadPool }; _numSchedulers = directScheduler.Length; _schedulers = directScheduler; } }
internal SocketConnectionListener( EndPoint endpoint, SocketTransportOptions options, ISocketsTrace trace) { EndPoint = endpoint; this.trace = trace; this.options = options; memoryPool = MemoryPool <byte> .Shared; var ioQueueCount = options.IOQueueCount; if (ioQueueCount > 0) { numSchedulers = ioQueueCount; schedulers = new IOQueue[numSchedulers]; for (var i = 0; i < numSchedulers; i++) { schedulers[i] = new IOQueue(); } } else { var directScheduler = new PipeScheduler[] { PipeScheduler.ThreadPool }; numSchedulers = directScheduler.Length; schedulers = directScheduler; } }
internal SocketConnection(Socket socket) { Debug.Assert(socket != null); _socket = socket; _trace = new EmptySocketsTrace(); var localEndPoint = (IPEndPoint)_socket.LocalEndPoint; var remoteEndPoint = (IPEndPoint)_socket.RemoteEndPoint; LocalAddress = localEndPoint.Address; LocalPort = localEndPoint.Port; RemoteAddress = remoteEndPoint.Address; RemotePort = remoteEndPoint.Port; ConnectionClosed = _connectionClosedTokenSource.Token; var pair = DuplexPipe.CreateConnectionPair(); Transport = pair.Transport; Application = pair.Application; PipeScheduler scheduler = MultiIOQueueGroup.GetIOQueue(); _receiver = new SocketReceiver(_socket, scheduler); _sender = new SocketSender(_socket, scheduler); }
/// <summary> /// Creates the <see cref="SocketConnectionContextFactory"/>. /// </summary> /// <param name="options">The options.</param> /// <param name="logger">The logger.</param> public SocketConnectionContextFactory(SocketConnectionFactoryOptions options, ILogger logger) { if (options == null) { throw new ArgumentNullException(nameof(options)); } if (logger == null) { throw new ArgumentNullException(nameof(logger)); } _options = options; _trace = new SocketsTrace(logger); _memoryPool = _options.MemoryPoolFactory(); _settingsCount = _options.IOQueueCount; var maxReadBufferSize = _options.MaxReadBufferSize ?? 0; var maxWriteBufferSize = _options.MaxWriteBufferSize ?? 0; var applicationScheduler = options.UnsafePreferInlineScheduling ? PipeScheduler.Inline : PipeScheduler.ThreadPool; if (_settingsCount > 0) { _settings = new QueueSettings[_settingsCount]; for (var i = 0; i < _settingsCount; i++) { var transportScheduler = options.UnsafePreferInlineScheduling ? PipeScheduler.Inline : new IOQueue(); // https://github.com/aspnet/KestrelHttpServer/issues/2573 var awaiterScheduler = OperatingSystem.IsWindows() ? transportScheduler : PipeScheduler.Inline; _settings[i] = new QueueSettings() { Scheduler = transportScheduler, 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) }; } } else { var transportScheduler = options.UnsafePreferInlineScheduling ? PipeScheduler.Inline : PipeScheduler.ThreadPool; // https://github.com/aspnet/KestrelHttpServer/issues/2573 var awaiterScheduler = OperatingSystem.IsWindows() ? transportScheduler : PipeScheduler.Inline; _settings = new QueueSettings[] { new QueueSettings() { Scheduler = transportScheduler, 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) } }; _settingsCount = 1; } }
internal SocketConnection(Socket socket, MemoryPool <byte> memoryPool, PipeScheduler scheduler, ISocketsTrace trace, long?maxReadBufferSize = null, long?maxWriteBufferSize = null, bool deferSends = true, bool deferReceives = true, SocketContinuationScheduler socketScheduler = SocketContinuationScheduler.ThreadPool, InputScheduler inputScheduler = InputScheduler.ThreadPool, bool dontAllocateMemoryForIdleConnections = true, OutputScheduler outputScheduler = OutputScheduler.IOQueue) { Debug.Assert(socket != null); Debug.Assert(memoryPool != null); Debug.Assert(trace != null); _socket = socket; MemoryPool = memoryPool; _trace = trace; _waitForReceiveReady = dontAllocateMemoryForIdleConnections; LocalEndPoint = _socket.LocalEndPoint; RemoteEndPoint = _socket.RemoteEndPoint; ConnectionClosed = _connectionClosedTokenSource.Token; // On *nix platforms, Sockets already dispatches to the ThreadPool. // Yes, the IOQueues are still used for the PipeSchedulers. This is intentional. // https://github.com/aspnet/KestrelHttpServer/issues/2573 var awaiterScheduler = IsWindows ? scheduler : PipeScheduler.Inline; _receiver = new SocketReceiver(_socket, awaiterScheduler, runContinuationsAsynchronously: socketScheduler == SocketContinuationScheduler.ThreadPool, preferSynchronousCompletion: !deferReceives); _sender = new SocketSender(_socket, awaiterScheduler, runContinuationsAsynchronously: socketScheduler == SocketContinuationScheduler.ThreadPool, preferSynchronousCompletion: !deferSends); maxReadBufferSize ??= 0; maxWriteBufferSize ??= 0; PipeScheduler pipeScheduler = outputScheduler switch { OutputScheduler.Inline => PipeScheduler.Inline, OutputScheduler.IOQueue => scheduler, OutputScheduler.IOThread => _socket.IOThreadScheduler, OutputScheduler.ThreadPool => PipeScheduler.ThreadPool, _ => throw new IndexOutOfRangeException() }; var appScheduler = inputScheduler == InputScheduler.Inline ? PipeScheduler.Inline : PipeScheduler.ThreadPool; var inputOptions = new PipeOptions(MemoryPool, appScheduler, scheduler, maxReadBufferSize.Value, maxReadBufferSize.Value / 2, useSynchronizationContext: false); var outputOptions = new PipeOptions(MemoryPool, pipeScheduler, appScheduler, maxWriteBufferSize.Value, maxWriteBufferSize.Value / 2, useSynchronizationContext: false); var pair = DuplexPipe.CreateConnectionPair(inputOptions, outputOptions); // Set the transport and connection id Transport = pair.Transport; Application = pair.Application; }
internal SocketConnectionListener( EndPoint endpoint, SocketTransportOptions options, ISocketsTrace trace) { EndPoint = endpoint; _trace = trace; _options = options; _memoryPool = _options.MemoryPoolFactory(); var ioQueueCount = options.IOQueueCount; var maxReadBufferSize = _options.MaxReadBufferSize ?? 0; var maxWriteBufferSize = _options.MaxWriteBufferSize ?? 0; var applicationScheduler = options.UnsafePreferInlineScheduling ? PipeScheduler.Inline : PipeScheduler.ThreadPool; if (ioQueueCount > 0) { _settingsCount = ioQueueCount; _settings = new Settings[_settingsCount]; for (var i = 0; i < _settingsCount; i++) { var transportScheduler = options.UnsafePreferInlineScheduling ? PipeScheduler.Inline : new IOQueue(); // https://github.com/aspnet/KestrelHttpServer/issues/2573 var awaiterScheduler = OperatingSystem.IsWindows() ? transportScheduler : PipeScheduler.Inline; _settings[i] = new Settings { Scheduler = transportScheduler, 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) }; } } else { var transportScheduler = options.UnsafePreferInlineScheduling ? PipeScheduler.Inline : PipeScheduler.ThreadPool; // https://github.com/aspnet/KestrelHttpServer/issues/2573 var awaiterScheduler = OperatingSystem.IsWindows() ? transportScheduler : PipeScheduler.Inline; var directScheduler = new Settings[] { new Settings { Scheduler = transportScheduler, 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) } }; _settingsCount = directScheduler.Length; _settings = directScheduler; } }
internal SocketConnectionListener( EndPoint endpoint, SocketTransportOptions options, ILoggerFactory loggerFactory) { EndPoint = endpoint; _options = options; var logger = loggerFactory.CreateLogger("Microsoft.AspNetCore.Server.Kestrel.Transport.Sockets"); _trace = new SocketsTrace(logger); _factory = new SocketConnectionContextFactory(new SocketConnectionFactoryOptions(options), logger); }
internal SocketConnection(Socket socket, MemoryPool <byte> memoryPool, PipeScheduler transportScheduler, ISocketsTrace trace, long?maxReadBufferSize = null, long?maxWriteBufferSize = null, bool waitForData = true, bool useInlineSchedulers = false) { Debug.Assert(socket != null); Debug.Assert(memoryPool != null); Debug.Assert(trace != null); _socket = socket; MemoryPool = memoryPool; _trace = trace; _waitForData = waitForData; LocalEndPoint = _socket.LocalEndPoint; RemoteEndPoint = _socket.RemoteEndPoint; ConnectionClosed = _connectionClosedTokenSource.Token; // On *nix platforms, Sockets already dispatches to the ThreadPool. // Yes, the IOQueues are still used for the PipeSchedulers. This is intentional. // https://github.com/aspnet/KestrelHttpServer/issues/2573 var awaiterScheduler = IsWindows ? transportScheduler : PipeScheduler.Inline; var applicationScheduler = PipeScheduler.ThreadPool; if (useInlineSchedulers) { transportScheduler = PipeScheduler.Inline; awaiterScheduler = PipeScheduler.Inline; applicationScheduler = PipeScheduler.Inline; } _receiver = new SocketReceiver(_socket, awaiterScheduler); _sender = new SocketSender(_socket, awaiterScheduler); maxReadBufferSize ??= 0; maxWriteBufferSize ??= 0; var inputOptions = new PipeOptions(MemoryPool, applicationScheduler, transportScheduler, maxReadBufferSize.Value, maxReadBufferSize.Value / 2, useSynchronizationContext: false); var outputOptions = new PipeOptions(MemoryPool, transportScheduler, applicationScheduler, maxWriteBufferSize.Value, maxWriteBufferSize.Value / 2, useSynchronizationContext: false); var pair = DuplexPipe.CreateConnectionPair(inputOptions, outputOptions); // Set the transport and connection id Transport = pair.Transport; Application = pair.Application; }
public SocketTransport(IEndPointInformation endPointInformation, IConnectionDispatcher dispatcher, int listenBacklog, int ioQueueCount, MemoryPool <byte> pool = null, ILogger logger = null) { if (endPointInformation == null) { throw new ArgumentNullException(nameof(endPointInformation)); } if (endPointInformation.Type != ListenType.IPEndPoint) { throw new InvalidOperationException(nameof(endPointInformation.IPEndPoint)); } if (dispatcher == null) { throw new ArgumentNullException(nameof(dispatcher)); } if (listenBacklog < 0) { throw new InvalidOperationException(nameof(listenBacklog)); } _endPointInformation = endPointInformation; _dispatcher = dispatcher; _backlog = listenBacklog; _pool = pool; _logger = logger ?? NullLoggerFactory.Instance.CreateLogger("NetGear.Core.SocketTransport"); _trace = new TraceDebugger(_logger); if (ioQueueCount > 0) { _numSchedulers = ioQueueCount; _cachedPipeOpts = new PipeOptionsPair[_numSchedulers]; for (var i = 0; i < _numSchedulers; i++) { _cachedPipeOpts[i] = new PipeOptionsPair( GetSendPipeOptions(_pool, new IOQueue()), GetReceivePipeOptions(_pool, new IOQueue())); } } else { _numSchedulers = 1; _cachedPipeOpts = new PipeOptionsPair[] { new PipeOptionsPair( GetSendPipeOptions(_pool, new IOQueue()), GetReceivePipeOptions(_pool, new IOQueue())) }; } }
internal SocketConnectionListener( EndPoint endpoint, SocketTransportOptions options, ISocketsTrace trace) { EndPoint = endpoint; _trace = trace; _options = options; _memoryPool = _options.MemoryPoolFactory(); var ioQueueCount = options.IOQueueCount; var maxReadBufferSize = _options.MaxReadBufferSize ?? 0; var maxWriteBufferSize = _options.MaxWriteBufferSize ?? 0; var applicationScheduler = options.UnsafePreferInlineScheduling ? PipeScheduler.Inline : PipeScheduler.ThreadPool; if (ioQueueCount > 0) { _settingsCount = ioQueueCount; _settings = new Settings[_settingsCount]; for (var i = 0; i < _settingsCount; i++) { var transportScheduler = options.UnsafePreferInlineScheduling ? PipeScheduler.Inline : new IOQueue(); _settings[i] = new Settings { Scheduler = transportScheduler, InputOptions = new PipeOptions(_memoryPool, applicationScheduler, transportScheduler, maxReadBufferSize, maxReadBufferSize / 2, useSynchronizationContext: false), OutputOptions = new PipeOptions(_memoryPool, transportScheduler, applicationScheduler, maxWriteBufferSize, maxWriteBufferSize / 2, useSynchronizationContext: false) }; } } else { var transportScheduler = options.UnsafePreferInlineScheduling ? PipeScheduler.Inline : PipeScheduler.ThreadPool; var directScheduler = new Settings[] { new Settings { Scheduler = transportScheduler, InputOptions = new PipeOptions(_memoryPool, applicationScheduler, transportScheduler, maxReadBufferSize, maxReadBufferSize / 2, useSynchronizationContext: false), OutputOptions = new PipeOptions(_memoryPool, transportScheduler, applicationScheduler, maxWriteBufferSize, maxWriteBufferSize / 2, useSynchronizationContext: false) } }; _settingsCount = directScheduler.Length; _settings = directScheduler; } }
internal SocketConnectionListener( EndPoint endpoint, SocketConnectionOptions options, ISocketsTrace trace, SocketSchedulers schedulers) { Debug.Assert(endpoint != null); Debug.Assert(endpoint is IPEndPoint); Debug.Assert(trace != null); EndPoint = endpoint; _trace = trace; _schedulers = schedulers; _options = options; _memoryPool = options.MemoryPoolFactory(); }
internal SocketTransport( IEndPointInformation endPointInformation, IConnectionHandler handler, IApplicationLifetime applicationLifetime, ISocketsTrace trace) { Debug.Assert(endPointInformation != null); Debug.Assert(endPointInformation.Type == ListenType.IPEndPoint); Debug.Assert(handler != null); Debug.Assert(applicationLifetime != null); Debug.Assert(trace != null); _endPointInformation = endPointInformation; _handler = handler; _appLifetime = applicationLifetime; _trace = trace; }
internal SocketTransport( IEndPointInformation endPointInformation, IConnectionHandler handler, ISocketsTrace trace) { Debug.Assert(endPointInformation != null); Debug.Assert(endPointInformation.Type == ListenType.IPEndPoint); Debug.Assert(handler != null); Debug.Assert(trace != null); _endPointInformation = endPointInformation; _handler = handler; _trace = trace; _listenSocket = null; _listenTask = null; }
private SocketConnection(Socket socket, PipeOptions sendPipeOptions, PipeOptions receivePipeOptions, SocketConnectionOptions socketConnectionOptions, string name, ILogger logger) { if (socket == null) { throw new ArgumentNullException(nameof(socket)); } if (string.IsNullOrWhiteSpace(name)) { Name = GetType().Name.Trim(); } if (sendPipeOptions == null) { sendPipeOptions = PipeOptions.Default; } if (receivePipeOptions == null) { receivePipeOptions = PipeOptions.Default; } Socket = socket; _logger = logger ?? NullLoggerFactory.Instance.CreateLogger("NetGear.Core.SocketConnection"); _trace = new TraceDebugger(_logger); var localEndPoint = (IPEndPoint)Socket.LocalEndPoint; var remoteEndPoint = (IPEndPoint)Socket.RemoteEndPoint; LocalAddress = localEndPoint.Address; LocalPort = localEndPoint.Port; RemoteAddress = remoteEndPoint.Address; RemotePort = remoteEndPoint.Port; SocketConnectionOptions = socketConnectionOptions; _sendOptions = sendPipeOptions; _receiveOptions = receivePipeOptions; _sendToSocket = new Pipe(_sendOptions); // read from this pipe and send to socket _receiveFromSocket = new Pipe(_receiveOptions); // recv from socket and push to this pipe _output = new WrappedWriter(_sendToSocket.Writer, this); _input = new WrappedReader(_receiveFromSocket.Reader, this); _sendOptions.ReaderScheduler.Schedule(s_DoSendAsync, this); _receiveOptions.WriterScheduler.Schedule(s_DoReceiveAsync, this); }
internal SocketConnection(Socket socket, PipeFactory pipeFactory, ISocketsTrace trace) { Debug.Assert(socket != null); Debug.Assert(pipeFactory != null); Debug.Assert(trace != null); _socket = socket; PipeFactory = pipeFactory; _trace = trace; var localEndPoint = (IPEndPoint)_socket.LocalEndPoint; var remoteEndPoint = (IPEndPoint)_socket.RemoteEndPoint; LocalAddress = localEndPoint.Address; LocalPort = localEndPoint.Port; RemoteAddress = remoteEndPoint.Address; RemotePort = remoteEndPoint.Port; }
internal SocketConnection(Socket socket, MemoryPool <byte> memoryPool, PipeScheduler scheduler, ISocketsTrace trace, long?maxReadBufferSize = null, long?maxWriteBufferSize = null) { Debug.Assert(socket != null); Debug.Assert(memoryPool != null); Debug.Assert(trace != null); this.socket = socket; this.MemoryPool = memoryPool; this.trace = trace; this.LocalEndPoint = this.socket.LocalEndPoint; this.RemoteEndPoint = this.socket.RemoteEndPoint; this.ConnectionClosed = connectionClosedTokenSource.Token; // On *nix platforms, Sockets already dispatches to the ThreadPool. // Yes, the IOQueues are still used for the PipeSchedulers. This is intentional. // https://github.com/aspnet/KestrelHttpServer/issues/2573 var awaiterScheduler = IsWindows ? scheduler : PipeScheduler.Inline; this.receiver = new SocketReceiver(this.socket, awaiterScheduler); this.sender = new SocketSender(this.socket, awaiterScheduler); maxReadBufferSize ??= 0; maxWriteBufferSize ??= 0; var inputOptions = new PipeOptions(MemoryPool, PipeScheduler.ThreadPool, scheduler, maxReadBufferSize.Value, maxReadBufferSize.Value / 2, useSynchronizationContext: false); var outputOptions = new PipeOptions(MemoryPool, scheduler, PipeScheduler.ThreadPool, maxWriteBufferSize.Value, maxWriteBufferSize.Value / 2, useSynchronizationContext: false); var pair = DuplexPipe.CreateConnectionPair(inputOptions, outputOptions); // Set the transport and connection id this.Transport = pair.Transport; this.Input = pair.Application.Output; this.Output = pair.Application.Input; this.ConnectionId = Guid.NewGuid().ToString(); }
public KestrelStackTransport( KestrelServerWithStack server, IEndPointInformation endPointInformation, IConnectionDispatcher dispatcher, IApplicationLifetime applicationLifetime, int ioQueueCount, ISocketsTrace trace) { Debug.Assert(endPointInformation != null); Debug.Assert(endPointInformation.Type == ListenType.IPEndPoint); Debug.Assert(dispatcher != null); Debug.Assert(applicationLifetime != null); Debug.Assert(trace != null); EndPointInformation = endPointInformation; Dispatcher = dispatcher; AppLifetime = applicationLifetime; Trace = trace; this.Server = server; }
internal SocketConnection(Socket socket, MemoryPool <byte> memoryPool, PipeScheduler transportScheduler, ISocketsTrace trace, SocketSenderPool socketSenderPool, PipeOptions inputOptions, PipeOptions outputOptions, bool waitForData = true) { Debug.Assert(socket != null); Debug.Assert(memoryPool != null); Debug.Assert(trace != null); _socket = socket; MemoryPool = memoryPool; _trace = trace; _waitForData = waitForData; _socketSenderPool = socketSenderPool; LocalEndPoint = _socket.LocalEndPoint; RemoteEndPoint = _socket.RemoteEndPoint; ConnectionClosed = _connectionClosedTokenSource.Token; // On *nix platforms, Sockets already dispatches to the ThreadPool. // Yes, the IOQueues are still used for the PipeSchedulers. This is intentional. // https://github.com/aspnet/KestrelHttpServer/issues/2573 var awaiterScheduler = OperatingSystem.IsWindows() ? transportScheduler : PipeScheduler.Inline; _receiver = new SocketReceiver(awaiterScheduler); var pair = DuplexPipe.CreateConnectionPair(inputOptions, outputOptions); _originalTransport = pair.Transport; Application = pair.Application; Transport = new SocketDuplexPipe(this); InitializeFeatures(); }
internal SocketConnection(Socket socket, MemoryPool memoryPool, ISocketsTrace trace) { Debug.Assert(socket != null); Debug.Assert(memoryPool != null); Debug.Assert(trace != null); _socket = socket; MemoryPool = memoryPool; _trace = trace; var localEndPoint = (IPEndPoint)_socket.LocalEndPoint; var remoteEndPoint = (IPEndPoint)_socket.RemoteEndPoint; LocalAddress = localEndPoint.Address; LocalPort = localEndPoint.Port; RemoteAddress = remoteEndPoint.Address; RemotePort = remoteEndPoint.Port; _receiver = new SocketReceiver(_socket); _sender = new SocketSender(_socket); }
internal SocketTransport( IEndPointInformation endPointInformation, IConnectionDispatcher dispatcher, IHostApplicationLifetime applicationLifetime, int ioQueueCount, ISocketsTrace trace, MemoryPool <byte> memoryPool) { Debug.Assert(endPointInformation != null); Debug.Assert(endPointInformation.Type == ListenType.IPEndPoint); Debug.Assert(dispatcher != null); Debug.Assert(applicationLifetime != null); Debug.Assert(trace != null); _endPointInformation = endPointInformation; _dispatcher = dispatcher; _appLifetime = applicationLifetime; _trace = trace; _memoryPool = memoryPool; if (ioQueueCount > 0) { _numSchedulers = ioQueueCount; _schedulers = new IOQueue[_numSchedulers]; for (var i = 0; i < _numSchedulers; i++) { _schedulers[i] = new IOQueue(); } } else { var directScheduler = new PipeScheduler[] { PipeScheduler.ThreadPool }; _numSchedulers = directScheduler.Length; _schedulers = directScheduler; } }