Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.quartz.simpl
Class RAMJobStore

    java.lang.Object
      org.quartz.simpl.RAMJobStore

All Implemented Interfaces:
  JobStore

    public class RAMJobStore

extends Object
implements JobStore

This class implements a ``JobStore`` that utilizes RAM as its storage device.

As you should know, the ramification of this is that access is extrememly fast, but the data is completely volatile - therefore this `JobStore` should not be used if true persistence between program shutdowns is required.

Author:
  James House, Sharada Jambula, Eric Mueller

Field Summary
`protected HashSet<JobKey>` | `blockedJobs`
`protected HashMap<String,Calendar>` | `calendarsByName`
`protected HashMap<String,HashMap<JobKey,org.quartz.simpl.JobWrapper>>` | `jobsByGroup`
`protected HashMap<JobKey,org.quartz.simpl.JobWrapper>` | `jobsByKey`
`protected Object` | `lock`
`protected long` | `misfireThreshold`
`protected HashSet<String>` | `pausedJobGroups`
`protected HashSet<String>` | `pausedTriggerGroups`
`protected SchedulerSignaler` | `signaler`
`protected TreeSet<org.quartz.simpl.TriggerWrapper>` | `timeTriggers`
`protected ArrayList<org.quartz.simpl.TriggerWrapper>` | `triggers`
`protected HashMap<String,HashMap<TriggerKey,org.quartz.simpl.TriggerWrapper>>` | `triggersByGroup`
`protected HashMap<TriggerKey,org.quartz.simpl.TriggerWrapper>` | `triggersByKey`

Constructor Summary
`RAMJobStore()` Create a new `RAMJobStore`.

