io.grpc.Deadline Java Examples

@Test
public void contextDeadlineShouldBePropagatedToStream() {
  Context context = Context.current()
      .withDeadlineAfter(1000, TimeUnit.MILLISECONDS, deadlineCancellationExecutor);
  Context origContext = context.attach();

  ClientCallImpl<Void, Void> call = new ClientCallImpl<Void, Void>(
      method,
      MoreExecutors.directExecutor(),
      baseCallOptions,
      provider,
      deadlineCancellationExecutor,
      channelCallTracer,
      false /* retryEnabled */);
  call.start(callListener, new Metadata());

  context.detach(origContext);

  ArgumentCaptor<Deadline> deadlineCaptor = ArgumentCaptor.forClass(Deadline.class);
  verify(stream).setDeadline(deadlineCaptor.capture());

  assertTimeoutBetween(deadlineCaptor.getValue().timeRemaining(TimeUnit.MILLISECONDS), 600, 1000);
}
 

@Test
public void newInputRemovesNonExistentEntry() throws IOException, InterruptedException {
  Digest nonexistentDigest =
      Digest.newBuilder().setHash("file_does_not_exist").setSizeBytes(1).build();
  String nonexistentKey = fileCache.getKey(nonexistentDigest, false);
  Entry entry = new Entry(nonexistentKey, 1, Deadline.after(10, SECONDS));
  entry.before = entry;
  entry.after = entry;
  storage.put(nonexistentKey, entry);
  NoSuchFileException noSuchFileException = null;
  try (InputStream in = fileCache.newInput(nonexistentDigest, 0)) {
    fail("should not get here");
  } catch (NoSuchFileException e) {
    noSuchFileException = e;
  }

  assertThat(noSuchFileException).isNotNull();
  assertThat(storage.containsKey(nonexistentKey)).isFalse();
}
 

@Test
public void contextDeadlineShouldNotOverrideSmallerCallOptionsDeadline() {
  Context context = Context.current()
      .withDeadlineAfter(2000, TimeUnit.MILLISECONDS, deadlineCancellationExecutor);
  Context origContext = context.attach();

  CallOptions callOpts = baseCallOptions.withDeadlineAfter(1000, TimeUnit.MILLISECONDS);
  ClientCallImpl<Void, Void> call = new ClientCallImpl<>(
      method,
      MoreExecutors.directExecutor(),
      callOpts,
      provider,
      deadlineCancellationExecutor,
      channelCallTracer,
      /* retryEnabled= */ false);
  call.start(callListener, new Metadata());

  context.detach(origContext);

  ArgumentCaptor<Deadline> deadlineCaptor = ArgumentCaptor.forClass(Deadline.class);
  verify(stream).setDeadline(deadlineCaptor.capture());

  assertTimeoutBetween(deadlineCaptor.getValue().timeRemaining(TimeUnit.MILLISECONDS), 600, 1000);
}
 

private static void logIfContextNarrowedTimeout(
    Deadline effectiveDeadline, @Nullable Deadline outerCallDeadline,
    @Nullable Deadline callDeadline) {
  if (!log.isLoggable(Level.FINE) || effectiveDeadline == null
      || !effectiveDeadline.equals(outerCallDeadline)) {
    return;
  }

  long effectiveTimeout = max(0, effectiveDeadline.timeRemaining(TimeUnit.NANOSECONDS));
  StringBuilder builder = new StringBuilder(String.format(
      "Call timeout set to '%d' ns, due to context deadline.", effectiveTimeout));
  if (callDeadline == null) {
    builder.append(" Explicit call timeout was not set.");
  } else {
    long callTimeout = callDeadline.timeRemaining(TimeUnit.NANOSECONDS);
    builder.append(String.format(" Explicit call timeout was '%d' ns.", callTimeout));
  }

  log.fine(builder.toString());
}
 

