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

List of usage examples for com.google.common.util.concurrent Futures 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.service.transport.LocalTransportApiService.java

private ListenableFuture<TransportApiResponseMsg> handle(GetOrCreateDeviceFromGatewayRequestMsg requestMsg) {
    DeviceId gatewayId = new DeviceId(new UUID(requestMsg.getGatewayIdMSB(), requestMsg.getGatewayIdLSB()));
    ListenableFuture<Device> gatewayFuture = deviceService.findDeviceByIdAsync(TenantId.SYS_TENANT_ID,
            gatewayId);//from   w w  w  . j  ava2 s  .  c om
    return Futures.transform(gatewayFuture, gateway -> {
        deviceCreationLock.lock();
        try {
            Device device = deviceService.findDeviceByTenantIdAndName(gateway.getTenantId(),
                    requestMsg.getDeviceName());
            if (device == null) {
                device = new Device();
                device.setTenantId(gateway.getTenantId());
                device.setName(requestMsg.getDeviceName());
                device.setType(requestMsg.getDeviceType());
                device.setCustomerId(gateway.getCustomerId());
                device = deviceService.saveDevice(device);
                relationService.saveRelationAsync(TenantId.SYS_TENANT_ID,
                        new EntityRelation(gateway.getId(), device.getId(), "Created"));
                deviceStateService.onDeviceAdded(device);
            }
            return TransportApiResponseMsg.newBuilder()
                    .setGetOrCreateDeviceResponseMsg(GetOrCreateDeviceFromGatewayResponseMsg.newBuilder()
                            .setDeviceInfo(getDeviceInfoProto(device)).build())
                    .build();
        } catch (JsonProcessingException e) {
            log.warn("[{}] Failed to lookup device by gateway id and name", gatewayId,
                    requestMsg.getDeviceName(), e);
            throw new RuntimeException(e);
        } finally {
            deviceCreationLock.unlock();
        }
    }, dbCallbackExecutorService);
}

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

private ListenableFuture<List<TsKvEntry>> findAllAsync(String entityType, UUID entityId, TsKvQuery query) {
    if (query.getAggregation() == Aggregation.NONE) {
        return findAllAsyncWithLimit(entityType, entityId, query);
    } else {/*from  w ww  . java 2s  .co  m*/
        long step = Math.max(query.getInterval(), minAggregationStepMs);
        long stepTs = query.getStartTs();
        List<ListenableFuture<Optional<TsKvEntry>>> futures = new ArrayList<>();
        while (stepTs < query.getEndTs()) {
            long startTs = stepTs;
            long endTs = stepTs + step;
            TsKvQuery subQuery = new BaseTsKvQuery(query.getKey(), startTs, endTs, step, 1,
                    query.getAggregation());
            futures.add(findAndAggregateAsync(entityType, entityId, subQuery, toPartitionTs(startTs),
                    toPartitionTs(endTs)));
            stepTs = endTs;
        }
        ListenableFuture<List<Optional<TsKvEntry>>> future = Futures.allAsList(futures);
        return Futures.transform(future, new Function<List<Optional<TsKvEntry>>, List<TsKvEntry>>() {
            @Nullable
            @Override
            public List<TsKvEntry> apply(@Nullable List<Optional<TsKvEntry>> input) {
                return input.stream().filter(v -> v.isPresent()).map(v -> v.get()).collect(Collectors.toList());
            }
        }, readResultsProcessingExecutor);
    }
}

From source file:com.skcraft.launcher.launch.LaunchSupervisor.java

private void launch(Window window, Instance instance, Session session, final LaunchListener listener) {
    final File extractDir = launcher.createExtractDir();

    // Get the process
    Runner task = new Runner(launcher, instance, session, extractDir);
    ObservableFuture<Process> processFuture = new ObservableFuture<Process>(launcher.getExecutor().submit(task),
            task);//from  www .j  a v  a 2 s  .c  o m

    // Show process for the process retrieval
    ProgressDialog.showProgress(window, processFuture, SharedLocale.tr("launcher.launchingTItle"),
            tr("launcher.launchingStatus", instance.getTitle()));

    // If the process is started, get rid of this window
    Futures.addCallback(processFuture, new FutureCallback<Process>() {
        @Override
        public void onSuccess(Process result) {
            SwingUtilities.invokeLater(new Runnable() {
                @Override
                public void run() {
                    listener.gameStarted();
                }
            });
        }

        @Override
        public void onFailure(Throwable t) {
        }
    });

    // Watch the created process
    ListenableFuture<?> future = Futures.transform(processFuture, new LaunchProcessHandler(launcher),
            launcher.getExecutor());
    SwingHelper.addErrorDialogCallback(null, future);

    // Clean up at the very end
    future.addListener(new Runnable() {
        @Override
        public void run() {
            try {
                log.info("Process ended; cleaning up " + extractDir.getAbsolutePath());
                FileUtils.deleteDirectory(extractDir);
            } catch (IOException e) {
                log.log(Level.WARNING, "Failed to clean up " + extractDir.getAbsolutePath(), e);
            }

            SwingUtilities.invokeLater(new Runnable() {
                @Override
                public void run() {
                    listener.gameClosed();
                }
            });
        }
    }, sameThreadExecutor());
}

