Examples with Future org.apache.cassandra.utils.concurrent.Future used on opensource projects

Example 16 with Future

use of org.apache.cassandra.utils.concurrent.Future in project cassandra by apache.

the class CompactionManager method submitMaximal.

// the tasks are executed in parallel on the executor, making sure that they get closed
@SuppressWarnings("resource")
public List<Future<?>> submitMaximal(final ColumnFamilyStore cfStore, final int gcBefore, boolean splitOutput) {
    // here we compute the task off the compaction executor, so having that present doesn't
    // confuse runWithCompactionsDisabled -- i.e., we don't want to deadlock ourselves, waiting
    // for ourselves to finish/acknowledge cancellation before continuing.
    CompactionTasks tasks = cfStore.getCompactionStrategyManager().getMaximalTasks(gcBefore, splitOutput);
    if (tasks.isEmpty())
        return Collections.emptyList();
    List<Future<?>> futures = new ArrayList<>();
    int nonEmptyTasks = 0;
    for (final AbstractCompactionTask task : tasks) {
        if (task.transaction.originals().size() > 0)
            nonEmptyTasks++;
        Runnable runnable = new WrappedRunnable() {

            protected void runMayThrow() {
                task.execute(active);
            }
        };
        Future<?> fut = executor.submitIfRunning(runnable, "maximal task");
        if (!fut.isCancelled())
            futures.add(fut);
    }
    if (nonEmptyTasks > 1)
        logger.info("Major compaction will not result in a single sstable - repaired and unrepaired data is kept separate and compaction runs per data_file_directory.");
    return futures;
}

Example 17 with Future

use of org.apache.cassandra.utils.concurrent.Future in project cassandra by apache.

the class CompactionManager method parallelAllSSTableOperation.

/**
 * Run an operation over all sstables using jobs threads
 *
 * @param cfs the column family store to run the operation on
 * @param operation the operation to run
 * @param jobs the number of threads to use - 0 means use all available. It never uses more than concurrent_compactors threads
 * @return status of the operation
 * @throws ExecutionException
 * @throws InterruptedException
 */
@SuppressWarnings("resource")
private AllSSTableOpStatus parallelAllSSTableOperation(final ColumnFamilyStore cfs, final OneSSTableOperation operation, int jobs, OperationType operationType) throws ExecutionException, InterruptedException {
    logger.info("Starting {} for {}.{}", operationType, cfs.keyspace.getName(), cfs.getTableName());
    List<LifecycleTransaction> transactions = new ArrayList<>();
    List<Future<?>> futures = new ArrayList<>();
    try (LifecycleTransaction compacting = cfs.markAllCompacting(operationType)) {
        if (compacting == null)
            return AllSSTableOpStatus.UNABLE_TO_CANCEL;
        Iterable<SSTableReader> sstables = Lists.newArrayList(operation.filterSSTables(compacting));
        if (Iterables.isEmpty(sstables)) {
            logger.info("No sstables to {} for {}.{}", operationType.name(), cfs.keyspace.getName(), cfs.name);
            return AllSSTableOpStatus.SUCCESSFUL;
        }
        for (final SSTableReader sstable : sstables) {
            final LifecycleTransaction txn = compacting.split(singleton(sstable));
            transactions.add(txn);
            Callable<Object> callable = new Callable<Object>() {

                @Override
                public Object call() throws Exception {
                    operation.execute(txn);
                    return this;
                }
            };
            Future<?> fut = executor.submitIfRunning(callable, "paralell sstable operation");
            if (!fut.isCancelled())
                futures.add(fut);
            else
                return AllSSTableOpStatus.ABORTED;
            if (jobs > 0 && futures.size() == jobs) {
                Future<?> f = FBUtilities.waitOnFirstFuture(futures);
                futures.remove(f);
            }
        }
        FBUtilities.waitOnFutures(futures);
        assert compacting.originals().isEmpty();
        logger.info("Finished {} for {}.{} successfully", operationType, cfs.keyspace.getName(), cfs.getTableName());
        return AllSSTableOpStatus.SUCCESSFUL;
    } finally {
        // wait on any unfinished futures to make sure we don't close an ongoing transaction
        try {
            FBUtilities.waitOnFutures(futures);
        } catch (Throwable t) {
        // these are handled/logged in CompactionExecutor#afterExecute
        }
        Throwable fail = Throwables.close(null, transactions);
        if (fail != null)
            logger.error("Failed to cleanup lifecycle transactions ({} for {}.{})", operationType, cfs.keyspace.getName(), cfs.getTableName(), fail);
    }
}

Example 18 with Future

use of org.apache.cassandra.utils.concurrent.Future in project cassandra by apache.

the class RepairJob method sendDCAwareValidationRequest.

/**
 * Creates {@link ValidationTask} and submit them to task executor so that tasks run sequentially within each dc.
 */
