private TaskExecution getTaskExecutionCopy(TaskExecution taskExecution){ Date startTime = new Date(taskExecution.getStartTime().getTime()); Date endTime = (taskExecution.getEndTime() == null) ? null : new Date(taskExecution.getEndTime().getTime()); return new TaskExecution(taskExecution.getExecutionId(), taskExecution.getExitCode(), taskExecution.getTaskName(), startTime, endTime,taskExecution.getExitMessage(), Collections.unmodifiableList(taskExecution.getArguments()), taskExecution.getErrorMessage(), taskExecution.getExternalExecutionId()); }
private TaskExecution sanitizePotentialSensitiveKeys(TaskExecution taskExecution) { List<String> args = taskExecution.getArguments().stream() .map(argument -> (this.argumentSanitizer.sanitize(argument))).collect(Collectors.toList()); taskExecution.setArguments(args); return taskExecution; }
private void setExitMessage(TaskExecution taskExecutionParam) { if(taskExecutionParam.getExitMessage() != null) { this.taskExecution.setExitMessage(taskExecutionParam.getExitMessage()); } }
@Override public TaskExecution startTaskExecution(long executionId, String taskName, Date startTime, List<String> arguments, String externalExecutionid, Long parentExecutionId) { TaskExecution taskExecution= taskExecutions.get(executionId); taskExecution.setTaskName(taskName); taskExecution.setStartTime(startTime); taskExecution.setArguments(arguments); taskExecution.setParentExecutionId(parentExecutionId); if(externalExecutionid != null) { taskExecution.setExternalExecutionId(externalExecutionid); } return taskExecution; }
private void doTaskEnd() { if((this.listenerFailed || this.started) && !this.finished) { this.taskExecution.setEndTime(new Date()); if(this.applicationFailedException != null) { this.taskExecution.setErrorMessage(stackTraceToString(this.applicationFailedException)); } this.taskExecution.setExitCode(calcExitStatus()); if (this.applicationFailedException != null) { setExitMessage(invokeOnTaskError(this.taskExecution, this.applicationFailedException)); } setExitMessage(invokeOnTaskEnd(this.taskExecution)); this.taskRepository.completeTaskExecution(this.taskExecution.getExecutionId(), this.taskExecution.getExitCode(), this.taskExecution.getEndTime(), this.taskExecution.getExitMessage(), this.taskExecution.getErrorMessage()); this.finished = true; if(this.taskProperties.getClosecontextEnabled() && this.context.isActive()) { this.context.close(); } } else if(!this.started){ logger.error("An event to end a task has been received for a task that has " + "not yet started."); } }
@Override public TaskExecution createTaskExecution(TaskExecution taskExecution) { initialize(); validateCreateInformation(taskExecution); TaskExecution daoTaskExecution = taskExecutionDao.createTaskExecution( taskExecution.getTaskName(), taskExecution.getStartTime(), taskExecution.getArguments(), taskExecution.getExternalExecutionId(), taskExecution.getParentExecutionId()); logger.debug("Creating: " + taskExecution.toString()); return daoTaskExecution; }
private List<String> updateCommandLineArgs(List<String> commandLineArgs, TaskExecution taskExecution) { return Stream .concat(commandLineArgs.stream().filter(a -> !a.startsWith("--spring.cloud.task.executionid=")), Stream.of("--spring.cloud.task.executionid=" + taskExecution.getExecutionId())) .collect(Collectors.toList()); }
if (!taskNamesAsList.contains(taskExecutionMapEntry.getValue().getTaskName())) { continue; final TaskExecution tempTaskExecution = tempTaskExecutions.get(taskExecutionMapEntry.getValue().getTaskName()); if (tempTaskExecution == null || tempTaskExecution.getStartTime().before(taskExecutionMapEntry.getValue().getStartTime()) || ( tempTaskExecution.getStartTime().equals(taskExecutionMapEntry.getValue().getStartTime()) && tempTaskExecution.getExecutionId() < taskExecutionMapEntry.getValue().getExecutionId() tempTaskExecutions.put(taskExecutionMapEntry.getValue().getTaskName(), taskExecutionMapEntry.getValue());
TaskExecution taskExecution = this.taskExplorer.getTaskExecution(this.taskProperties.getExecutionid()); Assert.notNull(taskExecution, String.format("Invalid TaskExecution, ID %s not found", this.taskProperties.getExecutionid())); Assert.isNull(taskExecution.getEndTime(), String.format( "Invalid TaskExecution, ID %s task is already complete", this.taskProperties.getExecutionid())); this.taskExecution = this.taskRepository.startTaskExecution(this.taskProperties.getExecutionid(), TaskExecution taskExecution = new TaskExecution(); taskExecution.setTaskName(this.taskNameResolver.getTaskName()); taskExecution.setStartTime(new Date()); taskExecution.setArguments(args); taskExecution.setExternalExecutionId(this.taskProperties.getExternalExecutionId()); taskExecution.setParentExecutionId(this.taskProperties.getParentExecutionId()); this.taskExecution = this.taskRepository.createTaskExecution( taskExecution);
@Override public long getRunningTaskExecutionCountByTaskName(String taskName) { int count = 0; for (Map.Entry<Long, TaskExecution> entry : taskExecutions.entrySet()) { if (entry.getValue().getTaskName().equals(taskName) && entry.getValue().getEndTime() == null) { count++; } } return count; }
private String resolveApplicationName() { if(StringUtils.hasText(this.applicationName)) { return this.applicationName; } else { return this.taskExecution.getTaskName(); } }
@Override public int compare(TaskExecution firstTaskExecution, TaskExecution secondTaskExecution) { if (firstTaskExecution.getStartTime().equals(secondTaskExecution.getStartTime())) { return Long.compare(firstTaskExecution.getExecutionId(), secondTaskExecution.getExecutionId()); } else { return secondTaskExecution.getStartTime().compareTo(firstTaskExecution.getStartTime()); } } }
@Override public void restartJobExecution(long jobExecutionId) throws NoSuchJobExecutionException { logger.info("Restarting Job with Id " + jobExecutionId); final TaskJobExecution taskJobExecution = this.getJobExecution(jobExecutionId); final JobExecution jobExecution = taskJobExecution.getJobExecution(); if (!JobUtils.isJobExecutionRestartable(taskJobExecution.getJobExecution())) { throw new JobNotRestartableException( String.format("JobExecution with Id '%s' and state '%s' is not " + "restartable.", jobExecution.getId(), taskJobExecution.getJobExecution().getStatus())); } TaskExecution taskExecution = this.taskExplorer.getTaskExecution(taskJobExecution.getTaskId()); TaskDefinition taskDefinition = this.taskDefinitionRepository.findById(taskExecution.getTaskName()) .orElseThrow(() -> new NoSuchTaskDefinitionException(taskExecution.getTaskName())); TaskDeployment taskDeployment = this.taskDeploymentRepository.findByTaskDeploymentId(String.valueOf(taskJobExecution.getTaskId())); if (taskDeployment != null) { Map<String, String> deploymentProperties = new HashMap<>(); deploymentProperties.put(DefaultTaskExecutionService.TASK_PLATFORM_NAME, taskDeployment.getPlatformName()); taskExecutionService.executeTask(taskDefinition.getName(), deploymentProperties, taskExecution.getArguments()); } else { throw new IllegalStateException(String.format("Did not find platform for taskName=[%s] , taskId=[%s]", taskExecution.getTaskName(),taskJobExecution.getTaskId())); } }
arguments.add(formatArgument(SPRING_CLOUD_TASK_STEP_NAME, this.stepName)); arguments.add(formatArgument(SPRING_CLOUD_TASK_NAME, String.format("%s_%s_%s", taskExecution.getTaskName(), workerStepExecution.getJobExecution().getJobInstance().getJobName(), workerStepExecution.getStepName()))); arguments.add(formatArgument(SPRING_CLOUD_TASK_PARENT_EXECUTION_ID, String.valueOf(taskExecution.getExecutionId()))); environmentVariables.put(SPRING_CLOUD_TASK_STEP_NAME, this.stepName); environmentVariables.put(SPRING_CLOUD_TASK_NAME, String.format("%s_%s_%s", taskExecution.getTaskName(), workerStepExecution.getJobExecution().getJobInstance().getJobName(), workerStepExecution.getStepName())); environmentVariables.put(SPRING_CLOUD_TASK_PARENT_EXECUTION_ID, String.valueOf(taskExecution.getExecutionId()));
@Override public void cleanupExecution(long id) { TaskExecution taskExecution = taskExplorer.getTaskExecution(id); Assert.notNull(taskExecution, "There was no task execution with id " + id); String launchId = taskExecution.getExternalExecutionId(); Assert.hasLength(launchId, "The TaskExecution for id " + id + " did not have an externalExecutionId"); TaskDeployment taskDeployment = this.taskDeploymentRepository.findByTaskDeploymentId(String.valueOf(id)); if (taskDeployment == null) { logger.warn(String.format("Did not find TaskDeployment for taskName = [%s], taskId = [%s]. Nothing to clean up.", taskExecution.getTaskName(), id)); return; } Launcher launcher = launcherRepository.findByName(taskDeployment.getPlatformName()); if (launcher != null) { TaskLauncher taskLauncher = launcher.getTaskLauncher(); taskLauncher.cleanup(launchId); } else { logger.info( "Could clean up execution for task id " + id + ". Did not find a task platform named " + taskDeployment.getPlatformName()); } }
/** * Validate startTime and taskName are valid. */ private void validateCreateInformation(TaskExecution taskExecution) { Assert.notNull(taskExecution.getStartTime(), "TaskExecution start time cannot be null."); if (taskExecution.getTaskName() != null && taskExecution.getTaskName().length() > this.maxTaskNameSize) { throw new IllegalArgumentException("TaskName length exceeds " + this.maxTaskNameSize + " characters"); } }
if (!StringUtils.isEmpty(resultExecution.getExitMessage())) { result = new ExitStatus(resultExecution.getExitMessage()); else if (resultExecution.getExitCode() != 0) { result = ExitStatus.FAILED;
if(taskExecution != null && taskExecution.getEndTime() != null) { if(taskExecution.getExitCode() != 0 ) { throw new UnexpectedJobExecutionException("Task returned a non zero exit code.");
@Override public List<String> getCommandLineArgs(ExecutionContext executionContext) { int listSize = this.taskExecution.getArguments().size() + (this.appendedArgs != null ? this.appendedArgs.size() : 0); List<String> args = new ArrayList<>(listSize); args.addAll(this.taskExecution.getArguments()); if(this.appendedArgs != null) { args.addAll(this.appendedArgs); } return args; } }
private TaskExecution invokeOnTaskError(TaskExecution taskExecution, Throwable throwable){ TaskExecution listenerTaskExecution = getTaskExecutionCopy(taskExecution); if (this.taskExecutionListeners != null) { try { for (TaskExecutionListener taskExecutionListener : this.taskExecutionListeners) { taskExecutionListener.onTaskFailed(listenerTaskExecution, throwable); } } catch (Throwable listenerException) { this.listenerFailed = true; String errorMessage; if(StringUtils.hasText(listenerTaskExecution.getErrorMessage())) { errorMessage = String.format("%s :While handling " + "this error: %s", listenerException.getMessage(), listenerTaskExecution.getErrorMessage()); } else { errorMessage = listenerTaskExecution.getErrorMessage(); } logger.error(errorMessage); listenerTaskExecution.setErrorMessage(errorMessage); listenerTaskExecution.setExitCode(1); } } return listenerTaskExecution; }