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:

io.netty.channel.ChannelHandler, io.netty.channel.ChannelInboundHandler, io.netty.channel.ChannelOutboundHandler

@UnstableApi
public class Http2FrameCodec
extends io.netty.channel.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

io.netty.channel.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(io.netty.channel.ChannelHandlerContext ctx, Throwable cause)
void	handlerAdded(io.netty.channel.ChannelHandlerContext ctx) Load any dependencies.
void	handlerRemoved(io.netty.channel.ChannelHandlerContext ctx) Clean up any dependencies.
void	userEventTriggered(io.netty.channel.ChannelHandlerContext ctx, Object evt) Handles the cleartext HTTP upgrade event.
void	write(io.netty.channel.ChannelHandlerContext ctx, Object msg, io.netty.channel.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(io.netty.channel.ChannelHandlerContext ctx)
                  throws Exception

Load any dependencies.

Specified by:

handlerAdded in interface io.netty.channel.ChannelHandler

Overrides:

handlerAdded in class io.netty.channel.ChannelHandlerAdapter

Throws:

Exception

handlerRemoved

public void handlerRemoved(io.netty.channel.ChannelHandlerContext ctx)
                    throws Exception

Clean up any dependencies.

Specified by:

handlerRemoved in interface io.netty.channel.ChannelHandler

Overrides:

handlerRemoved in class io.netty.channel.ChannelHandlerAdapter

Throws:

Exception

userEventTriggered

public void userEventTriggered(io.netty.channel.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 io.netty.channel.ChannelInboundHandler

Overrides:

userEventTriggered in class io.netty.channel.ChannelInboundHandlerAdapter

Throws:

Exception

exceptionCaught

public void exceptionCaught(io.netty.channel.ChannelHandlerContext ctx,
                   Throwable cause)

Specified by:

exceptionCaught in interface io.netty.channel.ChannelHandler

Specified by:

exceptionCaught in interface io.netty.channel.ChannelInboundHandler

Overrides:

exceptionCaught in class io.netty.channel.ChannelInboundHandlerAdapter

write

public void write(io.netty.channel.ChannelHandlerContext ctx,
         Object msg,
         io.netty.channel.ChannelPromise promise)

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

Specified by:

write in interface io.netty.channel.ChannelOutboundHandler

Overrides:

write in class io.netty.channel.ChannelDuplexHandler