Quartz trigger state error

Instructs the Scheduler that the Trigger
has no further instructions.

Instructs the Scheduler that the Trigger
wants the org.quartz.JobDetail to re-execute
immediately. If not in a ‘RECOVERING’ or ‘FAILED_OVER’ situation, the
execution context will be re-used (giving the Job the
abilitiy to ‘see’ anything placed in the context by its last execution).

Instructs the Scheduler that the Trigger
should be put in the COMPLETE state.

Instructs the Scheduler that the Trigger
wants itself deleted.

Instructs the Scheduler that all Trigger
s referencing the same org.quartz.JobDetail as
this one should be put in the COMPLETE state.

Instructs the Scheduler that all Trigger
s referencing the same org.quartz.JobDetail as
this one should be put in the ERROR state.

Instructs the Scheduler that the Trigger
should be put in the ERROR state.

Instructs the Scheduler that upon a mis-fire
situation, the updateAfterMisfire() method will be called
on the Trigger to determine the mis-fire instruction.

In order to see if this instruction fits your needs, you should look at
the documentation for the getSmartMisfirePolicy() method
on the particular Trigger implementation you are using.

Indicates that the Trigger is in the «normal» state.

Indicates that the Trigger is in the «paused» state.

Indicates that the Trigger is in the «complete» state.

«Complete» indicates that the trigger has not remaining fire-times in
its schedule.

Indicates that the Trigger is in the «error» state.

A Trigger arrives at the error state when the scheduler
attempts to fire it, but cannot due to an error creating and executing
its related job. Often this is due to the Job‘s
class not existing in the classpath.

When the trigger is in the error state, the scheduler will make no
attempts to fire it.

Indicates that the Trigger is in the «blocked» state.

A Trigger arrives at the blocked state when the job that
it is associated with is a StatefulJob and it is
currently executing.

Also see:
StatefulJob

Indicates that the Trigger does not exist.

 public Trigger() 
{
    /*
    * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    *
    * Constructors.
    *
    * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    */
        // do nothing...
}


Create a Trigger with no specified name, group, or org.quartz.JobDetail .


Note that the #setName(String) ,#setGroup(String) and

the #setJobName(String) and #setJobGroup(String) methods

must be called before the Trigger can be placed into a

Scheduler .

 public Trigger(String name,
    String group) 
{
        setName(name);
        setGroup(group);
}


Create a Trigger with the given name, and group.


Note that the #setJobName(String) and

#setJobGroup(String) methods must be called before the Trigger

can be placed into a Scheduler .


Parameters:

group —  if null, Scheduler.DEFAULT_GROUP will be used.
Throws:



  


                       
  




IllegalArgumentException —

if name is null or empty, or the group is an empty string.
exception: IllegalArgumentException —

if name is null or empty, or the group is an empty string.

 public Trigger(String name,
    String group,
    String jobName,
    String jobGroup) 
{
        setName(name);
        setGroup(group);
        setJobName(jobName);
        setJobGroup(jobGroup);
}


Create a Trigger with the given name, and group.


Parameters:

group —  if null, Scheduler.DEFAULT_GROUP will be used.
Throws:
IllegalArgumentException —

if name is null or empty, or the group is an empty string.
exception: IllegalArgumentException —

if name is null or empty, or the group is an empty string.

 public  void addTriggerListener(String name) 
{
        if (triggerListeners.contains(name)) {
            throw new IllegalArgumentException(
                "Trigger listener '" + name + "' is already registered for trigger: " + getFullName());
        }
        triggerListeners.add(name);
}


Add the specified name of a TriggerListener  to

the end of the Trigger‘s list of listeners.

 public  void clearAllTriggerListeners() 
{
        triggerListeners.clear();
}
Remove all TriggerListener s from the Trigger.

 public Object clone() 
{
        Trigger copy;
        try {
            copy = (Trigger) super.clone();
            copy.triggerListeners = (LinkedList)triggerListeners.clone();
            // Shallow copy the jobDataMap.  Note that this means that if a user
            // modifies a value object in this map from the cloned Trigger
            // they will also be modifying this Trigger. 
            if (jobDataMap != null) {
                copy.jobDataMap = (JobDataMap)jobDataMap.clone();
            }
        } catch (CloneNotSupportedException ex) {
            throw new IncompatibleClassChangeError("Not Cloneable.");
        }
        return copy;
}

 public int compareTo(Object obj) 
{
        Trigger other = (Trigger) obj;
        Date myTime = getNextFireTime();
        Date otherTime = other.getNextFireTime();
        if (myTime == null && otherTime == null) {
            return 0;
        }
        if (myTime == null) {
            return 1;
        }
        if (otherTime == null) {
            return -1;
        }
        if(myTime.before(otherTime)) {
            return -1;
        }
        if(myTime.after(otherTime)) {
            return 1;
        }
        return 0;
}


Compare the next fire time of this Trigger to that of

another.

 abstract public Date computeFirstFireTime(Calendar calendar)

This method should not be used by the Quartz client.



