public void Init(UvLoopHandle loop)
 {
     CreateMemory(
         loop.Libuv,
         loop.ThreadId,
         loop.Libuv.req_size(Libuv.RequestType.SHUTDOWN));
 }
 public void LoopCanBeInitAndClose()
 {
     var loop = new UvLoopHandle(_logger);
     loop.Init(_uv);
     loop.Run();
     loop.Dispose();
 }
 public async Task LoopCanBeInitAndClose()
 {
     var loop = new UvLoopHandle();
     loop.Init(_uv);
     loop.Run();
     loop.Dispose();
 }
 public async Task SocketCanListenAndAccept()
 {
     var loop = new UvLoopHandle(_logger);
     loop.Init(_uv);
     var tcp = new UvTcpHandle(_logger);
     tcp.Init(loop);
     var address = ServerAddress.FromUrl("http://localhost:54321/");
     tcp.Bind(address);
     tcp.Listen(10, (stream, status, error, state) =>
     {
         var tcp2 = new UvTcpHandle(_logger);
         tcp2.Init(loop);
         stream.Accept(tcp2);
         tcp2.Dispose();
         stream.Dispose();
     }, null);
     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);
         socket.Dispose();
     });
     loop.Run();
     loop.Dispose();
     await t;
 }
 public KestrelThread(KestrelEngine engine)
 {
     _engine = engine;
     _loop = new UvLoopHandle();
     _post = new UvAsyncHandle();
     _thread = new Thread(ThreadStart);
     QueueCloseHandle = PostCloseHandle;
 }
 public void Init(UvLoopHandle loop)
 {
     var requestSize = loop.Libuv.req_size(Libuv.RequestType.CONNECT);
     CreateMemory(
         loop.Libuv,
         loop.ThreadId,
         requestSize);
 }
        public void Init(UvLoopHandle loop, Action<Action<IntPtr>, IntPtr> queueCloseHandle)
        {
            CreateHandle(
                loop.Libuv,
                loop.ThreadId,
                loop.Libuv.handle_size(Libuv.HandleType.TCP), queueCloseHandle);

            _uv.tcp_init(loop, this);
        }
        public void Init(UvLoopHandle loop)
        {
            CreateMemory(
                loop.Libuv,
                loop.ThreadId,
                loop.Libuv.handle_size(Libuv.HandleType.TCP));

            _uv.tcp_init(loop, this);
        }
        public void Init(UvLoopHandle loop)
        {
            var requestSize = loop.Libuv.req_size(Libuv.RequestType.CONNECT);

            CreateMemory(
                loop.Libuv,
                loop.ThreadId,
                requestSize);
        }
        public void Init(UvLoopHandle loop, bool ipc)
        {
            CreateMemory(
                loop.Libuv,
                loop.ThreadId, 
                loop.Libuv.handle_size(Libuv.HandleType.NAMED_PIPE));

            _uv.pipe_init(loop, this, ipc);
        }
 public void Init(UvLoopHandle loop)
 {
     var requestSize = loop.Libuv.req_size(Libuv.RequestType.WRITE);
     var bufferSize = Marshal.SizeOf<Libuv.uv_buf_t>() * BUFFER_COUNT;
     CreateMemory(
         loop.Libuv,
         loop.ThreadId,
         requestSize + bufferSize);
     _bufs = handle + requestSize;
 }
        public void Init(UvLoopHandle loop, Action callback)
        {
            CreateMemory(
                loop.Libuv, 
                loop.ThreadId, 
                loop.Libuv.handle_size(Libuv.HandleType.ASYNC));

            _callback = callback;
            _uv.async_init(loop, this, _uv_async_cb);
        }
