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 void UpgradeToHttp2FrameCodec()
{
var b = new Http2FrameCodecBuilder(true);
b.GracefulShutdownTimeout = TimeSpan.Zero;
TestUpgrade(b.Build(), null);
}
protected override void InitChannel(IChannel channel)
{
var pipeline = channel.Pipeline;
if (_cert is object)
{
var tlsSettings = new ClientTlsSettings(_targetHost)
{
ApplicationProtocols = new List <SslApplicationProtocol>(new[]
{
SslApplicationProtocol.Http2,
SslApplicationProtocol.Http11
})
}.AllowAnyServerCertificate();
pipeline.AddLast("tls", new TlsHandler(tlsSettings));
}
var build = Http2FrameCodecBuilder.ForClient();
build.InitialSettings = Http2Settings.DefaultSettings(); // this is the default, but shows it can be changed.
Http2FrameCodec http2FrameCodec = build.Build();
pipeline.AddLast(http2FrameCodec);
pipeline.AddLast(new Http2MultiplexHandler(new SimpleChannelInboundHandler0()));
}
protected override void InitChannel(IChannel ch)
{
var pipeline = ch.Pipeline;
if (_cert is object)
{
pipeline.AddLast("tls", new TlsHandler(
stream => new SslStream(stream, true, (sender, certificate, chain, errors) => true),
new ClientTlsSettings(_targetHost)
{
ApplicationProtocols = new List <SslApplicationProtocol>(new[]
{
SslApplicationProtocol.Http2,
//SslApplicationProtocol.Http11
})
}
));
}
var build = Http2FrameCodecBuilder.ForClient();
build.InitialSettings = Http2Settings.DefaultSettings(); // this is the default, but shows it can be changed.
Http2FrameCodec http2FrameCodec = build.Build();
pipeline.AddLast(http2FrameCodec);
pipeline.AddLast(new Http2MultiplexHandler(new SimpleChannelInboundHandler0()));
}
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);
}
private void SetUp(Http2FrameCodecBuilder frameCodecBuilder, Http2Settings initialRemoteSettings)
{
// Some tests call this method twice. Once with JUnit's @Before and once directly to pass special settings.
// This call ensures that in case of two consecutive calls to setUp(), the previous channel is shutdown and
// ByteBufs are released correctly.
Dispose0();
_frameWriter = Http2TestUtil.MockedFrameWriter();
var builder = frameCodecBuilder.FrameWriter(_frameWriter.Object);
builder.FrameLogger = new Http2FrameLogger(Common.Internal.Logging.InternalLogLevel.TRACE);
builder.InitialSettings = initialRemoteSettings;
_frameCodec = frameCodecBuilder.Build();
_inboundHandler = new LastInboundHandler();
_channel = new EmbeddedChannel();
_frameInboundWriter = new Http2FrameInboundWriter(_channel);
//channel.Connect(new InetSocketAddress(0));
_channel.Pipeline.AddLast(_frameCodec);
_channel.Pipeline.AddLast(_inboundHandler);
_channel.Pipeline.FireChannelActive();
// Handshake
_frameWriter.Verify(
x => x.WriteSettingsAsync(
It.Is <IChannelHandlerContext>(v => v == _frameCodec._ctx),
It.IsAny <Http2Settings>(),
It.IsAny <IPromise>()));
_frameWriter.VerifyNoOtherCalls();
_channel.WriteInbound(Http2CodecUtil.ConnectionPrefaceBuf());
_frameInboundWriter.WriteInboundSettings(initialRemoteSettings);
_frameWriter.Verify(
x => x.WriteSettingsAckAsync(
It.Is <IChannelHandlerContext>(v => v == _frameCodec._ctx),
It.IsAny <IPromise>()));
_frameInboundWriter.WriteInboundSettingsAck();
var settingsFrame = _inboundHandler.ReadInbound <IHttp2SettingsFrame>();
Assert.NotNull(settingsFrame);
var settingsAckFrame = _inboundHandler.ReadInbound <IHttp2SettingsAckFrame>();
Assert.NotNull(settingsAckFrame);
}
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 UpgradeToHttp2FrameCodecWithMultiplexer()
{
TestUpgrade(
Http2FrameCodecBuilder.ForClient().Build(),
new Http2MultiplexHandler(new HttpInboundHandler(), new HttpInboundHandler()));
}
public void UpgradeToHttp2FrameCodec()
{
TestUpgrade(Http2FrameCodecBuilder.ForClient().Build(), null);
}
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());
}
protected override Http2FrameCodec NewCodec(IChannelHandler upgradeHandler)
{
return(Http2FrameCodecBuilder.ForClient().Build());
}
