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

Introduction

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

Prototype

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

Source Link

Document

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

Usage

From source file:io.crate.executor.transport.executionphases.ExecutionPhasesTask.java

@Override
public ListenableFuture<List<Long>> executeBulk() {
    FluentIterable<NodeOperation> nodeOperations = FluentIterable.from(nodeOperationTrees)
            .transformAndConcat(new Function<NodeOperationTree, Iterable<? extends NodeOperation>>() {
                @Nullable/*from www .  j a  v  a2s. c om*/
                @Override
                public Iterable<? extends NodeOperation> apply(NodeOperationTree input) {
                    return input.nodeOperations();
                }
            });
    Map<String, Collection<NodeOperation>> operationByServer = NodeOperationGrouper
            .groupByServer(nodeOperations);
    InitializationTracker initializationTracker = new InitializationTracker(operationByServer.size());

    List<Tuple<ExecutionPhase, RowReceiver>> handlerPhases = new ArrayList<>(nodeOperationTrees.size());
    List<SettableFuture<Long>> results = new ArrayList<>(nodeOperationTrees.size());
    for (NodeOperationTree nodeOperationTree : nodeOperationTrees) {
        SettableFuture<Long> result = SettableFuture.create();
        results.add(result);
        RowReceiver receiver = new InterceptingRowReceiver(jobId(), new RowCountResultRowDownstream(result),
                initializationTracker, transportKillJobsNodeAction);
        handlerPhases.add(new Tuple<>(nodeOperationTree.leaf(), receiver));
    }

    try {
        setupContext(operationByServer, handlerPhases, initializationTracker);
    } catch (Throwable throwable) {
        return Futures.immediateFailedFuture(throwable);
    }
    return Futures.successfulAsList(results);
}

---

From source file:com.netflix.metacat.main.services.impl.PartitionServiceImpl.java

@Override
public List<PartitionDto> list(final QualifiedName name, final String filter, final List<String> partitionNames,
        final Sort sort, final Pageable pageable, final boolean includeUserDefinitionMetadata,
        final boolean includeUserDataMetadata, final boolean includePartitionDetails) {
    if (Strings.isNullOrEmpty(filter) && (pageable == null || !pageable.isPageable())
            && (partitionNames == null || partitionNames.isEmpty())
            && config.getQualifiedNamesToThrowErrorWhenNoFilterOnListPartitions().contains(name)) {
        throw new IllegalArgumentException(String.format("No filter or limit specified for table %s", name));
    }/*from   w w w .  j a v  a  2  s  .c o  m*/
    final ConnectorPartitionResult partitionResult = getPartitionResult(name, filter, partitionNames, sort,
            pageable, includePartitionDetails);
    List<PartitionDto> result = Collections.emptyList();
    if (partitionResult != null) {
        final List<QualifiedName> names = Lists.newArrayList();
        final List<String> uris = Lists.newArrayList();
        result = partitionResult.getPartitions().stream().map(partition -> {
            final PartitionDto result1 = toPartitionDto(name, partition);
            names.add(result1.getName());
            uris.add(result1.getDataUri());
            return result1;
        }).collect(Collectors.toList());
        final TagList tags = BasicTagList.of("catalog", name.getCatalogName(), "database",
                name.getDatabaseName(), "table", name.getTableName());
        DynamicGauge.set(LogConstants.GaugeGetPartitionsCount.toString(), tags, result.size());
        log.info("Got {} partitions for {} using filter: {} and partition names: {}", result.size(), name,
                filter, partitionNames);
        if (includeUserDefinitionMetadata || includeUserDataMetadata) {
            final List<ListenableFuture<Map<String, ObjectNode>>> futures = Lists.newArrayList();
            futures.add(threadServiceManager.getExecutor()
                    .submit(() -> includeUserDefinitionMetadata
                            ? userMetadataService.getDefinitionMetadataMap(names)
                            : Maps.newHashMap()));
            futures.add(threadServiceManager.getExecutor()
                    .submit(() -> includeUserDataMetadata ? userMetadataService.getDataMetadataMap(uris)
                            : Maps.newHashMap()));
            try {
                final List<Map<String, ObjectNode>> metadataResults = Futures.successfulAsList(futures).get(1,
                        TimeUnit.HOURS);
                final Map<String, ObjectNode> definitionMetadataMap = metadataResults.get(0);
                final Map<String, ObjectNode> dataMetadataMap = metadataResults.get(1);
                result.forEach(partitionDto -> userMetadataService.populateMetadata(partitionDto,
                        definitionMetadataMap.get(partitionDto.getName().toString()),
                        dataMetadataMap.get(partitionDto.getDataUri())));
            } catch (Exception e) {
                Throwables.propagate(e);
            }
        }
    }
    return result;
}

