Example usage for com.google.common.util.concurrent ListenableFutureTask create

Introduction

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

Prototype

public static <V> ListenableFutureTask<V> create(Callable<V> callable) 

Source Link

Document

Creates a ListenableFutureTask that will upon running, execute the given Callable .

Usage

From source file:com.yahoo.yqlplus.engine.internal.scope.ScopedTracingExecutor.java

@Override
protected final <T> ListenableFutureTask<T> newTaskFor(Callable<T> callable) {
    return ListenableFutureTask.create(callable);
}

---

From source file:org.apache.cassandra.auth.PermissionsCache.java

private LoadingCache<Pair<AuthenticatedUser, IResource>, Set<Permission>> initCache(
        LoadingCache<Pair<AuthenticatedUser, IResource>, Set<Permission>> existing) {
    if (authorizer instanceof AllowAllAuthorizer)
        return null;

    if (DatabaseDescriptor.getPermissionsValidity() <= 0)
        return null;

    LoadingCache<Pair<AuthenticatedUser, IResource>, Set<Permission>> newcache = CacheBuilder.newBuilder()
            .refreshAfterWrite(DatabaseDescriptor.getPermissionsUpdateInterval(), TimeUnit.MILLISECONDS)
            .expireAfterWrite(DatabaseDescriptor.getPermissionsValidity(), TimeUnit.MILLISECONDS)
            .maximumSize(DatabaseDescriptor.getPermissionsCacheMaxEntries())
            .build(new CacheLoader<Pair<AuthenticatedUser, IResource>, Set<Permission>>() {
                public Set<Permission> load(Pair<AuthenticatedUser, IResource> userResource) {
                    return authorizer.authorize(userResource.left, userResource.right);
                }//from w  w  w .j  a  va  2 s .  c  o  m

                public ListenableFuture<Set<Permission>> reload(
                        final Pair<AuthenticatedUser, IResource> userResource, final Set<Permission> oldValue) {
                    ListenableFutureTask<Set<Permission>> task = ListenableFutureTask
                            .create(new Callable<Set<Permission>>() {
                                public Set<Permission> call() throws Exception {
                                    try {
                                        return authorizer.authorize(userResource.left, userResource.right);
                                    } catch (Exception e) {
                                        logger.trace("Error performing async refresh of user permissions", e);
                                        throw e;
                                    }
                                }
                            });
                    cacheRefreshExecutor.execute(task);
                    return task;
                }
            });
    if (existing != null)
        newcache.putAll(existing.asMap());
    return newcache;
}

---

From source file:org.eclipse.neoscada.da.server.iec60870.Hive.java

protected synchronized ListenableFuture<Void> performAddConnection(final String id,
        final ConnectionConfiguration configuration) {
    logger.debug("adding connection - id: {}, cfg: {}", id, configuration);

    if (this.executor == null) {
        logger.debug("Hive is not started");
        return Futures.immediateFailedFuture(new IllegalStateException("Hive is not started"));
    }//from   w ww.j a  v a  2 s .co  m

    final ListenableFutureTask<Void> task = ListenableFutureTask.create(new Callable<Void>() {

        @Override
        public Void call() throws Exception {
            try {
                handleAddConnection(id, configuration);
            } catch (final Exception e) {
                logger.warn("Failed to create connection", e);
                throw new InvocationTargetException(e);
            }
            return null;
        }
    });
    this.executor.execute(task);
    return task;
}

---

From source file:org.trinity.foundation.render.qt.impl.painter.PainterImpl.java

@Override
public ListenableFuture<Void> lower() {
    final QWidget view = this.viewDiscovery.lookupView(this.model);
    final Callable<Void> callable = new Callable<Void>() {
        @Override//from   w w  w  . j a v a 2s.c om
        public Void call() {
            LOG.debug("[view={}] lower.", view);
            view.lower();
            return null;
        }
    };

    final ListenableFutureTask<Void> futureTask = ListenableFutureTask.create(callable);
    QApplication.invokeLater(futureTask);
    return futureTask;
}

---

From source file:com.android.tools.perflib.heap.memoryanalyzer.MemoryAnalyzer.java

