Package io.grpc.netty

Class NettyClientHandler

  • All Implemented Interfaces:
    io.netty.channel.ChannelHandler, io.netty.channel.ChannelInboundHandler, io.netty.channel.ChannelOutboundHandler, io.netty.handler.codec.http2.Http2LifecycleManager

    class NettyClientHandler
    extends AbstractNettyHandler
    Client-side Netty handler for GRPC processing. All event handlers are executed entirely within the context of the Netty Channel thread.
    • Field Detail

      • logger

        private static final java.util.logging.Logger logger
      • NOOP_MESSAGE

        static final java.lang.Object NOOP_MESSAGE
        A message that simply passes through the channel without any real processing. It is useful to check if buffers have been drained and test the health of the channel in a single operation.
      • EXHAUSTED_STREAMS_STATUS

        private static final Status EXHAUSTED_STREAMS_STATUS
        Status used when the transport has exhausted the number of streams.
      • streamKey

        private final io.netty.handler.codec.http2.Http2Connection.PropertyKey streamKey
      • stopwatchFactory

        private final com.google.common.base.Supplier<com.google.common.base.Stopwatch> stopwatchFactory
      • eagAttributes

        private final Attributes eagAttributes
      • authority

        private final java.lang.String authority
      • inUseState

        private final InUseStateAggregator<io.netty.handler.codec.http2.Http2Stream> inUseState
      • clientWriteQueue

        private WriteQueue clientWriteQueue
      • abruptGoAwayStatus

        private Status abruptGoAwayStatus
      • channelInactiveReason

        private Status channelInactiveReason
    • Constructor Detail

      • NettyClientHandler

        private NettyClientHandler​(io.netty.handler.codec.http2.Http2ConnectionDecoder decoder,
                                   io.netty.handler.codec.http2.Http2ConnectionEncoder encoder,
                                   io.netty.handler.codec.http2.Http2Settings settings,
                                   ChannelLogger negotiationLogger,
                                   ClientTransportLifecycleManager lifecycleManager,
                                   KeepAliveManager keepAliveManager,
                                   com.google.common.base.Supplier<com.google.common.base.Stopwatch> stopwatchFactory,
                                   java.lang.Runnable tooManyPingsRunnable,
                                   TransportTracer transportTracer,
                                   Attributes eagAttributes,
                                   java.lang.String authority,
                                   boolean autoFlowControl,
                                   AbstractNettyHandler.PingLimiter pingLimiter,
                                   com.google.common.base.Ticker ticker)
    • Method Detail

      • newHandler

        static NettyClientHandler newHandler​(ClientTransportLifecycleManager lifecycleManager,
                                             @Nullable
                                             KeepAliveManager keepAliveManager,
                                             boolean autoFlowControl,
                                             int flowControlWindow,
                                             int maxHeaderListSize,
                                             com.google.common.base.Supplier<com.google.common.base.Stopwatch> stopwatchFactory,
                                             java.lang.Runnable tooManyPingsRunnable,
                                             TransportTracer transportTracer,
                                             Attributes eagAttributes,
                                             java.lang.String authority,
                                             ChannelLogger negotiationLogger,
                                             com.google.common.base.Ticker ticker)
      • newHandler

        static NettyClientHandler newHandler​(io.netty.handler.codec.http2.Http2Connection connection,
                                             io.netty.handler.codec.http2.Http2FrameReader frameReader,
                                             io.netty.handler.codec.http2.Http2FrameWriter frameWriter,
                                             ClientTransportLifecycleManager lifecycleManager,
                                             KeepAliveManager keepAliveManager,
                                             boolean autoFlowControl,
                                             int flowControlWindow,
                                             int maxHeaderListSize,
                                             com.google.common.base.Supplier<com.google.common.base.Stopwatch> stopwatchFactory,
                                             java.lang.Runnable tooManyPingsRunnable,
                                             TransportTracer transportTracer,
                                             Attributes eagAttributes,
                                             java.lang.String authority,
                                             ChannelLogger negotiationLogger,
                                             com.google.common.base.Ticker ticker)
      • getAttributes

        Attributes getAttributes()
        The protocol negotiation attributes, available once the protocol negotiation completes; otherwise returns Attributes.EMPTY.
      • write

        public void write​(io.netty.channel.ChannelHandlerContext ctx,
                          java.lang.Object msg,
                          io.netty.channel.ChannelPromise promise)
                   throws java.lang.Exception
        Handler for commands sent from the stream.
        Specified by:
        write in interface io.netty.channel.ChannelOutboundHandler
        Overrides:
        write in class io.netty.handler.codec.http2.Http2ConnectionHandler
        Throws:
        java.lang.Exception
      • startWriteQueue

        void startWriteQueue​(io.netty.channel.Channel channel)
      • returnProcessedBytes

        void returnProcessedBytes​(io.netty.handler.codec.http2.Http2Stream stream,
                                  int bytes)
        Returns the given processed bytes back to inbound flow control.
      • onHeadersRead

        private void onHeadersRead​(int streamId,
                                   io.netty.handler.codec.http2.Http2Headers headers,
                                   boolean endStream)
      • onDataRead

        private void onDataRead​(int streamId,
                                io.netty.buffer.ByteBuf data,
                                int padding,
                                boolean endOfStream)
        Handler for an inbound HTTP/2 DATA frame.
      • onRstStreamRead

        private void onRstStreamRead​(int streamId,
                                     long errorCode)
        Handler for an inbound HTTP/2 RST_STREAM frame, terminating a stream.
      • close

        public void close​(io.netty.channel.ChannelHandlerContext ctx,
                          io.netty.channel.ChannelPromise promise)
                   throws java.lang.Exception
        Specified by:
        close in interface io.netty.channel.ChannelOutboundHandler
        Overrides:
        close in class io.netty.handler.codec.http2.Http2ConnectionHandler
        Throws:
        java.lang.Exception
      • channelInactive

        public void channelInactive​(io.netty.channel.ChannelHandlerContext ctx)
                             throws java.lang.Exception
        Handler for the Channel shutting down.
        Specified by:
        channelInactive in interface io.netty.channel.ChannelInboundHandler
        Overrides:
        channelInactive in class io.netty.handler.codec.http2.Http2ConnectionHandler
        Throws:
        java.lang.Exception
      • writeBufferingAndRemove

        static void writeBufferingAndRemove​(io.netty.channel.Channel channel)
      • onConnectionError

        protected void onConnectionError​(io.netty.channel.ChannelHandlerContext ctx,
                                         boolean outbound,
                                         java.lang.Throwable cause,
                                         io.netty.handler.codec.http2.Http2Exception http2Ex)
        Overrides:
        onConnectionError in class io.netty.handler.codec.http2.Http2ConnectionHandler
      • onStreamError

        protected void onStreamError​(io.netty.channel.ChannelHandlerContext ctx,
                                     boolean outbound,
                                     java.lang.Throwable cause,
                                     io.netty.handler.codec.http2.Http2Exception.StreamException http2Ex)
        Overrides:
        onStreamError in class io.netty.handler.codec.http2.Http2ConnectionHandler
      • isGracefulShutdownComplete

        protected boolean isGracefulShutdownComplete()
        Overrides:
        isGracefulShutdownComplete in class io.netty.handler.codec.http2.Http2ConnectionHandler
      • createStream

        private void createStream​(CreateStreamCommand command,
                                  io.netty.channel.ChannelPromise promise)
                           throws java.lang.Exception
        Attempts to create a new stream from the given command. If there are too many active streams, the creation request is queued.
        Throws:
        java.lang.Exception
      • createStreamTraced

        private void createStreamTraced​(int streamId,
                                        NettyClientStream.TransportState stream,
                                        io.netty.handler.codec.http2.Http2Headers headers,
                                        boolean isGet,
                                        boolean shouldBeCountedForInUse,
                                        io.netty.channel.ChannelPromise promise)
      • cancelStream

        private void cancelStream​(io.netty.channel.ChannelHandlerContext ctx,
                                  CancelClientStreamCommand cmd,
                                  io.netty.channel.ChannelPromise promise)
        Cancels this stream.
      • sendGrpcFrame

        private void sendGrpcFrame​(io.netty.channel.ChannelHandlerContext ctx,
                                   SendGrpcFrameCommand cmd,
                                   io.netty.channel.ChannelPromise promise)
        Sends the given GRPC frame for the stream.
      • sendPingFrame

        private void sendPingFrame​(io.netty.channel.ChannelHandlerContext ctx,
                                   SendPingCommand msg,
                                   io.netty.channel.ChannelPromise promise)
      • sendPingFrameTraced

        private void sendPingFrameTraced​(io.netty.channel.ChannelHandlerContext ctx,
                                         SendPingCommand msg,
                                         io.netty.channel.ChannelPromise promise)
        Sends a PING frame. If a ping operation is already outstanding, the callback in the message is registered to be called when the existing operation completes, and no new frame is sent.
      • gracefulClose

        private void gracefulClose​(io.netty.channel.ChannelHandlerContext ctx,
                                   GracefulCloseCommand msg,
                                   io.netty.channel.ChannelPromise promise)
                            throws java.lang.Exception
        Throws:
        java.lang.Exception
      • forcefulClose

        private void forcefulClose​(io.netty.channel.ChannelHandlerContext ctx,
                                   ForcefulCloseCommand msg,
                                   io.netty.channel.ChannelPromise promise)
                            throws java.lang.Exception
        Throws:
        java.lang.Exception
      • goingAway

        private void goingAway​(long errorCode,
                               byte[] debugData)
        Handler for a GOAWAY being received. Fails any streams created after the last known stream. May only be called during a read.
      • cancelPing

        private void cancelPing​(java.lang.Throwable t)
      • statusFromH2Error

        private Status statusFromH2Error​(Status.Code statusCode,
                                         java.lang.String context,
                                         long errorCode,
                                         byte[] debugData)
        If statusCode is non-null, it will be used instead of the http2 error code mapping.
      • clientStream

        private NettyClientStream.TransportState clientStream​(io.netty.handler.codec.http2.Http2Stream stream)
        Gets the client stream associated to the given HTTP/2 stream object.
      • requireHttp2Stream

        private io.netty.handler.codec.http2.Http2Stream requireHttp2Stream​(int streamId)