Method Summary
`List<OperableTrigger>` | `acquireNextTriggers(long noLaterThan, int maxCount, long timeWindow)` Get a handle to the next trigger to be fired, and mark it as 'reserved' by the calling scheduler.
`protected boolean` | `applyMisfire(org.quartz.simpl.TriggerWrapper tw)`
`boolean` | `checkExists(JobKey jobKey)` Determine whether a `Job` with the given identifier already exists within the scheduler.
`boolean` | `checkExists(TriggerKey triggerKey)` Determine whether a `Trigger` with the given identifier already exists within the scheduler.
`void` | `clearAllSchedulingData()` Clear (delete!) all scheduling data - all `Job`s, `Trigger`s `Calendar`s.
`List<String>` | `getCalendarNames()` Get the names of all of the ``Calendar`` s in the `JobStore`.
`long` | `getEstimatedTimeToReleaseAndAcquireTrigger()` How long (in milliseconds) the `JobStore` implementation estimates that it will take to release a trigger and acquire a new one.
`protected String` | `getFiredTriggerRecordId()`
`List<String>` | `getJobGroupNames()` Get the names of all of the ``Job`` groups.
`Set<JobKey>` | `getJobKeys(GroupMatcher<JobKey> matcher)` Get the names of all of the ``Job`` s that match the given groupMatcher.
`protected org.slf4j.Logger` | `getLog()`
`long` | `getMisfireThreshold()`
`int` | `getNumberOfCalendars()` Get the number of ``Calendar`` s that are stored in the `JobsStore`.
`int` | `getNumberOfJobs()` Get the number of ``JobDetail`` s that are stored in the `JobsStore`.
`int` | `getNumberOfTriggers()` Get the number of ``Trigger`` s that are stored in the `JobsStore`.
`Set<String>` | `getPausedTriggerGroups()`
`List<String>` | `getTriggerGroupNames()` Get the names of all of the ``Trigger`` groups.
`Set<TriggerKey>` | `getTriggerKeys(GroupMatcher<TriggerKey> matcher)` Get the names of all of the ``Trigger`` s that match the given groupMatcher.
`List<OperableTrigger>` | `getTriggersForJob(JobKey jobKey)` Get all of the Triggers that are associated to the given Job.
`Trigger.TriggerState` | `getTriggerState(TriggerKey triggerKey)` Get the current state of the identified ``Trigger``.
`protected ArrayList<org.quartz.simpl.TriggerWrapper>` | `getTriggerWrappersForCalendar(String calName)`
`protected ArrayList<org.quartz.simpl.TriggerWrapper>` | `getTriggerWrappersForJob(JobKey jobKey)`
`void` | `initialize(ClassLoadHelper loadHelper, SchedulerSignaler schedSignaler)` Called by the QuartzScheduler before the `JobStore` is used, in order to give the it a chance to initialize.
`boolean` | `isClustered()` Whether or not the `JobStore` implementation is clustered.
`void` | `pauseAll()` Pause all triggers - equivalent of calling `pauseTriggerGroup(group)` on every group.
`void` | `pauseJob(JobKey jobKey)` Pause the ``JobDetail`` with the given name - by pausing all of its current `Trigger`s.
`List<String>` | `pauseJobs(GroupMatcher<JobKey> matcher)` Pause all of the ``JobDetail`s` in the given group - by pausing all of their `Trigger`s.
`void` | `pauseTrigger(TriggerKey triggerKey)` Pause the ``Trigger`` with the given name.
`List<String>` | `pauseTriggers(GroupMatcher<TriggerKey> matcher)` Pause all of the known ``Trigger`s` matching.
`protected String` | `peekTriggers()`
`void` | `releaseAcquiredTrigger(OperableTrigger trigger)` Inform the `JobStore` that the scheduler no longer plans to fire the given `Trigger`, that it had previously acquired (reserved).
`boolean` | `removeCalendar(String calName)` Remove (delete) the ``Calendar`` with the given name.
`boolean` | `removeJob(JobKey jobKey)` Remove (delete) the ``Job`` with the given name, and any ``Trigger`` s that reference it.
`boolean` | `removeJobs(List<JobKey> jobKeys)`
`boolean` | `removeTrigger(TriggerKey triggerKey)` Remove (delete) the ``Trigger`` with the given name.
`boolean` | `removeTriggers(List<TriggerKey> triggerKeys)`
`boolean` | `replaceTrigger(TriggerKey triggerKey, OperableTrigger newTrigger)` Remove (delete) the ``Trigger`` with the given key, and store the new given one - which must be associated with the same job.
`void` | `resumeAll()` Resume (un-pause) all triggers - equivalent of calling `resumeTriggerGroup(group)` on every group.
`void` | `resumeJob(JobKey jobKey)` Resume (un-pause) the ``JobDetail`` with the given name.
`Collection<String>` | `resumeJobs(GroupMatcher<JobKey> matcher)` Resume (un-pause) all of the ``JobDetail`s` in the given group.
`void` | `resumeTrigger(TriggerKey triggerKey)` Resume (un-pause) the ``Trigger`` with the given key.
`List<String>` | `resumeTriggers(GroupMatcher<TriggerKey> matcher)` Resume (un-pause) all of the ``Trigger`s` in the given group.
`Calendar` | `retrieveCalendar(String calName)` Retrieve the given ``Trigger``.
`JobDetail` | `retrieveJob(JobKey jobKey)` Retrieve the ``JobDetail`` for the given ``Job``.
`OperableTrigger` | `retrieveTrigger(TriggerKey triggerKey)` Retrieve the given ``Trigger``.
`void` | `schedulerPaused()` Called by the QuartzScheduler to inform the `JobStore` that the scheduler has been paused.
`void` | `schedulerResumed()` Called by the QuartzScheduler to inform the `JobStore` that the scheduler has resumed after being paused.
`void` | `schedulerStarted()` Called by the QuartzScheduler to inform the `JobStore` that the scheduler has started.
`protected void` | `setAllTriggersOfJobToState(JobKey jobKey, int state)`
`void` | `setInstanceId(String schedInstId)` Inform the `JobStore` of the Scheduler instance's Id, prior to initialize being invoked.
`void` | `setInstanceName(String schedName)` Inform the `JobStore` of the Scheduler instance's name, prior to initialize being invoked.
`void` | `setMisfireThreshold(long misfireThreshold)` The number of milliseconds by which a trigger must have missed its next-fire-time, in order for it to be considered "misfired" and thus have its misfire instruction applied.
`void` | `setThreadPoolSize(int poolSize)` Tells the JobStore the pool size used to execute jobs
`void` | `shutdown()` Called by the QuartzScheduler to inform the `JobStore` that it should free up all of it's resources because the scheduler is shutting down.
`void` | `storeCalendar(String name, Calendar calendar, boolean replaceExisting, boolean updateTriggers)` Store the given ``Calendar``.
`void` | `storeJob(JobDetail newJob, boolean replaceExisting)` Store the given ``Job``.
`void` | `storeJobAndTrigger(JobDetail newJob, OperableTrigger newTrigger)` Store the given ``JobDetail`` and ``Trigger``.
`void` | `storeJobsAndTriggers(Map<JobDetail,Set<? extends Trigger>> triggersAndJobs, boolean replace)`
`void` | `storeTrigger(OperableTrigger newTrigger, boolean replaceExisting)` Store the given ``Trigger``.
`boolean` | `supportsPersistence()`
`void` | `triggeredJobComplete(OperableTrigger trigger, JobDetail jobDetail, Trigger.CompletedExecutionInstruction triggerInstCode)` Inform the `JobStore` that the scheduler has completed the firing of the given `Trigger` (and the execution its associated `Job`), and that the ``JobDataMap`` in the given `JobDetail` should be updated if the `Job` is stateful.
`List<TriggerFiredResult>` | `triggersFired(List<OperableTrigger> firedTriggers)` Inform the `JobStore` that the scheduler is now firing the given `Trigger` (executing its associated `Job`), that it had previously acquired (reserved).

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### jobsByKey

    protected HashMap<JobKey,org.quartz.simpl.JobWrapper> jobsByKey

