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:org.apache.qpid.server.model.AbstractConfiguredObject.java

private ListenableFuture<Void> doAttainState(final AbstractConfiguredObjectExceptionHandler exceptionHandler) {
    final List<ListenableFuture<Void>> childStateFutures = new ArrayList<>();

    applyToChildren(new Action<ConfiguredObject<?>>() {
        @Override//  www  . j  a  va  2  s. c o  m
        public void performAction(final ConfiguredObject<?> child) {
            if (child instanceof AbstractConfiguredObject) {
                AbstractConfiguredObject<?> abstractConfiguredChild = (AbstractConfiguredObject<?>) child;
                if (abstractConfiguredChild._dynamicState.get().getDynamicState() == DynamicState.OPENED) {
                    final AbstractConfiguredObject configuredObject = abstractConfiguredChild;
                    childStateFutures.add(configuredObject.doAttainState(exceptionHandler));
                }
            } else if (child instanceof AbstractConfiguredObjectProxy
                    && ((AbstractConfiguredObjectProxy) child).getDynamicState() == DynamicState.OPENED) {
                final AbstractConfiguredObjectProxy configuredObject = (AbstractConfiguredObjectProxy) child;
                childStateFutures.add(configuredObject.doAttainState(exceptionHandler));
            }
        }
    });

    ListenableFuture<List<Void>> combinedChildStateFuture = Futures.allAsList(childStateFutures);

    final SettableFuture<Void> returnVal = SettableFuture.create();
    addFutureCallback(combinedChildStateFuture, new FutureCallback<List<Void>>() {
        @Override
        public void onSuccess(final List<Void> result) {
            try {
                addFutureCallback(attainState(), new FutureCallback<Void>() {
                    @Override
                    public void onSuccess(final Void result1) {
                        returnVal.set(null);
                    }

                    @Override
                    public void onFailure(final Throwable t) {
                        try {
                            if (t instanceof RuntimeException) {
                                try {
                                    exceptionHandler.handleException((RuntimeException) t,
                                            AbstractConfiguredObject.this);
                                    returnVal.set(null);
                                } catch (RuntimeException r) {
                                    returnVal.setException(r);
                                }
                            }
                        } finally {
                            if (!returnVal.isDone()) {
                                returnVal.setException(t);
                            }
                        }
                    }
                }, getTaskExecutor());
            } catch (RuntimeException e) {
                try {
                    exceptionHandler.handleException(e, AbstractConfiguredObject.this);
                    returnVal.set(null);
                } catch (Throwable t) {
                    returnVal.setException(t);
                }
            }
        }

        @Override
        public void onFailure(final Throwable t) {
            // One or more children failed to attain state but the error could not be handled by the handler
            returnVal.setException(t);
        }
    }, getTaskExecutor());

    return returnVal;
}

From source file:org.opendaylight.vbd.impl.VbdBridgeDomain.java

private ListenableFuture<Void> removeVxlanInterfaces(final NodeId sourceNode) {
    final KeyedInstanceIdentifier<Node, NodeKey> iiToSrcVpp = nodesToVpps.get(sourceNode).iterator().next();
    final List<ListenableFuture<Void>> deleteVxlanTaskList = new ArrayList<>();
    for (final NodeId dstNode : getNodePeers(sourceNode)) {
        final KeyedInstanceIdentifier<Node, NodeKey> iiToDstVpp = nodesToVpps.get(dstNode).iterator().next();
        final List<Ipv4AddressNoZone> endpoints = getTunnelEndpoints(iiToSrcVpp, iiToDstVpp);

        Preconditions.checkState(endpoints.size() == 2,
                "Got IP address list with wrong size (should be 2, actual size is {})", endpoints.size());

        final Ipv4AddressNoZone ipAddressSrcVpp = endpoints.get(SOURCE_VPP_INDEX);
        final Ipv4AddressNoZone ipAddressDstVpp = endpoints.get(DESTINATION_VPP_INDEX);

        // remove bridge domains from vpp
        LOG.debug("Removing bridge domain from vxlan tunnel on node {}", sourceNode);
        deleteVxlanTaskList.add(vppModifier.deleteVxlanInterface(ipAddressSrcVpp, ipAddressDstVpp, iiToSrcVpp));
        LOG.debug("Removing bridge domain from vxlan tunnel on node {}", dstNode);
        deleteVxlanTaskList.add(vppModifier.deleteVxlanInterface(ipAddressDstVpp, ipAddressSrcVpp, iiToDstVpp));
    }//from  w w w .  j  a  v a 2s .co m
    final ListenableFuture<List<Void>> cumulativeDeleteVxlanTask = Futures.allAsList(deleteVxlanTaskList);
    return transform(cumulativeDeleteVxlanTask);
}

