Java 类io.netty.handler.codec.http2.DefaultHttp2FrameWriter 实例源码

private Http2ClientConnectionHandler newHttp2ConnectionHandler(Channel ch) {
    final boolean validateHeaders = false;
    final Http2Connection conn = new DefaultHttp2Connection(false);
    conn.addListener(new Http2GoAwayListener(ch));

    Http2FrameReader reader = new DefaultHttp2FrameReader(validateHeaders);
    Http2FrameWriter writer = new DefaultHttp2FrameWriter();

    Http2ConnectionEncoder encoder = new DefaultHttp2ConnectionEncoder(conn, writer);
    Http2ConnectionDecoder decoder = new DefaultHttp2ConnectionDecoder(conn, encoder, reader);

    final Http2Settings http2Settings = http2Settings();

    final Http2ResponseDecoder listener = new Http2ResponseDecoder(conn, ch, encoder);
    final Http2ClientConnectionHandler handler =
            new Http2ClientConnectionHandler(decoder, encoder, http2Settings, listener);
    // Setup post build options
    handler.gracefulShutdownTimeoutMillis(clientFactory.idleTimeoutMillis());

    return handler;
}

private Http2ConnectionHandler newHttp2ConnectionHandler(ChannelPipeline pipeline) {

        final Http2Connection conn = new DefaultHttp2Connection(true);
        conn.addListener(new Http2GoAwayListener(pipeline.channel()));

        Http2FrameReader reader = new DefaultHttp2FrameReader(true);
        Http2FrameWriter writer = new DefaultHttp2FrameWriter();

        Http2ConnectionEncoder encoder = new DefaultHttp2ConnectionEncoder(conn, writer);
        Http2ConnectionDecoder decoder = new DefaultHttp2ConnectionDecoder(conn, encoder, reader);

        final Http2ConnectionHandler handler =
                new Http2ServerConnectionHandler(decoder, encoder, new Http2Settings());

        // Setup post build options
        final Http2RequestDecoder listener =
                new Http2RequestDecoder(config, pipeline.channel(), handler.encoder());

        handler.connection().addListener(listener);
        handler.decoder().frameListener(listener);
        handler.gracefulShutdownTimeoutMillis(config.idleTimeoutMillis());

        return handler;
    }

protected ByteBuf grpcDataFrame(int streamId, boolean endStream, byte[] content) {
  final ByteBuf compressionFrame = Unpooled.buffer(content.length);
  TransportTracer noTransportTracer = null;
  MessageFramer framer = new MessageFramer(
      new MessageFramer.Sink() {
        @Override
        public void deliverFrame(
            WritableBuffer frame, boolean endOfStream, boolean flush, int numMessages) {
          if (frame != null) {
            ByteBuf bytebuf = ((NettyWritableBuffer) frame).bytebuf();
            compressionFrame.writeBytes(bytebuf);
          }
        }
      },
      new NettyWritableBufferAllocator(ByteBufAllocator.DEFAULT),
      StatsTraceContext.NOOP);
  framer.writePayload(new ByteArrayInputStream(content));
  framer.flush();
  ChannelHandlerContext ctx = newMockContext();
  new DefaultHttp2FrameWriter().writeData(ctx, streamId, compressionFrame, 0, endStream,
      newPromise());
  return captureWrite(ctx);
}

static NettyClientHandler newHandler(
    ClientTransportLifecycleManager lifecycleManager,
    @Nullable KeepAliveManager keepAliveManager,
    int flowControlWindow,
    int maxHeaderListSize,
    Supplier<Stopwatch> stopwatchFactory,
    Runnable tooManyPingsRunnable,
    TransportTracer transportTracer) {
  Preconditions.checkArgument(maxHeaderListSize > 0, "maxHeaderListSize must be positive");
  Http2HeadersDecoder headersDecoder = new GrpcHttp2ClientHeadersDecoder(maxHeaderListSize);
  Http2FrameReader frameReader = new DefaultHttp2FrameReader(headersDecoder);
  Http2FrameWriter frameWriter = new DefaultHttp2FrameWriter();
  Http2Connection connection = new DefaultHttp2Connection(false);
  WeightedFairQueueByteDistributor dist = new WeightedFairQueueByteDistributor(connection);
  dist.allocationQuantum(16 * 1024); // Make benchmarks fast again.
  DefaultHttp2RemoteFlowController controller =
      new DefaultHttp2RemoteFlowController(connection, dist);
  connection.remote().flowController(controller);

  return newHandler(
      connection,
      frameReader,
      frameWriter,
      lifecycleManager,
      keepAliveManager,
      flowControlWindow,
      maxHeaderListSize,
      stopwatchFactory,
      tooManyPingsRunnable,
      transportTracer);
}

/**
 * Must be called by subclasses to initialize the handler and channel.
 */
