Package io.grpc.internal

Class RetriableStream<ReqT>

    • Field Detail

      • GRPC_PREVIOUS_RPC_ATTEMPTS

        static final Metadata.Key<java.lang.String> GRPC_PREVIOUS_RPC_ATTEMPTS

      • GRPC_RETRY_PUSHBACK_MS

        static final Metadata.Key<java.lang.String> GRPC_RETRY_PUSHBACK_MS

      • CANCELLED_BECAUSE_COMMITTED

        private static final Status CANCELLED_BECAUSE_COMMITTED

      • callExecutor

        private final java.util.concurrent.Executor callExecutor

      • listenerSerializeExecutor

        private final java.util.concurrent.Executor listenerSerializeExecutor

      • scheduledExecutorService

        private final java.util.concurrent.ScheduledExecutorService scheduledExecutorService

      • headers

        private final Metadata headers

      • retryPolicy

        @Nullable
private final RetryPolicy retryPolicy

      • hedgingPolicy

        @Nullable
private final HedgingPolicy hedgingPolicy

      • isHedging

        private final boolean isHedging

      • lock

        private final java.lang.Object lock
        Must be held when updating state, accessing state.buffer, or certain substream attributes.

      • perRpcBufferLimit

        private final long perRpcBufferLimit

      • channelBufferLimit

        private final long channelBufferLimit

      • closedSubstreamsInsight

        private final InsightBuilder closedSubstreamsInsight

      • noMoreTransparentRetry

        private final java.util.concurrent.atomic.AtomicBoolean noMoreTransparentRetry
        Either non-local transparent retry happened or reached server's application logic.

        Note that local-only transparent retries are unlimited.

      • localOnlyTransparentRetries

        private final java.util.concurrent.atomic.AtomicInteger localOnlyTransparentRetries

      • inFlightSubStreams

        private final java.util.concurrent.atomic.AtomicInteger inFlightSubStreams

      • perRpcBufferUsed

        private long perRpcBufferUsed

      • nextBackoffIntervalNanos

        private long nextBackoffIntervalNanos

      • cancellationStatus

        private Status cancellationStatus

      • isClosed

        private boolean isClosed

      • random

        private static java.util.Random random

    • Method Detail

      • postCommit

        abstract void postCommit()

      • commitAndRun

        private void commitAndRun​(RetriableStream.Substream winningSubstream)
        Calls commit() and if successful runs the post commit task. Post commit task will be non-null for only once. The post commit task cancels other non-winning streams on separate transport threads, thus it must be run on the callExecutor to prevent deadlocks between multiple stream transports.(issues/10314) This method should be called only in subListener callbacks. This guarantees callExecutor schedules tasks before master listener closes, which is protected by the inFlightSubStreams decorative. That is because: For a successful winning stream, other streams won't attempt to close master listener. For a cancelled winning stream (noop), other stream won't attempt to close master listener. For a failed/closed winning stream, the last closed stream closes the master listener, and callExecutor scheduling happens-before that.

      • createSubstream

        @Nullable
private RetriableStream.Substream createSubstream​(int previousAttemptCount,
                                                  boolean isTransparentRetry)

      • newSubstream

        abstract ClientStream newSubstream​(Metadata headers,
                                   ClientStreamTracer.Factory tracerFactory,
                                   int previousAttempts,
                                   boolean isTransparentRetry)
        Creates a new physical ClientStream that represents a retry/hedging attempt. The returned Client stream is not yet started.

      • updateHeaders

        final Metadata updateHeaders​(Metadata originalHeaders,
                             int previousAttemptCount)
        Adds grpc-previous-rpc-attempts in the headers of a retry/hedging RPC.

      • prestart

        @CheckReturnValue