### triggersByKey

    protected HashMap<TriggerKey,org.quartz.simpl.TriggerWrapper> triggersByKey

### jobsByGroup

    protected HashMap<String,HashMap<JobKey,org.quartz.simpl.JobWrapper>> jobsByGroup

### triggersByGroup

    protected HashMap<String,HashMap<TriggerKey,org.quartz.simpl.TriggerWrapper>> triggersByGroup

### timeTriggers

    protected TreeSet<org.quartz.simpl.TriggerWrapper> timeTriggers

### calendarsByName

    protected HashMap<String,Calendar> calendarsByName

### triggers

    protected ArrayList<org.quartz.simpl.TriggerWrapper> triggers

### lock

    protected final Object lock

### pausedTriggerGroups

    protected HashSet<String> pausedTriggerGroups

### pausedJobGroups

    protected HashSet<String> pausedJobGroups

### blockedJobs

    protected HashSet<JobKey> blockedJobs

### misfireThreshold

    protected long misfireThreshold

### signaler

    protected SchedulerSignaler signaler

Constructor Detail

### RAMJobStore

    public RAMJobStore()

  Create a new `RAMJobStore`.

Method Detail

### getLog

    protected org.slf4j.Logger getLog()

### initialize

    public void initialize(ClassLoadHelper loadHelper,
                           SchedulerSignaler schedSignaler)

  Called by the QuartzScheduler before the `JobStore` is used, in order to give the it a chance to initialize.

  Specified by:
    `initialize` in interface `JobStore`

### schedulerStarted

    public void schedulerStarted()

  Description copied from interface: `JobStore`
  Called by the QuartzScheduler to inform the `JobStore` that the scheduler has started.

  Specified by:
    `schedulerStarted` in interface `JobStore`

### schedulerPaused

    public void schedulerPaused()

  Description copied from interface: `JobStore`
  Called by the QuartzScheduler to inform the `JobStore` that the scheduler has been paused.

  Specified by:
    `schedulerPaused` in interface `JobStore`

### schedulerResumed

    public void schedulerResumed()

  Description copied from interface: `JobStore`
  Called by the QuartzScheduler to inform the `JobStore` that the scheduler has resumed after being paused.

  Specified by:
    `schedulerResumed` in interface `JobStore`

### getMisfireThreshold

    public long getMisfireThreshold()

### setMisfireThreshold

    public void setMisfireThreshold(long misfireThreshold)

  The number of milliseconds by which a trigger must have missed its next-fire-time, in order for it to be considered "misfired" and thus have its misfire instruction applied.

  Parameters:
    `misfireThreshold` - the new misfire threshold

### shutdown

    public void shutdown()

  Called by the QuartzScheduler to inform the `JobStore` that it should free up all of it's resources because the scheduler is shutting down.

  Specified by:
    `shutdown` in interface `JobStore`

### supportsPersistence

    public boolean supportsPersistence()

  Specified by:
    `supportsPersistence` in interface `JobStore`

### clearAllSchedulingData

    public void clearAllSchedulingData()
                                throws JobPersistenceException

  Clear (delete!) all scheduling data - all `Job`s, `Trigger`s `Calendar`s.

  Specified by:
    `clearAllSchedulingData` in interface `JobStore`
  Throws:
    `JobPersistenceException`

