static async Task RunServerAsync() { Console.WriteLine("Gateway Start, ThreadName=" + System.Threading.Thread.CurrentThread.ManagedThreadId); var bossGroup = new MultithreadEventLoopGroup(1); var workerGroup = new MultithreadEventLoopGroup(); try { var bootstrap = new ServerBootstrap(); bootstrap .Group(bossGroup, workerGroup) .Channel<TcpServerSocketChannel>() .Option(ChannelOption.SoBacklog, 100) .Handler(new LoggingHandler(LogLevel.INFO)) .ChildHandler(new ActionChannelInitializer<ISocketChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; pipeline.AddLast(new LengthFieldPrepender(2)); pipeline.AddLast(new LengthFieldBasedFrameDecoder(ushort.MaxValue, 0, 2, 0, 2)); pipeline.AddLast(new GatewayHandler()); })); IChannel bootstrapChannel = await bootstrap.BindAsync(GatewaySettings.Port); Console.ReadLine(); await bootstrapChannel.CloseAsync(); } finally { Task.WaitAll(bossGroup.ShutdownGracefullyAsync(), workerGroup.ShutdownGracefullyAsync()); } }
public async Task StartAsync(EndPoint endPoint) { if (_logger.IsEnabled(LogLevel.Debug)) _logger.LogDebug($"准备启动服务主机,监听地址:{endPoint}。"); var bossGroup = new MultithreadEventLoopGroup(1); var workerGroup = new MultithreadEventLoopGroup(); var bootstrap = new ServerBootstrap(); bootstrap .Group(bossGroup, workerGroup) .Channel<TcpServerSocketChannel>() .Option(ChannelOption.SoBacklog, 100) .ChildHandler(new ActionChannelInitializer<ISocketChannel>(channel => { var pipeline = channel.Pipeline; pipeline.AddLast(new LengthFieldPrepender(4)); pipeline.AddLast(new LengthFieldBasedFrameDecoder(int.MaxValue, 0, 4, 0, 4)); pipeline.AddLast(new TransportMessageChannelHandlerAdapter(_transportMessageDecoder)); pipeline.AddLast(new ServerHandler((contenxt, message) => { var sender = new DotNettyServerMessageSender(_transportMessageEncoder, contenxt); OnReceived(sender, message); }, _logger)); })); _channel = await bootstrap.BindAsync(endPoint); if (_logger.IsEnabled(LogLevel.Debug)) _logger.LogDebug($"服务主机启动成功,监听地址:{endPoint}。"); }
public NettyServer( int listenPort, Action<string, string, string, byte[]> dataReceivedAction, Action<string, string> clientConnectedAction) { this.listenPort = listenPort; this.channels = new Dictionary<string, IChannel>(); this.bossGroup = new MultithreadEventLoopGroup(1); this.workerGroup = new MultithreadEventLoopGroup(); this.bootstrap = new ServerBootstrap(); bootstrap .Group(bossGroup, workerGroup) .Channel<TcpServerSocketChannel>() .Option(ChannelOption.SoBacklog, 100) .Handler(new LoggingHandler("SRV-LSTN")) .ChildHandler(new ActionChannelInitializer<ISocketChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; //TODO: Receive InstanceId in the pipeline instead of part of the data buffer pipeline.AddLast("framing-enc", new LengthFieldPrepender(2)); pipeline.AddLast("framing-dec", new LengthFieldBasedFrameDecoder(32 * 1024, 0, 2, 0, 2)); pipeline.AddLast("main", new NettyServerHandler(this, dataReceivedAction, clientConnectedAction)); })); }
public void LocalChannel_batch_read_should_not_NRE() { var cb = new ClientBootstrap(); var sb = new ServerBootstrap(); var reads = 100; var resetEvent = new ManualResetEventSlim(); cb.Group(_group1) .Channel<LocalChannel>() .Handler( new ActionChannelInitializer<LocalChannel>( channel => { channel.Pipeline.AddLast(new LengthFieldBasedFrameDecoder(20, 0, 4, 0, 4)) .AddLast(new LengthFieldPrepender(4, false)) .AddLast(new TestHandler()); })); sb.Group(_group2) .Channel<LocalServerChannel>() .ChildHandler( new ActionChannelInitializer<LocalChannel>( channel => { channel.Pipeline.AddLast(new LengthFieldBasedFrameDecoder(20, 0, 4, 0, 4)) .AddLast(new LengthFieldPrepender(4, false)) .AddLast(new ReadCountAwaiter(resetEvent, reads)) .AddLast(new TestHandler()); })); IChannel sc = null; IChannel cc = null; try { // Start server sc = sb.BindAsync(TEST_ADDRESS).Result; // Connect to the server cc = cb.ConnectAsync(sc.LocalAddress).Result; foreach (var read in Enumerable.Range(0, reads)) { cc.WriteAndFlushAsync(Unpooled.Buffer(4).WriteInt(read)); } Assert.True(resetEvent.Wait(5000)); } finally { CloseChannel(sc); CloseChannel(cc); } }
public void TcpSocketChannel_Flush_should_not_be_reentrant_after_Close() { // Skip for Mono due to Code Contracts assertions not working properly there if (MonotonicClock.IsMono) return; var eventLoopGroup = new MultithreadEventLoopGroup(1); try { var futures = new ConcurrentQueue<Task>(); var sb = new ServerBootstrap(); sb.Group(eventLoopGroup).Channel<TcpServerSocketChannel>().ChildOption(ChannelOption.SoSndbuf, 1024) .ChildHandler(new ChannelFlushCloseHandler(futures)); var address = (IPEndPoint) sb.BindAsync(IPAddress.IPv6Loopback, 0).Result.LocalAddress; var s = new System.Net.Sockets.Socket(AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp); s.Connect(address.Address, address.Port); var inputStream = new NetworkStream(s, true); var buf = new byte[8192]; while (true) { var readBytes = inputStream.Read(buf, 0, 8192); if (readBytes == 0) { break; } // Wait a little bit so that the write attempts are split into multiple flush attempts. Thread.Sleep(10); } s.Close(); Assert.Equal(3, futures.Count); Task future1, future2, future3; futures.TryDequeue(out future1); futures.TryDequeue(out future2); futures.TryDequeue(out future3); Assert.True(future1.IsCompleted); Assert.False(future1.IsFaulted || future1.IsCanceled); Assert.True(future2.IsFaulted || future2.IsCanceled); Assert.IsType<ClosedChannelException>(future2.Exception.InnerException); Assert.True(future3.IsFaulted || future3.IsCanceled); Assert.IsType<ClosedChannelException>(future3.Exception.InnerException); } finally { eventLoopGroup.ShutdownGracefullyAsync(); } }
static async Task RunServerAsync() { var eventListener = new ObservableEventListener(); eventListener.LogToConsole(); eventListener.EnableEvents(DefaultEventSource.Log, EventLevel.Verbose); var bossGroup = new MultithreadEventLoopGroup(1); var workerGroup = new MultithreadEventLoopGroup(); X509Certificate2 tlsCertificate = null; if (EchoServerSettings.IsSsl) { tlsCertificate = new X509Certificate2("dotnetty.com.pfx", "password"); } try { var bootstrap = new ServerBootstrap(); bootstrap .Group(bossGroup, workerGroup) .Channel<TcpServerSocketChannel>() .Option(ChannelOption.SoBacklog, 100) .Handler(new LoggingHandler(LogLevel.INFO)) .ChildHandler(new ActionChannelInitializer<ISocketChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; if (tlsCertificate != null) { pipeline.AddLast(TlsHandler.Server(tlsCertificate)); } pipeline.AddLast(new LengthFieldPrepender(2)); pipeline.AddLast(new LengthFieldBasedFrameDecoder(ushort.MaxValue, 0, 2, 0, 2)); pipeline.AddLast(new EchoServerHandler()); })); IChannel bootstrapChannel = await bootstrap.BindAsync(EchoServerSettings.Port); Console.ReadLine(); await bootstrapChannel.CloseAsync(); } finally { Task.WaitAll(bossGroup.ShutdownGracefullyAsync(), workerGroup.ShutdownGracefullyAsync()); eventListener.Dispose(); } }
public override void TestShutdownGracefullyNoQuietPeriod() { IEventLoopGroup loop = new DispatcherEventLoopGroup(); ServerBootstrap b = new ServerBootstrap(); b.Group(loop) .Channel <TcpServerChannel>() .ChildHandler(new ChannelHandlerAdapter()); // Not close the Channel to ensure the EventLoop is still shutdown in time. var cf = b.BindAsync(0); cf.GetAwaiter().GetResult(); var f = loop.ShutdownGracefullyAsync(TimeSpan.Zero, TimeSpan.FromMinutes(1)); Assert.True(loop.TerminationCompletion.Wait(TimeSpan.FromMilliseconds(600))); Assert.True(f.IsSuccess()); Assert.True(loop.IsShutdown); Assert.True(loop.IsTerminated); }
private static async Task RunServerAsync() { LoggingHelper.SetNLogLogger(); IEventLoopGroup bossGroup = new MultithreadEventLoopGroup(1); IEventLoopGroup workerGroup = new MultithreadEventLoopGroup(); try { ServerBootstrap b = new ServerBootstrap(); b.Group(bossGroup, workerGroup) .Channel <TcpServerSocketChannel>() .Handler(new LoggingHandler(LogLevel.INFO)) .ChildHandler(new TelnetServerInitializer()); IChannel channel = await b.BindAsync(Port); await channel.CloseCompletion; } finally { Task.WaitAll(bossGroup.ShutdownGracefullyAsync(), workerGroup.ShutdownGracefullyAsync()); } }
/// <summary> /// /// </summary> /// <param name="cancellationToken"></param> /// <returns></returns> public async Task StartAsync(IEventLoopGroup BossGroup, IEventLoopGroup WorkerGroup, ServerOptions Options, AppFunc app) { X509Certificate2 tlsCertificate = null; if (Options.IsSsl) { tlsCertificate = new X509Certificate2(Path.Combine(_environment.ContentRootPath, Options.CertificatePath), Options.CertificateToken); } var bootstrap = new ServerBootstrap(); var appKey = AttributeKey <AppFunc> .ValueOf(Constants.AppAttributeKey); bootstrap.Group(BossGroup, WorkerGroup) .Channel <TcpServerSocketChannel>() .Option(ChannelOption.SoBacklog, 8192) //设置channelconfig .Handler(new ActionChannelInitializer <IChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; pipeline.AddLast(new LoggingHandler($"{Options.Name}-CONN")); this.Handler(channel, this._serviceProvider, Options); })) .ChildAttribute <AppFunc>(appKey, app) .ChildHandler(new ActionChannelInitializer <IChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; if (tlsCertificate != null) { pipeline.AddLast(TlsHandler.Server(tlsCertificate)); } pipeline.AddLast("encoder", new HttpResponseEncoder()); pipeline.AddLast("decoder", new HttpRequestDecoder(4096, 8192, 8192, false)); pipeline.AddLast(ActivatorUtilities.CreateInstance <HttpClientHandler>(this._serviceProvider, Options)); this.ChildHandler(channel, this._serviceProvider, Options); })); BoundChannel = await bootstrap.BindAsync(IPAddress.IPv6Any, Options.Port); _logger.LogInformation($"{Options.Name}-启动完成"); }
public async Task start() { IEventLoopGroup bossGroup; IEventLoopGroup workGroup; bossGroup = new MultithreadEventLoopGroup(1); workGroup = new MultithreadEventLoopGroup(); try { var bootstrap = new ServerBootstrap(); bootstrap.Group(bossGroup, workGroup); bootstrap.Channel <TcpServerSocketChannel>(); bootstrap .Option(ChannelOption.SoBacklog, 80) .Option(ChannelOption.SoReuseaddr, true) .Option(ChannelOption.TcpNodelay, true) .ChildHandler(new ActionChannelInitializer <IChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; pipeline.AddLast(new ProtobufVarint32FrameDecoder()) .AddLast(new ProtobufDecoder(Request.Parser)) .AddLast(new ProtobufVarint32LengthFieldPrepender()) .AddLast(new ProtobufEncoder()) .AddLast(new RequestHandler()); })); IChannel bootstrapChannel = await bootstrap.BindAsync(IPAddress.Any, _port); Console.ReadLine(); await bootstrapChannel.CloseAsync(); } finally { await workGroup.ShutdownGracefullyAsync(); await bossGroup.ShutdownGracefullyAsync(); } }
protected async Task RunServerAsync() { if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { GCSettings.LatencyMode = GCLatencyMode.SustainedLowLatency; } LogWrapper.Info($"Server garbage collection : {(GCSettings.IsServerGC ? "Enabled" : "Disabled")}"); LogWrapper.Info($"Current latency mode for garbage collection: {GCSettings.LatencyMode}"); LogWrapper.Info("\n"); _bossGroup = new MultithreadEventLoopGroup(1); _workGroup = new MultithreadEventLoopGroup(); var bootstrap = new ServerBootstrap(); bootstrap .Group(_bossGroup, _workGroup) .Channel <TcpServerSocketChannel>() .Option(ChannelOption.SoBacklog, 8192) .ChildHandler(new ActionChannelInitializer <IChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; pipeline.AddLast( new HttpServerCodec(), new HttpObjectAggregator(65536), //new WebSocketServerCompressionHandler(), new WebSocketServerProtocolHandler("/websocket", null, true), new BinaryWebSocketFrameHandler(), new ProtocolDecoder(), new ProtocolEncoder(), new MessageHandler(this.ChannelGroup)); })); int port = 18089; _bootstrapChannel = await bootstrap.BindAsync(IPAddress.Loopback, port); LogWrapper.Info("Listening on " + $"ws://127.0.0.1:{port}/websocket"); }
public Task StartAsync(CancellationToken cancellationToken) { bossGroup = new DispatcherEventLoopGroup(); workerGroup = new WorkerEventLoopGroup(bossGroup, configuration.EventLoopCount); serverBufferAllocator = new PooledByteBufferAllocator(); ServerBootstrap bootstrap = new ServerBootstrap(); bootstrap.Group(bossGroup, workerGroup); bootstrap.Channel <TcpServerChannel>(); if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) || RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) { bootstrap .Option(ChannelOption.SoReuseport, true) .ChildOption(ChannelOption.SoReuseaddr, true); } bootstrap .Option(ChannelOption.SoBacklog, configuration.SoBacklog) .ChildOption(ChannelOption.Allocator, serverBufferAllocator) .ChildHandler(new ActionChannelInitializer <IChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; using (var scope = serviceProvider.CreateScope()) { channel.Pipeline.AddLast("jt809SystemIdleState", new IdleStateHandler( configuration.ReaderIdleTimeSeconds, configuration.WriterIdleTimeSeconds, configuration.AllIdleTimeSeconds)); channel.Pipeline.AddLast("jt809TcpConnection", scope.ServiceProvider.GetRequiredService <JT809TcpConnectionHandler>()); channel.Pipeline.AddLast("jt809TcpBuffer", new DelimiterBasedFrameDecoder(int.MaxValue, Unpooled.CopiedBuffer(new byte[] { JT809Package.BEGINFLAG }), Unpooled.CopiedBuffer(new byte[] { JT809Package.ENDFLAG }))); channel.Pipeline.AddLast("jt809TcpDecode", scope.ServiceProvider.GetRequiredService <JT809TcpDecoder>()); channel.Pipeline.AddLast("jt809TcpService", scope.ServiceProvider.GetRequiredService <JT809TcpServerHandler>()); } })); logger.LogInformation($"JT809 TCP Server start at {IPAddress.Any}:{configuration.TcpPort}."); return(bootstrap.BindAsync(configuration.TcpPort) .ContinueWith(i => bootstrapChannel = i.Result)); }
public void TestFlushAfterGatheredFlush() { var group = new MultithreadEventLoopGroup(1); var socket = new Socket(SocketType.Stream, ProtocolType.Tcp); IChannel sc = null; try { ServerBootstrap sb = new ServerBootstrap(); sb.Group(group) .Channel <TcpServerSocketChannel>() .ChildHandler(new ChannelInboundHandlerAdapter0()); sc = sb.BindAsync(new IPEndPoint(IPAddress.Loopback, 0)).GetAwaiter().GetResult(); socket.ConnectAsync(sc.LocalAddress).GetAwaiter().GetResult(); byte[] tempArea = new byte[3]; Span <byte> buf = tempArea; var totalCount = 0; do { var byteCount = socket.Receive(buf); if (byteCount < 0) { break; } totalCount += byteCount; if (totalCount < 3) { buf = buf.Slice(totalCount); } } while (totalCount < 3); Assert.Equal("abc", Encoding.ASCII.GetString(tempArea)); } finally { sc?.CloseAsync().GetAwaiter().GetResult(); SocketEx.SafeClose(socket); group.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1)).GetAwaiter().GetResult(); } }
public async Task RunServerAsync() { OnSubMessage?.Invoke("服务启动中......", "重要"); //第一步:创建ServerBootstrap实例 var bootstrap = new ServerBootstrap(); //第二步:绑定事件组 IEventLoopGroup mainGroup = new MultithreadEventLoopGroup(1); //主工作线程组 IEventLoopGroup workGroup = new MultithreadEventLoopGroup(); //工作线程组 bootstrap.Group(mainGroup, workGroup); //第三步:绑定服务端的通道 bootstrap.Channel <TcpServerSocketChannel>();// 设置通道模式为TcpSocket //第四步:配置处理器 bootstrap.Option(ChannelOption.SoBacklog, 8192); bootstrap.ChildHandler(new ActionChannelInitializer <IChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; pipeline.AddLast(new HttpServerCodec()); pipeline.AddLast(new HttpObjectAggregator(65536)); var handler = DIHelper.GetService <HttpChannelHandler>(); if (OnException != null) { handler.OnException += OnException; } pipeline.AddLast(handler);//注入HttpChannelHandler })); //第五步:配置主机和端口号 var iPAddress = GetTrueIPAddress(); //获得真实IP地址 var port = ConfigHelper.Configuration["ServerConfig:Port"]; IChannel bootstrapChannel = await bootstrap.BindAsync(iPAddress, int.Parse(port)); OnSubMessage?.Invoke("服务启动成功", "重要"); OnMessage?.Invoke($"已监听http://{iPAddress}:{int.Parse(port)}"); //第六步:停止服务 WaitServerStop();//等待服务停止 OnSubMessage?.Invoke("正在停止服务......", "重要"); await bootstrapChannel.CloseAsync(); OnSubMessage?.Invoke("服务已停止", "重要"); }
/// <summary> /// /// </summary> /// <param name="cancellationToken"></param> /// <returns></returns> public async Task StartAsync(IEventLoopGroup BossGroup, IEventLoopGroup WorkerGroup, ServerOptions Options, AppFunc app) { X509Certificate2 tlsCertificate = null; if (Options.IsSsl) { tlsCertificate = new X509Certificate2(Path.Combine(_environment.ContentRootPath, Options.CertificatePath), Options.CertificateToken); } var bootstrap = new ServerBootstrap(); var appKey = AttributeKey <AppFunc> .ValueOf(Constants.AppAttributeKey); bootstrap .Group(BossGroup, WorkerGroup) .Channel <UdpServerSocketDatagramChannel>() .Option(ChannelOption.SoBroadcast, true) .Handler(new ActionChannelInitializer <IChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; this.Handler(channel, this._serviceProvider, Options); pipeline.AddLast(ActivatorUtilities.CreateInstance <UdpChannelGroupHandler>(this._serviceProvider, Options)); })) .ChildAttribute <AppFunc>(appKey, app) .ChildHandler(new ActionChannelInitializer <IChannel>(channel => { if (tlsCertificate != null) { channel.Pipeline.AddLast(TlsHandler.Server(tlsCertificate)); } channel.Pipeline.AddLast(new IdleStateHandler(Options.Timeout, 0, 0)); channel.Pipeline.AddLast(new HeartBeatCheckHandler()); this.ChildHandler(channel, this._serviceProvider, Options); })); BoundChannel = await bootstrap.BindAsync(IPAddress.IPv6Any, Options.Port); _logger.LogInformation($"{Options.Name}-Server-启动完成.端口号:{Options.Port}"); }
static async Task RunServerAsync() { IEventLoopGroup bossGroup = new MultithreadEventLoopGroup(1); IEventLoopGroup workerGroup = new MultithreadEventLoopGroup(); try { var bootstrap = new ServerBootstrap(); bootstrap .Group(bossGroup, workerGroup); bootstrap.Channel <TcpServerSocketChannel>(); bootstrap .Option(ChannelOption.SoBacklog, 100) .Handler(new LoggingHandler("SRV-LSTN")) .ChildHandler(new ActionChannelInitializer <IChannel>(channel => { var pipeline = channel.Pipeline; pipeline.AddLast(new ProtobufVarint32FrameDecoder()); pipeline.AddLast(new ProtobufDecoder(Packet.Parser)); pipeline.AddLast(new ProtobufVarint32LengthFieldPrepender()); pipeline.AddLast(new ProtobufEncoder()); pipeline.AddLast(new ServerHandler()); })); var boundChannel = await bootstrap.BindAsync(9999); Console.ReadLine(); await boundChannel.CloseAsync(); } finally { await Task.WhenAll( bossGroup.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1)), workerGroup.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1))); } }
public async Task Start(IPAddress ip_address, int port, string orleansClientConfigFile, SessionHandlerFactory factory) { bootstrap .Group(bossGroup, workerGroup) .Channel <TcpServerSocketChannel>() .Option(ChannelOption.SoBacklog, 100) .Handler(new LoggingHandler(LogLevel.INFO)) .ChildHandler(new ActionChannelInitializer <ISocketChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; pipeline.AddLast(new LengthFieldPrepender( ByteOrder.LittleEndian, 2, 0, false)); pipeline.AddLast(new LengthFieldBasedFrameDecoder( ByteOrder.LittleEndian, ushort.MaxValue, 0, 2, 0, 2, true)); pipeline.AddLast(new GatewayChannelHandler(factory)); })); bootstrapChannel = await bootstrap.BindAsync(ip_address, port); GrainClient.Initialize(orleansClientConfigFile); }
public virtual void TestShutdownGracefullyNoQuietPeriod() { IEventLoopGroup loop = NewEventLoopGroup(); ServerBootstrap b = new ServerBootstrap(); b.Group(loop) .Channel <TServerChannel>() .ChildHandler(new ChannelHandlerAdapter()); // Not close the Channel to ensure the EventLoop is still shutdown in time. var cf = typeof(TServerChannel) == typeof(LocalServerChannel) ? b.BindAsync(new LocalAddress("local")) : b.BindAsync(0); cf.GetAwaiter().GetResult(); var f = loop.ShutdownGracefullyAsync(TimeSpan.Zero, TimeSpan.FromMinutes(1)); Assert.True(loop.TerminationCompletion.Wait(TimeSpan.FromMilliseconds(600))); Assert.True(f.IsSuccess()); Assert.True(loop.IsShutdown); Assert.True(loop.IsTerminated); }
private static async Task RunServerAsync(int port) { MultithreadEventLoopGroup bossGroup = new MultithreadEventLoopGroup(1); MultithreadEventLoopGroup workerGroup = new MultithreadEventLoopGroup(); try { ServerBootstrap bootstrap = new ServerBootstrap(); bootstrap.Group(bossGroup, workerGroup) .Channel <TcpServerSocketChannel>() .ChildHandler(new ActionChannelInitializer <ISocketChannel>(channel => { channel.Pipeline.AddLast(new DiscardServerHandler()); })) .Option(ChannelOption.SoBacklog, 128) .ChildOption(ChannelOption.SoKeepalive, true); IChannel bootstrapChannel = await bootstrap.BindAsync(port); await bootstrapChannel.CloseCompletion; } finally { Task.WaitAll(bossGroup.ShutdownGracefullyAsync(), workerGroup.ShutdownGracefullyAsync()); } }
public async Task RunServerAsync() { //SocketUtil.SetConsoleLogger(); try { var bootstrap = new ServerBootstrap(); bootstrap.Group(bossGroup, workerGroup); bootstrap.Channel <TcpServerSocketChannel>(); bootstrap .Option(ChannelOption.SoBacklog, 1024) //ByteBuf的分配器(重用缓冲区)大小 .Option(ChannelOption.Allocator, UnpooledByteBufferAllocator.Default) .Option(ChannelOption.RcvbufAllocator, new FixedRecvByteBufAllocator(1024 * 8)) .ChildOption(ChannelOption.SoKeepalive, true) //保持长连接 .ChildOption(ChannelOption.TcpNodelay, true) //端口复用 .ChildOption(ChannelOption.SoReuseport, true) .Handler(new LoggingHandler("SRV-LSTN")) //自定义初始化Tcp服务 .ChildHandler(new TcpServerInitializer()); await bootstrap.BindAsync(8888); Console.WriteLine("TestNetty tcp server starting..."); do { var result = Console.ReadLine(); if (result != "exit") { break; } } while (true); } finally { await Task.WhenAll( bossGroup.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1)), workerGroup.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1))); } }
private void TestHalfClosureOnlyOneEventWhenAutoRead0(ServerBootstrap sb, Bootstrap cb) { IChannel serverChannel = null; try { cb.Option(ChannelOption.AllowHalfClosure, true) .Option(ChannelOption.AutoRead, true); sb.ChildHandler(new ActionChannelInitializer <IChannel>(ch => { ch.Pipeline.AddLast(new ChannelInboundHandlerAdapter4()); })); AtomicInteger shutdownEventReceivedCounter = new AtomicInteger(); AtomicInteger shutdownReadCompleteEventReceivedCounter = new AtomicInteger(); cb.Handler(new ActionChannelInitializer <IChannel>(ch => { ch.Pipeline.AddLast(new ChannelInboundHandlerAdapter5(shutdownEventReceivedCounter, shutdownReadCompleteEventReceivedCounter)); })); serverChannel = sb.BindAsync().GetAwaiter().GetResult(); IChannel clientChannel = cb.ConnectAsync(serverChannel.LocalAddress).GetAwaiter().GetResult(); clientChannel.CloseCompletion.GetAwaiter().GetResult(); Assert.Equal(1, shutdownEventReceivedCounter.Value); Assert.Equal(1, shutdownReadCompleteEventReceivedCounter.Value); } finally { if (serverChannel != null) { serverChannel.CloseAsync().GetAwaiter().GetResult(); } Task.WaitAll( sb.Group().ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(5)), sb.ChildGroup().ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(5)), cb.Group().ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(5))); } }
static async Task ServerStart() { IEventLoopGroup boss = new MultithreadEventLoopGroup(); IEventLoopGroup worker = new MultithreadEventLoopGroup(); try { var bootstrap = new ServerBootstrap(); bootstrap.Group(boss, worker) .Channel <TcpServerSocketChannel>() .Option(ChannelOption.SoBacklog, 1024 * 2) .Option(ChannelOption.SoRcvbuf, 32 * 1024 * 2 * 2) .ChildOption(ChannelOption.SoKeepalive, true) // 设置保持连接 .ChildOption(ChannelOption.SoSndbuf, 32 * 1024) .ChildHandler(new ActionChannelInitializer <IChannel>(channel => { var pipeline = channel.Pipeline; pipeline.AddLast(new LoggingHandler("STATIC-NETTY-SRV-CONN")); pipeline.AddLast("split", new FrameSplitHandler()); // pipeline.AddLast("validator", new ValidateHandler()); pipeline.AddLast("head-decode", new HeadDecoder()); pipeline.AddLast("core", new CoreHandler()); })); const int port = 19014; var boundChannel = await bootstrap.BindAsync(port); // Console.WriteLine("server启动成功,监听端口:{0}", port); _logger.Info($"server启动成功,监听端口:{port}"); Console.ReadLine(); await boundChannel.CloseAsync(); } finally { await Task.WhenAll( boss.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1)), worker.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1))); } }
static async Task RunServer() { var bossGroup = new MultithreadEventLoopGroup(1); var workerGroup = new MultithreadEventLoopGroup(); try { var bootstrap = new ServerBootstrap(); bootstrap .Group(bossGroup, workerGroup) .Channel <TcpServerSocketChannel>() .Option(ChannelOption.SoBacklog, 100) .Handler(new LoggingHandler(LogLevel.INFO)) .ChildHandler(new ActionSendChannelInitializer <ISocketChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; if (EchoServerSettings.IsSsl) { pipeline.AddLast(TlsHandler.Server(new X509Certificate2("dotnetty.com.pfx", "password"))); } pipeline.AddLast(new LengthFieldPrepender(2)); pipeline.AddLast(new LengthFieldBasedFrameDecoder(ushort.MaxValue, 0, 2, 0, 2)); pipeline.AddLast(new EchoServerHandler()); })); IChannel bootstrapChannel = await bootstrap.BindAsync(EchoServerSettings.Port); Console.ReadLine(); await bootstrapChannel.CloseAsync(); } finally { Task.WaitAll(bossGroup.ShutdownGracefullyAsync(), workerGroup.ShutdownGracefullyAsync()); } }
public async Task StartAsync(EndPoint endPoint) { var serverCompletion = new TaskCompletionSource(); var bossGroup = new MultithreadEventLoopGroup(1); var workerGroup = new MultithreadEventLoopGroup();//Default eventLoopCount is Environment.ProcessorCount * 2 var bootstrap = new ServerBootstrap(); bootstrap .Group(bossGroup, workerGroup) .Channel <TcpServerSocketChannel>() .Option(ChannelOption.SoReuseport, true) .ChildOption(ChannelOption.SoReuseaddr, true) .Option(ChannelOption.SoBacklog, AppConfig.ServerOptions.SoBacklog) .ChildHandler(new ActionChannelInitializer <IChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; pipeline.AddLast("encoder", new HttpResponseEncoder()); pipeline.AddLast(new HttpRequestDecoder(int.MaxValue, 8192, 8192, true)); pipeline.AddLast(new HttpObjectAggregator(int.MaxValue)); pipeline.AddLast(new ServerHandler(async(contenxt, message) => { var sender = new DotNettyHttpServerMessageSender(_transportMessageEncoder, contenxt, _serializer); await OnReceived(sender, message); }, _logger, _serializer, _serviceRouteProvider)); serverCompletion.TryComplete(); })); try { _channel = await bootstrap.BindAsync(endPoint); _logger.LogInformation($"Rpc服务主机(Http协议){AppConfig.ServerOptions.HostName}启动成功,RPC服务地址:{endPoint}。"); } catch (Exception ex) { _logger.LogError($"Rpc服务主机(Http协议){AppConfig.ServerOptions.HostName}启动失败,原因:{ex.Message},RPC服务地址:{endPoint}。 "); throw ex; } }
public Task <IChannel> StartAsync() { var bootstrap = new ServerBootstrap(); bootstrap.Group(this.bossGroup, this.workGroup); if (ServerSettings.UseLibuv) { bootstrap.Channel <TcpServerChannel>(); if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) || RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) { bootstrap .Option(ChannelOption.SoReuseport, true) .ChildOption(ChannelOption.SoReuseaddr, true); } } else { bootstrap.Channel <TcpServerSocketChannel>(); } bootstrap .Option(ChannelOption.SoBacklog, 1024) //.Option(ChannelOption.Allocator, UnpooledByteBufferAllocator.Default) .Handler(new LoggingHandler("LSTN")) .ChildHandler(new ActionChannelInitializer <IChannel>(ch => { ch.Pipeline.AddLast(new HttpRequestDecoder(), new HttpResponseEncoder(), new HttpObjectAggregator(MAX_CONTENT_LENGTH), new Http1RequestHandler()); })); return(bootstrap.BindAsync(IPAddress.Loopback, PORT)); }
/// <summary> /// 开始监听 /// </summary> public async Task RunAsync(CancellationToken cancellationToken) { connectionCount = 0; sendBytesCount = 0; receiveBytesCount = 0; startTime = DateTime.Now; stopTime = default(DateTime); var option = options.Value; var bossGroup = new MultithreadEventLoopGroup(option.ParentGroupCount); var workerGroup = new MultithreadEventLoopGroup(option.ChildGroupCount); var bootstrap = new ServerBootstrap(); bootstrap .Group(bossGroup, workerGroup) .Channel <TcpServerSocketChannel>() .Option(ChannelOption.SoBacklog, option.ListenBacklog) .ChildHandler(new ActionChannelInitializer <ISocketChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; pipeline.AddLast(new ArrayToByteEncoder(), new ArraySegmentToByteEnCoder(), new EnCoder(EnCodeRequestInfo)); pipeline.AddLast(new DeCoder(DeCodeRequestInfo), new SessionHandler(ChannelActive, ChannelInactive, ChannelRead)); })); foreach (var item in option.Listeners.Split(new char[] { ';' })) { var arr = item.Split(new char[] { ':' }); var bootstrapChannel = await bootstrap.BindAsync(IPAddress.Parse(arr[0]), int.Parse(arr[1])); this.channels.Add(bootstrapChannel); } isRun = 1; ServerStarted?.Invoke(this, new EventArgs()); OnServerStarted(); }
public async Task StartAsync(EndPoint endPoint) { if (_logger.IsEnabled(LogLevel.Debug)) { _logger.LogDebug($"准备启动服务主机,监听地址:{endPoint}。"); } var bossGroup = new MultithreadEventLoopGroup(1); var workerGroup = new MultithreadEventLoopGroup(); var bootstrap = new ServerBootstrap(); bootstrap .Group(bossGroup, workerGroup) .Channel <TcpServerSocketChannel>() .Option(ChannelOption.SoBacklog, 100) .ChildHandler(new ActionChannelInitializer <ISocketChannel>(channel => { var pipeline = channel.Pipeline; pipeline.AddLast( new IdleStateHandler(8, 0, 0), idleStateTrigger, new ProtocolDecoder(), encoder, new TransportMessageChannelHandlerAdapter(_transportMessageDecoder)); pipeline.AddLast(new ServerHandler(async(contenxt, message) => { var sender = new DotNettyServerMessageSender(_transportMessageEncoder, contenxt); await OnReceived(sender, message); }, _logger)); })); _channel = await bootstrap.BindAsync(endPoint); if (_logger.IsEnabled(LogLevel.Debug)) { _logger.LogDebug($"服务主机启动成功,监听地址:{endPoint}。"); } }
public async Task StartAsync(EndPoint endPoint) { var bossGroup = new MultithreadEventLoopGroup(1); var workerGroup = new MultithreadEventLoopGroup(); var bootstrap = new ServerBootstrap(); bootstrap .Group(bossGroup, workerGroup) .Channel <TcpServerSocketChannel>() .Option(ChannelOption.SoBacklog, 100) .Handler(new LoggingHandler("SRV-LSTN")) .ChildHandler(new ActionChannelInitializer <ISocketChannel>(channel => { var pipeline = channel.Pipeline; pipeline.AddLast(new LoggingHandler("SRV-CONN")); MessageMeta meta = _msgCodecs.GetMessageMeta(); // IdleStateHandler pipeline.AddLast("timeout", new IdleStateHandler(0, 0, meta.HeartbeatInterval / 1000 * 2)); //服务端双倍来处理 //消息前处理 pipeline.AddLast( new LengthFieldBasedFrameDecoder( meta.MaxFrameLength, meta.LengthFieldOffset, meta.LengthFieldLength, meta.LengthAdjustment, meta.InitialBytesToStrip ) ); pipeline.AddLast(new ChannelDecodeHandler <TMessage>(_msgCodecs)); pipeline.AddLast(new ServerChannelHandlerAdapter <TMessage>(this)); })); this._channel = await bootstrap.BindAsync(endPoint); }
private void TestAllDataReadClosure0(ServerBootstrap sb, Bootstrap cb, bool supportHalfClosed) { try { TestAllDataReadClosure0(true, false, sb, cb); if (supportHalfClosed) { TestAllDataReadClosure0(true, true, sb, cb); } TestAllDataReadClosure0(false, false, sb, cb); if (supportHalfClosed) { TestAllDataReadClosure0(false, true, sb, cb); } } finally { Task.WaitAll( sb.Group().ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(5)), sb.ChildGroup().ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(5)), cb.Group().ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(5))); } }
public async Task Listen(int port) { BossGroup = new MultithreadEventLoopGroup(1); WorkerGroup = new MultithreadEventLoopGroup(); var bootstrap = new ServerBootstrap(); bootstrap .Group(BossGroup, WorkerGroup) .Channel <TcpServerSocketChannel>() .Option(ChannelOption.SoBacklog, 100) .ChildHandler(new ActionChannelInitializer <ISocketChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; pipeline.AddLast(new LengthFieldPrepender(4)); pipeline.AddLast(new LengthFieldBasedFrameDecoder(int.MaxValue, 0, 4, 0, 4)); ServerMessageHandler handler = new ServerMessageHandler(); handler.Handle += new RpcDefaultRequestHandler().Handle; pipeline.AddLast(handler); })); BoundChannel = await bootstrap.BindAsync(port); }
static async Task RunServerAsync() { IEventLoopGroup bossGroup = new MultithreadEventLoopGroup(); IEventLoopGroup workerGroup = new MultithreadEventLoopGroup(); ServerBootstrap serverBootstrap = new ServerBootstrap(); try { serverBootstrap.Group(bossGroup, workerGroup) .Channel <TcpServerSocketChannel>() .Option(ChannelOption.SoBacklog, 128) .ChildOption(ChannelOption.SoKeepalive, true) .ChildOption(ChannelOption.TcpNodelay, true) .ChildHandler(new ActionChannelInitializer <IChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; pipeline.AddLast(new IdleStateHandler(READ_IDEL_TIME_OUT, WRITE_IDEL_TIME_OUT, ALL_IDEL_TIME_OUT)); pipeline.AddLast(new HeartBeatHandler()); pipeline.AddLast(new DelimiterBasedFrameDecoder(MESSAGE_MAX_SIZE, true, false, Unpooled.CopiedBuffer(Encoding.ASCII.GetBytes(new char[] { (char)'$' })))); pipeline.AddLast("framing-enc", new StringEncoder(Encoding.UTF8)); pipeline.AddLast("framing-dec", new StringDecoder(Encoding.UTF8)); pipeline.AddLast("echo", new ServerHandler()); })); IChannel boundChannel = await serverBootstrap.BindAsync(8999); Console.ReadLine(); await boundChannel.CloseAsync(); } finally { await Task.WhenAll( bossGroup.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1)), workerGroup.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1))); } }
public void LocalChannel_should_not_fire_channel_active_before_connecting() { var cb = new ClientBootstrap(); var sb = new ServerBootstrap(); cb.Group(_group1).Channel <LocalChannel>().Handler(new DummyHandler()); sb.Group(_group2).Channel <LocalServerChannel>().ChildHandler(new ActionChannelInitializer <LocalChannel>( channel => { channel.Pipeline.AddLast(new TestHandler()); })); IChannel sc = null; IChannel cc = null; try { // Start server sc = sb.BindAsync(TEST_ADDRESS).Result; cc = cb.Register().Result; var promise = new TaskCompletionSource(); var assertPromise = new TaskCompletionSource(); cc.Pipeline.AddLast(new PromiseAssertHandler(promise, assertPromise)); // Connect to the server cc.ConnectAsync(sc.LocalAddress).Wait(); assertPromise.Task.Wait(); Assert.True(promise.Task.IsCompleted); } finally { CloseChannel(cc); CloseChannel(sc); } }
private async Task TestChannelEventsFiredWhenClosedDirectly0(ServerBootstrap sb, Bootstrap cb) { BlockingCollection <int> events = new BlockingCollection <int>(); IChannel sc = null; IChannel cc = null; try { sb.ChildHandler(new ChannelHandlerAdapter()); sc = await sb.BindAsync(); cb.Handler(new ChannelInboundHandlerAdapter0(events)); // Connect and directly close again. cc = await cb.ConnectAsync(sc.LocalAddress); await cc.CloseAsync(); Assert.Equal(0, events.Take()); Assert.Equal(1, events.Take()); } finally { if (cc != null) { await cc.CloseAsync(); } if (sc != null) { await sc.CloseAsync(); } Task.WaitAll( sb.Group().ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(5)), sb.ChildGroup().ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(5)), cb.Group().ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(5))); } }
public TcpServer(TcpServerConfig config) { this.config = config; ReceiveAsync <Bind>(async m => { try { var bootstrap = new ServerBootstrap(); bootstrap // TODO configure to use seperate event loop groups .Group(new MultithreadEventLoopGroup()) .Channel <TcpServerSocketChannel>() // TODO configure socket options .Option(ChannelOption.SoBacklog, 100) .Option(ChannelOption.SoRcvbuf, 1024 * 16) .Option(ChannelOption.SoSndbuf, 1024 * 16) // TODO configure logging //.Handler(new LoggingHandler("ping-pong-server")) .ChildHandler(new ChannelInitializer(Context.System, Self)); // TODO Any threading risk here? channel = await bootstrap.BindAsync(m.LocalAddress); monitor = Sender; Sender.Tell(new Bound(m.LocalAddress)); Become(Bound); } catch (Exception) { // TODO Handler exceptions channel = null; monitor = null; } }); }
public Task ListenAsync() { if (EventLoopGroup == null) { var EventLoopGroup = new DispatcherEventLoopGroup(); WorkerGroup = new WorkerEventLoopGroup(EventLoopGroup); ServerBootstrap = new ServerBootstrap(); ServerBootstrap.Group(EventLoopGroup, WorkerGroup); ServerBootstrap.Channel <TcpServerChannel>(); ServerBootstrap .Option(ChannelOption.SoBacklog, 100) .Handler(new LoggingHandler("SRV-LSTN")) .ChildHandler(new ActionChannelInitializer <IChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; pipeline.AddLast(new LoggingHandler("SRV-CONN")); pipeline.AddLast("framing-enc", new LengthFieldPrepender(4)); pipeline.AddLast("framing-dec", new LengthFieldBasedFrameDecoder(int.MaxValue, 0, 4, 0, 4)); pipeline.AddLast("network-handler", new NetworkHandler(true, this)); })); if (EnableHeartbeat) { Ping(false); } } try { Console.WriteLine($"Listen ip {this.Address} port {this.Port}"); return(ServerBootstrap.BindAsync(new IPEndPoint(IPAddress.Parse(this.Address), this.Port))); } catch (Exception ex) { Console.WriteLine(ex); return(Task.FromResult(0)); } }
public async Task StartAsync(EndPoint endPoint) { if (_logger.IsEnabled(LogLevel.Debug)) { _logger.LogDebug($"准备启动服务主机,监听地址:{endPoint}。"); } var serverCompletion = new TaskCompletionSource(); var bossGroup = new MultithreadEventLoopGroup(1); var workerGroup = new MultithreadEventLoopGroup();//Default eventLoopCount is Environment.ProcessorCount * 2 var bootstrap = new ServerBootstrap(); bootstrap .Group(bossGroup, workerGroup) .Channel <TcpServerSocketChannel>() .Option(ChannelOption.SoReuseport, true) .ChildOption(ChannelOption.SoReuseaddr, true) .Option(ChannelOption.SoBacklog, 8192) .ChildHandler(new ActionChannelInitializer <IChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; pipeline.AddLast("encoder", new HttpResponseEncoder()); pipeline.AddLast(new HttpRequestDecoder(int.MaxValue, 8192, 8192, true)); pipeline.AddLast(new HttpObjectAggregator(int.MaxValue)); pipeline.AddLast(new ServerHandler(async(contenxt, message) => { var sender = new DotNettyHttpServerMessageSender(_transportMessageEncoder, contenxt, _serializer); await OnReceived(sender, message); }, _logger, _serializer)); serverCompletion.TryComplete(); })); _channel = await bootstrap.BindAsync(endPoint); if (_logger.IsEnabled(LogLevel.Debug)) { _logger.LogDebug($"服务主机启动成功,监听地址:{endPoint}。"); } }
/// <summary> /// 启动主机。 /// </summary> /// <param name="endPoint">主机终结点。</param> /// <returns>一个任务。</returns> public async Task StartAsync(EndPoint endPoint) { if (_logger.IsEnabled(LogLevel.Debug)) _logger.Debug($"准备启动服务主机,监听地址:{endPoint}。"); var bossGroup = new MultithreadEventLoopGroup(1); var workerGroup = new MultithreadEventLoopGroup(); var bootstrap = new ServerBootstrap(); bootstrap .Group(bossGroup, workerGroup) .Channel<TcpServerSocketChannel>() .Option(ChannelOption.SoBacklog, 100) .ChildHandler(new ActionChannelInitializer<ISocketChannel>(channel => { var pipeline = channel.Pipeline; pipeline.AddLast(new LengthFieldPrepender(4)); pipeline.AddLast(new LengthFieldBasedFrameDecoder(int.MaxValue, 0, 4, 0, 4)); pipeline.AddLast(new ServerHandler(_serializer, _serviceEntryLocate, _logger)); })); _channel = await bootstrap.BindAsync(endPoint); if (_logger.IsEnabled(LogLevel.Debug)) _logger.Debug($"服务主机启动成功,监听地址:{endPoint}。"); }
public void LocalChannel_WriteAsync_should_fail_fast_on_closed_channel() { var cb = new ClientBootstrap(); var sb = new ServerBootstrap(); cb.Group(_group1).Channel<LocalChannel>().Handler(new TestHandler()); sb.Group(_group2).Channel<LocalServerChannel>().ChildHandler(new ActionChannelInitializer<LocalChannel>( channel => { channel.Pipeline.AddLast(new TestHandler()); })); IChannel sc = null; IChannel cc = null; try { // Start server sc = sb.BindAsync(TEST_ADDRESS).Result; var latch = new CountdownEvent(1); // Connect to the server cc = cb.ConnectAsync(sc.LocalAddress).Result; // Close the channel and write something cc.CloseAsync().Wait(); var ag = Assert.Throws<AggregateException>(() => { cc.WriteAndFlushAsync(new object()).Wait(); }).Flatten(); Assert.IsType<ClosedChannelException>(ag.InnerException); } finally { CloseChannel(cc); CloseChannel(sc); } }
public void LocalChannel_writes_to_server_should_be_read_by_LocalChannel() { var cb = new ClientBootstrap(); var sb = new ServerBootstrap(); var reads = new[] {-11, 2, 9, 13, 1013, 1, 4}; var resetEvent = new ManualResetEventSlim(); var accumulatedReads = new List<int>(); cb.Group(_group1) .Channel<LocalChannel>() .Handler( new ActionChannelInitializer<LocalChannel>( channel => { channel.Pipeline.AddLast(new LengthFieldBasedFrameDecoder(20, 0, 4, 0, 4)) .AddLast(new LengthFieldPrepender(4, false)) .AddLast(new IntCodec()); })); sb.Group(_group2) .Channel<LocalServerChannel>() .ChildHandler( new ActionChannelInitializer<LocalChannel>( channel => { channel.Pipeline.AddLast(new LengthFieldBasedFrameDecoder(20, 0, 4, 0, 4)) .AddLast(new LengthFieldPrepender(4, false)) .AddLast(new IntCodec()) .AddLast(new ReadAssertHandler(accumulatedReads, resetEvent, reads)); })); IChannel sc = null; IChannel cc = null; try { // Start server sc = sb.BindAsync(TEST_ADDRESS).Result; // Connect to the server cc = cb.ConnectAsync(sc.LocalAddress).Result; foreach (var read in reads) { cc.WriteAsync(read); } cc.Flush(); resetEvent.Wait(200); Assert.Equal(reads, accumulatedReads); } finally { CloseChannel(sc); CloseChannel(cc); } }
public void TcpSocketChannel_can_connect_to_TcpServerSocketChannel() { IEventLoopGroup group1 = new MultithreadEventLoopGroup(2); IEventLoopGroup group2 = new MultithreadEventLoopGroup(2); var cb = new ClientBootstrap(); var sb = new ServerBootstrap(); var reads = 100; var resetEvent = new ManualResetEventSlim(); cb.Group(group1) .Channel<TcpSocketChannel>() .Handler( new ActionChannelInitializer<TcpSocketChannel>( channel => { channel.Pipeline.AddLast(new LengthFieldBasedFrameDecoder(20, 0, 4, 0, 4)) .AddLast(new LengthFieldPrepender(4, false)) .AddLast(new IntCodec()) .AddLast(new TestHandler()); })); sb.Group(group2) .Channel<TcpServerSocketChannel>() .ChildHandler( new ActionChannelInitializer<TcpSocketChannel>( channel => { channel.Pipeline.AddLast(new LengthFieldBasedFrameDecoder(20, 0, 4, 0, 4)) .AddLast(new LengthFieldPrepender(4, false)) .AddLast(new IntCodec()) .AddLast(new ReadCountAwaiter(resetEvent, reads)) .AddLast(new TestHandler()); })); IChannel sc = null; IChannel cc = null; try { // Start server sc = sb.BindAsync(TEST_ADDRESS).Result; // Connect to the server cc = cb.ConnectAsync(sc.LocalAddress).Result; foreach (var read in Enumerable.Range(0, reads)) { cc.WriteAndFlushAsync(read); } Assert.True(resetEvent.Wait(15000)); } finally { CloseChannel(cc); CloseChannel(sc); Task.WaitAll(group1.ShutdownGracefullyAsync(), group2.ShutdownGracefullyAsync()); } }
public void LocalChannel_should_not_fire_channel_active_before_connecting() { var cb = new ClientBootstrap(); var sb = new ServerBootstrap(); cb.Group(_group1).Channel<LocalChannel>().Handler(new DummyHandler()); sb.Group(_group2).Channel<LocalServerChannel>().ChildHandler(new ActionChannelInitializer<LocalChannel>( channel => { channel.Pipeline.AddLast(new TestHandler()); })); IChannel sc = null; IChannel cc = null; try { // Start server sc = sb.BindAsync(TEST_ADDRESS).Result; cc = cb.Register().Result; var promise = new TaskCompletionSource(); var assertPromise = new TaskCompletionSource(); cc.Pipeline.AddLast(new PromiseAssertHandler(promise, assertPromise)); // Connect to the server cc.ConnectAsync(sc.LocalAddress).Wait(); assertPromise.Task.Wait(); Assert.True(promise.Task.IsCompleted); } finally { CloseChannel(cc); CloseChannel(sc); } }
public void LocalChannel_PeerClose_when_WritePromiseComplete_in_same_eventloop_should_still_preserve_order() { var cb = new ClientBootstrap(); var sb = new ServerBootstrap(); var messageLatch = new CountdownEvent(2); var data = Unpooled.WrappedBuffer(new byte[1024]); var serverLatch = new CountdownEvent(1); var serverChannelRef = new AtomicReference<IChannel>(); try { cb.Group(_sharedGroup) .Channel<LocalChannel>() .Handler(new TestHandler()); sb.Group(_sharedGroup) .Channel<LocalServerChannel>() .ChildHandler(new ActionChannelInitializer<LocalChannel>(channel => { channel.Pipeline.AddLast(new ReadCountdown1(messageLatch, data)); serverChannelRef = channel; serverLatch.Signal(); })); IChannel sc = null; IChannel cc = null; try { // Start server sc = sb.BindAsync(TEST_ADDRESS).Result; // Connect to server cc = cb.ConnectAsync(sc.LocalAddress).Result; serverLatch.Wait(TimeSpan.FromSeconds(5)); Assert.True(serverLatch.IsSet); var ccCpy = cc; // Make sure a write operation is executed in the eventloop cc.Pipeline.LastContext().Executor.Execute(() => { ccCpy.WriteAndFlushAsync(data.Duplicate().Retain()).ContinueWith(tr => { var severChannelCopy = serverChannelRef.Value; severChannelCopy.CloseAsync(); }); }); Assert.True(messageLatch.Wait(TimeSpan.FromSeconds(5))); Assert.False(cc.IsOpen); Assert.False(serverChannelRef.Value.IsOpen); } finally { CloseChannel(sc); CloseChannel(cc); } } finally { data.Release(); } }
public void LocalChannel_should_reuse_LocalAddress() { for (var i = 0; i < 2; i++) { var cb = new ClientBootstrap(); var sb = new ServerBootstrap(); cb.Group(_group1).Channel<LocalChannel>().Handler(new TestHandler()); sb.Group(_group2).Channel<LocalServerChannel>().ChildHandler(new ActionChannelInitializer<LocalChannel>( channel => { channel.Pipeline.AddLast(new TestHandler()); })); IChannel sc = null; IChannel cc = null; try { // Start server sc = sb.BindAsync(TEST_ADDRESS).Result; var latch = new CountdownEvent(1); // Connect to the server cc = cb.ConnectAsync(sc.LocalAddress).Result; var cCpy = cc; cc.EventLoop.Execute(o => { var c = (LocalChannel) o; c.Pipeline.FireChannelRead("Hello, World"); latch.Signal(); }, cCpy); latch.Wait(TimeSpan.FromSeconds(5)); Assert.True(latch.IsSet); CloseChannel(cc); CloseChannel(sc); sc.CloseCompletion.Wait(); Assert.Null(LocalChannelRegistry.Get(TEST_ADDRESS)); } finally { CloseChannel(cc); CloseChannel(sc); } } }
public void LocalChannel_write_when_WritePromiseComplete_should_still_preserve_order() { var cb = new ClientBootstrap(); var sb = new ServerBootstrap(); var messageLatch = new CountdownEvent(2); var data1 = Unpooled.WrappedBuffer(new byte[1024]); var data2 = Unpooled.WrappedBuffer(new byte[512]); try { cb.Group(_group1) .Channel<LocalChannel>() .Handler(new TestHandler()); sb.Group(_group2) .Channel<LocalServerChannel>() .ChildHandler(new ReadCountdown2(messageLatch, data1, data2)); IChannel sc = null; IChannel cc = null; try { // Start server sc = sb.BindAsync(TEST_ADDRESS).Result; // Connect to server cc = cb.ConnectAsync(sc.LocalAddress).Result; var ccCpy = cc; // Make sure a write operation is executed in the eventloop cc.Pipeline.LastContext().Executor.Execute(() => { Logger.Info("Writing message 1"); ccCpy.WriteAndFlushAsync(data1.Duplicate().Retain()).ContinueWith(tr => { Logger.Info("Writing message 2"); ccCpy.WriteAndFlushAsync(data2.Duplicate().Retain()); }); }); Assert.True(messageLatch.Wait(TimeSpan.FromSeconds(5))); } finally { CloseChannel(sc); CloseChannel(cc); } } finally { data1.Release(); data2.Release(); } }
public void LocalServerChannel_should_be_able_to_close_channel_on_same_EventLoop() { var latch = new CountdownEvent(1); var sb = new ServerBootstrap(); sb.Group(_group2).Channel<LocalServerChannel>().ChildHandler(new ReadHandler1(latch)); IChannel sc = null; IChannel cc = null; try { sc = sb.BindAsync(TEST_ADDRESS).Result; var b = new ClientBootstrap() .Group(_group2) .Channel<LocalChannel>().Handler(new ReadHandler2()); cc = b.ConnectAsync(sc.LocalAddress).Result; cc.WriteAndFlushAsync(new object()); Assert.True(latch.Wait(TimeSpan.FromSeconds(5))); } finally { CloseChannel(cc); CloseChannel(sc); } }