---

From source file:com.sk89q.worldguard.WorldGuard.java

/**
 * Called when WorldGuard should be disabled.
 *///from   w  w w  . j av  a 2s . com
public void disable() {
    executorService.shutdown();

    try {
        WorldGuard.logger.log(Level.INFO, "Shutting down executor and waiting for any pending tasks...");

        List<Task<?>> tasks = supervisor.getTasks();
        if (!tasks.isEmpty()) {
            StringBuilder builder = new StringBuilder("Known tasks:");
            for (Task<?> task : tasks) {
                builder.append("\n");
                builder.append(task.getName());
            }
            WorldGuard.logger.log(Level.INFO, builder.toString());
        }

        Futures.successfulAsList(tasks).get();
        executorService.awaitTermination(Integer.MAX_VALUE, TimeUnit.DAYS);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    } catch (ExecutionException e) {
        WorldGuard.logger.log(Level.WARNING, "Some tasks failed while waiting for remaining tasks to finish",
                e);
    }

    platform.unload();
}

---

From source file:brooklyn.management.internal.LocalUsageManager.java

public void terminate() {
    // Wait for the listeners to finish + close the listeners
    Duration timeout = managementContext.getBrooklynProperties()
            .getConfig(UsageManager.USAGE_LISTENER_TERMINATION_TIMEOUT);
    if (listenerQueueSize.get() > 0) {
        log.info("Usage manager waiting for " + listenerQueueSize + " listener events for up to " + timeout);
    }/*from w  w w .j  a  va2  s.c o  m*/
    List<ListenableFuture<?>> futures = Lists.newArrayList();
    for (final UsageListener listener : listeners) {
        ListenableFuture<?> future = listenerExecutor.submit(new Runnable() {
            public void run() {
                if (listener instanceof Closeable) {
                    try {
                        ((Closeable) listener).close();
                    } catch (IOException e) {
                        log.warn("Problem closing usage listener " + listener + " (continuing)", e);
                    }
                }
            }
        });
        futures.add(future);
    }
    try {
        Futures.successfulAsList(futures).get(timeout.toMilliseconds(), TimeUnit.MILLISECONDS);
    } catch (Exception e) {
        Exceptions.propagateIfFatal(e);
        log.warn("Problem terminiating usage listeners (continuing)", e);
    } finally {
        listenerExecutor.shutdownNow();
    }
}

---

From source file:io.crate.executor.transport.task.elasticsearch.ESDeleteTask.java

@Override
public final ListenableFuture<List<Long>> executeBulk() {
    try {// w ww.  j  av  a  2 s. co  m
        startContext();
    } catch (Throwable throwable) {
        return Futures.immediateFailedFuture(throwable);
    }
    return Futures.successfulAsList(results);
}

---

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