### storeJobAndTrigger

    public void storeJobAndTrigger(JobDetail newJob,
                                   OperableTrigger newTrigger)
                            throws JobPersistenceException

  Store the given ``JobDetail`` and ``Trigger``.

  Specified by:
    `storeJobAndTrigger` in interface `JobStore`
  Parameters:
    `newJob` - The `JobDetail` to be stored.
    `newTrigger` - The `Trigger` to be stored.
  Throws:
    `ObjectAlreadyExistsException` - if a `Job` with the same name/group already exists.
    `JobPersistenceException`

### storeJob

    public void storeJob(JobDetail newJob,
                         boolean replaceExisting)
                  throws ObjectAlreadyExistsException

  Store the given ``Job``.

  Specified by:
    `storeJob` in interface `JobStore`
  Parameters:
    `newJob` - The `Job` to be stored.
    `replaceExisting` - If `true`, any `Job` existing in the `JobStore` with the same name & group should be over-written.
  Throws:
    `ObjectAlreadyExistsException` - if a `Job` with the same name/group already exists, and replaceExisting is set to false.

### removeJob

    public boolean removeJob(JobKey jobKey)

  Remove (delete) the ``Job`` with the given name, and any ``Trigger`` s that reference it.

  Specified by:
    `removeJob` in interface `JobStore`
  Returns:
    `true` if a `Job` with the given name & group was found and removed from the store.

### removeJobs

    public boolean removeJobs(List<JobKey> jobKeys)
                       throws JobPersistenceException

  Specified by:
    `removeJobs` in interface `JobStore`
  Throws:
    `JobPersistenceException`

### removeTriggers

    public boolean removeTriggers(List<TriggerKey> triggerKeys)
                           throws JobPersistenceException

  Specified by:
    `removeTriggers` in interface `JobStore`
  Throws:
    `JobPersistenceException`

### storeJobsAndTriggers

    public void storeJobsAndTriggers(Map<JobDetail,Set<? extends Trigger>> triggersAndJobs,
                                     boolean replace)
                              throws JobPersistenceException

  Specified by:
    `storeJobsAndTriggers` in interface `JobStore`
  Throws:
    `JobPersistenceException`

### storeTrigger

    public void storeTrigger(OperableTrigger newTrigger,
                             boolean replaceExisting)
                      throws JobPersistenceException

  Store the given ``Trigger``.

  Specified by:
    `storeTrigger` in interface `JobStore`
  Parameters:
    `newTrigger` - The `Trigger` to be stored.
    `replaceExisting` - If `true`, any `Trigger` existing in the `JobStore` with the same name & group should be over-written.
  Throws:
    `ObjectAlreadyExistsException` - if a `Trigger` with the same name/group already exists, and replaceExisting is set to false.
    `JobPersistenceException`
  See Also:
    `pauseTriggers(org.quartz.impl.matchers.GroupMatcher)`

### removeTrigger

    public boolean removeTrigger(TriggerKey triggerKey)

  Remove (delete) the ``Trigger`` with the given name.

  Specified by:
    `removeTrigger` in interface `JobStore`
  Returns:
    `true` if a `Trigger` with the given name & group was found and removed from the store.

### replaceTrigger

    public boolean replaceTrigger(TriggerKey triggerKey,
                                  OperableTrigger newTrigger)
                           throws JobPersistenceException

  Description copied from interface: `JobStore`
  Remove (delete) the ``Trigger`` with the given key, and store the new given one - which must be associated with the same job.

  Specified by:
    `replaceTrigger` in interface `JobStore`
    `newTrigger` - The new `Trigger` to be stored.
  Returns:
    `true` if a `Trigger` with the given name & group was found and removed from the store.
  Throws:
    `JobPersistenceException`
  See Also:
    `JobStore.replaceTrigger(TriggerKey triggerKey, OperableTrigger newTrigger)`

### retrieveJob

    public JobDetail retrieveJob(JobKey jobKey)

  Retrieve the ``JobDetail`` for the given ``Job``.

  Specified by:
    `retrieveJob` in interface `JobStore`
  Returns:
    The desired `Job`, or null if there is no match.

### retrieveTrigger

    public OperableTrigger retrieveTrigger(TriggerKey triggerKey)

  Retrieve the given ``Trigger``.

  Specified by:
    `retrieveTrigger` in interface `JobStore`
  Returns:
    The desired `Trigger`, or null if there is no match.

