How to use

run

method

in

org.apache.bookkeeper.common.util.Retries

private void cleanupOffloaded(long ledgerId, UUID uuid, String offloadDriverName, /*
                                          * TODO: use driver name to
                                          * identify offloader
                                          */
    Map<String, String> offloadDriverMetadata, String cleanupReason) {
  Retries.run(Backoff.exponentialJittered(TimeUnit.SECONDS.toMillis(1), TimeUnit.SECONDS.toHours(1)).limit(10),
      Retries.NonFatalPredicate,
      () -> config.getLedgerOffloader().deleteOffloaded(ledgerId, uuid, offloadDriverMetadata),
      scheduledExecutor, name).whenComplete((ignored, exception) -> {
        if (exception != null) {
          log.warn("Error cleaning up offload for {}, (cleanup reason: {})", ledgerId, cleanupReason,
              exception);
        }
      });
}

.thenCompose(readHandle -> config.getLedgerOffloader().offload(readHandle, uuid, extraMetadata))
.thenCompose((ignore) -> {
    return Retries.run(Backoff.exponentialJittered(TimeUnit.SECONDS.toMillis(1),
                            TimeUnit.SECONDS.toHours(1)).limit(10),
              FAIL_ON_CONFLICT,

/**
 * Retry a given {@code task} on failures.
 *
 * <p>It is a shortcut of {@link #run(Stream, Predicate, Supplier, OrderedScheduler, Object)}
 * that runs retries on any threads in the provided {@code scheduler}.
 *
 * @param backoffs       a stream of backoff delays, in milliseconds.
 * @param retryPredicate a predicate to test if failures are retryable.
 * @param task           a task to execute.
 * @param scheduler      scheduler to schedule the task and complete the futures.
 * @param <ReturnT>      the return type
 * @return future represents the result of the task with retries.
 */
public static <ReturnT> CompletableFuture<ReturnT> run(
  Stream<Long> backoffs,
  Predicate<Throwable> retryPredicate,
  Supplier<CompletableFuture<ReturnT>> task,
  OrderedScheduler scheduler) {
  return run(backoffs, retryPredicate, task, scheduler, null);
}

private <T> CompletableFuture<T> runRpcWithRetries(
    Supplier<CompletableFuture<T>> futureSupplier) {
  return Retries.run(
    backoffPolicy.toBackoffs(),
    ROOT_RANGE_CLIENT_RETRY_PREDICATE,
    futureSupplier,
    scheduler);
}

/**
 * Run the action with retries.
 *
 * @param action action to run
 * @return the result of the action
 */
public <T> CompletableFuture<T> execute(Supplier<CompletableFuture<T>> action) {
  return Retries.run(
    backoffPolicy.toBackoffs(),
    retryPredicate,
    action,
    scheduler
  );
}

/**
 * Run the action with retries.
 *
 * @param action action to run
 * @return the result of the action
 */
public <T> CompletableFuture<T> executeListenable(Supplier<ListenableFuture<T>> action) {
  return Retries.run(
    backoffPolicy.toBackoffs(),
    retryPredicate,
    () -> fromListenableFuture(action.get()),
    scheduler
  );
}

private void cleanupOffloaded(long ledgerId,
               UUID uuid,
               String offloadDriverName, /* TODO: use driver name to identify offloader */
               Map<String, String> offloadDriverMetadata,
               String cleanupReason) {
  Retries.run(Backoff.exponentialJittered(TimeUnit.SECONDS.toMillis(1), TimeUnit.SECONDS.toHours(1)).limit(10),
        Retries.NonFatalPredicate,
        () -> config.getLedgerOffloader().deleteOffloaded(ledgerId, uuid, offloadDriverMetadata),
        scheduledExecutor, name)
    .whenComplete((ignored, exception) -> {
        if (exception != null) {
          log.warn("Error cleaning up offload for {}, (cleanup reason: {})",
               ledgerId, cleanupReason, exception);
        }
      });
}

@Override
public CompletableFuture<List<OneStorageContainerEndpointResponse>>
locateStorageContainers(List<Revisioned<Long>> storageContainerIds) {
  GetStorageContainerEndpointRequest request = createGetStorageContainerEndpointRequest(storageContainerIds);
  return Retries.run(
    getDefaultBackoffs(),
    LOCATE_STORAGE_CONTAINERS_RETRY_PREDICATE,
    () -> fromListenableFuture(
      locationService.getStorageContainerEndpoint(request),
      GetStorageContainerEndpointsFunction),
    scheduler,
    request);
}

.thenCompose(readHandle -> config.getLedgerOffloader().offload(readHandle, uuid, extraMetadata))
.thenCompose((ignore) -> {
    return Retries.run(Backoff.exponentialJittered(TimeUnit.SECONDS.toMillis(1),
                            TimeUnit.SECONDS.toHours(1)).limit(10),
              FAIL_ON_CONFLICT,