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

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

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

Introduction

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

Prototype

public static <I, O> ListenableFuture<O> transform(ListenableFuture<I> input,
        Function<? super I, ? extends O> function, Executor executor)

Source Link

Document

Returns a new ListenableFuture whose result is the product of applying the given Function to the result of the given Future .

Usage

From source file:org.thingsboard.server.dao.timeseries.BaseTimeseriesDao.java

private ListenableFuture<Optional<TsKvEntry>> findAndAggregateAsync(String entityType, UUID entityId,
        TsKvQuery query, long minPartition, long maxPartition) {
    final Aggregation aggregation = query.getAggregation();
    final String key = query.getKey();
    final long startTs = query.getStartTs();
    final long endTs = query.getEndTs();
    final long ts = startTs + (endTs - startTs) / 2;

    ResultSetFuture partitionsFuture = fetchPartitions(entityType, entityId, key, minPartition, maxPartition);

    ListenableFuture<List<Long>> partitionsListFuture = Futures.transform(partitionsFuture,
            getPartitionsArrayFunction(), readResultsProcessingExecutor);

    ListenableFuture<List<ResultSet>> aggregationChunks = Futures.transform(partitionsListFuture,
            getFetchChunksAsyncFunction(entityType, entityId, key, aggregation, startTs, endTs),
            readResultsProcessingExecutor);

    return Futures.transform(aggregationChunks, new AggregatePartitionsFunction(aggregation, key, ts),
            readResultsProcessingExecutor);
}

From source file:com.facebook.buck.distributed.build_slave.MultiSlaveBuildModeRunnerFactory.java

/**
 * Create a {@link CoordinatorAndMinionModeRunner}.
 *
 * @param localBuildExecutor - instance of {@link BuildExecutor} object to be used by the minion.
 * @return a new instance of the {@link CoordinatorAndMinionModeRunner}.
 *///  w ww  . ja  va  2  s .co m
public static CoordinatorAndMinionModeRunner createCoordinatorAndMinion(
        ListenableFuture<DelegateAndGraphs> delegateAndGraphsFuture, List<BuildTarget> topLevelTargets,
        DistBuildConfig distBuildConfig, DistBuildService distBuildService, StampedeId stampedeId,
        Optional<BuildId> clientBuildId, CapacityService capacityService, BuildSlaveRunId buildSlaveRunId,
        ListenableFuture<BuildExecutor> localBuildExecutor, Path logDirectoryPath,
        CoordinatorBuildRuleEventsPublisher coordinatorBuildRuleEventsPublisher,
        MinionBuildProgressTracker minionBuildProgressTracker, BuckEventBus eventBus,
        ListeningExecutorService executorService, ArtifactCache remoteCache,
        BuildSlaveTimingStatsTracker timingStatsTracker, HealthCheckStatsTracker healthCheckStatsTracker) {
    return new CoordinatorAndMinionModeRunner(
            createCoordinator(delegateAndGraphsFuture, topLevelTargets, distBuildConfig, distBuildService,
                    stampedeId, clientBuildId, true, logDirectoryPath, coordinatorBuildRuleEventsPublisher,
                    eventBus, executorService, remoteCache,
                    Futures.transform(localBuildExecutor,
                            buildExecutor -> buildExecutor.getCachingBuildEngine().getRuleKeyCalculator(),
                            executorService),
                    healthCheckStatsTracker, Optional.of(timingStatsTracker),
                    Optional.of(DistBuildUtil.generateMinionId(buildSlaveRunId))),
            createMinion(localBuildExecutor, distBuildService, stampedeId, MinionType.STANDARD_SPEC, // Coordinator should always run on standard spec machine.
                    capacityService, buildSlaveRunId, LOCALHOST_ADDRESS, OptionalInt.empty(), distBuildConfig,
                    minionBuildProgressTracker, eventBus));
}

From source file:org.jclouds.atmos.internal.StubAtmosAsyncClient.java

@Override
public ListenableFuture<BoundedSet<? extends DirectoryEntry>> listDirectory(String directoryName,
        ListOptions... optionsList) {/* w  ww . j  a v  a 2  s.  c o  m*/
    org.jclouds.blobstore.options.ListContainerOptions options = container2ContainerListOptions
            .apply(optionsList);
    String container = directoryName;
    if (directoryName.indexOf('/') != -1) {
        container = directoryName.substring(0, directoryName.indexOf('/'));
        String path = directoryName.substring(directoryName.indexOf('/') + 1);
        if (!path.equals(""))
            options.inDirectory(path);
    }
    return Futures.transform(blobStore.list(container, options), resource2ObjectList, userExecutor);
}

From source file:org.opendaylight.ovsdb.lib.impl.OvsdbClientImpl.java

