Example usage for com.google.common.util.concurrent SettableFuture create

List of usage examples for com.google.common.util.concurrent SettableFuture create

  1. HOME
  2. Java
  3. com.google.common
  4. com.google.common.util.concurrent.*
  5. SettableFuture
  6. create

Introduction

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

Prototype

public static <V> SettableFuture<V> create()

Source Link

Document

Creates a new SettableFuture that can be completed or cancelled by a later method call.

Usage

From source file:org.opendaylight.openflowjava.protocol.impl.core.TcpHandler.java

/**
 * Shuts down {@link TcpHandler}}/*from  ww  w  .  j  a va  2  s  . c o m*/
 */
@Override
public ListenableFuture<Boolean> shutdown() {
    final SettableFuture<Boolean> result = SettableFuture.create();
    workerGroup.shutdownGracefully();
    // boss will shutdown as soon, as worker is down
    bossGroup.shutdownGracefully()
            .addListener(new GenericFutureListener<io.netty.util.concurrent.Future<Object>>() {

                @Override
                public void operationComplete(io.netty.util.concurrent.Future<Object> downResult)
                        throws Exception {
                    result.set(downResult.isSuccess());
                    if (downResult.cause() != null) {
                        result.setException(downResult.cause());
                    }
                }

            });
    return result;
}

From source file:io.datakernel.service.ServiceGraph.java

private ListenableFuture<LongestPath> processNode(final Object node, final boolean start,
        Map<Object, ListenableFuture<LongestPath>> futures, final Executor executor) {
    List<ListenableFuture<LongestPath>> dependencyFutures = new ArrayList<>();
    for (Object dependencyNode : (start ? forwards : backwards).get(node)) {
        ListenableFuture<LongestPath> dependencyFuture = processNode(dependencyNode, start, futures, executor);
        dependencyFutures.add(dependencyFuture);
    }/*from ww w  . jav  a2  s .  c om*/

    if (futures.containsKey(node)) {
        return futures.get(node);
    }

    final SettableFuture<LongestPath> future = SettableFuture.create();
    futures.put(node, future);

    final ListenableFuture<LongestPath> dependenciesFuture = combineDependenciesFutures(dependencyFutures,
            executor);

    dependenciesFuture.addListener(new Runnable() {
        @Override
        public void run() {
            try {
                final LongestPath longestPath = dependenciesFuture.get();

                Service service = services.get(node);
                if (service == null) {
                    logger.debug("...skipping no-service node: " + nodeToString(node));
                    future.set(longestPath);
                    return;
                }

                if (!start && !runningNodes.contains(node)) {
                    logger.debug("...skipping not running node: " + nodeToString(node));
                    future.set(longestPath);
                    return;
                }

                final Stopwatch sw = Stopwatch.createStarted();
                final ListenableFuture<?> serviceFuture = (start ? service.start() : service.stop());
                logger.info((start ? "Starting" : "Stopping") + " node: " + nodeToString(node));
                serviceFuture.addListener(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            serviceFuture.get();

                            if (start) {
                                runningNodes.add(node);
                            } else {
                                runningNodes.remove(node);
                            }

                            long elapsed = sw.elapsed(MILLISECONDS);
                            logger.info((start ? "Started" : "Stopped") + " " + nodeToString(node)
                                    + (elapsed >= 1L ? (" in " + sw) : ""));
                            future.set(
                                    new LongestPath(elapsed + (longestPath != null ? longestPath.totalTime : 0),
                                            elapsed, node, longestPath));
                        } catch (InterruptedException | ExecutionException e) {
                            logger.error("error: " + nodeToString(node), e);
                            future.setException(getRootCause(e));
                        }
                    }
                }, executor);
            } catch (InterruptedException | ExecutionException e) {
                future.setException(getRootCause(e));
            }
        }
    }, executor);

    return future;
}

From source file:io.crate.executor.transport.RepositoryService.java

