Java 类io.netty.handler.codec.http.HttpClientUpgradeHandler 实例源码

/**
 * Configure the pipeline for a cleartext upgrade from HTTP to HTTP/2.
 */
private void configureClearText(SocketChannel ch) {
    HttpClientCodec sourceCodec = new HttpClientCodec();
    Http2ClientUpgradeCodec upgradeCodec = new Http2ClientUpgradeCodec(connectionHandler);
    HttpClientUpgradeHandler upgradeHandler = new HttpClientUpgradeHandler(sourceCodec, upgradeCodec, 65536);

    ch.pipeline().addLast(sourceCodec,
                          upgradeHandler,
                          new UpgradeRequestHandler(),
                          new UserEventLogger());
}

/**
 * Configure the pipeline for a cleartext upgrade from HTTP to HTTP/2.
 */
private void configureClearText(SocketChannel ch) {
    HttpClientCodec sourceCodec = new HttpClientCodec();
    Http2ClientUpgradeCodec upgradeCodec = new Http2ClientUpgradeCodec(connectionHandler);
    HttpClientUpgradeHandler upgradeHandler = new HttpClientUpgradeHandler(sourceCodec, upgradeCodec, 65536);

    ch.pipeline().addLast("Http2SourceCodec", sourceCodec);
    ch.pipeline().addLast("Http2UpgradeHandler", upgradeHandler);
    ch.pipeline().addLast("Http2UpgradeRequestHandler", new UpgradeRequestHandler());
    ch.pipeline().addLast("Logger", new UserEventLogger());
}

/**
 * Configure the pipeline for a cleartext upgrade from HTTP to HTTP/2.
 */
private void configureClearText(SocketChannel ch) {
    HttpClientCodec sourceCodec = new HttpClientCodec();
    Http2ClientUpgradeCodec upgradeCodec = new Http2ClientUpgradeCodec(connectionHandler);
    HttpClientUpgradeHandler upgradeHandler = new HttpClientUpgradeHandler(sourceCodec, upgradeCodec, 65536);

    ch.pipeline().addLast("Http2SourceCodec", sourceCodec);
    ch.pipeline().addLast("Http2UpgradeHandler", upgradeHandler);
    ch.pipeline().addLast("Http2UpgradeRequestHandler", new UpgradeRequestHandler());
    ch.pipeline().addLast("Logger", new UserEventLogger());
}

@Override
public void initChannel(SocketChannel ch) throws Exception {
    final ChannelPipeline p = ch.pipeline();
    final Http2Connection conn = new DefaultHttp2Connection(false);
    final HttpToHttp2ConnectionHandler connHandler = new HttpToHttp2ConnectionHandlerBuilder()
            .connection(conn)
            .frameListener(new DelegatingDecompressorFrameListener(
                    conn,
                    new InboundHttp2ToHttpAdapterBuilder(conn)
                            .maxContentLength(Integer.MAX_VALUE)
                            .propagateSettings(true).build()))
            .build();

    clientHandler = new THttp2ClientHandler(ch.eventLoop());

    if (sslCtx != null) {
        p.addLast(sslCtx.newHandler(p.channel().alloc()));
        p.addLast(connHandler);
        configureEndOfPipeline(p);
    } else {
        Http1ClientCodec sourceCodec = new Http1ClientCodec();
        HttpClientUpgradeHandler upgradeHandler = new HttpClientUpgradeHandler(
                sourceCodec, new Http2ClientUpgradeCodec(connHandler), 65536);

        p.addLast(sourceCodec, upgradeHandler, new UpgradeRequestHandler());
    }
}

/**
 * Configure the pipeline for a cleartext upgrade from HTTP to HTTP/2.
 */