private Future<List<TreeResponse>> sendDCAwareValidationRequest(Collection<InetAddressAndPort> endpoints) {
    String message = String.format("Requesting merkle trees for %s (to %s)", desc.columnFamily, endpoints);
    logger.info("{} {}", session.previewKind.logPrefix(desc.sessionId), message);
    Tracing.traceRepair(message);
    int nowInSec = getNowInSeconds();
    List<Future<TreeResponse>> tasks = new ArrayList<>(endpoints.size());
    Map<String, Queue<InetAddressAndPort>> requestsByDatacenter = new HashMap<>();
    for (InetAddressAndPort endpoint : endpoints) {
        String dc = DatabaseDescriptor.getEndpointSnitch().getDatacenter(endpoint);
        Queue<InetAddressAndPort> queue = requestsByDatacenter.get(dc);
        if (queue == null) {
            queue = new LinkedList<>();
            requestsByDatacenter.put(dc, queue);
        }
        queue.add(endpoint);
    }
    for (Map.Entry<String, Queue<InetAddressAndPort>> entry : requestsByDatacenter.entrySet()) {
        Queue<InetAddressAndPort> requests = entry.getValue();
        InetAddressAndPort address = requests.poll();
        ValidationTask firstTask = newValidationTask(address, nowInSec);
        logger.info("{} Validating {}", session.previewKind.logPrefix(session.getId()), address);
        session.trackValidationCompletion(Pair.create(desc, address), firstTask);
        tasks.add(firstTask);
        ValidationTask currentTask = firstTask;
        while (requests.size() > 0) {
            final InetAddressAndPort nextAddress = requests.poll();
            final ValidationTask nextTask = newValidationTask(nextAddress, nowInSec);
            tasks.add(nextTask);
            currentTask.addCallback(new FutureCallback<TreeResponse>() {

                public void onSuccess(TreeResponse result) {
                    logger.info("{} Validating {}", session.previewKind.logPrefix(session.getId()), nextAddress);
                    session.trackValidationCompletion(Pair.create(desc, nextAddress), nextTask);
                    taskExecutor.execute(nextTask);
                }

                // failure is handled at root of job chain
                public void onFailure(Throwable t) {
                }
            });
            currentTask = nextTask;
        }
        // start running tasks
        taskExecutor.execute(firstTask);
    }
    return FutureCombiner.allOf(tasks);
}

Example 19 with Future

use of org.apache.cassandra.utils.concurrent.Future in project cassandra by apache.

the class RepairJob method sendSequentialValidationRequest.

/**
 * Creates {@link ValidationTask} and submit them to task executor so that tasks run sequentially.
 */
private Future<List<TreeResponse>> sendSequentialValidationRequest(Collection<InetAddressAndPort> endpoints) {
    String message = String.format("Requesting merkle trees for %s (to %s)", desc.columnFamily, endpoints);
    logger.info("{} {}", session.previewKind.logPrefix(desc.sessionId), message);
    Tracing.traceRepair(message);
    int nowInSec = getNowInSeconds();
    List<Future<TreeResponse>> tasks = new ArrayList<>(endpoints.size());
    Queue<InetAddressAndPort> requests = new LinkedList<>(endpoints);
    InetAddressAndPort address = requests.poll();
    ValidationTask firstTask = newValidationTask(address, nowInSec);
    logger.info("{} Validating {}", session.previewKind.logPrefix(desc.sessionId), address);
    session.trackValidationCompletion(Pair.create(desc, address), firstTask);
    tasks.add(firstTask);
    ValidationTask currentTask = firstTask;
    while (requests.size() > 0) {
        final InetAddressAndPort nextAddress = requests.poll();
        final ValidationTask nextTask = newValidationTask(nextAddress, nowInSec);
        tasks.add(nextTask);
        currentTask.addCallback(new FutureCallback<TreeResponse>() {

            public void onSuccess(TreeResponse result) {
                logger.info("{} Validating {}", session.previewKind.logPrefix(desc.sessionId), nextAddress);
                session.trackValidationCompletion(Pair.create(desc, nextAddress), nextTask);
                taskExecutor.execute(nextTask);
            }

            // failure is handled at root of job chain
            public void onFailure(Throwable t) {
            }
        });
        currentTask = nextTask;
    }
    // start running tasks
    taskExecutor.execute(firstTask);
    return FutureCombiner.allOf(tasks);
}

Example 20 with Future

use of org.apache.cassandra.utils.concurrent.Future in project cassandra by apache.

the class StorageService method drain.

