Package io.grpc.internal

Class DelayedClientCall<ReqT,​RespT>

  • Direct Known Subclasses:
    ManagedChannelImpl.RealChannel.PendingCall
    public class DelayedClientCall<ReqT,​RespT>
extends ClientCall<ReqT,​RespT>
    A call that queues requests before a real call is ready to be delegated to.

    ClientCall itself doesn't require thread-safety. However, the state of DelayedCall may be internally altered by different threads, thus internal synchronization is necessary.

    • Field Detail

      • logger

        private static final java.util.logging.Logger logger

      • initialDeadlineMonitor

        @Nullable
private final java.util.concurrent.ScheduledFuture<?> initialDeadlineMonitor
        A timer to monitor the initial deadline. The timer must be cancelled on transition to the real call.

      • callExecutor

        private final java.util.concurrent.Executor callExecutor

      • context

        private final Context context

      • passThrough

        private volatile boolean passThrough
        true once realCall is valid and all pending calls have been drained.

      • listener

        private ClientCall.Listener<RespT> listener
        Non-null iff start has been called. Used to assert methods are called in appropriate order, but also used if an error occurs before realCall is set.

      • pendingRunnables

        private java.util.List<java.lang.Runnable> pendingRunnables

      • NOOP_CALL

        private static final ClientCall<java.lang.Object,​java.lang.Object> NOOP_CALL

    • Constructor Detail

      • DelayedClientCall

        protected DelayedClientCall​(java.util.concurrent.Executor callExecutor,
                            java.util.concurrent.ScheduledExecutorService scheduler,
                            @Nullable
                            Deadline deadline)

    • Method Detail

      • isAbeforeB

        private boolean isAbeforeB​(@Nullable
                           Deadline a,
                           @Nullable
                           Deadline b)

      • scheduleDeadlineIfNeeded

        @Nullable
private java.util.concurrent.ScheduledFuture<?> scheduleDeadlineIfNeeded​(java.util.concurrent.ScheduledExecutorService scheduler,
                                                                         @Nullable
                                                                         Deadline deadline)

      • start

        public final void start​(ClientCall.Listener<RespT> listener,
                        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:
        listener - receives response messages
        headers - which can contain extra call metadata, e.g. authentication credentials.

      • cancel

        public final void cancel​(@Nullable
                         java.lang.String message,
                         @Nullable
                         java.lang.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

      • cancel

        private void cancel​(Status status,
                    boolean onlyCancelPendingCall)
        Cancels the call unless realCall is set and onlyCancelPendingCall is true.

      • callCancelled

        protected void callCancelled()

      • delayOrExecute

        private void delayOrExecute​(java.lang.Runnable runnable)

      • drainPendingCalls

        private void drainPendingCalls()
        Called to transition passThrough to true. This method is not safe to be called multiple times; the caller must ensure it will only be called once, ever. this lock should not be held when calling this method.

      • sendMessage

        public final 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.

      • setMessageCompression

        public final void setMessageCompression​(boolean enable)
        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>

      • request

        public final 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.

      • halfClose

        public final 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>

      • isReady

        public final 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>

      • toString

        public java.lang.String toString()
        Overrides:
        toString in class java.lang.Object