Exemple #13
0
        public void Init(UvLoopHandle loop, Action callback)
        {
            CreateMemory(
                loop.Libuv,
                loop.ThreadId,
                loop.Libuv.handle_size(Libuv.HandleType.ASYNC));

            _callback = callback;
            _uv.async_init(loop, this, _uv_async_cb);
        }
 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();
 }
 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 void Init(UvLoopHandle loop)
        {
            var requestSize = loop.Libuv.req_size(Libuv.RequestType.WRITE);
            var bufferSize  = Marshal.SizeOf <Libuv.uv_buf_t>() * BUFFER_COUNT;

            CreateMemory(
                loop.Libuv,
                loop.ThreadId,
                requestSize + bufferSize);
            _bufs = handle + requestSize;
        }
 public void SocketCanBeInitAndClose()
 {
     var loop = new UvLoopHandle(_logger);
     loop.Init(_uv);
     var tcp = new UvTcpHandle(_logger);
     tcp.Init(loop);
     var address = ServerAddress.FromUrl("http://localhost:0/");
     tcp.Bind(address);
     tcp.Dispose();
     loop.Run();
     loop.Dispose();
 }
 public KestrelThread(KestrelEngine engine)
 {
     _engine = engine;
     _appLifetime = engine.AppLifetime;
     _log = engine.Log;
     _threadPool = engine.ThreadPool;
     _loop = new UvLoopHandle(_log);
     _post = new UvAsyncHandle(_log);
     _thread = new Thread(ThreadStart);
     _thread.Name = "KestrelThread - libuv";
     QueueCloseHandle = PostCloseHandle;
 }
        public void InitAndCloseServerPipe()
        {
            var loop = new UvLoopHandle();
            var pipe = new UvPipeHandle();

            loop.Init(_uv);
            pipe.Init(loop, true);
            pipe.Bind(@"\\.\pipe\InitAndCloseServerPipe");
            pipe.Dispose();

            loop.Run();

            pipe.Dispose();
            loop.Dispose();
        }
 public async Task AsyncCanBeSent()
 {
     var loop = new UvLoopHandle();
     loop.Init(_uv);
     var trigger = new UvAsyncHandle();
     var called = false;
     trigger.Init(loop, () =>
     {
         called = true;
         trigger.Dispose();
     });
     trigger.Send();
     loop.Run();
     loop.Dispose();
     Assert.True(called);
 }
Exemple #21
0
 unsafe public void walk(UvLoopHandle loop, uv_walk_cb walk_cb, IntPtr arg)
 {
     loop.Validate();
     _uv_walk(loop, walk_cb, arg);
 }
Exemple #22
0
 public static extern int uv_tcp_init(UvLoopHandle loop,UvTcpHandle handle);
Exemple #23
0
 public unsafe void walk(UvLoopHandle loop, uv_walk_cb walk_cb, IntPtr arg)
 {
     loop.Validate();
     _uv_walk(loop, walk_cb, arg);
 }
 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;
 }
