net.joelinn.quartz.jobstore

Class AbstractRedisStorage<T extends redis.clients.jedis.JedisCommands>

java.lang.Object

net.joelinn.quartz.jobstore.AbstractRedisStorage<T>

Direct Known Subclasses:

RedisClusterStorage, RedisStorage

public abstract class AbstractRedisStorage<T extends redis.clients.jedis.JedisCommands>
extends Object

Joe Linn 7/16/2014

Field Summary

Fields

Modifier and Type	Field and Description
protected static String	CALENDAR_CLASS
protected static String	CALENDAR_JSON
protected int	lockTimeout
protected UUID	lockValue The value of the currently held Redis lock (if any)
protected com.fasterxml.jackson.databind.ObjectMapper	mapper
protected int	misfireThreshold
protected RedisJobStoreSchema	redisSchema
protected String	schedulerInstanceId
protected org.quartz.spi.SchedulerSignaler	signaler
protected static String	TRIGGER_CLASS
protected int	TRIGGER_LOCK_TIMEOUT
protected static String	TRIGGER_NEXT_FIRE_TIME The name of the trigger hash property which stores the trigger's next fire time

Constructor Summary

Constructors

Constructor and Description
AbstractRedisStorage(RedisJobStoreSchema redisSchema, com.fasterxml.jackson.databind.ObjectMapper mapper, org.quartz.spi.SchedulerSignaler signaler, String schedulerInstanceId, int lockTimeout)

Method Summary

