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 void ServerBootrap_must_support_BindAsync_on_DnsEndpoints_for_SocketChannels()
{
var sb = new ServerBootstrap()
.Channel<TcpServerSocketChannel>()
.ChildHandler(new ActionChannelInitializer<TcpSocketChannel>(channel => { }))
.Group(_serverGroup);
var c = sb.BindAsync(new DnsEndPoint("localhost", 0)).Result;
}
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 async Task TcpSocketChannel_should_not_throw_on_shutdown()
{
AtomicReference<Exception> clientError = new AtomicReference<Exception>(null);
AtomicReference<Exception> serverError = new AtomicReference<Exception>(null);
IChannel s = null;
IChannel c = null;
try
{
var sb = new ServerBootstrap()
.Channel<TcpServerSocketChannel>()
.ChildHandler(
new ActionChannelInitializer<TcpSocketChannel>(
channel => { channel.Pipeline.AddLast(new FailAssertionHandler(serverError)); }))
.Group(_serverGroup);
s = sb.BindAsync(new IPEndPoint(IPAddress.IPv6Loopback, 0)).Result;
var cb = new ClientBootstrap()
.Channel<TcpSocketChannel>()
.Option(ChannelOption.TcpNodelay, true)
.Option(ChannelOption.ConnectTimeout, TimeSpan.FromMilliseconds(100))
.Handler(
new ActionChannelInitializer<TcpSocketChannel>(
channel => { channel.Pipeline.AddLast(new FailAssertionHandler(clientError)); }))
.Group(_clientGroup);
var clientEp = s.LocalAddress;
c = cb.ConnectAsync(clientEp).Result;
c.WriteAndFlushAsync(Unpooled.Buffer(4).WriteInt(2)).Wait(20);
Assert.True(c.IsOpen);
await c.CloseAsync();
// assert that the counters were never decremented
Assert.True(clientError.Value == null,
$"Expected null but error on client was {clientError.Value?.Message} {clientError.Value?.StackTrace}");
Assert.True(serverError.Value == null,
$"Expected null but error on server was {serverError.Value?.Message} {serverError.Value?.StackTrace}");
}
finally
{
try
{
c?.CloseAsync().Wait(TimeSpan.FromMilliseconds(200));
s?.CloseAsync().Wait(TimeSpan.FromMilliseconds(200));
}
catch
{
}
}
}
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 async Task Run()
{
MultithreadEventLoopGroup bossGroup = new MultithreadEventLoopGroup();
MultithreadEventLoopGroup workerGroup = new MultithreadEventLoopGroup();
try
{
ServerBootstrap b = new ServerBootstrap();
b.Group(bossGroup, workerGroup)
.Channel <TcpServerSocketChannel>()
.ChildHandler(new ActionChannelInitializer <IChannel>(channel =>
{
IChannelPipeline pipeline = channel.Pipeline;
pipeline.AddLast("decoder", new StringDecoder());
pipeline.AddLast("encoder", new StringEncoder());
pipeline.AddLast("handler", new StringHandler());
Log.Info("initChannel:" + channel.RemoteAddress);
}))
.Option(ChannelOption.SoBacklog, 128)
.ChildOption(ChannelOption.SoKeepalive, true);
Log.Info("tcp server start......");
IChannel f = await b.BindAsync(port);
await f.CloseCompletion;
}
catch (Exception ex)
{
Log.Error("tcp server start error.");
}
finally
{
await workerGroup.ShutdownGracefullyAsync();
await bossGroup.ShutdownGracefullyAsync();
Log.Info("tcp server close");
}
}
public async Task TestFlushInWritabilityChanged()
{
LocalAddress addr = new LocalAddress("testFlushInWritabilityChanged");
ServerBootstrap sb = GetLocalServerBootstrap();
await sb.BindAsync(addr);
Bootstrap cb = GetLocalClientBootstrap();
SetInterest(LoggingHandler.Event.WRITE, LoggingHandler.Event.FLUSH, LoggingHandler.Event.WRITABILITY);
var clientChannel = await cb.ConnectAsync(addr);
clientChannel.Configuration.WriteBufferLowWaterMark = 512;
clientChannel.Configuration.WriteBufferHighWaterMark = 1024;
clientChannel.Pipeline.AddLast(new ChannelInboundHandlerAdapter0());
Assert.True(clientChannel.IsWritable);
await clientChannel.WriteAsync(CreateTestBuf(2000));
await clientChannel.CloseAsync();
AssertLog(
// Case 1:
"WRITABILITY: writable=False\n" +
"FLUSH\n" +
"WRITE\n" +
"WRITABILITY: writable=False\n" +
"WRITABILITY: writable=False\n" +
"FLUSH\n" +
"WRITABILITY: writable=True\n",
// Case 2:
"WRITABILITY: writable=False\n" +
"FLUSH\n" +
"WRITE\n" +
"WRITABILITY: writable=False\n" +
"FLUSH\n" +
"WRITABILITY: writable=True\n" +
"WRITABILITY: writable=True\n");
}
public async Task RunEngineAsync(int port, IBasicHandler basicHandler, ICustomizeHandler handler)
{
bossGroup = new MultithreadEventLoopGroup(1);
workerGroup = new MultithreadEventLoopGroup();
MessageDispatcher dispatcher = new MessageDispatcher(this.BasicController, basicHandler, handler);
List <ChannelServerHandler> handlers = new List <ChannelServerHandler>();
RingObject <ChannelServerHandler> ringHandlers = null;
if (!useDefaultThread)//此处相比默认handler增加了工作线程，默认工作线程为cpu核心*2
{
for (int i = 0; i < workThreadCount; i++)
{
WorkerEngine <RequestInfo> workerEngine = new WorkerEngine <RequestInfo>(3000, 1, dispatcher.Process);
workerEngine.Start();
handlers.Add(new ChannelServerHandler(this.userManager, workerEngine));
}
ringHandlers = new RingObject <ChannelServerHandler>(handlers);
}
else
{
var cChannelHandlers = new List <ChannelServerHandler>()
{
new ChannelServerHandler(this.userManager, dispatcher)
};
ringHandlers = new RingObject <ChannelServerHandler>(cChannelHandlers);
}
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(OFrameDecoder.NewOFrameDecoder());
pipeline.AddLast(ringHandlers.GetNext());
}));
IChannel bootstrapChannel = await bootstrap.BindAsync(port);
}
public async Task TestCloseAsync()
{
var group = new MultithreadEventLoopGroup();
var addr = new LocalAddress(ChannelPoolTestUtils.GetLocalAddrId());
Bootstrap cb = new Bootstrap().RemoteAddress(addr).Group(group).Channel <LocalChannel>();
ServerBootstrap sb = new ServerBootstrap()
.Group(group)
.Channel <LocalServerChannel>()
.ChildHandler(
new ActionChannelInitializer <LocalChannel>(
ch => ch.Pipeline.AddLast(new ChannelHandlerAdapter()))
);
// Start server
IChannel sc = await sb.BindAsync(addr);
var handler = new CountingChannelPoolHandler();
var pool = new SimpleChannelPool(cb, handler);
var ch1 = await pool.AcquireAsync();
var ch2 = await pool.AcquireAsync();
pool.ReleaseAsync(ch1).Wait(TimeSpan.FromSeconds(1));
pool.ReleaseAsync(ch2).Wait(TimeSpan.FromSeconds(1));
// Assert that returned channels are open before close
Assert.True(ch1.Open);
Assert.True(ch2.Open);
// Close asynchronously with timeout
await pool.CloseAsync().WithTimeout(TimeSpan.FromSeconds(1));
// Assert channels were indeed closed
Assert.False(ch1.Open);
Assert.False(ch2.Open);
await sc.CloseAsync();
pool.Close();
await group.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(5));
}
public void SetUp(BenchmarkContext context)
{
this.serverGroup = new MultithreadEventLoopGroup(_ => new EventLoop(), 1);
Encoding iso = Encoding.GetEncoding("ISO-8859-1");
IByteBuffer buf = Unpooled.Buffer().WriteInt(3).WriteBytes(iso.GetBytes("ABC"));
this.message = new byte[buf.ReadableBytes];
buf.GetBytes(buf.ReaderIndex, this.message);
this.inboundThroughputCounter = context.GetCounter(InboundThroughputCounterName);
var counterHandler = new CounterHandlerInbound(this.inboundThroughputCounter);
this.signal = new ManualResetEventSlimReadFinishedSignal(this.resetEvent);
// using default settings
this.serverBufferAllocator = new PooledByteBufferAllocator();
ServerBootstrap sb = new ServerBootstrap()
.Group(this.serverGroup)
.Channel <TcpServerChannel>()
.ChildOption(ChannelOption.Allocator, this.serverBufferAllocator)
.ChildHandler(new ActionChannelInitializer <TcpChannel>(channel =>
{
channel.Pipeline
.AddLast(GetEncoder())
.AddLast(GetDecoder())
.AddLast(counterHandler)
.AddLast(new ReadFinishedHandler(this.signal, WriteCount));
}));
// start server
this.serverChannel = sb.BindAsync(TestAddress).Result;
// connect to server
var address = (IPEndPoint)this.serverChannel.LocalAddress;
this.clientSocket = new Socket(AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp);
this.clientSocket.Connect(address.Address, address.Port);
this.stream = new NetworkStream(this.clientSocket, true);
}
public Task StartAsync(CancellationToken cancellationToken)
{
bossGroup = new DispatcherEventLoopGroup();
workerGroup = new WorkerEventLoopGroup(bossGroup, configuration.EventLoopCount);
serverBufferAllocator = new PooledByteBufferAllocator();
//serverBufferAllocator = new UnpooledByteBufferAllocator();
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("jt808TcpBuffer", new DelimiterBasedFrameDecoder(int.MaxValue,
Unpooled.CopiedBuffer(new byte[] { JT808.Protocol.JT808Package.BeginFlag }),
Unpooled.CopiedBuffer(new byte[] { JT808.Protocol.JT808Package.EndFlag })));
channel.Pipeline.AddLast("jt808TcpDecode", scope.ServiceProvider.GetRequiredService <JT808TcpDecoder>());
channel.Pipeline.AddLast("jt808TcpEncode", scope.ServiceProvider.GetRequiredService <JT808TcpEncoder>());
channel.Pipeline.AddLast("systemIdleState", new IdleStateHandler(
configuration.ReaderIdleTimeSeconds,
configuration.WriterIdleTimeSeconds,
configuration.AllIdleTimeSeconds));
channel.Pipeline.AddLast("jt808TcpConnection", scope.ServiceProvider.GetRequiredService <JT808TcpConnectionHandler>());
channel.Pipeline.AddLast("jt808TcpService", scope.ServiceProvider.GetRequiredService <JT808TcpServerHandler>());
}
}));
logger.LogInformation($"JT808 TCP Server start at {IPAddress.Any}:{configuration.TcpPort}.");
return(bootstrap.BindAsync(configuration.TcpPort)
.ContinueWith(i => bootstrapChannel = i.Result));
}
public async Task StartAsync(CancellationToken cancellationToken)
{
if (configuration.TcpPort <= 0)
{
return;
}
var bootstrap = new ServerBootstrap();
serverBufferAllocator = new PooledByteBufferAllocator();
if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) || RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
{
var dispatcher = new DispatcherEventLoopGroup();
bossGroup = dispatcher;
workerGroup = new WorkerEventLoopGroup(dispatcher);
bootstrap.Channel <TcpServerChannel>();
bootstrap
.Option(ChannelOption.SoReuseport, true)
.ChildOption(ChannelOption.SoReuseaddr, true);
}
else
{
bossGroup = new MultithreadEventLoopGroup(1);
workerGroup = new MultithreadEventLoopGroup();
bootstrap.Channel <TcpServerSocketChannel>();
}
bootstrap.Group(bossGroup, workerGroup);
bootstrap
.Option(ChannelOption.SoBacklog, configuration.SoBacklog)
.ChildOption(ChannelOption.Allocator, serverBufferAllocator)
.ChildHandler(new ActionChannelInitializer <IChannel>(channel =>
{
var pipeline = channel.Pipeline;
using var scope = serviceProvider.CreateScope();
pipeline.AddLast(new IdleStateHandler(configuration.ReaderIdleTimeSeconds, configuration.WriterIdleTimeSeconds, configuration.AllIdleTimeSeconds));
pipeline.AddLast(scope.ServiceProvider.GetRequiredService <TcpMetadataDecoder>());
pipeline.AddLast(scope.ServiceProvider.GetRequiredService <TcpMetadataEncoder>());
pipeline.AddLast(scope.ServiceProvider.GetRequiredService <BranchTcpServerHandler>());
}));
logger.LogInformation($"TCP Server start at {IPAddress.Any}:{configuration.TcpPort}.");
bootstrapChannel = await bootstrap.BindAsync(configuration.TcpPort);
}
static async Task RunServer()
{
var eventListener = new ObservableEventListener();
eventListener.LogToConsole();
eventListener.EnableEvents(DefaultEventSource.Log, EventLevel.Verbose);
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;
if (EchoServerSettings.IsSsl)
{
pipeline.AddLast(TlsHandler.Server(new X509Certificate2("dotnetty.com.pfx", "password")));
}
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();
}
}
private async Task TestSoLingerZeroCausesOnlyRstOnClose0(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);
// SO_LINGER=0 means that we must send ONLY a RST when closing (not a FIN + RST).
sb.ChildOption(ChannelOption.SoLinger, 0);
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();
IChannel cc = 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 received a RST.
var cause = throwableRef.Value;
if (cause is object)
{
Assert.True(cause is SocketException, "actual [type, message]: [" + cause.GetType() + ", " + cause.Message + "]");
//AssertRstOnCloseException((SocketException)cause, cc);
Assert.True(cause.Message.Contains("reset") || cause.Message.Contains("closed"), "actual message: " + cause.Message);
}
}
public async Task TestBoundedChannelPoolSegment()
{
var group = new MultithreadEventLoopGroup();
var addr = new LocalAddress(LOCAL_ADDR_ID);
Bootstrap cb = new Bootstrap().RemoteAddress(addr).Group(group).Channel <LocalChannel>();
ServerBootstrap sb = new ServerBootstrap()
.Group(group)
.Channel <LocalServerChannel>()
.ChildHandler(
new ActionChannelInitializer <LocalChannel>(
ch => ch.Pipeline.AddLast(new ChannelHandlerAdapter()))
);
// Start server
IChannel sc = await sb.BindAsync(addr);
var handler = new CountingChannelPoolHandler();
var pool = new SingleChannelPool(cb, handler);
IChannel channel = await pool.AcquireAsync();
IChannel channel2 = await pool.AcquireAsync();
await pool.ReleaseAsync(channel);
await Assert.ThrowsAsync <InvalidOperationException>(async() => await pool.ReleaseAsync(channel2));
await channel2.CloseAsync();
Assert.Equal(2, handler.ChannelCount);
Assert.Equal(0, handler.AcquiredCount);
Assert.Equal(1, handler.ReleasedCount);
await sc.CloseAsync();
await channel.CloseAsync();
await channel2.CloseAsync();
await group.ShutdownGracefullyAsync();
}
public async Task TestUnhealthyChannelIsNotOffered()
{
var group = new MultithreadEventLoopGroup();
var addr = new LocalAddress(LOCAL_ADDR_ID);
Bootstrap cb = new Bootstrap().RemoteAddress(addr).Group(group).Channel <LocalChannel>();
ServerBootstrap sb = new ServerBootstrap()
.Group(group)
.Channel <LocalServerChannel>()
.ChildHandler(
new ActionChannelInitializer <LocalChannel>(
ch => ch.Pipeline.AddLast(new ChannelHandlerAdapter()))
);
// Start server
IChannel sc = await sb.BindAsync(addr);
var handler = new CountingChannelPoolHandler();
var pool = new SimpleChannelPool(cb, handler);
IChannel channel1 = await pool.AcquireAsync();
await pool.ReleaseAsync(channel1);
IChannel channel2 = await pool.AcquireAsync();
//first check that when returned healthy then it actually offered back to the pool.
Assert.Same(channel1, channel2);
await channel1.CloseAsync();
await pool.ReleaseAsync(channel1);
IChannel channel3 = await pool.AcquireAsync();
//channel1 was not healthy anymore so it should not get acquired anymore.
Assert.NotSame(channel1, channel3);
await sc.CloseAsync();
await channel3.CloseAsync();
await group.ShutdownGracefullyAsync();
}
static async Task RunServerAsync()
{
ExampleHelper.SetConsoleLogger();
var bossGroup = new MultithreadEventLoopGroup(1);
var workerGroup = new MultithreadEventLoopGroup();
X509Certificate2 tlsCertificate = null;
if (ServerSettings.IsSsl)
{
tlsCertificate = new X509Certificate2(Path.Combine(ExampleHelper.ProcessDirectory, "dotnetty.com.pfx"), "password");
}
try
{
var bootstrap = new ServerBootstrap();
bootstrap
.Group(bossGroup, workerGroup)
.Channel <TcpServerSocketChannel>()
.Option(ChannelOption.SoBacklog, 100)
.Handler(new LoggingHandler("LSTN"))
.ChildHandler(new ActionChannelInitializer <ISocketChannel>(channel =>
{
IChannelPipeline pipeline = channel.Pipeline;
if (tlsCertificate != null)
{
pipeline.AddLast(TlsHandler.Server(tlsCertificate));
}
pipeline.AddLast(new LoggingHandler("CONN"));
pipeline.AddLast(new DiscardServerHandler());
}));
IChannel bootstrapChannel = await bootstrap.BindAsync(ServerSettings.Port);
Console.ReadLine();
await bootstrapChannel.CloseAsync();
}
finally
{
Task.WaitAll(bossGroup.ShutdownGracefullyAsync(), workerGroup.ShutdownGracefullyAsync());
}
}
public async Task <IChannel> startHttpPortAsync(string lport)
{
//X509Certificate2 tlsCertificate = null;
//if (ServerSettings.IsSsl)
//{
// tlsCertificate = new X509Certificate2(Path.Combine(commSetting.ProcessDirectory, "dotnetty.com.pfx"), "password");
//}
if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
GCSettings.LatencyMode = GCLatencyMode.SustainedLowLatency;
}
try
{
httpbootstrap.Group(httpbossGroup, httpworkerGroup);
httpbootstrap.Channel <CustHttpServerSocketChannel>();
httpbootstrap
.Option(ChannelOption.SoBacklog, 8192)
.ChildHandler(new ActionChannelInitializer <IChannel>(channel =>
{
IChannelPipeline pipeline = channel.Pipeline;
// pipeline.AddLast("encoder", new HttpResponseEncoder());
pipeline.AddLast("decoder", new HttpRequestDecoder(maxInitialLineLength, maxHeaderSize, maxChunkSize, true));
pipeline.AddLast("decoder2", new HttpObjectAggregator(maxContentLength));
pipeline.AddLast("handler", new HttpProxyServerHandler());
}))
.ChildOption(ChannelOption.SoKeepalive, true);
httpbootstrapChannel = await httpbootstrap.BindAsync(IPAddress.IPv6Any, int.Parse(lport));
Console.WriteLine($"Httpd started. Listening on {httpbootstrapChannel.LocalAddress}");
return(httpbootstrapChannel);
}
catch (Exception ex)
{
Task.WaitAll(httpbossGroup.ShutdownGracefullyAsync(), httpworkerGroup.ShutdownGracefullyAsync());
throw new Exception("服务启动失败");
}
}
public async Task TestSocketReuse()
{
ServerBootstrap serverBootstrap = new ServerBootstrap();
LocalHandler serverHandler = new LocalHandler("SERVER");
serverBootstrap
.Group(new DefaultEventLoopGroup(1), new DefaultEventLoopGroup())
.Channel <LocalServerChannel>()
.ChildHandler(serverHandler);
Bootstrap clientBootstrap = new Bootstrap();
LocalHandler clientHandler = new LocalHandler("CLIENT");
clientBootstrap
.Group(new DefaultEventLoopGroup())
.Channel <LocalChannel>()
.RemoteAddress(new LocalAddress(LOCAL_CHANNEL)).Handler(clientHandler);
await serverBootstrap.BindAsync(new LocalAddress(LOCAL_CHANNEL));
int count = 100;
for (int i = 1; i < count + 1; i++)
{
var ch = await clientBootstrap.ConnectAsync();
// SPIN until we get what we are looking for.
int target = i * c_messageCountPerRun;
while (serverHandler.Count.Value != target || clientHandler.Count.Value != target)
{
Thread.Sleep(50);
}
Close(ch, clientHandler);
}
Assert.Equal(count * 2 * c_messageCountPerRun, serverHandler.Count.Value + clientHandler.Count.Value);
Task.WaitAll(
serverBootstrap.Group().ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(5)),
serverBootstrap.ChildGroup().ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(5)),
clientBootstrap.Group().ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(5))
);
}
public void SetUp(BenchmarkContext context)
{
ServerGroup = new MultithreadEventLoopGroup(1);
WorkerGroup = new MultithreadEventLoopGroup();
var iso = Encoding.GetEncoding("ISO-8859-1");
message = Unpooled.Buffer().WriteInt(3).WriteBytes(iso.GetBytes("ABC")).ToArray();
_inboundThroughputCounter = context.GetCounter(InboundThroughputCounterName);
_outboundThroughputCounter = context.GetCounter(OutboundThroughputCounterName);
var counterHandler = new CounterHandlerInbound(_inboundThroughputCounter);
_signal = new ManualResetEventSlimReadFinishedSignal(ResetEvent);
var sb = new ServerBootstrap().Group(ServerGroup, WorkerGroup).Channel <TcpServerSocketChannel>()
.ChildOption(ChannelOption.TcpNodelay, true)
.ChildHandler(
new ActionChannelInitializer <TcpSocketChannel>(
channel =>
{
channel.Pipeline.AddLast(GetEncoder())
.AddLast(GetDecoder())
.AddLast(counterHandler)
.AddLast(new CounterHandlerOutbound(_outboundThroughputCounter))
.AddLast(new ReadFinishedHandler(_signal, WriteCount));
}));
// start server
_serverChannel = sb.BindAsync(TEST_ADDRESS).Result;
// connect to server
var address = (IPEndPoint)_serverChannel.LocalAddress;
ClientSocket = new System.Net.Sockets.Socket(AddressFamily.InterNetworkV6, SocketType.Stream,
ProtocolType.Tcp);
ClientSocket.Connect(address.Address, address.Port);
Stream = new NetworkStream(ClientSocket, true);
}
public async Task StartAsync(EndPoint endPoint)
{
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"准备启动服务主机，监听地址：{endPoint}。");
}
IEventLoopGroup bossGroup = new MultithreadEventLoopGroup(1);
IEventLoopGroup workerGroup = new MultithreadEventLoopGroup();//Default eventLoopCount is Environment.ProcessorCount * 2
var bootstrap = new ServerBootstrap();
bootstrap
.Channel <TcpServerSocketChannel>()
.Option(ChannelOption.SoBacklog, 128)
.ChildOption(ChannelOption.Allocator, PooledByteBufferAllocator.Default)
.Group(bossGroup, workerGroup)
.ChildHandler(new ActionChannelInitializer <IChannel>(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(async(contenxt, message) =>
{
var sender = new DotNettyServerMessageSender(_transportMessageEncoder, contenxt);
await OnReceived(sender, message);
}, _logger));
}));
try
{
_channel = await bootstrap.BindAsync(endPoint);
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"服务主机启动成功，监听地址：{endPoint}。");
}
}
catch
{
_logger.LogError($"服务主机启动失败，监听地址：{endPoint}。 ");
}
}
static async Task Server()
{
IEventLoopGroup bossGroup = new MultithreadEventLoopGroup(1);
IEventLoopGroup workerGroup = new MultithreadEventLoopGroup();
ServerBootstrap bootstrap = new ServerBootstrap();
bootstrap.Group(bossGroup, workerGroup)
.Channel <TcpServerSocketChannel>()
.ChildHandler(new ActionChannelInitializer <IChannel>(channel =>
{
channel.Pipeline.AddLast("echo", new ServerHandler());
}));
IChannel boundChannel = await bootstrap.BindAsync(12345);
Console.ReadLine();
await boundChannel.CloseAsync();
}
public async Task Run()
{
var bossGroup = new MultithreadEventLoopGroup(1);
var workerGroup = new MultithreadEventLoopGroup(5);
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 DeCoder());
pipeline.AddLast(new EnCoder());
pipeline.AddLast(new EnCoder2());
pipeline.AddLast(new EchoServerHandler());
}));
bootstrapChannel = await bootstrap.BindAsync(2012);
}
Task <IChannel> NewServer(bool autoRead, params IChannelHandler[] handlers)
{
Assert.True(handlers.Length >= 1);
var serverBootstrap = new ServerBootstrap();
serverBootstrap.Group(this.group)
.Channel <TcpServerSocketChannel>()
.ChildOption(ChannelOption.AutoRead, autoRead)
.ChildHandler(
new ActionChannelInitializer <IChannel>(
ch =>
{
IChannelPipeline pipeline = ch.Pipeline;
pipeline.AddLast(new OneByteToThreeStringsDecoder());
pipeline.AddLast(handlers);
}));
return(serverBootstrap.BindAsync(IPAddress.Loopback, 0));
}
/// <summary>
/// Starts the network.
/// </summary>
static async Task Bootstrap()
{
var boss = new MultithreadEventLoopGroup(1);
var worker = new MultithreadEventLoopGroup();
var bootstrap = new ServerBootstrap();
bootstrap.Group(boss, worker);
bootstrap.Option(ChannelOption.SoKeepalive, true);
bootstrap.Channel <TcpServerSocketChannel>();
bootstrap.ChildHandler(new ActionChannelInitializer <ISocketChannel>((ch) =>
{
IChannelPipeline pipeline = ch.Pipeline;
pipeline.AddLast("decoder", new ConnectionDecoder());
pipeline.AddLast("encoder", new ConnectionEncoder());
pipeline.AddLast("handler", new NetworkHandler(ch));
}));
await bootstrap.BindAsync(IPAddress.Any, Constants.HOST_PORT);
}
public Property TcpSocketServerChannel_can_bind_on_any_valid_EndPoint(EndPoint ep)
{
IChannel c = null;
try
{
var sb = new ServerBootstrap()
.Channel <TcpServerSocketChannel>()
.ChildHandler(new ActionChannelInitializer <TcpSocketChannel>(channel => { }))
.Group(_serverGroup);
c = sb.BindAsync(ep).Result;
return(c.IsOpen.Label("Channel should be open").And(c.IsActive).Label("Channel should be active"));
}
finally
{
c?.CloseAsync().Wait(TimeSpan.FromMilliseconds(200));
}
}
public async Task StartAsync()
{
try
{
this.logger.LogInformation("Starting MQTT head");
ServerBootstrap bootstrap = this.SetupServerBootstrap();
this.logger.LogInformation("Initializing TLS endpoint on port {0} for MQTT head.", MqttsPort);
this.serverChannel = await bootstrap.BindAsync(!Socket.OSSupportsIPv6?IPAddress.Any : IPAddress.IPv6Any, MqttsPort);
this.logger.LogInformation("Started MQTT head");
}
catch (Exception e)
{
this.logger.LogError("Failed to start MQTT server {0}", e);
await this.CloseAsync(CancellationToken.None);
}
}
public static async Task RunServerAsync(int port, IPacketCryptoFactory factory)
{
var bossGroup = new MultithreadEventLoopGroup(1);
var workerGroup = new MultithreadEventLoopGroup();
try
{
var bootstrap = new ServerBootstrap();
bootstrap
.Option(ChannelOption.SoBacklog, 100)
.Group(bossGroup, workerGroup)
.Channel <TcpServerSocketChannel>()
.ChildHandler(new ActionChannelInitializer <ISocketChannel>(channel =>
{
IChannelPipeline pipeline = channel.Pipeline;
pipeline.AddLast("encoder", (MessageToMessageEncoder <string>)factory.GetEncoder());
pipeline.AddLast("decoder", (MessageToMessageDecoder <IByteBuffer>)factory.GetDecoder());
pipeline.AddLast("session", new ClientSession(channel));
}));
IChannel bootstrapChannel = await bootstrap.BindAsync(port).ConfigureAwait(false);
Log.Info($"[LISTENING] Server is listening");
Log.Info($"-> PORT : {port}");
while (Console.ReadLine() != "quit")
{
Thread.Sleep(2000);
}
await bootstrapChannel.CloseAsync().ConfigureAwait(false);
}
catch (Exception ex)
{
Log.Error("[SERVER]", ex);
}
finally
{
Task.WaitAll(bossGroup.ShutdownGracefullyAsync(), workerGroup.ShutdownGracefullyAsync());
}
}
private async Task TestReadPendingIsResetAfterEachRead0(ServerBootstrap sb, Bootstrap cb)
{
IChannel serverChannel = null;
IChannel clientChannel = null;
try
{
MyInitializer serverInitializer = new MyInitializer();
sb.Option(ChannelOption.SoBacklog, 1024);
sb.ChildHandler(serverInitializer);
serverChannel = await sb.BindAsync();
cb.Handler(new MyInitializer());
clientChannel = await cb.ConnectAsync(serverChannel.LocalAddress);
await clientChannel.WriteAndFlushAsync(Unpooled.WrappedBuffer(new byte[1024]));
// We expect to get 2 exceptions (1 from BuggyChannelHandler and 1 from ExceptionHandler).
Assert.True(serverInitializer._exceptionHandler._latch1.Wait(TimeSpan.FromSeconds(5)));
// After we get the first exception, we should get no more, this is expected to timeout.
Assert.False(serverInitializer._exceptionHandler._latch2.Wait(TimeSpan.FromSeconds(1)),
"Encountered " + serverInitializer._exceptionHandler._count.Value + " exceptions when 1 was expected");
}
finally
{
if (serverChannel != null)
{
await serverChannel.CloseAsync();
}
if (clientChannel != null)
{
await clientChannel.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)));
}
}
//static
public async Task StartHttp()
{
ServerBootstrap bootstrap = null;
try
{
// if (bootstrap == null)
{
IEventLoopGroup group;
IEventLoopGroup workGroup;
bootstrap = new ServerBootstrap();
group = new MultithreadEventLoopGroup(1);
workGroup = new MultithreadEventLoopGroup();
bootstrap.Group(group, workGroup);
bootstrap.Channel <TcpServerSocketChannel>();
bootstrap
.Option(ChannelOption.SoBacklog, 8192)
.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("handler", this.adapter);
}));
IChannel bootstrapChannel = await bootstrap.BindAsync(System.Net.IPAddress.IPv6Any, this.port);
}
if (bootstrap == null)
{
}
}
catch (Exception ex)
{
//if (log != null)
// log.Log(new WarningLogEntry() { Exception = ex });
}
}
public static async System.Threading.Tasks.Task RunClientAsync(string[] args)
{
if (args == null || args.Length != 1 || !int.TryParse(args[0], out int port))
{
System.Console.WriteLine("Usage: port");
return;
}
MultithreadEventLoopGroup bossGroup = new MultithreadEventLoopGroup(1);
MultithreadEventLoopGroup workerGroup = new MultithreadEventLoopGroup();
try
{
ServerBootstrap b = new ServerBootstrap();
b.Group(bossGroup, workerGroup).Channel <TcpServerSocketChannel>().Handler(new LoggingHandler(LogLevel.INFO)).ChildHandler(new ActionChannelInitializer <ISocketChannel>(channel =>
{
IChannelPipeline p = channel.Pipeline;
p.AddLast(new ProtobufVarint32FrameDecoder());
p.AddLast(new ProtobufDecoder(ProtobufCommand.Command.Parser));
p.AddLast(new ProtobufVarint32LengthFieldPrepender());
p.AddLast(new ProtobufEncoder());
p.AddLast(new ServerHandler());
}));
IChannel ch = await b.BindAsync(port);
Server server = new Server(new ServerHandler());
server.Loop();
await ch.CloseAsync();
} catch (System.Exception e)
{
int line = (new StackTrace(e, true)).GetFrame(0).GetFileLineNumber();
System.Console.WriteLine("Error :" + e.Message + "on line " + line);
} finally
{
await bossGroup.ShutdownGracefullyAsync();
await workerGroup.ShutdownGracefullyAsync();
System.Console.WriteLine("Server closed gracefully");
}
}
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, 8192)
.ChildOption(ChannelOption.Allocator, serverBufferAllocator)
.ChildHandler(new ActionChannelInitializer <IChannel>(channel =>
{
IChannelPipeline pipeline = channel.Pipeline;
pipeline.AddLast(new HttpServerCodec());
pipeline.AddLast(new CorsHandler(CorsConfigBuilder
.ForAnyOrigin()
.AllowNullOrigin()
.AllowedRequestMethods(HttpMethod.Get, HttpMethod.Post, HttpMethod.Options, HttpMethod.Delete)
.AllowedRequestHeaders((AsciiString)"origin", (AsciiString)"range", (AsciiString)"accept-encoding", (AsciiString)"referer", (AsciiString)"Cache-Control", (AsciiString)"X-Proxy-Authorization", (AsciiString)"X-Requested-With", (AsciiString)"Content-Type")
.ExposeHeaders((StringCharSequence)"Server", (StringCharSequence)"range", (StringCharSequence)"Content-Length", (StringCharSequence)"Content-Range")
.AllowCredentials()
.Build()));
pipeline.AddLast(new HttpObjectAggregator(int.MaxValue));
using (var scope = serviceProvider.CreateScope())
{
pipeline.AddLast("JT1078HttpServerHandler", scope.ServiceProvider.GetRequiredService <JT1078HttpServerHandler>());
}
}));
logger.LogInformation($"JT1078 Http Server start at {IPAddress.Any}:{configuration.HttpPort}.");
return(bootstrap.BindAsync(configuration.HttpPort)
.ContinueWith(i => bootstrapChannel = i.Result));
}
public void FlushNotDiscarded()
{
var executorService = new SingleThreadEventExecutor("Discarded", TimeSpan.FromMilliseconds(100));
try
{
_sb = new ServerBootstrap();
_sb.Group(new MultithreadEventLoopGroup(1), new MultithreadEventLoopGroup());
_sb.Channel <TcpServerSocketChannel>();
_sb.ChildHandler(new ActionChannelInitializer <IChannel>(ch =>
{
ch.Pipeline.AddLast(new Http2FrameCodecBuilder(true).Build());
ch.Pipeline.AddLast(new Http2MultiplexHandler(new TestChannelInboundHandlerAdapter(executorService)));
}));
var loopback = IPAddress.IPv6Loopback;
_serverChannel = _sb.BindAsync(loopback, 0).GetAwaiter().GetResult();
CountdownEvent latch = new CountdownEvent(1);
_bs = new Bootstrap();
_bs.Group(new MultithreadEventLoopGroup());
_bs.Channel <TcpSocketChannel>();
_bs.Handler(new ActionChannelInitializer <IChannel>(ch =>
{
ch.Pipeline.AddLast(new Http2FrameCodecBuilder(false).Build());
ch.Pipeline.AddLast(new Http2MultiplexHandler(DISCARD_HANDLER.Instance));
}));
var port = ((IPEndPoint)_serverChannel.LocalAddress).Port;
var ccf = _bs.ConnectAsync(loopback, port);
_clientChannel = ccf.GetAwaiter().GetResult();
Http2StreamChannelBootstrap h2Bootstrap = new Http2StreamChannelBootstrap(_clientChannel);
h2Bootstrap.Handler(new TestFlushNotDiscardedHandler(latch));
IHttp2StreamChannel streamChannel = h2Bootstrap.OpenAsync().GetAwaiter().GetResult();
streamChannel.WriteAndFlushAsync(new DefaultHttp2HeadersFrame(new DefaultHttp2Headers(), true)).GetAwaiter().GetResult();
latch.Wait();
}
finally
{
executorService.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(5));
}
}
public async Task RunAsync(int threadCount, CancellationToken cancellationToken, RecieveServiceRequestDelegate recieveServiceRequest)
{
Contract.Requires(threadCount > 0);
try
{
LogsManager.Info("通用服务开始启动!");
this.parentEventLoopGroup = new MultithreadEventLoopGroup(1);
this.eventLoopGroup = new MultithreadEventLoopGroup(threadCount);
ServerBootstrap bootstrap = this.SetupBootstrap(recieveServiceRequest);
this.serverChannel = await bootstrap.BindAsync(port);
cancellationToken.Register(this.CloseAsync);
LogsManager.Info("通用服务成功启动!");
}
catch (Exception ex)
{
LogsManager.Error("通用服务启动失败");
this.CloseAsync();
}
}
private static async Task RunServerAsync()
{
IEventLoopGroup bossGroup = new MultithreadEventLoopGroup(1);
IEventLoopGroup workerGroup = new MultithreadEventLoopGroup();
try {
ServerBootstrap bootstrap = new ServerBootstrap()
.Group(bossGroup, workerGroup)
.Channel <TcpServerSocketChannel>()
.ChildHandler(new ActionChannelInitializer <IChannel>(channel => {
channel.Pipeline.AddLast(new TimeEncoder(), new TimeServerHandler());
}));
IChannel boundChannel = await bootstrap.BindAsync(Port);
await boundChannel.CloseCompletion;
} finally {
await Task.WhenAll(bossGroup.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1)),
workerGroup.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1)));
}
}
/// <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_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 Property TcpServerSocketChannel_can_accept_connection_on_any_valid_Endpoint(EndPoint ep)
{
var ip = ep as IPEndPoint;
var family = ep.BestAddressFamily();
// TODO: remove this code once https://bugzilla.xamarin.com/show_bug.cgi?id=35536 is fixed
if (IsMono && family == AddressFamily.InterNetworkV6 && ep is DnsEndPoint)
{
family = AddressFamily.InterNetwork;
}
IChannel s = null;
IChannel c = null;
try
{
var sb = new ServerBootstrap()
.ChannelFactory(() => new TcpServerSocketChannel(family))
.ChildHandler(new ActionChannelInitializer<TcpSocketChannel>(channel => { }))
.PreferredDnsResolutionFamily(family)
.Group(_serverGroup);
s = sb.BindAsync(ep).Result;
var cb = new ClientBootstrap()
.ChannelFactory(() => new TcpSocketChannel(family))
.Option(ChannelOption.TcpNodelay, true)
.Option(ChannelOption.ConnectTimeout, TimeSpan.FromMilliseconds(100))
.PreferredDnsResolutionFamily(family)
.Handler(new ActionChannelInitializer<TcpSocketChannel>(channel => { }))
.Group(_clientGroup);
var clientEp = s.LocalAddress;
if (ip != null) // handle special case of 0.0.0.0, which clients can't connect to directly.
{
if (ip.Address.Equals(IPAddress.Any))
clientEp = new IPEndPoint(IPAddress.Loopback, ((IPEndPoint) s.LocalAddress).Port);
if (ip.Address.Equals(IPAddress.IPv6Any))
clientEp = new IPEndPoint(IPAddress.IPv6Loopback, ((IPEndPoint) s.LocalAddress).Port);
}
c = cb.ConnectAsync(clientEp).Result;
c.WriteAndFlushAsync(Unpooled.Buffer(4).WriteInt(2)).Wait(20);
return c.IsOpen.Label("Channel should be open")
.And(c.IsActive).Label("Channel should be active")
.And(c.IsWritable).Label("Channel should be writable");
}
finally
{
try
{
c?.CloseAsync().Wait(TimeSpan.FromMilliseconds(200));
s?.CloseAsync().Wait(TimeSpan.FromMilliseconds(200));
}
catch
{
}
}
}
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);
}
}
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_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 static Task<IChannel> CreateConnection(Role role, IPEndPoint socketAddress, int poolSize, IChannelHandler upstreamHandler)
{
if (role == Role.Client)
{
var connection = new ClientBootstrap()
.ChannelFactory(() => new TcpSocketChannel(socketAddress.AddressFamily))
.Option(ChannelOption.TcpNodelay, true)
.Group(GetClientWorkerPool(poolSize))
.Handler(new ActionChannelInitializer<TcpSocketChannel>(channel =>
{
ApplyChannelPipeline(channel, upstreamHandler);
}));
return connection.ConnectAsync(socketAddress);
}
else //server
{
var connection = new ServerBootstrap()
.Group(GetServerPool(poolSize), GetServerWorkerPool(poolSize))
.ChannelFactory(() => new TcpServerSocketChannel(socketAddress.AddressFamily))
.ChildOption(ChannelOption.TcpNodelay, true)
.ChildHandler(new ActionChannelInitializer<TcpSocketChannel>(channel =>
{
ApplyChannelPipeline(channel, upstreamHandler);
}));
return connection.BindAsync(socketAddress);
}
}
/// <summary>
/// Starts Echo server.
/// </summary>
/// <returns>function to trigger closure of the server.</returns>
async Task<Func<Task>> StartServerAsync(bool tcpNoDelay, Action<IChannel> childHandlerSetupAction, TaskCompletionSource testPromise)
{
var bossGroup = new MultithreadEventLoopGroup(1);
var workerGroup = new MultithreadEventLoopGroup();
bool started = false;
//var tlsCertificate = new X509Certificate2("dotnetty.com.pfx", "password");
try
{
ServerBootstrap b = new ServerBootstrap()
.Group(bossGroup, workerGroup)
.Channel<TcpServerSocketChannel>()
.Handler(new ExceptionCatchHandler(ex => testPromise.TrySetException(ex)))
.ChildHandler(new ActionChannelInitializer<ISocketChannel>(childHandlerSetupAction))
.ChildOption(ChannelOption.TcpNodelay, tcpNoDelay);
this.output.WriteLine("Configured ServerBootstrap: {0}", b);
IChannel serverChannel = await b.BindAsync(Port);
this.output.WriteLine("Bound server channel: {0}", serverChannel);
started = true;
return async () =>
{
try
{
await serverChannel.CloseAsync();
}
finally
{
Task.WaitAll(bossGroup.ShutdownGracefullyAsync(), workerGroup.ShutdownGracefullyAsync());
}
};
}
finally
{
if (!started)
{
Task.WaitAll(bossGroup.ShutdownGracefullyAsync(), workerGroup.ShutdownGracefullyAsync());
}
}
}
public Property TcpSocketServerChannel_can_bind_on_any_valid_EndPoint(EndPoint ep)
{
IChannel c = null;
var family = ep.BestAddressFamily();
// TODO: remove this code once https://bugzilla.xamarin.com/show_bug.cgi?id=35536 is fixed
if (IsMono && family == AddressFamily.InterNetworkV6 && ep is DnsEndPoint)
{
family = AddressFamily.InterNetwork;
}
try
{
var sb = new ServerBootstrap()
.ChannelFactory(() => new TcpServerSocketChannel(family))
.ChildHandler(new ActionChannelInitializer<TcpSocketChannel>(channel => { }))
.PreferredDnsResolutionFamily(family)
.Group(_serverGroup);
c = sb.BindAsync(ep).Result;
return c.IsOpen.Label("Channel should be open").And(c.IsActive).Label("Channel should be active");
}
finally
{
c?.CloseAsync().Wait(TimeSpan.FromMilliseconds(200));
}
}
public void SetUp(BenchmarkContext context)
{
ServerGroup = new MultithreadEventLoopGroup(1);
WorkerGroup = new MultithreadEventLoopGroup();
var iso = Encoding.GetEncoding("ISO-8859-1");
message = Unpooled.Buffer().WriteInt(3).WriteBytes(iso.GetBytes("ABC")).ToArray();
_inboundThroughputCounter = context.GetCounter(InboundThroughputCounterName);
_outboundThroughputCounter = context.GetCounter(OutboundThroughputCounterName);
var counterHandler = new CounterHandlerInbound(_inboundThroughputCounter);
_signal = new ManualResetEventSlimReadFinishedSignal(ResetEvent);
var sb = new ServerBootstrap().Group(ServerGroup, WorkerGroup).Channel<TcpServerSocketChannel>()
.ChildOption(ChannelOption.TcpNodelay, true)
.ChildHandler(
new ActionChannelInitializer<TcpSocketChannel>(
channel =>
{
channel.Pipeline.AddLast(GetEncoder())
.AddLast(GetDecoder())
.AddLast(counterHandler)
.AddLast(new CounterHandlerOutbound(_outboundThroughputCounter))
.AddLast(new ReadFinishedHandler(_signal, WriteCount));
}));
// start server
_serverChannel = sb.BindAsync(TEST_ADDRESS).Result;
// connect to server
var address = (IPEndPoint) _serverChannel.LocalAddress;
ClientSocket = new System.Net.Sockets.Socket(AddressFamily.InterNetworkV6, SocketType.Stream,
ProtocolType.Tcp);
ClientSocket.Connect(address.Address, address.Port);
Stream = new NetworkStream(ClientSocket, true);
}
public void SetUp(BenchmarkContext context)
{
TaskScheduler.UnobservedTaskException += (sender, args) => Console.WriteLine(args.Exception);
this.ClientGroup = new MultithreadEventLoopGroup(1);
this.ServerGroup = new MultithreadEventLoopGroup(1);
this.WorkerGroup = new MultithreadEventLoopGroup();
Encoding iso = Encoding.GetEncoding("ISO-8859-1");
this.message = iso.GetBytes("ABC");
this.inboundThroughputCounter = context.GetCounter(InboundThroughputCounterName);
this.outboundThroughputCounter = context.GetCounter(OutboundThroughputCounterName);
var counterHandler = new CounterHandlerInbound(this.inboundThroughputCounter);
this.signal = new ManualResetEventSlimReadFinishedSignal(this.ResetEvent);
// reserve up to 10mb of 16kb buffers on both client and server; we're only sending about 700k worth of messages
this.serverBufferAllocator = new PooledByteBufferAllocator();
this.clientBufferAllocator = new PooledByteBufferAllocator();
Assembly assembly = typeof(TcpChannelPerfSpecs).Assembly;
byte[] certificateData;
using (Stream sourceStream = assembly.GetManifestResourceStream(assembly.GetManifestResourceNames()[0]))
using (var tempStream = new MemoryStream())
{
sourceStream.CopyTo(tempStream);
certificateData = tempStream.ToArray();
}
var tlsCertificate = new X509Certificate2(certificateData, "password");
string targetHost = tlsCertificate.GetNameInfo(X509NameType.DnsName, false);
ServerBootstrap sb = new ServerBootstrap()
.Group(this.ServerGroup, this.WorkerGroup)
.Channel<TcpServerSocketChannel>()
.ChildOption(ChannelOption.Allocator, this.serverBufferAllocator)
.ChildHandler(new ActionChannelInitializer<TcpSocketChannel>(channel =>
{
channel.Pipeline
//.AddLast(TlsHandler.Server(tlsCertificate))
.AddLast(this.GetEncoder())
.AddLast(this.GetDecoder())
.AddLast(counterHandler)
.AddLast(new CounterHandlerOutbound(this.outboundThroughputCounter))
.AddLast(new ReadFinishedHandler(this.signal, WriteCount));
}));
Bootstrap cb = new Bootstrap()
.Group(this.ClientGroup)
.Channel<TcpSocketChannel>()
.Option(ChannelOption.Allocator, this.clientBufferAllocator)
.Handler(new ActionChannelInitializer<TcpSocketChannel>(
channel =>
{
channel.Pipeline
//.AddLast(TlsHandler.Client(targetHost, null, (sender, certificate, chain, errors) => true))
.AddLast(this.GetEncoder())
.AddLast(this.GetDecoder())
.AddLast(counterHandler)
.AddLast(new CounterHandlerOutbound(this.outboundThroughputCounter));
}));
// start server
this.serverChannel = sb.BindAsync(TEST_ADDRESS).Result;
// connect to server
this.clientChannel = cb.ConnectAsync(this.serverChannel.LocalAddress).Result;
}
public void SetUp(BenchmarkContext context)
{
ClientGroup = new MultithreadEventLoopGroup(1);
ServerGroup = new MultithreadEventLoopGroup(2);
var iso = Encoding.GetEncoding("ISO-8859-1");
message = iso.GetBytes("ABC");
_inboundThroughputCounter = context.GetCounter(InboundThroughputCounterName);
_outboundThroughputCounter = context.GetCounter(OutboundThroughputCounterName);
var counterHandler = new CounterHandlerInbound(_inboundThroughputCounter);
_signal = new SimpleReadFinishedSignal();
var sb = new ServerBootstrap().Group(ServerGroup).Channel<LocalServerChannel>()
.ChildHandler(
new ActionChannelInitializer<LocalChannel>(
channel =>
{
channel.Pipeline.AddLast(GetEncoder())
.AddLast(GetDecoder())
.AddLast(counterHandler)
.AddLast(new CounterHandlerOutbound(_outboundThroughputCounter))
.AddLast(new ReadFinishedHandler(_signal, WriteCount));
}));
var cb =
new ClientBootstrap().Group(ClientGroup)
.Channel<LocalChannel>()
.Handler(new ActionChannelInitializer<LocalChannel>(
channel =>
{
channel.Pipeline.AddLast(GetEncoder()).AddLast(GetDecoder()).AddLast(counterHandler)
.AddLast(new CounterHandlerOutbound(_outboundThroughputCounter));
}));
// start server
_serverChannel = sb.BindAsync(TEST_ADDRESS).Result;
// connect to server
_clientChannel = cb.ConnectAsync(_serverChannel.LocalAddress).Result;
}
public void SetUp(BenchmarkContext context)
{
ClientGroup = new MultithreadEventLoopGroup(1);
ServerGroup = new MultithreadEventLoopGroup(1);
WorkerGroup = new MultithreadEventLoopGroup();
var iso = Encoding.GetEncoding("ISO-8859-1");
message = iso.GetBytes("ABC");
// pre-allocate all messages
foreach (var m in Enumerable.Range(0, WriteCount))
{
messages[m] = Unpooled.WrappedBuffer(message);
}
_inboundThroughputCounter = context.GetCounter(InboundThroughputCounterName);
_outboundThroughputCounter = context.GetCounter(OutboundThroughputCounterName);
var counterHandler = new CounterHandlerInbound(_inboundThroughputCounter);
_signal = new ManualResetEventSlimReadFinishedSignal(ResetEvent);
var sb = new ServerBootstrap().Group(ServerGroup, WorkerGroup).Channel<TcpServerSocketChannel>()
.ChildOption(ChannelOption.TcpNodelay, true)
.ChildHandler(
new ActionChannelInitializer<TcpSocketChannel>(
channel =>
{
channel.Pipeline.AddLast(GetEncoder())
.AddLast(GetDecoder())
.AddLast(counterHandler)
.AddLast(new CounterHandlerOutbound(_outboundThroughputCounter))
.AddLast(new ReadFinishedHandler(_signal, WriteCount));
}));
var cb = new ClientBootstrap().Group(ClientGroup)
.Option(ChannelOption.TcpNodelay, true)
.Channel<TcpSocketChannel>().Handler(new ActionChannelInitializer<TcpSocketChannel>(
channel =>
{
channel.Pipeline.AddLast(GetEncoder()).AddLast(GetDecoder()).AddLast(counterHandler)
.AddLast(new CounterHandlerOutbound(_outboundThroughputCounter));
}));
// start server
_serverChannel = sb.BindAsync(TEST_ADDRESS).Result;
// connect to server
_clientChannel = cb.ConnectAsync(_serverChannel.LocalAddress).Result;
//_clientChannel.Configuration.AutoRead = false;
}
async Task EnsureServerInitializedAsync()
{
if (this.ServerAddress != null)
{
return;
}
int threadCount = Environment.ProcessorCount;
var executorGroup = new MultithreadEventLoopGroup(threadCount);
var bufAllocator = new PooledByteBufferAllocator(16 * 1024, 10 * 1024 * 1024 / threadCount); // reserve 10 MB for 64 KB buffers
BlobSessionStatePersistenceProvider sessionStateProvider = await BlobSessionStatePersistenceProvider.CreateAsync(
this.settingsProvider.GetSetting("BlobSessionStatePersistenceProvider.StorageConnectionString"),
this.settingsProvider.GetSetting("BlobSessionStatePersistenceProvider.StorageContainerName"));
TableQos2StatePersistenceProvider qos2StateProvider = await TableQos2StatePersistenceProvider.CreateAsync(
this.settingsProvider.GetSetting("TableQos2StatePersistenceProvider.StorageConnectionString"),
this.settingsProvider.GetSetting("TableQos2StatePersistenceProvider.StorageTableName"));
var settings = new Settings(this.settingsProvider);
var authProvider = new SasTokenAuthenticationProvider();
var topicNameRouter = new TopicNameRouter();
DeviceClientFactoryFunc deviceClientFactoryFactory = IotHubDeviceClient.PreparePoolFactory(settings.IotHubConnectionString + ";DeviceId=stub", "a", 1);
ServerBootstrap server = new ServerBootstrap()
.Group(executorGroup)
.Channel<TcpServerSocketChannel>()
.ChildOption(ChannelOption.Allocator, bufAllocator)
.ChildOption(ChannelOption.AutoRead, false)
.ChildHandler(new ActionChannelInitializer<IChannel>(ch =>
{
ch.Pipeline.AddLast(TlsHandler.Server(this.tlsCertificate));
ch.Pipeline.AddLast(
MqttEncoder.Instance,
new MqttDecoder(true, 256 * 1024),
new MqttIotHubAdapter(
settings,
deviceClientFactoryFactory,
sessionStateProvider,
authProvider,
topicNameRouter,
qos2StateProvider),
new XUnitLoggingHandler(this.output));
}));
IChannel serverChannel = await server.BindAsync(IPAddress.Any, this.ProtocolGatewayPort);
this.ScheduleCleanup(async () =>
{
await serverChannel.CloseAsync();
await executorGroup.ShutdownGracefullyAsync();
});
this.ServerAddress = IPAddress.Loopback;
}
public void TcpSocketServerChannel_can_be_connected_to_on_any_aliased_Endpoint(IpMapping actual,
IpMapping alias, AddressFamily family)
{
var inboundActual = MappingToEndpoint(actual);
var inboundAlias = MappingToEndpoint(alias);
var isIp = inboundAlias is IPEndPoint;
if (IsMono && family == AddressFamily.InterNetworkV6)
{
Assert.True(true, "Mono currently does not support IPV6 in DNS resolution");
return;
}
IChannel s = null;
IChannel c = null;
try
{
var sb = new ServerBootstrap()
.ChannelFactory(() => new TcpServerSocketChannel())
.PreferredDnsResolutionFamily(family)
.ChildHandler(new ActionChannelInitializer<TcpSocketChannel>(channel => { }))
.Group(_serverGroup);
s = sb.BindAsync(inboundActual).Result;
var cb = new ClientBootstrap()
.ChannelFactory(() => new TcpSocketChannel())
.Option(ChannelOption.TcpNodelay, true)
.Option(ChannelOption.ConnectTimeout, TimeSpan.FromMilliseconds(100))
.PreferredDnsResolutionFamily(family)
.Handler(new ActionChannelInitializer<TcpSocketChannel>(channel => { }))
.Group(_clientGroup);
EndPoint clientEp = isIp
? new IPEndPoint(((IPEndPoint) inboundAlias).Address, ((IPEndPoint) s.LocalAddress).Port)
: (EndPoint) new DnsEndPoint(((DnsEndPoint) inboundAlias).Host, ((IPEndPoint) s.LocalAddress).Port);
c = cb.ConnectAsync(clientEp).Result;
c.WriteAndFlushAsync(Unpooled.Buffer(4).WriteInt(2)).Wait(20);
Assert.True(c.IsOpen);
Assert.True(c.IsActive);
Assert.True(c.IsWritable);
}
finally
{
try
{
c?.CloseAsync().Wait(TimeSpan.FromMilliseconds(200));
s?.CloseAsync().Wait(TimeSpan.FromMilliseconds(200));
}
catch
{
}
}
}
public void SetUp(BenchmarkContext context)
{
this.ServerGroup = new MultithreadEventLoopGroup(1);
this.WorkerGroup = new MultithreadEventLoopGroup();
Encoding iso = Encoding.GetEncoding("ISO-8859-1");
this.message = Unpooled.Buffer().WriteInt(3).WriteBytes(iso.GetBytes("ABC")).ToArray();
this.inboundThroughputCounter = context.GetCounter(InboundThroughputCounterName);
var counterHandler = new CounterHandlerInbound(this.inboundThroughputCounter);
this.signal = new ManualResetEventSlimReadFinishedSignal(this.ResetEvent);
// using default settings
this.serverBufferAllocator = new PooledByteBufferAllocator();
ServerBootstrap sb = new ServerBootstrap()
.Group(this.ServerGroup, this.WorkerGroup)
.Channel<TcpServerSocketChannel>()
.ChildOption(ChannelOption.Allocator, this.serverBufferAllocator)
.ChildHandler(new ActionChannelInitializer<TcpSocketChannel>(channel =>
{
channel.Pipeline
.AddLast(this.GetEncoder())
.AddLast(this.GetDecoder())
.AddLast(counterHandler)
.AddLast(new ReadFinishedHandler(this.signal, WriteCount));
}));
// start server
this.serverChannel = sb.BindAsync(TEST_ADDRESS).Result;
// connect to server
var address = (IPEndPoint)this.serverChannel.LocalAddress;
this.ClientSocket = new Socket(AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp);
this.ClientSocket.Connect(address.Address, address.Port);
this.Stream = new NetworkStream(this.ClientSocket, true);
}
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 SetUp(BenchmarkContext context)
{
ClientGroup = new MultithreadEventLoopGroup(Environment.ProcessorCount/2);
ServerGroup = new MultithreadEventLoopGroup(1);
WorkerGroup = new MultithreadEventLoopGroup(Environment.ProcessorCount/2);
_shutdownBenchmark = new CancellationTokenSource();
_clientChannels = new ConcurrentBag<IChannel>();
_inboundThroughputCounter = context.GetCounter(InboundThroughputCounterName);
_outboundThroughputCounter = context.GetCounter(OutboundThroughputCounterName);
_clientConnectedCounter = context.GetCounter(ClientConnectCounterName);
_errorCounter = context.GetCounter(ErrorCounterName);
_signal = new ManualResetEventSlimReadFinishedSignal(ResetEvent);
var sb = new ServerBootstrap().Group(ServerGroup, WorkerGroup).Channel<TcpServerSocketChannel>()
.ChildOption(ChannelOption.TcpNodelay, true)
.ChildHandler(new ActionChannelInitializer<TcpSocketChannel>(channel =>
{
channel.Pipeline.AddLast(GetEncoder())
.AddLast(GetDecoder())
.AddLast(new IntCodec(true))
.AddLast(new CounterHandlerInbound(_inboundThroughputCounter))
.AddLast(new CounterHandlerOutbound(_outboundThroughputCounter))
.AddLast(new ErrorCounterHandler(_errorCounter));
}));
ClientBootstrap = new ClientBootstrap().Group(ClientGroup)
.Option(ChannelOption.TcpNodelay, true)
.Channel<TcpSocketChannel>().Handler(new ActionChannelInitializer<TcpSocketChannel>(
channel =>
{
channel.Pipeline.AddLast(GetEncoder())
.AddLast(GetDecoder())
.AddLast(new IntCodec(true))
.AddLast(new CounterHandlerInbound(_inboundThroughputCounter))
.AddLast(new CounterHandlerOutbound(_outboundThroughputCounter))
.AddLast(new ErrorCounterHandler(_errorCounter));
}));
var token = _shutdownBenchmark.Token;
_eventLoop = () =>
{
while (!token.IsCancellationRequested)
{
foreach (var channel in _clientChannels)
{
// unrolling a loop
channel.WriteAsync(ThreadLocalRandom.Current.Next());
channel.WriteAsync(ThreadLocalRandom.Current.Next());
channel.WriteAsync(ThreadLocalRandom.Current.Next());
channel.WriteAsync(ThreadLocalRandom.Current.Next());
channel.WriteAsync(ThreadLocalRandom.Current.Next());
channel.WriteAsync(ThreadLocalRandom.Current.Next());
channel.WriteAsync(ThreadLocalRandom.Current.Next());
channel.WriteAsync(ThreadLocalRandom.Current.Next());
channel.WriteAsync(ThreadLocalRandom.Current.Next());
channel.Flush();
}
// sleep for a tiny bit, then get going again
Thread.Sleep(40);
}
};
// start server
_serverChannel = sb.BindAsync(TEST_ADDRESS).Result;
// connect to server with 1 client initially
_clientChannels.Add(ClientBootstrap.ConnectAsync(_serverChannel.LocalAddress).Result);
}
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());
}
}