@Nullable
abstract Status prestart()
        Runs pre-start tasks. Returns the Status of shutdown if the channel is shutdown.

      • start

        public final void start​(ClientStreamListener listener)
        Starts the first PRC attempt.
        Specified by:
        start in interface ClientStream
        Parameters:
        listener - non-null listener of stream events

      • pushbackHedging

        private void pushbackHedging​(@Nullable
                             java.lang.Integer delayMillis)

      • writeMessage

        public final void writeMessage​(java.io.InputStream message)
        Do not use it directly. Use sendMessage(Object) instead because we don't use InputStream for buffering.
        Specified by:
        writeMessage in interface Stream
        Parameters:
        message - stream containing the serialized message to be sent

      • sendMessage

        final void sendMessage​(ReqT message)

      • request

        public final void request​(int numMessages)
        Description copied from interface: Stream
        Requests up to the given number of messages from the call to be delivered via StreamListener.messagesAvailable(StreamListener.MessageProducer). No additional messages will be delivered. If the stream has a start() method, it must be called before requesting messages.
        Specified by:
        request in interface Stream
        Parameters:
        numMessages - the requested number of messages to be delivered to the listener.

      • flush

        public final void flush()
        Description copied from interface: Stream
        Flushes any internally buffered messages to the remote end-point.
        Specified by:
        flush in interface Stream

      • isReady

        public final boolean isReady()
        Description copied from interface: Stream
        If true, indicates that the transport is capable of sending additional messages without requiring excessive buffering internally. Otherwise, StreamListener.onReady() will be called when it turns true.

        This is just a suggestion and the application is free to ignore it, however doing so may result in excessive buffering within the transport.

        Specified by:
        isReady in interface Stream

      • optimizeForDirectExecutor

        public void optimizeForDirectExecutor()
        Description copied from interface: Stream
        Provides a hint that directExecutor is being used by the listener for callbacks to the application. No action is required. There is no requirement that this method actually matches the executor used.
        Specified by:
        optimizeForDirectExecutor in interface Stream

      • setCompressor

        public final void setCompressor​(Compressor compressor)
        Description copied from interface: Stream
        Sets the compressor on the framer.
        Specified by:
        setCompressor in interface Stream
        Parameters:
        compressor - the compressor to use

      • setFullStreamDecompression

        public final void setFullStreamDecompression​(boolean fullStreamDecompression)
        Description copied from interface: ClientStream
        Enables full-stream decompression, allowing the client stream to use GzipInflatingBuffer to decode inbound GZIP compressed streams.
        Specified by:
        setFullStreamDecompression in interface ClientStream

      • setMessageCompression

        public final void setMessageCompression​(boolean enable)
        Description copied from interface: Stream
        Enables per-message compression, if an encoding type has been negotiated. If no message encoding has been negotiated, this is a no-op. By default per-message compression is enabled, but may not have any effect if compression is not enabled on the call.
        Specified by:
        setMessageCompression in interface Stream

      • halfClose

        public final void halfClose()
        Description copied from interface: ClientStream
        Closes the local side of this stream and flushes any remaining messages. After this is called, no further messages may be sent on this stream, but additional messages may be received until the remote end-point is closed. This method may only be called once, and only after ClientStream.start(io.grpc.internal.ClientStreamListener).
        Specified by:
        halfClose in interface ClientStream

      • setMaxInboundMessageSize

        public final void setMaxInboundMessageSize​(int maxSize)
        Description copied from interface: ClientStream
        Sets the max size accepted from the remote endpoint.
        Specified by:
        setMaxInboundMessageSize in interface ClientStream

      • setMaxOutboundMessageSize

        public final void setMaxOutboundMessageSize​(int maxSize)
        Description copied from interface: ClientStream
        Sets the max size sent to the remote endpoint.
        Specified by:
        setMaxOutboundMessageSize in interface ClientStream

      • getAttributes

        public final Attributes getAttributes()
        Description copied from interface: ClientStream
        Attributes that the stream holds at the current moment. Thread-safe and can be called at any time, although some attributes are there only after a certain point.
        Specified by:
        getAttributes in interface ClientStream

      • appendTimeoutInsight

        public void appendTimeoutInsight​(InsightBuilder insight)
        Description copied from interface: ClientStream
        Append information that will be included in the locally generated DEADLINE_EXCEEDED errors to the given InsightBuilder, in order to tell the user about the state of the stream so that they can better diagnose the cause of the error.
        Specified by:
        appendTimeoutInsight in interface ClientStream

      • setRandom

        static void setRandom​(java.util.Random random)

      • hasPotentialHedging

        private boolean hasPotentialHedging​(RetriableStream.State state)
        Whether there is any potential hedge at the moment. A false return value implies there is absolutely no potential hedge. At least one of the hedges will observe a false return value when calling this method, unless otherwise the rpc is committed.

      • freezeHedging

        private void freezeHedging()