Consider the following sequence of events. Using quartz 1.8.0
<dependency>
<groupId>org.quartz-scheduler</groupId>
<artifactId>quartz</artifactId>
<version>1.8.0</version>
</dependency>
I schedule a job to be executed in the future
job.setGroup(MY_GROUP);
Date date = scheduler.scheduleJob(job, trigger); // Valid date received
Job executes as expected.
I then try to delete the job by running
boolean unscheduled = scheduler.deleteJob(event.getName(), MY_GROUP); // Always false
Attempt to delete the job always results in **false**
If i let the application to run past the time it was scheduled to execute, after having failed to delete it, it ... does not run (as if it was deleted successfully)
What could explain such a behavior? How can i know what is scheduled in quartz as part of the group?
EDIT:
Trigger is set as:
SimpleTrigger trigger = new SimpleTrigger();
trigger.setStartTime(new Date(event.getStartTime().inMillis()));
trigger.setName("trigger" + event.getTriggerName());
trigger.setRepeatInterval(event.getFrequency());
trigger.setRepeatCount(SimpleTrigger.REPEAT_INDEFINITELY);
What trigger are you using? If you haven't specified that the trigger should fire multiple times e.g. on a recurring interval, then it will only fire once and will then be discarded; if your job detail isn't durable then the scheduler will automatically remove it once no more triggers point to it.
Related
I'm using Quartz Scheduler in Java to schedule jobs based on entries in a database. I'm trying to automate disabling those entries when they will never run again, so I don't try to read them every time the application starts.
I have a cron for a very specific date, for example 0 25 12 4 DEC ? 2021. That is a specific date, it has passed, and cannot ever fire again.
I build a chrontrigger and check endTrigger.getFinalFireTime() and it returns null, which I believe should only happen when the cron allows future firing.
// Build the end cron trigger
CronTrigger endTrigger = TriggerBuilder.newTrigger()
.withIdentity("eventEndCron", "quartzGroup")
.withSchedule(CronScheduleBuilder.cronSchedule("0 25 12 4 DEC ? 2021"))
.forJob("eventEnd", "quartzGroup")
.build();
If I try to schedule the job, it throws an error Based on configured schedule, the given trigger 'quartzGroup.eventStartCron' will never fire.
Why isn't getFinalFireTime giving me a date? Is there some other approach I need to use?
I have a simple trigger which trigger a simple job (let's assume - send an email).
My trigger:
return newTrigger()
.withIdentity(name, group)
.withSchedule(
simpleSchedule()
.withMisfireHandlingInstructionNextWithExistingCount()
)
.startAt(triggerStartTime)
.usingJobData(JobDataMap(triggerData))
.withDescription(description)
.build()
But, imagine that service will not available at triggerStartTime fired time (I just shut down database and my service). Some time later, when I run my service again - in log I see, that the trigger was executed.
UPD #1:
It reproduces when I create simple trigger which should start the next minute, after that I shut down all environments (app+db) and then turn it on during the minute when trigger should fire. Check it:
16:00:00 create trigger which should fire 16:01:00
turn off all environments
wait 16:01:59
turn on and observe that trigger fire
But if I turn on all environments after 16:02:00 it will not fire trigger. It is very strange behavior. Also, I observe, that in this case trigger was not removed from database.
There is a property in quartz to control misfire threshold org.quartz.jobStore.misfireThreshold
The number of milliseconds the scheduler will 'tolerate' a trigger to pass its next-fire-time by, before being considered "misfired". The default value (if you don’t make an entry of this property in your configuration) is 60000 (60 seconds).
Link to configuration document
I think if the exceeded time is below 1 minute(default value), the scheduler still considers that job is pending for normal execution. Try playing with that number.
and this is the actual query fired to get the triggers to be executed, note the second condition in the below query is based on the misfireThreshold property
Link to query
I have a spring boot application in which I am trying to schedule a job using quartz scheduler to run daily at a specific time of the day. The following is my code to build the trigger.
DailyTimeIntervalScheduleBuilder scheduleBuilder = DailyTimeIntervalScheduleBuilder
.dailyTimeIntervalSchedule()
.startingDailyAt(TimeOfDay.hourAndMinuteFromDate(activeStartTime))
.endingDailyAfterCount(1)
.withMisfireHandlingInstructionFireAndProceed();
MutableTrigger trigger = scheduleBuilder.build();
The problem I am facing is that the job is scheduled but starting from the next day. So for instance, if I schedule the job for May 22 16:45, then the first fire time for the job is set to May 23 16:45.
I have tried using the builder with withIntervalInHours(24) instead of endingDailyAfterCount(1), but the result is the same.
I am not sure what seems to be the problem.
Note: This behavior is the same regardless of when I schedule my job, i.e., it doesn't matter if I execute this code before or after 16:45, the job is always scheduled for the next day
I am using spring boot version 1.5.10 and spring-boot-starter-quartz version 2.2.5.RELEASE
Can you try below code
CalendarIntervalScheduleBuilder schedule = CalendarIntervalScheduleBuilder
.calendarIntervalSchedule()
.inTimeZone(TimeZone.getDefault())
.withIntervalInDays((int) 1)
.withMisfireHandlingInstructionFireAndProceed();
Trigger trigger = TriggerBuilder
.newTrigger()
.startAt(startDateTime)
.withSchedule(schedule).build();
For the field startDateTime please use current Date time. if you want to start from May 22 16:45 then create the Date object accordingly.
And set the timezone also, or it will pick default system's timezone.
I have some repeating quartz jobs that use SimpleScheduleBuilder.repeatMinutelyForever(60). Lets say the job initially gets scheduled at 10:02am and runs for 5 minutes completing at 10:07am.
Right now it is getting scheduled to run again at 11:02am but I want it to run again 60 minutes after completing so it should be scheduled at 11:07am instead.
Is there any way to change the scheduling to do this? Or should I use a one time job that creates a new job each time it completes?
Use TriggerListener - see here for some examples in Quartz cookbook.
You will override triggerComplete and in there you will add your rescheduling code:
public void triggerComplete(Trigger trigger, JobExecutionContext context, CompletedExecutionInstruction triggerInstructionCode) {
// check here the triggerInstructionCode value and reschedule your job
super.triggerComplete(trigger, context, triggerInstructionCode);
}
Example for registering a TriggerListener with the scheduler to listen to a specific trigger:
scheduler.getListenerManager().addTriggerListener(myTriggerListener, keyEquals(triggerKey("myTriggerName", "myTriggerGroup")));
See also this answer.
You can place a Quartz scheduler in stand-by mode. During this time all triggers will not fire neither jobs being executed. But what happend if the standby(); command comes up during a job that is in the middle of its execution, let's say it is in the middle of writing a file?
example:
*// start() was previously invoked on the scheduler
scheduler.standby();
// now the scheduler will not fire triggers / execute jobs
// ...
scheduler.start();
// now the scheduler will fire triggers and execute jobs*
I believe calling standby() will only stop further execution of triggers, it will not stop or abort any jobs that are already executing.