Java Code Examples for io.grpc.Deadline#after()

@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));

  interceptor.handleUpdate(serviceConfig);

  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);
}
 

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);
}
 

@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 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();
}
 

@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 boolean directoryEntryExists(
    Path path, DirectoryEntry dirEntry, Map<Digest, Directory> directoriesIndex) {
  if (!dirEntry.existsDeadline.isExpired()) {
    return true;
  }

  if (directoryExists(path, dirEntry.directory, directoriesIndex)) {
    dirEntry.existsDeadline = Deadline.after(10, SECONDS);
    return true;
  }
  return false;
}
 

@Test
public void testConfigureDeadline() {
  Deadline deadline = Deadline.after(2, NANOSECONDS);
  // Create a default stub
  TestServiceGrpc.TestServiceBlockingStub stub = TestServiceGrpc.newBlockingStub(channel);
  assertNull(stub.getCallOptions().getDeadline());
  // Reconfigure it
  TestServiceGrpc.TestServiceBlockingStub reconfiguredStub = stub.withDeadline(deadline);
  // New altered config
  assertEquals(deadline, reconfiguredStub.getCallOptions().getDeadline());
  // Default config unchanged
  assertNull(stub.getCallOptions().getDeadline());
}
 

@Test
public void testDeadlinePropagation() throws Exception {
  final AtomicInteger recursionDepthRemaining = new AtomicInteger(3);
  final SettableFuture<Deadline> finalDeadline = SettableFuture.create();
  class DeadlineSaver extends TestServiceGrpc.TestServiceImplBase {
    @Override
    public void unaryCall(final SimpleRequest request,
        final StreamObserver<SimpleResponse> responseObserver) {
      Context.currentContextExecutor(otherWork).execute(new Runnable() {
        @Override
        public void run() {
          try {
            if (recursionDepthRemaining.decrementAndGet() == 0) {
              finalDeadline.set(Context.current().getDeadline());
              responseObserver.onNext(SimpleResponse.getDefaultInstance());
            } else {
              responseObserver.onNext(blockingStub.unaryCall(request));
            }
            responseObserver.onCompleted();
          } catch (Exception ex) {
            responseObserver.onError(ex);
          }
        }
      });
    }
  }

  server = InProcessServerBuilder.forName("channel").executor(otherWork)
      .addService(new DeadlineSaver())
      .build().start();

  Deadline initialDeadline = Deadline.after(1, TimeUnit.MINUTES);
  blockingStub.withDeadline(initialDeadline).unaryCall(SimpleRequest.getDefaultInstance());
  assertNotSame(initialDeadline, finalDeadline);
  // Since deadline is re-calculated at each hop, some variance is acceptable and expected.
  assertAbout(deadline())
      .that(finalDeadline.get()).isWithin(1, TimeUnit.SECONDS).of(initialDeadline);
}
 

private void runSlowFallbackAfterStartup() throws Exception {
  initStub();
  assertEquals(
      GrpclbRouteType.GRPCLB_ROUTE_TYPE_BACKEND,
      doRpcAndGetPath(Deadline.after(20, TimeUnit.SECONDS)));
  runShellCmd(blackholeLbAndBackendAddrsCmd);
  final Deadline fallbackDeadline = Deadline.after(40, TimeUnit.SECONDS);
  waitForFallbackAndDoRpcs(fallbackDeadline);
}
 

@Test
public void testDeadlinePropagation() throws Exception {
  final AtomicInteger recursionDepthRemaining = new AtomicInteger(3);
  final SettableFuture<Deadline> finalDeadline = SettableFuture.create();
  class DeadlineSaver extends TestServiceGrpc.TestServiceImplBase {
    @Override
    public void unaryCall(final SimpleRequest request,
        final StreamObserver<SimpleResponse> responseObserver) {
      Context.currentContextExecutor(otherWork).execute(new Runnable() {
        @Override
        public void run() {
          try {
            if (recursionDepthRemaining.decrementAndGet() == 0) {
              finalDeadline.set(Context.current().getDeadline());
              responseObserver.onNext(SimpleResponse.getDefaultInstance());
            } else {
              responseObserver.onNext(blockingStub.unaryCall(request));
            }
            responseObserver.onCompleted();
          } catch (Exception ex) {
            responseObserver.onError(ex);
          }
        }
      });
    }
  }

  server = InProcessServerBuilder.forName("channel").executor(otherWork)
      .addService(new DeadlineSaver())
      .build().start();

  Deadline initialDeadline = Deadline.after(1, TimeUnit.MINUTES);
  blockingStub.withDeadline(initialDeadline).unaryCall(SimpleRequest.getDefaultInstance());
  assertNotSame(initialDeadline, finalDeadline);
  // Since deadline is re-calculated at each hop, some variance is acceptable and expected.
  assertAbout(deadline())
      .that(finalDeadline.get()).isWithin(1, TimeUnit.SECONDS).of(initialDeadline);
}
 

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;
}
 

