public void endpointActivation(MessageEndpointFactory endpointFactory, ActivationSpec spec)
throws ResourceException {
log.debug("endpointActivation, spec=" + spec);
QuartzActivationSpec quartzSpec = (QuartzActivationSpec) spec;
// allocate instance of endpoint to figure out its endpoint interface
Class clazz = QuartzJob.class;
MessageEndpoint tmpMe = endpointFactory.createEndpoint(null);
if (tmpMe instanceof StatefulJob) clazz = StatefulQuartzJob.class;
tmpMe.release();
try {
JobDetail jobDetail =
new JobDetail(
quartzSpec.getJobName(), quartzSpec.getJobGroup(), clazz, true, false, false);
jobDetail.getJobDataMap().setAllowsTransientData(true);
jobDetail.getJobDataMap().put("endpointFactory", endpointFactory);
log.debug("adding job: " + quartzSpec);
CronTrigger trigger =
new CronTrigger(
quartzSpec.getTriggerName(),
quartzSpec.getTriggerGroup(),
quartzSpec.getCronTrigger());
sched.scheduleJob(jobDetail, trigger);
} catch (Exception e) {
log.error(e);
throw new ResourceException(e);
}
}
@Test
public void getLastSavedJobTest() throws FileNotFoundException {
JobDetail lastJob = LogFiles.getLastSavedJob(folderPath, printerName);
assertEquals(1635, lastJob.getJobNumber());
}
public RunTimeJobDetail scheduleJob(JobDetail jobDetail, Trigger trigger)
throws SchedulerException, JobAlreadyExistsException {
if (quartzScheduler.checkExists(jobDetail.getKey()))
throw new JobAlreadyExistsException(jobDetail.getKey().getName() + " already exists");
quartzScheduler.scheduleJob(jobDetail, trigger);
return getJobDetails(jobDetail.getKey().getGroup(), jobDetail.getKey().getName());
}
@Override
public ScheduleToken schedule(Instant triggerDateTime, Object event) {
Assert.state(initialized, () -> "Scheduler is not yet initialized");
EventMessage eventMessage = GenericEventMessage.asEventMessage(event);
String jobIdentifier = JOB_NAME_PREFIX + eventMessage.getIdentifier();
QuartzScheduleToken tr = new QuartzScheduleToken(jobIdentifier, groupIdentifier);
try {
JobDetail jobDetail =
buildJobDetail(eventMessage, new JobKey(jobIdentifier, groupIdentifier));
scheduler.scheduleJob(jobDetail, buildTrigger(triggerDateTime, jobDetail.getKey()));
} catch (SchedulerException e) {
throw new SchedulingException("An error occurred while setting a timer for a saga", e);
}
return tr;
}
/**
* 从Scheduler 移除当前的Job,修改Trigger
*
* @param jobDetail
* @param time
* @throws SchedulerException
* @throws ParseException
*/
public static void modifyJobTime(JobDetail jobDetail, String time)
throws SchedulerException, ParseException {
Scheduler sched = sf.getScheduler();
Trigger trigger = sched.getTrigger(jobDetail.getName(), TRIGGER_GROUP_NAME);
if (trigger != null) {
CronTrigger ct = (CronTrigger) trigger;
// 移除当前进程的Job
sched.deleteJob(jobDetail.getName(), jobDetail.getGroup());
// 修改Trigger
ct.setCronExpression(time);
System.out.println("CronTrigger getName " + ct.getJobName());
// 重新调度jobDetail
sched.scheduleJob(jobDetail, ct);
}
}
protected void updateScheduledRouteDetails(
Action action, JobDetail jobDetail, Trigger trigger, Route route) throws Exception {
ScheduledRouteDetails scheduledRouteDetails = getScheduledRouteDetails(route.getId());
if (action == Action.START) {
scheduledRouteDetails.setStartJobKey(jobDetail.getKey());
scheduledRouteDetails.setStartTriggerKey(trigger.getKey());
} else if (action == Action.STOP) {
scheduledRouteDetails.setStopJobKey(jobDetail.getKey());
scheduledRouteDetails.setStopTriggerKey(trigger.getKey());
} else if (action == Action.SUSPEND) {
scheduledRouteDetails.setSuspendJobKey(jobDetail.getKey());
scheduledRouteDetails.setSuspendTriggerKey(trigger.getKey());
} else if (action == Action.RESUME) {
scheduledRouteDetails.setResumeJobKey(jobDetail.getKey());
scheduledRouteDetails.setResumeTriggerKey(trigger.getKey());
}
}
public static void startJob(String jobName, Job job, String time)
throws SchedulerException, ParseException {
Scheduler sched = sf.getScheduler();
JobDetail jobDetail = new JobDetail();
jobDetail.setName(jobName);
jobDetail.setGroup(JOB_GROUP_NAME);
jobDetail.setJobClass(job.getClass());
CronTrigger trigger = new CronTrigger(jobName, TRIGGER_GROUP_NAME);
trigger.setCronExpression(time);
sched.scheduleJob(jobDetail, trigger);
if (!sched.isShutdown()) {
sched.start();
}
}
@Override
public boolean equals(Object obj) {
if (!(obj instanceof JobDetail)) {
return false;
}
JobDetail other = (JobDetail) obj;
if (other.getName() == null || getName() == null) {
return false;
}
if (!other.getName().equals(getName())) {
return false;
}
return true;
}
private void startJobs() {
try {
// Get a new scheduler
scheduler = new StdSchedulerFactory().getScheduler();
// Start it up. This won't start any jobs though.
scheduler.start();
for (GuanxiJobConfig gxJob : gxJobs) {
// Need a new JobDetail to hold custom data to send to the job we're controlling
JobDetail jobDetail =
new JobDetail(
gxJob.getKey(), Scheduler.DEFAULT_GROUP, Class.forName(gxJob.getJobClass()));
// Create a new JobDataMap for custom data to be sent to the job...
JobDataMap jobDataMap = new JobDataMap();
// ...and add the job's custom config object
jobDataMap.put(GuanxiJobConfig.JOB_KEY_JOB_CONFIG, gxJob);
// Put the job's custom data in it's JobDetail
jobDetail.setJobDataMap(jobDataMap);
/* Tell the scheduler when this job will run. Nothing will happen
* until the start method is called.
*/
Trigger trigger =
new CronTrigger(gxJob.getKey(), Scheduler.DEFAULT_GROUP, gxJob.getCronLine());
// Start the job
scheduler.scheduleJob(jobDetail, trigger);
if (gxJob.isStartImmediately()) {
scheduler.triggerJob(gxJob.getKey(), Scheduler.DEFAULT_GROUP);
}
}
} catch (ClassNotFoundException cnfe) {
logger.error("Error locating job class", cnfe);
} catch (SchedulerException se) {
logger.error("Job scheduling error", se);
} catch (ParseException pe) {
logger.error("Error parsing job cronline", pe);
}
}
protected void loadCallbackDataIntoSchedulerContext(
JobDetail jobDetail, Action action, Route route) throws SchedulerException {
getScheduler()
.getContext()
.put(jobDetail.getKey().toString(), new ScheduledJobState(action, route));
}
public void run() throws Exception {
Logger log = LoggerFactory.getLogger(JobStateExample.class);
log.info("------- Initializing -------------------");
// First we must get a reference to a scheduler
SchedulerFactory sf = new StdSchedulerFactory();
Scheduler sched = sf.getScheduler();
log.info("------- Initialization Complete --------");
log.info("------- Scheduling Jobs ----------------");
// get a "nice round" time a few seconds in the future....
Date startTime = nextGivenSecondDate(null, 10);
// job1 will only run 5 times (at start time, plus 4 repeats), every 10 seconds
JobDetail job1 = newJob(ColorJob.class).withIdentity("job1", "group1").build();
SimpleTrigger trigger1 =
newTrigger()
.withIdentity("trigger1", "group1")
.startAt(startTime)
.withSchedule(simpleSchedule().withIntervalInSeconds(10).withRepeatCount(4))
.build();
// pass initialization parameters into the job
job1.getJobDataMap().put(ColorJob.FAVORITE_COLOR, "Green");
job1.getJobDataMap().put(ColorJob.EXECUTION_COUNT, 1);
// schedule the job to run
Date scheduleTime1 = sched.scheduleJob(job1, trigger1);
log.info(
job1.getKey()
+ " will run at: "
+ scheduleTime1
+ " and repeat: "
+ trigger1.getRepeatCount()
+ " times, every "
+ trigger1.getRepeatInterval() / 1000
+ " seconds");
// job2 will also run 5 times, every 10 seconds
JobDetail job2 = newJob(ColorJob.class).withIdentity("job2", "group1").build();
SimpleTrigger trigger2 =
newTrigger()
.withIdentity("trigger2", "group1")
.startAt(startTime)
.withSchedule(simpleSchedule().withIntervalInSeconds(10).withRepeatCount(4))
.build();
// pass initialization parameters into the job
// this job has a different favorite color!
job2.getJobDataMap().put(ColorJob.FAVORITE_COLOR, "Red");
job2.getJobDataMap().put(ColorJob.EXECUTION_COUNT, 1);
// schedule the job to run
Date scheduleTime2 = sched.scheduleJob(job2, trigger2);
log.info(
job2.getKey().toString()
+ " will run at: "
+ scheduleTime2
+ " and repeat: "
+ trigger2.getRepeatCount()
+ " times, every "
+ trigger2.getRepeatInterval() / 1000
+ " seconds");
log.info("------- Starting Scheduler ----------------");
// All of the jobs have been added to the scheduler, but none of the jobs
// will run until the scheduler has been started
sched.start();
log.info("------- Started Scheduler -----------------");
log.info("------- Waiting 60 seconds... -------------");
try {
// wait five minutes to show jobs
Thread.sleep(60L * 1000L);
// executing...
} catch (Exception e) {
//
}
log.info("------- Shutting Down ---------------------");
sched.shutdown(true);
log.info("------- Shutdown Complete -----------------");
SchedulerMetaData metaData = sched.getMetaData();
log.info("Executed " + metaData.getNumberOfJobsExecuted() + " jobs.");
}
/** Initialize each job. */
protected void initializeJobs(Session jcrSession) {
Collection<KKStoreConfig> kkStoreConfigs =
HippoModuleConfig.getConfig().getStoresConfig().values();
if (kkStoreConfigs.size() == 0) {
log.error("No store config has been found. Please check the konakart:konakart configuration");
return;
}
// Get the first one.
KKStoreConfig kkStoreConfig = kkStoreConfigs.iterator().next();
try {
String triggerName = MASS_SYNC_JOB_TRIGGER;
String jobName = MASS_SYNC_JOB_ONCE;
JobDetail jobDetail =
new JobDetail(jobName, MASS_SYNC_JOB_GROUP, Class.forName(kkStoreConfig.getJobClass()));
JobDataMap dataMap = new JobDataMap();
jobDetail.setJobDataMap(dataMap);
// Create a trigger that fires immediately, and run only once
Trigger trigger = new SimpleTrigger(MASS_SYNC_JOB_TRIGGER_ONCE);
trigger.setStartTime(new Date(System.currentTimeMillis() + 10000));
if (!triggerExists(trigger)) {
resourceScheduler.scheduleJob(jobDetail, trigger);
}
jobName = MASS_SYNC_JOB;
jobDetail =
new JobDetail(jobName, MASS_SYNC_JOB_GROUP, Class.forName(kkStoreConfig.getJobClass()));
// Create the cron task. The first launch is scheduled after 30 minutes
if (StringUtils.isNotEmpty(kkStoreConfig.getCronExpression())) {
trigger =
new CronTrigger(
triggerName,
MASS_SYNC_JOB_TRIGGER_GROUP,
jobName,
MASS_SYNC_JOB_GROUP,
kkStoreConfig.getCronExpression());
trigger.setStartTime(new Date(System.currentTimeMillis() + 1000));
if (triggerExists(trigger)) {
if (triggerChanged(trigger)) {
resourceScheduler.rescheduleJob(
MASS_SYNC_JOB_TRIGGER, MASS_SYNC_JOB_TRIGGER_GROUP, trigger);
}
} else {
resourceScheduler.scheduleJob(jobDetail, trigger);
}
}
} catch (ClassNotFoundException e) {
log.error("Failed to find the Job class named - " + kkStoreConfig.getJobClass(), e);
} catch (ParseException e) {
log.error("Failed to parse the cron expression - " + kkStoreConfig.getCronExpression(), e);
} catch (SchedulerException e) {
log.error("Failed to start the job", e);
}
}
/**
* Refreshes the job schedule with the current list of enabled jobs of the type to be scheduled.
*
* @param scheduler The scheduler to update.
* @return The updated scheduler.
*/
protected Scheduler _refreshJobSchedule(Scheduler scheduler) {
_disposeScheduler(scheduler);
String schedulerName = null;
Properties props = new Properties();
// Set quartz worker thread properties
props.put(
QUARTZ_THREADPOOL_COUNT,
_configuration.getValue(
Property.QUARTZ_THREADPOOL_COUNT.getName(),
Property.QUARTZ_THREADPOOL_COUNT.getDefaultValue()));
props.put(QUARTZ_THREAD_PRIORITY, QUARTZ_THREAD_PRIORITY_VALUE);
props.put(
StdSchedulerFactory
.PROP_SCHED_SCHEDULER_THREADS_INHERIT_CONTEXT_CLASS_LOADER_OF_INITIALIZING_THREAD,
true);
/* Have multiple scheduler instances for different job types, so that when
* we stop the previous instance of a scheduler during the refresh cycle it does not affect another scheduler.
*/
switch (Thread.currentThread().getName()) {
case "schedule-alerts":
default:
schedulerName = "AlertScheduler";
}
props.put(StdSchedulerFactory.PROP_SCHED_INSTANCE_NAME, schedulerName);
SchedulerFactory schedulerFactory;
Scheduler result = null;
try {
schedulerFactory = new StdSchedulerFactory(props);
result = schedulerFactory.getScheduler();
} catch (Exception e) {
_logger.error("Exception in setting up scheduler: {}", e);
return result;
}
for (CronJob job : getEnabledJobs()) {
_logger.debug("Adding job to scheduler: {}", job);
try {
// Convert from linux cron to quartz cron expression
String quartzCronEntry =
"0 " + job.getCronEntry().substring(0, job.getCronEntry().length() - 1) + "?";
JobDetail jobDetail = JobBuilder.newJob(RunnableJob.class).build();
CronTrigger cronTrigger =
TriggerBuilder.newTrigger()
.withSchedule(CronScheduleBuilder.cronSchedule(quartzCronEntry))
.build();
// Pass parameter to quartz worker threads
jobDetail.getJobDataMap().put(RunnableJob.CRON_JOB, job);
jobDetail.getJobDataMap().put(RunnableJob.LOCK_TYPE, lockType);
jobDetail.getJobDataMap().put("AlertService", _alertService);
jobDetail.getJobDataMap().put("AuditService", _auditService);
result.scheduleJob(jobDetail, cronTrigger);
} catch (Exception ex) {
String msg = "Failed to schedule job {0} : {1}";
JPAEntity entity = JPAEntity.class.cast(job);
_auditService.createAudit(msg, entity, entity, ex.getMessage());
_logger.error("Failed to schedule job {} : {}", job, ex.getMessage());
}
}
try {
result.start();
} catch (SchedulerException e) {
_logger.error("Exception in starting scheduler: {}", e);
}
_logger.info("Job schedule refreshed.");
return result;
}
