public static <T> void copyResults(CompletableFuture<T> source, CompletableFuture<T> target) { source.whenComplete((o, throwable) -> { if (throwable != null) { target.completeExceptionally(throwable); return; } target.complete(o); }); }
@edu.umd.cs.findbugs.annotations.SuppressWarnings(value="NP_NONNULL_PARAM_VIOLATION", justification="it is valid to pass NULL to CompletableFuture#completedFuture") private CompletableFuture<Void> closeConn() { CompletableFuture<AsyncConnection> f = future.get(); if (f == null) { return CompletableFuture.completedFuture(null); } CompletableFuture<Void> closeFuture = new CompletableFuture<>(); f.whenComplete((conn, error) -> { if (error == null) { IOUtils.closeQuietly(conn); } closeFuture.complete(null); }); return closeFuture; }
@SuppressWarnings("unchecked") public static void linkFuturesOnError(CompletableFuture source, CompletableFuture target) { if (source != null && (!source.isDone() || source.isCompletedExceptionally())) { ((CompletableFuture<Object>) source).whenComplete((r, e) -> { if (e != null) { target.completeExceptionally(e); } }); } }
@Override public CompletableFuture<Void> abort() { TransactionId transactionId = this.transactionId; if (transactionId == null) { return CompletableFuture.completedFuture(null); } CompletableFuture<Void> future = new CompletableFuture<>(); transactionService.complete(transactionId).whenComplete((completeResult, completeError) -> Futures.allOf(participants.stream().map(TransactionParticipant::close).collect(Collectors.toList())) .whenComplete((closeResult, closeError) -> { if (completeError != null) { future.completeExceptionally(completeError); } else if (closeError != null) { future.completeExceptionally(closeError); } else { future.complete(null); } })); return future; }
@Override public CompletableFuture<Void> release(T object) { if (!all.contains(object)) { return Futures.failed(NOT_PART_OF_POOL); } if (idleCount.get() >= getMaxIdle()) { return destroy0(object); } if (isTestOnRelease()) { CompletableFuture<Boolean> valid = factory.validate(object); CompletableFuture<Void> res = new CompletableFuture<>(); valid.whenComplete((state1, throwable) -> { if (state1 != null && state1) { return0(object).whenComplete((x, y) -> res.complete(null)); } else { destroy0(object).whenComplete((x, y) -> res.complete(null)); } }); return res; } return return0(object); }
private void executeActionAsync( final CompletableFuture<KvStateResponse> result, final KvStateRequest request, final boolean update) { if (!result.isDone()) { final CompletableFuture<KvStateResponse> operationFuture = getState(request, update); operationFuture.whenCompleteAsync( (t, throwable) -> { if (throwable != null) { if ( throwable.getCause() instanceof UnknownKvStateIdException || throwable.getCause() instanceof UnknownKvStateKeyGroupLocationException || throwable.getCause() instanceof ConnectException ) { // These failures are likely to be caused by out-of-sync // KvStateLocation. Therefore we retry this query and // force look up the location. LOG.debug("Retrying after failing to retrieve state due to: {}.", throwable.getCause().getMessage()); executeActionAsync(result, request, true); } else { result.completeExceptionally(throwable); } } else { result.complete(t); } }, queryExecutor); result.whenComplete( (t, throwable) -> operationFuture.cancel(false)); } }
public static <U> CompletableFuture<List<U>> each(List<CompletableFuture<U>> futures) { CompletableFuture<List<U>> overallResult = new CompletableFuture<>(); CompletableFuture .allOf(futures.toArray(new CompletableFuture[0])) .whenComplete((noUsed, exception) -> { if (exception != null) { overallResult.completeExceptionally(exception); return; } List<U> results = new ArrayList<>(); for (CompletableFuture<U> future : futures) { results.add(future.join()); } overallResult.complete(results); }); return overallResult; }
CompletableFuture<RaftServer> future = new AtomixFuture<>(); openFuture = future; joiner.get().whenComplete((result, error) -> { if (error == null) { context.awaitState(RaftContext.State.READY, state -> { started = true; future.complete(null); }); } else { future.completeExceptionally(error); return openFuture.whenComplete((result, error) -> { if (error == null) { log.debug("Server started successfully!");
@Override protected void doCall() { conn.getMasterStub().whenComplete((stub, error) -> { if (error != null) { onError(error, () -> "Get async master stub failed", err -> { }); return; } resetCallTimeout(); callable.call(controller, stub).whenComplete((result, error2) -> { if (error2 != null) { onError(error2, () -> "Call to master failed", err -> { }); return; } future.complete(result); }); }); } }
/** * Closes the primary-backup partition. */ public CompletableFuture<Void> close() { if (client == null) { return CompletableFuture.completedFuture(null); } CompletableFuture<Void> future = new CompletableFuture<>(); client.stop().whenComplete((clientResult, clientError) -> { if (server != null) { server.stop().whenComplete((serverResult, serverError) -> { future.complete(null); }); } else { future.complete(null); } }); return future; }
public static <R, S, P extends Message, Q extends Message, T extends Message> CompletableFuture<R> median(AsyncTable<AdvancedScanResultConsumer> table, ColumnInterpreter<R, S, P, Q, T> ci, Scan scan) { CompletableFuture<R> future = new CompletableFuture<>(); sumByRegion(table, ci, scan).whenComplete((sumByRegion, error) -> { if (error != null) { future.completeExceptionally(error); } else if (sumByRegion.isEmpty()) { future.completeExceptionally(new NoSuchElementException()); } else { findMedian(future, table, ci, ReflectionUtils.newInstance(scan.getClass(), scan), sumByRegion); } }); return future; } }
(failForUnknownKeyOrNamespace && throwable.getCause() instanceof UnknownKeyOrNamespaceException) ) { resultFuture.completeExceptionally(throwable.getCause()); } else if (deadline.hasTimeLeft()) { getKvStateIgnoringCertainExceptions( resultFuture.complete(result); resultFuture.whenComplete((result, throwable) -> expected.cancel(false));
public static CompletableFuture<Void> waitForAll(List<CompletableFuture<Void>> futures) { final CompletableFuture<Void> compositeFuture = new CompletableFuture<>(); final AtomicInteger count = new AtomicInteger(futures.size()); for (CompletableFuture<Void> future : futures) { future.whenComplete((r, ex) -> { if (ex != null) { compositeFuture.completeExceptionally(ex); } else if (count.decrementAndGet() == 0) { // All the pending futures did complete compositeFuture.complete(null); } }); } if (futures.isEmpty()) { compositeFuture.complete(null); } return compositeFuture; } }
requestBootstrapFromPeer(peer).whenComplete((result, error) -> { if (error == null) { if (successful.compareAndSet(false, true)) { future.complete(null); } else if (totalCount.incrementAndGet() == totalPeers) { Throwable e = lastError.get(); if (e != null) { future.completeExceptionally(e); future.completeExceptionally(error); } else { lastError.set(error);
/** * Sends an update to the given node. * * @param member the node to which to send the update */ private CompletableFuture<Void> updateNode(Member member) { long updateTime = System.currentTimeMillis(); long lastUpdateTime = updateTimes.getOrDefault(member.id(), 0L); Collection<InternalSubscriptionInfo> subscriptions = topics.values() .stream() .flatMap(t -> t.remoteSubscriptions().stream().filter(subscriber -> subscriber.timestamp().unixTimestamp() >= lastUpdateTime)) .collect(Collectors.toList()); CompletableFuture<Void> future = new CompletableFuture<>(); messagingService.sendAndReceive(member.address(), GOSSIP_MESSAGE_SUBJECT, SERIALIZER.encode(subscriptions)) .whenComplete((result, error) -> { if (error == null) { updateTimes.put(member.id(), updateTime); } future.complete(null); }); return future; }
/** * Closes the log partition. */ public CompletableFuture<Void> close() { if (client == null) { return CompletableFuture.completedFuture(null); } CompletableFuture<Void> future = new CompletableFuture<>(); client.stop().whenComplete((clientResult, clientError) -> { if (server != null) { server.stop().whenComplete((serverResult, serverError) -> { future.complete(null); }); } else { future.complete(null); } }); return future; }
private <T> CompletableFuture<T> withTimeout(CompletableFuture<T> future, long timeoutNs, Supplier<String> timeoutMsg) { if (future.isDone() || timeoutNs <= 0) { return future; } Timeout timeoutTask = retryTimer.newTimeout(t -> { if (future.isDone()) { return; } future.completeExceptionally(new TimeoutIOException(timeoutMsg.get())); }, timeoutNs, TimeUnit.NANOSECONDS); return future.whenComplete((loc, error) -> { if (error != null && error.getClass() != TimeoutIOException.class) { // cancel timeout task if we are not completed by it. timeoutTask.cancel(); } }); }
private <R extends LogResponse> CompletableFuture<R> runOnContext(Supplier<CompletableFuture<R>> function) { CompletableFuture<R> future = new CompletableFuture<>(); threadContext.execute(() -> { function.get().whenComplete((response, error) -> { if (error == null) { future.complete(response); } else { future.completeExceptionally(error); } }); }); return future; }
LOG.debug("Start fetching meta region location from registry."); CompletableFuture<RegionLocations> future = metaRelocateFuture.get(); registry.getMetaRegionLocation().whenComplete((locs, error) -> { if (error != null) { LOG.debug("Failed to fetch meta region location from registry", error); metaRelocateFuture.getAndSet(null).completeExceptionally(error); return; future.complete(locs); }); } else {
future.whenComplete((v, t) -> { RpcResult rpcResult; if (t != null) { rFuture.complete(rpcResult); });