private Builder(Executor notificationExecutor, ScheduledExecutorService yieldExecutor, Session session) { this.notificationExecutor = notificationExecutor; this.yieldExecutor = yieldExecutor; this.session = session; this.taskStateMachine = new TaskStateMachine(new TaskId("query", 0, 0), notificationExecutor); }
public TaskInfo abort() { taskStateMachine.abort(); return getTaskInfo(); }
/** * Listener is always notified asynchronously using a dedicated notification thread pool so, care should * be taken to avoid leaking {@code this} when adding a listener in a constructor. Additionally, it is * possible notifications are observed out of order due to the asynchronous execution. */ public void addStateChangeListener(StateChangeListener<TaskState> stateChangeListener) { taskStateMachine.addStateChangeListener(stateChangeListener); }
private synchronized void checkTaskCompletion() { if (taskStateMachine.getState().isDone()) { return; } // are there more partition splits expected? for (DriverSplitRunnerFactory driverSplitRunnerFactory : driverRunnerFactoriesWithSplitLifeCycle.values()) { if (!driverSplitRunnerFactory.isNoMoreDriverRunner()) { return; } } // do we still have running tasks? if (status.getRemainingDriver() != 0) { return; } // no more output will be created outputBuffer.setNoMorePages(); // are there still pages in the output buffer if (!outputBuffer.isFinished()) { return; } // Cool! All done! taskStateMachine.finished(); }
private TaskStats getTaskStats(TaskHolder taskHolder) { TaskInfo finalTaskInfo = taskHolder.getFinalTaskInfo(); if (finalTaskInfo != null) { return finalTaskInfo.getStats(); } SqlTaskExecution taskExecution = taskHolder.getTaskExecution(); if (taskExecution != null) { return taskExecution.getTaskContext().getTaskStats(); } // if the task completed without creation, set end time DateTime endTime = taskStateMachine.getState().isDone() ? DateTime.now() : null; return new TaskStats(taskStateMachine.getCreatedTime(), endTime); }
@Override public void addFinalTaskInfoListener(StateChangeListener<TaskInfo> stateChangeListener) { AtomicBoolean done = new AtomicBoolean(); StateChangeListener<TaskState> fireOnceStateChangeListener = state -> { if (state.isDone() && done.compareAndSet(false, true)) { stateChangeListener.stateChanged(getTaskInfo()); } }; taskStateMachine.addStateChangeListener(fireOnceStateChangeListener); fireOnceStateChangeListener.stateChanged(taskStateMachine.getState()); }
TaskStateMachine taskStateMachine = new TaskStateMachine(TaskId.valueOf("task-id"), taskNotificationExecutor); PartitionedOutputBuffer outputBuffer = newTestingOutputBuffer(taskNotificationExecutor); OutputBufferConsumer outputBufferConsumer = new OutputBufferConsumer(outputBuffer, OUTPUT_BUFFER_ID); assertEquals(taskStateMachine.getState(), TaskState.RUNNING); TaskState taskState = taskStateMachine.getStateChange(TaskState.RUNNING).get(10, SECONDS); assertEquals(taskState, TaskState.FINISHED);
@Override public TaskInfo getTaskInfo() TaskState state = taskStateMachine.getState(); List<ExecutionFailureInfo> failures = ImmutableList.of(); if (state == TaskState.FAILED) { failures = toFailures(taskStateMachine.getFailureCauses()); taskStateMachine.getTaskId(), TASK_INSTANCE_ID, nextTaskInfoVersion.getAndIncrement(),
TaskState state = taskStateMachine.getState(); List<ExecutionFailureInfo> failures = ImmutableList.of(); if (state == TaskState.FAILED) { failures = toFailures(taskStateMachine.getFailureCauses()); taskStats = new TaskStats(taskStateMachine.getCreatedTime(), endTime); noMoreSplits = ImmutableSet.of(); taskStateMachine.getTaskId(), taskInstanceId, versionNumber,
this.taskId = taskStateMachine.getTaskId(); this.taskContext = requireNonNull(taskContext, "taskContext is null"); this.sharedBuffer = requireNonNull(sharedBuffer, "sharedBuffer is null"); taskStateMachine.failed(e); throw Throwables.propagate(e); if (!taskStateMachine.getState().isDone()) { taskHandle = taskExecutor.addTask(taskId, sharedBuffer::getUtilization, getInitialSplitsPerNode(taskContext.getSession()), getSplitConcurrencyAdjustmentInterval(taskContext.getSession())); taskStateMachine.addStateChangeListener(new RemoveTaskHandleWhenDone(taskExecutor, taskHandle)); taskStateMachine.addStateChangeListener(state -> { if (state.isDone()) { for (DriverFactory factory : driverFactories) {
public TaskState getState() { return taskStateMachine.getState(); }
public TaskId getTaskId() { return taskStateMachine.getTaskId(); }
this.taskId = taskStateMachine.getTaskId(); this.taskContext = requireNonNull(taskContext, "taskContext is null"); this.outputBuffer = requireNonNull(outputBuffer, "outputBuffer is null"); if (!taskStateMachine.getState().isDone()) { taskHandle = createTaskHandle(taskStateMachine, taskContext, outputBuffer, localExecutionPlan, taskExecutor);
taskStateMachine = new TaskStateMachine(taskId, taskNotificationExecutor); taskStateMachine.addStateChangeListener(new StateChangeListener<TaskState>()
private static TaskHandle createTaskHandle( TaskStateMachine taskStateMachine, TaskContext taskContext, OutputBuffer outputBuffer, LocalExecutionPlan localExecutionPlan, TaskExecutor taskExecutor) { TaskHandle taskHandle = taskExecutor.addTask( taskStateMachine.getTaskId(), outputBuffer::getUtilization, getInitialSplitsPerNode(taskContext.getSession()), getSplitConcurrencyAdjustmentInterval(taskContext.getSession()), getMaxDriversPerTask(taskContext.getSession())); taskStateMachine.addStateChangeListener(state -> { if (state.isDone()) { taskExecutor.removeTask(taskHandle); for (DriverFactory factory : localExecutionPlan.getDriverFactories()) { factory.noMoreDrivers(); } } }); return taskHandle; }
public TaskInfo cancel() { taskStateMachine.cancel(); return getTaskInfo(); }
public ListenableFuture<TaskStatus> getTaskStatus(TaskState callersCurrentState) { requireNonNull(callersCurrentState, "callersCurrentState is null"); if (callersCurrentState.isDone()) { return immediateFuture(getTaskStatus()); } ListenableFuture<TaskState> futureTaskState = taskStateMachine.getStateChange(callersCurrentState); return Futures.transform(futureTaskState, input -> getTaskStatus(), directExecutor()); }
@Override public synchronized void noMoreSplits(PlanNodeId sourceId) { noMoreSplits.add(sourceId); boolean allSourcesComplete = Stream.concat(fragment.getPartitionedSourceNodes().stream(), fragment.getRemoteSourceNodes().stream()) .filter(Objects::nonNull) .map(PlanNode::getId) .allMatch(noMoreSplits::contains); if (allSourcesComplete) { taskStateMachine.finished(); } }
private static void checkErrors(TaskStateMachine taskStateMachine) { if (taskStateMachine.getFailureCauses().size() > 0) { Throwable exception = requireNonNull(taskStateMachine.getFailureCauses().peek()); throw new RuntimeException(exception.getMessage(), exception); } }