@Test
public void nearerDeadlineKept_new() {
  // TODO(carl-mastrangelo): the deadlines are very large because they change over time.
  // This should be fixed, and is tracked in https://github.com/grpc/grpc-java/issues/2531
  JsonObj name = new JsonObj("service", "service");
  JsonObj methodConfig = new JsonObj("name", new JsonList(name), "timeout", "1s");
  JsonObj serviceConfig = new JsonObj("methodConfig", new JsonList(methodConfig));
  ManagedChannelServiceConfig parsedServiceConfig =
      createManagedChannelServiceConfig(serviceConfig);

  interceptor.handleUpdate(parsedServiceConfig);

  Deadline existingDeadline = Deadline.after(1234567890, TimeUnit.NANOSECONDS);
  interceptor.interceptCall(
      methodDescriptor, CallOptions.DEFAULT.withDeadline(existingDeadline), channel);

  verify(channel).newCall(eq(methodDescriptor), callOptionsCap.capture());
  assertThat(callOptionsCap.getValue().getDeadline()).isNotEqualTo(existingDeadline);
}
 

private GrpclbRouteType doRpcAndGetPath(Deadline deadline) {
  logger.info("doRpcAndGetPath deadline: " + deadline);
  final SimpleRequest request = SimpleRequest.newBuilder()
      .setFillGrpclbRouteType(true)
      .build();
  GrpclbRouteType result = GrpclbRouteType.GRPCLB_ROUTE_TYPE_UNKNOWN;
  try {
    SimpleResponse response = blockingStub
        .withDeadline(deadline)
        .unaryCall(request);
    result = response.getGrpclbRouteType();
  } catch (StatusRuntimeException ex) {
    logger.warning("doRpcAndGetPath failed. Status: " + ex);
    return GrpclbRouteType.GRPCLB_ROUTE_TYPE_UNKNOWN;
  }
  logger.info("doRpcAndGetPath. GrpclbRouteType result: " + result);
  if (result != GrpclbRouteType.GRPCLB_ROUTE_TYPE_FALLBACK
      && result != GrpclbRouteType.GRPCLB_ROUTE_TYPE_BACKEND) {
    throw new AssertionError("Received invalid LB route type. This suggests "
        + "that the server hasn't implemented this test correctly.");
  }
  return result;
}
 

@Test
public void readRemovesNonexistentEntry() throws IOException, InterruptedException {
  ByteString content = ByteString.copyFromUtf8("Hello, World");
  Blob blob = new Blob(content, DIGEST_UTIL);

  fileCache.put(blob);
  String key = fileCache.getKey(blob.getDigest(), /* isExecutable=*/ false);
  // putCreatesFile verifies this
  Files.delete(fileCache.getPath(key));
  // update entry with expired deadline
  storage.get(key).existsDeadline = Deadline.after(0, SECONDS);

  try (InputStream in = fileCache.newInput(blob.getDigest(), /* offset=*/ 0)) {
    fail("should not get here");
  } catch (NoSuchFileException e) {
    // success
  }
  assertThat(storage.containsKey(key)).isFalse();
}
 

private static void logIfContextNarrowedTimeout(
    Deadline effectiveDeadline, @Nullable Deadline outerCallDeadline,
    @Nullable Deadline callDeadline) {
  if (!log.isLoggable(Level.FINE) || effectiveDeadline == null
      || outerCallDeadline != effectiveDeadline) {
    return;
  }

  long effectiveTimeout = max(0, effectiveDeadline.timeRemaining(TimeUnit.NANOSECONDS));
  StringBuilder builder = new StringBuilder(String.format(
      "Call timeout set to '%d' ns, due to context deadline.", effectiveTimeout));
  if (callDeadline == null) {
    builder.append(" Explicit call timeout was not set.");
  } else {
    long callTimeout = callDeadline.timeRemaining(TimeUnit.NANOSECONDS);
    builder.append(String.format(" Explicit call timeout was '%d' ns.", callTimeout));
  }

  log.fine(builder.toString());
}
 

