io.netty.handler.codec.http2

Class Http2FrameCodec

java.lang.Object

io.netty.channel.ChannelHandlerAdapter

io.netty.channel.ChannelInboundHandlerAdapter

io.netty.channel.ChannelDuplexHandler

io.netty.handler.codec.http2.Http2FrameCodec

All Implemented Interfaces:

ChannelHandler, ChannelInboundHandler, ChannelOutboundHandler

@UnstableApi
public class Http2FrameCodec
extends ChannelDuplexHandler

An HTTP/2 handler that maps HTTP/2 frames to Http2Frame objects and vice versa. For every incoming HTTP/2 frame a Http2Frame object is created and propagated via ChannelInboundHandlerAdapter.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.

A change in stream state is propagated through the channel pipeline as a user event via Http2StreamStateEvent objects. When a HTTP/2 stream first becomes active a Http2StreamActiveEvent and when it gets closed a Http2StreamClosedEvent is emitted.

Server-side HTTP to HTTP/2 upgrade is supported in conjunction with Http2ServerUpgradeCodec; the necessary HTTP-to-HTTP/2 conversion is performed automatically.

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 Http2Connection-based API.

Opening and Closing Streams

When the remote side opens a new stream, the frame codec first emits a Http2StreamActiveEvent with the stream identifier set.

 Http2FrameCodec                                     Http2MultiplexCodec
        +                                                             +
        |         Http2StreamActiveEvent(streamId=3, headers=null)    |
        +------------------------------------------------------------->
        |                                                             |
        |         Http2HeadersFrame(streamId=3)                       |
        +------------------------------------------------------------->
        |                                                             |
        +                                                             +
 

When a stream is closed either due to a reset frame by the remote side, or due to both sides having sent frames with the END_STREAM flag, then the frame codec emits a Http2StreamClosedEvent.

 Http2FrameCodec                                 Http2MultiplexCodec
        +                                                         +
        |         Http2StreamClosedEvent(streamId=3)              |
        +--------------------------------------------------------->
        |                                                         |
        +                                                         +
 

When the local side wants to close a stream, it has to write a Http2ResetFrame to which the frame codec will respond to with a Http2StreamClosedEvent.

 Http2FrameCodec                                 Http2MultiplexCodec
        +                                                         +
        |         Http2ResetFrame(streamId=3)                     |
        <---------------------------------------------------------+
        |                                                         |
        |         Http2StreamClosedEvent(streamId=3)              |
        +--------------------------------------------------------->
        |                                                         |
        +                                                         +
 

Opening an outbound/local stream works by first sending the frame codec a Http2HeadersFrame with no stream identifier set (such that Http2CodecUtil.isStreamIdValid(int) returns false). If opening the stream was successful, the frame codec responds with a Http2StreamActiveEvent that contains the stream's new identifier as well as the same Http2HeadersFrame object that opened the stream.

 Http2FrameCodec                                                                  Http2MultiplexCodec
        +                                                                                               +
        |         Http2HeadersFrame(streamId=-1)                                                        |
        <-----------------------------------------------------------------------------------------------+
        |                                                                                               |
        |         Http2StreamActiveEvent(streamId=2, headers=Http2HeadersFrame(streamId=-1))            |
        +----------------------------------------------------------------------------------------------->
        |                                                                                               |
        +                                                                                               +
 

Nested Class Summary

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

ChannelHandler.Sharable

Constructor Summary

Constructors

Constructor and Description
Http2FrameCodec(boolean server) Construct a new handler.
Http2FrameCodec(boolean server, Http2FrameLogger frameLogger) Construct a new handler.

Method Summary

Methods

Modifier and Type	Method and Description
void	exceptionCaught(ChannelHandlerContext ctx, Throwable cause) Calls ChannelHandlerContext.fireExceptionCaught(Throwable) to forward to the next ChannelHandler in the ChannelPipeline.
void	handlerAdded(ChannelHandlerContext ctx) Load any dependencies.
void	handlerRemoved(ChannelHandlerContext ctx) Clean up any dependencies.
void	userEventTriggered(ChannelHandlerContext ctx, Object evt) Handles the cleartext HTTP upgrade event.
void	write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) Processes all Http2Frames.

Methods inherited from class io.netty.channel.ChannelDuplexHandler

bind, close, connect, deregister, disconnect, flush, read

Methods inherited from class io.netty.channel.ChannelInboundHandlerAdapter

channelActive, channelInactive, channelRead, channelReadComplete, channelRegistered, channelUnregistered, channelWritabilityChanged

Methods inherited from class io.netty.channel.ChannelHandlerAdapter

isSharable

Methods inherited from class java.lang.Object

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

Constructor Detail

Http2FrameCodec

public Http2FrameCodec(boolean server)

Construct a new handler.

Parameters:

server - true this is a server

Http2FrameCodec

public Http2FrameCodec(boolean server,
               Http2FrameLogger frameLogger)

Construct a new handler.

Parameters:

server - true this is a server

Method Detail

handlerAdded

public void handlerAdded(ChannelHandlerContext ctx)
                  throws Exception

Load any dependencies.

Specified by:

handlerAdded in interface ChannelHandler

Overrides:

handlerAdded in class ChannelHandlerAdapter

Throws:

Exception

handlerRemoved

public void handlerRemoved(ChannelHandlerContext ctx)
                    throws Exception

Clean up any dependencies.

Specified by:

handlerRemoved in interface ChannelHandler

Overrides:

handlerRemoved in class ChannelHandlerAdapter

Throws:

Exception

userEventTriggered

public void userEventTriggered(ChannelHandlerContext ctx,
                      Object evt)
                        throws 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 ChannelInboundHandlerAdapter

Throws:

Exception

exceptionCaught

public void exceptionCaught(ChannelHandlerContext ctx,
                   Throwable cause)

Description copied from class: ChannelInboundHandlerAdapter

Calls ChannelHandlerContext.fireExceptionCaught(Throwable) to forward to the next ChannelHandler in the ChannelPipeline. Sub-classes may override this method to change behavior.

Specified by:

exceptionCaught in interface ChannelHandler

Specified by:

exceptionCaught in interface ChannelInboundHandler

Overrides:

exceptionCaught in class ChannelInboundHandlerAdapter

write

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

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

Specified by:

write in interface ChannelOutboundHandler

Overrides:

write in class ChannelDuplexHandler

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