public void TcpServerSocketChannel_horizontal_scale_stress_test(BenchmarkContext context)
{
_clientConnectedCounter.Increment(); // for the initial client
var totalRunSeconds = TotalRunSeconds;
Console.WriteLine("Running benchmark for {0} minutes", totalRunSeconds.TotalMinutes);
var deadline = new PreciseDeadline(totalRunSeconds);
var due = DateTime.Now + totalRunSeconds;
var lastMeasure = due;
var task = Task.Factory.StartNew(_eventLoop); // start writing
var runCount = 1;
while (!deadline.IsOverdue)
{
// add a new client
_clientChannels.Add(ClientBootstrap.ConnectAsync(_serverChannel.LocalAddress).Result);
_clientConnectedCounter.Increment();
Thread.Sleep(SleepInterval);
if (++runCount % 10 == 0)
{
Console.WriteLine("{0} minutes remaining [{1} connections active].",
(due - DateTime.Now).TotalMinutes, runCount);
var saturation = (DateTime.Now - lastMeasure);
if (saturation > SaturationThreshold)
{
Console.WriteLine(
"Took {0} to create 10 connections; exceeded pre-defined saturation threshold of {1}. Ending stress test.",
saturation, SaturationThreshold);
break;
}
lastMeasure = DateTime.Now;
}
}
_shutdownBenchmark.Cancel();
}
protected override ITcpServerSocketModel RunInternal(ITcpServerSocketModel obj0)
{
var cb = new ClientBootstrap()
.Group(ClientEventLoopGroup)
.Channel <TcpSocketChannel>()
.Handler(new ActionChannelInitializer <TcpSocketChannel>(ConstructClientPipeline));
var connectTasks = new List <Task <IChannel> >();
for (var i = 0; i < ClientCount; i++)
{
connectTasks.Add(cb.ConnectAsync(obj0.BoundAddress));
}
if (!Task.WaitAll(connectTasks.ToArray(), TimeSpan.FromSeconds(ClientCount * 2)))
{
throw new TimeoutException(
$"Waited {ClientCount} seconds to connect {ClientCount} clients to {obj0.BoundAddress}, but the operation timed out.");
}
foreach (var task in connectTasks)
{
// storing our local address for comparison purposes
obj0 = obj0.AddLocalChannel(task.Result).AddClient((IPEndPoint)task.Result.LocalAddress);
}
return(obj0);
}
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));
}
}
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 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);
}
}
private static void CreateClient()
{
var channelConfig = new ChannelConfig()
{
AutoReceiving = true,
PenddingMessageCounter = 102400,
ReceivingBufferSize = 1024 * 64,
SendingBufferSize = 1024 * 64
};
var workGroup = new MutlEventloopGroup(1);
var bootstrap = new ClientBootstrap();
bootstrap
.Group(workGroup)
.Channel <TcpClientChannel>()
.Config(channelConfig)
.Pipeline(pipeline =>
{
pipeline.AddLast("Tls", new TlsHandler());
pipeline.AddLast("Enc", new LengthMessageEncoder());
pipeline.AddLast("Dec", new LengthMessageDecoder());
pipeline.AddLast("MyChannelHandler", new MyChannelHandler());
});
bootstrap.ConnectAsync(new IPEndPoint(IPAddress.Parse("192.168.1.103"), 46456));
}
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 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 Property TcpServerSocketChannel_can_accept_connection_on_any_valid_Endpoint(EndPoint ep)
{
var ip = ep as IPEndPoint;
IChannel s = null;
IChannel c = null;
try
{
var sb = new ServerBootstrap()
.Channel <TcpServerSocketChannel>()
.ChildHandler(new ActionChannelInitializer <TcpSocketChannel>(channel => { }))
.Group(_serverGroup);
s = sb.BindAsync(ep).Result;
var cb = new ClientBootstrap()
.Channel <TcpSocketChannel>()
.Option(ChannelOption.TcpNodelay, true)
.Option(ChannelOption.ConnectTimeout, TimeSpan.FromMilliseconds(100))
.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_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 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 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 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 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;
}
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 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);
}
}
}
private async Task Test(ClientBootstrap bootstrap)
{
// var ip = "127.0.0.1";
//ip="192.168.111.133";
// int port = 8007;
// ip = "192.168.3.5";
for (int i = 0; i < 10; i++)
{
Task.Run(async() =>
{
//IChannel client = null;
//try
//{
// client = await bootstrap.ConnectAsync(new IPEndPoint(IPAddress.Parse(ip), port));
//}
//catch (Exception ex)
//{
// Console.WriteLine("**********" + ex.Message);
//}
//if (client != null) await Test(100, client);
for (int i = 0; i < 100000; i++)
{
IChannel client = null;
try
{
client = await bootstrap.ConnectAsync(new IPEndPoint(IPAddress.Parse(ip), port));
await Test(1, client);
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
finally
{
if (client != null)
{
await client?.CloseAsync();
}
}
}
});
// await Task.Delay(10);
}
}
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 Helios20_Client_and_Helios14_Server_Should_ReadWrite()
{
IReactor server = null;
IChannel client = null;
try
{
server = _serverBootstrap.NewReactor(NodeBuilder.BuildNode().Host(IPAddress.Loopback).WithPort(0));
server.OnReceive += (data, channel) =>
{
// echo the response back
channel.Send(data);
};
server.OnConnection += (address, channel) => { channel.BeginReceive(); };
server.Start();
client = _clientBootstrap.ConnectAsync(server.LocalEndpoint).Result;
Task.Delay(TimeSpan.FromMilliseconds(500)).Wait(); // because Helios 1.4 is stupid
var writes =
Enumerable.Range(0, ReadCount)
.Select(x => ThreadLocalRandom.Current.Next())
.OrderBy(y => y)
.ToList();
foreach (var write in writes)
{
client.WriteAndFlushAsync(Unpooled.Buffer(4).WriteInt(write));
}
_resetEvent.Wait();
var decodedReceive = _received.Select(y => y.ReadInt()).OrderBy(x => x).ToList();
Assert.True(decodedReceive.SequenceEqual(writes));
}
finally
{
client?.CloseAsync().Wait();
server?.Stop();
_clientGroup.ShutdownGracefullyAsync().Wait();
}
}
public async Task Test()
{
int heartbeatIntervalSecond = 60;
InternalLoggerFactory.DefaultFactory = _loggerFactory;//.AddConsoleLogger();
//实际要考虑事件循环的共用，事件循环的关闭问题
MultithreadEventLoopGroup workerGroup = new MultithreadEventLoopGroup(8);
workerGroup.Start();
var bootstrap = new ClientBootstrap();
bootstrap
.Group(workerGroup)
.Config(ConfigConstant.HeartbeatIntervalSecond, heartbeatIntervalSecond)
.Config(ConfigConstant.ConnectTimeoutSecond, 10)
.Channel <TcpSocketChannel>()
.WorkerHandler(channel =>
{
//channel.Pipeline.AddLast("MessageDecoder", new MessageDecoder());
channel.Pipeline.AddLast("MessageBaseDecoder", new LengthFieldBasedFrameDecoder(int.MaxValue, 4, 4));
channel.Pipeline.AddLast("MessageDecoder", new MessageDecoder());
channel.Pipeline.AddLast("MessageEncoder", new MessageEncoder());
channel.Pipeline.AddLast("IdleStateHandler", new IdleStateHandler(0, 0, heartbeatIntervalSecond));
channel.Pipeline.AddLast("ClientHeartbeatHandler", new ClientHeartbeatHandler());
channel.Pipeline.AddLast("ServerHandler", new ClientHandler());
//便于理解 这里都是addlist 入站是从上外下执行的，出站是从下往上执行的
});
//这里创建连接 如果连接失败 会抛异常。如果连接成功以后，连接再断开会触发ChannelInactive 事件
//可以管理连接封装起来，首次连接失败 通过捕获异常进行重试，连接后再断开在ChannelInactive 事件中 进行连接重试
var client = await bootstrap.ConnectAsync(new IPEndPoint(IPAddress.Parse(ip), port));
await Test(bootstrap);
}
private void InitSocket()
{
new Thread(() => //new thread to run socket
{
clientBootstrap.ConnectAsync().ContinueWith(task =>
{
//if connect success
echoHandler.channel = task.Result;
echoHandler.slim.Set();
});
})
{
IsBackground = true
}.Start();
echoHandler.slim.WaitOne(msgTimeout);
if (echoHandler.channel == null)
{
throw new Exception("MyIdServer --> can not connect to " + server + ":" + port);
}
else //send login
{
echoHandler.sb.Clear();
byte[] byteArry = Encoding.Default.GetBytes(pwd);
echoHandler.channel.WriteAndFlushAsync(Unpooled.WrappedBuffer(byteArry));
echoHandler.slim.WaitOne(msgTimeout);
if (echoHandler.sb.ToString() == "-1")
{
echoHandler.channel.CloseAsync();
echoHandler.channel = null;
echoHandler.slim.Reset();
echoHandler.sb.Clear();
throw new Exception("MyIdServer --> password error");
}
}
}
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 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 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_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_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 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 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;
}
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 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 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(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 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 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);
}
}
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
{
}
}
}