@Test
public void testRunRestartableJobInstanceTwice() throws Exception {
job =
new JobSupport("foo") {
@Override
public boolean isRestartable() {
return true;
}
@Override
public void execute(JobExecution execution) {
execution.setExitStatus(ExitStatus.COMPLETED);
return;
}
};
testRun();
reset(jobRepository);
expect(jobRepository.getLastJobExecution(job.getName(), jobParameters))
.andReturn(new JobExecution(new JobInstance(1L, jobParameters, job.getName())));
expect(jobRepository.createJobExecution(job.getName(), jobParameters))
.andReturn(new JobExecution(new JobInstance(1L, jobParameters, job.getName())));
replay(jobRepository);
jobLauncher.run(job, jobParameters);
verify(jobRepository);
}
@Test
public void testFindOrCreateJobConcurrentlyWhenJobAlreadyExists() throws Exception {
job = new JobSupport("test-job");
job.setRestartable(true);
job.setName("spam");
JobExecution execution = repository.createJobExecution(job.getName(), new JobParameters());
cacheJobIds(execution);
execution.setEndTime(new Timestamp(System.currentTimeMillis()));
repository.update(execution);
execution.setStatus(BatchStatus.FAILED);
int before = simpleJdbcTemplate.queryForInt("SELECT COUNT(*) FROM BATCH_JOB_INSTANCE");
assertEquals(1, before);
long t0 = System.currentTimeMillis();
try {
doConcurrentStart();
fail("Expected JobExecutionAlreadyRunningException");
} catch (JobExecutionAlreadyRunningException e) {
// expected
}
long t1 = System.currentTimeMillis();
int after = simpleJdbcTemplate.queryForInt("SELECT COUNT(*) FROM BATCH_JOB_INSTANCE");
assertNotNull(execution.getId());
assertEquals(before, after);
logger.info(
"Duration: "
+ (t1 - t0)
+ " - the second transaction did not block if this number is less than about 1000.");
}
@Test
public void testTaskExecutorRejects() throws Exception {
final List<String> list = new ArrayList<String>();
jobLauncher.setTaskExecutor(
new TaskExecutor() {
@Override
public void execute(Runnable task) {
list.add("execute");
throw new TaskRejectedException("Planned failure");
}
});
JobExecution jobExecution = new JobExecution(null, null);
expect(jobRepository.getLastJobExecution(job.getName(), jobParameters)).andReturn(null);
expect(jobRepository.createJobExecution(job.getName(), jobParameters)).andReturn(jobExecution);
jobRepository.update(jobExecution);
expectLastCall();
replay(jobRepository);
jobLauncher.afterPropertiesSet();
try {
jobLauncher.run(job, jobParameters);
} finally {
assertEquals(BatchStatus.FAILED, jobExecution.getStatus());
assertEquals(ExitStatus.FAILED.getExitCode(), jobExecution.getExitStatus().getExitCode());
verify(jobRepository);
}
assertEquals(1, list.size());
}
@Test
@Ignore // FIXME
public void testTransactionException() throws Exception {
final SkipWriterStub<String> writer = new SkipWriterStub<String>();
FaultTolerantStepFactoryBean<String, String> factory =
new FaultTolerantStepFactoryBean<String, String>();
factory.setItemWriter(writer);
@SuppressWarnings("serial")
DataSourceTransactionManager transactionManager =
new DataSourceTransactionManager(dataSource) {
private boolean failed = false;
@Override
protected void doCommit(DefaultTransactionStatus status) throws TransactionException {
if (writer.getWritten().isEmpty()
|| failed
|| !isExistingTransaction(status.getTransaction())) {
super.doCommit(status);
return;
}
failed = true;
status.setRollbackOnly();
super.doRollback(status);
throw new UnexpectedRollbackException("Planned");
}
};
factory.setBeanName("stepName");
factory.setTransactionManager(transactionManager);
factory.setCommitInterval(2);
ItemReader<String> reader = new ListItemReader<String>(Arrays.asList("1", "2"));
factory.setItemReader(reader);
JobRepositoryFactoryBean repositoryFactory = new JobRepositoryFactoryBean();
repositoryFactory.setDataSource(dataSource);
repositoryFactory.setTransactionManager(transactionManager);
repositoryFactory.afterPropertiesSet();
JobRepository repository = repositoryFactory.getObject();
factory.setJobRepository(repository);
JobExecution jobExecution = repository.createJobExecution("job", new JobParameters());
StepExecution stepExecution = jobExecution.createStepExecution(factory.getName());
repository.add(stepExecution);
Step step = factory.getObject();
step.execute(stepExecution);
assertEquals(BatchStatus.FAILED, stepExecution.getStatus());
assertEquals("[]", writer.getCommitted().toString());
}
@Before
public void setUp() throws Exception {
step.setName("step");
MapJobRepositoryFactoryBean factory = new MapJobRepositoryFactoryBean();
jobRepository = factory.getObject();
step.setJobRepository(jobRepository);
JobExecution jobExecution = jobRepository.createJobExecution("job", new JobParameters());
stepExecution = jobExecution.createStepExecution("step");
jobRepository.add(stepExecution);
SimpleJobLauncher jobLauncher = new SimpleJobLauncher();
jobLauncher.setJobRepository(jobRepository);
jobLauncher.afterPropertiesSet();
step.setJobLauncher(jobLauncher);
}
private void run(ExitStatus exitStatus) throws Exception {
JobExecution jobExecution = new JobExecution(null, null);
expect(jobRepository.getLastJobExecution(job.getName(), jobParameters)).andReturn(null);
expect(jobRepository.createJobExecution(job.getName(), jobParameters)).andReturn(jobExecution);
replay(jobRepository);
jobLauncher.afterPropertiesSet();
try {
jobLauncher.run(job, jobParameters);
} finally {
assertEquals(exitStatus, jobExecution.getExitStatus());
verify(jobRepository);
}
}
@Test
public void testRuntimeBatchConfigurer() throws Exception {
jobRepository.toString(); // needed to trigger lazy bean initialization
assertSame(getTargetObject(jobRepository, JobRepository.class), testConfig.getCustomJobRepo());
}
public JobExecution launch(String jobName, JobParameters jobParameters)
throws NoSuchJobException, JobExecutionAlreadyRunningException, JobRestartException,
JobInstanceAlreadyCompleteException, JobParametersInvalidException {
Job job = jobLocator.getJob(jobName);
JobExecution lastJobExecution = jobRepository.getLastJobExecution(jobName, jobParameters);
boolean restart = false;
if (lastJobExecution != null) {
BatchStatus status = lastJobExecution.getStatus();
if (status.isUnsuccessful() && status != BatchStatus.ABANDONED) {
restart = true;
}
}
if (job.getJobParametersIncrementer() != null && !restart) {
jobParameters = job.getJobParametersIncrementer().getNext(jobParameters);
}
JobExecution jobExecution = jobLauncher.run(job, jobParameters);
if (jobExecution.isRunning()) {
activeExecutions.add(jobExecution);
}
return jobExecution;
}
public int stopAll() {
Collection<JobExecution> result = jobExecutionDao.getRunningJobExecutions();
for (JobExecution jobExecution : result) {
jobExecution.stop();
jobRepository.update(jobExecution);
}
return result.size();
}
@Transactional
@Test
public void testFindOrCreateJob() throws Exception {
job.setName("foo");
int before = 0;
JobExecution execution = repository.createJobExecution(job.getName(), new JobParameters());
int after = simpleJdbcTemplate.queryForInt("SELECT COUNT(*) FROM BATCH_JOB_INSTANCE");
assertEquals(before + 1, after);
assertNotNull(execution.getId());
}
@Test
public void testExecuteRestart() throws Exception {
DefaultJobParametersExtractor jobParametersExtractor = new DefaultJobParametersExtractor();
jobParametersExtractor.setKeys(new String[] {"foo"});
ExecutionContext executionContext = stepExecution.getExecutionContext();
executionContext.put("foo", "bar");
step.setJobParametersExtractor(jobParametersExtractor);
step.setJob(
new JobSupport("child") {
@Override
public void execute(JobExecution execution) throws UnexpectedJobExecutionException {
assertEquals(1, execution.getJobParameters().getParameters().size());
execution.setStatus(BatchStatus.FAILED);
execution.setEndTime(new Date());
jobRepository.update(execution);
throw new RuntimeException("FOO");
}
@Override
public boolean isRestartable() {
return true;
}
});
step.afterPropertiesSet();
step.execute(stepExecution);
assertEquals("FOO", stepExecution.getFailureExceptions().get(0).getMessage());
JobExecution jobExecution = stepExecution.getJobExecution();
jobExecution.setEndTime(new Date());
jobRepository.update(jobExecution);
jobExecution = jobRepository.createJobExecution("job", new JobParameters());
stepExecution = jobExecution.createStepExecution("step");
// In a restart the surrounding Job would set up the context like this...
stepExecution.setExecutionContext(executionContext);
jobRepository.add(stepExecution);
step.execute(stepExecution);
assertEquals("FOO", stepExecution.getFailureExceptions().get(0).getMessage());
}
public JobExecution stop(Long jobExecutionId)
throws NoSuchJobExecutionException, JobExecutionNotRunningException {
JobExecution jobExecution = getJobExecution(jobExecutionId);
if (!jobExecution.isRunning()) {
throw new JobExecutionNotRunningException(
"JobExecution is not running and therefore cannot be stopped");
}
logger.info("Stopping job execution: " + jobExecution);
jobExecution.stop();
jobRepository.update(jobExecution);
return jobExecution;
}
public JobExecution abandon(Long jobExecutionId)
throws NoSuchJobExecutionException, JobExecutionAlreadyRunningException {
JobExecution jobExecution = getJobExecution(jobExecutionId);
if (jobExecution.getStatus().isLessThan(BatchStatus.STOPPING)) {
throw new JobExecutionAlreadyRunningException(
"JobExecution is running or complete and therefore cannot be aborted");
}
logger.info("Aborting job execution: " + jobExecution);
jobExecution.upgradeStatus(BatchStatus.ABANDONED);
jobExecution.setEndTime(new Date());
jobRepository.update(jobExecution);
return jobExecution;
}
@Test(expected = JobParametersInvalidException.class)
public void testRunWithValidator() throws Exception {
job.setJobParametersValidator(
new DefaultJobParametersValidator(new String[] {"missing-and-required"}, new String[0]));
expect(jobRepository.getLastJobExecution(job.getName(), jobParameters)).andReturn(null);
replay(jobRepository);
jobLauncher.afterPropertiesSet();
try {
jobLauncher.run(job, jobParameters);
} finally {
verify(jobRepository);
}
}
private JobExecution doConcurrentStart() throws Exception {
new Thread(
new Runnable() {
public void run() {
try {
new TransactionTemplate(transactionManager)
.execute(
new TransactionCallback() {
public Object doInTransaction(
org.springframework.transaction.TransactionStatus status) {
try {
JobExecution execution =
repository.createJobExecution(
job.getName(), new JobParameters());
cacheJobIds(execution);
list.add(execution);
Thread.sleep(1000);
} catch (Exception e) {
list.add(e);
}
return null;
}
});
} catch (RuntimeException e) {
list.add(e);
}
}
})
.start();
Thread.sleep(400);
JobExecution execution = repository.createJobExecution(job.getName(), new JobParameters());
cacheJobIds(execution);
int count = 0;
while (list.size() == 0 && count++ < 100) {
Thread.sleep(200);
}
assertEquals("Timed out waiting for JobExecution to be created", 1, list.size());
assertTrue("JobExecution not created in thread", list.get(0) instanceof JobExecution);
return (JobExecution) list.get(0);
}
private void updateStatus(JobExecution jobExecution, BatchStatus status) {
jobExecution.setStatus(status);
jobRepository.update(jobExecution);
}
/*
* Start a job by obtaining a combined classpath using the job launcher and
* job paths. If a JobLocator has been set, then use it to obtain an actual
* job, if not ask the context for it.
*/
public int start(String moduleNm, String jobIdentifier, String[] parameters, Set<String> opts)
throws Exception {
INaviModuleContext context = null;
try {
context = NaviModuleContextFactory.getInstance().getNaviModuleContext(moduleNm);
launcher = (JobLauncher) context.getBean("jobLauncher");
jobExplorer = (JobExplorer) context.getBean("jobExplorer");
jobRepository = (JobRepository) context.getBean("jobRepository");
Assert.state(
launcher != null,
"A JobLauncher must be provided. Please add one to the configuration.");
if (opts.contains("-restart") || opts.contains("-next")) {
Assert.state(
jobExplorer != null,
"A JobExplorer must be provided for a restart or start next operation. Please add one to the configuration.");
}
String jobName = moduleNm + "_" + jobIdentifier;
JobParameters jobParameters =
jobParametersConverter.getJobParameters(
StringUtils.splitArrayElementsIntoProperties(parameters, "="));
Assert.isTrue(
parameters == null || parameters.length == 0 || !jobParameters.isEmpty(),
"Invalid JobParameters "
+ Arrays.asList(parameters)
+ ". If parameters are provided they should be in the form name=value (no whitespace).");
if (opts.contains("-stop")) {
List<JobExecution> jobExecutions = getRunningJobExecutions(jobName);
if (jobExecutions == null) {
throw new JobExecutionNotRunningException(
"No running execution found for job=" + jobName);
}
for (JobExecution jobExecution : jobExecutions) {
jobExecution.setStatus(BatchStatus.STOPPING);
jobRepository.update(jobExecution);
}
return exitCodeMapper.intValue(ExitStatus.COMPLETED.getExitCode());
}
if (opts.contains("-abandon")) {
List<JobExecution> jobExecutions = getStoppedJobExecutions(jobName);
if (jobExecutions == null) {
throw new JobExecutionNotStoppedException(
"No stopped execution found for job=" + jobName);
}
for (JobExecution jobExecution : jobExecutions) {
jobExecution.setStatus(BatchStatus.ABANDONED);
jobRepository.update(jobExecution);
}
return exitCodeMapper.intValue(ExitStatus.COMPLETED.getExitCode());
}
if (opts.contains("-restart")) {
JobExecution jobExecution = getLastFailedJobExecution(jobName);
if (jobExecution == null) {
throw new JobExecutionNotFailedException(
"No failed or stopped execution found for job=" + jobName);
}
jobParameters = jobExecution.getJobInstance().getJobParameters();
jobName = jobExecution.getJobInstance().getJobName();
}
Job job;
if (jobLocator != null) {
job = jobLocator.getJob(jobIdentifier);
} else {
job = (Job) context.getBean(jobIdentifier);
AbstractJob tmptJob = (AbstractJob) job;
// 重写jobNm
tmptJob.setName(jobName);
}
if (opts.contains("-next")) {
JobParameters nextParameters = getNextJobParameters(job);
Map<String, JobParameter> map =
new HashMap<String, JobParameter>(nextParameters.getParameters());
map.putAll(jobParameters.getParameters());
jobParameters = new JobParameters(map);
}
JobExecution jobExecution = launcher.run(job, jobParameters);
return exitCodeMapper.intValue(jobExecution.getExitStatus().getExitCode());
} catch (Throwable e) {
String message = "Job Terminated in error: " + e.getMessage();
log.error(message, e);
NaviDaemonJobRunner.message = message;
return exitCodeMapper.intValue(ExitStatus.FAILED.getExitCode());
} finally {
if (context != null) {
context.close();
}
}
}
/**
* Run the specified job, handling all listener and repository calls, and delegating the actual
* processing to {@link #doExecute(JobExecution)}.
*
* @see Job#execute(JobExecution)
* @throws StartLimitExceededException if start limit of one of the steps was exceeded
*/
@Override
public final void execute(JobExecution execution) {
logger.debug("Job execution starting: " + execution);
try {
jobParametersValidator.validate(execution.getJobInstance().getJobParameters());
if (execution.getStatus() != BatchStatus.STOPPING) {
execution.setStartTime(new Date());
updateStatus(execution, BatchStatus.STARTED);
listener.beforeJob(execution);
try {
doExecute(execution);
logger.debug("Job execution complete: " + execution);
} catch (RepeatException e) {
throw e.getCause();
}
} else {
// The job was already stopped before we even got this far. Deal
// with it in the same way as any other interruption.
execution.setStatus(BatchStatus.STOPPED);
execution.setExitStatus(ExitStatus.COMPLETED);
logger.debug("Job execution was stopped: " + execution);
}
} catch (JobInterruptedException e) {
logger.info("Encountered interruption executing job: " + e.getMessage());
if (logger.isDebugEnabled()) {
logger.debug("Full exception", e);
}
execution.setExitStatus(getDefaultExitStatusForFailure(e));
execution.setStatus(BatchStatus.max(BatchStatus.STOPPED, e.getStatus()));
execution.addFailureException(e);
} catch (Throwable t) {
logger.error("Encountered fatal error executing job", t);
execution.setExitStatus(getDefaultExitStatusForFailure(t));
execution.setStatus(BatchStatus.FAILED);
execution.addFailureException(t);
} finally {
if (execution.getStatus().isLessThanOrEqualTo(BatchStatus.STOPPED)
&& execution.getStepExecutions().isEmpty()) {
ExitStatus exitStatus = execution.getExitStatus();
execution.setExitStatus(
exitStatus.and(
ExitStatus.NOOP.addExitDescription(
"All steps already completed or no steps configured for this job.")));
}
execution.setEndTime(new Date());
try {
listener.afterJob(execution);
} catch (Exception e) {
logger.error("Exception encountered in afterStep callback", e);
}
jobRepository.update(execution);
}
}