public ListenableFuture<TaskState> getStateChange(TaskState currentState) { requireNonNull(currentState, "currentState is null"); checkArgument(!currentState.isDone(), "Current state is already done"); ListenableFuture<TaskState> future = taskState.getStateChange(currentState); TaskState state = taskState.get(); if (state.isDone()) { return immediateFuture(state); } return future; }
public boolean isDone() { return taskStateMachine.getState().isDone(); }
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()); }
public ListenableFuture<TaskInfo> getTaskInfo(TaskState callersCurrentState) { requireNonNull(callersCurrentState, "callersCurrentState is null"); // If the caller's current state is already done, just return the current // state of this task as it will either be done or possibly still running // (due to a bug in the caller), since we can not transition from a done // state. if (callersCurrentState.isDone()) { return immediateFuture(getTaskInfo()); } ListenableFuture<TaskState> futureTaskState = taskStateMachine.getStateChange(callersCurrentState); return Futures.transform(futureTaskState, input -> getTaskInfo(), directExecutor()); }
public boolean isCompleteInfo() { return state.isDone() && tasks.stream().allMatch(taskInfo -> taskInfo.getTaskStatus().getState().isDone()); } }
private static boolean isDone(TaskInfo taskInfo) { return taskInfo.getTaskStatus().getState().isDone(); } }
private List<TaskInfo> getActiveTasks() { return sqlTaskManager.getAllTaskInfo() .stream() .filter(taskInfo -> !taskInfo.getTaskStatus().getState().isDone()) .collect(toImmutableList()); }
@Override public synchronized void setOutputBuffers(OutputBuffers newOutputBuffers) { if (getTaskStatus().getState().isDone()) { return; } if (newOutputBuffers.getVersion() > outputBuffers.get().getVersion()) { outputBuffers.set(newOutputBuffers); needsUpdate.set(true); scheduleUpdate(); } }
private void updateStats() { SqlTaskIoStats tempIoStats = new SqlTaskIoStats(); tempIoStats.merge(finishedTaskStats); // there is a race here between task completion, which merges stats into // finishedTaskStats, and getting the stats from the task. Since we have // already merged the final stats, we could miss the stats from this task // which would result in an under-count, but we will not get an over-count. tasks.asMap().values().stream() .filter(task -> !task.getTaskStatus().getState().isDone()) .forEach(task -> tempIoStats.merge(task.getIoStats())); cachedStats.resetTo(tempIoStats); }
@Override public synchronized void abort() { if (getTaskStatus().getState().isDone()) { return; } abort(failWith(getTaskStatus(), ABORTED, ImmutableList.of())); }
@Override public int getQueuedPartitionedSplitCount() { TaskStatus taskStatus = getTaskStatus(); if (taskStatus.getState().isDone()) { return 0; } return getPendingSourceSplitCount() + taskStatus.getQueuedPartitionedDrivers(); }
@Override public void start() { taskStateMachine.addStateChangeListener(newValue -> { if (newValue.isDone()) { clearSplits(); } }); }
@Override public synchronized int getQueuedPartitionedSplitCount() { if (taskStateMachine.getState().isDone()) { return 0; } return getPartitionedSplitCount() - runningDrivers; } }
@Override public void onSuccess(JsonResponse<TaskInfo> result) { try { updateTaskInfo(result.getValue()); } finally { if (!getTaskInfo().getTaskStatus().getState().isDone()) { cleanUpLocally(); } } }
@Override public int getPartitionedSplitCount() { TaskStatus taskStatus = getTaskStatus(); if (taskStatus.getState().isDone()) { return 0; } return getPendingSourceSplitCount() + taskStatus.getQueuedPartitionedDrivers() + taskStatus.getRunningPartitionedDrivers(); }
/** * Move the task directly to the failed state if there was a failure in this task */ private void failTask(Throwable cause) { TaskStatus taskStatus = getTaskStatus(); if (!taskStatus.getState().isDone()) { log.debug(cause, "Remote task %s failed with %s", taskStatus.getSelf(), cause); } abort(failWith(getTaskStatus(), FAILED, ImmutableList.of(toFailure(cause)))); }
@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()); }
public TaskInfo summarize() { if (taskStatus.getState().isDone()) { return new TaskInfo(taskStatus, lastHeartbeat, outputBuffers.summarize(), noMoreSplits, stats.summarizeFinal(), needsPlan); } return new TaskInfo(taskStatus, lastHeartbeat, outputBuffers.summarize(), noMoreSplits, stats.summarize(), needsPlan); }
private synchronized void abort(TaskStatus status) { checkState(status.getState().isDone(), "cannot abort task with an incomplete status"); try (SetThreadName ignored = new SetThreadName("HttpRemoteTask-%s", taskId)) { taskStatusFetcher.updateTaskStatus(status); // send abort to task HttpUriBuilder uriBuilder = getHttpUriBuilder(getTaskStatus()); Request request = prepareDelete() .setUri(uriBuilder.build()) .build(); scheduleAsyncCleanupRequest(createCleanupBackoff(), request, "abort"); } }