/**
 * Prepares for a check that the subject is deadline within the given tolerance of an
 * expected value that will be provided in the next call in the fluent chain.
 */
@CheckReturnValue
public TolerantDeadlineComparison isWithin(final long delta, final TimeUnit timeUnit) {
  return new TolerantDeadlineComparison() {
    @Override
    public void of(Deadline expected) {
      Deadline actual = actual();
      checkNotNull(actual, "actual value cannot be null. expected=%s", expected);

      // This is probably overkill, but easier than thinking about overflow.
      BigInteger actualTimeRemaining = BigInteger.valueOf(actual.timeRemaining(NANOSECONDS));
      BigInteger expectedTimeRemaining = BigInteger.valueOf(expected.timeRemaining(NANOSECONDS));
      BigInteger deltaNanos = BigInteger.valueOf(timeUnit.toNanos(delta));
      if (actualTimeRemaining.subtract(expectedTimeRemaining).abs().compareTo(deltaNanos) > 0) {
        failWithoutActual(
            simpleFact(
                lenientFormat(
                    "%s and <%s> should have been within <%sns> of each other",
                    actualAsString(), expected, deltaNanos)));
      }
    }
  };
}
 

private Context.CancellableContext createContext(
    Metadata headers, StatsTraceContext statsTraceCtx) {
  Long timeoutNanos = headers.get(TIMEOUT_KEY);

  Context baseContext =
      statsTraceCtx
          .serverFilterContext(rootContext)
          .withValue(io.grpc.InternalServer.SERVER_CONTEXT_KEY, ServerImpl.this);

  if (timeoutNanos == null) {
    return baseContext.withCancellation();
  }

  Context.CancellableContext context =
      baseContext.withDeadline(
          Deadline.after(timeoutNanos, NANOSECONDS, ticker),
          transport.getScheduledExecutorService());

  return context;
}
 

@Test
public void deadlineTimeoutPopulatedToHeaders() {
  AbstractClientStream.Sink sink = mock(AbstractClientStream.Sink.class);
  ClientStream stream = new BaseAbstractClientStream(
      allocator, new BaseTransportState(statsTraceCtx, transportTracer), sink, statsTraceCtx,
      transportTracer);

  stream.setDeadline(Deadline.after(1, TimeUnit.SECONDS));
  stream.start(mockListener);

  ArgumentCaptor<Metadata> headersCaptor = ArgumentCaptor.forClass(Metadata.class);
  verify(sink).writeHeaders(headersCaptor.capture(), ArgumentMatchers.<byte[]>any());

  Metadata headers = headersCaptor.getValue();
  assertTrue(headers.containsKey(GrpcUtil.TIMEOUT_KEY));
  assertThat(headers.get(GrpcUtil.TIMEOUT_KEY).longValue())
      .isLessThan(TimeUnit.SECONDS.toNanos(1));
  assertThat(headers.get(GrpcUtil.TIMEOUT_KEY).longValue())
      .isGreaterThan(TimeUnit.MILLISECONDS.toNanos(600));
}
 

@Test
public void streamCancelAbortsDeadlineTimer() {
  fakeClock.forwardTime(System.nanoTime(), TimeUnit.NANOSECONDS);

  ClientCallImpl<Void, Void> call = new ClientCallImpl<>(
      method,
      MoreExecutors.directExecutor(),
      baseCallOptions.withDeadline(Deadline.after(1, TimeUnit.SECONDS)),
      provider,
      deadlineCancellationExecutor,
      channelCallTracer,
      /* retryEnabled= */ false);
  call.start(callListener, new Metadata());
  call.cancel("canceled", null);

  // Run the deadline timer, which should have been cancelled by the previous call to cancel()
  fakeClock.forwardNanos(TimeUnit.SECONDS.toNanos(1) + 1);

  verify(stream, times(1)).cancel(statusCaptor.capture());

  assertEquals(Status.CANCELLED.getCode(), statusCaptor.getValue().getCode());
}
 

