Package io.grpc.internal

Class ClientCallImpl<ReqT,RespT>

java.lang.Object
io.grpc.ClientCall<ReqT,RespT>
io.grpc.internal.ClientCallImpl<ReqT,RespT>
final class ClientCallImpl<ReqT,RespT> extends ClientCall<ReqT,RespT>
Implementation of ClientCall.

  • Field Details

    • log

      private static final Logger log

    • FULL_STREAM_DECOMPRESSION_ENCODINGS

      private static final byte[] FULL_STREAM_DECOMPRESSION_ENCODINGS

    • NANO_TO_SECS

      private static final double NANO_TO_SECS

    • method

      private final MethodDescriptor<ReqT,RespT> method

    • tag

      private final io.perfmark.Tag tag

    • callExecutor

      private final Executor callExecutor

    • callExecutorIsDirect

      private final boolean callExecutorIsDirect

    • channelCallsTracer

      private final CallTracer channelCallsTracer

    • context

      private final Context context

    • cancellationHandler

      private ClientCallImpl<ReqT,RespT>.CancellationHandler cancellationHandler

    • unaryRequest

      private final boolean unaryRequest

    • callOptions

      private CallOptions callOptions

    • stream

      private ClientStream stream

    • cancelCalled

      private boolean cancelCalled

    • halfCloseCalled

      private boolean halfCloseCalled

    • clientStreamProvider

      private final ClientCallImpl.ClientStreamProvider clientStreamProvider

    • deadlineCancellationExecutor

      private final ScheduledExecutorService deadlineCancellationExecutor

    • fullStreamDecompression

      private boolean fullStreamDecompression

    • decompressorRegistry

      private DecompressorRegistry decompressorRegistry

    • compressorRegistry

      private CompressorRegistry compressorRegistry

  • Constructor Details

  • Method Details

    • setFullStreamDecompression

      ClientCallImpl<ReqT,RespT> setFullStreamDecompression(boolean fullStreamDecompression)

    • setDecompressorRegistry

      ClientCallImpl<ReqT,RespT> setDecompressorRegistry(DecompressorRegistry decompressorRegistry)

    • setCompressorRegistry

      ClientCallImpl<ReqT,RespT> setCompressorRegistry(CompressorRegistry compressorRegistry)

    • prepareHeaders

      static void prepareHeaders(Metadata headers, DecompressorRegistry decompressorRegistry, Compressor compressor, boolean fullStreamDecompression)

    • start

      public void start(ClientCall.Listener<RespT> observer, Metadata headers)
      Description copied from class: ClientCall
      Start a call, using responseListener for processing response messages.

      It must be called prior to any other method on this class, except for ClientCall.cancel(java.lang.String, java.lang.Throwable) which may be called at any time.

      Since Metadata is not thread-safe, the caller must not access (read or write) headers after this point.

      Specified by:
      start in class ClientCall<ReqT,RespT>
      Parameters:
      observer - receives response messages
      headers - which can contain extra call metadata, e.g. authentication credentials.

    • startInternal

      private void startInternal(ClientCall.Listener<RespT> observer, Metadata headers)

    • applyMethodConfig

      private void applyMethodConfig()

    • effectiveDeadline

      @Nullable private Deadline effectiveDeadline()

    • min

      @Nullable private static Deadline min(@Nullable Deadline deadline0, @Nullable Deadline deadline1)

    • request

      public void request(int numMessages)
      Description copied from class: ClientCall
      Requests up to the given number of messages from the call to be delivered to ClientCall.Listener.onMessage(Object). No additional messages will be delivered.

      Message delivery is guaranteed to be sequential in the order received. In addition, the listener methods will not be accessed concurrently. While it is not guaranteed that the same thread will always be used, it is guaranteed that only a single thread will access the listener at a time.

      If it is desired to bypass inbound flow control, a very large number of messages can be specified (e.g. Integer.MAX_VALUE).

      If called multiple times, the number of messages able to delivered will be the sum of the calls.

      This method is safe to call from multiple threads without external synchronization.

      Specified by:
      request in class ClientCall<ReqT,RespT>
      Parameters:
      numMessages - the requested number of messages to be delivered to the listener. Must be non-negative.

    • cancel

      public void cancel(@Nullable String message, @Nullable Throwable cause)
      Description copied from class: ClientCall
      Prevent any further processing for this ClientCall. No further messages may be sent or will be received. The server is informed of cancellations, but may not stop processing the call. Cancellation is permitted even if previously ClientCall.halfClose()d. Cancelling an already cancel()ed ClientCall has no effect.

      No other methods on this class can be called after this method has been called.

      It is recommended that at least one of the arguments to be non-null, to provide useful debug information. Both argument being null may log warnings and result in suboptimal performance. Also note that the provided information will not be sent to the server.

      Specified by:
      cancel in class ClientCall<ReqT,RespT>
      Parameters:
      message - if not null, will appear as the description of the CANCELLED status
      cause - if not null, will appear as the cause of the CANCELLED status

    • cancelInternal

      private void cancelInternal(@Nullable String message, @Nullable Throwable cause)

    • halfClose

      public void halfClose()
      Description copied from class: ClientCall
      Close the call for request message sending. Incoming response messages are unaffected. This should be called when no more messages will be sent from the client.
      Specified by:
      halfClose in class ClientCall<ReqT,RespT>

    • halfCloseInternal

      private void halfCloseInternal()

    • sendMessage

      public void sendMessage(ReqT message)
      Description copied from class: ClientCall
      Send a request message to the server. May be called zero or more times depending on how many messages the server is willing to accept for the operation.
      Specified by:
      sendMessage in class ClientCall<ReqT,RespT>
      Parameters:
      message - message to be sent to the server.

    • sendMessageInternal

      private void sendMessageInternal(ReqT message)

    • setMessageCompression

      public void setMessageCompression(boolean enabled)
      Description copied from class: ClientCall
      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.
      Overrides:
      setMessageCompression in class ClientCall<ReqT,RespT>

    • isReady

      public boolean isReady()
      Description copied from class: ClientCall
      If true, indicates that the call is capable of sending additional messages without requiring excessive buffering internally. This event is just a suggestion and the application is free to ignore it, however doing so may result in excessive buffering within the call.

      If false, ClientCall.Listener.onReady() will be called after isReady() transitions to true.

      If the type of the call is either MethodDescriptor.MethodType.UNARY or MethodDescriptor.MethodType.SERVER_STREAMING, this method may persistently return false. Calls that send exactly one message should not check this method.

      This abstract class's implementation always returns true. Implementations generally override the method.

      Overrides:
      isReady in class ClientCall<ReqT,RespT>

    • getAttributes

      public Attributes getAttributes()
      Description copied from class: ClientCall
      Returns additional properties of the call. May only be called after ClientCall.Listener.onHeaders(io.grpc.Metadata) or ClientCall.Listener.onClose(io.grpc.Status, io.grpc.Metadata). If called prematurely, the implementation may throw IllegalStateException or return arbitrary Attributes.
      Overrides:
      getAttributes in class ClientCall<ReqT,RespT>
      Returns:
      non-null attributes

    • closeObserver

      private void closeObserver(ClientCall.Listener<RespT> observer, Status status, Metadata trailers)

    • toString

      public String toString()
      Overrides:
      toString in class Object