From source file:com.facebook.buck.core.build.engine.cache.manager.BuildCacheArtifactFetcher.java

public ListenableFuture<CacheResult> fetch(ArtifactCache artifactCache, RuleKey ruleKey, LazyPath outputPath) {
    return Futures.transform(artifactCache.fetchAsync(rule.getBuildTarget(), ruleKey, outputPath),
            (CacheResult cacheResult) -> {
                try (Scope ignored = buildRuleScope()) {
                    if (cacheResult.getType() != CacheResultType.HIT) {
                        return cacheResult;
                    }/*from w w w  .  ja v  a2 s .  co  m*/
                    for (String ruleKeyName : BuildInfo.RULE_KEY_NAMES) {
                        if (!cacheResult.getMetadata().containsKey(ruleKeyName)) {
                            continue;
                        }
                        String ruleKeyValue = cacheResult.getMetadata().get(ruleKeyName);
                        try {
                            verify(ruleKeyValue);
                        } catch (IllegalArgumentException e) {
                            throw new IllegalArgumentException(String.format(
                                    "Invalid '%s' rule key in metadata for artifact '%s' returned by cache '%s': '%s'",
                                    ruleKeyName, ruleKey, artifactCache.getClass(), ruleKeyValue), e);
                        }
                    }
                    return cacheResult;
                }
            }, executorService);
}

From source file:info.archinnov.achilles.internal.async.AsyncUtils.java

public ListenableFuture<ResultSet> applyLoggingTracingAndCASCheck(ResultSetFuture resultSetFuture,
        final AbstractStatementWrapper statementWrapper, ExecutorService executorService) {

    Function<ResultSet, ResultSet> tracing = new Function<ResultSet, ResultSet>() {
        @Override// ww w  .jav  a2 s.co m
        public ResultSet apply(ResultSet resultSet) {
            statementWrapper.tracing(resultSet);
            return resultSet;
        }
    };

    Function<ResultSet, ResultSet> LWTCheck = new Function<ResultSet, ResultSet>() {
        @Override
        public ResultSet apply(ResultSet resultSet) {
            statementWrapper.checkForLWTSuccess(resultSet);
            return resultSet;
        }
    };

    final ListenableFuture<ResultSet> tracingApplied = Futures.transform(resultSetFuture, tracing,
            executorService);
    return Futures.transform(tracingApplied, LWTCheck);
}

From source file:io.v.v23.VFutures.java

/**
 * Returns a new {@link ListenableFuture} that runs on an {@link Executor} specified in the
 * given {@code context}. If the future completes but the given {@code context} has been
 * canceled, the returned future is canceled as well.
 *//*from   ww w  . j a va 2s  .c  om*/
public static <T> ListenableFuture<T> withUserLandChecks(final VContext context,
        final ListenableFuture<T> future) {
    Executor executor = V.getExecutor(context);
    if (executor == null) {
        throw new RuntimeException("NULL executor in context: did you derive this context "
                + "from the context returned by V.init()?");
    }
    return Futures.transform(future, new AsyncFunction<T, T>() {
        @Override
        public ListenableFuture<T> apply(T input) throws Exception {
            if (context.isCanceled()) {
                return Futures.immediateCancelledFuture();
            }
            return Futures.immediateFuture(input);
        }
    }, executor);
}

From source file:org.jclouds.compute.strategy.impl.CreateNodesWithGroupEncodedIntoNameThenAddToSet.java

/**
 * This implementation gets a list of acceptable node names to encode the group into, then it
 * simultaneously runs the nodes and applies options to them.
 *///from www. j  ava  2s  . c  o  m
@Override
public Map<?, ListenableFuture<Void>> execute(String group, int count, Template template,
        Set<NodeMetadata> goodNodes, Map<NodeMetadata, Exception> badNodes,
        Multimap<NodeMetadata, CustomizationResponse> customizationResponses) {
    Map<String, ListenableFuture<Void>> responses = newLinkedHashMap();
    for (String name : getNextNames(group, template, count)) {
        responses.put(name,
                Futures.transform(createNodeInGroupWithNameAndTemplate(group, name, template),
                        customizeNodeAndAddToGoodMapOrPutExceptionIntoBadMapFactory
                                .create(template.getOptions(), goodNodes, badNodes, customizationResponses),
                        userExecutor));
    }
    return responses;
}

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