public ListenableFuture<Long> execute(CreateRepositoryAnalyzedStatement statement) {
    final SettableFuture<Long> result = SettableFuture.create();
    final String repoName = statement.repositoryName();

    PutRepositoryRequest request = new PutRepositoryRequest(repoName);
    request.type(statement.repositoryType());
    request.settings(statement.settings());
    putRepositoryAction.execute(request, new ActionListener<PutRepositoryResponse>() {
        @Override/*from   w  w w .j  a v  a 2  s.c  o  m*/
        public void onResponse(PutRepositoryResponse putRepositoryResponse) {
            result.set(1L);
        }

        @Override
        public void onFailure(Throwable e) {
            final Throwable t = convertRepositoryException(e);

            // in case the put repo action fails in the verificationPhase the repository got already created
            // but an exception is raised anyway.
            // --> remove the repo and then return the exception to the user
            dropIfExists(repoName, new Runnable() {
                @Override
                public void run() {
                    result.setException(t);
                }
            });
        }
    });
    return result;
}

From source file:org.opendaylight.openflowplugin.impl.services.SalExperimenterMpMessageServiceImpl.java

@Override
public Future<RpcResult<SendExperimenterMpRequestOutput>> sendExperimenterMpRequest(
        SendExperimenterMpRequestInput input) {
    final ListenableFuture<RpcResult<List<MultipartReply>>> multipartFuture = handleServiceCall(input);
    final SettableFuture<RpcResult<SendExperimenterMpRequestOutput>> finalFuture = SettableFuture.create();

    class CallBackImpl implements FutureCallback<RpcResult<List<MultipartReply>>> {
        @Override//www  .  j  a v a 2  s. com
        public void onSuccess(final RpcResult<List<MultipartReply>> result) {
            if (result.isSuccessful()) {
                final List<MultipartReply> multipartReplies = result.getResult();
                if (multipartReplies.isEmpty()) {
                    LOG.warn("Multipart reply to Experimenter-Mp request shouldn't be empty list.");
                    finalFuture.set(RpcResultBuilder.<SendExperimenterMpRequestOutput>failed()
                            .withError(ErrorType.RPC, "Multipart reply list is empty.").build());
                } else {
                    LOG.debug(
                            "OnSuccess, rpc result successful, multipart response for rpc sendExperimenterMpRequest with xid {} obtained.",
                            multipartReplies.get(0).getXid());
                    final SendExperimenterMpRequestOutputBuilder sendExpMpReqOutputBuilder = new SendExperimenterMpRequestOutputBuilder();
                    final List<ExperimenterCoreMessageItem> expCoreMessageItem = new ArrayList<>();
                    for (MultipartReply multipartReply : multipartReplies) {
                        final MultipartReplyExperimenterCase caseBody = (MultipartReplyExperimenterCase) multipartReply
                                .getMultipartReplyBody();
                        final MultipartReplyExperimenter replyBody = caseBody.getMultipartReplyExperimenter();
                        final ExperimenterDataOfChoice vendorData = replyBody.getExperimenterDataOfChoice();
                        final MessageTypeKey<? extends ExperimenterDataOfChoice> key = new MessageTypeKey<>(
                                getVersion(), (Class<? extends ExperimenterDataOfChoice>) vendorData
                                        .getImplementedInterface());
                        final ConvertorMessageFromOFJava<ExperimenterDataOfChoice, MessagePath> messageConverter = extensionConverterProvider
                                .getMessageConverter(key);
                        if (messageConverter == null) {
                            LOG.warn("Custom converter for {}[OF:{}] not found",
                                    vendorData.getImplementedInterface(), getVersion());
                            finalFuture.set(RpcResultBuilder.<SendExperimenterMpRequestOutput>failed()
                                    .withError(ErrorType.RPC, "Custom converter not found.").build());
                            return;
                        }
                        try {
                            final ExperimenterMessageOfChoice messageOfChoice = messageConverter
                                    .convert(vendorData, MessagePath.MPMESSAGE_RPC_OUTPUT);
                            final ExperimenterCoreMessageItemBuilder expCoreMessageItemBuilder = new ExperimenterCoreMessageItemBuilder();
                            expCoreMessageItemBuilder.setExperimenterMessageOfChoice(messageOfChoice);
                            expCoreMessageItem.add(expCoreMessageItemBuilder.build());
                        } catch (final ConversionException e) {
                            LOG.error("Conversion of experimenter message reply failed. Exception: {}", e);
                            finalFuture.set(RpcResultBuilder.<SendExperimenterMpRequestOutput>failed()
                                    .withError(ErrorType.RPC, "Conversion of experimenter rpc output failed.")
                                    .build());
                            return;
                        }
                    }
                    sendExpMpReqOutputBuilder.setExperimenterCoreMessageItem(expCoreMessageItem);
                    finalFuture.set(RpcResultBuilder.success(sendExpMpReqOutputBuilder.build()).build());
                }
            } else {
                LOG.warn(
                        "OnSuccess, rpc result unsuccessful, multipart response for rpc sendExperimenterMpRequest was unsuccessful.");
                finalFuture.set(RpcResultBuilder.<SendExperimenterMpRequestOutput>failed()
                        .withRpcErrors(result.getErrors()).build());
            }
        }

        @Override
        public void onFailure(final Throwable t) {
            LOG.warn("Failure multipart response for Experimenter-Mp request. Exception: {}", t);
            finalFuture.set(RpcResultBuilder.<SendExperimenterMpRequestOutput>failed()
                    .withError(ErrorType.RPC, "Future error", t).build());
        }
    }

    Futures.addCallback(multipartFuture, new CallBackImpl());

    return finalFuture;
}

