@Test public void testCreateGenericArchive() throws NoSuchJobException, JobExecutionAlreadyRunningException, JobRestartException, JobInstanceAlreadyCompleteException, JobParametersInvalidException, IOException { Map<String, JobParameter> parameters = new HashMap<String, JobParameter>(); JobParameters jobParameters = new JobParameters(parameters); Job palmwebArchive = jobLocator.getJob("PalmWeb"); assertNotNull("Palmweb must not be null", palmwebArchive); JobExecution jobExecution = jobLauncher.run(palmwebArchive, jobParameters); assertEquals("The job should complete successfully",jobExecution.getExitStatus().getExitCode(),"COMPLETED"); for (StepExecution stepExecution : jobExecution.getStepExecutions()) { logger.info(stepExecution.getStepName() + " " + stepExecution.getReadCount() + " " + stepExecution.getFilterCount() + " " + stepExecution.getWriteCount() + " " + stepExecution.getCommitCount()); } }
protected Parameter convertParameterEntryToParameter(Map.Entry<String, JobParameter> entry) { Parameter paramToAdd = new Parameter().setKey(entry.getKey()); JobParameter parameter = entry.getValue(); if (parameter.getType() == JobParameter.ParameterType.DATE) { paramToAdd.setParameterType(ParameterType.DATE); Date param = (Date) parameter.getValue(); if (param != null) { paramToAdd.value(DateUtil.getDate(param)); } return paramToAdd; } return paramToAdd .value(parameter.getValue().toString()) .parameterType(parameter.getType() == JobParameter.ParameterType.STRING ? ParameterType.STRING : ParameterType.NUMBER); }
private static void createSampleJob(String jobName, int jobExecutionCount) { JobInstance instance = jobRepository.createJobInstance(jobName, new JobParameters()); jobInstances.add(instance); TaskExecution taskExecution = dao.createTaskExecution(jobName, new Date(), new ArrayList<String>(), null); Map<String, JobParameter> jobParameterMap = new HashMap<>(); jobParameterMap.put("foo", new JobParameter("FOO", true)); jobParameterMap.put("bar", new JobParameter("BAR", false)); JobParameters jobParameters = new JobParameters(jobParameterMap); JobExecution jobExecution = null; for (int i = 0; i < jobExecutionCount; i++) { jobExecution = jobRepository.createJobExecution(instance, jobParameters, null); taskBatchDao.saveRelationship(taskExecution, jobExecution); StepExecution stepExecution = new StepExecution("foobar", jobExecution); jobRepository.add(stepExecution); } }
private void assertCorrectMixins(RestTemplate restTemplate) { boolean containsMappingJackson2HttpMessageConverter = false; for (HttpMessageConverter<?> converter : restTemplate.getMessageConverters()) { if (converter instanceof MappingJackson2HttpMessageConverter) { containsMappingJackson2HttpMessageConverter = true; final MappingJackson2HttpMessageConverter jacksonConverter = (MappingJackson2HttpMessageConverter) converter; final ObjectMapper objectMapper = jacksonConverter.getObjectMapper(); assertNotNull(objectMapper.findMixInClassFor(JobExecution.class)); assertNotNull(objectMapper.findMixInClassFor(JobParameters.class)); assertNotNull(objectMapper.findMixInClassFor(JobParameter.class)); assertNotNull(objectMapper.findMixInClassFor(JobInstance.class)); assertNotNull(objectMapper.findMixInClassFor(ExitStatus.class)); assertNotNull(objectMapper.findMixInClassFor(StepExecution.class)); assertNotNull(objectMapper.findMixInClassFor(ExecutionContext.class)); assertNotNull(objectMapper.findMixInClassFor(StepExecutionHistory.class)); } } if (!containsMappingJackson2HttpMessageConverter) { fail("Expected that the restTemplate's list of Message Converters contained a " + "MappingJackson2HttpMessageConverter"); } }
/** * @param jobId * Set the job id * @param jobName * Set the job name * @param authorityName * Set the authority name * @param version * Set the version */ public void createJobInstance(String jobId, String jobName, String authorityName, String version) { enableAuthentication(); Long id = null; if (jobId != null && jobId.length() > 0) { id = Long.parseLong(jobId); } Integer v = null; if (version != null && version.length() > 0) { v = Integer.parseInt(version); } Map<String, JobParameter> jobParameterMap = new HashMap<String, JobParameter>(); if (authorityName != null && authorityName.length() > 0) { jobParameterMap.put("authority.name", new JobParameter( authorityName)); } JobParameters jobParameters = new JobParameters(jobParameterMap); JobInstance jobInstance = new JobInstance(id, jobParameters, jobName); jobInstance.setVersion(v); data.push(jobInstance); jobInstanceService.save(jobInstance); disableAuthentication(); }
@Override public void launch(JobLaunchRequest request) { Job job; try { job = jobLocator.getJob(request.getJob()); Map<String, JobParameter> jobParameterMap = new HashMap<String, JobParameter>(); for(String parameterName : request.getParameters().keySet()) { jobParameterMap.put(parameterName, new JobParameter(request.getParameters().get(parameterName))); } JobParameters jobParameters = new JobParameters(jobParameterMap); try { jobLauncher.run(job, jobParameters); } catch (JobExecutionAlreadyRunningException jeare) { jobStatusNotifier.notify(new JobExecutionException(jeare.getLocalizedMessage()), request.getParameters().get("resource.identifier")); } catch (JobRestartException jre) { jobStatusNotifier.notify(new JobExecutionException(jre.getLocalizedMessage()), request.getParameters().get("resource.identifier")); } catch (JobInstanceAlreadyCompleteException jiace) { jobStatusNotifier.notify(new JobExecutionException(jiace.getLocalizedMessage()), request.getParameters().get("resource.identifier")); } catch (JobParametersInvalidException jpie) { jobStatusNotifier.notify(new JobExecutionException(jpie.getLocalizedMessage()), request.getParameters().get("resource.identifier")); } } catch (NoSuchJobException nsje) { jobStatusNotifier.notify(new JobExecutionException(nsje.getLocalizedMessage()), request.getParameters().get("resource.identifier")); } }
/** * @throws Exception */ @Test public void testWriteTaxonFile() throws Exception { Map<String, JobParameter> parameters = new HashMap<String, JobParameter>(); parameters.put("query", new JobParameter("")); parameters.put("selected.facets", new JobParameter("taxon.family_ss=Araceae")); parameters.put("download.taxon", new JobParameter(toParameter(DarwinCorePropertyMap.getConceptTerms(DwcTerm.Taxon)))); parameters.put("download.file", new JobParameter(UUID.randomUUID().toString() + ".txt")); parameters.put("download.limit", new JobParameter(new Integer(Integer.MAX_VALUE).toString())); parameters.put("download.fieldsTerminatedBy", new JobParameter("\t")); parameters.put("download.fieldsEnclosedBy", new JobParameter("\"")); parameters.put("download.format", new JobParameter("taxon")); JobParameters jobParameters = new JobParameters(parameters); Job archiveCreatorJob = jobLocator.getJob("FlatFileCreation"); assertNotNull("flatFileCreatorJob must exist", archiveCreatorJob); JobExecution jobExecution = jobLauncher.run(archiveCreatorJob, jobParameters); assertEquals("The Job should be sucessful", ExitStatus.COMPLETED, jobExecution.getExitStatus()); }
@Test public void testWriteChecklistPdf() throws Exception { Map<String, JobParameter> parameters = new HashMap<String, JobParameter>(); parameters.put("query", new JobParameter("")); parameters.put("selected.facets", new JobParameter("taxon.family_ss=Araceae")); parameters.put("download.taxon", new JobParameter(toParameter(DarwinCorePropertyMap.getConceptTerms(DwcTerm.Taxon)))); parameters.put("download.file", new JobParameter(UUID.randomUUID().toString() + ".pdf")); parameters.put("download.limit", new JobParameter(new Integer(Integer.MAX_VALUE).toString())); parameters.put("download.fieldsTerminatedBy", new JobParameter("\t")); parameters.put("download.fieldsEnclosedBy", new JobParameter("\"")); parameters.put("download.sort", new JobParameter("searchable.label_sort_asc")); parameters.put("download.format", new JobParameter("hierarchicalChecklist")); parameters.put("download.template.filepath", new JobParameter("org/emonocot/job/download/reports/name_report1.jrxml")); JobParameters jobParameters = new JobParameters(parameters); Job archiveCreatorJob = jobLocator.getJob("FlatFileCreation"); assertNotNull("flatFileCreator Job must exist", archiveCreatorJob); JobExecution jobExecution = jobLauncher.run(archiveCreatorJob, jobParameters); assertEquals("The Job should be sucessful", ExitStatus.COMPLETED, jobExecution.getExitStatus()); }
/** * * @throws IOException * if a temporary file cannot be created. * @throws NoSuchJobException * if SpeciesPageHarvestingJob cannot be located * @throws JobParametersInvalidException * if the job parameters are invalid * @throws JobInstanceAlreadyCompleteException * if the job has already completed * @throws JobRestartException * if the job cannot be restarted * @throws JobExecutionAlreadyRunningException * if the job is already running */ @Test public final void testNotModifiedResponse() throws IOException, NoSuchJobException, JobExecutionAlreadyRunningException, JobRestartException, JobInstanceAlreadyCompleteException, JobParametersInvalidException { Map<String, JobParameter> parameters = new HashMap<String, JobParameter>(); parameters.put("query.string", new JobParameter("select i from Image i")); JobParameters jobParameters = new JobParameters(parameters); Job job = jobLocator.getJob("ImageProcessing"); assertNotNull("ImageProcessing must not be null", job); JobExecution jobExecution = jobLauncher.run(job, jobParameters); assertEquals("The job should complete successfully",jobExecution.getExitStatus().getExitCode(),"COMPLETED"); for (StepExecution stepExecution : jobExecution.getStepExecutions()) { logger.info(stepExecution.getStepName() + " " + stepExecution.getReadCount() + " " + stepExecution.getFilterCount() + " " + stepExecution.getWriteCount()); } }
/** * * @throws Exception * if there is a problem serializing the object */ @Test public void testWriteJobInstance() throws Exception { Map<String, JobParameter> jobParameterMap = new HashMap<String, JobParameter>(); jobParameterMap.put("authority.name", new JobParameter("test")); JobInstance jobInstance = new JobInstance(1L, new JobParameters( jobParameterMap), "testJob"); jobInstance.setVersion(1); try { objectMapper.writeValueAsString(jobInstance); } catch (Exception e) { fail("No exception expected here"); } }
@Override public void launch(JobLaunchRequest request) { Job job; try { job = jobLocator.getJob(request.getJob()); Map<String, JobParameter> jobParameterMap = new HashMap<String, JobParameter>(); for(String parameterName : request.getParameters().keySet()) { jobParameterMap.put(parameterName, new JobParameter(request.getParameters().get(parameterName))); } JobParameters jobParameters = new JobParameters(jobParameterMap); jobLauncher.run(job, jobParameters); } catch (NoSuchJobException | JobExecutionAlreadyRunningException | JobRestartException | JobInstanceAlreadyCompleteException | JobParametersInvalidException exception) { jobStatusNotifier.notify(new JobExecutionException(exception.getLocalizedMessage()), request.getParameters().get("job.configuration.id")); } }
public static ParameterType convert(JobParameter.ParameterType type) { if(JobParameter.ParameterType.DATE.equals(type)) { return DATE; } else if(JobParameter.ParameterType.DOUBLE.equals(type)) { return DOUBLE; } else if(JobParameter.ParameterType.LONG.equals(type)) { return LONG; } else if(JobParameter.ParameterType.STRING.equals(type)) { return STRING; } else { throw new IllegalArgumentException("Unable to convert type"); } }
public JobParametersEvent(Map<String,JobParameter> jobParameters) { this.parameters = new LinkedHashMap<>(); for(Map.Entry<String, JobParameter> entry: jobParameters.entrySet()){ if(entry.getValue().getValue() instanceof String){ parameters.put(entry.getKey(), new JobParameterEvent(entry.getValue())); } else if(entry.getValue().getValue() instanceof Long){ parameters.put(entry.getKey(), new JobParameterEvent(entry.getValue())); } else if(entry.getValue().getValue() instanceof Date){ parameters.put(entry.getKey(), new JobParameterEvent(entry.getValue())); } else if(entry.getValue().getValue() instanceof Double){ parameters.put(entry.getKey(), new JobParameterEvent(entry.getValue())); } } }
@Test public void testJobParameters() { String[] JOB_PARAM_KEYS = {"A", "B", "C", "D"}; Date testDate = new Date(); JobParameter[] PARAMETERS = {new JobParameter("FOO", true), new JobParameter(1L, true), new JobParameter(1D, true), new JobParameter(testDate, false)}; Map jobParamMap = new LinkedHashMap<>(); for (int paramCount = 0; paramCount < JOB_PARAM_KEYS.length; paramCount++) { jobParamMap.put(JOB_PARAM_KEYS[paramCount], PARAMETERS[paramCount]); } jobParameters = new JobParameters(jobParamMap); JobExecution jobExecution = new JobExecution(jobInstance, JOB_EXECUTION_ID, jobParameters, JOB_CONFIGURATION_NAME); JobExecutionEvent jobExecutionEvent = new JobExecutionEvent(jobExecution); assertNotNull("Job Parameter A was expected", jobExecutionEvent.getJobParameters().getString("A")); assertNotNull("Job Parameter B was expected", jobExecutionEvent.getJobParameters().getLong("B")); assertNotNull("Job Parameter C was expected", jobExecutionEvent.getJobParameters().getDouble("C")); assertNotNull("Job Parameter D was expected", jobExecutionEvent.getJobParameters().getDate("D")); assertEquals("Job Parameter A value was not correct", "FOO", jobExecutionEvent.getJobParameters().getString("A")); assertEquals("Job Parameter B value was not correct", new Long(1), jobExecutionEvent.getJobParameters().getLong("B")); assertEquals("Job Parameter C value was not correct", new Double(1), jobExecutionEvent.getJobParameters().getDouble("C")); assertEquals("Job Parameter D value was not correct", testDate, jobExecutionEvent.getJobParameters().getDate("D")); }
public static JobExecutionResource toJobExecutionResource(final JobExecution jobExecution) { final JobExecutionResource execution = new JobExecutionResource( toJobInstanceResource(jobExecution.getJobInstance()), jobExecution.getId()); execution.setStatus(jobExecution.getStatus().name()); execution.setStartDate(jobExecution.getStartTime()); execution.setEndDate(jobExecution.getEndTime()); execution.setExitStatus(jobExecution.getExitStatus().getExitCode()); JobParameters jobParams = jobExecution.getJobParameters(); if (jobParams != null) { Map<String, JobParameter> params = jobParams.getParameters(); if (params != null && !params.isEmpty()) { Map<String, Object> jobParametersResource = new HashMap<String, Object>(); for (String key : params.keySet()) { jobParametersResource.put(key, params.get(key).getValue()); } execution.setJobParametersResource(jobParametersResource); } } return execution; }
@Test public void jobParameters() throws Exception { final Date date = new Date(); final JobParameters parameters = new JobParametersBuilder() // .addString("stringName", "stringValue") // .addLong("longName", 123L) // .addDouble("doubleName", 123.456d, false) // .addDate("dateName", date, false) // .toJobParameters(); final String json = mapper.writeValueAsString(parameters); final JobParameters read = mapper.readValue(json, JobParameters.class); assertThat("parameters after serialization", read, hasProperty("parameters", allOf(// hasEntry("stringName", new JobParameter("stringValue", true)), // hasEntry("longName", new JobParameter(123L, true)), // hasEntry("doubleName", new JobParameter(123.456d, false)), // hasEntry("dateName", new JobParameter(date, false)) // ))); }
protected Map<String, JobParameter> getParameters(JobExecutionContext context) { Map<String, JobParameter> parameters = Maps.newHashMap(); JobDataMap jobDataMap = context.getMergedJobDataMap(); for (Entry<String, Object> entry : jobDataMap.entrySet()) { // only 4 types of jobparameters at this time... if (entry.getValue() instanceof String) { parameters.put(entry.getKey(), new JobParameter((String) entry.getValue())); } else if (entry.getValue() instanceof Long) { parameters.put(entry.getKey(), new JobParameter((Long) entry.getValue())); } else if (entry.getValue() instanceof Double) { parameters.put(entry.getKey(), new JobParameter((Double) entry.getValue())); } else if (entry.getValue() instanceof Date) { parameters.put(entry.getKey(), new JobParameter((Date) entry.getValue())); } else { parameters.put(entry.getKey(), new JobParameter(entry.getValue().toString())); } } return parameters; }
private JobParameters createJobParametersWithIncrementerIfAvailable(String parameters, Job job) throws JobParametersNotFoundException { JobParameters jobParameters = jobParametersConverter.getJobParameters(PropertiesConverter.stringToProperties(parameters)); // use JobParametersIncrementer to create JobParameters if incrementer is set and only if the job is no restart if (job.getJobParametersIncrementer() != null){ JobExecution lastJobExecution = jobRepository.getLastJobExecution(job.getName(), jobParameters); boolean restart = false; // check if job failed before if (lastJobExecution != null) { BatchStatus status = lastJobExecution.getStatus(); if (status.isUnsuccessful() && status != BatchStatus.ABANDONED) { restart = true; } } // if it's not a restart, create new JobParameters with the incrementer if (!restart) { JobParameters nextParameters = getNextJobParameters(job); Map<String, JobParameter> map = new HashMap<String, JobParameter>(nextParameters.getParameters()); map.putAll(jobParameters.getParameters()); jobParameters = new JobParameters(map); } } return jobParameters; }
public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception { JobParameters jobParameters = chunkContext.getStepContext().getStepExecution().getJobParameters(); System.out.println("Hello Spring Batch!"); if (jobParameters != null && !jobParameters.isEmpty()) { final Set<Entry<String, JobParameter>> parameterEntries = jobParameters.getParameters().entrySet(); System.out.println(LINE); System.out.println(String.format("The following %s Job Parameter(s) is/are present:", parameterEntries.size())); System.out.println(LINE); for (Entry<String, JobParameter> jobParameterEntry : parameterEntries) { System.out.println(String.format( "Parameter name: %s; isIdentifying: %s; type: %s; value: %s", jobParameterEntry.getKey(), jobParameterEntry.getValue().isIdentifying(), jobParameterEntry.getValue().getType().toString(), jobParameterEntry.getValue().getValue())); } System.out.println(LINE); } return RepeatStatus.FINISHED; }
/** * @param args */ public static void main(String[] args) { ClassPathXmlApplicationContext c = new ClassPathXmlApplicationContext( "billing_job.xml"); SimpleJobLauncher launcher = new SimpleJobLauncher(); launcher.setJobRepository((JobRepository) c.getBean("jobRepository")); launcher.setTaskExecutor(new SyncTaskExecutor()); try { Map<String, JobParameter> parameters = new HashMap<String, JobParameter>(); parameters.put(RUN_MONTH_KEY, new JobParameter("2011-2")); JobExecution je = launcher.run((Job) c.getBean("billingJob"), new JobParameters(parameters)); System.out.println(je); System.out.println(je.getJobInstance()); System.out.println(je.getStepExecutions()); } catch (Exception e) { e.printStackTrace(); } }
public static void main(String[] args) { ClassPathXmlApplicationContext c = new ClassPathXmlApplicationContext( "message_job.xml"); SimpleJobLauncher launcher = new SimpleJobLauncher(); launcher.setJobRepository((JobRepository) c.getBean("jobRepository")); launcher.setTaskExecutor(new SyncTaskExecutor()); try { Map<String, JobParameter> parameters = new HashMap<String, JobParameter>(); parameters.put(RUN_MONTH_KEY, new JobParameter("2011-10")); JobExecution je = launcher.run((Job) c.getBean("messageJob"), new JobParameters(parameters)); System.out.println(je); System.out.println(je.getJobInstance()); System.out.println(je.getStepExecutions()); } catch (Exception e) { e.printStackTrace(); } }
private JobParameters getNextJobParameters(Job job, JobParameters additionalParameters) { String name = job.getName(); JobParameters parameters = new JobParameters(); List<JobInstance> lastInstances = this.jobExplorer.getJobInstances(name, 0, 1); JobParametersIncrementer incrementer = job.getJobParametersIncrementer(); Map<String, JobParameter> additionals = additionalParameters.getParameters(); if (lastInstances.isEmpty()) { // Start from a completely clean sheet if (incrementer != null) { parameters = incrementer.getNext(new JobParameters()); } } else { List<JobExecution> previousExecutions = this.jobExplorer .getJobExecutions(lastInstances.get(0)); JobExecution previousExecution = previousExecutions.get(0); if (previousExecution == null) { // Normally this will not happen - an instance exists with no executions if (incrementer != null) { parameters = incrementer.getNext(new JobParameters()); } } else if (isStoppedOrFailed(previousExecution) && job.isRestartable()) { // Retry a failed or stopped execution parameters = previousExecution.getJobParameters(); // Non-identifying additional parameters can be removed to a retry removeNonIdentifying(additionals); } else if (incrementer != null) { // New instance so increment the parameters if we can parameters = incrementer.getNext(previousExecution.getJobParameters()); } } return merge(parameters, additionals); }
private void removeNonIdentifying(Map<String, JobParameter> parameters) { HashMap<String, JobParameter> copy = new HashMap<String, JobParameter>( parameters); for (Map.Entry<String, JobParameter> parameter : copy.entrySet()) { if (!parameter.getValue().isIdentifying()) { parameters.remove(parameter.getKey()); } } }
public JobParameters getNext(JobParameters parameters) { Map<String, JobParameter> map = new HashMap<String, JobParameter>( parameters.getParameters()); map.put("run.count", new JobParameter(parameters .getLong("run.count", -1)+1)); return new JobParameters(map); }
public static void main(String[] args) { String[] springConfig = { "spring/batch/jobs/job-config.xml" }; @SuppressWarnings("resource") ApplicationContext context = new ClassPathXmlApplicationContext(springConfig); JobLauncher jobLauncher = (JobLauncher) context.getBean("jobLauncher"); Job job = (Job) context.getBean("scopesJob"); Map<String, JobParameter> parameters = new HashMap<String, JobParameter>(); parameters.put("customStepScopeParameter", new JobParameter("myCustomStepScopeParameterValue")); parameters.put("time", new JobParameter(System.currentTimeMillis())); JobParameters jp = new JobParameters(parameters); try { JobExecution execution = jobLauncher.run(job, jp); System.out.println("Exit Status : " + execution.getStatus()); System.out.println("Exit Status : " + execution.getAllFailureExceptions()); } catch (Exception e) { e.printStackTrace(); } System.out.println("Done"); }
/** * Will augment the provided {@link RestTemplate} with the Jackson Mixins required by * Spring Cloud Data Flow, specifically: * <p> * <ul> * <li>{@link JobExecutionJacksonMixIn} * <li>{@link JobParametersJacksonMixIn} * <li>{@link JobParameterJacksonMixIn} * <li>{@link JobInstanceJacksonMixIn} * <li>{@link ExitStatusJacksonMixIn} * <li>{@link StepExecutionJacksonMixIn} * <li>{@link ExecutionContextJacksonMixIn} * <li>{@link StepExecutionHistoryJacksonMixIn} * </ul> * <p> * Furthermore, this method will also register the {@link Jackson2HalModule} * * @param restTemplate Can be null. Instantiates a new {@link RestTemplate} if null * @return RestTemplate with the required Jackson Mixins */ public static RestTemplate prepareRestTemplate(RestTemplate restTemplate) { if (restTemplate == null) { restTemplate = new RestTemplate(); } restTemplate.setErrorHandler(new VndErrorResponseErrorHandler(restTemplate.getMessageConverters())); boolean containsMappingJackson2HttpMessageConverter = false; for (HttpMessageConverter<?> converter : restTemplate.getMessageConverters()) { if (converter instanceof MappingJackson2HttpMessageConverter) { containsMappingJackson2HttpMessageConverter = true; final MappingJackson2HttpMessageConverter jacksonConverter = (MappingJackson2HttpMessageConverter) converter; jacksonConverter.getObjectMapper().registerModule(new Jackson2HalModule()) .addMixIn(JobExecution.class, JobExecutionJacksonMixIn.class) .addMixIn(JobParameters.class, JobParametersJacksonMixIn.class) .addMixIn(JobParameter.class, JobParameterJacksonMixIn.class) .addMixIn(JobInstance.class, JobInstanceJacksonMixIn.class) .addMixIn(ExitStatus.class, ExitStatusJacksonMixIn.class) .addMixIn(StepExecution.class, StepExecutionJacksonMixIn.class) .addMixIn(ExecutionContext.class, ExecutionContextJacksonMixIn.class) .addMixIn(StepExecutionHistory.class, StepExecutionHistoryJacksonMixIn.class); } } if (!containsMappingJackson2HttpMessageConverter) { throw new IllegalArgumentException( "The RestTemplate does not contain a required " + "MappingJackson2HttpMessageConverter."); } return restTemplate; }
@Test public void testDeserializationOfMultipleJobExecutions() throws IOException { final ObjectMapper objectMapper = new ObjectMapper(); final InputStream inputStream = JobExecutionDeserializationTests.class .getResourceAsStream("/JobExecutionJson.txt"); final String json = new String(StreamUtils.copyToByteArray(inputStream)); objectMapper.registerModule(new Jackson2HalModule()); objectMapper.addMixIn(JobExecution.class, JobExecutionJacksonMixIn.class); objectMapper.addMixIn(JobParameters.class, JobParametersJacksonMixIn.class); objectMapper.addMixIn(JobParameter.class, JobParameterJacksonMixIn.class); objectMapper.addMixIn(JobInstance.class, JobInstanceJacksonMixIn.class); objectMapper.addMixIn(StepExecution.class, StepExecutionJacksonMixIn.class); objectMapper.addMixIn(StepExecutionHistory.class, StepExecutionHistoryJacksonMixIn.class); objectMapper.addMixIn(ExecutionContext.class, ExecutionContextJacksonMixIn.class); objectMapper.addMixIn(ExitStatus.class, ExitStatusJacksonMixIn.class); PagedResources<Resource<JobExecutionResource>> paged = objectMapper.readValue(json, new TypeReference<PagedResources<Resource<JobExecutionResource>>>() { }); JobExecutionResource jobExecutionResource = paged.getContent().iterator().next().getContent(); Assert.assertEquals("Expect 1 JobExecutionInfoResource", 6, paged.getContent().size()); Assert.assertEquals(Long.valueOf(6), jobExecutionResource.getJobId()); Assert.assertEquals("job200616815", jobExecutionResource.getName()); Assert.assertEquals("COMPLETED", jobExecutionResource.getJobExecution().getStatus().name()); }
@Test public void testDeserializationOfSingleJobExecution() throws IOException { final ObjectMapper objectMapper = new ObjectMapper(); objectMapper.registerModule(new Jackson2HalModule()); final InputStream inputStream = JobExecutionDeserializationTests.class .getResourceAsStream("/SingleJobExecutionJson.txt"); final String json = new String(StreamUtils.copyToByteArray(inputStream)); objectMapper.addMixIn(JobExecution.class, JobExecutionJacksonMixIn.class); objectMapper.addMixIn(JobParameters.class, JobParametersJacksonMixIn.class); objectMapper.addMixIn(JobParameter.class, JobParameterJacksonMixIn.class); objectMapper.addMixIn(JobInstance.class, JobInstanceJacksonMixIn.class); objectMapper.addMixIn(StepExecution.class, StepExecutionJacksonMixIn.class); objectMapper.addMixIn(StepExecutionHistory.class, StepExecutionHistoryJacksonMixIn.class); objectMapper.addMixIn(ExecutionContext.class, ExecutionContextJacksonMixIn.class); objectMapper.addMixIn(ExitStatus.class, ExitStatusJacksonMixIn.class); objectMapper.setDateFormat(new ISO8601DateFormatWithMilliSeconds()); final JobExecutionResource jobExecutionInfoResource = objectMapper.readValue(json, JobExecutionResource.class); Assert.assertNotNull(jobExecutionInfoResource); Assert.assertEquals(Long.valueOf(1), jobExecutionInfoResource.getJobId()); Assert.assertEquals("ff.job", jobExecutionInfoResource.getName()); Assert.assertEquals("COMPLETED", jobExecutionInfoResource.getJobExecution().getStatus().name()); }
/** * Runs the scheduled job. * * @throws JobParametersInvalidException * @throws JobInstanceAlreadyCompleteException * @throws JobRestartException * @throws JobExecutionAlreadyRunningException */ @Scheduled(fixedRate = RATE) public void run() throws JobExecutionAlreadyRunningException, JobRestartException, JobInstanceAlreadyCompleteException, JobParametersInvalidException { JobParameters params = new JobParameters(new HashMap<String, JobParameter>() { private static final long serialVersionUID = 1L; { put("execDate", new JobParameter(new Date(), true)); } }); jobLauncher.run(job, params); }
@Test public void shouldTaskletWork() throws JobExecutionAlreadyRunningException, JobRestartException, JobInstanceAlreadyCompleteException, JobParametersInvalidException { Map<String, JobParameter> params = Maps.newHashMap(); params.put("test", new JobParameter("przodownik")); params.put("time", new JobParameter(new Date())); JobExecution execution = jobLauncher.run(simpleStringProcessorTask, new JobParameters(params)); log.info("Exit Status : {}", execution.getExitStatus()); Assert.assertEquals(ExitStatus.COMPLETED, execution.getExitStatus()); }
@Override public void run(String... args) throws Exception { Map<String,JobParameter> params = Maps.newHashMap(); params.put("message", new JobParameter("przodownik -> batch -> first -> example")); JobParameters jobParameters = new JobParameters(params); jobLauncher.run(firstJob, jobParameters); }
/** * * @param jobInstance * The jobExecution to save */ public final void save(final JobInstance jobInstance) { String jobKey = createJobKey(jobInstance.getJobParameters()); getJdbcTemplate().update( "INSERT into BATCH_JOB_INSTANCE(JOB_INSTANCE_ID, JOB_NAME, VERSION, JOB_KEY)" + " values (?, ?, ?, ?)", jobInstance.getId(), jobInstance.getJobName(), jobInstance.getVersion(), jobKey); for (String key : jobInstance.getJobParameters().getParameters() .keySet()) { JobParameter jobParameter = jobInstance.getJobParameters() .getParameters().get(key); insertParameter(jobInstance.getId(), jobParameter.getType(), key, jobParameter.getValue()); } }
/** * */ @Test public final void testJobExecution() { Map<String, JobParameter> jobParametersMap = new HashMap<String, JobParameter>(); jobParametersMap.put("authority.name", new JobParameter("test")); JobInstance jobInstance = new JobInstance(1L, new JobParameters( jobParametersMap), "testJob"); jobInstance.setVersion(1); jobInstanceDao.save(jobInstance); JobExecution jobExecution = new JobExecution(jobInstance, 1L); jobExecution.setCreateTime(new Date()); jobExecutionDao.save(jobExecution); jobExecutionDao.delete(1L); jobInstanceDao.delete(1L); }