private static ListenableFuture<ImmutableList<BuildJobStateFileHashes>> fileHashesComputation(
        ListenableFuture<Void> ruleKeyComputationForSideEffect,
        final LoadingCache<ProjectFilesystem, BuildJobStateFileHashes> remoteFileHashes,
        ListeningExecutorService executorService) {
    return Futures.transform(ruleKeyComputationForSideEffect,
            new Function<Void, ImmutableList<BuildJobStateFileHashes>>() {
                @Override//from   w w w.  j  av a2  s  .  c  o m
                public ImmutableList<BuildJobStateFileHashes> apply(Void input) {
                    return ImmutableList.copyOf(remoteFileHashes.asMap().values());
                }
            }, executorService);
}

From source file:dagger.producers.internal.SetOfProducedProducer.java

/**
 * Returns a future {@link Set} of {@link Produced} values whose iteration order is that of the
 * elements given by each of the producers, which are invoked in the order given at creation.
 *
 * <p>If any of the delegate collections, or any elements therein, are null, then that
 * corresponding {@code Produced} element will fail with a NullPointerException.
 *
 * <p>Canceling this future will attempt to cancel all of the component futures; but if any of the
 * delegate futures fail or are canceled, this future succeeds, with the appropriate failed
 * {@link Produced}.//from w w  w  .ja v  a2  s. co  m
 *
 * @throws NullPointerException if any of the delegate producers return null
 */
@Override
public ListenableFuture<Set<Produced<T>>> compute() {
    List<ListenableFuture<? extends Produced<? extends Collection<T>>>> futureProducedCollections = new ArrayList<ListenableFuture<? extends Produced<? extends Collection<T>>>>(
            individualProducers.size() + collectionProducers.size());
    for (Producer<T> producer : individualProducers) {
        // TODO(ronshapiro): Don't require individual productions to be added to a collection just to
        // be materialized into futureProducedCollections.
        futureProducedCollections.add(Producers
                .createFutureProduced(Producers.createFutureSingletonSet(checkNotNull(producer.get()))));
    }
    for (Producer<Collection<T>> producer : collectionProducers) {
        futureProducedCollections.add(Producers.createFutureProduced(checkNotNull(producer.get())));
    }

    return Futures.transform(Futures.allAsList(futureProducedCollections),
            new Function<List<Produced<? extends Collection<T>>>, Set<Produced<T>>>() {
                @Override
                public Set<Produced<T>> apply(List<Produced<? extends Collection<T>>> producedCollections) {
                    ImmutableSet.Builder<Produced<T>> builder = ImmutableSet.builder();
                    for (Produced<? extends Collection<T>> producedCollection : producedCollections) {
                        try {
                            Collection<T> collection = producedCollection.get();
                            if (collection == null) {
                                // TODO(beder): This is a vague exception. Can we somehow point to the failing
                                // producer? See the similar comment in the component writer about null
                                // provisions.
                                builder.add(Produced.<T>failed(new NullPointerException(
                                        "Cannot contribute a null collection into a producer set binding when"
                                                + " it's injected as Set<Produced<T>>.")));
                            } else {
                                for (T value : collection) {
                                    if (value == null) {
                                        builder.add(Produced.<T>failed(new NullPointerException(
                                                "Cannot contribute a null element into a producer set binding"
                                                        + " when it's injected as Set<Produced<T>>.")));
                                    } else {
                                        builder.add(Produced.successful(value));
                                    }
                                }
                            }
                        } catch (ExecutionException e) {
                            builder.add(Produced.<T>failed(e.getCause()));
                        }
                    }
                    return builder.build();
                }
            }, directExecutor());
}

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