@Test
public void nearerDeadlineKept_existing() {
  JsonObj name = new JsonObj("service", "service");
  JsonObj methodConfig = new JsonObj("name", new JsonList(name), "timeout", "100000s");
  JsonObj serviceConfig = new JsonObj("methodConfig", new JsonList(methodConfig));
  ManagedChannelServiceConfig parsedServiceConfig =
      createManagedChannelServiceConfig(serviceConfig);

  interceptor.handleUpdate(parsedServiceConfig);

  Deadline existingDeadline = Deadline.after(1000, TimeUnit.NANOSECONDS);
  interceptor.interceptCall(
      methodDescriptor, CallOptions.DEFAULT.withDeadline(existingDeadline), channel);

  verify(channel).newCall(eq(methodDescriptor), callOptionsCap.capture());
  assertThat(callOptionsCap.getValue().getDeadline()).isEqualTo(existingDeadline);
}
 

@Test
public void contextDeadlineShouldOverrideLargerCallOptionsDeadline() {
  Context context = Context.current()
      .withDeadlineAfter(1000, TimeUnit.MILLISECONDS, deadlineCancellationExecutor);
  Context origContext = context.attach();

  CallOptions callOpts = baseCallOptions.withDeadlineAfter(2000, TimeUnit.MILLISECONDS);
  ClientCallImpl<Void, Void> call = new ClientCallImpl<Void, Void>(
      method,
      MoreExecutors.directExecutor(),
      callOpts,
      provider,
      deadlineCancellationExecutor,
      channelCallTracer,
      false /* retryEnabled */);
  call.start(callListener, new Metadata());

  context.detach(origContext);

  ArgumentCaptor<Deadline> deadlineCaptor = ArgumentCaptor.forClass(Deadline.class);
  verify(stream).setDeadline(deadlineCaptor.capture());

  assertTimeoutBetween(deadlineCaptor.getValue().timeRemaining(TimeUnit.MILLISECONDS), 600, 1000);
}
 

@Test
public void contextDeadlineShouldNotOverrideSmallerCallOptionsDeadline() {
  Context context = Context.current()
      .withDeadlineAfter(2000, TimeUnit.MILLISECONDS, deadlineCancellationExecutor);
  Context origContext = context.attach();

  CallOptions callOpts = baseCallOptions.withDeadlineAfter(1000, TimeUnit.MILLISECONDS);
  ClientCallImpl<Void, Void> call = new ClientCallImpl<Void, Void>(
      method,
      MoreExecutors.directExecutor(),
      callOpts,
      provider,
      deadlineCancellationExecutor,
      channelCallTracer,
      false /* retryEnabled */);
  call.start(callListener, new Metadata());

  context.detach(origContext);

  ArgumentCaptor<Deadline> deadlineCaptor = ArgumentCaptor.forClass(Deadline.class);
  verify(stream).setDeadline(deadlineCaptor.capture());

  assertTimeoutBetween(deadlineCaptor.getValue().timeRemaining(TimeUnit.MILLISECONDS), 600, 1000);
}
 

@Test
public void callOptionsDeadlineShouldBePropagatedToStream() {
  CallOptions callOpts = baseCallOptions.withDeadlineAfter(1000, TimeUnit.MILLISECONDS);
  ClientCallImpl<Void, Void> call = new ClientCallImpl<Void, Void>(
      method,
      MoreExecutors.directExecutor(),
      callOpts,
      provider,
      deadlineCancellationExecutor,
      channelCallTracer,
      false /* retryEnabled */);
  call.start(callListener, new Metadata());

  ArgumentCaptor<Deadline> deadlineCaptor = ArgumentCaptor.forClass(Deadline.class);
  verify(stream).setDeadline(deadlineCaptor.capture());

  assertTimeoutBetween(deadlineCaptor.getValue().timeRemaining(TimeUnit.MILLISECONDS), 600, 1000);
}
 

