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,