Package io.netty.handler.codec.http2

Class Http2FrameCodec

java.lang.Object

io.netty.channel.ChannelHandlerAdapter

io.netty.channel.ChannelInboundHandlerAdapter

io.netty.handler.codec.ByteToMessageDecoder

io.netty.handler.codec.http2.Http2ConnectionHandler

io.netty.handler.codec.http2.Http2FrameCodec

All Implemented Interfaces:

ChannelHandler, ChannelInboundHandler, ChannelOutboundHandler, Http2LifecycleManager

Direct Known Subclasses:

Http2MultiplexCodec

public class Http2FrameCodec
extends Http2ConnectionHandler

This API is very immature. The Http2Connection-based API is currently preferred over this API. This API is targeted to eventually replace or reduce the need for the Http2ConnectionHandler API.

An HTTP/2 handler that maps HTTP/2 frames to Http2Frame objects and vice versa. For every incoming HTTP/2 frame, an Http2Frame object is created and propagated via ByteToMessageDecoder.channelRead(io.netty.channel.ChannelHandlerContext, java.lang.Object). Outbound Http2Frame objects received via write(io.netty.channel.ChannelHandlerContext, java.lang.Object, io.netty.channel.ChannelPromise) are converted to the HTTP/2 wire format. HTTP/2 frames specific to a stream implement the Http2StreamFrame interface. The Http2FrameCodec is instantiated using the Http2FrameCodecBuilder. It's recommended for channel handlers to inherit from the Http2ChannelDuplexHandler, as it provides additional functionality like iterating over all active streams or creating outbound streams.

Stream Lifecycle

The frame codec delivers and writes frames for active streams. An active stream is closed when either side sends a RST_STREAM frame or both sides send a frame with the END_STREAM flag set. Each Http2StreamFrame has a Http2FrameStream object attached that uniquely identifies a particular stream.

Http2StreamFrames read from the channel always a Http2FrameStream object set, while when writing a Http2StreamFrame the application code needs to set a Http2FrameStream object using Http2StreamFrame.stream(Http2FrameStream).

Flow control

The frame codec automatically increments stream and connection flow control windows.

Incoming flow controlled frames need to be consumed by writing a Http2WindowUpdateFrame with the consumed number of bytes and the corresponding stream identifier set to the frame codec.

The local stream-level flow control window can be changed by writing a Http2SettingsFrame with the Http2Settings.initialWindowSize() set to the targeted value.

The connection-level flow control window can be changed by writing a Http2WindowUpdateFrame with the desired window size increment in bytes and the stream identifier set to 0. By default the initial connection-level flow control window is the same as initial stream-level flow control window.

New inbound Streams

The first frame of an HTTP/2 stream must be an Http2HeadersFrame, which will have an Http2FrameStream object attached.

New outbound Streams