Exemple #25
0
 public void stop(UvLoopHandle handle)
 {
     handle.Validate();
     _uv_stop(handle);
 }
        public void ServerPipeDispatchConnections()
        {
            var pipeName = @"\\.\pipe\ServerPipeDispatchConnections" + Guid.NewGuid().ToString("n");

            var loop = new UvLoopHandle();
            loop.Init(_uv);

            var serverConnectionPipe = default(UvPipeHandle);
            var serverConnectionPipeAcceptedEvent = new ManualResetEvent(false);
            var serverConnectionTcpDisposedEvent = new ManualResetEvent(false);

            var serverListenPipe = new UvPipeHandle();
            serverListenPipe.Init(loop, false);
            serverListenPipe.Bind(pipeName);
            serverListenPipe.Listen(128, (_1, status, error, _2) =>
            {
                serverConnectionPipe = new UvPipeHandle();
                serverConnectionPipe.Init(loop, true);
                try
                {
                    serverListenPipe.Accept(serverConnectionPipe);
                    serverConnectionPipeAcceptedEvent.Set();
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex);
                    serverConnectionPipe.Dispose();
                    serverConnectionPipe = null;
                }
            }, null);

            var serverListenTcp = new UvTcpHandle();
            serverListenTcp.Init(loop);
            serverListenTcp.Bind(new IPEndPoint(0, 54321));
            serverListenTcp.Listen(128, (_1, status, error, _2) =>
            {
                var serverConnectionTcp = new UvTcpHandle();
                serverConnectionTcp.Init(loop);
                serverListenTcp.Accept(serverConnectionTcp);

                serverConnectionPipeAcceptedEvent.WaitOne();

                var writeRequest = new UvWriteReq();
                writeRequest.Init(loop);
                writeRequest.Write2(
                    serverConnectionPipe,
                    new ArraySegment<ArraySegment<byte>>(new ArraySegment<byte>[] { new ArraySegment<byte>(new byte[] { 1, 2, 3, 4 }) }),
                    serverConnectionTcp,
                    (_3, status2, error2, _4) =>
                    {
                        writeRequest.Dispose();
                        serverConnectionTcp.Dispose();
                        serverConnectionTcpDisposedEvent.Set();
                        serverConnectionPipe.Dispose();
                        serverListenPipe.Dispose();
                        serverListenTcp.Dispose();
                    },
                    null);
            }, null);

            var worker = new Thread(() =>
            {
                var loop2 = new UvLoopHandle();
                var clientConnectionPipe = new UvPipeHandle();
                var connect = new UvConnectRequest();

                loop2.Init(_uv);
                clientConnectionPipe.Init(loop2, true);
                connect.Init(loop2);
                connect.Connect(clientConnectionPipe, pipeName, (_1, status, error, _2) =>
                {
                    connect.Dispose();

                    var buf = loop2.Libuv.buf_init(Marshal.AllocHGlobal(64), 64);

                    serverConnectionTcpDisposedEvent.WaitOne();

                    clientConnectionPipe.ReadStart(
                        (_3, cb, _4) => buf,
                        (_3, status2, error2, _4) =>
                        {
                            if (status2 == 0)
                            {
                                clientConnectionPipe.Dispose();
                                return;
                            }
                            var clientConnectionTcp = new UvTcpHandle();
                            clientConnectionTcp.Init(loop2);
                            clientConnectionPipe.Accept(clientConnectionTcp);
                            var buf2 = loop2.Libuv.buf_init(Marshal.AllocHGlobal(64), 64);
                            clientConnectionTcp.ReadStart(
                                (_5, cb, _6) => buf2,
                                (_5, status3, error3, _6) =>
                                {
                                    if (status3 == 0)
                                    {
                                        clientConnectionTcp.Dispose();
                                    }
                                },
                                null);
                        },
                        null);
                }, null);
                loop2.Run();
                loop2.Dispose();
            });

            var worker2 = new Thread(() =>
            {
                try
                {
                    serverConnectionPipeAcceptedEvent.WaitOne();

                    var socket = new Socket(SocketType.Stream, ProtocolType.IP);
                    socket.Connect(IPAddress.Loopback, 54321);
                    socket.Send(new byte[] { 6, 7, 8, 9 });
                    socket.Shutdown(SocketShutdown.Send);
                    var cb = socket.Receive(new byte[64]);
                    socket.Dispose();
                }
                catch(Exception ex)
                {
                    Console.WriteLine(ex);
                }
            });

            worker.Start();
            worker2.Start();

            loop.Run();
            loop.Dispose();
            worker.Join();
            worker2.Join();
        }
Exemple #27
0
 public void tcp_init(UvLoopHandle loop, UvTcpHandle handle)
 {
     loop.Validate();
     handle.Validate();
     Check(_uv_tcp_init(loop, handle));
 }
Exemple #28
0
 public static extern int uv_run(UvLoopHandle handle,int mode);