### checkExists

    public boolean checkExists(JobKey jobKey)
                        throws JobPersistenceException

  Determine whether a `Job` with the given identifier already exists within the scheduler.

  Specified by:
    `checkExists` in interface `JobStore`
  Parameters:
    `jobKey` - the identifier to check for
  Returns:
    true if a Job exists with the given identifier
  Throws:
    `JobPersistenceException`

### checkExists

    public boolean checkExists(TriggerKey triggerKey)
                        throws JobPersistenceException

  Determine whether a `Trigger` with the given identifier already exists within the scheduler.

  Specified by:
    `checkExists` in interface `JobStore`
  Parameters:
    `triggerKey` - the identifier to check for
  Returns:
    true if a Trigger exists with the given identifier
  Throws:
    `JobPersistenceException`

### getTriggerState

    public Trigger.TriggerState getTriggerState(TriggerKey triggerKey)
                                         throws JobPersistenceException

  Get the current state of the identified ``Trigger``.

  Specified by:
    `getTriggerState` in interface `JobStore`
  Throws:
    `JobPersistenceException`
  See Also:
    `Trigger.TriggerState.NORMAL`, `Trigger.TriggerState.PAUSED`, `Trigger.TriggerState.COMPLETE`, `Trigger.TriggerState.ERROR`, `Trigger.TriggerState.BLOCKED`, `Trigger.TriggerState.NONE`

### storeCalendar

    public void storeCalendar(String name,
                              Calendar calendar,
                              boolean replaceExisting,
                              boolean updateTriggers)
                       throws ObjectAlreadyExistsException

  Store the given ``Calendar``.

  Specified by:
    `storeCalendar` in interface `JobStore`
  Parameters:
    `calendar` - The `Calendar` to be stored.
    `replaceExisting` - If `true`, any `Calendar` existing in the `JobStore` with the same name & group should be over-written.
    `updateTriggers` - If `true`, any `Trigger`s existing in the `JobStore` that reference an existing Calendar with the same name with have their next fire time re-computed with the new `Calendar`.
  Throws:
    `ObjectAlreadyExistsException` - if a `Calendar` with the same name already exists, and replaceExisting is set to false.

### removeCalendar

    public boolean removeCalendar(String calName)
                           throws JobPersistenceException

  Remove (delete) the ``Calendar`` with the given name.

  If removal of the `Calendar` would result in `Trigger`s pointing to non-existent calendars, then a `JobPersistenceException` will be thrown.

  *

  Specified by:
    `removeCalendar` in interface `JobStore`
  Parameters:
    `calName` - The name of the `Calendar` to be removed.
  Returns:
    `true` if a `Calendar` with the given name was found and removed from the store.
  Throws:
    `JobPersistenceException`

### retrieveCalendar

    public Calendar retrieveCalendar(String calName)

  Retrieve the given ``Trigger``.

  Specified by:
    `retrieveCalendar` in interface `JobStore`
  Parameters:
    `calName` - The name of the `Calendar` to be retrieved.
  Returns:
    The desired `Calendar`, or null if there is no match.

### getNumberOfJobs

    public int getNumberOfJobs()

  Get the number of ``JobDetail`` s that are stored in the `JobsStore`.

  Specified by:
    `getNumberOfJobs` in interface `JobStore`

### getNumberOfTriggers

    public int getNumberOfTriggers()

  Get the number of ``Trigger`` s that are stored in the `JobsStore`.

  Specified by:
    `getNumberOfTriggers` in interface `JobStore`

### getNumberOfCalendars

    public int getNumberOfCalendars()

  Get the number of ``Calendar`` s that are stored in the `JobsStore`.

  Specified by:
    `getNumberOfCalendars` in interface `JobStore`

### getJobKeys

    public Set<JobKey> getJobKeys(GroupMatcher<JobKey> matcher)

  Get the names of all of the ``Job`` s that match the given groupMatcher.

  Specified by:
    `getJobKeys` in interface `JobStore`

### getCalendarNames

    public List<String> getCalendarNames()

  Get the names of all of the ``Calendar`` s in the `JobStore`.

  If there are no Calendars in the given group name, the result should be a zero-length array (not `null`).

  Specified by:
    `getCalendarNames` in interface `JobStore`

### getTriggerKeys

    public Set<TriggerKey> getTriggerKeys(GroupMatcher<TriggerKey> matcher)

  Get the names of all of the ``Trigger`` s that match the given groupMatcher.

  Specified by:
    `getTriggerKeys` in interface `JobStore`