Modifier and Type	Method and Description
List<org.quartz.spi.OperableTrigger>	acquireNextTriggers(long noLaterThan, int maxCount, long timeWindow, T jedis) Get a handle to the next trigger to be fired, and mark it as 'reserved' by the calling scheduler.
protected boolean	applyMisfire(org.quartz.spi.OperableTrigger trigger, T jedis) Determine whether or not the given trigger has misfired.
boolean	checkExists(org.quartz.JobKey jobKey, T jedis) Check if the job identified by the given key exists in storage
boolean	checkExists(org.quartz.TriggerKey triggerKey, T jedis) Check if the trigger identified by the given key exists
void	clearAllSchedulingData(T jedis) Clear (delete!) all scheduling data - all Jobs, Triggers Calendars.
List<String>	getCalendarNames(T jedis) Get the names of all of the Calendar s in the JobStore.
List<String>	getJobGroupNames(T jedis) Get the names of all of the Job groups.
abstract Set<org.quartz.JobKey>	getJobKeys(org.quartz.impl.matchers.GroupMatcher<org.quartz.JobKey> matcher, T jedis) Get the keys of all of the Job s that have the given group name.
protected long	getLastTriggersReleaseTime(T jedis) Retrieve the last time (in milliseconds) that orphaned triggers were released
int	getNumberOfCalendars(T jedis) Get the number of stored calendars
int	getNumberOfJobs(T jedis) Get the number of stored jobs
int	getNumberOfTriggers(T jedis) Get the number of stored triggers
Set<String>	getPausedTriggerGroups(T jedis) Retrieve all currently paused trigger groups
protected Map<String,String>	getStringDataMap(org.quartz.JobDataMap jobDataMap) Convert a JobDataMap to a HashMap with String keys and values
List<String>	getTriggerGroupNames(T jedis) Get the names of all of the Trigger groups.
abstract Set<org.quartz.TriggerKey>	getTriggerKeys(org.quartz.impl.matchers.GroupMatcher<org.quartz.TriggerKey> matcher, T jedis) Get the names of all of the Trigger s that have the given group name.
List<org.quartz.spi.OperableTrigger>	getTriggersForJob(org.quartz.JobKey jobKey, T jedis) Retrieve triggers associated with the given job
abstract org.quartz.Trigger.TriggerState	getTriggerState(org.quartz.TriggerKey triggerKey, T jedis) Get the current state of the identified Trigger.
protected boolean	isJobConcurrentExecutionDisallowed(Class<? extends org.quartz.Job> jobClass) Determine if the given job class disallows concurrent execution
protected boolean	isNullOrEmpty(String string) Check if a string is null or empty
protected boolean	isPersistJobDataAfterExecution(Class<? extends org.quartz.Job> jobClass)
boolean	lock(T jedis) Attempt to acquire a lock
protected boolean	lockTrigger(org.quartz.TriggerKey triggerKey, T jedis) Lock the trigger with the given key to the current jobstore instance
void	pauseAll(T jedis) Pause all triggers - equivalent of calling pauseTriggerGroup(group) on every group.
void	pauseJob(org.quartz.JobKey jobKey, T jedis) Pause a job by pausing all of its triggers
abstract Collection<String>	pauseJobs(org.quartz.impl.matchers.GroupMatcher<org.quartz.JobKey> groupMatcher, T jedis) Pause all of the Jobs in the given group - by pausing all of their Triggers.
abstract void	pauseTrigger(org.quartz.TriggerKey triggerKey, T jedis) Pause the trigger with the given key
abstract Collection<String>	pauseTriggers(org.quartz.impl.matchers.GroupMatcher<org.quartz.TriggerKey> matcher, T jedis) Pause all of the Triggers in the given group.
protected int	randomInt(int min, int max) Get a random integer within the specified bounds
void	releaseAcquiredTrigger(org.quartz.spi.OperableTrigger trigger, T jedis) Inform the JobStore that the scheduler no longer plans to fire the given Trigger, that it had previously acquired (reserved).
protected void	releaseOrphanedTriggers(RedisTriggerState currentState, RedisTriggerState newState, T jedis) Release triggers from the given current state to the new state if its locking scheduler has not registered as alive in the last 10 minutes
protected void	releaseTriggersCron(T jedis) Release triggers currently held by schedulers which have ceased to function
abstract boolean	removeCalendar(String calendarName, T jedis) Remove (delete) the Calendar with the given name.
abstract boolean	removeJob(org.quartz.JobKey jobKey, T jedis) Remove the given job from Redis
protected abstract boolean	removeTrigger(org.quartz.TriggerKey triggerKey, boolean removeNonDurableJob, T jedis) Remove (delete) the Trigger with the given key.
boolean	removeTrigger(org.quartz.TriggerKey triggerKey, T jedis) Remove (delete) the Trigger with the given key.
boolean	replaceTrigger(org.quartz.TriggerKey triggerKey, org.quartz.spi.OperableTrigger newTrigger, T jedis) Remove (delete) the Trigger with the given key, and store the new given one - which must be associated with the same job.
void	resumeAll(T jedis) Resume (un-pause) all triggers - equivalent of calling resumeTriggerGroup(group) on every group.
void	resumeJob(org.quartz.JobKey jobKey, T jedis) Resume (un-pause) the Job with the given key.
abstract Collection<String>	resumeJobs(org.quartz.impl.matchers.GroupMatcher<org.quartz.JobKey> matcher, T jedis) Resume (un-pause) all of the Jobs in the given group.
abstract void	resumeTrigger(org.quartz.TriggerKey triggerKey, T jedis) Resume (un-pause) a Trigger
abstract Collection<String>	resumeTriggers(org.quartz.impl.matchers.GroupMatcher<org.quartz.TriggerKey> matcher, T jedis) Resume (un-pause) all of the Triggers in the given group.
org.quartz.Calendar	retrieveCalendar(String name, T jedis) Retrieve a calendar
org.quartz.JobDetail	retrieveJob(org.quartz.JobKey jobKey, T jedis) Retrieve a job from redis
org.quartz.spi.OperableTrigger	retrieveTrigger(org.quartz.TriggerKey triggerKey, T jedis) Retrieve a trigger from Redis
AbstractRedisStorage	setMisfireThreshold(int misfireThreshold)
protected void	settLastTriggerReleaseTime(long time, T jedis) Set the last time at which orphaned triggers were released
boolean	setTriggerState(RedisTriggerState state, double score, String triggerHashKey, T jedis) Set a trigger state by adding the trigger to the relevant sorted set, using its next fire time as the score.
abstract void	storeCalendar(String name, org.quartz.Calendar calendar, boolean replaceExisting, boolean updateTriggers, T jedis) Store a Calendar
abstract void	storeJob(org.quartz.JobDetail jobDetail, boolean replaceExisting, T jedis) Store a job in Redis
abstract void	storeTrigger(org.quartz.spi.OperableTrigger trigger, boolean replaceExisting, T jedis) Store a trigger in redis
abstract void	triggeredJobComplete(org.quartz.spi.OperableTrigger trigger, org.quartz.JobDetail jobDetail, org.quartz.Trigger.CompletedExecutionInstruction triggerInstCode, T jedis) Inform the JobStore that the scheduler has completed the firing of the given Trigger (and the execution of its associated Job completed, threw an exception, or was vetoed), and that the JobDataMap in the given JobDetail should be updated if the Job is stateful.
abstract List<org.quartz.spi.TriggerFiredResult>	triggersFired(List<org.quartz.spi.OperableTrigger> triggers, T jedis) Inform the JobStore that the scheduler is now firing the given Trigger (executing its associated Job), that it had previously acquired (reserved).
boolean	unlock(T jedis) Attempt to remove lock
abstract boolean	unsetTriggerState(String triggerHashKey, T jedis) Unsets the state of the given trigger key by removing the trigger from all trigger state sets.
void	waitForLock(T jedis) Attempt to acquire lock.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