Exemple #29
0
 public static extern int uv_loop_init(UvLoopHandle handle);
        public async Task SocketCanReadAndWrite()
        {
            var loop = new UvLoopHandle(_logger);
            loop.Init(_uv);
            var tcp = new UvTcpHandle(_logger);
            tcp.Init(loop);
            var address = ServerAddress.FromUrl("http://localhost:54321/");
            tcp.Bind(address);
            tcp.Listen(10, (_, status, error, state) =>
            {
                Console.WriteLine("Connected");
                var tcp2 = new UvTcpHandle(_logger);
                tcp2.Init(loop);
                tcp.Accept(tcp2);
                var data = Marshal.AllocCoTaskMem(500);
                tcp2.ReadStart(
                    (a, b, c) => tcp2.Libuv.buf_init(data, 500),
                    (__, nread, state2) =>
                    {
                        if (nread <= 0)
                        {
                            tcp2.Dispose();
                        }
                        else
                        {
                            for (var x = 0; x < 2; x++)
                            {
                                var req = new UvWriteReq(new KestrelTrace(new TestKestrelTrace()));
                                req.Init(loop);
                                var block = MemoryPoolBlock2.Create(
                                    new ArraySegment<byte>(new byte[] { 65, 66, 67, 68, 69 }),
                                    dataPtr: IntPtr.Zero,
                                    pool: null,
                                    slab: null);
                                var start = new MemoryPoolIterator2(block, 0);
                                var end = new MemoryPoolIterator2(block, block.Data.Count);
                                req.Write(
                                    tcp2,
                                    start,
                                    end,
                                    1,
                                    (_1, _2, _3, _4) =>
                                    {
                                        block.Unpin();
                                    },
                                    null);
                            }
                        }
                    },
                    null);
                tcp.Dispose();
            }, null);
            Console.WriteLine("Task.Run");
            var t = Task.Run(async () =>
            {
                var socket = new Socket(
                    AddressFamily.InterNetwork,
                    SocketType.Stream,
                    ProtocolType.Tcp);
#if DNX451
                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);
#else
                await socket.ConnectAsync(new IPEndPoint(IPAddress.Loopback, 54321));
                await socket.SendAsync(new[] { new ArraySegment<byte>(new byte[] { 1, 2, 3, 4, 5 }) },
                                       SocketFlags.None);
#endif
                socket.Shutdown(SocketShutdown.Send);
                var buffer = new ArraySegment<byte>(new byte[2048]);
                while (true)
                {
#if DNX451
                    var count = await Task.Factory.FromAsync(
                        socket.BeginReceive,
                        socket.EndReceive,
                        new[] { buffer },
                        SocketFlags.None,
                        null,
                        TaskCreationOptions.None);
#else
                    var count = await socket.ReceiveAsync(new[] { buffer }, SocketFlags.None);
#endif
                    Console.WriteLine("count {0} {1}",
                        count,
                        System.Text.Encoding.ASCII.GetString(buffer.Array, 0, count));
                    if (count <= 0) break;
                }
                socket.Dispose();
            });
            loop.Run();
            loop.Dispose();
            await t;
        }
Exemple #31
0
 public static extern void uv_stop(UvLoopHandle handle);
Exemple #32
0
 public void loop_init(UvLoopHandle handle)
 {
     Check(_uv_loop_init(handle));
 }
Exemple #33
0
 unsafe public static extern int uv_walk(UvLoopHandle loop,uv_walk_cb walk_cb,IntPtr arg);
Exemple #34
0
 public static extern int uv_pipe_init(UvLoopHandle loop,UvPipeHandle handle,int ipc);
        public void ServerPipeListenForConnections()
        {
            var loop = new UvLoopHandle();
            var serverListenPipe = new UvPipeHandle();

            loop.Init(_uv);
            serverListenPipe.Init(loop, false);
            serverListenPipe.Bind(@"\\.\pipe\ServerPipeListenForConnections");
            serverListenPipe.Listen(128, (_1, status, error, _2) =>
            {
                var serverConnectionPipe = new UvPipeHandle();
                serverConnectionPipe.Init(loop, true);
                try
                {
                    serverListenPipe.Accept(serverConnectionPipe);
                }
                catch (Exception)
                {
                    serverConnectionPipe.Dispose();
                    return;
                }

                var writeRequest = new UvWriteReq();
                writeRequest.Init(loop);
                writeRequest.Write(
                    serverConnectionPipe,
                    new ArraySegment<ArraySegment<byte>>(new ArraySegment<byte>[] { new ArraySegment<byte>(new byte[] { 1, 2, 3, 4 }) }),
                    (_3, status2, error2, _4) =>
                    {
                        writeRequest.Dispose();
                        serverConnectionPipe.Dispose();
                        serverListenPipe.Dispose();
                    },
                    null);

            }, null);

            var worker = new Thread(() =>
            {
                var loop2 = new UvLoopHandle();
                var clientConnectionPipe = new UvPipeHandle();
                var connect = new UvConnectRequest();

                loop2.Init(_uv);
                clientConnectionPipe.Init(loop2, true);
                connect.Init(loop2);
                connect.Connect(clientConnectionPipe, @"\\.\pipe\ServerPipeListenForConnections", (_1, status, error, _2) =>
                {
                    var buf = loop2.Libuv.buf_init(Marshal.AllocHGlobal(8192), 8192);

                    connect.Dispose();
                    clientConnectionPipe.ReadStart(
                        (_3, cb, _4) => buf,
                        (_3, status2, error2, _4) =>
                        {
                            if (status2 == 0)
                            {
                                clientConnectionPipe.Dispose();
                            }
                        },
                        null);
                }, null);
                loop2.Run();
                loop2.Dispose();
            });
            worker.Start();
            loop.Run();
            loop.Dispose();
            worker.Join();
        }