@Test
public void expiredDeadlineCancelsStream_CallOptions() {
  fakeClock.forwardTime(System.nanoTime(), TimeUnit.NANOSECONDS);
  // The deadline needs to be a number large enough to get encompass the call to start, otherwise
  // the scheduled cancellation won't be created, and the call will fail early.
  ClientCallImpl<Void, Void> call = new ClientCallImpl<Void, Void>(
      method,
      MoreExecutors.directExecutor(),
      baseCallOptions.withDeadline(Deadline.after(1, TimeUnit.SECONDS)),
      provider,
      deadlineCancellationExecutor,
      channelCallTracer,
      false /* retryEnabled */);

  call.start(callListener, new Metadata());

  fakeClock.forwardNanos(TimeUnit.SECONDS.toNanos(1) + 1);

  verify(stream, times(1)).cancel(statusCaptor.capture());
  assertEquals(Status.Code.DEADLINE_EXCEEDED, statusCaptor.getValue().getCode());
}
 

@Test
public void streamCancelAbortsDeadlineTimer() {
  fakeClock.forwardTime(System.nanoTime(), TimeUnit.NANOSECONDS);

  ClientCallImpl<Void, Void> call = new ClientCallImpl<Void, Void>(
      method,
      MoreExecutors.directExecutor(),
      baseCallOptions.withDeadline(Deadline.after(1, TimeUnit.SECONDS)),
      provider,
      deadlineCancellationExecutor,
      channelCallTracer,
      false /* retryEnabled */);
  call.start(callListener, new Metadata());
  call.cancel("canceled", null);

  // Run the deadline timer, which should have been cancelled by the previous call to cancel()
  fakeClock.forwardNanos(TimeUnit.SECONDS.toNanos(1) + 1);

  verify(stream, times(1)).cancel(statusCaptor.capture());

  assertEquals(Status.CANCELLED.getCode(), statusCaptor.getValue().getCode());
}
 

@Test
public void deadlineTimeoutPopulatedToHeaders() {
  AbstractClientStream.Sink sink = mock(AbstractClientStream.Sink.class);
  ClientStream stream = new BaseAbstractClientStream(
      allocator, new BaseTransportState(statsTraceCtx, transportTracer), sink, statsTraceCtx,
      transportTracer);

  stream.setDeadline(Deadline.after(1, TimeUnit.SECONDS));
  stream.start(mockListener);

  ArgumentCaptor<Metadata> headersCaptor = ArgumentCaptor.forClass(Metadata.class);
  verify(sink).writeHeaders(headersCaptor.capture(), any(byte[].class));

  Metadata headers = headersCaptor.getValue();
  assertTrue(headers.containsKey(GrpcUtil.TIMEOUT_KEY));
  assertThat(headers.get(GrpcUtil.TIMEOUT_KEY).longValue())
      .isLessThan(TimeUnit.SECONDS.toNanos(1));
  assertThat(headers.get(GrpcUtil.TIMEOUT_KEY).longValue())
      .isGreaterThan(TimeUnit.MILLISECONDS.toNanos(600));
}
 

@Test
public void contextDeadlineShouldOverrideLargerCallOptionsDeadline() {
  Context context = Context.current()
      .withDeadlineAfter(1000, TimeUnit.MILLISECONDS, deadlineCancellationExecutor);
  Context origContext = context.attach();

  CallOptions callOpts = baseCallOptions.withDeadlineAfter(2000, TimeUnit.MILLISECONDS);
  ClientCallImpl<Void, Void> call = new ClientCallImpl<>(
      method,
      MoreExecutors.directExecutor(),
      callOpts,
      provider,
      deadlineCancellationExecutor,
      channelCallTracer,
      /* retryEnabled= */ false);
  call.start(callListener, new Metadata());

  context.detach(origContext);

  ArgumentCaptor<Deadline> deadlineCaptor = ArgumentCaptor.forClass(Deadline.class);
  verify(stream).setDeadline(deadlineCaptor.capture());

  assertTimeoutBetween(deadlineCaptor.getValue().timeRemaining(TimeUnit.MILLISECONDS), 600, 1000);
}
 