@Override
public Future<RpcResult<AddFlowsBatchOutput>> addFlowsBatch(final AddFlowsBatchInput input) {
    LOG.trace("Adding flows @ {} : {}", PathUtil.extractNodeId(input.getNode()),
            input.getBatchAddFlows().size());
    final ArrayList<ListenableFuture<RpcResult<AddFlowOutput>>> resultsLot = new ArrayList<>();
    for (BatchFlowInputGrouping batchFlow : input.getBatchAddFlows()) {
        final AddFlowInput addFlowInput = new AddFlowInputBuilder(batchFlow)
                .setFlowRef(createFlowRef(input.getNode(), batchFlow)).setNode(input.getNode()).build();
        resultsLot.add(JdkFutureAdapters.listenInPoolThread(salFlowService.addFlow(addFlowInput)));
    }//from   w ww .  j a  va 2 s .c o m

    final ListenableFuture<RpcResult<List<BatchFailedFlowsOutput>>> commonResult = Futures.transform(
            Futures.successfulAsList(resultsLot),
            FlowUtil.<AddFlowOutput>createCumulatingFunction(input.getBatchAddFlows()));

    ListenableFuture<RpcResult<AddFlowsBatchOutput>> addFlowsBulkFuture = Futures.transform(commonResult,
            FlowUtil.FLOW_ADD_TRANSFORM);

    if (input.isBarrierAfter()) {
        addFlowsBulkFuture = BarrierUtil.chainBarrier(addFlowsBulkFuture, input.getNode(), transactionService,
                FlowUtil.FLOW_ADD_COMPOSING_TRANSFORM);
    }

    return addFlowsBulkFuture;
}

---

From source file:com.google.bitcoin.net.discovery.TorDiscovery.java

private List<Circuit> getCircuits(long timeoutValue, TimeUnit timeoutUnit, Set<Router> routers)
        throws InterruptedException {
    createThreadPool(routers.size());//from  w  ww .  ja  v a2 s. com

    try {
        List<ListenableFuture<Circuit>> circuitFutures = Lists.newArrayList();
        for (final Router router : routers) {
            circuitFutures.add(threadPool.submit(new Callable<Circuit>() {
                public Circuit call() throws Exception {
                    return torClient.getCircuitManager().openInternalCircuitTo(Lists.newArrayList(router));
                }
            }));
        }

        int timeouts = 0;
        threadPool.awaitTermination(timeoutValue, timeoutUnit);
        for (ListenableFuture<Circuit> future : circuitFutures) {
            if (!future.isDone()) {
                timeouts++;
                future.cancel(true);
            }
        }
        if (timeouts > 0)
            log.warn("{} DNS lookup circuits timed out", timeouts);

        try {
            List<Circuit> circuits = new ArrayList<Circuit>(Futures.successfulAsList(circuitFutures).get());
            // Any failures will result in null entries.  Remove them.
            circuits.removeAll(singleton(null));
            return circuits;
        } catch (ExecutionException e) {
            // Cannot happen, successfulAsList accepts failures
            throw new RuntimeException(e);
        }
    } finally {
        shutdownThreadPool();
    }
}

---

From source file:com.google.sha1coin.net.discovery.TorDiscovery.java

private List<Circuit> getCircuits(long timeoutValue, TimeUnit timeoutUnit, Set<Router> routers)
        throws InterruptedException {
    createThreadPool(routers.size());/*  w w  w.j  av a  2 s.c om*/

    try {
        List<ListenableFuture<Circuit>> circuitFutures = Lists.newArrayList();
        for (final Router router : routers) {
            circuitFutures.add(threadPool.submit(new Callable<Circuit>() {
                @Override
                public Circuit call() throws Exception {
                    return torClient.getCircuitManager().openInternalCircuitTo(Lists.newArrayList(router));
                }
            }));
        }

        int timeouts = 0;
        threadPool.awaitTermination(timeoutValue, timeoutUnit);
        for (ListenableFuture<Circuit> future : circuitFutures) {
            if (!future.isDone()) {
                timeouts++;
                future.cancel(true);
            }
        }
        if (timeouts > 0)
            log.warn("{} DNS lookup circuits timed out", timeouts);

        try {
            List<Circuit> circuits = new ArrayList<Circuit>(Futures.successfulAsList(circuitFutures).get());
            // Any failures will result in null entries.  Remove them.
            circuits.removeAll(singleton(null));
            return circuits;
        } catch (ExecutionException e) {
            // Cannot happen, successfulAsList accepts failures
            throw new RuntimeException(e);
        }
    } finally {
        shutdownThreadPool();
    }
}