Called by the scheduler at the time a Trigger is first
added to the scheduler, in order to have the Trigger
compute its first fire time, based on any associated calendar.



After this method has been called, getNextFireTime()
should return a valid answer.

 public boolean equals(Object obj) 
{
        if (!(obj instanceof Trigger)) {
            return false;
        }
        Trigger other = (Trigger) obj;
        if (!other.getName().equals(getName())) {
            return false;
        }
        if (!other.getGroup().equals(getGroup())) {
            return false;
        }
        return true;
}

 abstract public int executionComplete(JobExecutionContext context,
    JobExecutionException result)

This method should not be used by the Quartz client.



Called after the Scheduler  has executed the
org.quartz.JobDetail  associated with the Trigger
in order to get the final instruction code from the trigger.




  


                       
  

 public String getCalendarName() 
{
        return calendarName;
}


Get the name of the Calendar  associated with this

Trigger.

 public String getDescription() 
{
        return description;
}


Return the description given to the Trigger instance by

its creator (if any).

 abstract public Date getEndTime()

Get the time at which the Trigger should quit repeating -
even if an assigned 'repeatCount' isn't yet satisfied.

 abstract public Date getFinalFireTime()

Returns the last time at which the Trigger will fire, if
the Trigger will repeat indefinitely, null will be returned.



Note that the return time *may* be in the past.

 public String getFireInstanceId() 
{
        return fireInstanceId;
}


This method should not be used by the Quartz client.

 abstract public Date getFireTimeAfter(Date afterTime)

Returns the next time at which the Trigger will fire,
after the given time. If the trigger will not fire after the given time,
null will be returned.

 public String getFullJobName() 
{
        return jobGroup + "." + jobName;
}


Returns the ‘full name’ of the Job that the Trigger

points to, in the format «group.name».

 public String getFullName() 
{
        return group + "." + name;
}


Returns the ‘full name’ of the Trigger in the format

«group.name».

 public String getGroup() 
{
        return group;
}


Get the group of this Trigger.




  


                       
  

 public JobDataMap getJobDataMap() 
{
        if (jobDataMap == null) {
            jobDataMap = new JobDataMap();
        }
        return jobDataMap;
}


Get the JobDataMap that is associated with the

Trigger.


Changes made to this map during job execution are not re-persisted, and

in fact typically result in an IllegalStateException.

 public String getJobGroup() 
{
        return jobGroup;
}


Get the name of the associated org.quartz.JobDetail ‘s

group.

 public String getJobName() 
{
        return jobName;
}


Get the name of the associated org.quartz.JobDetail .

 public Key getKey() 
{
        if(key == null) {
            key = new Key(getName(), getGroup());
        }
        return key;
}

 public int getMisfireInstruction() 
{
        return misfireInstruction;
}


Get the instruction the Scheduler should be given for

handling misfire situations for this Trigger— the

concrete Trigger type that you are using will have

defined a set of additional MISFIRE_INSTRUCTION_XXX

constants that may be passed to this method.


If not explicitly set, the default value is MISFIRE_INSTRUCTION_SMART_POLICY.

 public String getName() 
{
        return name;
}


Get the name of this Trigger.

 abstract public Date getNextFireTime()

Returns the next time at which the Trigger will fire. If
the trigger will not fire again, null will be returned.
The value returned is not guaranteed to be valid until after the Trigger
has been added to the scheduler.

 abstract public Date getPreviousFireTime()

Returns the previous time at which the Trigger will fire.
If the trigger has not yet fired, null will be returned.

 public int getPriority() 
{
        return priority;
}
The priority of a Trigger acts as a tiebreaker such that if

two Triggers have the same scheduled fire time, then the

one with the higher priority will get first access to a worker

thread.




  


                       
  





If not explicitly set, the default value is 5.

 abstract public Date getStartTime()

Get the time at which the Trigger should occur.

 public String[] getTriggerListenerNames() 
{
        return (String[])triggerListeners.toArray(new String[triggerListeners.size()]);
}


Returns an array of String containing the names of all

TriggerListener s assigned to the Trigger,

in the order in which they should be notified.

 public int hashCode() 
{
        return getFullName().hashCode();
}

 public boolean isVolatile() 
{
        return volatility;
}


Whether or not the Trigger should be persisted in the

org.quartz.spi.JobStore  for re-use after program

restarts.


If not explicitly set, the default value is false.

 abstract public boolean mayFireAgain()

Used by the Scheduler  to determine whether or not
it is possible for this Trigger to fire again.



If the returned value is false then the Scheduler
may remove the Trigger from the org.quartz.spi.JobStore .

 public boolean removeTriggerListener(String name) 
{
        return triggerListeners.remove(name);
}


Remove the specified name of a TriggerListener 

from the Trigger‘s list of listeners.

 public  void setCalendarName(String calendarName) 
{
        this.calendarName = calendarName;
}


Associate the Calendar  with the given name with

this Trigger.

 public  void setDescription(String description) 
{
        this.description = description;
}


Set a description for the Trigger instance — may be

useful for remembering/displaying the purpose of the trigger, though the