public ExitCode buildAndReturnExitCode() throws Exception {
    if (args.getRemoteCommand() == RemoteCommand.RULE_KEY_DIVERGENCE_CHECK) {
        return setPreparationCallbackAndRun(RuleKeyDivergenceRunnerFactory.createRunner(args.getStampedeId(),
                args.getBuildSlaveRunId(), args.getClock(), args.getDistBuildService(), initializer,
                args.getRuleKeyConfiguration(), args.getRuleKeyCacheScope(), args.getExecutorService(),
                args.getBuckEventBus(), args.getState(), args.getRootCell(),
                args.getUnconfiguredBuildTargetFactory()));
    }// w w  w.ja v a 2 s.c  o m

    Optional<BuildId> clientBuildId = fetchClientBuildId();

    DistBuildModeRunner runner = null;
    if (DistBuildMode.COORDINATOR == args.getDistBuildMode()) {
        if (args.getDistBuildConfig().getSchedulingEnvironmentType() == SchedulingEnvironmentType.MIXED_HARDWARE
                && !args.getDistBuildConfig().getLowSpecMinionQueue().isPresent()) {
            args.getConsole().printErrorText(
                    "Stampede Low Spec Minion Queue name must be specified to used mixed hardware environment");
            return ExitCode.COMMANDLINE_ERROR;
        }

        runner = MultiSlaveBuildModeRunnerFactory.createCoordinator(initializer.getDelegateAndGraphs(),
                getTopLevelTargetsToBuild(), args.getDistBuildConfig(), args.getDistBuildService(),
                args.getStampedeId(), clientBuildId, false, args.getLogDirectoryPath(),
                args.getCoordinatorBuildRuleEventsPublisher(), args.getBuckEventBus(),
                args.getExecutorService(), args.getArtifactCacheFactory().remoteOnlyInstance(true, false),
                Futures.transform(initializer.getDelegateAndGraphs(), graphs -> {
                    SourcePathRuleFinder ruleFinder = new SourcePathRuleFinder(
                            graphs.getActionGraphAndBuilder().getActionGraphBuilder());
                    return new ParallelRuleKeyCalculator<RuleKey>(args.getExecutorService(),
                            new DefaultRuleKeyFactory(new RuleKeyFieldLoader(args.getRuleKeyConfiguration()),
                                    graphs.getCachingBuildEngineDelegate().getFileHashCache(),
                                    DefaultSourcePathResolver.from(ruleFinder), ruleFinder,
                                    args.getRuleKeyCacheScope().getCache(), Optional.empty()),
                            new DefaultRuleDepsCache(graphs.getActionGraphAndBuilder().getActionGraphBuilder()),
                            (buckEventBus, rule) -> () -> {
                            });
                }, MoreExecutors.directExecutor()), args.getHealthCheckStatsTracker(),
                Optional.of(args.getTimingStatsTracker()),
                Optional.of(DistBuildUtil.generateMinionId(args.getBuildSlaveRunId())));
        return setPreparationCallbackAndRun(runner);
    }

    BuildExecutorArgs builderArgs = args.createBuilderArgs();
    try (ExecutionContext executionContext = LocalBuildExecutor.createExecutionContext(builderArgs)) {
        ListenableFuture<BuildExecutor> localBuildExecutor = createBuilder(builderArgs, executionContext);

        switch (args.getDistBuildMode()) {
        case REMOTE_BUILD:
            runner = new RemoteBuildModeRunner(localBuildExecutor,
                    args.getState().getRemoteState().getTopLevelTargets(),
                    createRemoteBuildFinalBuildStatusSetter(), args.getDistBuildService(),
                    args.getStampedeId());
            break;

        case MINION:
            runner = MultiSlaveBuildModeRunnerFactory.createMinion(localBuildExecutor,
                    args.getDistBuildService(), args.getStampedeId(), args.getDistBuildConfig().getMinionType(),
                    args.getCapacityService(), args.getBuildSlaveRunId(), args.getRemoteCoordinatorAddress(),
                    OptionalInt.of(args.getRemoteCoordinatorPort()), args.getDistBuildConfig(),
                    args.getMinionBuildProgressTracker(), args.getBuckEventBus());
            break;

        case COORDINATOR_AND_MINION:
            runner = MultiSlaveBuildModeRunnerFactory.createCoordinatorAndMinion(
                    initializer.getDelegateAndGraphs(), getTopLevelTargetsToBuild(), args.getDistBuildConfig(),
                    args.getDistBuildService(), args.getStampedeId(), clientBuildId, args.getCapacityService(),
                    args.getBuildSlaveRunId(), localBuildExecutor, args.getLogDirectoryPath(),
                    args.getCoordinatorBuildRuleEventsPublisher(), args.getMinionBuildProgressTracker(),
                    args.getBuckEventBus(), args.getExecutorService(),
                    args.getArtifactCacheFactory().remoteOnlyInstance(true, false),
                    args.getTimingStatsTracker(), args.getHealthCheckStatsTracker());
            break;

        case COORDINATOR:
            throw new IllegalStateException("COORDINATOR mode should have already been handled.");

        default:
            LOG.error("Unknown distributed build mode [%s].", args.getDistBuildMode().toString());
            return ExitCode.FATAL_GENERIC;
        }

        return setPreparationCallbackAndRun(runner);
    }
}