private void configureClearText(SocketChannel ch) {
    HttpClientCodec sourceCodec = new HttpClientCodec();
    Http2ClientUpgradeCodec upgradeCodec = new Http2ClientUpgradeCodec(connectionHandler);
    HttpClientUpgradeHandler upgradeHandler = new HttpClientUpgradeHandler(sourceCodec, upgradeCodec, 65536);

    ch.pipeline().addLast(sourceCodec,
            upgradeHandler,
            new UpgradeRequestHandler(),
            new UserEventLogger());
}

@Override
public Handler newHandler(GrpcHttp2ConnectionHandler handler) {
  // Register the plaintext upgrader
  Http2ClientUpgradeCodec upgradeCodec = new Http2ClientUpgradeCodec(handler);
  HttpClientCodec httpClientCodec = new HttpClientCodec();
  final HttpClientUpgradeHandler upgrader =
      new HttpClientUpgradeHandler(httpClientCodec, upgradeCodec, 1000);
  return new BufferingHttp2UpgradeHandler(upgrader);
}

@Override
public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
  if (evt == HttpClientUpgradeHandler.UpgradeEvent.UPGRADE_SUCCESSFUL) {
    writeBufferedAndRemove(ctx);
  } else if (evt == HttpClientUpgradeHandler.UpgradeEvent.UPGRADE_REJECTED) {
    fail(ctx, unavailableException("HTTP/2 upgrade rejected"));
  }
  super.userEventTriggered(ctx, evt);
}

private void configureAsHttp(Channel ch) {
    final ChannelPipeline pipeline = ch.pipeline();
    pipeline.addLast(TrafficLoggingHandler.CLIENT);

    final boolean attemptUpgrade;
    switch (httpPreference) {
    case HTTP1_REQUIRED:
        attemptUpgrade = false;
        break;
    case HTTP2_PREFERRED:
        attemptUpgrade = !SessionProtocolNegotiationCache.isUnsupported(remoteAddress, H2C);
        break;
    case HTTP2_REQUIRED:
        attemptUpgrade = true;
        break;
    default:
        // Should never reach here.
        throw new Error();
    }

    if (attemptUpgrade) {
        final Http2ClientConnectionHandler http2Handler = newHttp2ConnectionHandler(ch);
        if (clientFactory.useHttp2Preface()) {
            pipeline.addLast(new DowngradeHandler());
            pipeline.addLast(http2Handler);
        } else {
            Http1ClientCodec http1Codec = newHttp1Codec(
                    clientFactory.maxHttp1InitialLineLength(),
                    clientFactory.maxHttp1HeaderSize(),
                    clientFactory.maxHttp1ChunkSize());
            Http2ClientUpgradeCodec http2ClientUpgradeCodec =
                    new Http2ClientUpgradeCodec(http2Handler);
            HttpClientUpgradeHandler http2UpgradeHandler =
                    new HttpClientUpgradeHandler(
                            http1Codec, http2ClientUpgradeCodec,
                            (int) Math.min(Integer.MAX_VALUE, UPGRADE_RESPONSE_MAX_LENGTH));

            pipeline.addLast(http1Codec);
            pipeline.addLast(new WorkaroundHandler());
            pipeline.addLast(http2UpgradeHandler);
            pipeline.addLast(new UpgradeRequestHandler(http2Handler.responseDecoder()));
        }
    } else {
        pipeline.addLast(newHttp1Codec(
                clientFactory.maxHttp1InitialLineLength(),
                clientFactory.maxHttp1HeaderSize(),
                clientFactory.maxHttp1ChunkSize()));

        // NB: We do not call finishSuccessfully() immediately here
        //     because it assumes HttpSessionHandler to be in the pipeline,
        //     which is only true after the connection attempt is successful.
        pipeline.addLast(new ChannelInboundHandlerAdapter() {
            @Override
            public void channelActive(ChannelHandlerContext ctx) throws Exception {
                ctx.pipeline().remove(this);
                finishSuccessfully(pipeline, H1C);
                ctx.fireChannelActive();
            }
        });
    }
}