From source file:org.waveprotocol.box.server.waveserver.RemoteWaveletContainerImpl.java

@Override
public ListenableFuture<Void> update(final List<ByteString> deltas, final String domain,
        final WaveletFederationProvider federationProvider, final CertificateManager certificateManager) {
    SettableFuture<Void> futureResult = SettableFuture.create();
    internalUpdate(deltas, domain, federationProvider, certificateManager, futureResult);
    return futureResult;
}

From source file:org.apache.heron.statemgr.localfs.LocalFileSystemStateManager.java

@Override
protected ListenableFuture<Boolean> nodeExists(String path) {
    SettableFuture<Boolean> future = SettableFuture.create();
    boolean ret = FileUtils.isFileExists(path);
    safeSetFuture(future, ret);//from   w ww  .  j  av  a 2s. c  o m

    return future;
}

From source file:co.cask.cdap.internal.app.runtime.AbstractProgramController.java

@Override
public final ListenableFuture<ProgramController> stop() {
    if (!state.compareAndSet(State.STARTING, State.STOPPING)
            && !state.compareAndSet(State.ALIVE, State.STOPPING)
            && !state.compareAndSet(State.SUSPENDED, State.STOPPING)) {
        return Futures
                .immediateFailedFuture(new IllegalStateException("Stopping not allowed").fillInStackTrace());
    }//from   w  ww .  jav  a  2 s. co  m
    final SettableFuture<ProgramController> result = SettableFuture.create();
    executor(State.STOPPING).execute(new Runnable() {
        @Override
        public void run() {
            try {
                caller.stopping();
                doStop();
                state.set(State.KILLED);
                result.set(AbstractProgramController.this);
                caller.killed();
            } catch (Throwable t) {
                error(t, result);
            }
        }
    });
    return result;
}

From source file:org.opendaylight.openflowplugin.impl.services.SalTableServiceImpl.java