### getJobGroupNames

    public List<String> getJobGroupNames()

  Get the names of all of the ``Job`` groups.

  Specified by:
    `getJobGroupNames` in interface `JobStore`

### getTriggerGroupNames

    public List<String> getTriggerGroupNames()

  Get the names of all of the ``Trigger`` groups.

  Specified by:
    `getTriggerGroupNames` in interface `JobStore`

### getTriggersForJob

    public List<OperableTrigger> getTriggersForJob(JobKey jobKey)

  Get all of the Triggers that are associated to the given Job.

  If there are no matches, a zero-length array should be returned.

  Specified by:
    `getTriggersForJob` in interface `JobStore`

### getTriggerWrappersForJob

    protected ArrayList<org.quartz.simpl.TriggerWrapper> getTriggerWrappersForJob(JobKey jobKey)

### getTriggerWrappersForCalendar

    protected ArrayList<org.quartz.simpl.TriggerWrapper> getTriggerWrappersForCalendar(String calName)

### pauseTrigger

    public void pauseTrigger(TriggerKey triggerKey)

  Pause the ``Trigger`` with the given name.

  Specified by:
    `pauseTrigger` in interface `JobStore`
  See Also:
    `JobStore.resumeTrigger(TriggerKey)`

### pauseTriggers

    public List<String> pauseTriggers(GroupMatcher<TriggerKey> matcher)

  Pause all of the known ``Trigger`s` matching.

  The JobStore should "remember" the groups paused, and impose the pause on any new triggers that are added to one of these groups while the group is paused.

  Specified by:
    `pauseTriggers` in interface `JobStore`
  See Also:
    `#resumeTriggerGroup(String)`

### pauseJob

    public void pauseJob(JobKey jobKey)

  Pause the ``JobDetail`` with the given name - by pausing all of its current `Trigger`s.

  Specified by:
    `pauseJob` in interface `JobStore`
  See Also:
    `JobStore.resumeJob(JobKey)`

### pauseJobs

    public List<String> pauseJobs(GroupMatcher<JobKey> matcher)

  Pause all of the ``JobDetail`s` in the given group - by pausing all of their `Trigger`s.

  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.

  Specified by:
    `pauseJobs` in interface `JobStore`
  See Also:
    `#resumeJobGroup(String)`

### resumeTrigger

    public void resumeTrigger(TriggerKey triggerKey)

  Resume (un-pause) the ``Trigger`` with the given key.

  If the `Trigger` missed one or more fire-times, then the `Trigger`'s misfire instruction will be applied.

  Specified by:
    `resumeTrigger` in interface `JobStore`
  See Also:
    `JobStore.pauseTrigger(TriggerKey)`

### resumeTriggers

    public List<String> resumeTriggers(GroupMatcher<TriggerKey> matcher)

  Resume (un-pause) all of the ``Trigger`s` in the given group.

  If any `Trigger` missed one or more fire-times, then the `Trigger`'s misfire instruction will be applied.

  Specified by:
    `resumeTriggers` in interface `JobStore`
  See Also:
    `#pauseTriggers(String)`

### resumeJob

    public void resumeJob(JobKey jobKey)

  Resume (un-pause) the ``JobDetail`` with the given name.

  If any of the `Job`'s`Trigger` s missed one or more fire-times, then the `Trigger`'s misfire instruction will be applied.

  Specified by:
    `resumeJob` in interface `JobStore`
  See Also:
    `JobStore.pauseJob(JobKey)`

### resumeJobs

    public Collection<String> resumeJobs(GroupMatcher<JobKey> matcher)

  Resume (un-pause) all of the ``JobDetail`s` in the given group.

  If any of the `Job` s had `Trigger` s that missed one or more fire-times, then the `Trigger`'s misfire instruction will be applied.

  Specified by:
    `resumeJobs` in interface `JobStore`
  See Also:
    `#pauseJobGroup(String)`

### pauseAll

    public void pauseAll()

  Pause all triggers - equivalent of calling `pauseTriggerGroup(group)` on every group.

  When `resumeAll()` is called (to un-pause), trigger misfire instructions WILL be applied.

  Specified by:
    `pauseAll` in interface `JobStore`
  See Also:
    `resumeAll()`, `pauseTrigger(org.quartz.TriggerKey)`, `pauseTriggers(org.quartz.impl.matchers.GroupMatcher)`