@Override
public ListenableFuture<DatabaseSchema> getSchema(final String database) {

    DatabaseSchema databaseSchema = schema.get(database);

    if (databaseSchema == null) {
        return Futures.transform(getSchemaFromDevice(Lists.newArrayList(database)),
                new Function<Map<String, DatabaseSchema>, DatabaseSchema>() {
                    @Override//from   w ww.j  a  v  a 2 s . co  m
                    public DatabaseSchema apply(Map<String, DatabaseSchema> result) {
                        if (result.containsKey(database)) {
                            DatabaseSchema dbSchema = result.get(database);
                            dbSchema.populateInternallyGeneratedColumns();
                            OvsdbClientImpl.this.schema.put(database, dbSchema);
                            return dbSchema;
                        } else {
                            return null;
                        }
                    }
                }, executorService);
    } else {
        return Futures.immediateFuture(databaseSchema);
    }
}

From source file:com.toro.torod.connection.DefaultToroTransaction.java

@Override
public ListenableFuture<Iterator<ValueRow<KVValue<?>>>> sqlSelect(String sqlQuery)
        throws UnsupportedOperationException, UserToroException {
    ListenableFuture<Iterator<ValueRow<ScalarValue<?>>>> valueFuture = sessionTransaction.sqlSelect(sqlQuery);

    IteratorTranslator<ValueRow<ScalarValue<?>>, ValueRow<KVValue<?>>> iteratorTranslator = new IteratorTranslator<>(
            TranslatorValueRow.getBuilderFunction(new ToDocValueFunction()));

    return Futures.transform(valueFuture, iteratorTranslator, MoreExecutors.directExecutor());
}

From source file:com.facebook.buck.distributed.DistBuildArtifactCacheImpl.java

@Override
public synchronized void prewarmRemoteContains(ImmutableSet<BuildRule> rulesToBeChecked) {
    @SuppressWarnings("PMD.PrematureDeclaration")
    Stopwatch stopwatch = Stopwatch.createStarted();
    Set<BuildRule> unseenRules = rulesToBeChecked.stream()
            .filter(rule -> !remoteCacheContainsFutures.containsKey(rule)).collect(Collectors.toSet());

    if (unseenRules.isEmpty()) {
        return;/*from ww  w  .j  a v a  2s.  com*/
    }

    LOG.info("Checking remote cache for [%d] new rules.", unseenRules.size());
    Map<BuildRule, ListenableFuture<RuleKey>> rulesToKeys = Maps.asMap(unseenRules,
            rule -> ruleKeyCalculator.calculate(eventBus, rule));

    ListenableFuture<Map<RuleKey, CacheResult>> keysToCacheResultFuture = Futures
            .transformAsync(Futures.allAsList(rulesToKeys.values()), ruleKeys -> {
                LOG.info("Computing RuleKeys for %d new rules took %dms.", unseenRules.size(),
                        stopwatch.elapsed(TimeUnit.MILLISECONDS));
                stopwatch.reset();
                stopwatch.start();
                return multiContainsAsync(ruleKeys);
            }, executorService);

    Map<BuildRule, ListenableFuture<Boolean>> containsResultsForUnseenRules = Maps
            .asMap(unseenRules,
                    rule -> Futures.transform(keysToCacheResultFuture, keysToCacheResult -> Objects
                            .requireNonNull(keysToCacheResult.get(Futures.getUnchecked(rulesToKeys.get(rule))))
                            .getType().isSuccess(), MoreExecutors.directExecutor()));

    remoteCacheContainsFutures.putAll(containsResultsForUnseenRules);
    Futures.allAsList(containsResultsForUnseenRules.values())
            .addListener(() -> LOG.info("Checking the remote cache for %d rules took %dms.", unseenRules.size(),
                    stopwatch.elapsed(TimeUnit.MILLISECONDS)), MoreExecutors.directExecutor());
}

From source file:org.opendaylight.groupbasedpolicy.endpoint.AbstractEndpointRegistry.java

@Override
public Future<RpcResult<Void>> setEndpointGroupConditions(SetEndpointGroupConditionsInput input) {
    WriteTransaction t = dataProvider.newWriteOnlyTransaction();

    ConditionMappingKey key = new ConditionMappingKey(input.getEndpointGroup());

    for (EndpointGroupCondition condition : input.getEndpointGroupCondition()) {
        EndpointGroupConditionKey ckey = new EndpointGroupConditionKey(condition.getCondition());
        InstanceIdentifier<EndpointGroupCondition> iid = InstanceIdentifier.builder(Endpoints.class)
                .child(ConditionMapping.class, key).child(EndpointGroupCondition.class, ckey).build();
        t.put(LogicalDatastoreType.OPERATIONAL, iid, condition);
    }/*from   ww  w  . jav  a2  s.  co  m*/

    ListenableFuture<Void> r = t.submit();
    return Futures.transform(r, futureTrans, executor);
}

From source file:com.orangerhymelabs.helenus.cassandra.document.historical.HistoricalDocumentRepository.java

