Example usage for com.google.common.util.concurrent Futures allAsList

List of usage examples for com.google.common.util.concurrent Futures allAsList

  1. HOME
  2. Java
  3. com.google.common
  4. com.google.common.util.concurrent.*
  5. Futures
  6. allAsList

Introduction

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

Prototype

@Beta
@CheckReturnValue
public static <V> ListenableFuture<List<V>> allAsList(
        Iterable<? extends ListenableFuture<? extends V>> futures)

Source Link

Document

Creates a new ListenableFuture whose value is a list containing the values of all its input futures, if all succeed.

Usage

From source file:com.orangerhymelabs.helenus.cassandra.AbstractCassandraRepository.java

/**
 * Read all given identifiers./*from w  w w  . ja v  a2 s .  co m*/
 * 
 * Leverages the token-awareness of the driver to optimally query each node directly instead of invoking a
 * coordinator node. Sends an individual query for each partition key, so reaches the appropriate replica
 * directly and collates the results client-side.
 * 
 * @param ids the partition keys (identifiers) to select.
 */
public ListenableFuture<List<T>> readIn(Identifier... ids) {
    List<ListenableFuture<ResultSet>> futures = submitReadIn(ids);
    List<ListenableFuture<T>> results = new ArrayList<>(ids.length);

    for (ListenableFuture<ResultSet> future : futures) {
        results.add(Futures.transformAsync(future, new AsyncFunction<ResultSet, T>() {
            @Override
            public ListenableFuture<T> apply(ResultSet input) {
                if (!input.isExhausted()) {
                    return Futures.immediateFuture(marshalRow(input.one()));
                }

                return Futures.immediateFuture(null);
            }
        }, MoreExecutors.directExecutor()));
    }

    return Futures.allAsList(results);
}

From source file:org.apache.streams.instagram.provider.InstagramAbstractProvider.java

@Override
public boolean isRunning() {
    if (dataQueue.isEmpty() && executorService.isTerminated() && Futures.allAsList(futures).isDone()) {
        LOGGER.info("Completed");
        isCompleted.set(true);/*  w  ww . ja v a 2s.c o m*/
        LOGGER.info("Exiting");
    }
    return !isCompleted.get();
}

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

@Override
public Future<RpcResult<AddMetersBatchOutput>> addMetersBatch(final AddMetersBatchInput input) {
    LOG.trace("Adding meters @ {} : {}", PathUtil.extractNodeId(input.getNode()),
            input.getBatchAddMeters().size());
    final ArrayList<ListenableFuture<RpcResult<AddMeterOutput>>> resultsLot = new ArrayList<>();
    for (BatchAddMeters addMeter : input.getBatchAddMeters()) {
        final AddMeterInput addMeterInput = new AddMeterInputBuilder(addMeter)
                .setMeterRef(createMeterRef(input.getNode(), addMeter)).setNode(input.getNode()).build();
        resultsLot.add(JdkFutureAdapters.listenInPoolThread(salMeterService.addMeter(addMeterInput)));
    }/*w  w w.  j  a  v  a2  s . co m*/

    final ListenableFuture<RpcResult<List<BatchFailedMetersOutput>>> commonResult = Futures.transform(
            Futures.allAsList(resultsLot),
            MeterUtil.<AddMeterOutput>createCumulativeFunction(input.getBatchAddMeters()));

    ListenableFuture<RpcResult<AddMetersBatchOutput>> addMetersBulkFuture = Futures.transform(commonResult,
            MeterUtil.METER_ADD_TRANSFORM);

    if (input.isBarrierAfter()) {
        addMetersBulkFuture = BarrierUtil.chainBarrier(addMetersBulkFuture, input.getNode(), transactionService,
                MeterUtil.METER_ADD_COMPOSING_TRANSFORM);
    }

    return addMetersBulkFuture;
}

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