@Override
public Future<RpcResult<UpdateTableOutput>> updateTable(final UpdateTableInput input) {
    final ListenableFuture<RpcResult<List<MultipartReply>>> multipartFuture = handleServiceCall(input);
    final SettableFuture<RpcResult<UpdateTableOutput>> finalFuture = SettableFuture.create();

    class CallBackImpl implements FutureCallback<RpcResult<List<MultipartReply>>> {
        @Override//from w  ww  .  j a  v a2s  . com
        public void onSuccess(final RpcResult<List<MultipartReply>> result) {

            if (result.isSuccessful()) {
                final List<MultipartReply> multipartReplies = result.getResult();
                if (multipartReplies.isEmpty()) {
                    LOG.debug("Multipart reply to table features request shouldn't be empty list.");
                    finalFuture.set(RpcResultBuilder.<UpdateTableOutput>failed()
                            .withError(ErrorType.RPC, "Multipart reply list is empty.").build());
                } else {
                    final Long xid = multipartReplies.get(0).getXid();
                    LOG.debug(
                            "OnSuccess, rpc result successful, multipart response for rpc update-table with xid {} obtained.",
                            xid);
                    final UpdateTableOutputBuilder updateTableOutputBuilder = new UpdateTableOutputBuilder();
                    updateTableOutputBuilder.setTransactionId(new TransactionId(BigInteger.valueOf(xid)));
                    finalFuture.set(RpcResultBuilder.success(updateTableOutputBuilder.build()).build());
                    writeResponseToOperationalDatastore(multipartReplies);
                }
            } else {
                LOG.debug(
                        "OnSuccess, rpc result unsuccessful, multipart response for rpc update-table was unsuccessful.");
                finalFuture.set(
                        RpcResultBuilder.<UpdateTableOutput>failed().withRpcErrors(result.getErrors()).build());
            }
        }

        @Override
        public void onFailure(final Throwable t) {
            LOG.debug("Failure multipart response for table features request. Exception: {}", t);
            finalFuture.set(RpcResultBuilder.<UpdateTableOutput>failed()
                    .withError(ErrorType.RPC, "Future error", t).build());
        }
    }

    Futures.addCallback(multipartFuture, new CallBackImpl());

    return finalFuture;
}

From source file:org.opendaylight.laas.impl.CentinelLaasStreamImpl.java

/**
 * @param tx//w ww. ja v a2  s.  c  o m
 * @param record
 * @param iterator
 */
private void createIntoOperational(final ReadWriteTransaction tx, StreamRecord record,
        Iterator<DataObject> iterator) {
    StreamList tempStreamList = null;
    DataObject streamObject = iterator.next();
    if (!(streamObject instanceof StreamList) && !record.getStreamList().isEmpty()) {
        tempStreamList = (StreamList) record.getStreamList().get(0);
    } else if (streamObject instanceof StreamList) {
        tempStreamList = (StreamList) streamObject;
    }

    final SettableFuture<RpcResult<SetStreamOutput>> futureResult = SettableFuture.create();
    final StreamList newstreamList = tempStreamList;

    List<StreamList> streamList = new ArrayList<StreamList>();
    StreamList streamListObj = (StreamList) restService.createFromConfigToOperationalStream(newstreamList);
    streamList.add(streamListObj);

    try {
        if (streamListObj != null) {
            tx.merge(LogicalDatastoreType.OPERATIONAL, streamRecordId,
                    new StreamRecordBuilder().setStreamList(streamList).build(), true);
            tx.submit();
            LOG.info("Stream commited sucessfully to operational datastore on data change");
        }
    }

    catch (Exception e) {
        LOG.info("Failed to commit Stream", e);
        futureResult.set(RpcResultBuilder.<SetStreamOutput>failed()
                .withRpcErrors(((TransactionCommitFailedException) e).getErrorList()).build());
    }
}

From source file:co.cask.cdap.route.store.ZKRouteStore.java

@Override
public RouteConfig fetch(final ProgramId serviceId) {
    Future<RouteConfig> future = routeConfigMap.get(serviceId);
    if (future == null) {
        SettableFuture<RouteConfig> settableFuture = SettableFuture.create();
        future = routeConfigMap.putIfAbsent(serviceId, settableFuture);
        if (future == null) {
            future = getAndWatchData(serviceId, settableFuture, settableFuture, new ZKRouteWatcher(serviceId));
        }//from   w  w w. j  a  va  2 s .c  om
    }
    return getConfig(serviceId, future);
}