From source file:org.hawkular.alerts.engine.impl.CassDefinitionsServiceImpl.java

@Override
public Page<Trigger> getTriggers(String tenantId, TriggersCriteria criteria, Pager pager) throws Exception {
    if (isEmpty(tenantId)) {
        throw new IllegalArgumentException("TenantId must be not null");
    }//from w  w  w.  j a  v  a 2  s . c  om
    boolean filter = (null != criteria && criteria.hasCriteria());
    boolean thin = (null != criteria && criteria.isThin()); // currently ignored, triggers have no thinned data

    if (filter && log.isDebugEnabled()) {
        log.debug("getTriggers criteria: " + criteria.toString());
    }

    List<Trigger> triggers = new ArrayList<>();
    Set<String> triggerIds = new HashSet<>();
    boolean activeFilter = false;

    try {
        if (filter) {
            /*
            Get triggerIds explicitly added into the criteria. Start with these as there is no query involved
            */
            if (criteria.hasTriggerIdCriteria()) {
                Set<String> idsFilteredByTriggers = filterByTriggers(criteria);
                if (activeFilter) {
                    triggerIds.retainAll(idsFilteredByTriggers);
                    if (triggerIds.isEmpty()) {
                        return new Page<>(triggers, pager, 0);
                    }
                } else {
                    triggerIds.addAll(idsFilteredByTriggers);
                }
                activeFilter = true;
            }

            /*
            Get triggerIds via tags
            */
            if (criteria.hasTagCriteria()) {
                Set<String> idsFilteredByTags = getIdsByTags(tenantId, TagType.TRIGGER, criteria.getTags());
                if (activeFilter) {
                    triggerIds.retainAll(idsFilteredByTags);
                    if (triggerIds.isEmpty()) {
                        return new Page<>(triggers, pager, 0);
                    }
                } else {
                    triggerIds.addAll(idsFilteredByTags);
                }
                activeFilter = true;
            }

            /*
            If we have reached this point then we have at least 1 filtered triggerId, so now
            get the resulting Triggers...
             */
            PreparedStatement selectTrigger = CassStatement.get(session, CassStatement.SELECT_TRIGGER);
            List<ResultSetFuture> futures = triggerIds.stream()
                    .map(id -> session.executeAsync(selectTrigger.bind(tenantId, id)))
                    .collect(Collectors.toList());
            List<ResultSet> rsTriggers = Futures.allAsList(futures).get();
            for (ResultSet rs : rsTriggers) {
                for (Row row : rs) {
                    Trigger trigger = mapTrigger(row);
                    selectTriggerActions(trigger);
                    triggers.add(trigger);
                }
            }
        } else {
            triggers.addAll(selectTriggers(tenantId));

        }
    } catch (Exception e) {
        msgLog.errorDatabaseException(e.getMessage());
        throw e;
    }

    return prepareTriggersPage(triggers, pager);
}

From source file:org.hawkular.alerts.engine.impl.CassDefinitionsServiceImpl.java