@Override
public Future<RpcResult<AddGroupsBatchOutput>> addGroupsBatch(final AddGroupsBatchInput input) {
    LOG.trace("Adding groups @ {} : {}", PathUtil.extractNodeId(input.getNode()),
            input.getBatchAddGroups().size());
    final ArrayList<ListenableFuture<RpcResult<AddGroupOutput>>> resultsLot = new ArrayList<>();
    for (BatchAddGroups addGroup : input.getBatchAddGroups()) {
        final AddGroupInput addGroupInput = new AddGroupInputBuilder(addGroup)
                .setGroupRef(createGroupRef(input.getNode(), addGroup)).setNode(input.getNode()).build();
        resultsLot.add(JdkFutureAdapters.listenInPoolThread(salGroupService.addGroup(addGroupInput)));
    }/* w ww. ja va 2s.  c om*/

    final ListenableFuture<RpcResult<List<BatchFailedGroupsOutput>>> commonResult = Futures.transform(
            Futures.allAsList(resultsLot),
            GroupUtil.<AddGroupOutput>createCumulatingFunction(input.getBatchAddGroups()));

    ListenableFuture<RpcResult<AddGroupsBatchOutput>> addGroupsBulkFuture = Futures.transform(commonResult,
            GroupUtil.GROUP_ADD_TRANSFORM);

    if (input.isBarrierAfter()) {
        addGroupsBulkFuture = BarrierUtil.chainBarrier(addGroupsBulkFuture, input.getNode(), transactionService,
                GroupUtil.GROUP_ADD_COMPOSING_TRANSFORM);
    }

    return addGroupsBulkFuture;
}

From source file:org.opendaylight.controller.cluster.sharding.ShardProxyTransaction.java

