Package io.grpc.internal

Class RetriableStream<ReqT>

java.lang.Object
io.grpc.internal.RetriableStream<ReqT>
All Implemented Interfaces:
ClientStream, Stream
abstract class RetriableStream<ReqT> extends Object implements ClientStream
A logical ClientStream that is retriable.

  • Field Details

    • GRPC_PREVIOUS_RPC_ATTEMPTS

      static final Metadata.Key<String> GRPC_PREVIOUS_RPC_ATTEMPTS

    • GRPC_RETRY_PUSHBACK_MS

      static final Metadata.Key<String> GRPC_RETRY_PUSHBACK_MS

    • CANCELLED_BECAUSE_COMMITTED

      private static final Status CANCELLED_BECAUSE_COMMITTED

    • method

      private final MethodDescriptor<ReqT,?> method

    • callExecutor

      private final Executor callExecutor

    • listenerSerializeExecutor

      private final Executor listenerSerializeExecutor

    • scheduledExecutorService

      private final 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 Object lock
      Must be held when updating state, accessing state.buffer, or certain substream attributes.

    • channelBufferUsed

      private final RetriableStream.ChannelBufferMeter channelBufferUsed

    • perRpcBufferLimit

      private final long perRpcBufferLimit

    • channelBufferLimit

      private final long channelBufferLimit

    • throttle

      @Nullable private final RetriableStream.Throttle throttle

    • closedSubstreamsInsight

      private final InsightBuilder closedSubstreamsInsight

    • state

      private volatile RetriableStream.State state

    • noMoreTransparentRetry

      private final 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 AtomicInteger localOnlyTransparentRetries

    • inFlightSubStreams

      private final AtomicInteger inFlightSubStreams

    • savedCloseMasterListenerReason

      private RetriableStream.SavedCloseMasterListenerReason savedCloseMasterListenerReason

    • perRpcBufferUsed

      private long perRpcBufferUsed

    • masterListener

      private ClientStreamListener masterListener

    • scheduledRetry

      private RetriableStream.FutureCanceller scheduledRetry

    • scheduledHedging

      private RetriableStream.FutureCanceller scheduledHedging

    • nextBackoffIntervalNanos

      private long nextBackoffIntervalNanos

    • cancellationStatus

      private Status cancellationStatus

    • isClosed

      private boolean isClosed

    • random

      private static Random random

  • Constructor Details

  • Method Details

    • commit

      @Nullable @CheckReturnValue private Runnable commit(RetriableStream.Substream winningSubstream)

    • 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.

    • drain

      private void drain(RetriableStream.Substream substream)

    • 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 Integer delayMillis)

    • cancel

      public final void cancel(Status reason)
      Description copied from interface: ClientStream
      Abnormally terminates the stream. After calling this method, no further messages will be sent or received, however it may still be possible to receive buffered messages for a brief period until ClientStreamListener.closed(io.grpc.Status, io.grpc.internal.ClientStreamListener.RpcProgress, io.grpc.Metadata) is called. This method may only be called after ClientStream.start(io.grpc.internal.ClientStreamListener), but else is safe to be called at any time and multiple times and from any thread.
      Specified by:
      cancel in interface ClientStream
      Parameters:
      reason - must be non-OK

    • delayOrExecute

      private void delayOrExecute(RetriableStream.BufferEntry bufferEntry)

    • writeMessage

      public final void writeMessage(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

    • setAuthority

      public final void setAuthority(String authority)
      Description copied from interface: ClientStream
      Override the default authority with authority. May only be called before ClientStream.start(io.grpc.internal.ClientStreamListener).
      Specified by:
      setAuthority in interface ClientStream

    • setDecompressorRegistry

      public final void setDecompressorRegistry(DecompressorRegistry decompressorRegistry)
      Description copied from interface: ClientStream
      Sets the registry to find a decompressor for the framer. May only be called before ClientStream.start(io.grpc.internal.ClientStreamListener). If the transport does not support compression, this may do nothing.
      Specified by:
      setDecompressorRegistry in interface ClientStream
      Parameters:
      decompressorRegistry - the registry of decompressors for decoding responses

    • 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

    • setDeadline

      public final void setDeadline(Deadline deadline)
      Description copied from interface: ClientStream
      Sets the effective deadline of the RPC.
      Specified by:
      setDeadline 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(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()

    • safeCloseMasterListener

      private void safeCloseMasterListener(Status status, ClientStreamListener.RpcProgress progress, Metadata metadata)