/**
 * Analyze the given {@code captureGroup}. It is highly recommended to call this method on the
 * same thread as that of the {@code synchronizingExecutor} to avoid race conditions.
 *
 * @param captureGroup          captures to analyze
 * @param synchronizingExecutor executor to synchronize the results aggregation
 * @param taskExecutor          executor service to run the analyzer tasks on
 * @return an AnalysisReport in which the caller can listen to
 *///from  ww w  .  j  av  a  2s .co m
@NonNull
@Override
public AnalysisReport analyze(@NonNull CaptureGroup captureGroup,
        @NonNull Set<AnalysisReport.Listener> listeners, @NonNull Set<? extends AnalyzerTask> tasks,
        @NonNull final Executor synchronizingExecutor, @NonNull ExecutorService taskExecutor) {
    // TODO move this to Analyzer once Configuration is implemented
    if (mOutstandingReport != null) {
        return mOutstandingReport;
    }

    for (AnalyzerTask task : tasks) {
        if (task instanceof MemoryAnalyzerTask) {
            mTasks.add((MemoryAnalyzerTask) task);
        }
    }

    mOutstandingReport = new AnalysisReport();
    mOutstandingReport.addResultListeners(listeners);

    List<ListenableFutureTask<List<AnalysisResultEntry>>> futuresList = new ArrayList<ListenableFutureTask<List<AnalysisResultEntry>>>();

    for (final Capture capture : captureGroup.getCaptures()) {
        if (accept(capture)) {
            final Snapshot snapshot = capture.getRepresentation(Snapshot.class);
            if (snapshot == null) {
                continue;
            }

            List<Heap> heapsToUse = new ArrayList<Heap>(snapshot.getHeaps().size());
            for (Heap heap : snapshot.getHeaps()) {
                if ("app".equals(heap.getName())) {
                    heapsToUse.add(heap);
                    break;
                }
            }
            final MemoryAnalyzerTask.Configuration configuration = new MemoryAnalyzerTask.Configuration(
                    heapsToUse);

            for (final MemoryAnalyzerTask task : mTasks) {
                final ListenableFutureTask<List<AnalysisResultEntry>> futureTask = ListenableFutureTask
                        .create(new Callable<List<AnalysisResultEntry>>() {
                            @Override
                            public List<AnalysisResultEntry> call() throws Exception {
                                if (mCancelAnalysis) {
                                    return null;
                                }

                                return task.analyze(configuration, snapshot);
                            }
                        });
                Futures.addCallback(futureTask, new FutureCallback<List<AnalysisResultEntry>>() {
                    @Override
                    public void onSuccess(List<AnalysisResultEntry> result) {
                        if (mCancelAnalysis) {
                            return;
                        }

                        mOutstandingReport.addAnalysisResultEntries(result);
                    }

                    @Override
                    public void onFailure(@Nullable Throwable t) {

                    }
                }, synchronizingExecutor);
                taskExecutor.submit(futureTask);
                futuresList.add(futureTask);
            }
        }
    }

    mRunningAnalyzers = Futures.allAsList(futuresList);
    Futures.addCallback(mRunningAnalyzers, new FutureCallback<List<List<AnalysisResultEntry>>>() {
        @Override
        public void onSuccess(@Nullable List<List<AnalysisResultEntry>> result) {
            mAnalysisComplete = true;
            mOutstandingReport.setCompleted();
        }

        @Override
        public void onFailure(@NonNull Throwable t) {
            mAnalysisComplete = true;
            mOutstandingReport.setCancelled();
        }
    }, synchronizingExecutor);
    return mOutstandingReport;
}

---

From source file:com.codeabovelab.dm.cluman.job.AbstractJobInstance.java

public AbstractJobInstance(Config config) {
    Assert.notNull(config.parameters, "parameters is null");
    Assert.notNull(config.job, "job is null");
    Assert.notNull(config.jobsManager, "jobsManager is null");
    Assert.notNull(config.info, "info is null");
    this.jobContext = new JobContext(this, config.parameters);
    this.infoRef = new AtomicReference<>(config.info);
    this.manager = config.jobsManager;
    // create wait future with stub
    this.atEndFuture = SettableFuture.create();
    this.job = config.job;
    this.authentication = config.authentication;
    this.watcher = config.watcher;
    this.cancelFuture = ListenableFutureTask.create(this::innerCancel);
    this.startFuture = ListenableFutureTask.create(this::innerStart);
}

---

From source file:org.waveprotocol.box.server.rpc.render.WaveHtmlRendererImpl.java