---

From source file:org.guldenj.net.discovery.TorDiscovery.java

private List<Circuit> getCircuits(long timeoutValue, TimeUnit timeoutUnit, Set<Router> routers)
        throws InterruptedException {
    checkArgument(routers.size() >= MINIMUM_ROUTER_LOOKUP_COUNT,
            "Set of {} routers is smaller than required minimum {}", routers.size(),
            MINIMUM_ROUTER_LOOKUP_COUNT);
    createThreadPool(routers.size());/*  w w  w .j  a  v a 2s . c  o  m*/

    try {
        List<ListenableFuture<Circuit>> circuitFutures = Lists.newArrayList();
        final CountDownLatch doneSignal = new CountDownLatch(MINIMUM_ROUTER_LOOKUP_COUNT);
        for (final Router router : routers) {
            ListenableFuture<Circuit> openCircuit = threadPool.submit(new Callable<Circuit>() {
                @Override
                public Circuit call() throws Exception {
                    return torClient.getCircuitManager().openInternalCircuitTo(Lists.newArrayList(router));
                }
            });
            Futures.addCallback(openCircuit, new FutureCallback<Circuit>() {
                @Override
                public void onSuccess(Circuit circuit) {
                    doneSignal.countDown();
                }

                @Override
                public void onFailure(Throwable thrown) {
                    doneSignal.countDown();
                }
            });
            circuitFutures.add(openCircuit);
        }

        boolean countedDown = doneSignal.await(timeoutValue, timeoutUnit);

        try {
            List<Circuit> circuits = new ArrayList<Circuit>(Futures.successfulAsList(circuitFutures).get());
            // Any failures will result in null entries.  Remove them.
            circuits.removeAll(singleton(null));
            int failures = routers.size() - circuits.size();
            if (failures > 0)
                log.warn("{} failures " + (countedDown ? "" : "(including timeout) ")
                        + "opening DNS lookup circuits", failures);
            return circuits;
        } catch (ExecutionException e) {
            // Cannot happen, successfulAsList accepts failures
            throw new RuntimeException(e);
        }
    } finally {
        shutdownThreadPool();
    }
}

---

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

private void setExternalChangeWatcher() throws ExecutionException, InterruptedException {

    ZKOperations.watchChildren(zkClient, "", new ZKOperations.ChildrenCallback() {
        @Override// w w  w .jav a 2s.  c o  m
        public void updated(NodeChildren nodeChildren) {
            List<String> nodes = nodeChildren.getChildren();
            final Map<String, ListenableFuture<NodeData>> nodeAndDataFutures = Maps.newHashMap();
            List<OperationFuture<NodeData>> dataFutures = Lists.newArrayList();
            for (String node : nodes) {
                OperationFuture<NodeData> dataFuture = zkClient.getData(getNodePath(node));
                dataFutures.add(dataFuture);
                nodeAndDataFutures.put(node, dataFuture);
            }

            final ListenableFuture<List<NodeData>> fetchFuture = Futures.successfulAsList(dataFutures);
            fetchFuture.addListener(new Runnable() {
                @Override
                public void run() {
                    ImmutableMap.Builder<String, T> builder = ImmutableMap.builder();
                    for (Map.Entry<String, ListenableFuture<NodeData>> nodeAndData : nodeAndDataFutures
                            .entrySet()) {
                        T value = serializer
                                .deserialize(Futures.getUnchecked(nodeAndData.getValue()).getData());
                        builder.put(nodeAndData.getKey(), value);
                    }

                    currentView.set(builder.build());
                    updateWaitingForElements();
                }
            }, Threads.SAME_THREAD_EXECUTOR);

        }
    });
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• »