private Set<String> getIdsByTags(String tenantId, TagType tagType, Map<String, String> tags) throws Exception {
    Set<String> ids = new HashSet<>();
    List<ResultSetFuture> futures = new ArrayList<>();
    PreparedStatement selectTagsByName = CassStatement.get(session, CassStatement.SELECT_TAGS_BY_NAME);
    PreparedStatement selectTagsByNameAndValue = CassStatement.get(session,
            CassStatement.SELECT_TAGS_BY_NAME_AND_VALUE);

    for (Entry<String, String> tag : tags.entrySet()) {
        boolean nameOnly = "*".equals(tag.getValue());
        BoundStatement bs = nameOnly ? selectTagsByName.bind(tenantId, tagType.name(), tag.getKey())
                : selectTagsByNameAndValue.bind(tenantId, tagType.name(), tag.getKey(), tag.getValue());
        futures.add(session.executeAsync(bs));
    }/*from  w w w  . j  a va 2s. c  o m*/
    List<ResultSet> rsTags = Futures.allAsList(futures).get();
    rsTags.stream().forEach(r -> {
        for (Row row : r) {
            ids.add(row.getString("id"));
        }
    });
    return ids;
}

From source file:org.opendaylight.vbd.impl.VbdBridgeDomain.java

private ListenableFuture<Void> createNode(final Node node) {
    List<ListenableFuture<Void>> createdNodesFuture = new ArrayList<>();
    for (SupportingNode supportingNode : node.getSupportingNode()) {
        final NodeId nodeMount = supportingNode.getNodeRef();
        final VbdNetconfConnectionProbe probe = new VbdNetconfConnectionProbe(supportingNode.getNodeRef(),
                dataBroker);//from   www  .  j a va2  s . co  m
        try {
            // Verify netconf connection
            boolean connectionReady = probe.startProbing();
            if (connectionReady) {
                LOG.debug("Node {} is connected, creating ...", supportingNode.getNodeRef());
                final TopologyId topologyMount = supportingNode.getTopologyRef();
                final KeyedInstanceIdentifier<Node, NodeKey> iiToVpp = InstanceIdentifier
                        .create(NetworkTopology.class).child(Topology.class, new TopologyKey(topologyMount))
                        .child(Node.class, new NodeKey(nodeMount));
                nodesToVpps.put(node.getNodeId(), iiToVpp);
                ListenableFuture<Void> addVppToBridgeDomainFuture = vppModifier.addVppToBridgeDomain(iiToVpp);
                createdNodesFuture.add(addSupportingBridgeDomain(addVppToBridgeDomainFuture, node));
            } else {
                LOG.debug("Failed while connecting to node {}", supportingNode.getNodeRef());
            }
        } catch (InterruptedException | ExecutionException e) {
            LOG.warn("Exception while processing node {} ... ", supportingNode.getNodeRef(), e);
        } catch (TimeoutException e) {
            LOG.warn(
                    "Node {} was not connected within {} seconds. Check node configuration and connectivity to proceed",
                    supportingNode.getNodeRef(), VbdNetconfConnectionProbe.NODE_CONNECTION_TIMER);
        }
    }
    // configure all or nothing
    return Futures.transform(Futures.allAsList(createdNodesFuture), new Function<List<Void>, Void>() {

        @Override
        public Void apply(List<Void> input) {
            return null;
        }

    });
}

From source file:com.microsoftopentechnologies.intellij.helpers.o365.Office365RestAPIManager.java

@Override
public ListenableFuture<List<ServicePrincipal>> addServicePrincipals(
        @NotNull final List<ServicePrincipal> servicePrincipals) throws ParseException {

    return requestWithToken(new RequestCallback<List<ServicePrincipal>>() {
        @Override/*w  ww. j  a v  a  2 s .c o m*/
        public ListenableFuture<List<ServicePrincipal>> execute() throws ParseException {
            List<ListenableFuture<ServicePrincipal>> futures = Lists.transform(servicePrincipals,
                    new Function<ServicePrincipal, ListenableFuture<ServicePrincipal>>() {
                        @Override
                        public ListenableFuture<ServicePrincipal> apply(ServicePrincipal servicePrincipal) {
                            try {
                                return getDirectoryClient().getservicePrincipals().add(servicePrincipal);
                            } catch (ParseException e) {
                                return Futures.immediateFailedFuture(e);
                            }
                        }
                    });

            return Futures.allAsList(futures);
        }
    });
}