TRIGGER_CLASS

protected static final String TRIGGER_CLASS

See Also:

Constant Field Values

CALENDAR_CLASS

protected static final String CALENDAR_CLASS

See Also:

Constant Field Values

CALENDAR_JSON

protected static final String CALENDAR_JSON

See Also:

Constant Field Values

TRIGGER_NEXT_FIRE_TIME

protected static final String TRIGGER_NEXT_FIRE_TIME

The name of the trigger hash property which stores the trigger's next fire time

See Also:

Constant Field Values

redisSchema

protected final RedisJobStoreSchema redisSchema

mapper

protected final com.fasterxml.jackson.databind.ObjectMapper mapper

signaler

protected final org.quartz.spi.SchedulerSignaler signaler

schedulerInstanceId

protected final String schedulerInstanceId

lockTimeout

protected final int lockTimeout

TRIGGER_LOCK_TIMEOUT

protected final int TRIGGER_LOCK_TIMEOUT

See Also:

Constant Field Values

misfireThreshold

protected int misfireThreshold

lockValue

protected UUID lockValue

The value of the currently held Redis lock (if any)

Constructor Detail

AbstractRedisStorage

public AbstractRedisStorage(RedisJobStoreSchema redisSchema,
                            com.fasterxml.jackson.databind.ObjectMapper mapper,
                            org.quartz.spi.SchedulerSignaler signaler,
                            String schedulerInstanceId,
                            int lockTimeout)

Method Detail

setMisfireThreshold

public AbstractRedisStorage setMisfireThreshold(int misfireThreshold)

lock

public boolean lock(T jedis)

Attempt to acquire a lock

Returns:

true if lock was successfully acquired; false otherwise

waitForLock

public void waitForLock(T jedis)

Attempt to acquire lock. If lock cannot be acquired, wait until lock is successfully acquired.

Parameters:

jedis - a thread-safe Redis connection

unlock

public boolean unlock(T jedis)

Attempt to remove lock

Returns:

true if lock was successfully removed; false otherwise

randomInt

protected int randomInt(int min,
                        int max)

Get a random integer within the specified bounds

Parameters:

min - the minimum possible value

max - the maximum possible value

Returns:

a random integer between min and max, inclusive

clearAllSchedulingData

public void clearAllSchedulingData(T jedis)
                            throws org.quartz.JobPersistenceException,
                                   ClassNotFoundException

Clear (delete!) all scheduling data - all Jobs, Triggers Calendars.

Parameters:

jedis - a thread-safe Redis connection

Throws:

org.quartz.JobPersistenceException

ClassNotFoundException

storeJob

public abstract void storeJob(org.quartz.JobDetail jobDetail,
                              boolean replaceExisting,
                              T jedis)
                       throws org.quartz.ObjectAlreadyExistsException

Store a job in Redis

Parameters:

jobDetail - the JobDetail object to be stored

replaceExisting - if true, any existing job with the same group and name as the given job will be overwritten

jedis - a thread-safe Redis connection

Throws:

org.quartz.ObjectAlreadyExistsException

getStringDataMap

protected Map<String,String> getStringDataMap(org.quartz.JobDataMap jobDataMap)

Convert a JobDataMap to a HashMap with String keys and values

Parameters:

jobDataMap - the job data map to be converted

Returns:

a map with string keys and values

retrieveJob

public org.quartz.JobDetail retrieveJob(org.quartz.JobKey jobKey,
                                        T jedis)
                                 throws org.quartz.JobPersistenceException,
                                        ClassNotFoundException

Retrieve a job from redis

Parameters:

jobKey - the job key detailing the identity of the job to be retrieved

jedis - a thread-safe Redis connection

Returns:

the JobDetail of the desired job

Throws:

org.quartz.JobPersistenceException - if the desired job does not exist

