Example usage for com.google.common.util.concurrent Futures addCallback

Introduction

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

Prototype

public static <V> void addCallback(ListenableFuture<V> future, FutureCallback<? super V> callback)

Source Link

Document

Registers separate success and failure callbacks to be run when the Future 's computation is java.util.concurrent.Future#isDone() complete or, if the computation is already complete, immediately.

Usage

From source file:org.opendaylight.vtn.manager.it.ofmock.impl.DeleteTopologyNodeTask.java

/**
 * Construct a new instance.//from   w  w  w. j  av  a  2  s. c o m
 *
 * @param broker  The data broker service.
 * @param nid     The MD-SAL node identifier that specifies the target
 *                switch.
 */
public DeleteTopologyNodeTask(DataBroker broker, String nid) {
    super(broker);
    nodeId = nid;
    Futures.addCallback(getFuture(), this);
}

From source file:com.spotify.scio.extra.transforms.GuavaAsyncDoFn.java

@Override
protected ListenableFuture<OutputT> addCallback(ListenableFuture<OutputT> future,
        Function<OutputT, Void> onSuccess, Function<Throwable, Void> onFailure) {
    Futures.addCallback(future, new FutureCallback<OutputT>() {
        @Override//  www .  j  a va  2  s.  c  om
        public void onSuccess(@Nullable OutputT result) {
            onSuccess.apply(result);
        }

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

From source file:io.ucoin.ucoinj.elasticsearch.service.task.JobFuture.java

public void addCallback(FutureCallback<? super Job> callback) {
    Futures.addCallback(delegate, callback);
}

From source file:com.microsoft.artcurator.net.MessagesLoader.java

/**
 * Fetches the Outlook Folders visible to this user
 *
 * @param client   the client to make the request
 * @param callback callback to notify on success/failure
 *///from  w w  w .j  a  v a2 s. c  om
public static void getFoldersAsync(OutlookClient client, FutureCallback<List<Folder>> callback) {
    ListenableFuture<List<Folder>> future = client.getMe().getFolders().select("Id,DisplayName").read();
    Futures.addCallback(future, callback);
}

From source file:org.opendaylight.vtn.manager.it.ofmock.impl.DeleteTerminationPointTask.java

/**
 * Construct a new instance.// w w  w .ja  v a 2s. c  om
 *
 * @param broker  The data broker service.
 * @param port    An {@link OfPort} instance that specifies the termination
 *                point.
 */
public DeleteTerminationPointTask(DataBroker broker, OfPort port) {
    super(broker);
    targetPort = port;
    Futures.addCallback(getFuture(), this);
}

From source file:org.opendaylight.genius.interfacemanager.renderer.ovs.utilities.IfmClusterUtils.java

public static void runOnlyInLeaderNode(final Runnable job, String entity) {
    ListenableFuture<Boolean> checkEntityOwnerFuture = ClusteringUtils
            .checkNodeEntityOwner(ifaceServiceProvider.getEntityOwnershipService(), entity, entity);
    Futures.addCallback(checkEntityOwnerFuture, new FutureCallback<Boolean>() {
        @Override/*from w w w.  j  av  a  2s .c o  m*/
        public void onSuccess(Boolean isOwner) {
            LOG.debug("scheduling job {} ", isOwner);
            if (isOwner) {
                job.run();
            } else {
                LOG.trace("job is not run as node is not owner for :{} ", INTERFACE_CONFIG_ENTITY);
            }
        }

        @Override
        public void onFailure(Throwable error) {
            LOG.error("Failed to identify owner for entity {} due to {}", INTERFACE_CONFIG_ENTITY, error);
        }
    });
}

From source file:org.opendaylight.vtn.manager.internal.util.concurrent.FutureCanceller.java

/**
 * Set a future canceller that cancels the given future.
 *
 * @param timer    A {@link Timer} instance to execute the timer.
 * @param timeout  The number of milliseconds to wait for completion of
 *                 the target task./*  w  ww  . j  a v  a2  s .  c o  m*/
 * @param f        A {@link ListenableFuture} instance associated with the
 *                 task to wait.
 * @param intr     {@code true} if the task runner thread should be
 *                 interrupted. Otherwise in-progress task are allowed
 *                 to complete.
 * @param <T>      The type of the result returned by the target task.
 */
public static <T> void set(Timer timer, long timeout, ListenableFuture<T> f, boolean intr) {
    if (!f.isDone()) {
        FutureCanceller<T> canceller = new FutureCanceller<T>(f, intr);
        timer.schedule(canceller, timeout);
        Futures.addCallback(f, canceller);
    }
}

From source file:org.sglover.nlp.AbstractEntityTagger.java

private void makeCall(final TaggerCall call, final EntityTaggerCallback callback) {
    final ListenableFuture<Entities> future = executorService.submit(call);
    Futures.addCallback(future, new FutureCallback<Entities>() {
        @Override//from w  w  w  . j a  v a 2 s.  com
        public void onSuccess(Entities entities) {
            callback.onSuccess(entities);
        }

        @Override
        public void onFailure(Throwable ex) {
            callback.onFailure(ex);
        }
    });
}

From source file:com.continuuity.loom.common.zookeeper.ZKClientExt.java

/**
 * Acts as {@link ZKClient#create(String, byte[], org.apache.zookeeper.CreateMode, boolean)} if node does not exist,
 * otherwise as {@link ZKClient#setData(String, byte[])}.
 *//*from w  w w. java2s  .  c om*/
public static ListenableFuture<SetResult> createOrSet(final ZKClient zkClient, final String path,
        @Nullable final byte[] data, final CreateMode createMode, final boolean createParent) {
    final SettableFuture<SetResult> resultFuture = SettableFuture.create();

    final OperationFuture<String> createResult = zkClient.create(path, data, createMode, createParent);
    Futures.addCallback(createResult, new FutureCallback<String>() {
        private final FutureCallback<String> createCallback = this;

        @Override
        public void onSuccess(String result) {
            resultFuture.set(new SetResult(result, null));
        }

        @Override
        public void onFailure(Throwable t) {
            if (causedBy(t, KeeperException.NodeExistsException.class)) {
                OperationFuture<Stat> setDataResult = zkClient.setData(path, data);
                Futures.addCallback(setDataResult, new FutureCallback<Stat>() {
                    @Override
                    public void onSuccess(Stat result) {
                        resultFuture.set(new SetResult(null, result));
                    }

                    @Override
                    public void onFailure(Throwable t) {
                        if (causedBy(t, KeeperException.NoNodeException.class)) {
                            Futures.addCallback(zkClient.create(path, data, createMode, createParent),
                                    createCallback);
                            return;
                        }
                        resultFuture.setException(t);
                    }
                });
                return;
            }
            resultFuture.setException(t);
        }
    });

    return resultFuture;
}

From source file:org.solovyev.tasks.ListenersAwareFutureTask.java

private ListenersAwareFutureTask(@Nonnull ListenableFutureTask<T> futureTask) {
    this.futureTask = futureTask;
    Futures.addCallback(futureTask, new FutureCallback<T>() {
        @Override//from  w w w  .j  a v a2  s. c  o m
        public void onSuccess(T result) {
            synchronized (listeners) {
                executed = true;
            }

            for (FutureCallback<T> listener : getListenersCopy()) {
                listener.onSuccess(result);
            }

            synchronized (listeners) {
                listeners.clear();
            }
        }

        @Override
        public void onFailure(Throwable t) {
            synchronized (listeners) {
                executed = true;
            }

            for (FutureCallback<T> listener : getListenersCopy()) {
                listener.onFailure(t);
            }

            synchronized (listeners) {
                listeners.clear();
            }
        }
    });
}