protected final void initChannel(Http2HeadersDecoder headersDecoder) throws Exception {
  content = Unpooled.copiedBuffer("hello world", UTF_8);
  frameWriter = mock(Http2FrameWriter.class, delegatesTo(new DefaultHttp2FrameWriter()));
  frameReader = new DefaultHttp2FrameReader(headersDecoder);

  channel = new FakeClockSupportedChanel();
  handler = newHandler();
  channel.pipeline().addLast(handler);
  ctx = channel.pipeline().context(handler);

  writeQueue = initWriteQueue();
}

protected final ByteBuf dataFrame(int streamId, boolean endStream, ByteBuf content) {
  // Need to retain the content since the frameWriter releases it.
  content.retain();

  ChannelHandlerContext ctx = newMockContext();
  new DefaultHttp2FrameWriter().writeData(ctx, streamId, content, 0, endStream, newPromise());
  return captureWrite(ctx);
}

protected final ByteBuf pingFrame(boolean ack, ByteBuf payload) {
  // Need to retain the content since the frameWriter releases it.
  payload.retain();

  ChannelHandlerContext ctx = newMockContext();
  new DefaultHttp2FrameWriter().writePing(ctx, ack, payload, newPromise());
  return captureWrite(ctx);
}

private static Http2FrameWriter frameWriter() {
  return new Http2OutboundFrameLogger(new DefaultHttp2FrameWriter(),
      FRAME_LOGGER);
}

private static Http2FrameWriter frameWriter() {
    return new Http2OutboundFrameLogger(new DefaultHttp2FrameWriter(), logger);
}

public HelloWorldHttp2Handler() {
    this(new DefaultHttp2Connection(true), new Http2InboundFrameLogger(
            new DefaultHttp2FrameReader(), logger), 
            new Http2OutboundFrameLogger(new DefaultHttp2FrameWriter(), logger), 
            new SimpleHttp2FrameListener());
}

static NettyServerHandler newHandler(
    ServerTransportListener transportListener,
    ChannelPromise channelUnused,
    List<ServerStreamTracer.Factory> streamTracerFactories,
    TransportTracer transportTracer,
    int maxStreams,
    int flowControlWindow,
    int maxHeaderListSize,
    int maxMessageSize,
    long keepAliveTimeInNanos,
    long keepAliveTimeoutInNanos,
    long maxConnectionIdleInNanos,
    long maxConnectionAgeInNanos,
    long maxConnectionAgeGraceInNanos,
    boolean permitKeepAliveWithoutCalls,
    long permitKeepAliveTimeInNanos) {
  Preconditions.checkArgument(maxHeaderListSize > 0, "maxHeaderListSize must be positive");
  Http2FrameLogger frameLogger = new Http2FrameLogger(LogLevel.DEBUG, NettyServerHandler.class);
  Http2HeadersDecoder headersDecoder = new GrpcHttp2ServerHeadersDecoder(maxHeaderListSize);
  Http2FrameReader frameReader = new Http2InboundFrameLogger(
      new DefaultHttp2FrameReader(headersDecoder), frameLogger);
  Http2FrameWriter frameWriter =
      new Http2OutboundFrameLogger(new DefaultHttp2FrameWriter(), frameLogger);
  return newHandler(
      channelUnused,
      frameReader,
      frameWriter,
      transportListener,
      streamTracerFactories,
      transportTracer,
      maxStreams,
      flowControlWindow,
      maxHeaderListSize,
      maxMessageSize,
      keepAliveTimeInNanos,
      keepAliveTimeoutInNanos,
      maxConnectionIdleInNanos,
      maxConnectionAgeInNanos,
      maxConnectionAgeGraceInNanos,
      permitKeepAliveWithoutCalls,
      permitKeepAliveTimeInNanos);
}

protected final ByteBuf headersFrame(int streamId, Http2Headers headers) {
  ChannelHandlerContext ctx = newMockContext();
  new DefaultHttp2FrameWriter().writeHeaders(ctx, streamId, headers, 0, false, newPromise());
  return captureWrite(ctx);
}

protected final ByteBuf goAwayFrame(int lastStreamId, int errorCode, ByteBuf data) {
  ChannelHandlerContext ctx = newMockContext();
  new DefaultHttp2FrameWriter().writeGoAway(ctx, lastStreamId, errorCode, data, newPromise());
  return captureWrite(ctx);
}

protected final ByteBuf rstStreamFrame(int streamId, int errorCode) {
  ChannelHandlerContext ctx = newMockContext();
  new DefaultHttp2FrameWriter().writeRstStream(ctx, streamId, errorCode, newPromise());
  return captureWrite(ctx);
}

protected final ByteBuf serializeSettings(Http2Settings settings) {
  ChannelHandlerContext ctx = newMockContext();
  new DefaultHttp2FrameWriter().writeSettings(ctx, settings, newPromise());
  return captureWrite(ctx);
}

protected final ByteBuf windowUpdate(int streamId, int delta) {
  ChannelHandlerContext ctx = newMockContext();
  new DefaultHttp2FrameWriter().writeWindowUpdate(ctx, 0, delta, newPromise());
  return captureWrite(ctx);
}