protected <ReqT,R> ListenableFuture<R> fuCall(MethodDescriptor<ReqT,R> method, ReqT request,
        CallOptions callOptions, long timeoutMs) {
    if (timeoutMs <= 0L) {
        timeoutMs = defaultTimeoutMs;
    }
    if (timeoutMs > 0L) {
        Deadline deadline = callOptions.getDeadline();
        Deadline timeoutDeadline = Deadline.after(timeoutMs, MILLISECONDS);
        if (deadline == null || timeoutDeadline.isBefore(deadline)) {
            callOptions = callOptions.withDeadline(timeoutDeadline);
        } else if (deadline.isExpired()) {
            return Futures.immediateFailedFuture(
                    Status.DEADLINE_EXCEEDED.asRuntimeException());
        }
    }
    final CallOptions finalCallOpts = callOptions;
    return sendViaEventLoop && !isEventThread.satisfied()
            ? Futures.submitAsync(() -> fuCall(method, request, finalCallOpts), ses)
                    : fuCall(method, request, finalCallOpts);
}
 

@Override
public void resumePoller(
    Poller poller,
    String name,
    QueueEntry queueEntry,
    ExecutionStage.Value stage,
    Runnable onFailure,
    Deadline deadline) {
  String operationName = queueEntry.getExecuteEntry().getOperationName();
  poller.resume(
      () -> {
        boolean success = false;
        try {
          success =
              operationPoller.poll(queueEntry, stage, System.currentTimeMillis() + 30 * 1000);
        } catch (IOException e) {
          logger.log(
              Level.SEVERE, format("%s: poller: error while polling %s", name, operationName), e);
        }

        logger.log(
            Level.INFO,
            format(
                "%s: poller: Completed Poll for %s: %s",
                name, operationName, success ? "OK" : "Failed"));
        if (!success) {
          onFailure.run();
        }
        return success;
      },
      () -> {
        logger.log(
            Level.INFO, format("%s: poller: Deadline expired for %s", name, operationName));
        onFailure.run();
      },
      deadline);
}
 

@Override
protected OperationContext tick(OperationContext operationContext) throws InterruptedException {
  workerContext.resumePoller(
      operationContext.poller,
      "ReportResultStage",
      operationContext.queueEntry,
      EXECUTING,
      this::cancelTick,
      Deadline.after(60, SECONDS));
  try {
    return reportPolled(operationContext);
  } finally {
    operationContext.poller.pause();
  }
}
 

private Duration getWaitTime() {
  checkNotNull(periodDeadline);
  Deadline waitDeadline = expirationDeadline.minimum(periodDeadline);
  long waitMicros = waitDeadline.timeRemaining(MICROSECONDS);
  if (waitMicros <= 0) {
    return Duration.getDefaultInstance();
  }
  return Durations.fromMicros(waitMicros);
}
 

private boolean entryExists(Entry e) {
  if (!e.existsDeadline.isExpired()) {
    return true;
  }

  if (Files.exists(getPath(e.key))) {
    e.existsDeadline = Deadline.after(10, SECONDS);
    return true;
  }
  return false;
}
 

private FluxInvocation(FluxSink<Object> sink, Object[] args) {
    StreamObserver<Object> grpcStreamObserver = new ClientResponseObserver<Object, Object>() {
        @Override
        public void beforeStart(ClientCallStreamObserver requestStream) {
            sink.onCancel(() -> requestStream.cancel("React subscription cancelled", null));
        }

        @Override
        public void onNext(Object value) {
            sink.next(value);
        }

        @Override
        public void onError(Throwable error) {
            sink.error(error);
        }

        @Override
        public void onCompleted() {
            sink.complete();
        }
    };

    Object[] grpcArgs = new Object[]{
            grpcArgPos < 0 ? Empty.getDefaultInstance() : args[grpcArgPos],
            grpcStreamObserver
    };

    GRPC_STUB invocationStub = handleCallMetadata(args)
            .withDeadline(Deadline.after(timeout.toMillis(), TimeUnit.MILLISECONDS));

    try {
        grpcMethod.invoke(invocationStub, grpcArgs);
    } catch (Exception e) {
        sink.error(e);
    }
}
 

