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);
}
}
