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

List of usage examples for com.google.common.util.concurrent FutureCallback onSuccess

Introduction

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

Prototype

void onSuccess(@Nullable V result);

Source Link

Document

Invoked with the result of the Future computation when it is successful.

Usage

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

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

    try {/* ww  w .j av a2 s .c om*/
        String connectionString = createConnectionString(serverAddress);
        kubernetesClient.getNodeAddressesAsync(connectionString, new FutureCallback<Set<String>>() {
            @Override
            public void onSuccess(@Nullable Set<String> nodes) {
                if (!nodes.contains(serverAddress)) {
                    logger.info("Node not registered with Kubernetes: {}", serverAddress);
                    callback.onSuccess(false);
                    return;
                }
                callback.onSuccess(true);
            }

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

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

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

    try {/*from www .j a v a2 s  .c  om*/
        String connectionString = createConnectionString(masterAddress);
        swarmClient.getNodeAddressesAsync(connectionString, new FutureCallback<Set<String>>() {
            @Override
            public void onSuccess(@Nullable Set<String> nodes) {
                if (!nodes.contains(masterAddress)) {
                    logger.info("Node not registered with Swarm: {}", masterAddress);
                    callback.onSuccess(false);
                    return;
                }

                try {
                    if (slaveAddresses == null || slaveAddresses.size() == 0) {
                        // we are only checking the current master
                        callback.onSuccess(true);
                    } else {
                        for (String slaveAddress : slaveAddresses) {
                            if (!nodes.contains(slaveAddress)) {
                                logger.info("Slave not registered with Swarm: {}", slaveAddress);
                                callback.onSuccess(false);
                                return;
                            }
                        }
                        callback.onSuccess(true);
                    }
                } catch (Exception e) {
                    logger.warn("Failed to process Swarm nodes: ", e);
                    callback.onFailure(e);
                }
            }

            @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:com.vmware.photon.controller.nsxclient.apis.NsxClientApi.java

/**
 * Performs a DELETE HTTP request to NSX.
 *//*from   w ww . ja  v  a2s.  c  om*/
protected void deleteAsync(final String path, final int expectedResponseStatus,
        final FutureCallback<Void> responseCallback) throws IOException {
    restClient.sendAsync(RestClient.Method.DELETE, path, null,
            new org.apache.http.concurrent.FutureCallback<HttpResponse>() {
                @Override
                public void completed(HttpResponse result) {
                    try {
                        restClient.check(result, expectedResponseStatus);
                    } catch (Throwable e) {
                        responseCallback.onFailure(e);
                    }

                    responseCallback.onSuccess(null);
                }

                @Override
                public void failed(Exception ex) {
                    responseCallback.onFailure(ex);
                }

                @Override
                public void cancelled() {
                    responseCallback.onFailure(
                            new RuntimeException(String.format("deleteAsync %s was cancelled", path)));
                }
            });
}

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

@Override
public void checkSlavesStatus(final String masterAddress, final List<String> slaveAddresses,
        final FutureCallback<Boolean> callback) {
    Preconditions.checkNotNull(masterAddress, "masterAddress cannot be null");
    logger.info("Checking Kubernetes: {}", masterAddress);

    try {//  w  w  w . j  a v  a  2  s. co  m
        String connectionString = createConnectionString(masterAddress);
        kubernetesClient.getNodeAddressesAsync(connectionString, new FutureCallback<Set<String>>() {
            @Override
            public void onSuccess(@Nullable Set<String> nodes) {
                if (!nodes.contains(masterAddress)) {
                    logger.info("Node not registered with Kubernetes: {}", masterAddress);
                    callback.onSuccess(false);
                    return;
                }

                try {
                    if (slaveAddresses == null || slaveAddresses.size() == 0) {
                        // we are only checking the current master
                        callback.onSuccess(true);
                    } else {
                        for (String slaveAddress : slaveAddresses) {
                            if (!nodes.contains(slaveAddress)) {
                                logger.info("Slave not registered with Kubernetes: {}", slaveAddress);
                                callback.onSuccess(false);
                                return;
                            }
                        }
                        callback.onSuccess(true);
                    }
                } catch (Exception e) {
                    logger.warn("Failed to process Kubernetes nodes: ", e);
                    callback.onFailure(e);
                }
            }

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

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   w w w .  ja  v a2  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:co.cask.common.security.zookeeper.SharedResourceCache.java

private void getResource(String path, final FutureCallback<T> resourceCallback) {
    OperationFuture<NodeData> future = zookeeper.getData(path, watcher);
    Futures.addCallback(future, new FutureCallback<NodeData>() {
        @Override//from   w ww .  j ava  2 s  .  co m
        public void onSuccess(NodeData result) {
            T resource = null;
            try {
                resource = codec.decode(result.getData());
                resourceCallback.onSuccess(resource);
            } catch (IOException ioe) {
                resourceCallback.onFailure(ioe);
            }
        }

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

From source file:com.vmware.photon.controller.clustermanager.tasks.GarbageCollectionTaskService.java

/**
 * Delete an Inactive VM entity.//from   w  w  w  .  j a  v  a  2  s.  c  o m
 */
private void deleteInactiveVmEntity(String vmId, FutureCallback<Void> callback) {
    String documentLink = InactiveVmFactoryService.SELF_LINK + "/" + vmId;

    try {
        Operation deleteOperation = Operation.createDelete(UriUtils.buildUri(getHost(), documentLink))
                .setBody(new ServiceDocument()).setCompletion((Operation operation, Throwable throwable) -> {
                    if (null != throwable) {
                        callback.onFailure(throwable);
                        return;
                    }
                    callback.onSuccess(null);
                });
        sendRequest(deleteOperation);
    } catch (Throwable t) {
        callback.onFailure(t);
    }
}

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 va2s .  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.vmware.photon.controller.deployer.dcp.util.MiscUtils.java

private static void getVmNetworks(Service service, ApiClient client, String vmId, Integer taskPollDelay,
        FutureCallback<List<String>> callback) throws IOException {
    client.getVmApi().getNetworksAsync(vmId, new FutureCallback<Task>() {
        @Override/*w w  w  . ja  v  a2s .  c  o m*/
        public void onSuccess(@Nullable Task task) {
            try {
                ApiUtils.pollTaskAsync(task, client, service, taskPollDelay, new FutureCallback<Task>() {
                    @Override
                    public void onSuccess(@Nullable Task task) {
                        try {
                            VmNetworks vmNetworks = VmApi.parseVmNetworksFromTask(task);

                            checkState(vmNetworks.getNetworkConnections() != null);
                            List<String> result = new ArrayList<>();
                            // Get only the non-docker ips. For docker Ips, network is null
                            Set<NetworkConnection> connections = vmNetworks.getNetworkConnections();
                            for (NetworkConnection networkConnection : connections) {
                                if (networkConnection.getNetwork() != null) {
                                    result.add(networkConnection.getIpAddress());
                                }
                            }
                            ServiceUtils.logInfo(service, "Found " + result.size() + " vm ips");
                            checkState(result.size() > 0);
                            callback.onSuccess(result);
                            return;
                        } catch (Throwable t) {
                            callback.onFailure(t);
                        }
                    }

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

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

From source file:com.vmware.photon.controller.nsxclient.apis.NsxClientApi.java

/**
 * Check if an NSX equipment is there./*  w  ww. j a v  a  2s .c o  m*/
 * For example, NSX does not provide the function to check if a port has been deleted successfully.
 * Adding this function to check if it is still there.
 */
protected void checkExistenceAsync(final String path, final FutureCallback<Boolean> responseCallback)
        throws IOException {
    restClient.sendAsync(RestClient.Method.GET, path, null,
            new org.apache.http.concurrent.FutureCallback<HttpResponse>() {
                @Override
                public void completed(HttpResponse result) {
                    Boolean ret = null;
                    try {
                        int statusCode = result.getStatusLine().getStatusCode();
                        ret = (statusCode == HttpStatus.SC_OK) || (statusCode == HttpStatus.SC_CREATED);
                    } catch (Throwable e) {
                        responseCallback.onFailure(e);
                    }

                    responseCallback.onSuccess(ret);
                }

                @Override
                public void failed(Exception ex) {
                    responseCallback.onFailure(ex);
                }

                @Override
                public void cancelled() {
                    responseCallback.onFailure(
                            new RuntimeException(String.format("checkExistenceAsync %s was cancelled", path)));
                }
            });
}