Package io.grpc.stub

Class ClientCalls


  • public final class ClientCalls
    extends java.lang.Object
    Utility functions for processing different call idioms. We have one-to-one correspondence between utilities in this class and the potential signatures in a generated stub class so that the runtime can vary behavior without requiring regeneration of the stub.
    • Field Detail

      • logger

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

        static boolean rejectRunnableOnExecutor
    • Constructor Detail

      • ClientCalls

        private ClientCalls()
    • Method Detail

      • asyncUnaryCall

        public static <ReqT,​RespT> void asyncUnaryCall​(ClientCall<ReqT,​RespT> call,
                                                             ReqT req,
                                                             StreamObserver<RespT> responseObserver)
        Executes a unary call with a response StreamObserver. The call should not be already started. After calling this method, call should no longer be used.

        If the provided responseObserver is an instance of ClientResponseObserver, beforeStart() will be called.

      • asyncServerStreamingCall

        public static <ReqT,​RespT> void asyncServerStreamingCall​(ClientCall<ReqT,​RespT> call,
                                                                       ReqT req,
                                                                       StreamObserver<RespT> responseObserver)
        Executes a server-streaming call with a response StreamObserver. The call should not be already started. After calling this method, call should no longer be used.

        If the provided responseObserver is an instance of ClientResponseObserver, beforeStart() will be called.

      • asyncClientStreamingCall

        public static <ReqT,​RespT> StreamObserver<ReqT> asyncClientStreamingCall​(ClientCall<ReqT,​RespT> call,
                                                                                       StreamObserver<RespT> responseObserver)
        Executes a client-streaming call returning a StreamObserver for the request messages. The call should not be already started. After calling this method, call should no longer be used.

        If the provided responseObserver is an instance of ClientResponseObserver, beforeStart() will be called.

        Returns:
        request stream observer. It will extend ClientCallStreamObserver
      • asyncBidiStreamingCall

        public static <ReqT,​RespT> StreamObserver<ReqT> asyncBidiStreamingCall​(ClientCall<ReqT,​RespT> call,
                                                                                     StreamObserver<RespT> responseObserver)
        Executes a bidirectional-streaming call. The call should not be already started. After calling this method, call should no longer be used.

        If the provided responseObserver is an instance of ClientResponseObserver, beforeStart() will be called.

        Returns:
        request stream observer. It will extend ClientCallStreamObserver
      • blockingUnaryCall

        public static <ReqT,​RespT> RespT blockingUnaryCall​(ClientCall<ReqT,​RespT> call,
                                                                 ReqT req)
        Executes a unary call and blocks on the response. The call should not be already started. After calling this method, call should no longer be used.
        Returns:
        the single response message.
        Throws:
        StatusRuntimeException - on error
      • blockingUnaryCall

        public static <ReqT,​RespT> RespT blockingUnaryCall​(Channel channel,
                                                                 MethodDescriptor<ReqT,​RespT> method,
                                                                 CallOptions callOptions,
                                                                 ReqT req)
        Executes a unary call and blocks on the response. The call should not be already started. After calling this method, call should no longer be used.
        Returns:
        the single response message.
        Throws:
        StatusRuntimeException - on error
      • blockingServerStreamingCall

        public static <ReqT,​RespT> java.util.Iterator<RespT> blockingServerStreamingCall​(ClientCall<ReqT,​RespT> call,
                                                                                               ReqT req)
        Executes a server-streaming call returning a blocking Iterator over the response stream. The call should not be already started. After calling this method, call should no longer be used.

        The returned iterator may throw StatusRuntimeException on error.

        Returns:
        an iterator over the response stream.
      • blockingServerStreamingCall

        public static <ReqT,​RespT> java.util.Iterator<RespT> blockingServerStreamingCall​(Channel channel,
                                                                                               MethodDescriptor<ReqT,​RespT> method,
                                                                                               CallOptions callOptions,
                                                                                               ReqT req)
        Executes a server-streaming call returning a blocking Iterator over the response stream. The call should not be already started. After calling this method, call should no longer be used.

        The returned iterator may throw StatusRuntimeException on error.

        Returns:
        an iterator over the response stream.
      • futureUnaryCall

        public static <ReqT,​RespT> com.google.common.util.concurrent.ListenableFuture<RespT> futureUnaryCall​(ClientCall<ReqT,​RespT> call,
                                                                                                                   ReqT req)
        Executes a unary call and returns a ListenableFuture to the response. The call should not be already started. After calling this method, call should no longer be used.
        Returns:
        a future for the single response message.
      • getUnchecked

        private static <V> V getUnchecked​(java.util.concurrent.Future<V> future)
        Returns the result of calling Future.get() interruptibly on a task known not to throw a checked exception.

        If interrupted, the interrupt is restored before throwing an exception..

        Throws:
        java.util.concurrent.CancellationException - if get throws a CancellationException.
        StatusRuntimeException - if get throws an ExecutionException or an InterruptedException.
      • cancelThrow

        private static java.lang.RuntimeException cancelThrow​(ClientCall<?,​?> call,
                                                              java.lang.Throwable t)
        Cancels a call, and throws the exception.
        Parameters:
        t - must be a RuntimeException or Error
      • asyncUnaryRequestCall

        private static <ReqT,​RespT> void asyncUnaryRequestCall​(ClientCall<ReqT,​RespT> call,
                                                                     ReqT req,
                                                                     StreamObserver<RespT> responseObserver,
                                                                     boolean streamingResponse)
      • asyncStreamingRequestCall

        private static <ReqT,​RespT> StreamObserver<ReqT> asyncStreamingRequestCall​(ClientCall<ReqT,​RespT> call,
                                                                                         StreamObserver<RespT> responseObserver,
                                                                                         boolean streamingResponse)