From source file:com.b2international.snowowl.snomed.api.impl.SnomedMergeReviewServiceImpl.java

@Override
public Merge mergeAndReplayConceptUpdates(final String mergeReviewId, final String userId,
        final List<ExtendedLocale> extendedLocales)
        throws IOException, InterruptedException, ExecutionException, ConflictException {
    final MergeReview mergeReview = getMergeReview(mergeReviewId);
    final String sourcePath = mergeReview.sourcePath();
    final String targetPath = mergeReview.targetPath();

    // Check we have a full set of manually merged concepts 
    final Set<String> mergeReviewIntersection = getFilteredMergeReviewIntersection(mergeReview);
    final List<ListenableFuture<String>> changeFutures = Lists.newArrayList();
    final MergeReviewParameters parameters = new MergeReviewParameters(sourcePath, targetPath, extendedLocales,
            mergeReview.id());/*from   w  ww  .ja v a2  s . c  o m*/

    for (final String conceptId : mergeReviewIntersection) {
        changeFutures.add(executorService.submit(new ComputeIntersectionIdsCallable(conceptId, parameters)));
    }

    final List<String> changes = Futures.allAsList(changeFutures).get();
    final Set<String> relevantIntersection = changes.stream().filter(change -> change != SKIP_ID)
            .collect(toSet());

    final List<ISnomedBrowserConcept> conceptUpdates = new ArrayList<ISnomedBrowserConcept>();
    for (final String conceptId : relevantIntersection) {
        if (!getManualConceptMergeService().exists(targetPath, mergeReviewId, conceptId)) {
            throw new BadRequestException("Manually merged concept %s does not exist for merge review %s",
                    conceptId, mergeReviewId);
        } else {
            conceptUpdates.add(getManualConceptMergeService().retrieve(targetPath, mergeReviewId, conceptId));
        }
    }

    final UUID mergeId = UUID.randomUUID();
    final String address = String.format(Merge.ADDRESS_TEMPLATE, SnomedDatastoreActivator.REPOSITORY_UUID,
            mergeId);

    // using a latch here because the merge sends notification to the handlers on a different thread, so the actual concept apply may/or may not
    // happen by the end of this method.
    // the latch here makes sure that the handlers run before returning from this method.
    CountDownLatch latch = new CountDownLatch(1);
    MergeReviewCompletionHandler mergeReviewCompletionHandler = new MergeReviewCompletionHandler(address,
            getBus(), latch,
            // Set up one-shot handlers that will be notified when the merge completes successfully
            new ConceptUpdateHandler(conceptUpdates, userId, extendedLocales, getBrowserService()),
            new MergeReviewDeleteHandler(mergeReview.id()),
            new ManualMergeDeleteHandler(getManualConceptMergeService(), mergeReviewId));

    mergeReviewCompletionHandler.register();

    Merge merge = RepositoryRequests.merging().prepareCreate().setId(mergeId)
            .setUserId(User.SYSTEM.getUsername()).setSource(sourcePath).setTarget(targetPath)
            .setReviewId(mergeReview.sourceToTargetReviewId())
            .setCommitComment("Auto merging branches before applying manually merged concepts. " + sourcePath
                    + " > " + targetPath)
            .build(SnomedDatastoreActivator.REPOSITORY_UUID).execute(getBus()).getSync();

    latch.await(20, TimeUnit.MINUTES);
    Optional<Collection<MergeConflict>> conflictsOptional = mergeReviewCompletionHandler.conflictsOptional();
    if (conflictsOptional.isPresent()) {
        Collection<MergeConflict> collection = conflictsOptional.get();
        collection.forEach(conflict -> {
            LOG.info("Found conflict: {}", conflict.getMessage());
        });
        throw new MergeConflictException(collection, "Encountered conflicts while applying merge.");
    }
    return merge;
}

