We Keep Coding

Dynamically Adding jobs to a running Quartz scheduler from different executable

I have a started scheduler and have one job running on it. This is the main scheduler thread I shall be running.
public class MyApp {
Scheduler scheduler1;
public static void main(String[] args) {
run();
}
public static void run(){
try {
JobDetail job = JobBuilder.newJob(Job.class)
.withIdentity("JoeyJob", "group1").build();
Trigger trigger1 = TriggerBuilder.newTrigger()
.withIdentity("cronTrigger1", "group1")
.withSchedule(CronScheduleBuilder.cronSchedule("0/10 * * * * ?"))
.build();
scheduler1 = new StdSchedulerFactory().getScheduler();
scheduler1.start();
System.out.println(scheduler1.getSchedulerInstanceId());
scheduler1.scheduleJob(job,trigger1);
Thread.sleep(1000000);
scheduler1.shutdown();
}
catch(Exception e){
e.printStackTrace();
}
}
I wish to run another another job with a trigger on the very same scheduler but I need to access it from a different java executable using probably the scheduler name or any such parameter. I realize that the scheduler name returns something like 'defaultScheduler' and the Instance ID returns 'NON_CLUSTERED' I need to develop an application to run a single scheduler thread and constantly add/remove update jobs of sending emails. As this will be initialized used by a servlet. Is there a way I can access this scheduler from the memory from a different executable instance. This is what I am looking for.
public class Test {
public static void main(String[] args) throws SchedulerException {
run();
}
public static void run()throws SchedulerException{
JobDetail job = JobBuilder.newJob(Job2.class)
.withIdentity("Jake", "group2").build();
Trigger trigger1 = TriggerBuilder.newTrigger()
.withIdentity("cronTrigger2", "group1")
.withSchedule(CronScheduleBuilder.cronSchedule("0/2 * * * * ?"))
.build();
Scheduler scheduler= new StdSchedulerFactory().getScheduler("scheduler-name-something");
scheduler.scheduleJob(job,trigger1);
}
}
Is there a way to use the Scheduler Instance ID and the Scheduler Name to do this?

I checked the documentation, there is no way to do what I was looking for.

Run 2 parts through one cron job

I am using quartz with cron to schedule 2 jobs . One runs at 12:00 and the other at 14:00 and it runs perfectly. Here's my code.
#Override
public void contextInitialized(ServletContextEvent servletContextEvent) {
JobDetail job1 = JobBuilder.newJob(FirstInvoiceGeneration.class)
.withIdentity("FirstInvoiceGenerationJob", "group1").build();
Trigger trigger1 = TriggerBuilder
.newTrigger()
.withIdentity("FirstInvoiceGenerationTrigger", "group1")
.withSchedule(CronScheduleBuilder.cronSchedule("0 0 12 * * ?")).build();
//Simple invoice generation to check which invoice to be generated today
JobDetail job2 = JobBuilder.newJob(TodayInvoiceGeneration.class)
.withIdentity("TodayInvoiceGenerationJob", "group1").build();
Trigger trigger2 = TriggerBuilder
.newTrigger()
.withIdentity("TodayInvoiceGenerationTrigger", "group1")
.withSchedule(CronScheduleBuilder.cronSchedule(0 0 14 * * ?")).build();
//Schedule it
Scheduler scheduler;
try {
scheduler = new StdSchedulerFactory().getScheduler();
scheduler.start();
scheduler.scheduleJob(job1, trigger1);
scheduler.scheduleJob(job2, trigger2);
} catch (SchedulerException e) {
e.printStackTrace();
}
}}
My two classes for running two jobs are :
public class FirstInvoiceGeneration implements Job {
#Override
public void execute(JobExecutionContext arg0)
throws JobExecutionException {
System.out.println("Listener running.");
}
}
my second class for second job is
public class FirstInvoiceGeneration implements Job {
#Override
public void execute(JobExecutionContext arg0)
throws JobExecutionException {
System.out.println("Listener running.");
}
}
Now this runs perfectly , but what i want to do is to have 1 job that runs these two codes. Now i can use this cron expression --> "0 0 12,14 * * ?"
this will make the job run at 12pm , 2pm (my guess :p ). But i want to have only one class that execute one code when time is 12pm and other when time is 2pm. So can someone tell me how i can do it?

Reference. As you can see you can send data to a job by usingJobData() method to a job e.g. ("WORK","FIRST"),("WORK","SECOND").
In a single job class only check for the WORK key and accordingly do the operations you want to do. JobExecutionContext you can retrieve the job data using context.getJobDetails().getJobDataMap()

Running a method once a week at a particular time

I looked all over the place. I looked through Timers and Quartz and I am still confused.
I have a huge class performing different methods. One of those methods is a synchronized method:
public void onSynch()
{
String environment = validateEnvironment(env2);
if (environment == null) return;
try
{
RAT.synchronize(environment);
onSelectEnv();
}
catch (Exception e)
{
// TODO: tell user, log
}
}
I need to be able to create a timer that triggers this method alone once a week at a particular time, every Friday and 3:00 PM for example.
I cannot create separate classes.
I need to be able to put the scheduler inside of this method, or create another method next to it that would create a scheduler and run that sync method.

I would like to suggest to use QUARTZ or Spring Batch for scheduler job.
Try below Quartz Example.
Reference : CronTrigger Tutorial, Example
YourJob.java
public class YourJob implements Job {
public void execute(JobExecutionContext context) throws JobExecutionException {
//here your operation
}
}
MySchedule.java
public class MySchedule {
public void startUp() throws Exception {
SchedulerFactory sf = new StdSchedulerFactory();
Scheduler scheduler = sf.getScheduler();
JobDetail yourJob = JobBuilder.newJob(YourJob.class).withIdentity("job1", "group1").build();
/*Run every 30 seconds on Weekdays (Monday through Friday)*/
Trigger trigger_1 = TriggerBuilder.newTrigger()
.withIdentity("trigger1", "group1")
.withSchedule(CronScheduleBuilder.cronSchedule("0,30 * * ? * MON-FRI"))
.build();
/*Run at 10am on the 1st and 15th days of the month*/
Trigger trigger_2 = TriggerBuilder.newTrigger()
.withIdentity("trigger2", "group1")
.withSchedule(CronScheduleBuilder.cronSchedule("0 0 10am 1,15 * ?"))
.build();
/*Run at 3:30PM of every friday f month*/
Trigger trigger_3 = TriggerBuilder.newTrigger()
.withIdentity("trigger3", "group1")
.withSchedule(CronScheduleBuilder.cronSchedule("0 18 30 ? * 6"))
.build();
scheduler.start();
scheduler.scheduleJob(yourJob, trigger_1);
scheduler.scheduleJob(yourJob, trigger_2);
scheduler.scheduleJob(yourJob, trigger_3);
}
}

How to reschedule the job execution interval in Quartz?

I am a bit new to Quartz. Is there a way to update the job execution interval for an already submitted Quartz job? Does this interval get updated immediately? Do you have to start the job once again after rescheduling it?
I found the following link but I don't know which libraries is the code referring to since my quartz jars don't contain some of the classes used in the link. Also, where did the triggerKey method come from? Is this some kind of a static import?
http://www.quartz-scheduler.org/documentation/2.4.0-SNAPSHOT/cookbook/UpdateTrigger.html
I want to update the job execution interval to a very large number in one of my JUnit test cases since I don't want the job to interfere with the state of the class under test. Once the test case completes, I want to reset the the job execution interval to the actual value that will be used in production

You have to reschedule the job by creating a new trigger.
public void execute(JobExecutionContext context) throws JobExecutionException {
Trigger newTrigger = what_ever_you_want;
Trigger oldTrigger = context.getTrigger();
Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
scheduler.rescheduleJob(oldTrigger.getKey(), newTrigger);
}
This will replace the same job with a new trigger fire time.

Perhaps there is a static method triggerKey() somewhere in the Quartz library. However, I managed to reschedule an existing Quartz job (using Quartz 2.3.2) without using this (potential) method, but rather using the TriggerKey class as follows:
boolean updateExisting = true; // try it also with false
int aveId = 1234; // change it as you wish
java.util.Date closeDate = new java.util.Date(); // change it as you wish
SchedulerFactory sf = new StdSchedulerFactory("... /quartz_priority.properties");
Scheduler scheduler = sf.getScheduler();
TriggerKey triggerKey = new TriggerKey("trigger" + aveId, "group1");
if (updateExisting) {
Trigger oldTrigger = scheduler.getTrigger(triggerKey);
TriggerBuilder oldTriggerBuilder = oldTrigger.getTriggerBuilder();
Trigger newTrigger = oldTriggerBuilder.startAt(closeDate).build();
scheduler.rescheduleJob(triggerKey, newTrigger);
} else {
Trigger trigger = TriggerBuilder.newTrigger().withIdentity(triggerKey).startAt(closeDate).build();
// Define job instance
JobDetail job1 = JobBuilder.newJob(<YOUR_JOB_CLASS_NAME>.class).withIdentity("job" + aveId, "group1").build();
JobDataMap map = job1.getJobDataMap();
map.put(<PARAMETER_NAME>, aveId);
// Schedule the job with the trigger
scheduler.scheduleJob(job1, trigger);
}

Firing Quartz jobs manually

We have several Quartz jobs configured in our application. During development, we leave the quartz scheduler in standby - however, we sometimes want to start a job manually (for development purposes). If I call fireTrigger, it tells me I need to start the scheduler. However, if I start the scheduler, it will also immediately schedule all the other jobs, which is not what I want (since they may trigger while I'm debugging the manually fired job).
I could pause all triggers when I start the scheduler, but then I have to deal with misfire instructions etc.
Is there a simple way to fire off a job manually without having to deal with pausing and misfires (i.e. a fireTrigger which works even if the scheduler is in standby)?

this is the loop you will require to fire the job manually:
SchedulerFactory stdSchedulerFactory = new StdSchedulerFactory();
Scheduler scheduler = stdSchedulerFactory.getScheduler();
// loop jobs by group
for (String groupName : scheduler.getJobGroupNames()) {
// get jobkey
for (JobKey jobKey : scheduler.getJobKeys(GroupMatcher.jobGroupEquals(groupName))) {
String jobName = jobKey.getName();
String jobGroup = jobKey.getGroup();
scheduler.triggerJob(jobName, jobGroup);
}
}

All the Jobs registered in the Quartz Scheduler are uniquely identified by the JobKey which is composed of a name and group . You can fire the job which has a given JobKey immediately by calling triggerJob(JobKey jobKey) of your Scheduler instance.
// Create a new Job
JobKey jobKey = JobKey.jobKey("myNewJob", "myJobGroup");
JobDetail job = JobBuilder.newJob(MyJob.class).withIdentity(jobKey).storeDurably().build();
// Register this job to the scheduler
scheduler.addJob(job, true);
// Immediately fire the Job MyJob.class
scheduler.triggerJob(jobKey);
Note:
scheduler is the Scheduler instance used throughout your application . Its start() method should be already called after it is created.
The job is the durable job which cannot attach any triggers or cron to it .It can only be fired programmatically by calling `triggerJob(JobKey jobKey)`.

You can try to add a trigger filter in your scheduler
this.scheduler.addGlobalTriggerListener(new DebugExecutionFilter());
The debug execution filter will add a veto when the execution is not volatile (not scheduled to run immediately) and you are in debug mode .
Here is an implementation example :
private static class DebugExecutionFilter implements TriggerListener
{
public DebugExecutionFilter()
{
}
#Override
public String getName()
{
return "Task execution filter";
}
#Override
public void triggerFired(Trigger trigger, JobExecutionContext context)
{
// Do nothing
}
/* (non-Javadoc)
*
* #see org.quartz.TriggerListener#vetoJobExecution(org.quartz.Trigger, org.quartz.JobExecutionContext) */
#Override
#SuppressWarnings("unchecked")
/**
* A veto is added if :
* - For non volatile trigger if we are in debug mode
*/
public boolean vetoJobExecution(Trigger trigger, JobExecutionContext context)
{
try
{
//
if ( !trigger.isVolatile() && isDebugMode() )
{
return true;
}
//task is run by scheduler.triggerJobWithVolatileTrigger() for immediate schedule
//or task is schedule and we are not in debugMode
return false;
}
#Override
public void triggerMisfired(Trigger trigger)
{
// do nothing
}
#Override
public void triggerComplete(Trigger trigger, JobExecutionContext context, int triggerInstructionCode)
{
// do nothing
}
}

No need for start-time and end-time.
<trigger>
<cron>
<name>TestTrigger</name>
<group>CronSampleTrigger</group>
<description>CronSampleTrigger</description>
<job-name>TestJob</job-name>
<job-group>jobGroup1</job-group>
<!--<start-time>1982-06-28T18:15:00.0Z</start-time>
<end-time>2020-05-04T18:13:51.0Z</end-time>-->
<cron-expression>0 0/1 * * * ?</cron-expression>
</cron>
</trigger>