@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 settingCallOptionsWorks() {
    ManagedChannel channel = serverRule.getChannel();
    Deadline deadline = Deadline.after(42, TimeUnit.SECONDS);

    RxGreeterGrpc.RxGreeterStub stub = RxGreeterGrpc.newRxStub(channel).withDeadline(deadline);

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

@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));

  interceptor.handleUpdate(serviceConfig);

  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 testConfigureDeadline() {
  Deadline deadline = Deadline.after(2, NANOSECONDS);
  // Create a default stub
  TestServiceGrpc.TestServiceBlockingStub stub = TestServiceGrpc.newBlockingStub(channel);
  assertNull(stub.getCallOptions().getDeadline());
  // Reconfigure it
  TestServiceGrpc.TestServiceBlockingStub reconfiguredStub = stub.withDeadline(deadline);
  // New altered config
  assertEquals(deadline, reconfiguredStub.getCallOptions().getDeadline());
  // Default config unchanged
  assertNull(stub.getCallOptions().getDeadline());
}
 

private void processRootFile(
    Path file,
    ImmutableList.Builder<Path> computeDirs,
    ImmutableList.Builder<Path> deleteFiles,
    ImmutableMap.Builder<Object, Entry> fileKeys)
    throws IOException, InterruptedException {

  String basename = file.getFileName().toString();

  // ignore our directories index database
  // indexes will be removed and rebuilt for compute
  if (!basename.equals(directoriesIndexDbName)) {
    FileStatus stat = stat(file, false);

    // mark directory for later key compute
    if (file.toString().endsWith("_dir")) {
      if (stat.isDirectory()) {
        synchronized (computeDirs) {
          computeDirs.add(file);
        }
      } else {
        synchronized (deleteFiles) {
          deleteFiles.add(file);
        }
      }
    } else if (stat.isDirectory()) {
      synchronized (deleteFiles) {
        deleteFiles.add(file);
      }
    } else {
      // if cas is full or entry is oversized or empty, mark file for later deletion.
      long size = stat.getSize();
      if (sizeInBytes + size > maxSizeInBytes || size > maxEntrySizeInBytes || size == 0) {
        synchronized (deleteFiles) {
          deleteFiles.add(file);
        }
      } else {
        // get the key entry from the file name.
        FileEntryKey fileEntryKey = parseFileEntryKey(basename, stat.getSize());

        // if key entry file name cannot be parsed, mark file for later deletion.
        if (fileEntryKey == null
            || stat.isReadOnlyExecutable() != fileEntryKey.getIsExecutable()) {
          synchronized (deleteFiles) {
            deleteFiles.add(file);
          }
        } else {
          // populate key it is not currently stored.
          String key = fileEntryKey.getKey();
          Entry e = new Entry(key, size, Deadline.after(10, SECONDS));
          synchronized (fileKeys) {
            fileKeys.put(getFileKey(root.resolve(key), stat), e);
          }
          storage.put(e.key, e);
          onPut.accept(fileEntryKey.getDigest());
          synchronized (CASFileCache.this) {
            e.decrementReference(header);
          }
          sizeInBytes += size;
        }
      }
    }
  }
}
 

public Poller(Duration period) {
  checkState(period.getSeconds() > 0 || period.getNanos() >= 1000);
  periodMicros = period.getSeconds() * 1000000 + period.getNanos() / 1000;
  periodDeadline = Deadline.after(periodMicros, MICROSECONDS);
}
 

private void runFastFallbackBeforeStartup() throws Exception {
  runShellCmd(unrouteLbAndBackendAddrsCmd);
  final Deadline fallbackDeadline = Deadline.after(5, TimeUnit.SECONDS);
  initStub();
  waitForFallbackAndDoRpcs(fallbackDeadline);
}
 

private void runSlowFallbackBeforeStartup() throws Exception {
  runShellCmd(blackholeLbAndBackendAddrsCmd);
  final Deadline fallbackDeadline = Deadline.after(20, TimeUnit.SECONDS);
  initStub();
  waitForFallbackAndDoRpcs(fallbackDeadline);
}
 

protected static Deadline getDeadline() {
    return Deadline.after(10, TimeUnit.SECONDS);
}