ClassNotFoundException

removeJob

public abstract boolean removeJob(org.quartz.JobKey jobKey,
                                  T jedis)
                           throws org.quartz.JobPersistenceException

Remove the given job from Redis

Parameters:

jobKey - the job to be removed

jedis - a thread-safe Redis connection

Returns:

true if the job was removed; false if it did not exist

Throws:

org.quartz.JobPersistenceException

storeTrigger

public abstract void storeTrigger(org.quartz.spi.OperableTrigger trigger,
                                  boolean replaceExisting,
                                  T jedis)
                           throws org.quartz.JobPersistenceException

Store a trigger in redis

Parameters:

trigger - the trigger to be stored

replaceExisting - true if an existing trigger with the same identity should be replaced

jedis - a thread-safe Redis connection

Throws:

org.quartz.JobPersistenceException

org.quartz.ObjectAlreadyExistsException

removeTrigger

public boolean removeTrigger(org.quartz.TriggerKey triggerKey,
                             T jedis)
                      throws org.quartz.JobPersistenceException,
                             ClassNotFoundException

Remove (delete) the Trigger with the given key. If the associated job is non-durable and has no triggers after the given trigger is removed, the job will be removed, as well.

Parameters:

triggerKey - the key of the trigger to be removed

jedis - a thread-safe Redis connection

Returns:

true if the trigger was found and removed

Throws:

org.quartz.JobPersistenceException

ClassNotFoundException

removeTrigger

protected abstract boolean removeTrigger(org.quartz.TriggerKey triggerKey,
                                         boolean removeNonDurableJob,
                                         T jedis)
                                  throws org.quartz.JobPersistenceException,
                                         ClassNotFoundException

Remove (delete) the Trigger with the given key.

Parameters:

triggerKey - the key of the trigger to be removed

removeNonDurableJob - if true, the job associated with the given trigger will be removed if it is non-durable and has no other triggers

jedis - a thread-safe Redis connection

Returns:

true if the trigger was found and removed

Throws:

org.quartz.JobPersistenceException

ClassNotFoundException

replaceTrigger

public boolean replaceTrigger(org.quartz.TriggerKey triggerKey,
                              org.quartz.spi.OperableTrigger newTrigger,
                              T jedis)
                       throws org.quartz.JobPersistenceException,
                              ClassNotFoundException

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

Parameters:

triggerKey - the key of the trigger to be replaced

newTrigger - the replacement trigger

jedis - a thread-safe Redis connection

Returns:

true if the target trigger was found, removed, and replaced

Throws:

org.quartz.JobPersistenceException

ClassNotFoundException

retrieveTrigger

public org.quartz.spi.OperableTrigger retrieveTrigger(org.quartz.TriggerKey triggerKey,
                                                      T jedis)
                                               throws org.quartz.JobPersistenceException

Retrieve a trigger from Redis

Parameters:

triggerKey - the trigger key

jedis - a thread-safe Redis connection

Returns:

the requested OperableTrigger if it exists; null if it does not

Throws:

org.quartz.JobPersistenceException - if the job associated with the retrieved trigger does not exist

getTriggersForJob

public List<org.quartz.spi.OperableTrigger> getTriggersForJob(org.quartz.JobKey jobKey,
                                                              T jedis)
                                                       throws org.quartz.JobPersistenceException

Retrieve triggers associated with the given job

Parameters:

jobKey - the job for which to retrieve triggers

jedis - a thread-safe Redis connection

Returns:

a list of triggers associated with the given job

Throws:

org.quartz.JobPersistenceException

unsetTriggerState

public abstract boolean unsetTriggerState(String triggerHashKey,
                                          T jedis)
                                   throws org.quartz.JobPersistenceException

Unsets the state of the given trigger key by removing the trigger from all trigger state sets.

Parameters:

triggerHashKey - the redis key of the desired trigger hash

jedis - a thread-safe Redis connection

Returns:

true if the trigger was removed, false if the trigger was stateless

Throws:

org.quartz.JobPersistenceException - if the unset operation failed

setTriggerState

public boolean setTriggerState(RedisTriggerState state,
                               double score,
                               String triggerHashKey,
                               T jedis)
                        throws org.quartz.JobPersistenceException

Set a trigger state by adding the trigger to the relevant sorted set, using its next fire time as the score.

Parameters:

state - the new state to be set

score - the trigger's next fire time

