GRPC client onNext does not fail if there is no server

Question

I have a simple gRPC client as follows:

  /**
    * Client that calls gRPC.
    */
  public class Client {

  private static final Context.Key<String> URI_CONTEXT_KEY = 
      Context.key(Constants.URI_HEADER_KEY);

  private final ManagedChannel channel;
  private final DoloresRPCStub asyncStub;

  /** 
   * Construct client for accessing gRPC server at {@code host:port}. 
   * @param host 
   * @param port 
   */
  public Client(String host, int port) {
    this(ManagedChannelBuilder.forAddress(host, port).usePlaintext(true));
  }

  /** 
   * Construct client for accessing gRPC server using the existing channel. 
   * @param channelBuilder {@link ManagedChannelBuilder} instance 
   */
  public Client(ManagedChannelBuilder<?> channelBuilder) {
    channel = channelBuilder.build();
    asyncStub = DoloresRPCGrpc.newStub(channel);
  }

  /**
   * Closes the client
   * @throws InterruptedException
   */
  public void shutdown() throws InterruptedException {
    channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
  }

  /**
   * Main async method for communication between client and server
   * @param responseObserver user's {@link StreamObserver} implementation to handle 
   *        responses received from the server.
   * @return {@link StreamObserver} instance to provide requests into
   */
  public StreamObserver<Request> downloading(StreamObserver<Response> responseObserver) {
    return asyncStub.downloading(responseObserver);
  }

  public static void main(String[] args) {
    Client cl = new Client("localhost", 8999); // fail??
    StreamObserver<Request> requester = cl.downloading(new StreamObserver<Response>() {
      @Override
      public void onNext(Response value) {
        System.out.println("On Next");
      }
      @Override
      public void onError(Throwable t) {
        System.out.println("Error");
      }
      @Override
      public void onCompleted() {
        System.out.println("Completed");
      }
    }); // fail ??
    System.out.println("Start");
    requester.onNext(Request.newBuilder().setUrl("http://my-url").build()); // fail?
    requester.onNext(Request.newBuilder().setUrl("http://my-url").build());
    requester.onNext(Request.newBuilder().setUrl("http://my-url").build());
    requester.onNext(Request.newBuilder().setUrl("http://my-url").build());
    System.out.println("Finish");
  }
}

I don't start any server and run the main method. I would suppose that the program fails on:

client creation
client.downloading call
or observer.onNext

but suprisingly (for me), the code runs successfully, only messages got lost. The output is: Start Finish Error Because of the asynchronnous nature, the finish can be called even before an error is propagated at least through the response observer. Is that a desired behavior? I can't lose any messages. Am I missing something?

Thank you, Adam

score 1 · Accepted Answer · edited May 23 '17 at 11:46

This is the intended behavior. As you mentioned the API is asynchronous and so errors must generally be asynchronous as well. gRPC does not guarantee message delivery and in the case of a streaming RPC failure does not indicate which messages were received by the remote side. The advanced ClientCall API calls this out.

If you need stronger guarantees it must be added at the application-level, such as with replies or with a Status of OK. As an example, in gRPC + Image Upload I mention using a bidirectional stream for acknowledgements.

Creating a ManagedChannelBuilder does not error because the channel is lazy: it only creates a TCP connection when necessary (and reconnects when necessary). Also since most failures are transient, we wouldn't want to prevent all future RPCs on the channel just because your client happened to start when the network was broken.

Since the API is asynchronous already, grpc-java can purposefully throw away messages when sending even when it knows an error has occurred (i.e., it chooses not to throw). Thus almost all errors are delivered to the application via onError().

GRPC client onNext does not fail if there is no server

1 Answers1