/** * Creates an in memory job store (<code>{@link RAMJobStore}</code>) * The thread priority is set to Thread.NORM_PRIORITY * * @param maxThreads * The number of threads in the thread pool * @throws SchedulerException * if initialization failed. */ public void createVolatileScheduler(int maxThreads) throws SchedulerException { SimpleThreadPool threadPool = new SimpleThreadPool(maxThreads, Thread.NORM_PRIORITY); JobStore jobStore = new RAMJobStore(); this.createScheduler(threadPool, jobStore); }
if (applyMisfire(tw)) { if (tw.trigger.getNextFireTime() != null) { timeTriggers.add(tw); tw.trigger.setFireInstanceId(getFiredTriggerRecordId()); OperableTrigger trig = (OperableTrigger) tw.trigger.clone(); if (result.isEmpty()) {
/** * <p> * Pause the <code>{@link org.quartz.JobDetail}</code> with the given * name - by pausing all of its current <code>Trigger</code>s. * </p> * */ public void pauseJob(JobKey jobKey) { synchronized (lock) { List<OperableTrigger> triggersOfJob = getTriggersForJob(jobKey); for (OperableTrigger trigger: triggersOfJob) { pauseTrigger(trigger.getKey()); } } }
/** * <p> * Store the given <code>{@link org.quartz.JobDetail}</code> and <code>{@link org.quartz.Trigger}</code>. * </p> * * @param newJob * The <code>JobDetail</code> to be stored. * @param newTrigger * The <code>Trigger</code> to be stored. * @throws ObjectAlreadyExistsException * if a <code>Job</code> with the same name/group already * exists. */ public void storeJobAndTrigger(JobDetail newJob, OperableTrigger newTrigger) throws JobPersistenceException { storeJob(newJob, false); storeTrigger(newTrigger, false); }
List<String> lst = getTriggerGroupNames(); for (String group: lst) { Set<TriggerKey> keys = getTriggerKeys(GroupMatcher.triggerGroupEquals(group)); for (TriggerKey key: keys) { removeTrigger(key); lst = getJobGroupNames(); for (String group: lst) { Set<JobKey> keys = getJobKeys(GroupMatcher.jobGroupEquals(group)); for (JobKey key: keys) { removeJob(key); lst = getCalendarNames(); for(String name: lst) { removeCalendar(name);
ArrayList<TriggerWrapper> trigs = getTriggerWrappersForJob(jd.getKey()); for(TriggerWrapper ttw : trigs) { if (ttw.state == TriggerWrapper.STATE_BLOCKED) { removeTrigger(trigger.getKey()); removeTrigger(trigger.getKey()); signaler.signalSchedulingChange(0L); signaler.signalSchedulingChange(0L); } else if(triggerInstCode == CompletedExecutionInstruction.SET_TRIGGER_ERROR) { getLog().info("Trigger " + trigger.getKey() + " set to ERROR state."); tw.state = TriggerWrapper.STATE_ERROR; signaler.signalSchedulingChange(0L); } else if (triggerInstCode == CompletedExecutionInstruction.SET_ALL_JOB_TRIGGERS_ERROR) { getLog().info("All triggers of Job " + trigger.getJobKey() + " set to ERROR state."); setAllTriggersOfJobToState(trigger.getJobKey(), TriggerWrapper.STATE_ERROR); signaler.signalSchedulingChange(0L); } else if (triggerInstCode == CompletedExecutionInstruction.SET_ALL_JOB_TRIGGERS_COMPLETE) { setAllTriggersOfJobToState(trigger.getJobKey(), TriggerWrapper.STATE_COMPLETE); signaler.signalSchedulingChange(0L);
super.storeJob(job, true); jobKeys.add(job.getKey()); continue; super.storeTrigger(trigger.trigger, true); super.pauseTrigger(trigger.trigger.getKey());
List<OperableTrigger> trigs = getTriggersForJob(tw.jobKey); if ((trigs == null || trigs.size() == 0) && !jw.jobDetail.isDurable()) { if (removeJob(jw.key)) { signaler.notifySchedulerListenersJobDeleted(jw.key);
/** * <p> * Resume (un-pause) the <code>{@link org.quartz.JobDetail}</code> with * the given name. * </p> * * <p> * If any of the <code>Job</code>'s<code>Trigger</code> s missed one * or more fire-times, then the <code>Trigger</code>'s misfire * instruction will be applied. * </p> * */ public void resumeJob(JobKey jobKey) { synchronized (lock) { List<OperableTrigger> triggersOfJob = getTriggersForJob(jobKey); for (OperableTrigger trigger: triggersOfJob) { resumeTrigger(trigger.getKey()); } } }
List<OperableTrigger> triggersOfJob = getTriggersForJob(jobKey); for (OperableTrigger trig: triggersOfJob) { this.removeTrigger(trig.getKey()); found = true;
removeTrigger(newTrigger.getKey(), false); if (retrieveJob(newTrigger.getJobKey()) == null) { throw new JobPersistenceException("The job (" + newTrigger.getJobKey()
public void storeJobsAndTriggers( Map<JobDetail, Set<? extends Trigger>> triggersAndJobs, boolean replace) throws JobPersistenceException { synchronized (lock) { // make sure there are no collisions... if(!replace) { for(Entry<JobDetail, Set<? extends Trigger>> e: triggersAndJobs.entrySet()) { if(checkExists(e.getKey().getKey())) throw new ObjectAlreadyExistsException(e.getKey()); for(Trigger trigger: e.getValue()) { if(checkExists(trigger.getKey())) throw new ObjectAlreadyExistsException(trigger); } } } // do bulk add... for(Entry<JobDetail, Set<? extends Trigger>> e: triggersAndJobs.entrySet()) { storeJob(e.getKey(), true); for(Trigger trigger: e.getValue()) { storeTrigger((OperableTrigger) trigger, true); } } } }
Set<String> resumedGroups = new HashSet<String>(); synchronized (lock) { Set<JobKey> keys = getJobKeys(matcher); List<OperableTrigger> triggersOfJob = getTriggersForJob(key); for (OperableTrigger trigger: triggersOfJob) { resumeTrigger(trigger.getKey());
for (JobKey jobKey: getJobKeys(GroupMatcher.jobGroupEquals(groupName))) { List<OperableTrigger> triggersOfJob = getTriggersForJob(jobKey); for (OperableTrigger trigger: triggersOfJob) { pauseTrigger(trigger.getKey());
/** * <p> * Pause all of the <code>{@link org.quartz.JobDetail}s</code> in the * given group - by pausing all of their <code>Trigger</code>s. * </p> * * * <p> * The JobStore should "remember" that the group is paused, and impose the * pause on any new jobs that are added to the group while the group is * paused. * </p> */ public void pauseJobGroup(SchedulingContext ctxt, String groupName) { synchronized (triggerLock) { if (!pausedJobGroups.contains(groupName)) { pausedJobGroups.add(groupName); } String[] jobNames = getJobNames(ctxt, groupName); for (int i = 0; i < jobNames.length; i++) { Trigger[] triggers = getTriggersForJob(ctxt, jobNames[i], groupName); for (int j = 0; j < triggers.length; j++) { pauseTrigger(ctxt, triggers[j].getName(), triggers[j].getGroup()); } } } }
/** * <p> * Resume (un-pause) all of the <code>{@link org.quartz.JobDetail}s</code> * in the given group. * </p> * * <p> * If any of the <code>Job</code> s had <code>Trigger</code> s that * missed one or more fire-times, then the <code>Trigger</code>'s * misfire instruction will be applied. * </p> * */ public void resumeJobGroup(SchedulingContext ctxt, String groupName) { synchronized (triggerLock) { String[] jobNames = getJobNames(ctxt, groupName); if(pausedJobGroups.contains(groupName)) { pausedJobGroups.remove(groupName); } for (int i = 0; i < jobNames.length; i++) { Trigger[] triggers = getTriggersForJob(ctxt, jobNames[i], groupName); for (int j = 0; j < triggers.length; j++) { resumeTrigger(ctxt, triggers[j].getName(), triggers[j].getGroup()); } } } }
.getJobNameKey(tw.trigger.getJobName(), tw.trigger .getJobGroup())); Trigger[] trigs = getTriggersForJob(ctxt, tw.trigger .getJobName(), tw.trigger.getJobGroup()); if ((trigs == null || trigs.length == 0) && !jw.jobDetail.isDurable()) { removeJob(ctxt, tw.trigger.getJobName(), tw.trigger .getJobGroup());
public boolean removeTriggers(List<TriggerKey> triggerKeys) throws JobPersistenceException { boolean allFound = true; synchronized (lock) { for(TriggerKey key: triggerKeys) allFound = removeTrigger(key) && allFound; } return allFound; }
storeTrigger(newTrigger, false); } catch(JobPersistenceException jpe) { storeTrigger(tw.getTrigger(), false); // put previous trigger back... throw jpe;
public boolean removeJobs(List<JobKey> jobKeys) throws JobPersistenceException { boolean allFound = true; synchronized (lock) { for(JobKey key: jobKeys) allFound = removeJob(key) && allFound; } return allFound; }