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` | `blockedJobs`
`protected HashMap` | `calendarsByName`
`protected HashMap` | `jobsByFQN`
`protected HashMap` | `jobsByGroup`
`protected Object` | `lock`
`protected long` | `misfireThreshold`
`protected HashSet` | `pausedJobGroups`
`protected HashSet` | `pausedTriggerGroups`
`protected SchedulerSignaler` | `signaler`
`protected TreeSet` | `timeTriggers`
`protected ArrayList` | `triggers`
`protected HashMap` | `triggersByFQN`
`protected HashMap` | `triggersByGroup`

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

Method Summary
`Trigger` | `acquireNextTrigger(SchedulingContext ctxt, long noLaterThan)` 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)`
`String[]` | `getCalendarNames(SchedulingContext ctxt)` 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()`
`String[]` | `getJobGroupNames(SchedulingContext ctxt)` Get the names of all of the ``Job`` groups.
`String[]` | `getJobNames(SchedulingContext ctxt, String groupName)` Get the names of all of the ``Job`` s that have the given group name.
`protected org.slf4j.Logger` | `getLog()`
`long` | `getMisfireThreshold()`
`int` | `getNumberOfCalendars(SchedulingContext ctxt)` Get the number of ``Calendar`` s that are stored in the `JobsStore`.
`int` | `getNumberOfJobs(SchedulingContext ctxt)` Get the number of ``JobDetail`` s that are stored in the `JobsStore`.
`int` | `getNumberOfTriggers(SchedulingContext ctxt)` Get the number of ``Trigger`` s that are stored in the `JobsStore`.
`Set` | `getPausedTriggerGroups(SchedulingContext ctxt)`
`String[]` | `getTriggerGroupNames(SchedulingContext ctxt)` Get the names of all of the ``Trigger`` groups.
`String[]` | `getTriggerNames(SchedulingContext ctxt, String groupName)` Get the names of all of the ``Trigger`` s that have the given group name.
`Trigger[]` | `getTriggersForJob(SchedulingContext ctxt, String jobName, String groupName)` Get all of the Triggers that are associated to the given Job.
`int` | `getTriggerState(SchedulingContext ctxt, String triggerName, String groupName)` Get the current state of the identified ``Trigger``.
`protected ArrayList` | `getTriggerWrappersForCalendar(String calName)`
`protected ArrayList` | `getTriggerWrappersForJob(String jobName, String groupName)`
`void` | `initialize(ClassLoadHelper loadHelper, SchedulerSignaler signaler)` 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(SchedulingContext ctxt)` Pause all triggers - equivalent of calling `pauseTriggerGroup(group)` on every group.
`void` | `pauseJob(SchedulingContext ctxt, String jobName, String groupName)` Pause the ``JobDetail`` with the given name - by pausing all of its current `Trigger`s.
`void` | `pauseJobGroup(SchedulingContext ctxt, String groupName)` Pause all of the ``JobDetail`s` in the given group - by pausing all of their `Trigger`s.
`void` | `pauseTrigger(SchedulingContext ctxt, String triggerName, String groupName)` Pause the ``Trigger`` with the given name.
`void` | `pauseTriggerGroup(SchedulingContext ctxt, String groupName)` Pause all of the ``Trigger`s` in the given group.
`protected String` | `peekTriggers()`
`void` | `releaseAcquiredTrigger(SchedulingContext ctxt, Trigger trigger)` Inform the `JobStore` that the scheduler no longer plans to fire the given `Trigger`, that it had previously acquired (reserved).
`boolean` | `removeCalendar(SchedulingContext ctxt, String calName)` Remove (delete) the ``Calendar`` with the given name.
`boolean` | `removeJob(SchedulingContext ctxt, String jobName, String groupName)` Remove (delete) the ``Job`` with the given name, and any ``Trigger`` s that reference it.
`boolean` | `removeTrigger(SchedulingContext ctxt, String triggerName, String groupName)` Remove (delete) the ``Trigger`` with the given name.
`boolean` | `replaceTrigger(SchedulingContext ctxt, String triggerName, String groupName, Trigger newTrigger)` Remove (delete) the ``Trigger`` with the given name, and store the new given one - which must be associated with the same job.
`void` | `resumeAll(SchedulingContext ctxt)` Resume (un-pause) all triggers - equivalent of calling `resumeTriggerGroup(group)` on every group.
`void` | `resumeJob(SchedulingContext ctxt, String jobName, String groupName)` Resume (un-pause) the ``JobDetail`` with the given name.
`void` | `resumeJobGroup(SchedulingContext ctxt, String groupName)` Resume (un-pause) all of the ``JobDetail`s` in the given group.
`void` | `resumeTrigger(SchedulingContext ctxt, String triggerName, String groupName)` Resume (un-pause) the ``Trigger`` with the given name.
`void` | `resumeTriggerGroup(SchedulingContext ctxt, String groupName)` Resume (un-pause) all of the ``Trigger`s` in the given group.
`Calendar` | `retrieveCalendar(SchedulingContext ctxt, String calName)` Retrieve the given ``Trigger``.
`JobDetail` | `retrieveJob(SchedulingContext ctxt, String jobName, String groupName)` Retrieve the ``JobDetail`` for the given ``Job``.
`Trigger` | `retrieveTrigger(SchedulingContext ctxt, String triggerName, String groupName)` Retrieve the given ``Trigger``.
`void` | `schedulerStarted()` Called by the QuartzScheduler to inform the `JobStore` that the scheduler has started.
`protected void` | `setAllTriggersOfJobToState(String jobName, String jobGroup, 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` | `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(SchedulingContext ctxt, String name, Calendar calendar, boolean replaceExisting, boolean updateTriggers)` Store the given ``Calendar``.
`void` | `storeJob(SchedulingContext ctxt, JobDetail newJob, boolean replaceExisting)` Store the given ``Job``.
`void` | `storeJobAndTrigger(SchedulingContext ctxt, JobDetail newJob, Trigger newTrigger)` Store the given ``JobDetail`` and ``Trigger``.
`void` | `storeTrigger(SchedulingContext ctxt, Trigger newTrigger, boolean replaceExisting)` Store the given ``Trigger``.
`boolean` | `supportsPersistence()`
`void` | `triggeredJobComplete(SchedulingContext ctxt, Trigger trigger, JobDetail jobDetail, int 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.
`TriggerFiredBundle` | `triggerFired(SchedulingContext ctxt, Trigger trigger)` 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

### jobsByFQN

    protected HashMap jobsByFQN

### triggersByFQN

    protected HashMap triggersByFQN

### jobsByGroup

    protected HashMap jobsByGroup

### triggersByGroup

    protected HashMap triggersByGroup

### timeTriggers

    protected TreeSet timeTriggers

### calendarsByName

    protected HashMap calendarsByName

### triggers

    protected ArrayList triggers

### lock

    protected final Object lock

### pausedTriggerGroups

    protected HashSet pausedTriggerGroups

### pausedJobGroups

    protected HashSet pausedJobGroups

### blockedJobs

    protected HashSet 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 signaler)

  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()
                          throws SchedulerException

  Description copied from interface: `JobStore`

  Called by the QuartzScheduler to inform the `JobStore` that the scheduler has started.

  Specified by:
    `schedulerStarted` in interface `JobStore`
  Throws:
    `SchedulerException`

### 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` -

