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:com.continuuity.weave.internal.zookeeper.RewatchOnExpireZKClient.java

@Override
public OperationFuture<Stat> exists(String path, Watcher watcher) {
    final RewatchOnExpireWatcher wrappedWatcher = new RewatchOnExpireWatcher(this, ActionType.EXISTS, path,
            watcher);/*from  w  ww  .  j av  a 2  s. c  o  m*/
    OperationFuture<Stat> result = super.exists(path, wrappedWatcher);
    Futures.addCallback(result, new FutureCallback<Stat>() {
        @Override
        public void onSuccess(Stat result) {
            wrappedWatcher.setLastResult(result);
        }

        @Override
        public void onFailure(Throwable t) {
            // No-op
        }
    });
    return result;
}

From source file:org.anhonesteffort.p25.chnlzr.ChnlzrController.java

public ListenableFuture<SamplesSourceHandler> createSourceFor(ChannelRequest.Reader request) {
    P25DcodrMetrics.getInstance().chnlzrRequest(request.getCenterFrequency());

    ListenableFuture<ChnlzrConnectionHandler> connectFuture = factory.create(chnlzrHost);
    SettableFuture<SamplesSourceHandler> sourceFuture = SettableFuture.create();

    Futures.addCallback(connectFuture, new ChnlzrConnectionCallback(sourceFuture, request));

    return sourceFuture;
}

From source file:org.opendaylight.faas.fabricmgr.FabMgrDatastoreUtil.java

public static <T extends DataObject> void putData(final LogicalDatastoreType storeType,
        final InstanceIdentifier<T> path, final T data) {
    final WriteTransaction tx = FabMgrDatastoreDependency.getDataProvider().newWriteOnlyTransaction();
    tx.put(storeType, path, data, true);
    Futures.addCallback(tx.submit(), new FutureCallback<Void>() {

        @Override/*  www . ja  v  a  2 s. c  o  m*/
        public void onSuccess(final Void result) {
            LOG.trace("FABMGR: Data has put into datastore {} {}", storeType, path);
        }

        @Override
        public void onFailure(final Throwable t) {
            LOG.error("FABMGR: ERROR: Can not put data into datastore [store: {}] [path: {}] [exception: {}]",
                    storeType, path, t);
        }
    });

}

From source file:io.v.v23.syncbase.nosql.NoSql.java

private static ListenableFuture<Boolean> tryBatch(final VContext ctx, final Database db,
        final BatchOptions opts, final BatchOperation op) {
    final SettableFuture<Boolean> ret = SettableFuture.create();
    Futures.addCallback(db.beginBatch(ctx, opts), new FutureCallback<BatchDatabase>() {
        @Override//ww w .  j  a  v a  2s.  co m
        public void onFailure(Throwable t) {
            ret.setException(t);
        }

        @Override
        public void onSuccess(final BatchDatabase batch) {
            Futures.addCallback(op.run(batch), new FutureCallback<Void>() {
                @Override
                public void onFailure(final Throwable t) {
                    Futures.addCallback(batch.abort(ctx), new FutureCallback<Void>() {
                        @Override
                        public void onSuccess(Void result) {
                            ret.setException(t);
                        }

                        @Override
                        public void onFailure(Throwable newT) {
                            ret.setException(t);
                        }
                    });
                }

                @Override
                public void onSuccess(Void result) {
                    Futures.addCallback(batch.commit(ctx), new FutureCallback<Void>() {
                        @Override
                        public void onSuccess(Void result) {
                            ret.set(true); // success
                        }

                        @Override
                        public void onFailure(Throwable t) {
                            if (t instanceof ConcurrentBatchException) {
                                // retry
                                ret.set(false);
                            } else {
                                ret.setException(t);
                            }
                        }
                    });
                }
            });
        }
    });
    return ret;
}

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

/**
 * Construct a new instance.//from  w w w .j  av  a 2  s . com
 *
 * @param broker  The data broker service.
 * @param path    The path to the target data.
 * @param data    The data to be set into the MD-SAL operational datastore.
 */
