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.eclipse.emf.compare.ide.ui.internal.logical.resolver.ResourceDependencyRemoteResolver.java

public RemoteResolveComputation getRemoteResolveComputation(final SynchronizedResourceSet resourceSet,
        final URI uri, final DiagnosticSupport diagnostic, final ThreadSafeProgressMonitor tspm) {
    return new RemoteResolveComputation(scheduler, diagnostic, resourceSet, uri, new FutureCallback<Object>() {
        public void onSuccess(Object o) {
            if (!ResolutionUtil.isInterruptedOrCanceled(tspm)) {
                // do not report progress anymore when the task has been interrupted of canceled.
                // It speeds up the cancellation.
                tspm.worked(1);//from  w ww.j  av a  2 s .c  o m
            }
        }

        public void onFailure(Throwable t) {
            if (!ResolutionUtil.isInterruptedOrCanceled(tspm)) {
                // do not report progress or errors anymore when the task has been interrupted of
                // canceled. It speeds up the cancellation.
                tspm.worked(1);
                diagnostic.merge(BasicDiagnostic.toDiagnostic(t));
            }
        }
    }, tspm);
}

From source file:com.vmware.photon.controller.clustermanager.statuschecks.MesosStatusChecker.java

@Override
public void checkSlavesStatus(final String masterAddress, final List<String> slaveAddresses,
        final FutureCallback<Boolean> callback) {
    Preconditions.checkNotNull(slaveAddresses, "slaveAddresses cannot be null");
    Preconditions.checkArgument(slaveAddresses.size() > 0, "slaveAddresses cannot be empty");

    try {/*from  ww w.  j a v a 2 s  . co m*/
        checkStatus(masterAddress, new FutureCallback<String>() {
            @Override
            public void onSuccess(@Nullable String leaderConnectionString) {
                try {
                    if (slaveAddresses == null || slaveAddresses.size() == 0) {
                        // no slaveAddresses - we are only checking the current master
                        callback.onSuccess(true);
                    } else {
                        checkSlaves(leaderConnectionString, slaveAddresses, callback);
                    }
                } catch (Throwable t) {
                    callback.onFailure(t);
                }
            }

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

From source file:com.vmware.photon.controller.deployer.xenon.util.ApiUtils.java

/**
 * This method polls the task status asynchronously until the task completes or fails.
 *
 * @param task              Supplies the task object.
 * @param client            Supplies the API client object.
 * @param service           Supplies the Xenon micro-service which is waiting on the task completion.
 * @param queryTaskInterval Supplies the time interval between the task status query.
 * @param callback          Supplies the callback to be invoked when the task completes or fails.
 */// w w w .  j a  v a 2  s  .  c  o m
public static void pollTaskAsync(final Task task, final ApiClient client, final Service service,
        final int queryTaskInterval, final FutureCallback<Task> callback) {

    switch (task.getState().toUpperCase()) {
    case "QUEUED":
    case "STARTED":
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                try {
                    ServiceUtils.logInfo(service, "Calling GetTask API on with task ID %s", task.getId());

                    client.getTasksApi().getTaskAsync(task.getId(), new FutureCallback<Task>() {
                        @Override
                        public void onSuccess(Task result) {
                            ServiceUtils.logInfo(service, "GetTask API call returned task %s",
                                    result.toString());
                            try {
                                pollTaskAsync(result, client, service, queryTaskInterval, callback);
                            } catch (Throwable throwable) {
                                callback.onFailure(throwable);
                            }
                        }

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

        service.getHost().schedule(runnable, queryTaskInterval, TimeUnit.MILLISECONDS);
        break;
    case "ERROR":
        callback.onFailure(new RuntimeException(ApiUtils.getErrors(task)));
        break;
    case "COMPLETED":
        callback.onSuccess(task);
        break;
    default:
        callback.onFailure(new RuntimeException("Unknown task state: " + task.getState()));
        break;
    }
}

From source file:com.facebook.swift.service.unframed.UnframedTestSuite.java

@Test
public void testUnframedAsyncMethod() throws Exception {
    TestServerInfo info = startServer();
    ThriftClientManager clientManager = new ThriftClientManager();
    final CountDownLatch latch = new CountDownLatch(1);
    final ResultCode[] resultHolder = new ResultCode[0];

    ListenableFuture<AsyncScribe> clientFuture = createUnframedClient(clientManager, AsyncScribe.class,
            info.port);/*from  w  w  w.  j  av  a  2  s  .c o  m*/
    Futures.addCallback(clientFuture, new FutureCallback<AsyncScribe>() {
        @Override
        public void onSuccess(AsyncScribe client) {
            try {
                ListenableFuture<ResultCode> methodFuture = client
                        .log(Lists.newArrayList(new LogEntry("testCategory", "testMessage")));
                Futures.addCallback(methodFuture, new FutureCallback<ResultCode>() {
                    @Override
                    public void onSuccess(ResultCode result) {
                        resultHolder[0] = result;
                        latch.countDown();
                    }

                    @Override
                    public void onFailure(Throwable t) {
                        latch.countDown();
                    }
                });
            } catch (TException e) {
                latch.countDown();
            }
        }

        @Override
        public void onFailure(Throwable t) {
            latch.countDown();
        }
    });

    latch.await();

    stopServer(info);
}

From source file:com.mirantis.opendaylight.Retrier.java

private void doRetry(SettableFuture<V> promise, int attempt) {
    if (attempt > 0) {
        try {/*from w  w w . j av a 2  s  . co  m*/
            Futures.addCallback(block.get(), new FutureCallback<V>() {
                @Override
                public void onSuccess(V value) {
                    promise.set(value);
                }

                @Override
                public void onFailure(Throwable t) {
                    if (condition.apply(t)) {
                        log.debug("Retrying", t);
                        doRetry(promise, attempt - 1);
                    } else {
                        log.debug(t.getMessage(), t);
                        promise.setException(t);
                    }
                }
            }, executor);
        } catch (RuntimeException e) {
            log.debug("Couldn't get code block to retrying", e);
            promise.setException(e);
        }
    } else {
        promise.setException(new RuntimeException("Number of attempts exeeded"));
    }
}

From source file:com.github.nethad.clustermeister.example.fractals.ComputeMandelbrotAsync.java

public void computePicture(final FractalConfiguration config) {
    try {//from   w ww . jav  a 2s.  c  o m
        if (clustermeister == null) {
            clustermeister = ClustermeisterFactory.create();
        }
        int nbTask = config.bsize;
        logger.info("Executing " + nbTask + " tasks");

        Map<String, Object> jobData = new HashMap<String, Object>();
        jobData.put("config", config);

        Job<MandelbrotResult> job = JobFactory.create("Clustermeister Mandelbrot", jobData);

        newImage(config);

        for (int i = 0; i < nbTask; i++) {
            job.addTask(new MandelbrotCMTask(i, config));
        }

        long start = System.currentTimeMillis();

        //            List<MandelbrotResult> results = clustermeister.executeJob(job);
        final List<ListenableFuture<MandelbrotResult>> futures = clustermeister.executeJobAsyncTasks(job);
        final FutureCallback<MandelbrotResult> callback = new FutureCallback<MandelbrotResult>() {
            public void onSuccess(MandelbrotResult result) {
                processPictureLine(result, config);
                //                    logger.info("process line {}", result.getRow());
            }

            public void onFailure(Throwable t) {
                logger.warn("Parts of the picture could not be computed.", t);
            }
        };

        for (ListenableFuture<MandelbrotResult> future : futures) {
            Futures.addCallback(future, callback);
        }

        Futures.successfulAsList(futures).get(); // wait for all jobs to be finished

        long elapsed = System.currentTimeMillis() - start;
        logger.info("Computation performed in " + StringUtils.toStringDuration(elapsed));

        //            generateMandelbrotImage(results, config);

        refreshImage();

    } catch (Exception ex) {
        ex.printStackTrace();
    }
}

From source file:org.opendaylight.ocpplugin.impl.services.SalConfigMgmtServiceImpl.java

@Override
public Future<RpcResult<GetParamOutput>> getParam(final GetParamInput input) {
    ListenableFuture<RpcResult<org.opendaylight.yang.gen.v1.urn.opendaylight.ocp.protocol.rev150811.GetParamOutput>> future = getParam
            .handleServiceCall(input);// ww w . j  a v a2 s .  c o m
    final SettableFuture<RpcResult<GetParamOutput>> finalFuture = SettableFuture.create();
    Futures.addCallback(future,
            new FutureCallback<RpcResult<org.opendaylight.yang.gen.v1.urn.opendaylight.ocp.protocol.rev150811.GetParamOutput>>() {
                @Override
                public void onSuccess(
                        final RpcResult<org.opendaylight.yang.gen.v1.urn.opendaylight.ocp.protocol.rev150811.GetParamOutput> result) {
                    org.opendaylight.yang.gen.v1.urn.opendaylight.ocp.protocol.rev150811.GetParamOutput output = result
                            .getResult();
                    GetParamOutputBuilder builder = new GetParamOutputBuilder();
                    builder.setObj(output.getObj());
                    builder.setResult(output.getResult());
                    RpcResultBuilder<GetParamOutput> rpcResultBuilder = RpcResultBuilder.success(builder);
                    finalFuture.set(rpcResultBuilder.build());
                }

                @Override
                public void onFailure(final Throwable t) {
                    RpcResultBuilder<GetParamOutput> rpcResultBuilder = RpcResultBuilder.failed();
                    finalFuture.set(rpcResultBuilder.build());
                }
            });

    return finalFuture;
}

From source file:com.android.camera.one.v2.sharedimagereader.metadatasynchronizer.MetadataPoolImpl.java

@Nonnull
@Override//from   w  w  w .ja  va 2 s.  com
public ListenableFuture<TotalCaptureResultProxy> removeMetadataFuture(final long timestamp) {
    ListenableFuture<TotalCaptureResultProxy> future = getOrCreateFuture(timestamp);
    // Remove the future from the map when it is done to free the memory.
    Futures.addCallback(future, new FutureCallback<TotalCaptureResultProxy>() {
        @Override
        public void onSuccess(TotalCaptureResultProxy totalCaptureResultProxy) {
            synchronized (mLock) {
                mMetadataFutures.remove(timestamp);
            }
        }

        @Override
        public void onFailure(Throwable throwable) {
            throw new UnsupportedOperationException();
        }
    });
    return Futures2.nonCancellationPropagating(future);
}

From source file:com.microsoftopentechnologies.auth.samples.swingapp.AADAuthSample.java

public AADAuthSample() {
    setContentPane(panelControls);/* w w w .j a  v  a 2 s  . c  o  m*/
    promptValue.setModel(new DefaultComboBoxModel(
            new String[] { PromptValue.login, PromptValue.refreshSession, PromptValue.attemptNone }));

    authority.setText("login.windows.net");
    tenantName.setText("common");
    resource.setText("https://management.core.windows.net/");

    signIn.addActionListener(new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent e) {
            try {
                result.setText("(loading...)");

                AuthenticationContext context = new AuthenticationContext(authority.getText());
                ListenableFuture<AuthenticationResult> future = context.acquireTokenInteractiveAsync(
                        tenantName.getText(), resource.getText(), clientID.getText(), redirectURI.getText(),
                        (String) promptValue.getSelectedItem());

                Futures.addCallback(future, new FutureCallback<AuthenticationResult>() {
                    @Override
                    public void onSuccess(AuthenticationResult authenticationResult) {
                        String resultText = "Authentication cancelled.";

                        if (authenticationResult != null) {
                            Gson gson = new GsonBuilder().setPrettyPrinting().create();
                            resultText = gson.toJson(authenticationResult);
                        }

                        result.setText(resultText);
                    }

                    @Override
                    public void onFailure(Throwable t) {
                        showError(t);
                        result.setText("ERROR: " + t.toString());
                    }
                });
            } catch (IOException e1) {
                showError(e1);
            }
        }
    });
}

From source file:org.apache.qpid.server.model.AbstractConfiguredObjectTypeFactory.java

@Override
public ListenableFuture<X> createAsync(final ConfiguredObjectFactory factory,
        final Map<String, Object> attributes, final ConfiguredObject<?> parent) {
    final SettableFuture<X> returnVal = SettableFuture.create();
    final X instance = createInstance(attributes, parent);
    final ListenableFuture<Void> createFuture = instance.createAsync();
    AbstractConfiguredObject.addFutureCallback(createFuture, new FutureCallback<Void>() {
        @Override//  w ww .  j av a 2s .  com
        public void onSuccess(final Void result) {
            returnVal.set(instance);
        }

        @Override
        public void onFailure(final Throwable t) {
            returnVal.setException(t);
        }
    }, MoreExecutors.directExecutor());

    return returnVal;
}