protected synchronized void drain(boolean isFinalShutdown) throws IOException, InterruptedException, ExecutionException {
    ExecutorService counterMutationStage = Stage.COUNTER_MUTATION.executor();
    ExecutorService viewMutationStage = Stage.VIEW_MUTATION.executor();
    ExecutorService mutationStage = Stage.MUTATION.executor();
    if (mutationStage.isTerminated() && counterMutationStage.isTerminated() && viewMutationStage.isTerminated()) {
        if (!isFinalShutdown)
            logger.warn("Cannot drain node (did it already happen?)");
        return;
    }
    assert !isShutdown;
    isShutdown = true;
    Throwable preShutdownHookThrowable = Throwables.perform(null, preShutdownHooks.stream().map(h -> h::run));
    if (preShutdownHookThrowable != null)
        logger.error("Attempting to continue draining after pre-shutdown hooks returned exception", preShutdownHookThrowable);
    try {
        setMode(Mode.DRAINING, "starting drain process", !isFinalShutdown);
        try {
            /* not clear this is reasonable time, but propagated from prior embedded behaviour */
            BatchlogManager.instance.shutdownAndWait(1L, MINUTES);
        } catch (TimeoutException t) {
            logger.error("Batchlog manager timed out shutting down", t);
        }
        snapshotManager.stop();
        HintsService.instance.pauseDispatch();
        if (daemon != null)
            shutdownClientServers();
        ScheduledExecutors.optionalTasks.shutdown();
        Gossiper.instance.stop();
        ActiveRepairService.instance.stop();
        if (!isFinalShutdown)
            setMode(Mode.DRAINING, "shutting down MessageService", false);
        // before mutation stage, so we can get all the hints saved before shutting down.
        try {
            MessagingService.instance().shutdown();
        } catch (Throwable t) {
            // prevent messaging service timing out shutdown from aborting
            // drain process; otherwise drain and/or shutdown might throw
            logger.error("Messaging service timed out shutting down", t);
        }
        if (!isFinalShutdown)
            setMode(Mode.DRAINING, "clearing mutation stage", false);
        viewMutationStage.shutdown();
        counterMutationStage.shutdown();
        mutationStage.shutdown();
        // FIXME? should these *really* take up to one hour?
        viewMutationStage.awaitTermination(3600, TimeUnit.SECONDS);
        counterMutationStage.awaitTermination(3600, TimeUnit.SECONDS);
        mutationStage.awaitTermination(3600, TimeUnit.SECONDS);
        StorageProxy.instance.verifyNoHintsInProgress();
        if (!isFinalShutdown)
            setMode(Mode.DRAINING, "flushing column families", false);
        // we don't want to start any new compactions while we are draining
        disableAutoCompaction();
        // count CFs first, since forceFlush could block for the flushWriter to get a queue slot empty
        totalCFs = 0;
        for (Keyspace keyspace : Keyspace.nonSystem()) totalCFs += keyspace.getColumnFamilyStores().size();
        remainingCFs = totalCFs;
        // flush
        List<Future<?>> flushes = new ArrayList<>();
        for (Keyspace keyspace : Keyspace.nonSystem()) {
            for (ColumnFamilyStore cfs : keyspace.getColumnFamilyStores()) flushes.add(cfs.forceFlush());
        }
        // thus make several short ones "instant" if we wait for them later.
        for (Future f : flushes) {
            try {
                FBUtilities.waitOnFuture(f);
            } catch (Throwable t) {
                JVMStabilityInspector.inspectThrowable(t);
                // don't let this stop us from shutting down the commitlog and other thread pools
                logger.warn("Caught exception while waiting for memtable flushes during shutdown hook", t);
            }
            remainingCFs--;
        }
        // Interrupt ongoing compactions and shutdown CM to prevent further compactions.
        CompactionManager.instance.forceShutdown();
        // Flush the system tables after all other tables are flushed, just in case flushing modifies any system state
        // like CASSANDRA-5151. Don't bother with progress tracking since system data is tiny.
        // Flush system tables after stopping compactions since they modify
        // system tables (for example compactions can obsolete sstables and the tidiers in SSTableReader update
        // system tables, see SSTableReader.GlobalTidy)
        flushes.clear();
        for (Keyspace keyspace : Keyspace.system()) {
            for (ColumnFamilyStore cfs : keyspace.getColumnFamilyStores()) flushes.add(cfs.forceFlush());
        }
        FBUtilities.waitOnFutures(flushes);
        SnapshotManager.shutdownAndWait(1L, MINUTES);
        HintsService.instance.shutdownBlocking();
        // Interrupt ongoing compactions and shutdown CM to prevent further compactions.
        CompactionManager.instance.forceShutdown();
        // whilst we've flushed all the CFs, which will have recycled all completed segments, we want to ensure
        // there are no segments to replay, so we force the recycling of any remaining (should be at most one)
        CommitLog.instance.forceRecycleAllSegments();
        CommitLog.instance.shutdownBlocking();
        // wait for miscellaneous tasks like sstable and commitlog segment deletion
        ScheduledExecutors.nonPeriodicTasks.shutdown();
        if (!ScheduledExecutors.nonPeriodicTasks.awaitTermination(1, MINUTES))
            logger.warn("Unable to terminate non-periodic tasks within 1 minute.");
        ColumnFamilyStore.shutdownPostFlushExecutor();
        setMode(Mode.DRAINED, !isFinalShutdown);
    } catch (Throwable t) {
        logger.error("Caught an exception while draining ", t);
    } finally {
        Throwable postShutdownHookThrowable = Throwables.perform(null, postShutdownHooks.stream().map(h -> h::run));
        if (postShutdownHookThrowable != null)
            logger.error("Post-shutdown hooks returned exception", postShutdownHookThrowable);
    }
}