### 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`

### storeJobAndTrigger

    public void storeJobAndTrigger(SchedulingContext ctxt,
                                   JobDetail newJob,
                                   Trigger 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(SchedulingContext ctxt,
                         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(SchedulingContext ctxt,
                             String jobName,
                             String groupName)

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

  Specified by:
    `removeJob` in interface `JobStore`
  Parameters:
    `jobName` - The name of the `Job` to be removed.
    `groupName` - The group name of the `Job` to be removed.
  Returns:
    `true` if a `Job` with the given name & group was found and removed from the store.

### storeTrigger

    public void storeTrigger(SchedulingContext ctxt,
                             Trigger 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:
    `pauseTriggerGroup(SchedulingContext, String)`

### removeTrigger

    public boolean removeTrigger(SchedulingContext ctxt,
                                 String triggerName,
                                 String groupName)

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

  Specified by:
    `removeTrigger` in interface `JobStore`
  Parameters:
    `triggerName` - The name of the `Trigger` to be removed.
    `groupName` - The group name of the `Trigger` to be removed.
  Returns:
    `true` if a `Trigger` with the given name & group was found and removed from the store.

### replaceTrigger

    public boolean replaceTrigger(SchedulingContext ctxt,
                                  String triggerName,
                                  String groupName,
                                  Trigger newTrigger)
                           throws JobPersistenceException

  Description copied from interface: `JobStore`

  Remove (delete) the ``Trigger`` with the given name, and store the new given one - which must be associated with the same job.

  Specified by:
    `replaceTrigger` in interface `JobStore`
    `triggerName` - The name of the `Trigger` to be removed.
    `groupName` - The group name of the `Trigger` to be removed.
    `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(org.quartz.core.SchedulingContext, java.lang.String, java.lang.String, org.quartz.Trigger)`

### retrieveJob

    public JobDetail retrieveJob(SchedulingContext ctxt,
                                 String jobName,
                                 String groupName)

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

  Specified by:
    `retrieveJob` in interface `JobStore`
  Parameters:
    `jobName` - The name of the `Job` to be retrieved.
    `groupName` - The group name of the `Job` to be retrieved.
  Returns:
    The desired `Job`, or null if there is no match.

### retrieveTrigger

    public Trigger retrieveTrigger(SchedulingContext ctxt,
                                   String triggerName,
                                   String groupName)

  Retrieve the given ``Trigger``.

  Specified by:
    `retrieveTrigger` in interface `JobStore`
  Parameters:
    `triggerName` - The name of the `Trigger` to be retrieved.
    `groupName` - The group name of the `Trigger` to be retrieved.
  Returns:
    The desired `Trigger`, or null if there is no match.

### getTriggerState

    public int getTriggerState(SchedulingContext ctxt,
                               String triggerName,
                               String groupName)
                        throws JobPersistenceException

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

  Specified by:
    `getTriggerState` in interface `JobStore`
  Throws:
    `JobPersistenceException`
  See Also:
    `Trigger.STATE_NORMAL`, `Trigger.STATE_PAUSED`, `Trigger.STATE_COMPLETE`, `Trigger.STATE_ERROR`, `Trigger.STATE_BLOCKED`, `Trigger.STATE_NONE`

### storeCalendar

    public void storeCalendar(SchedulingContext ctxt,
                              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(SchedulingContext ctxt,
                                  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(SchedulingContext ctxt,
                                     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(SchedulingContext ctxt)

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

  Specified by:
    `getNumberOfJobs` in interface `JobStore`

### getNumberOfTriggers

    public int getNumberOfTriggers(SchedulingContext ctxt)

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

  Specified by:
    `getNumberOfTriggers` in interface `JobStore`

### getNumberOfCalendars

    public int getNumberOfCalendars(SchedulingContext ctxt)

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

  Specified by:
    `getNumberOfCalendars` in interface `JobStore`

### getJobNames

    public String[] getJobNames(SchedulingContext ctxt,
                                String groupName)

  Get the names of all of the ``Job`` s that have the given group name.

  Specified by:
    `getJobNames` in interface `JobStore`

### getCalendarNames

    public String[] getCalendarNames(SchedulingContext ctxt)

  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`

### getTriggerNames

    public String[] getTriggerNames(SchedulingContext ctxt,
                                    String groupName)

  Get the names of all of the ``Trigger`` s that have the given group name.

  Specified by:
    `getTriggerNames` in interface `JobStore`

### getJobGroupNames

    public String[] getJobGroupNames(SchedulingContext ctxt)

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

  Specified by:
    `getJobGroupNames` in interface `JobStore`

### getTriggerGroupNames

    public String[] getTriggerGroupNames(SchedulingContext ctxt)

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

  Specified by:
    `getTriggerGroupNames` in interface `JobStore`

### getTriggersForJob

    public Trigger[] getTriggersForJob(SchedulingContext ctxt,
                                       String jobName,
                                       String groupName)

  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 getTriggerWrappersForJob(String jobName,
                                                 String groupName)

### getTriggerWrappersForCalendar

    protected ArrayList getTriggerWrappersForCalendar(String calName)

### pauseTrigger

    public void pauseTrigger(SchedulingContext ctxt,
                             String triggerName,
                             String groupName)

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

  Specified by:
    `pauseTrigger` in interface `JobStore`
  See Also:
    `JobStore.resumeTrigger(SchedulingContext, String, String)`

### pauseTriggerGroup

    public void pauseTriggerGroup(SchedulingContext ctxt,
                                  String groupName)

  Pause all of the ``Trigger`s` in the given group.

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

  Specified by:
    `pauseTriggerGroup` in interface `JobStore`
  See Also:
    `JobStore.resumeTriggerGroup(SchedulingContext, String)`

### pauseJob

    public void pauseJob(SchedulingContext ctxt,
                         String jobName,
                         String groupName)

  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(SchedulingContext, String, String)`

### pauseJobGroup

    public void pauseJobGroup(SchedulingContext ctxt,
                              String groupName)

  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:
    `pauseJobGroup` in interface `JobStore`
  See Also:
    `JobStore.resumeJobGroup(SchedulingContext, String)`

### resumeTrigger

    public void resumeTrigger(SchedulingContext ctxt,
                              String triggerName,
                              String groupName)

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

  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(SchedulingContext, String, String)`

### resumeTriggerGroup

    public void resumeTriggerGroup(SchedulingContext ctxt,
                                   String groupName)

  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:
    `resumeTriggerGroup` in interface `JobStore`
  See Also:
    `JobStore.pauseTriggerGroup(SchedulingContext, String)`

### resumeJob

    public void resumeJob(SchedulingContext ctxt,
                          String jobName,
                          String groupName)

  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(SchedulingContext, String, String)`

### resumeJobGroup

    public void resumeJobGroup(SchedulingContext ctxt,
                               String groupName)

  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:
    `resumeJobGroup` in interface `JobStore`
  See Also:
    `JobStore.pauseJobGroup(SchedulingContext, String)`

### pauseAll

    public void pauseAll(SchedulingContext ctxt)

  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(SchedulingContext)`, `pauseTriggerGroup(SchedulingContext, String)`

### resumeAll

    public void resumeAll(SchedulingContext ctxt)

  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(SchedulingContext)`

### applyMisfire

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

### getFiredTriggerRecordId

    protected String getFiredTriggerRecordId()

### acquireNextTrigger

    public Trigger acquireNextTrigger(SchedulingContext ctxt,
                                      long noLaterThan)

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

  Specified by:
    `acquireNextTrigger` in interface `JobStore`
    `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(SchedulingContext, Trigger)`

### releaseAcquiredTrigger

    public void releaseAcquiredTrigger(SchedulingContext ctxt,
                                       Trigger 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`

### triggerFired

    public TriggerFiredBundle triggerFired(SchedulingContext ctxt,
                                           Trigger trigger)

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

  Specified by:
    `triggerFired` in interface `JobStore`
  Returns:
    null if the trigger or it's job or calendar no longer exist, or if the trigger was not successfully put into the 'executing' state.

### triggeredJobComplete

    public void triggeredJobComplete(SchedulingContext ctxt,
                                     Trigger trigger,
                                     JobDetail jobDetail,
                                     int 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(String jobName,
                                              String jobGroup,
                                              int state)

### peekTriggers

    protected String peekTriggers()

### getPausedTriggerGroups

    public Set getPausedTriggerGroups(SchedulingContext ctxt)
                               throws JobPersistenceException

  Specified by:
    `getPausedTriggerGroups` in interface `JobStore`
  Throws:
    `JobPersistenceException`
  See Also:
    `JobStore.getPausedTriggerGroups(org.quartz.core.SchedulingContext)`

### 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`

### 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-2012, Terracotta, Inc.