@Override public void shutdown() { _taskRunner.shutdown(); }
public void awaitTasks(final int numTasks) { while (numTasks > _counter.get() && !isErrornous()) { _taskRunner.assistExecution(); } } }
@Override public void onComplete(final Task task) { _taskRunner.run(_nextTask, _nextListener); }
taskRunner.run(new Task() { @Override public void execute() throws Exception { taskRunner.assistExecution(); } catch(Throwable t) { synchronized (errors) {
@Override public void shutdown() { getDelegate().shutdown(); }
@Override public void onComplete(final Task task) { logger.info("onComplete({})", _whatAreYouWaitingFor); int index = 1; for (final TaskRunnable tr : _tasks) { logger.debug("Scheduling task {} out of {}: {}", new Object[] { index, _tasks.size(), tr }); _taskRunner.run(tr); index++; } }
@Override public void assistExecution() { getDelegate().assistExecution(); }
private void exitCommandLine(final DataCleanerConfiguration configuration, final int statusCode) { if (configuration != null) { logger.debug("Shutting down task runner"); try { configuration.getEnvironment().getTaskRunner().shutdown(); } catch (final Exception e) { logger.warn("Shutting down TaskRunner threw unexpected exception", e); } } final ExitActionListener exitActionListener = _options.getExitActionListener(); if (exitActionListener != null) { exitActionListener.exit(statusCode); } } }
@Override public void run(Task task, TaskListener listener) { getDelegate().run(task, listener); }
@Override public void assistExecution() { if (!isErrornous() && !isCancelled()) { _taskRunner.assistExecution(); } } }
@Override public void exit() { // ensure that exit actions only occur once. if (_exiting) { return; } _exiting = true; if (_userPreferences != null) { _userPreferences.save(); } if (_configuration != null) { _configuration.getEnvironment().getTaskRunner().shutdown(); } for (final ExitActionListener actionListener : _exitActionListeners) { actionListener.exit(0); } final List<DCWindow> windowsCopy = new ArrayList<>(getWindows()); for (final DCWindow window : windowsCopy) { window.close(); } }
@Override public void run(TaskRunnable taskRunnable) { getDelegate().run(taskRunnable); }
} finally { if (configuration != null) { configuration.getEnvironment().getTaskRunner().shutdown();
@Override public void run(final Task task, final TaskListener taskListener) { if (isErrornous()) { taskListener.onError(task, _previousErrorsExistException); } else if (isCancelled()) { logger.info("Ignoring task because job has been cancelled: {}", task); taskListener.onError(task, _previousErrorsExistException); } else { _taskRunner.run(task, taskListener); } }
_taskRunner.run(task, listener); return this;
/** * Closes consumers of this {@link SourceTableRowProcessingPublisher}. * Usually this will be done automatically when * {@link #runRowProcessing(Queue, TaskListener)} is invoked. */ @Override public final void closeConsumers() { final TaskRunner taskRunner = getTaskRunner(); final List<RowProcessingConsumer> configurableConsumers = getConsumers(); for (final RowProcessingConsumer consumer : configurableConsumers) { final TaskRunnable task = createCloseTask(consumer, null); taskRunner.run(task); } } }
/** * Initializes consumers of this {@link SourceTableRowProcessingPublisher}. * * This method will not initialize consumers containing * {@link MultiStreamComponent}s. Ensure that * {@link #initializeMultiStreamConsumers(Set)} is also invoked. * * Once consumers are initialized, row processing can begin, expected rows * can be calculated and more. * * @param finishedListener */ @Override public final void initializeConsumers(final TaskListener finishedListener) { final TaskRunner taskRunner = getTaskRunner(); final List<RowProcessingConsumer> configurableConsumers = getConsumers(); final int numConfigurableConsumers = configurableConsumers.size(); final JoinTaskListener initFinishedListener = new JoinTaskListener(numConfigurableConsumers, finishedListener); for (final RowProcessingConsumer consumer : configurableConsumers) { final TaskRunnable task = createInitTask(consumer, initFinishedListener); taskRunner.run(task); } }
@Override protected boolean runRowProcessingInternal(final List<TaskRunnable> postProcessingTasks) { final TaskListener runCompletionListener = new ForkTaskListener("run row processing (" + getStream() + ")", getTaskRunner(), postProcessingTasks); final RowProcessingMetrics rowProcessingMetrics = getRowProcessingMetrics(); final RunRowProcessingPublisherTask runTask = new RunRowProcessingPublisherTask(this, rowProcessingMetrics); getTaskRunner().run(runTask, runCompletionListener); return true; }
new ConsumeRowTask(consumeRowHandler, rowProcessingMetrics, inputRow, analysisListener, numTasks); getTaskRunner().run(task, taskListener);