public void AutoAckPingFalse()
{
var builder = Http2FrameCodecBuilder.ForServer();
builder.AutoAckPingFrame = false;
SetUp(builder, new Http2Settings());
_frameInboundWriter.WriteInboundPing(false, 8);
_frameWriter.Verify(
x => x.WritePingAsync(
It.Is <IChannelHandlerContext>(v => v == _frameCodec._ctx),
It.Is <bool>(v => v == true),
It.Is <long>(v => v == 8L),
It.IsAny <IPromise>()),
Times.Never());
var frame = _inboundHandler.ReadInbound <IHttp2PingFrame>();
Assert.False(frame.Ack);
Assert.Equal(8, frame.Content);
// Now ack the frame manually.
_channel.WriteAndFlushAsync(new DefaultHttp2PingFrame(8, true));
_frameWriter.Verify(
x => x.WritePingAsync(
It.Is <IChannelHandlerContext>(v => v == _frameCodec._ctx),
It.Is <bool>(v => v == true),
It.Is <long>(v => v == 8L),
It.IsAny <IPromise>()));
}
public HttpServerUpgradeHandler.IUpgradeCodec NewUpgradeCodec(ICharSequence protocol)
{
if (AsciiString.ContentEquals(Http2CodecUtil.HttpUpgradeProtocolName, protocol))
{
return(new Http2ServerUpgradeCodec(Http2FrameCodecBuilder.ForServer().Build(), new HelloWorldHttp2Handler()));
}
else
{
return(null);
}
}
public Http2FrameCodecTest()
{
_request = new DefaultHttp2Headers();
_request.Method = HttpMethod.Get.AsciiName;
_request.Scheme = HttpScheme.Https.Name;
_request.Authority = new AsciiString("example.org");
_request.Path = new AsciiString("/foo");
_response = new DefaultHttp2Headers();
_response.Status = HttpResponseStatus.OK.CodeAsText;
SetUp(Http2FrameCodecBuilder.ForServer(), new Http2Settings());
}
public void IterateActiveStreams()
{
var builder = Http2FrameCodecBuilder.ForServer();
builder.EncoderEnforceMaxConcurrentStreams = true;
SetUp(builder, new Http2Settings().MaxConcurrentStreams(1));
_frameInboundWriter.WriteInboundHeaders(3, _request, 0, false);
IHttp2HeadersFrame headersFrame = _inboundHandler.ReadInbound <IHttp2HeadersFrame>();
Assert.NotNull(headersFrame);
IHttp2FrameStream activeInbond = headersFrame.Stream;
IHttp2FrameStream activeOutbound = _frameCodec.NewStream();
_channel.WriteAndFlushAsync(new DefaultHttp2HeadersFrame(new DefaultHttp2Headers())
{
Stream = activeOutbound
});
IHttp2FrameStream bufferedOutbound = _frameCodec.NewStream();
_channel.WriteAndFlushAsync(new DefaultHttp2HeadersFrame(new DefaultHttp2Headers())
{
Stream = bufferedOutbound
});
//@SuppressWarnings("unused")
IHttp2FrameStream idleStream = _frameCodec.NewStream();
ISet <IHttp2FrameStream> activeStreams = new HashSet <IHttp2FrameStream>();
bool localVisit(IHttp2FrameStream stream)
{
activeStreams.Add(stream);
return(true);
}
_frameCodec.ForEachActiveStream(localVisit);
Assert.Equal(2, activeStreams.Count);
ISet <IHttp2FrameStream> expectedStreams = new HashSet <IHttp2FrameStream>();
expectedStreams.Add(activeInbond);
expectedStreams.Add(activeOutbound);
Assert.Equal(expectedStreams, activeStreams);
}
protected override void ConfigurePipeline(IChannelHandlerContext ctx, SslApplicationProtocol protocol)
{
if (SslApplicationProtocol.Http2.Equals(protocol))
{
ctx.Pipeline.AddLast(Http2FrameCodecBuilder.ForServer().Build(), new HelloWorldHttp2Handler());
return;
}
if (SslApplicationProtocol.Http11.Equals(protocol))
{
ctx.Pipeline.AddLast(new HttpServerCodec(),
new HttpObjectAggregator(MAX_CONTENT_LENGTH),
new Http2Helloworld.Server.HelloWorldHttp1Handler("ALPN Negotiation"));
return;
}
throw new InvalidOperationException("unknown protocol: " + protocol);
}
public void DoNotLeakOnFailedInitializationForChannels()
{
// We use a limit of 1 and then increase it step by step.
SetUp(Http2FrameCodecBuilder.ForServer(), new Http2Settings().MaxConcurrentStreams(2));
IHttp2FrameStream stream1 = _frameCodec.NewStream();
IHttp2FrameStream stream2 = _frameCodec.NewStream();
var stream1HeaderPromise = _channel.NewPromise();
var stream2HeaderPromise = _channel.NewPromise();
_channel.WriteAndFlushAsync(new DefaultHttp2HeadersFrame(new DefaultHttp2Headers())
{
Stream = stream1
},
stream1HeaderPromise);
_channel.RunPendingTasks();
_frameInboundWriter.WriteInboundGoAway(stream1.Id, 0L, Unpooled.Empty);
_channel.WriteAndFlushAsync(new DefaultHttp2HeadersFrame(new DefaultHttp2Headers())
{
Stream = stream2
},
stream2HeaderPromise);
_channel.RunPendingTasks();
try
{
stream1HeaderPromise.Task.GetAwaiter().GetResult();
}
catch
{
Assert.False(true);
}
Assert.True(stream2HeaderPromise.IsCompleted);
Assert.Equal(0, _frameCodec.NumInitializingStreams);
Assert.False(_channel.FinishAndReleaseAll());
}
public void NewOutboundStreamsShouldBeBuffered()
{
var builder = Http2FrameCodecBuilder.ForServer();
builder.EncoderEnforceMaxConcurrentStreams = true;
SetUp(builder, new Http2Settings().MaxConcurrentStreams(1));
var stream1 = _frameCodec.NewStream();
var stream2 = _frameCodec.NewStream();
var promise1 = _channel.NewPromise();
var promise2 = _channel.NewPromise();
_channel.WriteAndFlushAsync(new DefaultHttp2HeadersFrame(new DefaultHttp2Headers())
{
Stream = stream1
}, promise1);
_channel.WriteAndFlushAsync(new DefaultHttp2HeadersFrame(new DefaultHttp2Headers())
{
Stream = stream2
}, promise2);
Assert.True(Http2CodecUtil.IsStreamIdValid(stream1.Id));
_channel.RunPendingTasks();
Assert.True(Http2CodecUtil.IsStreamIdValid(stream2.Id));
Assert.True(promise1.IsSuccess);
Assert.False(promise2.IsCompleted);
// Increase concurrent streams limit to 2
_frameInboundWriter.WriteInboundSettings(new Http2Settings().MaxConcurrentStreams(2));
_channel.Flush();
Assert.True(promise2.IsSuccess);
}
public void MultipleNewOutboundStreamsShouldBeBuffered()
{
var builder = Http2FrameCodecBuilder.ForServer();
builder.EncoderEnforceMaxConcurrentStreams = true;
// We use a limit of 1 and then increase it step by step.
SetUp(builder, new Http2Settings().MaxConcurrentStreams(1));
IHttp2FrameStream stream1 = _frameCodec.NewStream();
IHttp2FrameStream stream2 = _frameCodec.NewStream();
IHttp2FrameStream stream3 = _frameCodec.NewStream();
IPromise promise1 = _channel.NewPromise();
IPromise promise2 = _channel.NewPromise();
IPromise promise3 = _channel.NewPromise();
_channel.WriteAndFlushAsync(new DefaultHttp2HeadersFrame(new DefaultHttp2Headers())
{
Stream = stream1
}, promise1);
_channel.WriteAndFlushAsync(new DefaultHttp2HeadersFrame(new DefaultHttp2Headers())
{
Stream = stream2
}, promise2);
_channel.WriteAndFlushAsync(new DefaultHttp2HeadersFrame(new DefaultHttp2Headers())
{
Stream = stream3
}, promise3);
Assert.True(Http2CodecUtil.IsStreamIdValid(stream1.Id));
_channel.RunPendingTasks();
Assert.True(Http2CodecUtil.IsStreamIdValid(stream2.Id));
if (promise1.IsCompleted)
{
Assert.True(promise1.Task.IsSuccess());
}
else
{
try
{
promise1.Task.GetAwaiter().GetResult();
}
catch (Exception)
{
Assert.False(true);
}
}
Assert.False(promise2.IsCompleted);
Assert.False(promise3.IsCompleted);
// Increase concurrent streams limit to 2
_frameInboundWriter.WriteInboundSettings(new Http2Settings().MaxConcurrentStreams(2));
_channel.Flush();
// As we increased the limit to 2 we should have also succeed the second frame.
if (promise2.IsCompleted)
{
Assert.True(promise2.Task.IsSuccess());
}
else
{
try
{
promise2.Task.GetAwaiter().GetResult();
}
catch (Exception)
{
Assert.False(true);
}
}
Assert.False(promise3.IsCompleted);
_frameInboundWriter.WriteInboundSettings(new Http2Settings().MaxConcurrentStreams(3));
_channel.Flush();
// With the max streams of 3 all streams should be succeed now.
if (promise3.IsCompleted)
{
Assert.True(promise3.Task.IsSuccess());
}
else
{
try
{
promise3.Task.GetAwaiter().GetResult();
}
catch (Exception)
{
Assert.False(true);
}
}
Assert.False(_channel.FinishAndReleaseAll());
}