triggerHashKey - the trigger hash key

jedis - a thread-safe Redis connection

Returns:

true if set, false if the trigger was already a member of the given state's sorted set and its score was updated

Throws:

org.quartz.JobPersistenceException - if the set operation fails

checkExists

public boolean checkExists(org.quartz.JobKey jobKey,
                           T jedis)

Check if the job identified by the given key exists in storage

Parameters:

jobKey - the key of the desired job

jedis - a thread-safe Redis connection

Returns:

true if the job exists; false otherwise

checkExists

public boolean checkExists(org.quartz.TriggerKey triggerKey,
                           T jedis)

Check if the trigger identified by the given key exists

Parameters:

triggerKey - the key of the desired trigger

jedis - a thread-safe Redis connection

Returns:

true if the trigger exists; false otherwise

storeCalendar

public abstract void storeCalendar(String name,
                                   org.quartz.Calendar calendar,
                                   boolean replaceExisting,
                                   boolean updateTriggers,
                                   T jedis)
                            throws org.quartz.JobPersistenceException

Store a Calendar

Parameters:

name - the name of the calendar

calendar - the calendar object to be stored

replaceExisting - if true, any existing calendar with the same name will be overwritten

updateTriggers - if true, any existing triggers associated with the calendar will be updated

jedis - a thread-safe Redis connection

Throws:

org.quartz.JobPersistenceException

removeCalendar

public abstract boolean removeCalendar(String calendarName,
                                       T jedis)
                                throws org.quartz.JobPersistenceException

Remove (delete) the Calendar with the given name.

Parameters:

calendarName - the name of the calendar to be removed

jedis - a thread-safe Redis connection

Returns:

true if a calendar with the given name was found and removed

Throws:

org.quartz.JobPersistenceException

retrieveCalendar

public org.quartz.Calendar retrieveCalendar(String name,
                                            T jedis)
                                     throws org.quartz.JobPersistenceException

Retrieve a calendar

Parameters:

name - the name of the calendar to be retrieved

jedis - a thread-safe Redis connection

Returns:

the desired calendar if it exists; null otherwise

Throws:

org.quartz.JobPersistenceException

getNumberOfJobs

public int getNumberOfJobs(T jedis)

Get the number of stored jobs

Parameters:

jedis - a thread-safe Redis connection

Returns:

the number of jobs currently persisted in the jobstore

getNumberOfTriggers

public int getNumberOfTriggers(T jedis)

Get the number of stored triggers

Parameters:

jedis - a thread-safe Redis connection

Returns:

the number of triggers currently persisted in the jobstore

getNumberOfCalendars

public int getNumberOfCalendars(T jedis)

Get the number of stored calendars

Parameters:

jedis - a thread-safe Redis connection

Returns:

the number of calendars currently persisted in the jobstore

getJobKeys

public abstract Set<org.quartz.JobKey> getJobKeys(org.quartz.impl.matchers.GroupMatcher<org.quartz.JobKey> matcher,
                                                  T jedis)

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

Parameters:

matcher - the matcher with which to compare group names

jedis - a thread-safe Redis connection

Returns:

the set of all JobKeys which have the given group name

getTriggerKeys

public abstract Set<org.quartz.TriggerKey> getTriggerKeys(org.quartz.impl.matchers.GroupMatcher<org.quartz.TriggerKey> matcher,
                                                          T jedis)

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

Parameters:

matcher - the matcher with which to compare group names

jedis - a thread-safe Redis connection

Returns:

the set of all TriggerKeys which have the given group name

getJobGroupNames

public List<String> getJobGroupNames(T jedis)

Get the names of all of the Job groups.

Parameters:

jedis - a thread-safe Redis connection

Returns:

the names of all of the job groups or an empty list if no job groups exist

getTriggerGroupNames

public List<String> getTriggerGroupNames(T jedis)

Get the names of all of the Trigger groups.

Parameters:

jedis - a thread-safe Redis connection

Returns:

the names of all trigger groups or an empty list if no trigger groups exist

getCalendarNames

public List<String> getCalendarNames(T jedis)

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

Parameters:

jedis - a thread-safe Redis connection

Returns:

the names of all calendars or an empty list if no calendars exist

getTriggerState

public abstract org.quartz.Trigger.TriggerState getTriggerState(org.quartz.TriggerKey triggerKey,
                                                                T jedis)

Get the current state of the identified Trigger.

Parameters:

triggerKey - the key of the desired trigger

