/// <summary>
/// Performs the opening handshake
/// When call this method you <c>MUST NOT</c> retain the <see cref="IFullHttpRequest"/> which is passed in.
/// </summary>
/// <param name="channel">Channel</param>
/// <param name="req">HTTP Request</param>
/// <param name="responseHeaders">Extra headers to add to the handshake response or <code>null</code> if no extra headers should be added</param>
/// <param name="completion">the <see cref="IPromise"/> to be notified when the opening handshake is done</param>
public void Handshake(IChannel channel, IFullHttpRequest req, HttpHeaders responseHeaders, IPromise completion)
{
#if DEBUG
if (Logger.DebugEnabled)
{
Logger.WebSocketVersionServerHandshake(channel, _version);
}
#endif
IFullHttpResponse response = NewHandshakeResponse(req, responseHeaders);
IChannelPipeline p = channel.Pipeline;
if (p.Get <HttpObjectAggregator>() is object)
{
_ = p.Remove <HttpObjectAggregator>();
}
if (p.Get <HttpContentCompressor>() is object)
{
_ = p.Remove <HttpContentCompressor>();
}
if (p.Get <CorsHandler>() is object)
{
_ = p.Remove <CorsHandler>();
}
if (p.Get <HttpServerExpectContinueHandler>() is object)
{
_ = p.Remove <HttpServerExpectContinueHandler>();
}
if (p.Get <HttpServerKeepAliveHandler>() is object)
{
_ = p.Remove <HttpServerKeepAliveHandler>();
}
IChannelHandlerContext ctx = p.Context <HttpRequestDecoder>();
string encoderName;
if (ctx is null)
{
// this means the user use an HttpServerCodec
ctx = p.Context <HttpServerCodec>();
if (ctx is null)
{
_ = completion.TrySetException(ThrowHelper.GetInvalidOperationException_NoHttpDecoderAndServerCodec());
return;
}
encoderName = ctx.Name;
_ = p.AddBefore(encoderName, "wsencoder", NewWebSocketEncoder());
_ = p.AddBefore(encoderName, "wsdecoder", NewWebsocketDecoder());
}
else
{
_ = p.Replace(ctx.Name, "wsdecoder", NewWebsocketDecoder());
encoderName = p.Context <HttpResponseEncoder>().Name;
_ = p.AddBefore(encoderName, "wsencoder", NewWebSocketEncoder());
}
_ = channel.WriteAndFlushAsync(response).ContinueWith(RemoveHandlerAfterWriteAction, (completion, p, encoderName), TaskContinuationOptions.ExecuteSynchronously);
}
public void Handshake(IChannel channel, IFullHttpRequest req, HttpHeaders responseHeaders, TaskCompletionSource completion)
{
if (Logger.DebugEnabled)
{
Logger.Debug("{} WebSocket version {} server handshake", channel, this.version);
}
IFullHttpResponse response = this.NewHandshakeResponse(req, responseHeaders);
IChannelPipeline p = channel.Pipeline;
if (p.Get <HttpObjectAggregator>() != null)
{
p.Remove <HttpObjectAggregator>();
}
if (p.Get <HttpContentCompressor>() != null)
{
p.Remove <HttpContentCompressor>();
}
IChannelHandlerContext ctx = p.Context <HttpRequestDecoder>();
string encoderName;
if (ctx == null)
{
// this means the user use a HttpServerCodec
ctx = p.Context <HttpServerCodec>();
if (ctx == null)
{
completion.TrySetException(new InvalidOperationException("No HttpDecoder and no HttpServerCodec in the pipeline"));
return;
}
p.AddBefore(ctx.Name, "wsdecoder", this.NewWebsocketDecoder());
p.AddBefore(ctx.Name, "wsencoder", this.NewWebSocketEncoder());
encoderName = ctx.Name;
}
else
{
p.Replace(ctx.Name, "wsdecoder", this.NewWebsocketDecoder());
encoderName = p.Context <HttpResponseEncoder>().Name;
p.AddBefore(encoderName, "wsencoder", this.NewWebSocketEncoder());
}
channel.WriteAndFlushAsync(response).ContinueWith(t =>
{
if (t.Status == TaskStatus.RanToCompletion)
{
p.Remove(encoderName);
completion.TryComplete();
}
else
{
completion.TrySetException(t.Exception);
}
});
}
protected override void ChannelRead0(IChannelHandlerContext ctx, IHttpMessage msg)
{
// If this handler is hit then no upgrade has been attempted and the client is just talking HTTP.
s_logger.LogInformation("Directly talking: " + msg.ProtocolVersion + " (no upgrade was attempted)");
IChannelPipeline pipeline = ctx.Pipeline;
pipeline.AddAfter(ctx.Name, null, new Http2Helloworld.Server.HelloWorldHttp1Handler("Direct. No Upgrade Attempted."));
pipeline.Replace(this, null, new HttpObjectAggregator(this.maxHttpContentLength));
ctx.FireChannelRead(ReferenceCountUtil.Retain(msg));
}
/// <summary>
/// Populates the channel pipeline in order to read data from a WebSocket connection.
/// </summary>
public static void populateWSPipeline(IChannel ch, IChannelHandler wsChHandler)
{
IChannelPipeline chPipeline = ch.Pipeline;
IChannelHandler reader = chPipeline.Get(READER_KEY);
if (reader == null)
{
/*
* there is no reader when the WebSocket channel is fresh,
* i.e the channel was filled by populateWSPipelineForHandshake()
*/
chPipeline.AddLast(READER_KEY, wsChHandler);
}
else
{
/*
* the old reader is the WebSocket channel handler used before the channel was released to the pool,
* i.e the channel was already filled by populateWSPipeline()
*/
chPipeline.Replace(READER_KEY, READER_KEY, wsChHandler);
}
}