@Override
public ListenableFuture<Void> commit() {
    LOG.debug("Committing transaction for shard {}", shardRoot);

    checkTransactionReadied();//  w w w  .  ja  v  a2s  . com
    final List<ListenableFuture<Void>> futures = cohorts.stream().map(DOMStoreThreePhaseCommitCohort::commit)
            .collect(Collectors.toList());
    final SettableFuture<Void> ret = SettableFuture.create();

    Futures.addCallback(Futures.allAsList(futures), new FutureCallback<List<Void>>() {
        @Override
        public void onSuccess(final List<Void> result) {
            ret.set(null);
        }

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

    return ret;
}

From source file:com.facebook.watchman.WatchmanClientImpl.java

/**
 * unsubscribes from all the subscriptions; convenience method
 */// w  w  w  . ja v a2s .c  om
@Override
public ListenableFuture<Boolean> unsubscribeAll() {
    Collection<ListenableFuture<Boolean>> unsubscribeAll = Collections2.transform(subscriptions.keySet(),
            new Function<SubscriptionDescriptor, ListenableFuture<Boolean>>() {
                @Nullable
                @Override
                public ListenableFuture<Boolean> apply(@Nullable SubscriptionDescriptor input) {
                    return unsubscribe(input);
                }
            });
    return Futures.transform(Futures.allAsList(unsubscribeAll), new Function<List<Boolean>, Boolean>() {
        @Nullable
        @Override
        public Boolean apply(@Nullable List<Boolean> input) {
            return !Collections2.filter(input, Predicates.equalTo(false)).isEmpty();
        }
    });
}

From source file:com.yahoo.yqlplus.engine.internal.java.sequences.Sequences.java

public static <ROW, SEQUENCE extends Iterable<ROW>, KEY> ListenableFuture<List<ROW>> invokeScatter(
        final ListeningExecutorService workExecutor, final Function<KEY, SEQUENCE> source, final List<KEY> keys,
        Tracer tracer, Timeout timeout, TimeoutHandler handler) throws Exception {
    List<ListenableFuture<SEQUENCE>> results = Lists.newArrayList();
    int idx = -1;
    for (KEY key : keys) {
        if (key != null) {
            results.add(workExecutor.submit(createJob(tracer, ++idx, source, key)));
        }//from w  w w  . ja  v a2 s . c  om
    }
    ListenableFuture<List<SEQUENCE>> gather = Futures.allAsList(results);
    final int estimatedResultSize = results.size();
    return handler.withTimeout(gatherResults(workExecutor, gather, estimatedResultSize), timeout.verify(),
            timeout.getTickUnits());
}

From source file:com.continuuity.loom.common.zookeeper.lib.SynchronizedZKMap.java

private void clearInternal() {
    if (currentView.size() > 0) {
        currentView = Collections.emptyMap();
        NodeChildren nodeChildren = Futures.getUnchecked(zkClient.getChildren(ENTRIES_PATH));
        List<ListenableFuture<String>> deleteFutures = Lists.newArrayList();
        for (String node : nodeChildren.getChildren()) {
            deleteFutures.add(ZKClientExt.delete(zkClient, getNodePath(node), true));
        }/*from www.jav  a 2 s .c  o m*/
        Futures.getUnchecked(Futures.allAsList(deleteFutures));
    }
}

From source file:com.spotify.folsom.client.ascii.DefaultAsciiMemcacheClient.java

private ListenableFuture<List<GetResult<V>>> multiget(List<String> keys, boolean withCas) {
    final int size = keys.size();
    if (size == 0) {
        return Futures.immediateFuture(Collections.<GetResult<V>>emptyList());
    }/*from w  w w  .j a v a 2  s. co m*/

    final List<List<String>> keyPartition = Lists.partition(keys, MemcacheEncoder.MAX_MULTIGET_SIZE);
    final List<ListenableFuture<List<GetResult<byte[]>>>> futureList = new ArrayList<>(keyPartition.size());

    for (final List<String> part : keyPartition) {
        MultigetRequest request = MultigetRequest.create(part, charset, withCas);
        futureList.add(rawMemcacheClient.send(request));
    }

    final ListenableFuture<List<GetResult<byte[]>>> future = Utils.transform(Futures.allAsList(futureList),
            Utils.<GetResult<byte[]>>flatten());

    metrics.measureMultigetFuture(future);
    return transformerUtil.decodeList(future);
}

From source file:org.grouplens.lenskit.eval.script.EvalScript.java

public Object methodMissing(String name, Object arg) {
    Object[] args = InvokerHelper.asArray(arg);
    logger.debug("searching for eval command {}", name);
    Object obj = null;//from  w w w  .j av  a 2s.com
    try {
        obj = helper.callExternalMethod(name, args);
    } catch (NoSuchMethodException e) {
        throw new MissingMethodException(name, getClass(), args, true);
    }
    if (obj instanceof Builder) {
        return helper.finishBuilder((Builder<?>) obj);
    } else if (obj instanceof EvalTask) {
        final EvalTask<?> task = (EvalTask<?>) obj;
        if (currentTarget == null) {
            try {
                ListenableFuture<List<Object>> deps = Futures.allAsList(helper.getDeps(task));
                helper.clearDeps(task);
                Runnable execute = new Runnable() {
                    @Override
                    public void run() {
                        try {
                            task.execute();
                        } catch (TaskExecutionException e) {
                            throw new RuntimeException("task failure", e);
                        }
                    }
                };
                deps.addListener(execute, MoreExecutors.sameThreadExecutor());
                if (task.isDone()) {
                    return Uninterruptibles.getUninterruptibly(task);
                } else {
                    return task;
                }
            } catch (ExecutionException e) {
                throw new RuntimeException("task failure", e);
            }
        } else {
            EvalAntTask aTask = new EvalAntTask(task, helper.getDeps(task));
            aTask.setProject(getAntProject());
            aTask.setOwningTarget(currentTarget);
            aTask.init();
            currentTarget.addTask(aTask);
            return obj;
        }
    } else {
        return obj;
    }
}