Example usage for com.google.common.util.concurrent FutureCallback FutureCallback

Introduction

In this page you can find the example usage for com.google.common.util.concurrent FutureCallback FutureCallback.

Prototype

FutureCallback

Source Link

Usage

From source file:com.spotify.apollo.concurrent.Util.java

public static <T> CompletionStage<T> asStage(ListenableFuture<T> future) {
    CompletableFuture<T> completableFuture = new CompletableFuture<>();

    Futures.addCallback(future, new FutureCallback<T>() {
        @Override//w w w  .j  av  a  2s .c o  m
        public void onSuccess(T result) {
            completableFuture.complete(result);
        }

        @Override
        public void onFailure(Throwable t) {
            completableFuture.completeExceptionally(t);
        }
    });

    return completableFuture;
}

From source file:info.archinnov.achilles.internals.futures.FutureUtils.java

public static <T> CompletableFuture<T> toCompletableFuture(ListenableFuture<T> listenableFuture,
        ExecutorService executor) {
    CompletableFuture<T> completable = new CompletableListenableFuture<>(listenableFuture);

    Futures.addCallback(listenableFuture, new FutureCallback<T>() {
        @Override/*from ww w  . j  ava2  s  .  c o  m*/
        public void onSuccess(T result) {
            completable.complete(result);
        }

        @Override
        public void onFailure(Throwable t) {
            completable.completeExceptionally(t);
        }
    }, executor);

    return completable;
}

From source file:com.vmware.photon.controller.common.zookeeper.ServiceNodeUtils.java

public static void joinService(final ServiceNode serviceNode, final long retryIntervalMsec,
        final ServiceNodeEventHandler serviceNodeEventHandler) {
    Futures.addCallback(serviceNode.join(), new FutureCallback<ServiceNode.Lease>() {
        @Override/*from ww w  .j a va  2 s. co  m*/
        public void onSuccess(ServiceNode.Lease result) {
            if (serviceNodeEventHandler != null) {
                serviceNodeEventHandler.onJoin();
            }
            handleLeaseExpiration(result, serviceNode, retryIntervalMsec, serviceNodeEventHandler);
        }

        @Override
        public void onFailure(Throwable t) {
            // This could happen when connection to ZK goes away while we were trying to join the service.
            // The proper way to proceed seems to be to just try to join again, rather than exit the process.
            logger.error("Could not acquire service lease", t);
            logger.debug("Sleeping for {} before retrying", retryIntervalMsec);
            try {
                Thread.sleep(retryIntervalMsec);
            } catch (InterruptedException e) {
                logger.error("Failed to sleep between registration retries", e);
            }
            joinService(serviceNode, retryIntervalMsec, serviceNodeEventHandler);
        }
    });
}

From source file:io.bitsquare.trade.protocol.trade.taker.tasks.PayTakeOfferFee.java

public static void run(ResultHandler resultHandler, ExceptionHandler exceptionHandler,
        WalletService walletService, String tradeId) {
    log.trace("Run task");
    try {//from   ww  w  . ja  v  a2 s.c o  m
        walletService.payTakeOfferFee(tradeId, new FutureCallback<Transaction>() {
            @Override
            public void onSuccess(Transaction transaction) {
                log.debug(
                        "Take offer fee paid successfully. Transaction ID = " + transaction.getHashAsString());
                resultHandler.onResult(transaction.getHashAsString());
            }

            @Override
            public void onFailure(@NotNull Throwable t) {
                log.error("Take offer fee paid faultHandler.onFault with exception: " + t);
                exceptionHandler.handleException(
                        new Exception("Take offer fee paid faultHandler.onFault with exception: " + t));
            }
        });
    } catch (InsufficientMoneyException e) {
        log.error("Take offer fee paid faultHandler.onFault due InsufficientMoneyException " + e);
        exceptionHandler.handleException(new Exception(
                "Take offer fee paid faultHandler.onFault due to InsufficientMoneyException " + e));
    }
}

From source file:com.spotify.heroic.metric.datastax.Async.java

/**
 * Helper method to convert a {@link ListenableFuture} to an {@link AsyncFuture}.
 *//*from ww w  . j  av  a 2 s.co  m*/
