private UvTcpHandle ListenTcp(bool useFileHandle) { var socket = new UvTcpHandle(Log); try { socket.Init(Thread.Loop, Thread.QueueCloseHandle); #pragma warning disable CS0618 socket.NoDelay(TransportContext.Options.NoDelay); #pragma warning restore CS0618 if (!useFileHandle) { socket.Bind((IPEndPoint)EndPoint); // If requested port was "0", replace with assigned dynamic port. EndPoint = socket.GetSockIPEndPoint(); } else { socket.Open((IntPtr)((FileHandleEndPoint)EndPoint).FileHandle); } } catch { socket.Dispose(); throw; } return(socket); }
/// <summary> /// Creates a socket which can be used to accept an incoming connection /// </summary> protected override UvStreamHandle CreateAcceptSocket() { var acceptSocket = new UvTcpHandle(Log); acceptSocket.Init(Thread.Loop, Thread.QueueCloseHandle); return(acceptSocket); }
public async Task SocketCanListenAndAccept() { var loop = new UvLoopHandle(_logger); loop.Init(_uv); var tcp = new UvTcpHandle(_logger); tcp.Init(loop, (a, b) => { }); var address = ServerAddress.FromUrl($"http://127.0.0.1:0/"); tcp.Bind(address); var port = tcp.GetSockIPEndPoint().Port; tcp.Listen(10, (stream, status, error, state) => { var tcp2 = new UvTcpHandle(_logger); tcp2.Init(loop, (a, b) => { }); stream.Accept(tcp2); tcp2.Dispose(); stream.Dispose(); }, null); var t = Task.Run(() => { var socket = TestConnection.CreateConnectedLoopbackSocket(port); socket.Dispose(); }); loop.Run(); loop.Dispose(); await t; }
private UvTcpHandle ListenTcp(bool useFileHandle) { var socket = new UvTcpHandle(Log); try { socket.Init(Thread.Loop, Thread.QueueCloseHandle); socket.NoDelay(EndPointInformation.NoDelay); if (!useFileHandle) { socket.Bind(EndPointInformation.IPEndPoint); // If requested port was "0", replace with assigned dynamic port. EndPointInformation.IPEndPoint = socket.GetSockIPEndPoint(); } else { socket.Open((IntPtr)EndPointInformation.FileHandle); } } catch { socket.Dispose(); throw; } return(socket); }
public Task StartAsync( string scheme, string host, int port, KestrelThread thread, Func <Frame, Task> application) { Thread = thread; Application = application; var tcs = new TaskCompletionSource <int>(); Thread.Post(_ => { try { ListenSocket = new UvTcpHandle(); ListenSocket.Init(Thread.Loop, Thread.QueueCloseHandle); ListenSocket.Bind(new IPEndPoint(IPAddress.Any, port)); ListenSocket.Listen(10, _connectionCallback, this); tcs.SetResult(0); } catch (Exception ex) { tcs.SetException(ex); } }, null); return(tcs.Task); }
public UvServerChannelBus() { _uvLoop = new UvLoopHandle(); _uvLoop.Init(); _listenUvTcpHandle = new UvTcpHandle(); _listenUvTcpHandle.Init(_uvLoop); }
private void Listen() { _listenSocket = new UvTcpHandle(); _listenSocket.Init(_thread.Loop, UvThread._queueCloseCallback); _listenSocket.NoDelay(true); _listenSocket.Bind(_endpoint); _listenSocket.Listen(10, _onConnectionCallback, this); }
private void DoConnect() { _connectSocket = new UvTcpHandle(); _connectSocket.Init(_thread.Loop, null); var connectReq = new UvConnectRequest(); connectReq.Init(_thread.Loop); connectReq.Connect(_connectSocket, _ipEndPoint, _connectCallback, this); }
/// <summary> /// Creates the socket used to listen for incoming connections /// </summary> protected override UvStreamHandle CreateListenSocket(string host, int port) { var socket = new UvTcpHandle(Log); socket.Init(Thread.Loop, Thread.QueueCloseHandle); socket.Bind(host, port); socket.Listen(Constants.ListenBacklog, ConnectionCallback, this); return(socket); }
/// <summary> /// Creates a socket which can be used to accept an incoming connection /// </summary> protected override UvStreamHandle CreateAcceptSocket() { var acceptSocket = new UvTcpHandle(); acceptSocket.Init(Thread.Loop, Thread.QueueCloseHandle); acceptSocket.NoDelay(true); acceptSocket.KeepAlive(true); return(acceptSocket); }
public async Task SocketCanRead() { int bytesRead = 0; var loop = new UvLoopHandle(); loop.Init(_uv); var tcp = new UvTcpHandle(); tcp.Init(loop); tcp.Bind(new IPEndPoint(IPAddress.Loopback, 54321)); tcp.Listen(10, (_, status, error, state) => { Console.WriteLine("Connected"); var tcp2 = new UvTcpHandle(); tcp2.Init(loop); tcp.Accept(tcp2); var data = Marshal.AllocCoTaskMem(500); tcp2.ReadStart( (a, b, c) => _uv.buf_init(data, 500), (__, nread, error2, state2) => { bytesRead += nread; if (nread == 0) { tcp2.Dispose(); } }, null); tcp.Dispose(); }, null); Console.WriteLine("Task.Run"); var t = Task.Run(async() => { var socket = new Socket( AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); await Task.Factory.FromAsync( socket.BeginConnect, socket.EndConnect, new IPEndPoint(IPAddress.Loopback, 54321), null, TaskCreationOptions.None); await Task.Factory.FromAsync( socket.BeginSend, socket.EndSend, new[] { new ArraySegment <byte>(new byte[] { 1, 2, 3, 4, 5 }) }, SocketFlags.None, null, TaskCreationOptions.None); socket.Dispose(); }); loop.Run(); loop.Dispose(); await t; }
/// <summary> /// Creates the socket used to listen for incoming connections /// </summary> protected override UvStreamHandle CreateListenSocket() { var socket = new UvTcpHandle(Log); socket.Init(Thread.Loop, Thread.QueueCloseHandle); socket.NoDelay(NoDelay); socket.Bind(ServerAddress); socket.Listen(Constants.ListenBacklog, (stream, status, error, state) => ConnectionCallback(stream, status, error, state), this); return(socket); }
private void OnConnection(UvStreamHandle listenSocket, int status) { var acceptSocket = new UvTcpHandle(); acceptSocket.Init(Thread.Loop, Thread.QueueCloseHandle); listenSocket.Accept(acceptSocket); var connection = new Connection(this, acceptSocket); connection.Start(); }
public async Task SocketCanRead() { var loop = new UvLoopHandle(_logger); loop.Init(_uv); var tcp = new UvTcpHandle(_logger); tcp.Init(loop, (a, b) => { }); var address = ServerAddress.FromUrl($"http://127.0.0.1:0/"); tcp.Bind(address); var port = tcp.GetSockIPEndPoint().Port; tcp.Listen(10, (_, status, error, state) => { var tcp2 = new UvTcpHandle(_logger); tcp2.Init(loop, (a, b) => { }); tcp.Accept(tcp2); var data = Marshal.AllocCoTaskMem(500); tcp2.ReadStart( (a, b, c) => _uv.buf_init(data, 500), (__, nread, state2) => { if (nread <= 0) { tcp2.Dispose(); } }, null); tcp.Dispose(); }, null); var t = Task.Run(async() => { var socket = TestConnection.CreateConnectedLoopbackSocket(port); #if NET451 await Task.Factory.FromAsync( socket.BeginSend, socket.EndSend, new[] { new ArraySegment <byte>(new byte[] { 1, 2, 3, 4, 5 }) }, SocketFlags.None, null, TaskCreationOptions.None); #else await socket.SendAsync(new[] { new ArraySegment <byte>(new byte[] { 1, 2, 3, 4, 5 }) }, SocketFlags.None); #endif socket.Dispose(); }); loop.Run(); loop.Dispose(); await t; }
private void Listen() { // TODO: Error handling _listenSocket = new UvTcpHandle(); _listenSocket.Init(_thread.Loop, null); _listenSocket.NoDelay(true); _listenSocket.Bind(_endpoint); _listenSocket.Listen(10, _onConnectionCallback, this); // Don't complete the task on the UV thread Task.Run(() => _startedTcs.TrySetResult(null)); }
public void SocketCanBeInitAndClose() { var loop = new UvLoopHandle(_logger); loop.Init(_uv); var tcp = new UvTcpHandle(_logger); tcp.Init(loop); tcp.Bind("localhost", 0); tcp.Dispose(); loop.Run(); loop.Dispose(); }
public async Task SocketCanBeInitAndClose() { var loop = new UvLoopHandle(); loop.Init(_uv); var tcp = new UvTcpHandle(); tcp.Init(loop); tcp.Bind(new IPEndPoint(IPAddress.Loopback, 0)); tcp.Dispose(); loop.Run(); loop.Dispose(); }
/// <summary> /// Creates the socket used to listen for incoming connections /// </summary> protected override UvStreamHandle CreateListenSocket() { var socket = new UvTcpHandle(Log); socket.Init(Thread.Loop, Thread.QueueCloseHandle); socket.NoDelay(ServerOptions.NoDelay); socket.Bind(ServerAddress); // If requested port was "0", replace with assigned dynamic port. ServerAddress.Port = socket.GetSockIPEndPoint().Port; socket.Listen(Constants.ListenBacklog, (stream, status, error, state) => ConnectionCallback(stream, status, error, state), this); return(socket); }
public void ReadStopIsIdempotent() { var libuvTrace = new TestApplicationErrorLogger(); using (var uvLoopHandle = new UvLoopHandle(libuvTrace)) using (var uvTcpHandle = new UvTcpHandle(libuvTrace)) { uvLoopHandle.Init(new MockLibuv()); uvTcpHandle.Init(uvLoopHandle, null); UvStreamHandle uvStreamHandle = uvTcpHandle; uvStreamHandle.ReadStop(); uvStreamHandle.ReadStop(); } }
public void SocketCanBeInitAndClose() { var loop = new UvLoopHandle(_logger); loop.Init(_uv); var tcp = new UvTcpHandle(_logger); tcp.Init(loop, (a, b) => { }); var address = ServerAddress.FromUrl("http://127.0.0.1:0/"); tcp.Bind(address); tcp.Dispose(); loop.Run(); loop.Dispose(); }
public void SocketCanBeInitAndClose() { var loop = new UvLoopHandle(_logger); loop.Init(_uv); var tcp = new UvTcpHandle(_logger); tcp.Init(loop, (a, b) => { }); var endPoint = new IPEndPoint(IPAddress.Loopback, 0); tcp.Bind(endPoint); tcp.Dispose(); loop.Run(); loop.Dispose(); }
private UvTcpHandle AcceptTcp() { var socket = new UvTcpHandle(TransportContext.Log); try { socket.Init(Thread.Loop, Thread.QueueCloseHandle); socket.NoDelay(EndPointInformation.NoDelay); } catch { socket.Dispose(); throw; } return(socket); }
/// <summary> /// Handle an incoming connection /// </summary> /// <param name="listenSocket">Socket being used to listen on</param> /// <param name="status">Connection status</param> protected override void OnConnection(UvStreamHandle listenSocket, int status) { var acceptSocket = new UvTcpHandle(Log); try { acceptSocket.Init(Thread.Loop, Thread.QueueCloseHandle); acceptSocket.NoDelay(ServerOptions.NoDelay); listenSocket.Accept(acceptSocket); DispatchConnection(acceptSocket); } catch (UvException ex) { Log.LogError(0, ex, "TcpListener.OnConnection"); acceptSocket.Dispose(); } }
/// <summary> /// Handles an incoming connection /// </summary> /// <param name="listenSocket">Socket being used to listen on</param> /// <param name="status">Connection status</param> protected override void OnConnection(UvStreamHandle listenSocket, int status) { var acceptSocket = new UvTcpHandle(Log); acceptSocket.Init(Thread.Loop, Thread.QueueCloseHandle); try { listenSocket.Accept(acceptSocket); } catch (UvException ex) { Log.LogError("TcpListenerPrimary.OnConnection", ex); return; } DispatchConnection(acceptSocket); }
private static void OnConnectionCallback(UvStreamHandle listenSocket, int status, Exception error, object state) { var listener = (UvTcpListener)state; var acceptSocket = new UvTcpHandle(); try { acceptSocket.Init(listener._thread.Loop, UvThread._queueCloseCallback); acceptSocket.NoDelay(true); listenSocket.Accept(acceptSocket); var connection = new UvTcpServerConnection(listener._thread, acceptSocket); listener._callback?.Invoke(connection); } catch (UvException) { acceptSocket.Dispose(); } }
private void RunLoop() { Uv = new Uv(); Loop = new UvLoopHandle(); Loop.Init(Uv); _shutdownPostHandle = new UvAsyncHandle(); _shutdownPostHandle.Init(Loop, OnPost, _queueCloseCallback); _listenSocket = new UvTcpHandle(); _listenSocket.Init(Loop, _queueCloseCallback); _listenSocket.NoDelay(true); _listenSocket.Bind(new IPEndPoint(_ip, _port)); _listenSocket.Listen(10, _onConnectionCallback, this); Uv.run(Loop, 0); }
private static void OnConnectionCallback(UvStreamHandle listenSocket, int status, Exception error, object state) { var listener = (UvTcpListener)state; var acceptSocket = new UvTcpHandle(); try { acceptSocket.Init(listener._thread.Loop, null); acceptSocket.NoDelay(true); listenSocket.Accept(acceptSocket); var connection = new UvTcpConnection(listener._thread, acceptSocket); ExecuteCallback(listener, connection); } catch (UvException) { acceptSocket.Dispose(); } }
/// <summary> /// Handle an incoming connection /// </summary> /// <param name="listenSocket">Socket being used to listen on</param> /// <param name="status">Connection status</param> protected override void OnConnection(UvStreamHandle listenSocket, int status) { var acceptSocket = new UvTcpHandle(); try { acceptSocket.Init(Thread.Loop, Thread.QueueCloseHandle); acceptSocket.NoDelay(true); acceptSocket.KeepAlive(true); listenSocket.Accept(acceptSocket); DispatchConnection(acceptSocket); } catch (UvException) { //Service.Logger.Log(ex); acceptSocket.Dispose(); return; } }
private UvTcpHandle AcceptTcp() { var socket = new UvTcpHandle(TransportContext.Log); try { socket.Init(Thread.Loop, Thread.QueueCloseHandle); #pragma warning disable CS0618 socket.NoDelay(TransportContext.Options.NoDelay); #pragma warning restore CS0618 } catch { socket.Dispose(); throw; } return(socket); }
public async Task SocketCanRead() { var loop = new UvLoopHandle(_logger); loop.Init(_uv); var tcp = new UvTcpHandle(_logger); tcp.Init(loop, (a, b) => { }); var endPoint = new IPEndPoint(IPAddress.Loopback, 0); tcp.Bind(endPoint); var port = tcp.GetSockIPEndPoint().Port; tcp.Listen(10, (_, status, error, state) => { var tcp2 = new UvTcpHandle(_logger); tcp2.Init(loop, (a, b) => { }); tcp.Accept(tcp2); var data = Marshal.AllocCoTaskMem(500); tcp2.ReadStart( (a, b, c) => _uv.buf_init(data, 500), (__, nread, state2) => { if (nread <= 0) { tcp2.Dispose(); } }, null); tcp.Dispose(); }, null); var t = Task.Run(async() => { var socket = TestConnection.CreateConnectedLoopbackSocket(port); await socket.SendAsync(new[] { new ArraySegment <byte>(new byte[] { 1, 2, 3, 4, 5 }) }, SocketFlags.None); socket.Dispose(); }); loop.Run(); loop.Dispose(); await t; }