From source file:com.sk89q.worldguard.bukkit.commands.RegionCommands.java

/**
 * Reload the region database./* www. j a  va  2s .  com*/
 * 
 * @param args the arguments
 * @param sender the sender
 * @throws CommandException any error
 */
@Command(aliases = { "load", "reload" }, usage = "[world]", desc = "Reload regions from file", flags = "w:")
public void load(CommandContext args, final CommandSender sender) throws CommandException {
    World world = null;
    try {
        world = getWorld(args, sender, 'w'); // Get the world
    } catch (CommandException e) {
        // assume the user wants to reload all worlds
    }

    // Check permissions
    if (!getPermissionModel(sender).mayForceLoadRegions()) {
        throw new CommandPermissionsException();
    }

    if (world != null) {
        RegionManager regionManager = plugin.getGlobalRegionManager().get(world);
        if (regionManager == null) {
            throw new CommandException("No region manager exists for world '" + world.getName() + "'.");
        }
        reloadChanges(sender, regionManager, world, false);
    } else {
        List<ListenableFuture<?>> futures = new ArrayList<ListenableFuture<?>>();
        for (World w : plugin.getServer().getWorlds()) {
            RegionManager regionManager = plugin.getGlobalRegionManager().get(w);
            if (regionManager == null) {
                continue;
            }
            futures.add(reloadChanges(sender, regionManager, world, true));
        }

        Futures.addCallback(Futures.allAsList(futures), new FutureCallback<Object>() {
            @Override
            public void onSuccess(Object o) {
                sender.sendMessage(ChatColor.YELLOW + "Successfully loaded region data for all worlds.");
            }

            @Override
            public void onFailure(Throwable throwable) {
                sender.sendMessage(
                        ChatColor.RED + "Failed to load region data for all worlds: " + throwable.getMessage());
                plugin.getLogger().log(Level.WARNING, "Failed to load region data", throwable);
            }
        });
    }
}

From source file:com.sk89q.worldguard.bukkit.commands.RegionCommands.java

/**
 * Re-save the region database./*from ww  w .  jav a  2 s .  c  o  m*/
 * 
 * @param args the arguments
 * @param sender the sender
 * @throws CommandException any error
 */
@Command(aliases = { "save", "write" }, usage = "[world]", desc = "Re-save regions to file", flags = "w:")
public void save(CommandContext args, final CommandSender sender) throws CommandException {
    World world = null;
    try {
        world = getWorld(args, sender, 'w'); // Get the world
    } catch (CommandException e) {
        // assume user wants to save all worlds
    }

    // Check permissions
    if (!getPermissionModel(sender).mayForceSaveRegions()) {
        throw new CommandPermissionsException();
    }

    if (world != null) {
        RegionManager regionManager = plugin.getGlobalRegionManager().get(world);
        if (regionManager == null) {
            throw new CommandException("No region manager exists for world '" + world.getName() + "'.");
        }
        commitChanges(sender, regionManager, world, false);
    } else {
        sender.sendMessage(ChatColor.YELLOW + "Saving all region databases... This might take a bit.");
        List<ListenableFuture<?>> futures = new ArrayList<ListenableFuture<?>>();
        for (World w : plugin.getServer().getWorlds()) {
            RegionManager regionManager = plugin.getGlobalRegionManager().get(w);
            if (regionManager == null) {
                continue;
            }
            futures.add(commitChanges(sender, regionManager, world, true));
        }

        Futures.addCallback(Futures.allAsList(futures), new FutureCallback<Object>() {
            @Override
            public void onSuccess(Object o) {
                sender.sendMessage(ChatColor.YELLOW + "Successfully saved region data for all worlds.");
            }

            @Override
            public void onFailure(Throwable throwable) {
                sender.sendMessage(
                        ChatColor.RED + "Failed to save region data for all worlds: " + throwable.getMessage());
                plugin.getLogger().log(Level.WARNING, "Failed to save region data", throwable);
            }
        });
    }
}