private ListenableFuture<Void> sheduleUpdateHtml(final WaveId waveId) {
    ListenableFutureTask<Void> task = processingWaves.get(waveId);
    if (task == null) {
        task = ListenableFutureTask.create(new Callable<Void>() {

            @Override/*from  www .jav  a2 s .  c  o  m*/
            public Void call() throws Exception {
                processingWaves.remove(waveId);
                try {
                    updateHtml(waveId);
                } catch (Exception e) {
                    LOG.log(Level.SEVERE, "Failed to make HTML for " + waveId.serialise(), e);
                    throw e;
                }
                return null;
            }
        });
        processingWaves.put(waveId, task);
        executor.schedule(task, WAVE_UPDATE_HTML_DELAY_MIN, TimeUnit.MINUTES);
    }
    return task;
}

---

From source file:org.apache.druid.query.PrioritizedExecutorService.java

@Override
protected <T> PrioritizedListenableFutureTask<T> newTaskFor(Callable<T> callable) {
    Preconditions.checkArgument(allowRegularTasks || callable instanceof PrioritizedCallable,
            "task does not implement PrioritizedCallable");
    return PrioritizedListenableFutureTask.create(ListenableFutureTask.create(callable),
            callable instanceof PrioritizedCallable ? ((PrioritizedCallable) callable).getPriority()
                    : defaultPriority,/*from ww w  . j av  a 2s.  c  om*/
            config.isFifo() ? queuePosition.decrementAndGet() : 0);
}

---

From source file:com.netflix.spinnaker.front50.model.EventingS3ObjectKeyLoader.java

public EventingS3ObjectKeyLoader(ExecutorService executionService, ObjectMapper objectMapper,
        S3Properties s3Properties, TemporarySQSQueue temporarySQSQueue, S3StorageService s3StorageService,
        Registry registry, boolean scheduleImmediately) {
    this.objectMapper = objectMapper;
    this.temporarySQSQueue = temporarySQSQueue;
    this.s3StorageService = s3StorageService;
    this.registry = registry;

    this.objectKeysByLastModifiedCache = CacheBuilder.newBuilder()
            // ensure that these keys only expire _after_ their object type has been refreshed
            .expireAfterWrite(s3Properties.getEventing().getRefreshIntervalMs() + 60000, TimeUnit.MILLISECONDS)
            .recordStats().build();/*from   ww  w  .java  2s.  c  o m*/

    this.objectKeysByObjectTypeCache = CacheBuilder.newBuilder()
            .refreshAfterWrite(s3Properties.getEventing().getRefreshIntervalMs(), TimeUnit.MILLISECONDS)
            .recordStats().build(new CacheLoader<ObjectType, Map<String, Long>>() {
                @Override
                public Map<String, Long> load(ObjectType objectType) throws Exception {
                    log.debug("Loading object keys for {}", value("type", objectType));
                    return s3StorageService.listObjectKeys(objectType);
                }

                @Override
                public ListenableFuture<Map<String, Long>> reload(ObjectType objectType,
                        Map<String, Long> previous) throws Exception {
                    ListenableFutureTask<Map<String, Long>> task = ListenableFutureTask.create(() -> {
                        log.debug("Refreshing object keys for {} (asynchronous)", value("type", objectType));
                        return s3StorageService.listObjectKeys(objectType);
                    });
                    executor.execute(task);
                    return task;
                }
            });

    this.rootFolder = s3Properties.getRootFolder();

    if (scheduleImmediately) {
        executionService.submit(this);
    }
}

---

From source file:at.d4muck.fireworm.repository.Database.java

public <T> Task<Set<T>> getAll(final Class<T> modelClass) {
    ListenableFutureTask<Set<T>> futureTask = ListenableFutureTask
            .create(new DatabaseMultipleGetCallable<T>(modelClass));
    executor.execute(futureTask);/*from  w ww  .ja  v  a  2s . c o  m*/
    final DatabaseGetTask<Set<T>> databaseGetTask = new DatabaseGetTask<>();
    Futures.addCallback(futureTask, new FutureCallback<Set<T>>() {
        @Override
        public void onSuccess(Set<T> result) {
            databaseGetTask.setResult(result);
        }

        @Override
        public void onFailure(Throwable t) {
            databaseGetTask.setException(t);
        }
    }, mainLooperExecutor);
    return databaseGetTask;
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• »