List<JobExecution> executions = jobExecutionDao.findJobExecutions(jobInstance); executionContext = ecDao.getExecutionContext(jobExecutionDao.getLastJobExecution(jobInstance)); jobExecutionDao.saveJobExecution(jobExecution); ecDao.saveExecutionContext(jobExecution);
@Override public StepExecution getStepExecution(Long jobExecutionId, Long executionId) { JobExecution jobExecution = jobExecutionDao.getJobExecution(jobExecutionId); if (jobExecution == null) { return null; } getJobExecutionDependencies(jobExecution); StepExecution stepExecution = stepExecutionDao.getStepExecution(jobExecution, executionId); getStepExecutionDependencies(stepExecution); return stepExecution; }
/** * Update and retrieve job execution - check attributes have changed as * expected. */ @Transactional @Test public void testUpdateExecution() { execution.setStatus(BatchStatus.STARTED); dao.saveJobExecution(execution); execution.setLastUpdated(new Date(0)); execution.setStatus(BatchStatus.COMPLETED); dao.updateJobExecution(execution); JobExecution updated = dao.findJobExecutions(jobInstance).get(0); assertEquals(execution, updated); assertEquals(BatchStatus.COMPLETED, updated.getStatus()); assertExecutionsAreEqual(execution, updated); }
@Override public void update(JobExecution jobExecution) { Assert.notNull(jobExecution, "JobExecution cannot be null."); Assert.notNull(jobExecution.getJobId(), "JobExecution must have a Job ID set."); Assert.notNull(jobExecution.getId(), "JobExecution must be already saved (have an id assigned)."); jobExecution.setLastUpdated(new Date(System.currentTimeMillis())); jobExecutionDao.synchronizeStatus(jobExecution); jobExecutionDao.updateJobExecution(jobExecution); }
@Transactional @Test public void testUpdateJobExecution() { jobExecution.setStatus(BatchStatus.COMPLETED); jobExecution.setExitStatus(ExitStatus.COMPLETED); jobExecution.setEndTime(new Date(System.currentTimeMillis())); jobExecutionDao.updateJobExecution(jobExecution); List<JobExecution> executions = jobExecutionDao.findJobExecutions(jobInstance); assertEquals(executions.size(), 1); validateJobExecution(jobExecution, executions.get(0)); }
/** * Check the execution with most recent start time is returned */ @Transactional @Test public void testGetLastExecution() { JobExecution exec1 = new JobExecution(jobInstance, jobParameters); exec1.setCreateTime(new Date(0)); JobExecution exec2 = new JobExecution(jobInstance, jobParameters); exec2.setCreateTime(new Date(1)); dao.saveJobExecution(exec1); dao.saveJobExecution(exec2); JobExecution last = dao.getLastJobExecution(jobInstance); assertEquals(exec2, last); }
/** * @return number of executions of the step within given job instance */ @Override public int getStepExecutionCount(JobInstance jobInstance, String stepName) { int count = 0; List<JobExecution> jobExecutions = jobExecutionDao.findJobExecutions(jobInstance); for (JobExecution jobExecution : jobExecutions) { stepExecutionDao.addStepExecutions(jobExecution); for (StepExecution stepExecution : jobExecution.getStepExecutions()) { if (stepName.equals(stepExecution.getStepName())) { count++; } } } return count; }
/** * Modifications to saved entity do not affect the persisted object. */ @Test public void testPersistentCopy() { JobExecutionDao tested = new MapJobExecutionDao(); JobExecution jobExecution = new JobExecution(new JobInstance((long) 1, "mapJob"), new JobParameters()); assertNull(jobExecution.getStartTime()); tested.saveJobExecution(jobExecution); jobExecution.setStartTime(new Date()); JobExecution retrieved = tested.getJobExecution(jobExecution.getId()); assertNull(retrieved.getStartTime()); tested.updateJobExecution(jobExecution); jobExecution.setEndTime(new Date()); assertNull(retrieved.getEndTime()); }
@Override public void saveStepExecutions(Collection<StepExecution> stepExecutions) { Assert.notNull(stepExecutions, "Attempt to save a null collection of step executions"); if (!stepExecutions.isEmpty()) { Long jobExecutionId = stepExecutions.iterator().next().getJobExecutionId(); Assert.notNull(jobExecutionId, "JobExecution must be saved already."); JobExecution jobExecution = jobExecutionDao.getJobExecution(jobExecutionId); Assert.notNull(jobExecution, "JobExecution must be saved already."); List<StepExecution> stepExecutionList = new ArrayList<>(); for (StepExecution stepExecution : stepExecutions) { Assert.isTrue(stepExecution.getId() == null); Assert.isTrue(stepExecution.getVersion() == null); validateStepExecution(stepExecution); stepExecution.setId(incrementer.nextLongValue()); stepExecution.incrementVersion(); stepExecutionList.add(stepExecution); } jobExecution.addStepExecutions(stepExecutionList); jobExecutionDao.updateJobExecution(jobExecution); } }
@Override public JobExecution createJobExecution(JobInstance jobInstance, JobParameters jobParameters, String jobConfigurationLocation) { Assert.notNull(jobInstance, "A JobInstance is required to associate the JobExecution with"); Assert.notNull(jobParameters, "A JobParameters object is required to create a JobExecution"); JobExecution jobExecution = new JobExecution(jobInstance, jobParameters, jobConfigurationLocation); ExecutionContext executionContext = new ExecutionContext(); jobExecution.setExecutionContext(executionContext); jobExecution.setLastUpdated(new Date(System.currentTimeMillis())); // Save the JobExecution so that it picks up an ID (useful for clients // monitoring asynchronous executions): jobExecutionDao.saveJobExecution(jobExecution); ecDao.saveExecutionContext(jobExecution); return jobExecution; } }
/** * Executions should be returned in the reverse order they were saved. */ @Transactional @Test public void testFindExecutionsOrdering() { List<JobExecution> execs = new ArrayList<>(); for (int i = 0; i < 10; i++) { JobExecution exec = new JobExecution(jobInstance, jobParameters); exec.setCreateTime(new Date(i)); execs.add(exec); dao.saveJobExecution(exec); } List<JobExecution> retrieved = dao.findJobExecutions(jobInstance); Collections.reverse(retrieved); for (int i = 0; i < 10; i++) { assertExecutionsAreEqual(execs.get(i), retrieved.get(i)); } }
@Override @Nullable public JobExecution getLastJobExecution(String jobName, JobParameters jobParameters) { JobInstance jobInstance = jobInstanceDao.getJobInstance(jobName, jobParameters); if (jobInstance == null) { return null; } JobExecution jobExecution = jobExecutionDao.getLastJobExecution(jobInstance); if (jobExecution != null) { jobExecution.setExecutionContext(ecDao.getExecutionContext(jobExecution)); stepExecutionDao.addStepExecutions(jobExecution); } return jobExecution; }
@Transactional @Test public void testUpdateNullIdJobExecution() { JobExecution execution = new JobExecution(jobInstance, jobParameters); try { jobExecutionDao.updateJobExecution(execution); fail(); } catch (IllegalArgumentException ex) { // expected } }
/** * UNKNOWN status won't be changed by synchronizeStatus, because it is the * 'largest' BatchStatus (will not downgrade). */ @Transactional @Test public void testSynchronizeStatusDowngrade() { JobExecution exec1 = new JobExecution(jobInstance, jobParameters); exec1.setStatus(BatchStatus.STARTED); dao.saveJobExecution(exec1); JobExecution exec2 = new JobExecution(jobInstance, jobParameters); assertTrue(exec1.getId() != null); exec2.setId(exec1.getId()); exec2.setStatus(BatchStatus.UNKNOWN); exec2.setVersion(7); assertTrue(exec1.getVersion() != exec2.getVersion()); assertTrue(exec1.getStatus().isLessThan(exec2.getStatus())); dao.synchronizeStatus(exec2); assertEquals(exec1.getVersion(), exec2.getVersion()); assertEquals(BatchStatus.UNKNOWN, exec2.getStatus()); }
/** * Check the execution is returned */ @Transactional @Test public void testGetExecution() { JobExecution exec = new JobExecution(jobInstance, jobParameters); exec.setCreateTime(new Date(0)); exec.createStepExecution("step"); dao.saveJobExecution(exec); StepExecutionDao stepExecutionDao = getStepExecutionDao(); if (stepExecutionDao != null) { for (StepExecution stepExecution : exec.getStepExecutions()) { stepExecutionDao.saveStepExecution(stepExecution); } } JobExecution value = dao.getJobExecution(exec.getId()); assertEquals(exec, value); // N.B. the job instance is not re-hydrated in the JDBC case... }
/** * Exception should be raised when the version of update argument doesn't * match the version of persisted entity. */ @Transactional @Test public void testConcurrentModificationException() { JobExecution exec1 = new JobExecution(jobInstance, jobParameters); dao.saveJobExecution(exec1); JobExecution exec2 = new JobExecution(jobInstance, jobParameters); exec2.setId(exec1.getId()); exec2.incrementVersion(); assertEquals((Integer) 0, exec1.getVersion()); assertEquals(exec1.getVersion(), exec2.getVersion()); dao.updateJobExecution(exec1); assertEquals((Integer) 1, exec1.getVersion()); try { dao.updateJobExecution(exec2); fail(); } catch (OptimisticLockingFailureException e) { // expected } }
@Override public Set<JobExecution> findRunningJobExecutions(String jobName) { Set<JobExecution> executions = jobExecutionDao.findRunningJobExecutions(jobName); for (JobExecution jobExecution : executions) { getJobExecutionDependencies(jobExecution); for (StepExecution stepExecution : jobExecution.getStepExecutions()) { getStepExecutionDependencies(stepExecution); } } return executions; }
exec.setEndTime(new Date(2L)); exec.setLastUpdated(new Date(5L)); dao.saveJobExecution(exec); dao.saveJobExecution(exec); exec.setLastUpdated(new Date(5L)); exec.createStepExecution("step"); dao.saveJobExecution(exec); Set<JobExecution> values = dao.findRunningJobExecutions(exec.getJobInstance().getJobName());
/** * Check to determine whether or not the JobExecution that is the parent of * the provided StepExecution has been interrupted. If, after synchronizing * the status with the database, the status has been updated to STOPPING, * then the job has been interrupted. * * @param stepExecution */ private void checkForInterruption(StepExecution stepExecution) { JobExecution jobExecution = stepExecution.getJobExecution(); jobExecutionDao.synchronizeStatus(jobExecution); if (jobExecution.isStopping()) { logger.info("Parent JobExecution is stopped, so passing message on to StepExecution"); stepExecution.setTerminateOnly(); } }
@Override public List<JobExecution> getJobExecutions(JobInstance jobInstance) { List<JobExecution> executions = jobExecutionDao.findJobExecutions(jobInstance); for (JobExecution jobExecution : executions) { getJobExecutionDependencies(jobExecution); for (StepExecution stepExecution : jobExecution.getStepExecutions()) { getStepExecutionDependencies(stepExecution); } } return executions; }