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: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.co 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:org.opendaylight.unimgr.mef.nrp.ovs.DataStoreTestUtils.java

public static void delete(InstanceIdentifier<?> instanceIdentifier, DataBroker dataBroker) {
    ReadWriteTransaction transaction = dataBroker.newReadWriteTransaction();
    transaction.delete(LogicalDatastoreType.OPERATIONAL, instanceIdentifier);

    Futures.addCallback(transaction.commit(), new FutureCallback<CommitInfo>() {
        @Override// w ww  . j a v a 2  s.  c  om
        public void onSuccess(@Nullable CommitInfo result) {
            LOG.debug("Object: {} deleted.", instanceIdentifier.toString());
        }

        @Override
        public void onFailure(Throwable t) {
            LOG.debug("Object: {} wasn't deleted due to a error: {}", instanceIdentifier.toString(),
                    t.getMessage());
            fail("Object wasn't deleted due to a error: " + t.getMessage());
        }
    }, MoreExecutors.directExecutor());
}

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/*w  w w. j a  v a2 s .co  m*/
        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();/*from w w w.  ja  v  a  2  s . 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: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//www. ja v  a2 s .  c  o  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.messenger.impl.MessengerMdsalUtils.java

/**
 * initialize the data tree for the given InstanceIdentifier type
 *
 * @param type data store type/*from   w ww.ja  v a2s  . c o  m*/
 * @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:com.vmware.photon.controller.clustermanager.statuschecks.SwarmStatusChecker.java

@Override
public void checkNodeStatus(final String serverAddress, final FutureCallback<Boolean> callback) {
    Preconditions.checkNotNull(serverAddress, "serverAddress cannot be null");
    logger.info("Checking Swarm: {}", serverAddress);

    try {//w ww .j  a va 2 s . c o  m
        String connectionString = createConnectionString(serverAddress);
        swarmClient.getNodeAddressesAsync(connectionString, new FutureCallback<Set<String>>() {
            @Override
            public void onSuccess(@Nullable Set<String> nodes) {
                if (!nodes.contains(serverAddress)) {
                    logger.info("Node not registered with Swarm: {}", serverAddress);
                    callback.onSuccess(false);
                    return;
                }
                callback.onSuccess(true);
            }

            @Override
            public void onFailure(Throwable t) {
                logger.warn("Swarm call failed: ", t);
                callback.onSuccess(false);
            }
        });
    } catch (Exception e) {
        logger.warn("Swarm call failed: ", e);
        callback.onSuccess(false);
    }
}

From source file:ubic.gemma.core.job.executor.common.TaskPostProcessingImpl.java

private FutureCallback<TaskResult> createEmailNotificationFutureCallback(
        final EmailNotificationContext context) {

    return new FutureCallback<TaskResult>() {
        private final EmailNotificationContext emailNotificationContext = context;

        @Override//from   ww w .j a va 2s.  co m
        public void onSuccess(TaskResult taskResult) {
            mailUtils.sendTaskCompletedNotificationEmail(emailNotificationContext, taskResult);
        }

        @Override
        public void onFailure(Throwable throwable) {
            TaskPostProcessingImpl.log
                    .error("Shouldn't happen since we take care of exceptions inside ExecutingTask. "
                            + throwable.getMessage());
        }
    };
}

From source file:org.opendaylight.netconf.sal.connect.netconf.sal.tx.ReadOnlyTx.java

public ReadOnlyTx(final NetconfBaseOps netconfOps, final RemoteDeviceId id) {
    this.netconfOps = netconfOps;
    this.id = id;

    // Simple logging callback to log result of read operation
    loggingCallback = new FutureCallback<DOMRpcResult>() {
        @Override//from ww w .  ja  va 2 s. co m
        public void onSuccess(final DOMRpcResult result) {
            if (AbstractWriteTx.isSuccess(result)) {
                LOG.trace("{}: Reading data successful", id);
            } else {
                LOG.warn("{}: Reading data unsuccessful: {}", id, result.getErrors());
            }

        }

        @Override
        public void onFailure(final Throwable t) {
            LOG.warn("{}: Reading data failed", id, t);
        }
    };
}

From source file:ubic.gemma.job.executor.common.TaskPostProcessingImpl.java

private FutureCallback<TaskResult> createEmailNotificationFutureCallback(
        final EmailNotificationContext context) {
    FutureCallback<TaskResult> futureCallback = new FutureCallback<TaskResult>() {
        private EmailNotificationContext emailNotifcationContext = context;

        @Override/* w  w  w  . jav a2 s  . c  o m*/
        public void onSuccess(TaskResult taskResult) {
            mailUtils.sendTaskCompletedNotificationEmail(emailNotifcationContext, taskResult);
        }

        @Override
        public void onFailure(Throwable throwable) {
            log.error("Shouldn't happen since we take care of exceptions inside ExecutingTask. "
                    + throwable.getMessage());
        }
    };

    return futureCallback;
}