com.twitter.http2.HttpConnectionHandler Maven / Gradle / Ivy

Go to download
/*
 * Copyright 2015 Twitter, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.twitter.http2;

import java.io.IOException;
import java.net.SocketAddress;
import java.nio.channels.ClosedChannelException;
import java.util.List;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelOutboundHandler;
import io.netty.channel.ChannelPromise;
import io.netty.handler.codec.ByteToMessageDecoder;
import io.netty.util.internal.EmptyArrays;

import static com.twitter.http2.HttpCodecUtil.HTTP_CONNECTION_STREAM_ID;
import static com.twitter.http2.HttpCodecUtil.isServerId;

/**
 * Manages streams within an HTTP/2 connection.
 */
public class HttpConnectionHandler extends ByteToMessageDecoder
        implements HttpFrameDecoderDelegate, ChannelOutboundHandler {

    private static final HttpProtocolException PROTOCOL_EXCEPTION =
            new HttpProtocolException();

    static {
        PROTOCOL_EXCEPTION.setStackTrace(EmptyArrays.EMPTY_STACK_TRACE);
    }

    private static final HttpSettingsFrame SETTINGS_ACK_FRAME =
            new DefaultHttpSettingsFrame().setAck(true);

    private static final int DEFAULT_HEADER_TABLE_SIZE = 4096;

    private static final int DEFAULT_WINDOW_SIZE = 65535;
    private int initialSendWindowSize = DEFAULT_WINDOW_SIZE;
    private int initialReceiveWindowSize = DEFAULT_WINDOW_SIZE;
    private volatile int initialConnectionReceiveWindowSize = DEFAULT_WINDOW_SIZE;

    private final HttpConnection httpConnection =
            new HttpConnection(initialSendWindowSize, initialReceiveWindowSize);
    private int lastStreamId;

    private static final int DEFAULT_MAX_CONCURRENT_STREAMS = Integer.MAX_VALUE;
    private int remoteConcurrentStreams = DEFAULT_MAX_CONCURRENT_STREAMS;
    private int localConcurrentStreams = DEFAULT_MAX_CONCURRENT_STREAMS;

    private boolean sentGoAwayFrame;
    private boolean receivedGoAwayFrame;

    private final ChannelFutureListener connectionErrorListener =
            new ConnectionErrorFutureListener();
    private ChannelFutureListener closingChannelFutureListener;

    private final boolean server;
    private final boolean handleStreamWindowUpdates;

    private final HttpFrameDecoder httpFrameDecoder;
    private final HttpFrameEncoder httpFrameEncoder;
    private final HttpHeaderBlockDecoder httpHeaderBlockDecoder;
    private final HttpHeaderBlockEncoder httpHeaderBlockEncoder;

    private HttpHeaderBlockFrame httpHeaderBlockFrame;
    private HttpSettingsFrame httpSettingsFrame;

    private boolean needSettingsAck;

    private boolean changeDecoderHeaderTableSize;
    private int headerTableSize;

    private boolean changeEncoderHeaderTableSize;
    private int lastHeaderTableSize = Integer.MAX_VALUE;
    private int minHeaderTableSize = Integer.MAX_VALUE;
    private boolean pushEnabled = true;

    private ChannelHandlerContext context;

    /**
     * Creates a new connection handler.
     *
     * @param server {@code true} if and only if this connection handler should
     *               handle the server endpoint of the connection.
     *               {@code false} if and only if this connection handler should
     *               handle the client endpoint of the connection.
     */
    public HttpConnectionHandler(boolean server) {
        this(server, true);
    }

    /**
     * Creates a new connection handler with the specified options.
     */
    public HttpConnectionHandler(boolean server, boolean handleStreamWindowUpdates) {
        this(server, handleStreamWindowUpdates, 8192, 16384);
    }

    /**
     * Creates a new connection handler with the specified options.
     */
    public HttpConnectionHandler(boolean server, int maxChunkSize, int maxHeaderSize) {
        this(server, true, maxChunkSize, maxHeaderSize);
    }

    /**
     * Creates a new connection handler with the specified options.
     */
    public HttpConnectionHandler(
            boolean server, boolean handleStreamWindowUpdates, int maxChunkSize, int maxHeaderSize) {
        this.server = server;
        this.handleStreamWindowUpdates = handleStreamWindowUpdates;
        httpFrameDecoder = new HttpFrameDecoder(server, this, maxChunkSize);
        httpFrameEncoder = new HttpFrameEncoder();
        httpHeaderBlockDecoder = new HttpHeaderBlockDecoder(maxHeaderSize, DEFAULT_HEADER_TABLE_SIZE);
        httpHeaderBlockEncoder = new HttpHeaderBlockEncoder(DEFAULT_HEADER_TABLE_SIZE);
    }

    public void setConnectionReceiveWindowSize(int connectionReceiveWindowSize) {
      if (connectionReceiveWindowSize < 0) {
          throw new IllegalArgumentException("connectionReceiveWindowSize");
      }
      // This will not send a window update frame immediately.
      // If this value increases the allowed receive window size,
      // a WINDOW_UPDATE frame will be sent when only half of the
      // session window size remains during data frame processing.
      // If this value decreases the allowed receive window size,
      // the window will be reduced as data frames are processed.
      initialConnectionReceiveWindowSize = connectionReceiveWindowSize;
    }

    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
        super.handlerAdded(ctx);
        context = ctx;
    }

    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List