// For testing public LibuvTransport(LibuvFunctions uv, LibuvTransportContext context, IEndPointInformation endPointInformation) { Libuv = uv; TransportContext = context; _endPointInformation = endPointInformation; }
public Transport(IEndPointInformation ipEndPointInformation, IConnectionDispatcher connectionDispatcher, LinuxTransportOptions transportOptions, ILoggerFactory loggerFactory) { if (connectionDispatcher == null) { throw new ArgumentNullException(nameof(connectionDispatcher)); } if (transportOptions == null) { throw new ArgumentException(nameof(transportOptions)); } if (loggerFactory == null) { throw new ArgumentException(nameof(loggerFactory)); } if (ipEndPointInformation == null) { throw new ArgumentException(nameof(ipEndPointInformation)); } _endPoint = ipEndPointInformation; _connectionDispatcher = connectionDispatcher; _transportOptions = transportOptions; _loggerFactory = loggerFactory; _logger = loggerFactory.CreateLogger <Transport>(); _threads = Array.Empty <TransportThread>(); }
internal QuicTransport( IEndPointInformation endPointInformation, IConnectionDispatcher dispatcher, IApplicationLifetime applicationLifetime, int ioQueueCount, ILogger logger) { _endPointInformation = endPointInformation; _dispatcher = dispatcher; _applicationLifetime = applicationLifetime; _logger = logger; 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 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; } }
public SocketTransport(IEndPointInformation endPointInformation, IConnectionDispatcher dispatcher, int listenBacklog, PipeOptions sendOptions, PipeOptions receiveOptions) { 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; _numSchedulers = 1; _cachedPipeOpts = new PipeOptionsPair[] { new PipeOptionsPair(sendOptions, receiveOptions) }; }
public async void ConnectAsync(IEndPointInformation endPoint) { await _connectTcs.Task; SetPipe(_connectTcs.Task.Result); StartReceiveLoopAsync().FireAndForget(); }
public UvTransport(IEndPointInformation endPoint, IConnectionDispatcher dispatcher, int threadCount = 1, ILibuvTrace log = null) { _endPointInformation = endPoint; _dispatcher = dispatcher; _threadCount = threadCount; Log = log; Threads = new List <UvThread>(); _listeners = new List <IAsyncDisposable>(); }
public ITransport Create(IEndPointInformation endPointInformation, IConnectionDispatcher dispatcher) { endPointInformation = endPointInformation ?? throw new ArgumentNullException(nameof(endPointInformation)); dispatcher = dispatcher ?? throw new ArgumentNullException(nameof(dispatcher)); var transport = new NetMapTransport(endPointInformation.IPEndPoint, _options.InterfaceName, dispatcher); return(transport); }
public UvListenerPrimary(UvThread thread, IEndPointInformation endpoint, ILibuvTrace log = null) : base(thread, endpoint, log) { _dispatchPipes = new List <UvPipeHandle>(); _createdPipes = new List <UvPipeHandle>(); _dummyMessage = new ArraySegment <ArraySegment <byte> >(new[] { new ArraySegment <byte>(new byte[] { 1, 2, 3, 4 }) }); }
public UvDuplexPipeClient(IEndPointInformation endPoint) { _awaitingResponses = new Dictionary <int, TaskCompletionSource <IMemoryOwner <byte> > >(); _connectTcs = new TaskCompletionSource <UvConnection>(); _endPoint = endPoint; _thread = new UvThread(Log); _thread.Post(_startConnect, this); }
public ITransport Create(IEndPointInformation endPointInformation, IConnectionDispatcher dispatcher) { if (ConnectionDispatcher != null) { throw new InvalidOperationException("InMemoryTransportFactory doesn't support creating multiple endpoints"); } ConnectionDispatcher = dispatcher; return(new NoopTransport()); }
public ITransport Create(IEndPointInformation endPointInformation, IConnectionDispatcher dispatcher) { var transportContext = new LibuvTransportContext { Options = _baseTransportContext.Options, AppLifetime = _baseTransportContext.AppLifetime, Log = _baseTransportContext.Log, ConnectionDispatcher = dispatcher }; return(new LibuvTransport(transportContext, endPointInformation)); }
public Transport( IListenerLogger logger, InlineSocketsOptions options, INetworkProvider networkProvider, IEndPointInformation endPointInformation, IConnectionDispatcher dispatcher) { _listener = new Listener(logger, options, networkProvider); _logger = logger; _endPointInformation = endPointInformation; _dispatcher = dispatcher; }
// TODO:这里之前是override,但是因为我需要有个口子可以设定transport, // 所以需要从这里传入一个配置项;很杯具的是libuv可不需要Pipeline这个概念, // 所以暂时先去掉override让编译可以通过吧。 public async Task StartAsync(IEndPointInformation endPoint) { if (_disposed) { throw new ObjectDisposedException(ToString()); } _transport = new UvTransport(endPoint, _dispather, ThreadCount, Log); await _transport.BindAsync(); OnServerStarted(endPoint); }
public ITransport Create(IEndPointInformation endPointInformation, IConnectionHandler handler) { var connections = new InMemoryConnection[_connectionsPerEndPoint]; for (var i = 0; i < _connectionsPerEndPoint; i++) { connections[i] = new InMemoryConnection(); } _connections.Add(endPointInformation, connections); return(new InMemoryTransport(handler, connections)); }
public Task StartAsync( IEndPointInformation endPointInformation, LibuvThread thread) { EndPointInformation = endPointInformation; Thread = thread; return(Thread.PostAsync(listener => { listener.ListenSocket = listener.CreateListenSocket(); listener.ListenSocket.Listen(LibuvConstants.ListenBacklog, ConnectionCallback, listener); }, this)); }
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 SocketTransport(SocketTransportFactory transportFactory, IEndPointInformation endPointInformation, IConnectionHandler handler) { Debug.Assert(transportFactory != null); Debug.Assert(endPointInformation != null); Debug.Assert(endPointInformation.Type == ListenType.IPEndPoint); Debug.Assert(handler != null); _transportFactory = transportFactory; _endPointInformation = endPointInformation; _handler = handler; _listenSocket = null; _listenTask = null; }
public async Task RunAsync(ITransportFactory transportFactory, IEndPointInformation endPointInformation, ApplicationLifetime lifetime) { Console.CancelKeyPress += (sender, e) => lifetime.StopApplication(); var transport = transportFactory.Create(endPointInformation, this); await transport.BindAsync(); Console.WriteLine($"Server ({nameof(PlainTextRawWithHeadersApplication)}) listening on http://{endPointInformation.IPEndPoint}"); lifetime.ApplicationStopping.WaitHandle.WaitOne(); await transport.UnbindAsync(); await transport.StopAsync(); }
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; }
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; }
private static IPEndPoint CreateEndPointFromIEndPointInformation(IEndPointInformation IEndPointInformation) { if (IEndPointInformation == null) { throw new ArgumentNullException(nameof(IEndPointInformation)); } if (IEndPointInformation.Type != ListenType.IPEndPoint) { throw new NotSupportedException("Only IPEndPoints are supported."); } if (IEndPointInformation.IPEndPoint == null) { throw new ArgumentNullException(nameof(IEndPointInformation.IPEndPoint)); } return(IEndPointInformation.IPEndPoint); }
public ITransport Create(IEndPointInformation endPointInformation, IConnectionHandler handler) { if (endPointInformation == null) { throw new ArgumentNullException(nameof(endPointInformation)); } if (endPointInformation.Type != ListenType.IPEndPoint) { throw new ArgumentException(SocketsStrings.OnlyIPEndPointsSupported, nameof(endPointInformation)); } if (handler == null) { throw new ArgumentNullException(nameof(handler)); } return(new SocketTransport(endPointInformation, handler, _trace)); }
public Task StartAsync( string pipeName, byte[] pipeMessage, IEndPointInformation endPointInformation, LibuvThread thread) { _pipeName = pipeName; _pipeMessage = pipeMessage; _buf = thread.Loop.Libuv.buf_init(_ptr, 4); EndPointInformation = endPointInformation; Thread = thread; DispatchPipe = new UvPipeHandle(Log); var tcs = new TaskCompletionSource <int>(this, TaskCreationOptions.RunContinuationsAsynchronously); Thread.Post(StartCallback, tcs); return(tcs.Task); }
public ITransport Create(IEndPointInformation endPointInformation, IConnectionDispatcher dispatcher) { if (endPointInformation == null) { throw new ArgumentNullException(nameof(endPointInformation)); } if (endPointInformation.Type != ListenType.IPEndPoint) { throw new ArgumentException("OnlyIPEndPointsSupported"); } if (dispatcher == null) { throw new ArgumentNullException(nameof(dispatcher)); } return(new KestrelStackTransport(this.Server._NullCheck(), endPointInformation, dispatcher, AppLifeTime, Options.IOQueueCount, Trace)); }
public ITransport Create(IEndPointInformation endPointInformation, IConnectionDispatcher dispatcher) { if (endPointInformation == null) { throw new ArgumentNullException(nameof(endPointInformation)); } if (endPointInformation.Type != ListenType.IPEndPoint) { throw new ArgumentException(SocketsStrings.OnlyIPEndPointsSupported, nameof(endPointInformation)); } if (dispatcher == null) { throw new ArgumentNullException(nameof(dispatcher)); } return(new SocketTransport(endPointInformation, dispatcher, _appLifetime, _options.IOQueueCount, _trace)); }
public ITransport Create(IEndPointInformation endPointInformation, IConnectionDispatcher dispatcher) { if (endPointInformation == null) { throw new ArgumentNullException(nameof(endPointInformation)); } if (endPointInformation.Type != ListenType.IPEndPoint) { throw new ArgumentException("Only IP endpoint is supported", nameof(endPointInformation)); } if (dispatcher == null) { throw new ArgumentNullException(nameof(dispatcher)); } return(new QuicTransport(endPointInformation, dispatcher, _appLifetime, _options.IOQueueCount, _logger)); }
#pragma warning disable PUB0001 // Pubternal type in public API public ITransport Create(IEndPointInformation endPointInformation, IConnectionDispatcher dispatcher) #pragma warning restore PUB0001 // Pubternal type in public API { if (endPointInformation == null) { throw new ArgumentNullException(nameof(endPointInformation)); } if (endPointInformation.Type != ListenType.IPEndPoint) { throw new ArgumentException(SocketsStrings.OnlyIPEndPointsSupported, nameof(endPointInformation)); } if (dispatcher == null) { throw new ArgumentNullException(nameof(dispatcher)); } return(new SocketTransport(endPointInformation, dispatcher, _appLifetime, _options.IOQueueCount, _trace, _options.MemoryPoolFactory())); }
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); }
#pragma warning disable PUB0001 // Pubternal type in public API public ITransport Create(IEndPointInformation endPointInformation, IConnectionDispatcher dispatcher) #pragma warning restore PUB0001 // Pubternal type in public API { if (endPointInformation == null) { throw new ArgumentNullException(nameof(endPointInformation)); } if (endPointInformation.Type != ListenType.IPEndPoint) { throw new ArgumentException("Only ListenType.IPEndPoint is supported by the Socket Transport. https://go.microsoft.com/fwlink/?linkid=874850", nameof(endPointInformation)); } if (dispatcher == null) { throw new ArgumentNullException(nameof(dispatcher)); } return(new SocketTransport(endPointInformation, dispatcher, _appLifetime, _options.IOQueueCount, _trace, _options.MemoryPoolFactory())); }