From source file:org.hawkular.alerts.engine.impl.CassDefinitionsServiceImpl.java

@Override
public Collection<Trigger> getAllTriggersByTag(String name, String value) throws Exception {
    if (isEmpty(name)) {
        throw new IllegalArgumentException("name must be not null");
    }//from   w w  w  .j  a v  a 2 s  . c  om
    if (isEmpty(value)) {
        throw new IllegalArgumentException("value must be not null (use '*' for all");
    }

    try {
        // first, get all the partitions (i.e. tenants) for triggers
        BoundStatement bs = CassStatement.get(session, CassStatement.SELECT_PARTITIONS_TRIGGERS).bind();
        Set<String> tenants = new HashSet<>();
        for (Row row : session.execute(bs)) {
            tenants.add(row.getString("tenantId"));
        }

        // next, get all of the tagged triggerIds
        boolean nameOnly = "*".equals(value);
        PreparedStatement selectTags = nameOnly ? CassStatement.get(session, CassStatement.SELECT_TAGS_BY_NAME)
                : CassStatement.get(session, CassStatement.SELECT_TAGS_BY_NAME_AND_VALUE);
        if (selectTags == null) {
            throw new RuntimeException("selectTags PreparedStatement is null");
        }

        String triggerType = TagType.TRIGGER.name();
        Map<String, Set<String>> tenantTriggerIdsMap = new HashMap<>();
        List<ResultSetFuture> futures = nameOnly
                ? tenants.stream()
                        .map(tenantId -> session.executeAsync(selectTags.bind(tenantId, triggerType, name)))
                        .collect(Collectors.toList())
                : tenants.stream().map(
                        tenantId -> session.executeAsync(selectTags.bind(tenantId, triggerType, name, value)))
                        .collect(Collectors.toList());
        List<ResultSet> rsTriggerIds = Futures.allAsList(futures).get();
        rsTriggerIds.stream().forEach(rs -> {
            for (Row row : rs) {
                String tenantId = row.getString("tenantId");
                String triggerId = row.getString("id");
                Set<String> storedTriggerIds = tenantTriggerIdsMap.get(tenantId);
                if (null == storedTriggerIds) {
                    storedTriggerIds = new HashSet<>();
                }
                storedTriggerIds.add(triggerId);
                tenantTriggerIdsMap.put(tenantId, storedTriggerIds);
            }
        });

        // Now, generate a cross-tenant result set if Triggers using the tenantIds and triggerIds
        List<Trigger> triggers = new ArrayList<>();
        PreparedStatement selectTrigger = CassStatement.get(session, CassStatement.SELECT_TRIGGER);
        for (Entry<String, Set<String>> entry : tenantTriggerIdsMap.entrySet()) {
            String tenantId = entry.getKey();
            Set<String> triggerIds = entry.getValue();
            futures = triggerIds.stream()
                    .map(triggerId -> session.executeAsync(selectTrigger.bind(tenantId, triggerId)))
                    .collect(Collectors.toList());
            List<ResultSet> rsTriggers = Futures.allAsList(futures).get();
            for (ResultSet rs : rsTriggers) {
                for (Row row : rs) {
                    Trigger trigger = mapTrigger(row);
                    selectTriggerActions(trigger);
                    triggers.add(trigger);
                }
            }
        }

        return triggers;

    } catch (Exception e) {
        msgLog.errorDatabaseException(e.getMessage());
        throw e;
    }
}