jedis - a thread-safe Redis connection

Returns:

the state of the trigger

pauseTrigger

public abstract void pauseTrigger(org.quartz.TriggerKey triggerKey,
                                  T jedis)
                           throws org.quartz.JobPersistenceException

Pause the trigger with the given key

Parameters:

triggerKey - the key of the trigger to be paused

jedis - a thread-safe Redis connection

Throws:

org.quartz.JobPersistenceException - if the desired trigger does not exist

pauseTriggers

public abstract Collection<String> pauseTriggers(org.quartz.impl.matchers.GroupMatcher<org.quartz.TriggerKey> matcher,
                                                 T jedis)
                                          throws org.quartz.JobPersistenceException

Pause all of the Triggers in the given group.

Parameters:

matcher - matcher for the trigger groups to be paused

jedis - a thread-safe Redis connection

Returns:

a collection of names of trigger groups which were matched and paused

Throws:

org.quartz.JobPersistenceException

pauseJob

public void pauseJob(org.quartz.JobKey jobKey,
                     T jedis)
              throws org.quartz.JobPersistenceException

Pause a job by pausing all of its triggers

Parameters:

jobKey - the key of the job to be paused

jedis - a thread-safe Redis connection

Throws:

org.quartz.JobPersistenceException

pauseJobs

public abstract Collection<String> pauseJobs(org.quartz.impl.matchers.GroupMatcher<org.quartz.JobKey> groupMatcher,
                                             T jedis)
                                      throws org.quartz.JobPersistenceException

Pause all of the Jobs in the given group - by pausing all of their Triggers.

Parameters:

groupMatcher - the mather which will determine which job group should be paused

jedis - a thread-safe Redis connection

Returns:

a collection of names of job groups which have been paused

Throws:

org.quartz.JobPersistenceException

resumeTrigger

public abstract void resumeTrigger(org.quartz.TriggerKey triggerKey,
                                   T jedis)
                            throws org.quartz.JobPersistenceException

Resume (un-pause) a Trigger

Parameters:

triggerKey - the key of the trigger to be resumed

jedis - a thread-safe Redis connection

Throws:

org.quartz.JobPersistenceException

applyMisfire

protected boolean applyMisfire(org.quartz.spi.OperableTrigger trigger,
                               T jedis)
                        throws org.quartz.JobPersistenceException

Determine whether or not the given trigger has misfired. If so, notify the SchedulerSignaler and update the trigger.

Parameters:

trigger - the trigger to check for misfire

jedis - a thread-safe Redis connection

Returns:

false if the trigger has misfired; true otherwise

Throws:

org.quartz.JobPersistenceException

resumeTriggers

public abstract Collection<String> resumeTriggers(org.quartz.impl.matchers.GroupMatcher<org.quartz.TriggerKey> matcher,
                                                  T jedis)
                                           throws org.quartz.JobPersistenceException

Resume (un-pause) all of the Triggers in the given group.

Parameters:

matcher - matcher for the trigger groups to be resumed

jedis - a thread-safe Redis connection

Returns:

the names of trigger groups which were resumed

Throws:

org.quartz.JobPersistenceException

getPausedTriggerGroups

public Set<String> getPausedTriggerGroups(T jedis)

Retrieve all currently paused trigger groups

Parameters:

jedis - a thread-safe Redis connection

Returns:

a set containing the names of all currently paused trigger groups

resumeJob

public void resumeJob(org.quartz.JobKey jobKey,
                      T jedis)
               throws org.quartz.JobPersistenceException

Resume (un-pause) the Job with the given key.

Parameters:

jobKey - the key of the job to be resumed

jedis - a thread-safe Redis connection

Throws:

org.quartz.JobPersistenceException

resumeJobs

public abstract Collection<String> resumeJobs(org.quartz.impl.matchers.GroupMatcher<org.quartz.JobKey> matcher,
                                              T jedis)
                                       throws org.quartz.JobPersistenceException

Resume (un-pause) all of the Jobs in the given group.

Parameters:

matcher - the matcher with which to compare job group names

jedis - a thread-safe Redis connection

Returns:

the set of job groups which were matched and resumed

Throws:

org.quartz.JobPersistenceException

pauseAll

public void pauseAll(T jedis)
              throws org.quartz.JobPersistenceException

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

Parameters:

jedis - a thread-safe Redis connection

Throws:

org.quartz.JobPersistenceException

resumeAll

