public void BindAsync() { var bootstrap = new ServerBootstrap(); bootstrap.Group(this.BossGroup, this.WorkerGroup) .Channel <TcpServerSocketChannel>() .Handler(new LoggingHandler(LogLevel.INFO)); if (Config.Type == LazynetSocketType.TcpSocket) { bootstrap.ChildHandler(new LazynetTSChannelInitializer(this)); } else if (Config.Type == LazynetSocketType.Websocket) { if (string.IsNullOrEmpty(this.Config.WSPath)) { throw new Exception("使用websocket时[path]参数必填"); } bootstrap.ChildHandler(new LazynetWSChannelInitializer(this)); } else { throw new Exception("没有其它类型的socket"); } this.BindResult = bootstrap.BindAsync(this.Config.Port); }
void SimpleEcho0(ServerBootstrap sb, Bootstrap cb, bool additionalExecutor, bool autoRead) { var sh = new EchoHandler(autoRead, this.data, this.output); var ch = new EchoHandler(autoRead, this.data, this.output); if (additionalExecutor) { sb.ChildHandler(new ActionChannelInitializer <TcpChannel>(channel => { channel.Pipeline.AddLast(this.group, sh); })); cb.Handler(new ActionChannelInitializer <TcpChannel>(channel => { channel.Pipeline.AddLast(this.group, ch); })); } else { sb.ChildHandler(sh); sb.Handler(new ErrorOutputHandler(this.output)); cb.Handler(ch); } sb.ChildOption(ChannelOption.AutoRead, autoRead); cb.Option(ChannelOption.AutoRead, autoRead); // start server Task <IChannel> task = sb.BindAsync(LoopbackAnyPort); Assert.True(task.Wait(DefaultTimeout), "Server bind timed out"); this.serverChannel = task.Result; Assert.NotNull(this.serverChannel.LocalAddress); var endPoint = (IPEndPoint)this.serverChannel.LocalAddress; // connect to server task = cb.ConnectAsync(endPoint); Assert.True(task.Wait(DefaultTimeout), "Connect to server timed out"); this.clientChannel = task.Result; Assert.NotNull(this.clientChannel.LocalAddress); for (int i = 0; i < this.data.Length;) { int length = Math.Min(this.random.Next(1024 * 64), this.data.Length - i); IByteBuffer buf = Unpooled.WrappedBuffer(this.data, i, length); this.clientChannel.WriteAndFlushAsync(buf); i += length; } Assert.True(Task.WhenAll(ch.Completion, sh.Completion).Wait(DefaultTimeout), "Echo read/write timed out"); }
static async Task RunServerAsync() { IEventLoopGroup eventLoop = new MultithreadEventLoopGroup(); try { ServerBootstrap bootstrap = new ServerBootstrap(); bootstrap.Group(eventLoop); bootstrap.Channel <TcpServerSocketChannel>(); bootstrap.ChildHandler(new ActionChannelInitializer <IChannel>(chl => { chl.Pipeline.AddLast(new ServerTestHandler()); })); IChannel channel = await bootstrap.BindAsync(3000); Console.WriteLine("服务器已启动........."); Console.ReadLine();//阻塞线程 await channel.CloseAsync(); } catch (Exception ex) { } finally { await eventLoop.ShutdownGracefullyAsync(); } }
private void Initialize() { if (Initializer == null) { Out.QuickLog("Abstract server failed to start on Port " + Port + " due to the server's initializer being NULL"); return; } _bootstrap.Group(_bossEventLoopGroup, _workerEventLoopGroup); // Set Channel Type to Tcp. _bootstrap.Channel <TcpServerSocketChannel>(); // Set Server Options _bootstrap.Option(ChannelOption.SoLinger, 0); _bootstrap.Option(ChannelOption.SoBacklog, Backlog); _bootstrap.ChildHandler(Initializer); _bootstrap.ChildOption(ChannelOption.SoLinger, 0); _bootstrap.ChildOption(ChannelOption.SoKeepalive, true); _bootstrap.ChildOption(ChannelOption.TcpNodelay, true); _bootstrap.ChildOption(ChannelOption.SoReuseaddr, true); }
protected override Task StartAsync(CancellationToken cancellationToken) { try { var dispatcher = new DispatcherEventLoopGroup(); bossGroup = dispatcher; workerGroup = new WorkerEventLoopGroup(dispatcher); var bootstrap = new ServerBootstrap(); bootstrap.Group(bossGroup, workerGroup); bootstrap.Channel <TcpServerChannel>(); bootstrap //.Handler(new LoggingHandler("SRV-LSTN")) .ChildHandler(new ActionChannelInitializer <IChannel>(channel => { InitChannel(channel); })) .Option(ChannelOption.SoBacklog, 1048576); if (nettyOptions.Host == "") { boundChannel = bootstrap.BindAsync(nettyOptions.Port).Result; } else { boundChannel = bootstrap.BindAsync(nettyOptions.Host, nettyOptions.Port).Result; } } catch (Exception ex) { } return(Task.CompletedTask); }
void ReadPendingIsResetAfterEachRead0(ServerBootstrap sb, Bootstrap cb) { var serverInitializer = new MyInitializer(); sb.Option(ChannelOption.SoBacklog, 1024); sb.ChildHandler(serverInitializer); // start server Task <IChannel> task = sb.BindAsync(LoopbackAnyPort); Assert.True(task.Wait(DefaultTimeout), "Server bind timed out"); this.serverChannel = task.Result; Assert.NotNull(this.serverChannel.LocalAddress); var endPoint = (IPEndPoint)this.serverChannel.LocalAddress; cb.Handler(new MyInitializer()); // connect to server task = cb.ConnectAsync(endPoint); Assert.True(task.Wait(DefaultTimeout), "Connect to server timed out"); this.clientChannel = task.Result; Assert.NotNull(this.clientChannel.LocalAddress); Task writeTask = this.clientChannel.WriteAndFlushAsync(Unpooled.WrappedBuffer(new byte[1024])); Assert.True(writeTask.Wait(DefaultTimeout), "Write task timed out"); ExceptionHandler exceptionHandler = serverInitializer.ErrorHandler; Assert.True(exceptionHandler.Inactive.Wait(DefaultTimeout), "Handler inactive timed out"); Assert.Equal(1, exceptionHandler.Count); }
public void TestAsyncResolutionFailure() { Bootstrap bootstrapA = new Bootstrap(); bootstrapA.Group(_groupA); bootstrapA.Channel <LocalChannel>(); bootstrapA.Resolver(new TestAddressResolverGroup(false)); bootstrapA.Handler(_dummyHandler); ServerBootstrap bootstrapB = new ServerBootstrap(); bootstrapB.Group(_groupB); bootstrapB.Channel <LocalServerChannel>(); bootstrapB.ChildHandler(_dummyHandler); var localAddress = bootstrapB.BindAsync(LocalAddress.Any).GetAwaiter().GetResult().LocalAddress; // Connect to the server using the asynchronous resolver. var connectFuture = bootstrapA.ConnectAsync(localAddress); // Should fail with the UnknownHostException. Assert.True(TaskUtil.WaitAsync(connectFuture, TimeSpan.FromSeconds(10)).GetAwaiter().GetResult()); Assert.False(connectFuture.IsSuccess()); Assert.IsType <System.Net.Sockets.SocketException>(connectFuture.Exception.InnerException); //Assert.False(connectFuture.Channel().isOpen()); }
private async Task TestNoRstIfSoLingerOnClose0(ServerBootstrap sb, Bootstrap cb) { AtomicReference <IChannel> serverChannelRef = new AtomicReference <IChannel>(); AtomicReference <Exception> throwableRef = new AtomicReference <Exception>(); CountdownEvent latch = new CountdownEvent(1); CountdownEvent latch2 = new CountdownEvent(1); sb.ChildHandler(new ActionChannelInitializer <IChannel>(ch => { serverChannelRef.CompareAndSet(null, ch); latch.SafeSignal(); })); cb.Handler(new ActionChannelInitializer <IChannel>(ch => { ch.Pipeline.AddLast(new ChannelInboundHandlerAdapter0(throwableRef, latch2)); })); IChannel sc = await sb.BindAsync(); await cb.ConnectAsync(sc.LocalAddress); // Wait for the server to get setup. latch.Wait(); // The server has SO_LINGER=0 and so it must send a RST when close is called. serverChannelRef.Value.CloseAsync().Ignore(); // Wait for the client to get channelInactive. latch2.Wait(); // Verify the client did not received a RST. Assert.Null(throwableRef.Value); }
public void Start() { try { _bootstrap.Group(_bossGroup, _workerGroup); _bootstrap.Channel <TcpServerSocketChannel>(); _bootstrap.Option(ChannelOption.SoBacklog, 100); _bootstrap.ChildOption(ChannelOption.SoKeepalive, true); _bootstrap.Option(ChannelOption.TcpNodelay, true); _bootstrap.Option(ChannelOption.SoReuseport, true); _bootstrap.ChildOption(ChannelOption.SoReuseport, true); _bootstrap.Option(ChannelOption.Allocator, UnpooledByteBufferAllocator.Default); _bootstrap.ChildOption(ChannelOption.Allocator, UnpooledByteBufferAllocator.Default); _bootstrap.ChildHandler(new ActionChannelInitializer <ISocketChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; pipeline.AddLast("DotNetty-enc", new LengthFieldPrepender(4)); pipeline.AddLast("DotNetty-dec", new LengthFieldBasedFrameDecoder(GlobalConfig.Config.MaxFrameLength, 0, 4, 0, 4)); pipeline.AddLast(new MasterMessageHandler((IChannelMessageHandler)this)); })); _bootstrapChannel = _bootstrap.BindAsync(_localPort).Result; Logger.Log.Info(false, "主节点侦听端口:" + GlobalConfig.Config.MasterListenPort); } catch (Exception ex) { Logger.Log.Error(true, "", ex); } }
public void RunServerAsync() { IEventLoopGroup eventLoop; eventLoop = new MultithreadEventLoopGroup(); try { // 服务器引导程序 var bootstrap = new ServerBootstrap(); bootstrap.Group(eventLoop); bootstrap.Channel <TcpServerSocketChannel>(); bootstrap.ChildHandler(new ActionChannelInitializer <IChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; //解码 pipeline.AddLast(new ServerDecoder()); //服务端为读IDLE pipeline.AddLast(new IdleStateHandler(60 * 5, 60 * 5, 60 * 5));//第一个参数为读,第二个为写,第三个为读写全部 //解码 pipeline.AddLast(new ServerEncoder()); //添加handler pipeline.AddLast(new NettyServer()); })); foreach (var server in _app.Value.Servers) { bootstrap.BindAsync(server.Port); LogHelper.Info("服务器启动:" + server.Name + "端口" + server.Port); } } catch (Exception ex) { Console.WriteLine(ex); } }
/// <summary> /// 开启、关闭DotNetty服务 /// </summary> private async void RaiseStartServerHandler() { StartServerButtonEnabled = false; IEventLoopGroup bossGroup = new MultithreadEventLoopGroup(1); IEventLoopGroup workerGroup = new MultithreadEventLoopGroup(); try { var bootstrap = new ServerBootstrap(); bootstrap.Group(bossGroup, workerGroup); bootstrap.Channel <TcpServerSocketChannel>(); bootstrap.ChildHandler(new ActionChannelInitializer <IChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; pipeline.AddLast(new LengthFieldBasedFrameDecoder(ushort.MaxValue, 0, 4, 0, 4)); pipeline.AddLast(new MessagePackDecoder()); pipeline.AddLast(new LengthFieldPrepender(4)); pipeline.AddLast(new MessagePackEncoder()); pipeline.AddLast(DotNettyServerHandler); })); await bootstrap.BindAsync(ServerPort); } catch (Exception ex) { Console.WriteLine($"连接服务异常:{ex.Message}"); } }
void SingleCompositeBufferWrite0(ServerBootstrap sb, Bootstrap cb) { sb.ChildHandler(new ActionChannelInitializer <TcpChannel>(channel => { channel.Pipeline.AddLast(new ServerHandler()); })); var clientHandler = new ClientHandler(); cb.Handler(new ActionChannelInitializer <TcpChannel>(channel => { channel.Pipeline.AddLast(clientHandler); })); // start server Task <IChannel> task = sb.BindAsync(LoopbackAnyPort); Assert.True(task.Wait(DefaultTimeout), "Server bind timed out"); this.serverChannel = task.Result; Assert.NotNull(this.serverChannel.LocalAddress); var endPoint = (IPEndPoint)this.serverChannel.LocalAddress; // connect to server task = cb.ConnectAsync(endPoint); Assert.True(task.Wait(DefaultTimeout), "Connect to server timed out"); this.clientChannel = task.Result; Assert.NotNull(this.clientChannel.LocalAddress); IByteBuffer expected = NewCompositeBuffer(this.clientChannel.Allocator); clientHandler.AssertReceived(expected); }
static async Task RunHttpServerAsync(int port) { if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { GCSettings.LatencyMode = GCLatencyMode.SustainedLowLatency; } bossGroup = new MultithreadEventLoopGroup(1); workerGroup = new MultithreadEventLoopGroup(); try { var bootstrap = new ServerBootstrap(); bootstrap.Group(bossGroup, workerGroup); bootstrap.Channel <TcpServerSocketChannel>(); bootstrap.Option(ChannelOption.SoBacklog, 8192); bootstrap.ChildHandler(new ActionChannelInitializer <DotNetty.Transport.Channels.IChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; pipeline.AddLast(new HttpServerCodec()); pipeline.AddLast(new HttpObjectAggregator(65536 * 5)); pipeline.AddLast(new HttpDecoder()); })); bootstrapChannel = await bootstrap.BindAsync(port); LOGGER.Info("start http server success. listener port:[{}]", port); } catch (Exception e) { throw new Exception("start http server ERROR! \n" + e.ToString()); } }
public async Task TestNotThrowBlockingOperationException() { IEventLoopGroup bossGroup = new MultithreadEventLoopGroup(1); IEventLoopGroup workerGroup = new MultithreadEventLoopGroup(1); IChannelGroup allChannels = new DefaultChannelGroup(); ServerBootstrap b = new ServerBootstrap(); b.Group(bossGroup, workerGroup); b.ChildHandler(new ChannelInboundHandlerAdapter0(allChannels)); b.Channel <TcpServerSocketChannel>(); var ch = await b.BindAsync(0); allChannels.Add(ch); await allChannels.CloseAsync(); await Task.WhenAll( bossGroup.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(5)), workerGroup.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(5)) ); await bossGroup.TerminationCompletion; await workerGroup.TerminationCompletion; }
public async void Start(int port) { IEventLoopGroup boss_group = new MultithreadEventLoopGroup(1); IEventLoopGroup worker_group = new MultithreadEventLoopGroup(Args.Instance.Node.TcpNettyWorkThreadNum); try { ServerBootstrap bootstrap = new ServerBootstrap(); bootstrap.Group(boss_group, worker_group); bootstrap.Channel <TcpServerSocketChannel>(); bootstrap.Option(ChannelOption.SoKeepalive, true); bootstrap.Option(ChannelOption.MessageSizeEstimator, DefaultMessageSizeEstimator.Default); bootstrap.Option(ChannelOption.ConnectTimeout, TimeSpan.FromSeconds(Args.Instance.Node.ConnectionTimeout)); bootstrap.Handler(new LoggingHandler()); bootstrap.ChildHandler(new NettyChannelInitializer("", false)); Logger.Info("Tcp listener started, bind port : " + port); this.channel = await bootstrap.BindAsync(port); } catch (System.Exception e) { Logger.Error(e.Message, e); } finally { } }
void Run(ServerBootstrap sb, Bootstrap cb) { var serverInitializer = new ServerInitializer(); sb.ChildHandler(serverInitializer); var clientInitializer = new ClientInitializer(); cb.Handler(clientInitializer); // start server Task <IChannel> task = sb.BindAsync(LoopbackAnyPort); Assert.True(task.Wait(DefaultTimeout), "Server bind timed out"); this.serverChannel = task.Result; Assert.NotNull(this.serverChannel.LocalAddress); var endPoint = (IPEndPoint)this.serverChannel.LocalAddress; // connect to server task = cb.ConnectAsync(endPoint); Assert.True(task.Wait(DefaultTimeout), "Connect to server timed out"); this.clientChannel = task.Result; Assert.NotNull(this.clientChannel.LocalAddress); Assert.True(serverInitializer.Initialized.Wait(DefaultTimeout), "Channel initialize timed out"); Assert.True(serverInitializer.Close()); // Server connection closed will cause the client // to receive EOF and the channel should go inactive Assert.True(clientInitializer.Inactive.Wait(DefaultTimeout), "TcpChannel should fire Inactive if the server connection is closed."); Assert.Null(clientInitializer.ErrorCaught); }
public void Test1() { // 作为源包转发服务端 DispatcherEventLoopGroup bossGroup = new DispatcherEventLoopGroup(); WorkerEventLoopGroup workerGroup = new WorkerEventLoopGroup(bossGroup, 1); 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 .ChildHandler(new ActionChannelInitializer <IChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; channel.Pipeline.AddLast("jt808Buffer", new DelimiterBasedFrameDecoder(int.MaxValue, Unpooled.CopiedBuffer(new byte[] { JT808.Protocol.JT808Package.BeginFlag }), Unpooled.CopiedBuffer(new byte[] { JT808.Protocol.JT808Package.EndFlag }))); channel.Pipeline.AddLast("jt808Decode", new JT808ClientDecoder()); })); bootstrap.BindAsync(6655); //作为设备上传 byte[] bytes = "7E 02 00 00 26 12 34 56 78 90 12 00 7D 02 00 00 00 01 00 00 00 02 00 BA 7F 0E 07 E4 F1 1C 00 28 00 3C 00 00 18 10 15 10 10 10 01 04 00 00 00 64 02 02 00 7D 01 13 7E".ToHexBytes(); SimpleTcpClient.WriteAsync(bytes); Thread.Sleep(10000); SimpleTcpClient.Down(); }
/// <summary> /// 开启、关闭DotNetty服务 /// </summary> private async void RaiseStartServerHandler() { StartServerButtonEnabled = false; IEventLoopGroup bossGroup = new MultithreadEventLoopGroup(1); IEventLoopGroup workerGroup = new MultithreadEventLoopGroup(); try { var bootstrap = new ServerBootstrap(); bootstrap.Group(bossGroup, workerGroup); bootstrap.Channel <TcpServerSocketChannel>(); bootstrap.ChildHandler(new ActionChannelInitializer <IChannel>(channel => { channel.Pipeline.AddLast(new ProtobufVarint32FrameDecoder()) .AddLast(new ProtobufDecoder(ChatInfo.Parser)) .AddLast(new ProtobufVarint32LengthFieldPrepender()) .AddLast(new ProtobufEncoder()) .AddLast(DotNettyServerHandler); })); await bootstrap.BindAsync(ServerPort); } catch (Exception ex) { Console.WriteLine($"连接服务异常:{ex.Message}"); } }
void BufRelease0(ServerBootstrap sb, Bootstrap cb) { var serverHandler = new BufWriterHandler(); var clientHandler = new BufWriterHandler(); sb.ChildHandler(serverHandler); cb.Handler(clientHandler); // start server Task <IChannel> task = sb.BindAsync(LoopbackAnyPort); Assert.True(task.Wait(DefaultTimeout), "Server bind timed out"); this.serverChannel = task.Result; Assert.NotNull(this.serverChannel.LocalAddress); var endPoint = (IPEndPoint)this.serverChannel.LocalAddress; // connect to server task = cb.ConnectAsync(endPoint); Assert.True(task.Wait(DefaultTimeout), "Connect to server timed out"); this.clientChannel = task.Result; Assert.NotNull(this.clientChannel.LocalAddress); // Ensure the server socket accepted the client connection *and* initialized pipeline successfully. Assert.True(serverHandler.Added.Wait(DefaultTimeout), "Channel HandlerAdded timed out"); // and then close all sockets. this.serverChannel.CloseAsync().Wait(DefaultTimeout); this.clientChannel.CloseAsync().Wait(DefaultTimeout); serverHandler.Check(); clientHandler.Check(); serverHandler.Release(); clientHandler.Release(); }
private void AsyncSettingsAck0(Http2FrameCodec codec, IChannelHandler multiplexer) { // The client expects 2 settings frames. One from the connection setup and one from this test. CountdownEvent serverAckOneLatch = new CountdownEvent(1); CountdownEvent serverAckAllLatch = new CountdownEvent(2); CountdownEvent clientSettingsLatch = new CountdownEvent(2); CountdownEvent serverConnectedChannelLatch = new CountdownEvent(1); AtomicReference <IChannel> serverConnectedChannelRef = new AtomicReference <IChannel>(); _sb = new ServerBootstrap(); _sb.Group(new MultithreadEventLoopGroup(1), new MultithreadEventLoopGroup()); _sb.Channel <TcpServerSocketChannel>(); _sb.ChildHandler(new ActionChannelInitializer <IChannel>(ch => { ch.Pipeline.AddLast(codec); if (multiplexer != null) { ch.Pipeline.AddLast(multiplexer); } ch.Pipeline.AddLast(new TestServerInboundHandler(serverAckOneLatch, serverAckAllLatch, serverConnectedChannelLatch, serverConnectedChannelRef)); })); var loopback = IPAddress.IPv6Loopback; _serverChannel = _sb.BindAsync(loopback, 0).GetAwaiter().GetResult(); _bs = new Bootstrap(); _bs.Group(new MultithreadEventLoopGroup()); _bs.Channel <TcpSocketChannel>(); _bs.Handler(new ActionChannelInitializer <IChannel>(ch => { var builder = Http2MultiplexCodecBuilder.ForClient(DISCARD_HANDLER.Instance); builder.AutoAckSettingsFrame = false; ch.Pipeline.AddLast(builder.Build()); ch.Pipeline.AddLast(new TestClientInboundHandler(clientSettingsLatch)); })); var port = ((IPEndPoint)_serverChannel.LocalAddress).Port; var ccf = _bs.ConnectAsync(loopback, port); _clientChannel = ccf.GetAwaiter().GetResult(); serverConnectedChannelLatch.Wait(); _serverConnectedChannel = serverConnectedChannelRef.Value; _serverConnectedChannel.WriteAndFlushAsync(new DefaultHttp2SettingsFrame(new Http2Settings() .MaxConcurrentStreams(10))).GetAwaiter().GetResult(); clientSettingsLatch.Wait(); // We expect a timeout here because we want to asynchronously generate the SETTINGS ACK below. Assert.False(serverAckOneLatch.Wait(TimeSpan.FromMilliseconds(300))); // We expect 2 settings frames, the initial settings frame during connection establishment and the setting frame // written in this test. We should ack both of these settings frames. _clientChannel.WriteAndFlushAsync(DefaultHttp2SettingsAckFrame.Instance).GetAwaiter().GetResult(); _clientChannel.WriteAndFlushAsync(DefaultHttp2SettingsAckFrame.Instance).GetAwaiter().GetResult(); serverAckAllLatch.Wait(); }
public void TestReuseFd(ServerBootstrap sb, Bootstrap cb) { sb.ChildOption(ChannelOption.AutoRead, true); cb.Option(ChannelOption.AutoRead, true); // Use a number which will typically not exceed /proc/sys/net/core/somaxconn (which is 128 on linux by default // often). int numChannels = 100; AtomicReference <Exception> globalException = new AtomicReference <Exception>(); AtomicInteger serverRemaining = new AtomicInteger(numChannels); AtomicInteger clientRemaining = new AtomicInteger(numChannels); IPromise serverDonePromise = new DefaultPromise(); IPromise clientDonePromise = new DefaultPromise(); sb.ChildHandler(new ActionChannelInitializer <IChannel>(sch => { ReuseFdHandler sh = new ReuseFdHandler( false, globalException, serverRemaining, serverDonePromise); sch.Pipeline.AddLast("handler", sh); })); cb.Handler(new ActionChannelInitializer <IChannel>(sch => { ReuseFdHandler ch = new ReuseFdHandler( true, globalException, clientRemaining, clientDonePromise); sch.Pipeline.AddLast("handler", ch); })); IChannel sc = sb.BindAsync().GetAwaiter().GetResult(); for (int i = 0; i < numChannels; i++) { cb.ConnectAsync(sc.LocalAddress).ContinueWith(t => { if (!t.IsSuccess()) { clientDonePromise.TrySetException(t.Exception); } }); } clientDonePromise.Task.GetAwaiter().GetResult(); serverDonePromise.Task.GetAwaiter().GetResult(); sc.CloseAsync().GetAwaiter().GetResult(); if (globalException.Value is object) { throw globalException.Value; } }
public virtual void InitServer(string fsimage) { FSImageLoader loader = FSImageLoader.Load(fsimage); bootstrap.ChildHandler(new _ChannelInitializer_92(this, loader)); channel = bootstrap.Bind(address).Sync().Channel(); allChannels.AddItem(channel); address = (IPEndPoint)channel.LocalAddress(); Log.Info("WebImageViewer started. Listening on " + address.ToString() + ". Press Ctrl+C to stop the viewer." ); }
private static void TestAutoCloseFalseDoesShutdownOutput0(bool allowHalfClosed, bool clientIsLeader, ServerBootstrap sb, Bootstrap cb) { const int expectedBytes = 100; CountdownEvent serverReadExpectedLatch = new CountdownEvent(1); CountdownEvent doneLatch = new CountdownEvent(1); AtomicReference <Exception> causeRef = new AtomicReference <Exception>(); IChannel serverChannel = null; IChannel clientChannel = null; try { cb.Option(ChannelOption.AllowHalfClosure, allowHalfClosed) .Option(ChannelOption.AutoClose, false) .Option(ChannelOption.SoLinger, 0); sb.ChildOption(ChannelOption.AllowHalfClosure, allowHalfClosed) .ChildOption(ChannelOption.AutoClose, false) .ChildOption(ChannelOption.SoLinger, 0); SimpleChannelInboundHandler <IByteBuffer> leaderHandler = new AutoCloseFalseLeader(expectedBytes, serverReadExpectedLatch, doneLatch, causeRef); SimpleChannelInboundHandler <IByteBuffer> followerHandler = new AutoCloseFalseFollower(expectedBytes, serverReadExpectedLatch, doneLatch, causeRef); sb.ChildHandler(new ActionChannelInitializer <IChannel>(ch => { ch.Pipeline.AddLast(clientIsLeader ? followerHandler : leaderHandler); })); cb.Handler(new ActionChannelInitializer <IChannel>(ch => { ch.Pipeline.AddLast(clientIsLeader ? leaderHandler : followerHandler); })); serverChannel = sb.BindAsync().GetAwaiter().GetResult(); clientChannel = cb.ConnectAsync(serverChannel.LocalAddress).GetAwaiter().GetResult(); doneLatch.Wait(); Assert.Null(causeRef.Value); } finally { if (clientChannel != null) { clientChannel.CloseAsync().GetAwaiter().GetResult(); } if (serverChannel != null) { serverChannel.CloseAsync().GetAwaiter().GetResult(); } } }
private async Task TestSingleCompositeBufferWrite0(ServerBootstrap sb, Bootstrap cb) { IChannel serverChannel = null; IChannel clientChannel = null; try { CountdownEvent latch = new CountdownEvent(1); AtomicReference <object> clientReceived = new AtomicReference <object>(); sb.ChildHandler(new ActionChannelInitializer <IChannel>(ch => { ch.Pipeline.AddLast(new ChannelInboundHandlerAdapter2()); })); cb.Handler(new ActionChannelInitializer <IChannel>(ch => { ch.Pipeline.AddLast(new ChannelInboundHandlerAdapter3(latch, clientReceived)); })); serverChannel = await sb.BindAsync(); clientChannel = await cb.ConnectAsync(serverChannel.LocalAddress); IByteBuffer expected = NewCompositeBuffer(clientChannel.Allocator); latch.Wait(); object received = clientReceived.Value; if (received is IByteBuffer actual) { Assert.Equal(expected, actual); expected.Release(); actual.Release(); } else { expected.Release(); throw (Exception)received; } } finally { if (clientChannel != null) { await clientChannel.CloseAsync(); } if (serverChannel != null) { await serverChannel.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))); } }
internal virtual ServerBootstrap GetLocalServerBootstrap() { IEventLoopGroup serverGroup = new DefaultEventLoopGroup(); ServerBootstrap sb = new ServerBootstrap(); sb.Group(serverGroup); sb.Channel <LocalServerChannel>(); sb.ChildHandler(new ActionChannelInitializer <LocalChannel>(ch => { })); return(sb); }
protected void Init() { _bootstrap.Group(_bossEventLoopGroup, _workerEventLoopGroup); _bootstrap.Channel <TcpServerSocketChannel>(); _bootstrap.Option(ChannelOption.SoLinger, 0); _bootstrap.Option(ChannelOption.SoBacklog, Backlog); _bootstrap.Handler(new LoggingHandler(LogLevel.INFO)); _bootstrap.ChildHandler(new InboundSessionInitializer(inboundSession)); _bootstrap.ChildOption(ChannelOption.SoLinger, 0); _bootstrap.ChildOption(ChannelOption.SoKeepalive, true); _bootstrap.ChildOption(ChannelOption.TcpNodelay, true); _bootstrap.ChildOption(ChannelOption.SoReuseaddr, true); }
private static void TestAllDataReadAfterHalfClosure0(bool autoRead, ServerBootstrap sb, Bootstrap cb) { const int totalServerBytesWritten = 1024 * 16; const int numReadsPerReadLoop = 2; CountdownEvent serverInitializedLatch = new CountdownEvent(1); CountdownEvent clientReadAllDataLatch = new CountdownEvent(1); CountdownEvent clientHalfClosedLatch = new CountdownEvent(1); AtomicInteger clientReadCompletes = new AtomicInteger(); IChannel serverChannel = null; IChannel clientChannel = null; try { cb.Option(ChannelOption.AllowHalfClosure, true) .Option(ChannelOption.AutoRead, autoRead) .Option(ChannelOption.RcvbufAllocator, new TestNumReadsRecvByteBufAllocator(numReadsPerReadLoop)); sb.ChildHandler(new ActionChannelInitializer <IChannel>(ch => { ch.Pipeline.AddLast(new ChannelInboundHandlerAdapter2(totalServerBytesWritten, serverInitializedLatch)); })); cb.Handler(new ActionChannelInitializer <IChannel>(ch => { ch.Pipeline.AddLast(new ChannelInboundHandlerAdapter3(autoRead, totalServerBytesWritten, clientHalfClosedLatch, clientReadAllDataLatch, clientReadCompletes)); })); serverChannel = sb.BindAsync().GetAwaiter().GetResult(); clientChannel = cb.ConnectAsync(serverChannel.LocalAddress).GetAwaiter().GetResult(); clientChannel.Read(); serverInitializedLatch.Wait(); clientReadAllDataLatch.Wait(); clientHalfClosedLatch.Wait(); Assert.True(totalServerBytesWritten / numReadsPerReadLoop + 10 > clientReadCompletes.Value, "too many read complete events: " + clientReadCompletes.Value); } finally { if (clientChannel != null) { clientChannel.CloseAsync().GetAwaiter().GetResult(); } if (serverChannel != null) { serverChannel.CloseAsync().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)); pipeline.AddLast(new TcpServerHandler()); })); //第五步:配置主机和端口号 string hostName = Dns.GetHostName(); IPAddress[] ipAddresses = Dns.GetHostAddresses(hostName); ipAddresses = ipAddresses.Where(m => m.ToString().IsIPv4()).ToArray(); var host = ConfigHelper.Configuration["ServerConfig:Host"]; bool trueAddress = ipAddresses.Any(m => host.Equals(m.ToString())); IPAddress iPAddress = trueAddress ? IPAddress.Parse(host) : ipAddresses[0]; var port = ConfigHelper.Configuration["ServerConfig:Port"]; IChannel bootstrapChannel = await bootstrap.BindAsync(iPAddress, int.Parse(port)); OnSubMessage?.Invoke("服务启动成功", "重要"); OnMessage?.Invoke($"已监听http://{iPAddress}:{int.Parse(port)}"); //第六步:停止服务 OnMessage?.Invoke("输入Stop停止服务"); string inputKey = string.Empty; while (!string.Equals(inputKey, "Stop", StringComparison.Ordinal)) { inputKey = OnGetCommand?.Invoke(); if (!string.Equals(inputKey, "Stop", StringComparison.Ordinal)) { OnException?.Invoke(new Exception("未识别命令请重新输入")); } } OnSubMessage?.Invoke("正在停止服务......", "重要"); await bootstrapChannel.CloseAsync(); OnSubMessage?.Invoke("服务已停止", "重要"); }
/// <summary> /// 开启、关闭DotNetty服务 /// </summary> private async void RaiseStartServerHandler() { IsStartServer = !IsStartServer; StartServerButtonContent = (IsStartServer ? "关闭服务" : "开启服务"); if (!IsStartServer) { StopServer(); return; } // 主工作线程组,设置为1个线程 IEventLoopGroup bossGroup = new MultithreadEventLoopGroup(1); // 工作线程组,默认为内核数*2的线程数 IEventLoopGroup workerGroup = new MultithreadEventLoopGroup(); try { //声明一个服务端Bootstrap,每个Netty服务端程序,都由ServerBootstrap控制, //通过链式的方式组装需要的参数 var bootstrap = new ServerBootstrap(); bootstrap.Group(bossGroup, workerGroup); // 设置主和工作线程组 bootstrap.Channel <TcpServerSocketChannel>(); // 设置通道模式为TcpSocket bootstrap.ChildHandler(new ActionChannelInitializer <IChannel>(channel => { //工作线程连接器 是设置了一个管道,服务端主线程所有接收到的信息都会通过这个管道一层层往下传输 //同时所有出栈的消息 也要这个管道的所有处理器进行一步步处理 IChannelPipeline pipeline = channel.Pipeline; //配置编码解码器 pipeline.AddLast("frameDecoder", new LengthFieldBasedFrameDecoder(ushort.MaxValue, 0, 4, 0, 4)); pipeline.AddLast("msgPackDecoder", new MessagePackDecoder()); pipeline.AddLast("frameEncoder", new LengthFieldPrepender(4)); pipeline.AddLast("msgPackEncoder", new MessagePackEncoder()); // IdleStateHandler 心跳 //服务端为读IDLE pipeline.AddLast(new IdleStateHandler(150, 0, 0)); //第一个参数为读,第二个为写,第三个为读写全部 //业务handler ,这里是实际处理业务的Handler pipeline.AddLast("handler", DotNettyServerHandler); })); // bootstrap绑定到指定端口的行为 就是服务端启动服务,同样的Serverbootstrap可以bind到多个端口 serverChannel = await bootstrap.BindAsync(ServerPort); } catch (Exception ex) { Console.WriteLine(ex); } }
void Bootstrap() { bootstrap.Group(parentEventLoopGroup, eventLoopGroup); bootstrap.Option(ChannelOption.SoBacklog, ListenBacklogSize); bootstrap.ChildOption(ChannelOption.Allocator, PooledByteBufferAllocator.Default); bootstrap.Channel <TcpServerSocketChannel>(); bootstrap.Option(ChannelOption.ConnectTimeout, DefaultConnectionIdleTimeout); bootstrap.ChildHandler(new ActionChannelInitializer <ISocketChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; pipeline.AddLast(new LengthFieldBasedFrameDecoder(ByteOrder.BigEndian, 4096, 1, 4, -5, 0, true)); pipeline.AddLast(new BmpDecoder(), new BmpMessageHandler()); })); }