public TaskServicesRunner()
{
//获取默认任务调度器
scheduler = StdSchedulerFactory.GetDefaultScheduler();
majorTaskInfo = new TB_TM_TaskInfo()
{
TaskId = -1,
TaskType = TaskType.IJob.ToString(),
TaskName = System.Configuration.ConfigurationManager.AppSettings["MajorTaskName"],
Description = System.Configuration.ConfigurationManager.AppSettings["MajorTaskDescription"],
CronExpression = System.Configuration.ConfigurationManager.AppSettings["MajorTaskCronExpression"],
CronExpressionDescription = System.Configuration.ConfigurationManager.AppSettings["MajorTaskCronExpressionDescription"],
};
//scheduler.ListenerManager.AddSchedulerListener(new SchedulerListener());
scheduler.ListenerManager.AddJobListener(new SchedulerJobListener(), GroupMatcher <JobKey> .GroupStartsWith("TaskGroup."));
var job = JobBuilder.Create <MajorTask>()
.WithIdentity(majorTaskInfo.TaskName + ".TaskName", majorTaskInfo.TaskName + ".TaskGroup")
.Build();
job.JobDataMap.Add("TaskInfo", JsonConvert.SerializeObject(majorTaskInfo));
var trigger = TriggerBuilder.Create()
.StartNow()
.WithIdentity(majorTaskInfo.TaskName + ".TriggerName", majorTaskInfo.TaskName + ".TriggerGroup")
.WithCronSchedule(majorTaskInfo.CronExpression)
.Build();
scheduler.ScheduleJob(job, trigger);
}
public void ResumeTrigger_UseStartsWithOperator_Successfully()
{
//arrange
var job = CreateJob();
var trigger1 = CreateTrigger("trigger1", "trigger1Group", job.Key);
var trigger2 = CreateTrigger("trigger2", "trigger1Group", job.Key);
var trigger3 = CreateTrigger("trigger3", "triggerGroup1", job.Key);
var trigger4 = CreateTrigger("trigger4", "triggerGroup1", job.Key);
JobStore.StoreJob(job, true);
JobStore.StoreTrigger(trigger1, true);
JobStore.StoreTrigger(trigger2, true);
JobStore.StoreTrigger(trigger3, true);
JobStore.StoreTrigger(trigger4, true);
JobStore.PauseTriggers(GroupMatcher <TriggerKey> .GroupStartsWith("trigger1"));
//act
var resumedGroups = JobStore.ResumeTriggers(GroupMatcher <TriggerKey> .GroupStartsWith("trigger1")).Result;
//assert
Assert.IsTrue(resumedGroups.Count == 1);
Assert.AreEqual(TriggerState.Normal, JobStore.GetTriggerState(trigger1.Key).Result);
Assert.AreEqual(TriggerState.Normal, JobStore.GetTriggerState(trigger2.Key).Result);
}
/// <summary>
/// 删除指定分组的Jobs
/// </summary>
/// <param name="group">Job分组名称</param>
/// <param name="compareWith">分组名称匹配规则</param>
/// <returns>true if all of the Jobs were found and deleted, false if one or more were not</returns>
public static async Task <bool> DeleteJobsAsync(string group, StringOperator compareWith)
{
GroupMatcher <JobKey> matcher;
if (Equals(compareWith, StringOperator.Contains))
{
matcher = GroupMatcher <JobKey> .GroupContains(group);
}
else if (Equals(compareWith, StringOperator.EndsWith))
{
matcher = GroupMatcher <JobKey> .GroupEndsWith(group);
}
else if (Equals(compareWith, StringOperator.Equality))
{
matcher = GroupMatcher <JobKey> .GroupEquals(group);
}
else if (Equals(compareWith, StringOperator.StartsWith))
{
matcher = GroupMatcher <JobKey> .GroupStartsWith(group);
}
else
{
matcher = GroupMatcher <JobKey> .AnyGroup();
}
return(await GetScheduler().DeleteJobs((await GetScheduler().GetJobKeys(matcher)).ToList()));
}
public async Task UnscheduleAllAsync(CancellationToken cancellationToken)
{
var scheduler = await _schedulerProvider.GetSchedulerAsync(cancellationToken);
var jobKeys = await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupStartsWith("workflow-instance"), cancellationToken);
await scheduler.DeleteJobs(jobKeys, cancellationToken);
}
public void GetJobKeys_UseStartsWithOperator_Successfully()
{
//arrange
JobStore.StoreJob(CreateJob("job1", "groups1"), true);
JobStore.StoreJob(CreateJob("job2", "groups2"), true);
JobStore.StoreJob(CreateJob("job3", "groups3"), true);
//act
var jobKeys = JobStore.GetJobKeys(GroupMatcher <JobKey> .GroupStartsWith("groups")).Result;
//assert
Assert.IsTrue(jobKeys.Count == 3);
}
public void ResumeJobs_UseStartsWithOperator_Successfully()
{
//arrange
var jobsAndTriggers = CreateJobsAndTriggers(2, 1, 1, 1);
JobStore.StoreJobsAndTriggers(jobsAndTriggers, false);
JobStore.PauseJobs(GroupMatcher <JobKey> .GroupStartsWith("jobGroup_"));
//act
var resumedJobGroups = JobStore.ResumeJobs(GroupMatcher <JobKey> .GroupStartsWith("jobGroup_")).Result;
//assert
Assert.IsTrue(resumedJobGroups.Count == 2);
}
public void GetTriggerKeys_UseStartsWithOperator_Successfully()
{
//arrange
var job = CreateJob();
JobStore.StoreJob(job, false);
JobStore.StoreTrigger(CreateTrigger("trigger1", "tGroup", job.Key), false);
JobStore.StoreTrigger(CreateTrigger("trigger2", "tGroup", job.Key), false);
JobStore.StoreTrigger(CreateTrigger("trigger3", "tGroup1", job.Key), false);
JobStore.StoreTrigger(CreateTrigger("trigger4", "tGroup1", job.Key), false);
//act
var triggerKeys = JobStore.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupStartsWith("tGroup")).Result;
//assert
Assert.IsTrue(triggerKeys.Count == 4);
}
public SchedulerModel(IScheduler scheduler)
{
//get triggers
//get job groups and jobs
foreach (string groupName in scheduler.GetJobGroupNames())
{
var jobs = scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupStartsWith(groupName));
List <JobModel> jobModels = new List <JobModel>();
foreach (JobKey jobKey in jobs)
{
jobModels.Add(new JobModel(scheduler, jobKey));
}
_jobGroups.Add(new JobGroup(groupName, jobModels));
}
}
private GroupMatcher <T> GetGroupMatcher <T>() where T : Key <T>
{
if (!string.IsNullOrWhiteSpace(NameContains))
{
return(GroupMatcher <T> .GroupContains(NameContains));
}
if (!string.IsNullOrWhiteSpace(NameStartsWith))
{
return(GroupMatcher <T> .GroupStartsWith(NameStartsWith));
}
if (!string.IsNullOrWhiteSpace(NameEndsWith))
{
return(GroupMatcher <T> .GroupEndsWith(NameEndsWith));
}
if (!string.IsNullOrWhiteSpace(NameEquals))
{
return(GroupMatcher <T> .GroupEquals(NameEquals));
}
return(GroupMatcher <T> .AnyGroup());
}
public void PauseTriggers_UseStartsWithOperator_Successfully()
{
//arrange
var job = CreateJob();
JobStore.StoreJob(job, true);
JobStore.StoreTrigger(CreateTrigger("trigger1", "triggerGroup", job.Key), true);
JobStore.StoreTrigger(CreateTrigger("trigger2", "triggerGroup", job.Key), true);
JobStore.StoreTrigger(CreateTrigger("trigger3", "triggerfoobarGroup1", job.Key), true);
JobStore.StoreTrigger(CreateTrigger("trigger4", "triggerfoobarGroup1", job.Key), true);
//act
var pausedGroups = JobStore.PauseTriggers(GroupMatcher <TriggerKey> .GroupStartsWith("triggerfooba")).Result;
//assert
Assert.IsTrue(pausedGroups.Count == 1);
Assert.AreEqual(TriggerState.Paused, JobStore.GetTriggerState(new TriggerKey("trigger3", "triggerfoobarGroup1")).Result);
Assert.AreEqual(TriggerState.Paused, JobStore.GetTriggerState(new TriggerKey("trigger4", "triggerfoobarGroup1")).Result);
}
public void PauseJobs_UseStartsWithOperator_Successfully()
{
//arrange
var job = CreateJob("job1", "startGroup");
var trigger1 = CreateTrigger("trigger1", "triggerGroup1", job.Key);
var trigger2 = CreateTrigger("trigger2", "triggerGroup2", job.Key);
var triggerSet = new HashSet <ITrigger> {
trigger1, trigger2
};
this.StoreJobAndTriggers(job, triggerSet);
//act
var pausedJobs = JobStore.PauseJobs(GroupMatcher <JobKey> .GroupStartsWith("start")).Result;
//assert
Assert.IsTrue(pausedJobs.Count == 1);
Assert.AreEqual(TriggerState.Paused, JobStore.GetTriggerState(trigger1.Key).Result);
Assert.AreEqual(TriggerState.Paused, JobStore.GetTriggerState(trigger2.Key).Result);
}
public void Test(IScheduler scheduler, bool clearJobs, bool scheduleJobs)
{
try
{
if (clearJobs)
{
scheduler.Clear();
}
if (scheduleJobs)
{
ICalendar cronCalendar = new CronCalendar("0/5 * * * * ?");
ICalendar holidayCalendar = new HolidayCalendar();
// QRTZNET-86
ITrigger t = scheduler.GetTrigger(new TriggerKey("NonExistingTrigger", "NonExistingGroup"));
Assert.IsNull(t);
AnnualCalendar cal = new AnnualCalendar();
scheduler.AddCalendar("annualCalendar", cal, false, true);
IOperableTrigger calendarsTrigger = new SimpleTriggerImpl("calendarsTrigger", "test", 20, TimeSpan.FromMilliseconds(5));
calendarsTrigger.CalendarName = "annualCalendar";
JobDetailImpl jd = new JobDetailImpl("testJob", "test", typeof(NoOpJob));
scheduler.ScheduleJob(jd, calendarsTrigger);
// QRTZNET-93
scheduler.AddCalendar("annualCalendar", cal, true, true);
scheduler.AddCalendar("baseCalendar", new BaseCalendar(), false, true);
scheduler.AddCalendar("cronCalendar", cronCalendar, false, true);
scheduler.AddCalendar("dailyCalendar", new DailyCalendar(DateTime.Now.Date, DateTime.Now.AddMinutes(1)), false, true);
scheduler.AddCalendar("holidayCalendar", holidayCalendar, false, true);
scheduler.AddCalendar("monthlyCalendar", new MonthlyCalendar(), false, true);
scheduler.AddCalendar("weeklyCalendar", new WeeklyCalendar(), false, true);
scheduler.AddCalendar("cronCalendar", cronCalendar, true, true);
scheduler.AddCalendar("holidayCalendar", holidayCalendar, true, true);
Assert.IsNotNull(scheduler.GetCalendar("annualCalendar"));
JobDetailImpl lonelyJob = new JobDetailImpl("lonelyJob", "lonelyGroup", typeof(SimpleRecoveryJob));
lonelyJob.Durable = true;
lonelyJob.RequestsRecovery = true;
scheduler.AddJob(lonelyJob, false);
scheduler.AddJob(lonelyJob, true);
string schedId = scheduler.SchedulerInstanceId;
int count = 1;
JobDetailImpl job = new JobDetailImpl("job_" + count, schedId, typeof(SimpleRecoveryJob));
// ask scheduler to re-Execute this job if it was in progress when
// the scheduler went down...
job.RequestsRecovery = true;
IOperableTrigger trigger = new SimpleTriggerImpl("trig_" + count, schedId, 20, TimeSpan.FromSeconds(5));
trigger.JobDataMap.Add("key", "value");
trigger.EndTimeUtc = DateTime.UtcNow.AddYears(10);
trigger.StartTimeUtc = DateTime.Now.AddMilliseconds(1000L);
scheduler.ScheduleJob(job, trigger);
// check that trigger was stored
ITrigger persisted = scheduler.GetTrigger(new TriggerKey("trig_" + count, schedId));
Assert.IsNotNull(persisted);
Assert.IsTrue(persisted is SimpleTriggerImpl);
count++;
job = new JobDetailImpl("job_" + count, schedId, typeof(SimpleRecoveryJob));
// ask scheduler to re-Execute this job if it was in progress when
// the scheduler went down...
job.RequestsRecovery = (true);
trigger = new SimpleTriggerImpl("trig_" + count, schedId, 20, TimeSpan.FromSeconds(5));
trigger.StartTimeUtc = (DateTime.Now.AddMilliseconds(2000L));
scheduler.ScheduleJob(job, trigger);
count++;
job = new JobDetailImpl("job_" + count, schedId, typeof(SimpleRecoveryStatefulJob));
// ask scheduler to re-Execute this job if it was in progress when
// the scheduler went down...
job.RequestsRecovery = (true);
trigger = new SimpleTriggerImpl("trig_" + count, schedId, 20, TimeSpan.FromSeconds(3));
trigger.StartTimeUtc = (DateTime.Now.AddMilliseconds(1000L));
scheduler.ScheduleJob(job, trigger);
count++;
job = new JobDetailImpl("job_" + count, schedId, typeof(SimpleRecoveryJob));
// ask scheduler to re-Execute this job if it was in progress when
// the scheduler went down...
job.RequestsRecovery = (true);
trigger = new SimpleTriggerImpl("trig_" + count, schedId, 20, TimeSpan.FromSeconds(4));
trigger.StartTimeUtc = (DateTime.Now.AddMilliseconds(1000L));
scheduler.ScheduleJob(job, trigger);
count++;
job = new JobDetailImpl("job_" + count, schedId, typeof(SimpleRecoveryJob));
// ask scheduler to re-Execute this job if it was in progress when
// the scheduler went down...
job.RequestsRecovery = (true);
trigger = new SimpleTriggerImpl("trig_" + count, schedId, 20, TimeSpan.FromMilliseconds(4500));
scheduler.ScheduleJob(job, trigger);
count++;
job = new JobDetailImpl("job_" + count, schedId, typeof(SimpleRecoveryJob));
// ask scheduler to re-Execute this job if it was in progress when
// the scheduler went down...
job.RequestsRecovery = (true);
IOperableTrigger ct = new CronTriggerImpl("cron_trig_" + count, schedId, "0/10 * * * * ?");
ct.JobDataMap.Add("key", "value");
ct.StartTimeUtc = DateTime.Now.AddMilliseconds(1000);
scheduler.ScheduleJob(job, ct);
count++;
job = new JobDetailImpl("job_" + count, schedId, typeof(SimpleRecoveryJob));
// ask scheduler to re-Execute this job if it was in progress when
// the scheduler went down...
job.RequestsRecovery = (true);
NthIncludedDayTrigger nt = new NthIncludedDayTrigger("nth_trig_" + count, schedId);
nt.StartTimeUtc = DateTime.Now.Date.AddMilliseconds(1000);
nt.N = 1;
scheduler.ScheduleJob(job, nt);
job.RequestsRecovery = (true);
CalendarIntervalTriggerImpl intervalTrigger = new CalendarIntervalTriggerImpl(
"calint_trig_" + count,
schedId,
DateTime.UtcNow.AddMilliseconds(300),
DateTime.UtcNow.AddMinutes(1),
IntervalUnit.Second,
8);
intervalTrigger.JobKey = job.Key;
scheduler.ScheduleJob(intervalTrigger);
// bulk operations
var info = new Dictionary <IJobDetail, Collection.ISet <ITrigger> >();
IJobDetail detail = new JobDetailImpl("job_" + count, schedId, typeof(SimpleRecoveryJob));
ITrigger simple = new SimpleTriggerImpl("trig_" + count, schedId, 20, TimeSpan.FromMilliseconds(4500));
var triggers = new Collection.HashSet <ITrigger>();
triggers.Add(simple);
info[detail] = triggers;
scheduler.ScheduleJobs(info, true);
Assert.IsTrue(scheduler.CheckExists(detail.Key));
Assert.IsTrue(scheduler.CheckExists(simple.Key));
// QRTZNET-243
scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupContains("a").DeepClone());
scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEndsWith("a").DeepClone());
scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupStartsWith("a").DeepClone());
scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals("a").DeepClone());
scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupContains("a").DeepClone());
scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEndsWith("a").DeepClone());
scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupStartsWith("a").DeepClone());
scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals("a").DeepClone());
scheduler.Start();
Thread.Sleep(TimeSpan.FromSeconds(3));
scheduler.PauseAll();
scheduler.ResumeAll();
scheduler.PauseJob(new JobKey("job_1", schedId));
scheduler.ResumeJob(new JobKey("job_1", schedId));
scheduler.PauseJobs(GroupMatcher <JobKey> .GroupEquals(schedId));
Thread.Sleep(TimeSpan.FromSeconds(1));
scheduler.ResumeJobs(GroupMatcher <JobKey> .GroupEquals(schedId));
scheduler.PauseTrigger(new TriggerKey("trig_2", schedId));
scheduler.ResumeTrigger(new TriggerKey("trig_2", schedId));
scheduler.PauseTriggers(GroupMatcher <TriggerKey> .GroupEquals(schedId));
Assert.AreEqual(1, scheduler.GetPausedTriggerGroups().Count);
Thread.Sleep(TimeSpan.FromSeconds(3));
scheduler.ResumeTriggers(GroupMatcher <TriggerKey> .GroupEquals(schedId));
Assert.IsNotNull(scheduler.GetTrigger(new TriggerKey("trig_2", schedId)));
Assert.IsNotNull(scheduler.GetJobDetail(new JobKey("job_1", schedId)));
Assert.IsNotNull(scheduler.GetMetaData());
Assert.IsNotNull(scheduler.GetCalendar("weeklyCalendar"));
Thread.Sleep(TimeSpan.FromSeconds(20));
scheduler.Standby();
CollectionAssert.IsNotEmpty(scheduler.GetCalendarNames());
CollectionAssert.IsNotEmpty(scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals(schedId)));
CollectionAssert.IsNotEmpty(scheduler.GetTriggersOfJob(new JobKey("job_2", schedId)));
Assert.IsNotNull(scheduler.GetJobDetail(new JobKey("job_2", schedId)));
scheduler.DeleteCalendar("cronCalendar");
scheduler.DeleteCalendar("holidayCalendar");
scheduler.DeleteJob(new JobKey("lonelyJob", "lonelyGroup"));
scheduler.DeleteJob(job.Key);
scheduler.GetJobGroupNames();
scheduler.GetCalendarNames();
scheduler.GetTriggerGroupNames();
}
}
finally
{
scheduler.Shutdown(false);
}
}
public void TestGetJobKeysWithLike()
{
var sched = CreateScheduler(null);
sched.GetJobKeys(GroupMatcher <JobKey> .GroupStartsWith("foo"));
}
private async Task TestMatchers(IScheduler scheduler)
{
await scheduler.Clear();
var job = JobBuilder.Create <NoOpJob>().WithIdentity("job1", "aaabbbccc").StoreDurably().Build();
await scheduler.AddJob(job, true);
var schedule = SimpleScheduleBuilder.Create();
var trigger =
TriggerBuilder.Create().WithIdentity("trig1", "aaabbbccc").WithSchedule(schedule).ForJob(job).Build();
await scheduler.ScheduleJob(trigger);
job = JobBuilder.Create <NoOpJob>().WithIdentity("job1", "xxxyyyzzz").StoreDurably().Build();
await scheduler.AddJob(job, true);
schedule = SimpleScheduleBuilder.Create();
trigger =
TriggerBuilder.Create().WithIdentity("trig1", "xxxyyyzzz").WithSchedule(schedule).ForJob(job).Build();
await scheduler.ScheduleJob(trigger);
job = JobBuilder.Create <NoOpJob>().WithIdentity("job2", "xxxyyyzzz").StoreDurably().Build();
await scheduler.AddJob(job, true);
schedule = SimpleScheduleBuilder.Create();
trigger =
TriggerBuilder.Create().WithIdentity("trig2", "xxxyyyzzz").WithSchedule(schedule).ForJob(job).Build();
await scheduler.ScheduleJob(trigger);
var jkeys = await scheduler.GetJobKeys(GroupMatcher <JobKey> .AnyGroup());
jkeys.Count.Should().Be(3, "Wrong number of jobs found by anything matcher");
jkeys = await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals("xxxyyyzzz"));
jkeys.Count.Should().Be(2, "Wrong number of jobs found by equals matcher");
jkeys = await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals("aaabbbccc"));
jkeys.Count.Should().Be(1, "Wrong number of jobs found by equals matcher");
jkeys = await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupStartsWith("aa"));
jkeys.Count.Should().Be(1, "Wrong number of jobs found by starts with matcher");
jkeys = await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupStartsWith("xx"));
jkeys.Count.Should().Be(2, "Wrong number of jobs found by starts with matcher");
jkeys = await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEndsWith("cc"));
jkeys.Count.Should().Be(1, "Wrong number of jobs found by ends with matcher");
jkeys = await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEndsWith("zzz"));
jkeys.Count.Should().Be(2, "Wrong number of jobs found by ends with matcher");
jkeys = await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupContains("bc"));
jkeys.Count.Should().Be(1, "Wrong number of jobs found by contains with matcher");
jkeys = await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupContains("yz"));
jkeys.Count.Should().Be(2, "Wrong number of jobs found by contains with matcher");
var tkeys = await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .AnyGroup());
tkeys.Count.Should().Be(3, "Wrong number of triggers found by anything matcher");
tkeys = await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals("xxxyyyzzz"));
tkeys.Count.Should().Be(2, "Wrong number of triggers found by equals matcher");
tkeys = await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals("aaabbbccc"));
tkeys.Count.Should().Be(1, "Wrong number of triggers found by equals matcher");
tkeys = await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupStartsWith("aa"));
tkeys.Count.Should().Be(1, "Wrong number of triggers found by starts with matcher");
tkeys = await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupStartsWith("xx"));
tkeys.Count.Should().Be(2, "Wrong number of triggers found by starts with matcher");
tkeys = await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEndsWith("cc"));
tkeys.Count.Should().Be(1, "Wrong number of triggers found by ends with matcher");
tkeys = await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEndsWith("zzz"));
tkeys.Count.Should().Be(2, "Wrong number of triggers found by ends with matcher");
tkeys = await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupContains("bc"));
tkeys.Count.Should().Be(1, "Wrong number of triggers found by contains with matcher");
tkeys = await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupContains("yz"));
tkeys.Count.Should().Be(2, "Wrong number of triggers found by contains with matcher");
}
public async Task Test(IScheduler[] schedulers, bool clearJobs, bool scheduleJobs)
{
var scheduler = schedulers[0];
try
{
if (clearJobs)
{
foreach (var s in schedulers)
{
await s.Clear();
}
}
if (scheduleJobs)
{
ICalendar cronCalendar = new CronCalendar("0/5 * * * * ?");
ICalendar holidayCalendar = new HolidayCalendar();
// QRTZNET-86
var t = await scheduler.GetTrigger(new TriggerKey("NonExistingTrigger", "NonExistingGroup"));
(t).Should().BeNull();
var cal = new AnnualCalendar();
await scheduler.AddCalendar("annualCalendar", cal, false, true);
IOperableTrigger calendarsTrigger = new SimpleTriggerImpl("calendarsTrigger", "test", 20,
TimeSpan.FromMilliseconds(5));
calendarsTrigger.CalendarName = "annualCalendar";
var jd = new JobDetailImpl("testJob", "test", typeof(NoOpJob));
await scheduler.ScheduleJob(jd, calendarsTrigger);
// QRTZNET-93
await scheduler.AddCalendar("annualCalendar", cal, true, true);
await scheduler.AddCalendar("baseCalendar", new BaseCalendar(), false, true);
await scheduler.AddCalendar("cronCalendar", cronCalendar, false, true);
await scheduler.AddCalendar("dailyCalendar",
new DailyCalendar(DateTime.Now.Date, DateTime.Now.AddMinutes(1)), false, true);
await scheduler.AddCalendar("holidayCalendar", holidayCalendar, false, true);
await scheduler.AddCalendar("monthlyCalendar", new MonthlyCalendar(), false, true);
await scheduler.AddCalendar("weeklyCalendar", new WeeklyCalendar(), false, true);
await scheduler.AddCalendar("cronCalendar", cronCalendar, true, true);
await scheduler.AddCalendar("holidayCalendar", holidayCalendar, true, true);
(await scheduler.GetCalendar("annualCalendar")).Should().NotBeNull();
var lonelyJob = new JobDetailImpl("lonelyJob", "lonelyGroup", typeof(SimpleRecoveryJob));
lonelyJob.Durable = true;
lonelyJob.RequestsRecovery = true;
await scheduler.AddJob(lonelyJob, false);
await scheduler.AddJob(lonelyJob, true);
var schedId = scheduler.SchedulerInstanceId;
var count = 1;
var job = new JobDetailImpl("job_" + count, schedId, typeof(SimpleRecoveryJob));
// ask scheduler to re-Execute this job if it was in progress when
// the scheduler went down...
job.RequestsRecovery = true;
IOperableTrigger trigger = new SimpleTriggerImpl("trig_" + count, schedId, 20,
TimeSpan.FromSeconds(5));
trigger.JobDataMap.Add("key", "value");
trigger.EndTimeUtc = DateTime.UtcNow.AddYears(10);
trigger.StartTimeUtc = DateTime.UtcNow.AddMilliseconds(1000L);
await scheduler.ScheduleJob(job, trigger);
// check that trigger was stored
var persisted = await scheduler.GetTrigger(new TriggerKey("trig_" + count, schedId));
(persisted).Should().NotBeNull();
(persisted is SimpleTriggerImpl).Should().BeTrue();
count++;
job = new JobDetailImpl("job_" + count, schedId, typeof(SimpleRecoveryJob));
// ask scheduler to re-Execute this job if it was in progress when
// the scheduler went down...
job.RequestsRecovery = true;
trigger = new SimpleTriggerImpl("trig_" + count, schedId, 20, TimeSpan.FromSeconds(5));
trigger.StartTimeUtc = DateTime.UtcNow.AddMilliseconds(2000L);
await scheduler.ScheduleJob(job, trigger);
count++;
job = new JobDetailImpl("job_" + count, schedId, typeof(SimpleRecoveryStatefulJob));
// ask scheduler to re-Execute this job if it was in progress when
// the scheduler went down...
job.RequestsRecovery = true;
trigger = new SimpleTriggerImpl("trig_" + count, schedId, 20, TimeSpan.FromSeconds(3));
trigger.StartTimeUtc = DateTime.UtcNow.AddMilliseconds(1000L);
await scheduler.ScheduleJob(job, trigger);
count++;
job = new JobDetailImpl("job_" + count, schedId, typeof(SimpleRecoveryJob));
// ask scheduler to re-Execute this job if it was in progress when
// the scheduler went down...
job.RequestsRecovery = true;
trigger = new SimpleTriggerImpl("trig_" + count, schedId, 20, TimeSpan.FromSeconds(4));
trigger.StartTimeUtc = DateTime.UtcNow.AddMilliseconds(1000L);
await scheduler.ScheduleJob(job, trigger);
count++;
job = new JobDetailImpl("job_" + count, schedId, typeof(SimpleRecoveryJob));
// ask scheduler to re-Execute this job if it was in progress when
// the scheduler went down...
job.RequestsRecovery = true;
trigger = new SimpleTriggerImpl("trig_" + count, schedId, 20, TimeSpan.FromMilliseconds(4500));
await scheduler.ScheduleJob(job, trigger);
count++;
job = new JobDetailImpl("job_" + count, schedId, typeof(SimpleRecoveryJob));
// ask scheduler to re-Execute this job if it was in progress when
// the scheduler went down...
job.RequestsRecovery = true;
IOperableTrigger ct = new CronTriggerImpl("cron_trig_" + count, schedId, "0/10 * * * * ?");
ct.JobDataMap.Add("key", "value");
ct.StartTimeUtc = DateTime.UtcNow.AddMilliseconds(1000);
await scheduler.ScheduleJob(job, ct);
count++;
job = new JobDetailImpl("job_" + count, schedId, typeof(SimpleRecoveryJob));
// ask scheduler to re-Execute this job if it was in progress when
// the scheduler went down...
job.RequestsRecovery = true;
var nt = new DailyTimeIntervalTriggerImpl("nth_trig_" + count, schedId, new TimeOfDay(1, 1, 1),
new TimeOfDay(23, 30, 0), IntervalUnit.Hour, 1);
nt.StartTimeUtc = DateTime.UtcNow.Date.AddMilliseconds(1000);
await scheduler.ScheduleJob(job, nt);
var nt2 = new DailyTimeIntervalTriggerImpl();
nt2.Key = new TriggerKey("nth_trig2_" + count, schedId);
nt2.StartTimeUtc = DateTime.UtcNow.Date.AddMilliseconds(1000);
nt2.JobKey = job.Key;
await scheduler.ScheduleJob(nt2);
// GitHub issue #92
await scheduler.GetTrigger(nt2.Key);
// GitHub issue #98
nt2.StartTimeOfDay = new TimeOfDay(1, 2, 3);
nt2.EndTimeOfDay = new TimeOfDay(2, 3, 4);
await scheduler.UnscheduleJob(nt2.Key);
await scheduler.ScheduleJob(nt2);
var triggerFromDb = (IDailyTimeIntervalTrigger)await scheduler.GetTrigger(nt2.Key);
triggerFromDb.StartTimeOfDay.Hour.Should().Be(1);
triggerFromDb.StartTimeOfDay.Minute.Should().Be(2);
triggerFromDb.StartTimeOfDay.Second.Should().Be(3);
triggerFromDb.EndTimeOfDay.Hour.Should().Be(2);
triggerFromDb.EndTimeOfDay.Minute.Should().Be(3);
triggerFromDb.EndTimeOfDay.Second.Should().Be(4);
job.RequestsRecovery = true;
var intervalTrigger = new CalendarIntervalTriggerImpl(
"calint_trig_" + count,
schedId,
DateTime.Now.AddMilliseconds(300),
DateTime.Now.AddMinutes(1),
IntervalUnit.Second,
8);
intervalTrigger.JobKey = job.Key;
await scheduler.ScheduleJob(intervalTrigger);
// bulk operations
IJobDetail detail = new JobDetailImpl("job_" + count, schedId, typeof(SimpleRecoveryJob));
ITrigger simple = new SimpleTriggerImpl("trig_" + count, schedId, 20,
TimeSpan.FromMilliseconds(4500));
var triggers = (IReadOnlyCollection <ITrigger>) new HashSet <ITrigger> {
simple
};
var info = (IReadOnlyDictionary <IJobDetail, IReadOnlyCollection <ITrigger> >) new Dictionary <IJobDetail, IReadOnlyCollection <ITrigger> >
{
[detail] = triggers
};
await scheduler.ScheduleJobs(info, true);
(await scheduler.CheckExists(detail.Key)).Should().BeTrue();
(await scheduler.CheckExists(simple.Key)).Should().BeTrue();
// QRTZNET-243
await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupContains("a").DeepClone());
await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEndsWith("a").DeepClone());
await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupStartsWith("a").DeepClone());
await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals("a").DeepClone());
await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupContains("a").DeepClone());
await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEndsWith("a").DeepClone());
await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupStartsWith("a").DeepClone());
await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals("a").DeepClone());
foreach (var s in schedulers)
{
await s.Start();
}
await Task.Delay(3 *schedulers.Length);
await scheduler.PauseAll();
await scheduler.ResumeAll();
await scheduler.PauseJob(new JobKey("job_1", schedId));
await scheduler.ResumeJob(new JobKey("job_1", schedId));
await scheduler.PauseJobs(GroupMatcher <JobKey> .GroupEquals(schedId));
await Task.Delay(TimeSpan.FromSeconds(1));
await scheduler.ResumeJobs(GroupMatcher <JobKey> .GroupEquals(schedId));
await scheduler.PauseTrigger(new TriggerKey("trig_2", schedId));
await scheduler.ResumeTrigger(new TriggerKey("trig_2", schedId));
await scheduler.PauseTriggers(GroupMatcher <TriggerKey> .GroupEquals(schedId));
(await scheduler.GetPausedTriggerGroups()).Count.Should().Be(1);
await Task.Delay(TimeSpan.FromSeconds(3));
await scheduler.ResumeTriggers(GroupMatcher <TriggerKey> .GroupEquals(schedId));
(await scheduler.GetTrigger(new TriggerKey("trig_2", schedId))).Should().NotBeNull();
(await scheduler.GetJobDetail(new JobKey("job_1", schedId))).Should().NotBeNull();
(await scheduler.GetMetaData()).Should().NotBeNull();
(await scheduler.GetCalendar("weeklyCalendar")).Should().NotBeNull();
var genericjobKey = new JobKey("genericJob", "genericGroup");
var genericJob = JobBuilder.Create <GenericJobType <string> >()
.WithIdentity(genericjobKey)
.StoreDurably()
.Build();
await scheduler.AddJob(genericJob, false);
genericJob = await scheduler.GetJobDetail(genericjobKey);
genericJob.Should().NotBeNull();
await scheduler.TriggerJob(genericjobKey);
await Task.Delay(TimeSpan.FromSeconds(30));
GenericJobType <string> .TriggeredCount.Should().Be(1);
await scheduler.Standby();
(await scheduler.GetCalendarNames()).Should().NotBeEmpty();
(await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals(schedId))).Should().NotBeEmpty();
(await scheduler.GetTriggersOfJob(new JobKey("job_2", schedId))).Should().NotBeEmpty();
(await scheduler.GetJobDetail(new JobKey("job_2", schedId))).Should().NotBeNull();
await scheduler.DeleteCalendar("cronCalendar");
await scheduler.DeleteCalendar("holidayCalendar");
await scheduler.DeleteJob(new JobKey("lonelyJob", "lonelyGroup"));
await scheduler.DeleteJob(job.Key);
await scheduler.GetJobGroupNames();
await scheduler.GetCalendarNames();
await scheduler.GetTriggerGroupNames();
await TestMatchers(scheduler);
}
}
finally
{
foreach (var s in schedulers)
{
await s.Shutdown(false);
}
}
}
/// <summary>
/// Updates the scheduled jobs.
/// </summary>
/// <param name="context">The context.</param>
private void UpdateScheduledJobs(IJobExecutionContext context)
{
var scheduler = context.Scheduler;
int jobsDeleted = 0;
int jobsScheduleUpdated = 0;
var rockContext = new Rock.Data.RockContext();
ServiceJobService jobService = new ServiceJobService(rockContext);
List <ServiceJob> activeJobList = jobService.GetActiveJobs().ToList();
List <Quartz.JobKey> scheduledQuartzJobs = scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupStartsWith(string.Empty)).ToList();
// delete any jobs that are no longer exist (are are not set to active) in the database
var quartsJobsToDelete = scheduledQuartzJobs.Where(a => !activeJobList.Any(j => j.Guid.Equals(a.Name.AsGuid())));
foreach (JobKey jobKey in quartsJobsToDelete)
{
scheduler.DeleteJob(jobKey);
jobsDeleted++;
}
// add any jobs that are not yet scheduled
var newActiveJobs = activeJobList.Where(a => !scheduledQuartzJobs.Any(q => q.Name.AsGuid().Equals(a.Guid)));
foreach (Rock.Model.ServiceJob job in newActiveJobs)
{
const string errorSchedulingStatus = "Error scheduling Job";
try
{
IJobDetail jobDetail = jobService.BuildQuartzJob(job);
ITrigger jobTrigger = jobService.BuildQuartzTrigger(job);
scheduler.ScheduleJob(jobDetail, jobTrigger);
jobsScheduleUpdated++;
if (job.LastStatus == errorSchedulingStatus)
{
job.LastStatusMessage = string.Empty;
job.LastStatus = string.Empty;
rockContext.SaveChanges();
}
}
catch (Exception ex)
{
ExceptionLogService.LogException(ex, null);
// create a friendly error message
string message = string.Format("Error scheduling the job: {0}.\n\n{2}", job.Name, job.Assembly, ex.Message);
job.LastStatusMessage = message;
job.LastStatus = errorSchedulingStatus;
}
}
rockContext.SaveChanges();
// reload the jobs in case any where added/removed
scheduledQuartzJobs = scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupStartsWith(string.Empty)).ToList();
// update schedule if the schedule has changed
foreach (var jobKey in scheduledQuartzJobs)
{
var jobCronTrigger = scheduler.GetTriggersOfJob(jobKey).OfType <ICronTrigger>().FirstOrDefault();
if (jobCronTrigger != null)
{
var activeJob = activeJobList.FirstOrDefault(a => a.Guid.Equals(jobKey.Name.AsGuid()));
if (activeJob != null)
{
bool rescheduleJob = false;
// fix up the schedule if it has changed
if (activeJob.CronExpression != jobCronTrigger.CronExpressionString)
{
rescheduleJob = true;
}
// update the job detail if it has changed
var scheduledJobDetail = scheduler.GetJobDetail(jobKey);
var jobDetail = jobService.BuildQuartzJob(activeJob);
if (scheduledJobDetail != null && jobDetail != null)
{
if (scheduledJobDetail.JobType != jobDetail.JobType)
{
rescheduleJob = true;
}
if (scheduledJobDetail.JobDataMap.ToJson() != jobDetail.JobDataMap.ToJson())
{
rescheduleJob = true;
}
}
if (rescheduleJob)
{
const string errorReschedulingStatus = "Error re-scheduling Job";
try
{
ITrigger newJobTrigger = jobService.BuildQuartzTrigger(activeJob);
bool deletedSuccessfully = scheduler.DeleteJob(jobKey);
scheduler.ScheduleJob(jobDetail, newJobTrigger);
jobsScheduleUpdated++;
if (activeJob.LastStatus == errorReschedulingStatus)
{
activeJob.LastStatusMessage = string.Empty;
activeJob.LastStatus = string.Empty;
rockContext.SaveChanges();
}
}
catch (Exception ex)
{
ExceptionLogService.LogException(ex, null);
// create a friendly error message
string message = string.Format("Error re-scheduling the job: {0}.\n\n{2}", activeJob.Name, activeJob.Assembly, ex.Message);
activeJob.LastStatusMessage = message;
activeJob.LastStatus = errorReschedulingStatus;
}
}
}
}
}
context.Result = string.Empty;
if (jobsDeleted > 0)
{
context.Result += string.Format("Deleted {0} job schedule(s)", jobsDeleted);
}
if (jobsScheduleUpdated > 0)
{
context.Result += (string.IsNullOrEmpty(context.Result as string) ? "" : " and ") + string.Format("Updated {0} schedule(s)", jobsScheduleUpdated);
}
}
private void TestMatchers(IScheduler scheduler)
{
scheduler.Clear();
IJobDetail job = JobBuilder.Create <NoOpJob>().WithIdentity("job1", "aaabbbccc").StoreDurably().Build();
scheduler.AddJob(job, true);
SimpleScheduleBuilder schedule = SimpleScheduleBuilder.Create();
ITrigger trigger = TriggerBuilder.Create().WithIdentity("trig1", "aaabbbccc").WithSchedule(schedule).ForJob(job).Build();
scheduler.ScheduleJob(trigger);
job = JobBuilder.Create <NoOpJob>().WithIdentity("job1", "xxxyyyzzz").StoreDurably().Build();
scheduler.AddJob(job, true);
schedule = SimpleScheduleBuilder.Create();
trigger = TriggerBuilder.Create().WithIdentity("trig1", "xxxyyyzzz").WithSchedule(schedule).ForJob(job).Build();
scheduler.ScheduleJob(trigger);
job = JobBuilder.Create <NoOpJob>().WithIdentity("job2", "xxxyyyzzz").StoreDurably().Build();
scheduler.AddJob(job, true);
schedule = SimpleScheduleBuilder.Create();
trigger = TriggerBuilder.Create().WithIdentity("trig2", "xxxyyyzzz").WithSchedule(schedule).ForJob(job).Build();
scheduler.ScheduleJob(trigger);
Collection.ISet <JobKey> jkeys = scheduler.GetJobKeys(GroupMatcher <JobKey> .AnyGroup());
Assert.That(jkeys.Count, Is.EqualTo(3), "Wrong number of jobs found by anything matcher");
jkeys = scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals("xxxyyyzzz"));
Assert.That(jkeys.Count, Is.EqualTo(2), "Wrong number of jobs found by equals matcher");
jkeys = scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals("aaabbbccc"));
Assert.That(jkeys.Count, Is.EqualTo(1), "Wrong number of jobs found by equals matcher");
jkeys = scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupStartsWith("aa"));
Assert.That(jkeys.Count, Is.EqualTo(1), "Wrong number of jobs found by starts with matcher");
jkeys = scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupStartsWith("xx"));
Assert.That(jkeys.Count, Is.EqualTo(2), "Wrong number of jobs found by starts with matcher");
jkeys = scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEndsWith("cc"));
Assert.That(jkeys.Count, Is.EqualTo(1), "Wrong number of jobs found by ends with matcher");
jkeys = scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEndsWith("zzz"));
Assert.That(jkeys.Count, Is.EqualTo(2), "Wrong number of jobs found by ends with matcher");
jkeys = scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupContains("bc"));
Assert.That(jkeys.Count, Is.EqualTo(1), "Wrong number of jobs found by contains with matcher");
jkeys = scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupContains("yz"));
Assert.That(jkeys.Count, Is.EqualTo(2), "Wrong number of jobs found by contains with matcher");
Collection.ISet <TriggerKey> tkeys = scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .AnyGroup());
Assert.That(tkeys.Count, Is.EqualTo(3), "Wrong number of triggers found by anything matcher");
tkeys = scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals("xxxyyyzzz"));
Assert.That(tkeys.Count, Is.EqualTo(2), "Wrong number of triggers found by equals matcher");
tkeys = scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals("aaabbbccc"));
Assert.That(tkeys.Count, Is.EqualTo(1), "Wrong number of triggers found by equals matcher");
tkeys = scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupStartsWith("aa"));
Assert.That(tkeys.Count, Is.EqualTo(1), "Wrong number of triggers found by starts with matcher");
tkeys = scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupStartsWith("xx"));
Assert.That(tkeys.Count, Is.EqualTo(2), "Wrong number of triggers found by starts with matcher");
tkeys = scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEndsWith("cc"));
Assert.That(tkeys.Count, Is.EqualTo(1), "Wrong number of triggers found by ends with matcher");
tkeys = scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEndsWith("zzz"));
Assert.That(tkeys.Count, Is.EqualTo(2), "Wrong number of triggers found by ends with matcher");
tkeys = scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupContains("bc"));
Assert.That(tkeys.Count, Is.EqualTo(1), "Wrong number of triggers found by contains with matcher");
tkeys = scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupContains("yz"));
Assert.That(tkeys.Count, Is.EqualTo(2), "Wrong number of triggers found by contains with matcher");
}
public async Task Test(IScheduler scheduler, bool clearJobs, bool scheduleJobs)
{
try
{
if (clearJobs)
{
await scheduler.Clear();
}
if (scheduleJobs)
{
ICalendar cronCalendar = new CronCalendar("0/5 * * * * ?");
ICalendar holidayCalendar = new HolidayCalendar();
// QRTZNET-86
ITrigger t = await scheduler.GetTrigger(new TriggerKey("NonExistingTrigger", "NonExistingGroup"));
Assert.IsNull(t);
AnnualCalendar cal = new AnnualCalendar();
await scheduler.AddCalendar("annualCalendar", cal, false, true);
IOperableTrigger calendarsTrigger = new SimpleTriggerImpl("calendarsTrigger", "test", 20, TimeSpan.FromMilliseconds(5));
calendarsTrigger.CalendarName = "annualCalendar";
JobDetailImpl jd = new JobDetailImpl("testJob", "test", typeof(NoOpJob));
await scheduler.ScheduleJob(jd, calendarsTrigger);
// QRTZNET-93
await scheduler.AddCalendar("annualCalendar", cal, true, true);
await scheduler.AddCalendar("baseCalendar", new BaseCalendar(), false, true);
await scheduler.AddCalendar("cronCalendar", cronCalendar, false, true);
await scheduler.AddCalendar("dailyCalendar", new DailyCalendar(DateTime.Now.Date, DateTime.Now.AddMinutes(1)), false, true);
await scheduler.AddCalendar("holidayCalendar", holidayCalendar, false, true);
await scheduler.AddCalendar("monthlyCalendar", new MonthlyCalendar(), false, true);
await scheduler.AddCalendar("weeklyCalendar", new WeeklyCalendar(), false, true);
await scheduler.AddCalendar("cronCalendar", cronCalendar, true, true);
await scheduler.AddCalendar("holidayCalendar", holidayCalendar, true, true);
Assert.IsNotNull(scheduler.GetCalendar("annualCalendar"));
JobDetailImpl lonelyJob = new JobDetailImpl("lonelyJob", "lonelyGroup", typeof(SimpleRecoveryJob));
lonelyJob.Durable = true;
lonelyJob.RequestsRecovery = true;
await scheduler.AddJob(lonelyJob, false);
await scheduler.AddJob(lonelyJob, true);
string schedId = scheduler.SchedulerInstanceId;
int count = 1;
JobDetailImpl job = new JobDetailImpl("job_" + count, schedId, typeof(SimpleRecoveryJob));
// ask scheduler to re-Execute this job if it was in progress when
// the scheduler went down...
job.RequestsRecovery = true;
IOperableTrigger trigger = new SimpleTriggerImpl("trig_" + count, schedId, 20, TimeSpan.FromSeconds(5));
trigger.JobDataMap.Add("key", "value");
trigger.EndTimeUtc = DateTime.UtcNow.AddYears(10);
trigger.StartTimeUtc = DateTime.Now.AddMilliseconds(1000L);
await scheduler.ScheduleJob(job, trigger);
// check that trigger was stored
ITrigger persisted = await scheduler.GetTrigger(new TriggerKey("trig_" + count, schedId));
Assert.IsNotNull(persisted);
Assert.IsTrue(persisted is SimpleTriggerImpl);
count++;
job = new JobDetailImpl("job_" + count, schedId, typeof(SimpleRecoveryJob));
// ask scheduler to re-Execute this job if it was in progress when
// the scheduler went down...
job.RequestsRecovery = true;
trigger = new SimpleTriggerImpl("trig_" + count, schedId, 20, TimeSpan.FromSeconds(5));
trigger.StartTimeUtc = DateTime.Now.AddMilliseconds(2000L);
await scheduler.ScheduleJob(job, trigger);
count++;
job = new JobDetailImpl("job_" + count, schedId, typeof(SimpleRecoveryStatefulJob));
// ask scheduler to re-Execute this job if it was in progress when
// the scheduler went down...
job.RequestsRecovery = true;
trigger = new SimpleTriggerImpl("trig_" + count, schedId, 20, TimeSpan.FromSeconds(3));
trigger.StartTimeUtc = DateTime.Now.AddMilliseconds(1000L);
await scheduler.ScheduleJob(job, trigger);
count++;
job = new JobDetailImpl("job_" + count, schedId, typeof(SimpleRecoveryJob));
// ask scheduler to re-Execute this job if it was in progress when
// the scheduler went down...
job.RequestsRecovery = true;
trigger = new SimpleTriggerImpl("trig_" + count, schedId, 20, TimeSpan.FromSeconds(4));
trigger.StartTimeUtc = DateTime.Now.AddMilliseconds(1000L);
await scheduler.ScheduleJob(job, trigger);
count++;
job = new JobDetailImpl("job_" + count, schedId, typeof(SimpleRecoveryJob));
// ask scheduler to re-Execute this job if it was in progress when
// the scheduler went down...
job.RequestsRecovery = true;
trigger = new SimpleTriggerImpl("trig_" + count, schedId, 20, TimeSpan.FromMilliseconds(4500));
await scheduler.ScheduleJob(job, trigger);
count++;
job = new JobDetailImpl("job_" + count, schedId, typeof(SimpleRecoveryJob));
// ask scheduler to re-Execute this job if it was in progress when
// the scheduler went down...
job.RequestsRecovery = true;
IOperableTrigger ct = new CronTriggerImpl("cron_trig_" + count, schedId, "0/10 * * * * ?");
ct.JobDataMap.Add("key", "value");
ct.StartTimeUtc = DateTime.Now.AddMilliseconds(1000);
await scheduler.ScheduleJob(job, ct);
count++;
job = new JobDetailImpl("job_" + count, schedId, typeof(SimpleRecoveryJob));
// ask scheduler to re-Execute this job if it was in progress when
// the scheduler went down...
job.RequestsRecovery = true;
var timeZone1 = TimeZoneUtil.FindTimeZoneById("Central European Standard Time");
var timeZone2 = TimeZoneUtil.FindTimeZoneById("Mountain Standard Time");
DailyTimeIntervalTriggerImpl nt = new DailyTimeIntervalTriggerImpl("nth_trig_" + count, schedId, new TimeOfDay(1, 1, 1), new TimeOfDay(23, 30, 0), IntervalUnit.Hour, 1);
nt.StartTimeUtc = DateTime.Now.Date.AddMilliseconds(1000);
nt.TimeZone = timeZone1;
await scheduler.ScheduleJob(job, nt);
var loadedNt = (IDailyTimeIntervalTrigger)await scheduler.GetTrigger(nt.Key);
Assert.That(loadedNt.TimeZone.Id, Is.EqualTo(timeZone1.Id));
nt.TimeZone = timeZone2;
await scheduler.RescheduleJob(nt.Key, nt);
loadedNt = (IDailyTimeIntervalTrigger)await scheduler.GetTrigger(nt.Key);
Assert.That(loadedNt.TimeZone.Id, Is.EqualTo(timeZone2.Id));
DailyTimeIntervalTriggerImpl nt2 = new DailyTimeIntervalTriggerImpl();
nt2.Key = new TriggerKey("nth_trig2_" + count, schedId);
nt2.StartTimeUtc = DateTime.Now.Date.AddMilliseconds(1000);
nt2.JobKey = job.Key;
await scheduler.ScheduleJob(nt2);
// GitHub issue #92
await scheduler.GetTrigger(nt2.Key);
// GitHub issue #98
nt2.StartTimeOfDay = new TimeOfDay(1, 2, 3);
nt2.EndTimeOfDay = new TimeOfDay(2, 3, 4);
await scheduler.UnscheduleJob(nt2.Key);
await scheduler.ScheduleJob(nt2);
var triggerFromDb = (IDailyTimeIntervalTrigger)await scheduler.GetTrigger(nt2.Key);
Assert.That(triggerFromDb.StartTimeOfDay.Hour, Is.EqualTo(1));
Assert.That(triggerFromDb.StartTimeOfDay.Minute, Is.EqualTo(2));
Assert.That(triggerFromDb.StartTimeOfDay.Second, Is.EqualTo(3));
Assert.That(triggerFromDb.EndTimeOfDay.Hour, Is.EqualTo(2));
Assert.That(triggerFromDb.EndTimeOfDay.Minute, Is.EqualTo(3));
Assert.That(triggerFromDb.EndTimeOfDay.Second, Is.EqualTo(4));
job.RequestsRecovery = true;
CalendarIntervalTriggerImpl intervalTrigger = new CalendarIntervalTriggerImpl(
"calint_trig_" + count,
schedId,
DateTime.UtcNow.AddMilliseconds(300),
DateTime.UtcNow.AddMinutes(1),
IntervalUnit.Second,
8);
intervalTrigger.JobKey = job.Key;
await scheduler.ScheduleJob(intervalTrigger);
// custom time zone
const string CustomTimeZoneId = "Custom TimeZone";
var webTimezone = TimeZoneInfo.CreateCustomTimeZone(
CustomTimeZoneId,
TimeSpan.FromMinutes(22),
null,
null);
TimeZoneUtil.CustomResolver = id =>
{
if (id == CustomTimeZoneId)
{
return(webTimezone);
}
return(null);
};
var customTimeZoneTrigger = TriggerBuilder.Create()
.WithIdentity("customTimeZoneTrigger")
.WithCronSchedule("0/5 * * * * ?", x => x.InTimeZone(webTimezone))
.StartNow()
.ForJob(job)
.Build();
await scheduler.ScheduleJob(customTimeZoneTrigger);
var loadedCustomTimeZoneTrigger = (ICronTrigger)await scheduler.GetTrigger(customTimeZoneTrigger.Key);
Assert.That(loadedCustomTimeZoneTrigger.TimeZone.BaseUtcOffset, Is.EqualTo(TimeSpan.FromMinutes(22)));
// bulk operations
var info = new Dictionary <IJobDetail, IReadOnlyCollection <ITrigger> >();
IJobDetail detail = new JobDetailImpl("job_" + count, schedId, typeof(SimpleRecoveryJob));
ITrigger simple = new SimpleTriggerImpl("trig_" + count, schedId, 20, TimeSpan.FromMilliseconds(4500));
var triggers = new List <ITrigger>();
triggers.Add(simple);
info[detail] = triggers;
await scheduler.ScheduleJobs(info, true);
Assert.IsTrue(await scheduler.CheckExists(detail.Key));
Assert.IsTrue(await scheduler.CheckExists(simple.Key));
// QRTZNET-243
await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupContains("a").DeepClone());
await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEndsWith("a").DeepClone());
await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupStartsWith("a").DeepClone());
await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals("a").DeepClone());
await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupContains("a").DeepClone());
await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEndsWith("a").DeepClone());
await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupStartsWith("a").DeepClone());
await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals("a").DeepClone());
await scheduler.Start();
await Task.Delay(TimeSpan.FromSeconds(3));
await scheduler.PauseAll();
await scheduler.ResumeAll();
await scheduler.PauseJob(new JobKey("job_1", schedId));
await scheduler.ResumeJob(new JobKey("job_1", schedId));
await scheduler.PauseJobs(GroupMatcher <JobKey> .GroupEquals(schedId));
await Task.Delay(TimeSpan.FromSeconds(1));
await scheduler.ResumeJobs(GroupMatcher <JobKey> .GroupEquals(schedId));
await scheduler.PauseTrigger(new TriggerKey("trig_2", schedId));
await scheduler.ResumeTrigger(new TriggerKey("trig_2", schedId));
await scheduler.PauseTriggers(GroupMatcher <TriggerKey> .GroupEquals(schedId));
var pausedTriggerGroups = await scheduler.GetPausedTriggerGroups();
Assert.AreEqual(1, pausedTriggerGroups.Count);
await Task.Delay(TimeSpan.FromSeconds(3));
await scheduler.ResumeTriggers(GroupMatcher <TriggerKey> .GroupEquals(schedId));
Assert.IsNotNull(scheduler.GetTrigger(new TriggerKey("trig_2", schedId)));
Assert.IsNotNull(scheduler.GetJobDetail(new JobKey("job_1", schedId)));
Assert.IsNotNull(scheduler.GetMetaData());
Assert.IsNotNull(scheduler.GetCalendar("weeklyCalendar"));
var genericjobKey = new JobKey("genericJob", "genericGroup");
GenericJobType.Reset();
var genericJob = JobBuilder.Create <GenericJobType>()
.WithIdentity(genericjobKey)
.StoreDurably()
.Build();
await scheduler.AddJob(genericJob, false);
genericJob = await scheduler.GetJobDetail(genericjobKey);
Assert.That(genericJob, Is.Not.Null);
await scheduler.TriggerJob(genericjobKey);
GenericJobType.WaitForTrigger(TimeSpan.FromSeconds(20));
Assert.That(GenericJobType.TriggeredCount, Is.EqualTo(1));
await scheduler.Standby();
CollectionAssert.IsNotEmpty(await scheduler.GetCalendarNames());
CollectionAssert.IsNotEmpty(await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals(schedId)));
CollectionAssert.IsNotEmpty(await scheduler.GetTriggersOfJob(new JobKey("job_2", schedId)));
Assert.IsNotNull(scheduler.GetJobDetail(new JobKey("job_2", schedId)));
await scheduler.DeleteCalendar("cronCalendar");
await scheduler.DeleteCalendar("holidayCalendar");
await scheduler.DeleteJob(new JobKey("lonelyJob", "lonelyGroup"));
await scheduler.DeleteJob(job.Key);
await scheduler.GetJobGroupNames();
await scheduler.GetCalendarNames();
await scheduler.GetTriggerGroupNames();
await TestMatchers(scheduler);
}
}
finally
{
await scheduler.Shutdown(false);
}
}
public async Task TestGetJobKeysWithLike()
{
var sched = await CreateScheduler(null);
await sched.GetJobKeys(GroupMatcher <JobKey> .GroupStartsWith("foo"));
}
/// <summary>
/// Updates the scheduled jobs.
/// </summary>
/// <param name="context">The context.</param>
private void UpdateScheduledJobs(IJobExecutionContext context)
{
var scheduler = context.Scheduler;
var rockContext = new Rock.Data.RockContext();
ServiceJobService jobService = new ServiceJobService(rockContext);
List <ServiceJob> activeJobList = jobService.GetActiveJobs().ToList();
List <Quartz.JobKey> scheduledQuartzJobs = scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupStartsWith(string.Empty)).ToList();
// delete any jobs that are no longer exist (are are not set to active) in the database
var quartsJobsToDelete = scheduledQuartzJobs.Where(a => !activeJobList.Any(j => j.Guid.Equals(a.Name.AsGuid())));
foreach (JobKey jobKey in quartsJobsToDelete)
{
scheduler.DeleteJob(jobKey);
}
// add any jobs that are not yet scheduled
var newActiveJobs = activeJobList.Where(a => !scheduledQuartzJobs.Any(q => q.Name.AsGuid().Equals(a.Guid)));
foreach (Rock.Model.ServiceJob job in newActiveJobs)
{
try
{
IJobDetail jobDetail = jobService.BuildQuartzJob(job);
ITrigger jobTrigger = jobService.BuildQuartzTrigger(job);
scheduler.ScheduleJob(jobDetail, jobTrigger);
}
catch (Exception ex)
{
// create a friendly error message
string message = string.Format("Error loading the job: {0}. Ensure that the correct version of the job's assembly ({1}.dll) in the websites App_Code directory. \n\n\n\n{2}", job.Name, job.Assembly, ex.Message);
job.LastStatusMessage = message;
job.LastStatus = "Error Loading Job";
}
}
rockContext.SaveChanges();
// reload the jobs in case any where added/removed
scheduledQuartzJobs = scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupStartsWith(string.Empty)).ToList();
// update schedule if the schedule has changed
foreach (var jobKey in scheduledQuartzJobs)
{
var jobCronTrigger = scheduler.GetTriggersOfJob(jobKey).OfType <ICronTrigger>().FirstOrDefault();
if (jobCronTrigger != null)
{
var activeJob = activeJobList.FirstOrDefault(a => a.Guid.Equals(jobKey.Name.AsGuid()));
if (activeJob != null)
{
bool rescheduleJob = false;
// fix up the schedule if it has changed
if (activeJob.CronExpression != jobCronTrigger.CronExpressionString)
{
rescheduleJob = true;
}
// update the job detail if it has changed
var scheduledJobDetail = scheduler.GetJobDetail(jobKey);
var jobDetail = jobService.BuildQuartzJob(activeJob);
if (scheduledJobDetail != null && jobDetail != null)
{
if (scheduledJobDetail.JobType != jobDetail.JobType)
{
rescheduleJob = true;
}
if (scheduledJobDetail.JobDataMap.ToJson() != jobDetail.JobDataMap.ToJson())
{
rescheduleJob = true;
}
}
if (rescheduleJob)
{
ITrigger newJobTrigger = jobService.BuildQuartzTrigger(activeJob);
scheduler.DeleteJob(jobKey);
scheduler.ScheduleJob(jobDetail, newJobTrigger);
}
}
}
}
}
public void TestGetTriggerKeysWithLike()
{
var sched = CreateScheduler();
sched.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupStartsWith("foo"));
}