Exemple #36
0
 public int run(UvLoopHandle handle, int mode)
 {
     handle.Validate();
     return(Check(_uv_run(handle, mode)));
 }
Exemple #37
0
 public void pipe_init(UvLoopHandle loop, UvPipeHandle handle, bool ipc)
 {
     loop.Validate();
     handle.Validate();
     Check(_uv_pipe_init(loop, handle, ipc ? -1 : 0));
 }
Exemple #38
0
 public void loop_init(UvLoopHandle handle)
 {
     Check(_uv_loop_init(handle));
 }
 unsafe public static extern int uv_walk(UvLoopHandle loop, uv_walk_cb walk_cb, IntPtr arg);
Exemple #40
0
 public int run(UvLoopHandle handle, int mode)
 {
     handle.Validate();
     return Check(_uv_run(handle, mode));
 }
Exemple #41
0
 public void async_init(UvLoopHandle loop, UvAsyncHandle handle, uv_async_cb cb)
 {
     loop.Validate();
     handle.Validate();
     Check(_uv_async_init(loop, handle, cb));
 }
Exemple #42
0
 public void stop(UvLoopHandle handle)
 {
     handle.Validate();
     _uv_stop(handle);
 }
 public async Task SocketCanReadAndWrite()
 {
     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) => tcp2.Libuv.buf_init(data, 500),
             (__, nread, error2, state2) =>
             {
                 bytesRead += nread;
                 if (nread == 0)
                 {
                     tcp2.Dispose();
                 }
                 else
                 {
                     for (var x = 0; x != 2; ++x)
                     {
                         var req = new UvWriteReq();
                         req.Init(loop);
                         req.Write(
                             tcp2,
                             new ArraySegment<ArraySegment<byte>>(
                                 new[] { new ArraySegment<byte>(new byte[] { 65, 66, 67, 68, 69 }) }
                                 ),
                             (_1, _2, _3, _4) => { },
                             null);
                     }
                 }
             },
             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.Shutdown(SocketShutdown.Send);
         var buffer = new ArraySegment<byte>(new byte[2048]);
         for (; ;)
         {
             var count = await Task.Factory.FromAsync(
                 socket.BeginReceive,
                 socket.EndReceive,
                 new[] { buffer },
                 SocketFlags.None,
                 null,
                 TaskCreationOptions.None);
             Console.WriteLine("count {0} {1}",
                 count,
                 System.Text.Encoding.ASCII.GetString(buffer.Array, 0, count));
             if (count <= 0) break;
         }
         socket.Dispose();
     });
     loop.Run();
     loop.Dispose();
     await t;
 }
Exemple #44
0
 public void tcp_init(UvLoopHandle loop, UvTcpHandle handle)
 {
     loop.Validate();
     handle.Validate();
     Check(_uv_tcp_init(loop, handle));
 }
Exemple #45
0
 public void async_init(UvLoopHandle loop, UvAsyncHandle handle, uv_async_cb cb)
 {
     loop.Validate();
     handle.Validate();
     Check(_uv_async_init(loop, handle, cb));
 }
Exemple #46
0
 public static extern int uv_async_init(UvLoopHandle loop,UvAsyncHandle handle,uv_async_cb cb);
Exemple #47
0
 public void loop_close(UvLoopHandle handle)
 {
     handle.Validate(closed: true);
     Check(_uv_loop_close(handle.InternalGetHandle()));
 }
Exemple #48
0
 public void loop_close(UvLoopHandle handle)
 {
     handle.Validate(closed: true);
     Check(_uv_loop_close(handle.InternalGetHandle()));
 }