@Override
public ServerServiceDefinition bindService() {
  return io.grpc.ServerServiceDefinition
      .builder(GreeterGrpc.getServiceDescriptor().getName())
      .addMethod(HelloJsonClient.HelloJsonStub.METHOD_SAY_HELLO,
          asyncUnaryCall(
              new UnaryMethod<HelloRequest, HelloReply>() {
                @Override
                public void invoke(
                    HelloRequest request, StreamObserver<HelloReply> responseObserver) {
                  sayHello(request, responseObserver);
                }
              }))
      .build();
}
 

@Override
public ServerServiceDefinition bindService() {
  return io.grpc.ServerServiceDefinition
      .builder(GreeterGrpc.getServiceDescriptor().getName())
      .addMethod(HelloJsonClient.HelloJsonStub.METHOD_SAY_HELLO,
          asyncUnaryCall(
              new UnaryMethod<HelloRequest, HelloReply>() {
                @Override
                public void invoke(
                    HelloRequest request, StreamObserver<HelloReply> responseObserver) {
                  sayHello(request, responseObserver);
                }
              }))
      .build();
}
 

@Test
public void blockingUnaryCall2_interruptedWaitsForOnClose() throws Exception {
  Integer req = 2;

  class NoopUnaryMethod implements UnaryMethod<Integer, Integer> {
    ServerCallStreamObserver<Integer> observer;

    @Override public void invoke(Integer request, StreamObserver<Integer> responseObserver) {
      observer = (ServerCallStreamObserver<Integer>) responseObserver;
    }
  }

  NoopUnaryMethod methodImpl = new NoopUnaryMethod();
  server = InProcessServerBuilder.forName("noop").directExecutor()
      .addService(ServerServiceDefinition.builder("some")
          .addMethod(UNARY_METHOD, ServerCalls.asyncUnaryCall(methodImpl))
          .build())
      .build().start();

  InterruptInterceptor interceptor = new InterruptInterceptor();
  channel = InProcessChannelBuilder.forName("noop")
      .directExecutor()
      .intercept(interceptor)
      .build();
  try {
    ClientCalls.blockingUnaryCall(channel, UNARY_METHOD, CallOptions.DEFAULT, req);
    fail();
  } catch (StatusRuntimeException ex) {
    assertTrue(Thread.interrupted());
    assertTrue("interrupted", ex.getCause() instanceof InterruptedException);
  }
  assertTrue("onCloseCalled", interceptor.onCloseCalled);
  assertTrue("context not cancelled", methodImpl.observer.isCancelled());
}
 

private TestServer(final Builder builder) throws IOException {
    this.semaphore = new Semaphore(builder.concurrency, true);
    
    ServerCallHandler<String, String> handler = ServerCalls.asyncUnaryCall(new UnaryMethod<String, String>() {
        volatile int segment = 0;
        
        {
            Executors.newSingleThreadExecutor().execute(() -> {
                while (true) {
                    Segment s = builder.segments.get(0);
                    Uninterruptibles.sleepUninterruptibly(s.duration(), TimeUnit.NANOSECONDS);
                    segment = segment++ % builder.segments.size();
                }
            });
        }
        
        @Override
        public void invoke(String req, StreamObserver<String> observer) {
            try {
                long delay = builder.segments.get(0).latency();
                semaphore.acquire();
                TimeUnit.MILLISECONDS.sleep(delay);
                observer.onNext("response");
                observer.onCompleted();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                observer.onError(Status.UNKNOWN.asRuntimeException());
            } finally {
                semaphore.release();
            }
        }
    });
    
    this.server = NettyServerBuilder.forPort(0)
            .addService(ServerInterceptors.intercept(ServerServiceDefinition.builder("service")
                    .addMethod(METHOD_DESCRIPTOR, handler)  // Rate = Limit / Latency = 2 / 0.02 = 100
                    .build(), ConcurrencyLimitServerInterceptor.newBuilder(builder.limiter)
                    .build()
                ))
            .build()
            .start();
}