@Test
public void expiredDeadlineCancelsStream_CallOptions() {
  fakeClock.forwardTime(System.nanoTime(), TimeUnit.NANOSECONDS);
  // The deadline needs to be a number large enough to get encompass the call to start, otherwise
  // the scheduled cancellation won't be created, and the call will fail early.
  ClientCallImpl<Void, Void> call = new ClientCallImpl<>(
      method,
      MoreExecutors.directExecutor(),
      baseCallOptions.withDeadline(
          Deadline.after(1, TimeUnit.SECONDS, fakeClock.getDeadlineTicker())),
      provider,
      deadlineCancellationExecutor,
      channelCallTracer,
      /* retryEnabled= */ false);

  call.start(callListener, new Metadata());

  fakeClock.forwardTime(1000, TimeUnit.MILLISECONDS);

  // Verify cancel sent to application when deadline just past
  verify(callListener).onClose(statusCaptor.capture(), metadataArgumentCaptor.capture());
  assertThat(statusCaptor.getValue().getDescription())
      .matches("deadline exceeded after [0-9]+\\.[0-9]+s. \\[remote_addr=127\\.0\\.0\\.1:443\\]");
  assertThat(statusCaptor.getValue().getCode()).isEqualTo(Code.DEADLINE_EXCEEDED);
  verify(stream, never()).cancel(statusCaptor.capture());

  fakeClock.forwardNanos(DEADLINE_EXPIRATION_CANCEL_DELAY_NANOS - 1);
  verify(stream, never()).cancel(any(Status.class));

  // verify cancel send to server is delayed with DEADLINE_EXPIRATION_CANCEL_DELAY
  fakeClock.forwardNanos(1);
  verify(stream).cancel(statusCaptor.capture());
  assertEquals(Status.Code.DEADLINE_EXCEEDED, statusCaptor.getValue().getCode());
  assertThat(statusCaptor.getValue().getDescription())
      .matches("deadline exceeded after [0-9]+\\.[0-9]+s. \\[remote_addr=127\\.0\\.0\\.1:443\\]");
}
 

@Test
public void settingCallOptionsWorks() {
    ManagedChannel channel = serverRule.getChannel();
    Deadline deadline = Deadline.after(42, TimeUnit.SECONDS);

    ReactorGreeterGrpc.ReactorGreeterStub stub = ReactorGreeterGrpc.newReactorStub(channel).withDeadline(deadline);

    assertThat(stub.getCallOptions().getDeadline()).isEqualTo(deadline);
}
 

@Test
public void testWithSessionLease() throws Exception {
    LockResponse lr = lockClient.lock(KeyUtils.bs("mylock"))
            .deadline(Deadline.after(500, TimeUnit.MILLISECONDS)).sync();

    ByteString lockKey = lr.getKey();
    assertNotNull(lockKey);
    assertTrue(kvClient.txnIf().exists(lockKey).sync().getSucceeded());

    assertNotNull(lockClient.unlock(lockKey).sync());
    assertFalse(kvClient.txnIf().exists(lockKey).sync().getSucceeded());
}
 

private long runInterruptibly(Stopwatch stopwatch) throws InterruptedException {
  final Thread fetcherThread = Thread.currentThread();
  workerContext.resumePoller(
      operationContext.poller,
      "InputFetcher",
      operationContext.queueEntry,
      QUEUED,
      () -> fetcherThread.interrupt(),
      Deadline.after(60, SECONDS));
  try {
    return fetchPolled(stopwatch);
  } finally {
    operationContext.poller.pause();
  }
}