description has no meaning to Quartz.




  


                       
  

 abstract public  void setEndTime(Date endTime)

 public  void setFireInstanceId(String id) 
{
        this.fireInstanceId = id;
}


This method should not be used by the Quartz client.


Usable by org.quartz.spi.JobStore 

implementations, in order to facilitate ‘recognizing’ instances of fired

Trigger s as their jobs complete execution.

 public  void setGroup(String group) 
{
        if (group != null && group.trim().length() == 0) {
            throw new IllegalArgumentException(
                    "Group name cannot be an empty string.");
        }
        if(group == null) {
            group = Scheduler.DEFAULT_GROUP;
        }
        this.group = group;
}


Set the name of this Trigger.

 public  void setJobDataMap(JobDataMap jobDataMap) 
{
        this.jobDataMap = jobDataMap;
}


Set the JobDataMap to be associated with the

Trigger.

 public  void setJobGroup(String jobGroup) 
{
        if (jobGroup != null && jobGroup.trim().length() == 0) {
            throw new IllegalArgumentException(
                    "Group name cannot be null or empty.");
        }
        if(jobGroup == null) {
            jobGroup = Scheduler.DEFAULT_GROUP;
        }
        this.jobGroup = jobGroup;
}


Set the name of the associated org.quartz.JobDetail ‘s

group.

 public  void setJobName(String jobName) 
{
        if (jobName == null || jobName.trim().length() == 0) {
            throw new IllegalArgumentException(
                    "Job name cannot be null or empty.");
        }
        this.jobName = jobName;
}


Set the name of the associated org.quartz.JobDetail .

 public  void setMisfireInstruction(int misfireInstruction) 
{
        if (!validateMisfireInstruction(misfireInstruction)) {
            throw new IllegalArgumentException(
                        "The misfire instruction code is invalid for this type of trigger.");
        }
        this.misfireInstruction = misfireInstruction;
}


Set the instruction the Scheduler should be given for

handling misfire situations for this Trigger— the

concrete Trigger type that you are using will have

defined a set of additional MISFIRE_INSTRUCTION_XXX

constants that may be passed to this method.


If not explicitly set, the default value is MISFIRE_INSTRUCTION_SMART_POLICY.

 public  void setName(String name) 
{
        if (name == null || name.trim().length() == 0) {
            throw new IllegalArgumentException(
                    "Trigger name cannot be null or empty.");
        }
        this.name = name;
}


Set the name of this Trigger.

 public  void setPriority(int priority) 
{
        this.priority = priority;
}
The priority of a Trigger acts as a tiebreaker such that if

two Triggers have the same scheduled fire time, then the

one with the higher priority will get first access to a worker

thread.




  


                       
  





If not explicitly set, the default value is 5.

 abstract public  void setStartTime(Date startTime)

 public  void setVolatility(boolean volatility) 
{
        this.volatility = volatility;
}


Set whether or not the Trigger should be persisted in the

org.quartz.spi.JobStore  for re-use after program

restarts.

 public String toString() 
{
        return "Trigger '" + getFullName() + "':  triggerClass: '"
                + getClass().getName() + " isVolatile: " + isVolatile()
                + " calendar: '" + getCalendarName() + "' misfireInstruction: "
                + getMisfireInstruction() + " nextFireTime: " + getNextFireTime();
}


Return a simple string representation of this object.

 abstract public  void triggered(Calendar calendar)

This method should not be used by the Quartz client.



Called when the Scheduler  has decided to 'fire'
the trigger (execute the associated Job), in order to
give the Trigger a chance to update itself for its next
triggering (if any).

 abstract public  void updateAfterMisfire(Calendar cal)

This method should not be used by the Quartz client.



To be implemented by the concrete classes that extend this class.



The implementation should update the Trigger's state
based on the MISFIRE_INSTRUCTION_XXX that was selected when the Trigger
was created.

 abstract public  void updateWithNewCalendar(Calendar cal,
    long misfireThreshold)

This method should not be used by the Quartz client.



To be implemented by the concrete class.




  


                       
  






The implementation should update the Trigger's state
based on the given new version of the associated Calendar
(the state should be updated so that it's next fire time is appropriate
given the Calendar's new settings).

 public  void validate() throws SchedulerException 
{
        if (name == null) {
            throw new SchedulerException("Trigger's name cannot be null",
                        SchedulerException.ERR_CLIENT_ERROR);
        }
        if (group == null) {
            throw new SchedulerException("Trigger's group cannot be null",
                        SchedulerException.ERR_CLIENT_ERROR);
        }
        if (jobName == null) {
            throw new SchedulerException(
                        "Trigger's related Job's name cannot be null",
                        SchedulerException.ERR_CLIENT_ERROR);
        }
        if (jobGroup == null) {
            throw new SchedulerException(
                        "Trigger's related Job's group cannot be null",
                        SchedulerException.ERR_CLIENT_ERROR);
        }
}


Validates whether the properties of the JobDetail are

valid for submission into a Scheduler.

 abstract protected boolean validateMisfireInstruction(int misfireInstruction)