public async Task TestClosedChannelExceptionCarryIOException()
{
IOException ioException = new IOException();
IChannel channel = new TestChannel0(ioException);
var loopGroup = new DefaultEventLoopGroup(1);
IEventLoop loop = loopGroup.GetNext();
try
{
RegisterChannel(loop, channel);
await channel.ConnectAsync(new IPEndPoint(IPAddress.IPv6Any, 8888));
try
{
await channel.WriteAndFlushAsync("");
}
catch (Exception exc)
{
Assert.Same(ioException, exc);
}
AssertClosedChannelException(channel.WriteAndFlushAsync(""), ioException);
AssertClosedChannelException(channel.WriteAsync(""), ioException);
AssertClosedChannelException(channel.BindAsync(new IPEndPoint(IPAddress.IPv6Any, 8888)), ioException);
}
finally
{
channel.CloseAsync().Ignore();
await loopGroup.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(5));
}
}
public async Task TestMap()
{
IEventLoopGroup group = new DefaultEventLoopGroup();
LocalAddress addr = new LocalAddress(ChannelPoolTestUtils.GetLocalAddrId());
// Start server
IChannel sc = await StartServerBootstrapAsync(group, addr);
Bootstrap cb = new Bootstrap();
cb.RemoteAddress(addr);
cb.Group(group).Channel <LocalChannel>();
var poolMap = new TestChannelPoolMap0(cb);
IEventLoop loop = group.GetNext();
Assert.True(poolMap.IsEmpty);
Assert.Equal(0, poolMap.Count);
SimpleChannelPool pool = poolMap.Get(loop);
Assert.Equal(1, poolMap.Count);
Assert.Same(pool, poolMap.Get(loop));
Assert.True(poolMap.Remove(loop));
Assert.False(poolMap.Remove(loop));
Assert.Equal(0, poolMap.Count);
await pool.AcquireAsync();
poolMap.Close();
await sc.CloseAsync();
}
public void TestExceptionDuringConnect()
{
IEventLoopGroup group = null;
IChannel serverChannel = null;
IChannel clientChannel = null;
try
{
group = new DefaultEventLoopGroup(1);
var addr = new LocalAddress("a");
var exception = new AtomicReference <Exception>();
var sf =
new ServerBootstrap().Channel <LocalServerChannel>().Group(group).ChildHandler(
new ActionChannelInitializer <IChannel>(ch =>
{
ch.Pipeline.AddFirst(new HttpResponseEncoder());
var response = new DefaultFullHttpResponse(
HttpVersion.Http11,
HttpResponseStatus.BadGateway);
response.Headers.Add(AsciiString.Of("name"), "value");
response.Headers.Add(HttpHeaderNames.ContentLength, "0");
ch.WriteAndFlushAsync(response);
}
)).BindAsync(addr);
serverChannel = sf.Result;
var cf = new Bootstrap().Channel <LocalChannel>().Group(group).Handler(
new ActionChannelInitializer <IChannel>(ch =>
{
ch.Pipeline.AddFirst(new HttpProxyHandler(addr));
ch.Pipeline.AddLast(new ErrorCaptureHandler(exception));
})).ConnectAsync(new DnsEndPoint("localhost", 1234));
clientChannel = cf.Result;
clientChannel.CloseAsync().Wait();
Assert.True(exception.Value is HttpProxyConnectException);
var actual = (HttpProxyConnectException)exception.Value;
Assert.NotNull(actual.Headers);
Assert.Equal("value", actual.Headers.GetAsString(AsciiString.Of("name")));
}
finally
{
if (clientChannel != null)
{
clientChannel.CloseAsync();
}
if (serverChannel != null)
{
serverChannel.CloseAsync();
}
if (group != null)
{
@group.ShutdownGracefullyAsync().Wait();
}
}
}
public async Task TestAcquire()
{
var group = new DefaultEventLoopGroup();
var addr = new LocalAddress(ChannelPoolTestUtils.GetLocalAddrId());
var cb = new Bootstrap().RemoteAddress(addr).Group(group).Channel <LocalChannel>();
var 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 channel = await pool.AcquireAsync();
await pool.ReleaseAsync(channel);
IChannel channel2 = await pool.AcquireAsync();
Assert.Same(channel, channel2);
Assert.Equal(1, handler.ChannelCount);
await pool.ReleaseAsync(channel2);
// Should fail on multiple release calls.
await Assert.ThrowsAsync <ArgumentException>(async() => await pool.ReleaseAsync(channel2));
Assert.False(channel.IsActive);
try
{
await pool.ReleaseAsync(channel2);
Assert.True(false, "release should fail");
}
catch (ArgumentException)
{
// expected
Assert.False(channel.IsActive);
}
Assert.Equal(1, handler.AcquiredCount);
Assert.Equal(2, handler.ReleasedCount);
await sc.CloseAsync();
pool.Close();
await group.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(5));
}
internal virtual Bootstrap GetLocalClientBootstrap()
{
IEventLoopGroup clientGroup = new DefaultEventLoopGroup();
Bootstrap cb = new Bootstrap();
cb.Channel <LocalChannel>();
cb.Group(clientGroup);
cb.Handler(_loggingHandler);
return(cb);
}
internal virtual ServerBootstrap GetLocalServerBootstrap()
{
IEventLoopGroup serverGroup = new DefaultEventLoopGroup();
ServerBootstrap sb = new ServerBootstrap();
sb.Group(serverGroup);
sb.Channel <LocalServerChannel>();
sb.ChildHandler(new ActionChannelInitializer <LocalChannel>(ch =>
{
}));
return(sb);
}
private static async Task TestParentHandler0(bool channelInitializer)
{
LocalAddress addr = new LocalAddress(Guid.NewGuid().ToString());
CountdownEvent readLatch = new CountdownEvent(1);
CountdownEvent initLatch = new CountdownEvent(1);
IChannelHandler handler = new TestHandler(readLatch, initLatch);
IEventLoopGroup group = new DefaultEventLoopGroup(1);
IChannel sch = null;
IChannel cch = null;
try
{
ServerBootstrap sb = new ServerBootstrap();
sb.Channel <LocalServerChannel>()
.Group(group)
.ChildHandler(new ChannelHandlerAdapter());
if (channelInitializer)
{
sb.Handler(new ActionChannelInitializer <IChannel>(ch => ch.Pipeline.AddLast(handler)));
}
else
{
sb.Handler(handler);
}
Bootstrap cb = new Bootstrap();
cb.Group(group)
.Channel <LocalChannel>()
.Handler(new ChannelHandlerAdapter());
sch = await sb.BindAsync(addr);
cch = await cb.ConnectAsync(addr);
initLatch.Wait();
readLatch.Wait();
}
finally
{
if (sch != null)
{
await sch.CloseAsync();
}
if (cch != null)
{
await cch.CloseAsync();
}
await group.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(5));
}
}
public DefaultHttp2ConnectionTest()
{
_group = new DefaultEventLoopGroup(2);
_clientListener = new Mock <IHttp2ConnectionListener>();
_clientListener
.Setup(x => x.OnStreamClosed(It.IsAny <IHttp2Stream>()))
.Callback <IHttp2Stream>(stream => Assert.True(stream.Id > 0));
_clientListener
.Setup(x => x.OnStreamRemoved(It.IsAny <IHttp2Stream>()))
.Callback <IHttp2Stream>(stream => Assert.True(stream.Id > 0));
_clientListener2 = new Mock <IHttp2ConnectionListener>();
_server = new DefaultHttp2Connection(true);
_client = new DefaultHttp2Connection(false);
_client.AddListener(_clientListener.Object);
}
public async Task TestBoundedChannelPoolSegment()
{
var group = new DefaultEventLoopGroup();
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 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();
pool.Close();
await group.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(5));
}
public async Task TestUnhealthyChannelIsNotOffered()
{
var group = new DefaultEventLoopGroup();
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);
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();
pool.Close();
await group.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(5));
}
public async Task TestCloseAsync()
{
var group = new DefaultEventLoopGroup();
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.IsOpen);
Assert.True(ch2.IsOpen);
// Close asynchronously with timeout
await pool.CloseAsync().WithTimeout(TimeSpan.FromSeconds(1));
// Assert channels were indeed closed
Assert.False(ch1.IsOpen);
Assert.False(ch2.IsOpen);
await sc.CloseAsync();
pool.Close();
await group.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(5));
}
public async Task TestHandlerRegister()
{
CountdownEvent latch = new CountdownEvent(1);
AtomicReference <Exception> error = new AtomicReference <Exception>();
var group = new DefaultEventLoopGroup(1);
try
{
ServerBootstrap sb = new ServerBootstrap();
sb.Channel <LocalServerChannel>()
.Group(group)
.ChildHandler(new ChannelHandlerAdapter())
.Handler(new TestRegisterHandler(latch, error));
await sb.RegisterAsync();
latch.Wait();
Assert.Null(error.Value);
}
finally
{
await group.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(5));
}
}
public async Task TestUnhealthyChannelIsOfferedWhenNoHealthCheckRequested()
{
var group = new DefaultEventLoopGroup();
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, ChannelActiveHealthChecker.Instance, false);
IChannel channel1 = await pool.AcquireAsync();
await channel1.CloseAsync();
await pool.ReleaseAsync(channel1);
IChannel channel2 = await pool.AcquireAsync();
//verifying that in fact the channel2 is different that means is not pulled from the pool
Assert.NotSame(channel1, channel2);
await sc.CloseAsync();
await channel2.CloseAsync();
pool.Close();
await group.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(5));
}
public async Task TestStagedExecution()
{
IEventLoopGroup l = new DefaultEventLoopGroup(4, new DefaultThreadFactory("l"));
IEventExecutorGroup e1 = new DefaultEventExecutorGroup(4, new DefaultThreadFactory("e1"));
IEventExecutorGroup e2 = new DefaultEventExecutorGroup(4, new DefaultThreadFactory("e2"));
ThreadNameAuditor h1 = new ThreadNameAuditor();
ThreadNameAuditor h2 = new ThreadNameAuditor();
ThreadNameAuditor h3 = new ThreadNameAuditor(true);
IChannel ch = new LocalChannel();
// With no EventExecutor specified, h1 will be always invoked by EventLoop 'l'.
ch.Pipeline.AddLast(h1);
// h2 will be always invoked by EventExecutor 'e1'.
ch.Pipeline.AddLast(e1, h2);
// h3 will be always invoked by EventExecutor 'e2'.
ch.Pipeline.AddLast(e2, h3);
await l.RegisterAsync(ch);
await ch.ConnectAsync(_localAddr);
// Fire inbound events from all possible starting points.
ch.Pipeline.FireChannelRead("1");
ch.Pipeline.Context(h1).FireChannelRead("2");
ch.Pipeline.Context(h2).FireChannelRead("3");
ch.Pipeline.Context(h3).FireChannelRead("4");
// Fire outbound events from all possible starting points.
ch.Pipeline.WriteAsync("5").Ignore();
ch.Pipeline.Context(h3).WriteAsync("6").Ignore();
ch.Pipeline.Context(h2).WriteAsync("7").Ignore();
await ch.Pipeline.Context(h1).WriteAndFlushAsync("8");
await ch.CloseAsync();
// Wait until all events are handled completely.
while (h1._outboundThreadNames.Count < 3 || h3._inboundThreadNames.Count < 3 ||
h1._removalThreadNames.Count < 1)
{
if (h1._exception.Value != null)
{
throw h1._exception.Value;
}
if (h2._exception.Value != null)
{
throw h2._exception.Value;
}
if (h3._exception.Value != null)
{
throw h3._exception.Value;
}
Thread.Sleep(10);
}
string currentName = Thread.CurrentThread.Name;
try
{
// Events should never be handled from the current thread.
Assert.DoesNotContain(currentName, h1._inboundThreadNames);
Assert.DoesNotContain(currentName, h2._inboundThreadNames);
Assert.DoesNotContain(currentName, h3._inboundThreadNames);
Assert.DoesNotContain(currentName, h1._outboundThreadNames);
Assert.DoesNotContain(currentName, h2._outboundThreadNames);
Assert.DoesNotContain(currentName, h3._outboundThreadNames);
Assert.DoesNotContain(currentName, h1._removalThreadNames);
Assert.DoesNotContain(currentName, h2._removalThreadNames);
Assert.DoesNotContain(currentName, h3._removalThreadNames);
// Assert that events were handled by the correct executor.
foreach (string name in h1._inboundThreadNames)
{
Assert.StartsWith("l-", name);
}
foreach (string name in h2._inboundThreadNames)
{
Assert.StartsWith("e1-", name);
}
foreach (string name in h3._inboundThreadNames)
{
Assert.StartsWith("e2-", name);
}
foreach (string name in h1._outboundThreadNames)
{
Assert.StartsWith("l-", name);
}
foreach (string name in h2._outboundThreadNames)
{
Assert.StartsWith("e1-", name);
}
foreach (string name in h3._outboundThreadNames)
{
Assert.StartsWith("e2-", name);
}
foreach (string name in h1._removalThreadNames)
{
Assert.StartsWith("l-", name);
}
foreach (string name in h2._removalThreadNames)
{
Assert.StartsWith("e1-", name);
}
foreach (string name in h3._removalThreadNames)
{
Assert.StartsWith("e2-", name);
}
// Assert that the events for the same handler were handled by the same thread.
HashSet <string> names = new HashSet <string>();
names.UnionWith(h1._inboundThreadNames);
names.UnionWith(h1._outboundThreadNames);
names.UnionWith(h1._removalThreadNames);
Assert.Single(names);
names.Clear();
names.UnionWith(h2._inboundThreadNames);
names.UnionWith(h2._outboundThreadNames);
names.UnionWith(h2._removalThreadNames);
Assert.Single(names);
names.Clear();
names.UnionWith(h3._inboundThreadNames);
names.UnionWith(h3._outboundThreadNames);
names.UnionWith(h3._removalThreadNames);
Assert.Single(names);
// Count the number of events
Assert.Single(h1._inboundThreadNames);
Assert.Equal(2, h2._inboundThreadNames.Count);
Assert.Equal(3, h3._inboundThreadNames.Count);
Assert.Equal(3, h1._outboundThreadNames.Count);
Assert.Equal(2, h2._outboundThreadNames.Count);
Assert.Single(h3._outboundThreadNames);
Assert.Single(h1._removalThreadNames);
Assert.Single(h2._removalThreadNames);
Assert.Single(h3._removalThreadNames);
}
catch (Exception)
{
//System.out.println("H1I: " + h1.inboundThreadNames);
//System.out.println("H2I: " + h2.inboundThreadNames);
//System.out.println("H3I: " + h3.inboundThreadNames);
//System.out.println("H1O: " + h1.outboundThreadNames);
//System.out.println("H2O: " + h2.outboundThreadNames);
//System.out.println("H3O: " + h3.outboundThreadNames);
//System.out.println("H1R: " + h1.removalThreadNames);
//System.out.println("H2R: " + h2.removalThreadNames);
//System.out.println("H3R: " + h3.removalThreadNames);
throw;
}
finally
{
Task.WaitAll(
l.ShutdownGracefullyAsync(),
e1.ShutdownGracefullyAsync(),
e2.ShutdownGracefullyAsync());
}
}