A outbound HTTP/2 stream can be created by first instantiating a new Http2FrameStream object via Http2ChannelDuplexHandler.newStream(), and then writing a Http2HeadersFrame object with the stream attached.

 {@code
     final Http2Stream2 stream = handler.newStream();
     ctx.write(headersFrame.stream(stream)).addListener(new ChannelFutureListener() {

Nested Class Summary

Nested classes/interfaces inherited from class io.netty.handler.codec.ByteToMessageDecoder

ByteToMessageDecoder.Cumulator

Nested classes/interfaces inherited from interface io.netty.channel.ChannelHandler

ChannelHandler.Sharable

Field Summary

Fields

Modifier and Type	Field	Description
protected Http2Connection.PropertyKey	streamKey

Fields inherited from class io.netty.handler.codec.ByteToMessageDecoder

COMPOSITE_CUMULATOR, MERGE_CUMULATOR

Constructor Summary

Constructors

Modifier	Constructor	Description
protected	Http2FrameCodec(Http2ConnectionEncoder encoder, Http2ConnectionDecoder decoder, Http2Settings initialSettings, boolean decoupleCloseAndGoAway, boolean flushPreface)

Method Summary

Modifier and Type	Method	Description
void	handlerAdded(ChannelHandlerContext ctx)	Do nothing by default, sub-classes may override this method.
protected boolean	isGracefulShutdownComplete()	Called by the graceful shutdown logic to determine when it is safe to close the connection.
protected Http2StreamFrame	newHttp2UnknownFrame(byte frameType, int streamId, Http2Flags flags, ByteBuf payload)	Create a Http2UnknownFrame.
protected void	onConnectionError(ChannelHandlerContext ctx, boolean outbound, java.lang.Throwable cause, Http2Exception http2Ex)	Handler for a connection error.
protected void	onStreamError(ChannelHandlerContext ctx, boolean outbound, java.lang.Throwable cause, Http2Exception.StreamException streamException)	Exceptions for unknown streams, that is streams that have no Http2FrameStream object attached are simply logged and replied to by sending a RST_STREAM frame.
void	userEventTriggered(ChannelHandlerContext ctx, java.lang.Object evt)	Handles the cleartext HTTP upgrade event.
void	write(ChannelHandlerContext ctx, java.lang.Object msg, ChannelPromise promise)	Processes all Http2Frames.

Methods inherited from class io.netty.handler.codec.http2.Http2ConnectionHandler

bind, channelActive, channelInactive, channelReadComplete, channelWritabilityChanged, close, closeStream, closeStreamLocal, closeStreamRemote, connect, connection, decode, decoder, deregister, disconnect, encoder, exceptionCaught, flush, frameWriter, goAway, gracefulShutdownTimeoutMillis, gracefulShutdownTimeoutMillis, handlerRemoved0, handleServerHeaderDecodeSizeError, onError, onHttpClientUpgrade, onHttpServerUpgrade, read, resetStream

Methods inherited from class io.netty.handler.codec.ByteToMessageDecoder

actualReadableBytes, callDecode, channelRead, decodeLast, discardSomeReadBytes, handlerRemoved, internalBuffer, isSingleDecode, setCumulator, setDiscardAfterReads, setSingleDecode

Methods inherited from class io.netty.channel.ChannelInboundHandlerAdapter

channelRegistered, channelUnregistered

Methods inherited from class io.netty.channel.ChannelHandlerAdapter

ensureNotSharable, isSharable

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface io.netty.channel.ChannelHandler

handlerRemoved

Field Detail

streamKey

protected final Http2Connection.PropertyKey streamKey

Constructor Detail

Http2FrameCodec

protected Http2FrameCodec(Http2ConnectionEncoder encoder,
                          Http2ConnectionDecoder decoder,
                          Http2Settings initialSettings,
                          boolean decoupleCloseAndGoAway,
                          boolean flushPreface)

Method Detail

handlerAdded

public final void handlerAdded(ChannelHandlerContext ctx)
                        throws java.lang.Exception

Description copied from class: ChannelHandlerAdapter

Do nothing by default, sub-classes may override this method.

Specified by:

handlerAdded in interface ChannelHandler

Overrides:

handlerAdded in class Http2ConnectionHandler

Throws:

java.lang.Exception

userEventTriggered

public final void userEventTriggered(ChannelHandlerContext ctx,
                                     java.lang.Object evt)
                              throws java.lang.Exception

Handles the cleartext HTTP upgrade event. If an upgrade occurred, sends a simple response via HTTP/2 on stream 1 (the stream specifically reserved for cleartext HTTP upgrade).

Specified by:

userEventTriggered in interface ChannelInboundHandler

Overrides:

userEventTriggered in class ByteToMessageDecoder

Throws:

java.lang.Exception

write

public void write(ChannelHandlerContext ctx,
                  java.lang.Object msg,
                  ChannelPromise promise)

Processes all Http2Frames. Http2StreamFrames may only originate in child streams.

Specified by:

write in interface ChannelOutboundHandler

Overrides:

write in class Http2ConnectionHandler

Parameters:

ctx - the ChannelHandlerContext for which the write operation is made

msg - the message to write

promise - the ChannelPromise to notify once the operation completes

onConnectionError

protected void onConnectionError(ChannelHandlerContext ctx,
                                 boolean outbound,
                                 java.lang.Throwable cause,
                                 Http2Exception http2Ex)

Description copied from class: Http2ConnectionHandler

Handler for a connection error. Sends a GO_AWAY frame to the remote endpoint. Once all streams are closed, the connection is shut down.

Overrides:

onConnectionError in class Http2ConnectionHandler

Parameters:

ctx - the channel context

outbound - true if the error was caused by an outbound operation.

cause - the exception that was caught

http2Ex - the Http2Exception that is embedded in the causality chain. This may be null if it's an unknown exception.

onStreamError

protected final void onStreamError(ChannelHandlerContext ctx,
                                   boolean outbound,
                                   java.lang.Throwable cause,
                                   Http2Exception.StreamException streamException)

Exceptions for unknown streams, that is streams that have no Http2FrameStream object attached are simply logged and replied to by sending a RST_STREAM frame.

Overrides:

onStreamError in class Http2ConnectionHandler

Parameters:

ctx - the channel context

outbound - true if the error was caused by an outbound operation.

cause - the exception that was caught

streamException - the Http2Exception.StreamException that is embedded in the causality chain.

isGracefulShutdownComplete

protected final boolean isGracefulShutdownComplete()

Description copied from class: Http2ConnectionHandler

Called by the graceful shutdown logic to determine when it is safe to close the connection. Returns true if the graceful shutdown has completed and the connection can be safely closed. This implementation just guarantees that there are no active streams. Subclasses may override to provide additional checks.

Overrides:

isGracefulShutdownComplete in class Http2ConnectionHandler

newHttp2UnknownFrame

protected Http2StreamFrame newHttp2UnknownFrame(byte frameType,
                                                int streamId,
                                                Http2Flags flags,
                                                ByteBuf payload)

Create a Http2UnknownFrame. The ownership of the ByteBuf is transferred.