public static <T> AsyncFuture<T> bind(AsyncFramework async, ListenableFuture<T> source) {
    final ResolvableFuture<T> target = async.future();

    Futures.addCallback(source, new FutureCallback<T>() {
        @Override
        public void onSuccess(T result) {
            target.resolve(result);
        }

        @Override
        public void onFailure(Throwable t) {
            target.fail(t);
        }
    });

    target.onCancelled(() -> {
        source.cancel(false);
    });

    return target;
}

From source file:de.xaniox.heavyspleef.core.persistence.MoreFutures.java

/**
 * Add a callback to a {@link ListenableFuture}
 * to be run on the bukkit main thread/*from w  ww  .  j a  v a 2 s .  com*/
 * 
 * @param plugin The plugin registering the callback
 * @param future The {@link ListenableFuture} to add this callback
 * @param callback The callback to be called
 */
public static <T> void addBukkitSyncCallback(final Plugin plugin, ListenableFuture<T> future,
        final FutureCallback<T> callback) {
    Futures.addCallback(future, new FutureCallback<T>() {
        @Override
        public void onFailure(final Throwable cause) {
            Bukkit.getScheduler().runTask(plugin, new Runnable() {

                @Override
                public void run() {
                    callback.onFailure(cause);
                }
            });
        }

        @Override
        public void onSuccess(final T result) {
            Bukkit.getScheduler().runTask(plugin, new Runnable() {

                @Override
                public void run() {
                    callback.onSuccess(result);
                }
            });
        }
    });
}

From source file:com.microsoft.office365.http.SharepointCookieCredentials.java

public static ListenableFuture<CookieCredentials> requestCredentials(String sharepointSiteUrl,
        Activity activity) {/*from ww  w . j  a  va2 s  .c  o m*/
    final SettableFuture<CookieCredentials> future = SettableFuture.create();

    ListenableFuture<String> login = showLoginForCookies(activity, sharepointSiteUrl);

    Futures.addCallback(login, new FutureCallback<String>() {
        @Override
        public void onFailure(Throwable t) {
            future.setException(t);
        }

        @Override
        public void onSuccess(String cookies) {
            future.set(new CookieCredentials(cookies));
        }
    });

    return future;
}

From source file:net.javacrumbs.futureconverter.guavarx.ListenableFutureObservable.java

private static <T> OnSubscribe<T> onSubscribe(final ListenableFuture<T> listenableFuture) {
    return new Observable.OnSubscribe<T>() {
        @Override//from   w  w  w . j  a v  a2  s  .c om
        public void call(final Subscriber<? super T> subscriber) {
            Futures.addCallback(listenableFuture, new FutureCallback<T>() {
                @Override
                public void onSuccess(T result) {
                    if (!subscriber.isUnsubscribed()) {
                        subscriber.onNext(result);
                        subscriber.onCompleted();
                    }
                }

                @Override
                public void onFailure(Throwable t) {
                    if (!subscriber.isUnsubscribed()) {
                        subscriber.onError(t);
                    }
                }
            });
        }
    };
}

From source file:org.thingsboard.server.kafka.AsyncCallbackTemplate.java

public static <T> void withCallback(ListenableFuture<T> future, Consumer<T> onSuccess,
        Consumer<Throwable> onFailure, Executor executor) {
    FutureCallback<T> callback = new FutureCallback<T>() {
        @Override//from ww w . j  a  va  2s.c o  m
        public void onSuccess(T result) {
            try {
                onSuccess.accept(result);
            } catch (Throwable th) {
                onFailure(th);
            }
        }

        @Override
        public void onFailure(Throwable t) {
            onFailure.accept(t);
        }
    };
    if (executor != null) {
        Futures.addCallback(future, callback, executor);
    } else {
        Futures.addCallback(future, callback);
    }
}

From source file:com.noorq.casser.support.Scala.java

public static <T, A> Future<Fun.Tuple2<T, A>> asFuture(ListenableFuture<T> future, A a) {
    final scala.concurrent.Promise<Fun.Tuple2<T, A>> promise = new DefaultPromise<Fun.Tuple2<T, A>>();
    Futures.addCallback(future, new FutureCallback<T>() {
        @Override/*  ww  w .j a v  a2 s  .c o  m*/
        public void onSuccess(T result) {
            promise.success(new Fun.Tuple2<T, A>(result, a));
        }

        @Override
        public void onFailure(Throwable t) {
            promise.failure(t);
        }
    });
    return promise.future();
}