### resumeAll

    public void resumeAll()

  Resume (un-pause) all triggers - equivalent of calling `resumeTriggerGroup(group)` on every group.

  If any `Trigger` missed one or more fire-times, then the `Trigger`'s misfire instruction will be applied.

  Specified by:
    `resumeAll` in interface `JobStore`
  See Also:
    `pauseAll()`

### applyMisfire

    protected boolean applyMisfire(org.quartz.simpl.TriggerWrapper tw)

### getFiredTriggerRecordId

    protected String getFiredTriggerRecordId()

### acquireNextTriggers

    public List<OperableTrigger> acquireNextTriggers(long noLaterThan,
                                                     int maxCount,
                                                     long timeWindow)

  Get a handle to the next trigger to be fired, and mark it as 'reserved' by the calling scheduler.

  Specified by:
    `acquireNextTriggers` in interface `JobStore`
  Parameters:
    `noLaterThan` - If > 0, the JobStore should only return a Trigger that will fire no later than the time represented in this value as milliseconds.
  See Also:
    `releaseAcquiredTrigger(OperableTrigger)`

### releaseAcquiredTrigger

    public void releaseAcquiredTrigger(OperableTrigger trigger)

  Inform the `JobStore` that the scheduler no longer plans to fire the given `Trigger`, that it had previously acquired (reserved).

  Specified by:
    `releaseAcquiredTrigger` in interface `JobStore`

### triggersFired

    public List<TriggerFiredResult> triggersFired(List<OperableTrigger> firedTriggers)

  Inform the `JobStore` that the scheduler is now firing the given `Trigger` (executing its associated `Job`), that it had previously acquired (reserved).

  Specified by:
    `triggersFired` in interface `JobStore`
  Returns:
    may return null if all the triggers or their calendars no longer exist, or if the trigger was not successfully put into the 'executing' state. Preference is to return an empty list if none of the triggers could be fired.

### triggeredJobComplete

    public void triggeredJobComplete(OperableTrigger trigger,
                                     JobDetail jobDetail,
                                     Trigger.CompletedExecutionInstruction triggerInstCode)

  Inform the `JobStore` that the scheduler has completed the firing of the given `Trigger` (and the execution its associated `Job`), and that the ``JobDataMap`` in the given `JobDetail` should be updated if the `Job` is stateful.

  Specified by:
    `triggeredJobComplete` in interface `JobStore`

### setAllTriggersOfJobToState

    protected void setAllTriggersOfJobToState(JobKey jobKey,
                                              int state)

### peekTriggers

    protected String peekTriggers()

### getPausedTriggerGroups

    public Set<String> getPausedTriggerGroups()
                                       throws JobPersistenceException

  Specified by:
    `getPausedTriggerGroups` in interface `JobStore`
  Throws:
    `JobPersistenceException`
  See Also:
    `JobStore.getPausedTriggerGroups()`

### setInstanceId

    public void setInstanceId(String schedInstId)

  Description copied from interface: `JobStore`
  Inform the `JobStore` of the Scheduler instance's Id, prior to initialize being invoked.

  Specified by:
    `setInstanceId` in interface `JobStore`

### setInstanceName

    public void setInstanceName(String schedName)

  Description copied from interface: `JobStore`
  Inform the `JobStore` of the Scheduler instance's name, prior to initialize being invoked.

  Specified by:
    `setInstanceName` in interface `JobStore`

### setThreadPoolSize

    public void setThreadPoolSize(int poolSize)

  Description copied from interface: `JobStore`
  Tells the JobStore the pool size used to execute jobs

  Specified by:
    `setThreadPoolSize` in interface `JobStore`
  Parameters:
    `poolSize` - amount of threads allocated for job execution

### getEstimatedTimeToReleaseAndAcquireTrigger

    public long getEstimatedTimeToReleaseAndAcquireTrigger()

  Description copied from interface: `JobStore`
  How long (in milliseconds) the `JobStore` implementation estimates that it will take to release a trigger and acquire a new one.

  Specified by:
    `getEstimatedTimeToReleaseAndAcquireTrigger` in interface `JobStore`

### isClustered

    public boolean isClustered()

  Description copied from interface: `JobStore`
  Whether or not the `JobStore` implementation is clustered.

  Specified by:
    `isClustered` in interface `JobStore`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright 2001-2016, Terracotta, Inc.