public void resumeAll(T jedis)
               throws org.quartz.JobPersistenceException

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

Parameters:

jedis - a thread-safe Redis connection

Throws:

org.quartz.JobPersistenceException

releaseOrphanedTriggers

protected void releaseOrphanedTriggers(RedisTriggerState currentState,
                                       RedisTriggerState newState,
                                       T jedis)
                                throws org.quartz.JobPersistenceException

Release triggers from the given current state to the new state if its locking scheduler has not registered as alive in the last 10 minutes

Parameters:

currentState - the current state of the orphaned trigger

newState - the new state of the orphaned trigger

jedis - a thread-safe Redis connection

Throws:

org.quartz.JobPersistenceException

releaseTriggersCron

protected void releaseTriggersCron(T jedis)
                            throws org.quartz.JobPersistenceException

Release triggers currently held by schedulers which have ceased to function

Parameters:

jedis - a thread-safe Redis connection

Throws:

org.quartz.JobPersistenceException

getLastTriggersReleaseTime

protected long getLastTriggersReleaseTime(T jedis)

Retrieve the last time (in milliseconds) that orphaned triggers were released

Parameters:

jedis - a thread-safe Redis connection

Returns:

a unix timestamp in milliseconds

settLastTriggerReleaseTime

protected void settLastTriggerReleaseTime(long time,
                                          T jedis)

Set the last time at which orphaned triggers were released

Parameters:

time - a unix timestamp in milliseconds

jedis - a thread-safe Redis connection

isJobConcurrentExecutionDisallowed

protected boolean isJobConcurrentExecutionDisallowed(Class<? extends org.quartz.Job> jobClass)

Determine if the given job class disallows concurrent execution

Parameters:

jobClass - the job class in question

Returns:

true if concurrent execution is NOT allowed; false if concurrent execution IS allowed

lockTrigger

protected boolean lockTrigger(org.quartz.TriggerKey triggerKey,
                              T jedis)

Lock the trigger with the given key to the current jobstore instance

Parameters:

triggerKey - the key of the desired trigger

jedis - a thread-safe Redis connection

Returns:

true if lock was acquired successfully; false otherwise

acquireNextTriggers

public List<org.quartz.spi.OperableTrigger> acquireNextTriggers(long noLaterThan,
                                                                int maxCount,
                                                                long timeWindow,
                                                                T jedis)
                                                         throws org.quartz.JobPersistenceException,
                                                                ClassNotFoundException

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

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.

maxCount - the maximum number of triggers to return

timeWindow - the time window within which the triggers must fire next

jedis - a thread-safe Redis connection

Returns:

the acquired triggers

Throws:

org.quartz.JobPersistenceException

ClassNotFoundException

releaseAcquiredTrigger

public void releaseAcquiredTrigger(org.quartz.spi.OperableTrigger trigger,
                                   T jedis)
                            throws org.quartz.JobPersistenceException

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

Parameters:

trigger - the trigger to be released

jedis - a thread-safe Redis connection

Throws:

org.quartz.JobPersistenceException

triggersFired

public abstract List<org.quartz.spi.TriggerFiredResult> triggersFired(List<org.quartz.spi.OperableTrigger> triggers,
                                                                      T jedis)
                                                               throws org.quartz.JobPersistenceException,
                                                                      ClassNotFoundException

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

Parameters:

triggers - a list of triggers

jedis - a thread-safe Redis connection

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.

Throws:

org.quartz.JobPersistenceException

ClassNotFoundException

isPersistJobDataAfterExecution

protected boolean isPersistJobDataAfterExecution(Class<? extends org.quartz.Job> jobClass)

triggeredJobComplete

public abstract void triggeredJobComplete(org.quartz.spi.OperableTrigger trigger,
                                          org.quartz.JobDetail jobDetail,
                                          org.quartz.Trigger.CompletedExecutionInstruction triggerInstCode,
                                          T jedis)
                                   throws org.quartz.JobPersistenceException,
                                          ClassNotFoundException

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

Parameters:

trigger - the trigger which was completed

jobDetail - the job which was completed

triggerInstCode - the status of the completed job

jedis - a thread-safe Redis connection

Throws:

org.quartz.JobPersistenceException

ClassNotFoundException

isNullOrEmpty

protected boolean isNullOrEmpty(String string)

Check if a string is null or empty

Parameters:

string - a string to check

Returns:

true if the string is null or empty; false otherwise