public UpdateDataTask(DataBroker broker, InstanceIdentifier<T> path, T data) {
    super(broker);
    targetPath = path;
    targetData = data;
    Futures.addCallback(getFuture(), this);
}

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

public static <T, A, B, C> Future<Fun.Tuple4<T, A, B, C>> asFuture(ListenableFuture<T> future, A a, B b, C c) {
    final scala.concurrent.Promise<Fun.Tuple4<T, A, B, C>> promise = new DefaultPromise<Fun.Tuple4<T, A, B, C>>();
    Futures.addCallback(future, new FutureCallback<T>() {
        @Override//from   w  w w  .j  a v a2s.c om
        public void onSuccess(T result) {
            promise.success(new Fun.Tuple4<T, A, B, C>(result, a, b, c));
        }

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

From source file:com.microsoft.office.integration.test.ContactsAsyncTestCase.java

public void testRead() {
    // create contact first
    prepareContact();/* w  ww.  j a  v  a  2s. com*/
    counter = new CountDownLatch(1);
    Futures.addCallback(Me.flushAsync(), new FutureCallback<Void>() {
        public void onFailure(Throwable t) {
            reportError(t);
            counter.countDown();
        }

        public void onSuccess(Void result) {
            try {
                readAndCheck();
                // clean-up
                removeContact();
            } catch (Throwable t) {
                reportError(t);
            }

            counter.countDown();
        }
    });

    try {
        if (!counter.await(60000, TimeUnit.MILLISECONDS)) {
            fail("testRead() timed out");
        }
    } catch (InterruptedException e) {
        fail("testRead() has been interrupted");
    }
}

From source file:org.opendaylight.messenger.impl.MessengerMdsalUtils.java

/**
 * initialize the data tree for the given InstanceIdentifier type
 *
 * @param type data store type//from w  w w.  java 2s .c  om
 * @param dataBroker Mdsal data Broker
 * @param iid InstanceIdentifier type
 * @param object data object
 */
public static <T extends DataObject> void initalizeDatastore(final LogicalDatastoreType type,
        final DataBroker dataBroker, final InstanceIdentifier<T> iid, final T object) {
    // Put data to MD-SAL data store
    final WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
    transaction.put(type, iid, object);

    // Perform the transaction.submit asynchronously
    Futures.addCallback(transaction.submit(), new FutureCallback<Void>() {
        @Override
        public void onFailure(final Throwable throwable) {
            LOG.error("initDatastore: transaction failed");
        }

        @Override
        public void onSuccess(final Void result) {
            LOG.debug("initDatastore: transaction succeeded");
        }
    });
    LOG.info("initDatastore: data populated: {}, {}, {}", type, iid, object);
}

From source file:io.radiowitness.kinesis.consumer.KinesisRecordConsumerFactory.java

@Override
public IRecordProcessor createProcessor() {
    log.info("creating new record consumer");
    SettableFuture<ShutdownReason> shutdown = SettableFuture.create();
    Futures.addCallback(shutdown, this);
    return create(shutdown);
}

From source file:org.apache.hadoop.hdfs.qjournal.client.QuorumCall.java

static <KEY, RESULT> QuorumCall<KEY, RESULT> create(Map<KEY, ? extends ListenableFuture<RESULT>> calls) {
    final QuorumCall<KEY, RESULT> qr = new QuorumCall<KEY, RESULT>();
    for (final Entry<KEY, ? extends ListenableFuture<RESULT>> e : calls.entrySet()) {
        Preconditions.checkArgument(e.getValue() != null, "null future for key: " + e.getKey());
        Futures.addCallback(e.getValue(), new FutureCallback<RESULT>() {
            @Override/*from w ww . j  av  a2s.  c  o m*/
            public void onFailure(Throwable t) {
                qr.addException(e.getKey(), t);
            }

            @Override
            public void onSuccess(RESULT res) {
                qr.addResult(e.getKey(), res);
            }
        });
    }
    return qr;
}