public ListenableFuture<Boolean> exists(Identifier id) {
    ListenableFuture<ResultSet> future = submitExists(id);
    return Futures.transform(future, new Function<ResultSet, Boolean>() {
        @Override//from w  w  w.j a  v a 2s . c  o  m
        public Boolean apply(ResultSet result) {
            return result.one().getLong(0) > 0;
        }
    }, MoreExecutors.directExecutor());
}

From source file:org.opendaylight.faas.fabrics.vxlan.adapters.ovs.providers.FabricDeviceManager.java

@Override
public Future<RpcResult<Void>> addToVxlanFabric(final AddToVxlanFabricInput input) {
    Preconditions.checkNotNull(input);//from   www  .j av  a  2  s .  c om
    Preconditions.checkNotNull(input.getNodeId());
    Preconditions.checkNotNull(input.getFabricId());

    final RpcResult<Void> result = RpcResultBuilder.<Void>success().build();

    @SuppressWarnings("unchecked")
    final InstanceIdentifier<Node> deviceIId = (InstanceIdentifier<Node>) input.getNodeId();
    final FabricId fabricId = new FabricId(input.getFabricId());

    final Node bridgeNode = OvsSouthboundUtils.getOvsdbBridgeNode(deviceIId, databroker);

    Preconditions.checkNotNull(bridgeNode);

    if (!OvsSouthboundUtils.addVxlanTunnelPort(bridgeNode, databroker)) {
        LOG.error("can not create tunnel port!");
        return Futures.immediateFailedFuture(new RuntimeException("can not create tunnel port"));
    }

    if (!OvsSouthboundUtils.addVxlanGpeTunnelPort(bridgeNode, databroker)) {
        LOG.error("can not create tunnel port!");
        return Futures.immediateFailedFuture(new RuntimeException("can not create nsh tunnel port"));
    }

    FabricCapableDeviceBuilder deviceBuilder = new FabricCapableDeviceBuilder();
    AttributesBuilder attributesBuilder = new AttributesBuilder();

    attributesBuilder.setFabricId(input.getFabricId());

    InstanceIdentifier<Node> fabricpath = Constants.DOM_FABRICS_PATH.child(Node.class,
            new NodeKey(input.getFabricId()));
    attributesBuilder.setFabricRef(new NodeRef(fabricpath));

    deviceBuilder.setAttributes(attributesBuilder.build());

    @SuppressWarnings("unchecked")
    final InstanceIdentifier<FabricCapableDevice> path = ((InstanceIdentifier<Node>) input.getNodeId())
            .augmentation(FabricCapableDevice.class);

    WriteTransaction wt = databroker.newWriteOnlyTransaction();
    wt.merge(LogicalDatastoreType.OPERATIONAL, path, deviceBuilder.build(), true);
    addTp2Fabric(wt, bridgeNode, deviceIId, fabricId);

    CheckedFuture<Void, TransactionCommitFailedException> future = wt.submit();

    return Futures.transform(future, new AsyncFunction<Void, RpcResult<Void>>() {

        @Override
        public ListenableFuture<RpcResult<Void>> apply(Void input) throws Exception {
            renderers.put(deviceIId, new DeviceRenderer(executor, databroker, deviceIId, bridgeNode, fabricId));

            return Futures.immediateFuture(result);
        }
    }, executor);

}

From source file:com.facebook.buck.distributed.MaterializerDummyFileHashCache.java

private ListenableFuture<?> materializeFileAsync(Path relPath, BuildJobStateFileHashEntry fileHashEntry)
        throws IOException {
    // We need to maintain synchronization a per-file basis. Trying to materialize a file again
    // makes the file unavailable for a small window when we're writing it again.
    synchronized (fileHashEntry) {
        // Check if we've previously tried to materialize this file.
        if (fileMaterializationFuturesByFileHashEntry.containsKey(fileHashEntry)) {
            LOG.verbose("File already materialized: [%s].", relPath.toString());
            return fileMaterializationFuturesByFileHashEntry.get(fileHashEntry);
        }//from  w  w  w.j  a va  2s . com

        LOG.info("Materializing file: [%s]", relPath.toString());
        Path absPath = projectFilesystem.resolve(relPath);
        projectFilesystem.createParentDirs(absPath);
        projectFilesystem.touch(absPath);

        ListenableFuture<?> materializationFuture = Futures
                .transform(provider.materializeFileContentsAsync(fileHashEntry, absPath), (success) -> {
                    try {
                        postFileMaterializationHelper(success, relPath, fileHashEntry);
                        return success;
                    } catch (IOException e) {
                        throw new RuntimeException(
                                String.format("Failed to materialize source file [%s] for FileHashEntry=[%s].",
                                        absPath, fileHashEntry),
                                e);
                    }
                }, executorService);

        ListenableFuture<?> prevValue = fileMaterializationFuturesByFileHashEntry.put(fileHashEntry,
                materializationFuture);

        Preconditions.checkState(prevValue == null, "must not override prev value");

        return materializationFuture;
    }
}