public void TestClone()
{
CronCalendar calendar = new CronCalendar("0/15 * * * * ?");
CronCalendar clone = (CronCalendar)calendar.Clone();
Assert.AreEqual(calendar.CronExpression, clone.CronExpression);
}
public QueryResponse Put(string name, [FromBody] CronCalendar model)
{
Logger.InfoFormat("Entered CronCalendarsController.Put(). Calendar Name = {0}", name);
var response = new QueryResponse {
Valid = true
};
try
{
_schedulerCore.AddCronCalendar(name, model.Description, model.CronExpression);
}
catch (Exception ex)
{
response.Valid = false;
response.Errors = new List <Error>
{
new Error
{
Code = "ErrorEditingCronCalendar",
Type = "Server",
Message = string.Format("Error: {0}", ex.Message)
}
};
}
return(response);
}
public void TestCronCalendarSerialization()
{
CronCalendar cronCalendar = new CronCalendar("* * 8-17 ? * *");
CronCalendar clone = cronCalendar.DeepClone();
Assert.AreEqual("* * 8-17 ? * *", clone.CronExpression.CronExpressionString);
}
/// <summary>
/// Builds a <see cref="ICalendar"/> based on the allowed months.
/// </summary>
/// <param name="monthSpecs">The month specs.</param>
/// <returns></returns>
private ICalendar BuildCalendarOnMonths(ICalendar baseCalendar, string[] monthSpecs, TimeZoneInfo timeZone)
{
int maxMonths = 12;
var months = GrammarHelper.GetMonthValues(monthSpecs);
//need exclusive so remove anything that we don't have
List <int> toExclude = new List <int>();
for (int i = 1; i < maxMonths + 1; i++)
{
toExclude.Add(i);
}
//remove any values that we already have
foreach (var item in months)
{
toExclude.Remove(item);
}
string exclusiveCronExpression = string.Format("* * * * {0} ?", string.Join(",", toExclude));
CronCalendar cronCal = null;
if (baseCalendar != null)
{
cronCal = new CronCalendar(baseCalendar, exclusiveCronExpression);
}
else
{
cronCal = new CronCalendar(exclusiveCronExpression);
}
cronCal.TimeZone = timeZone;
return(cronCal);
}
/// <summary>
/// CronCalendar 通过Cron表达式排除任务的执行
/// </summary>
public static void Fun16()
{
var sche = StdSchedulerFactory.GetDefaultScheduler();
sche.Start();
//只在营业时间执行8AM-5PM
CronCalendar cale = new CronCalendar("* * 0-7,18-23 ? * *");
sche.AddCalendar("myCalendar", cale, true, true);
var job = JobBuilder.Create <MyJob>()
.Build();
var trigger = TriggerBuilder.Create().StartNow().WithDailyTimeIntervalSchedule(
m => m.StartingDailyAt(TimeOfDay.HourAndMinuteOfDay(7, 0))
.EndingDailyAt(TimeOfDay.HourAndMinuteOfDay(19, 0))
.WithIntervalInSeconds(1)
.Build() //是任务在7点-19点间执行，执行频率：每秒执行一次
)
.ModifiedByCalendar("myCalendar")
.Build();
//ModifiedByCalendar 将ICalendar的设置应用到触发器中
sche.ScheduleJob(job, trigger);
}
private ICalendar parseCronCalendar(XElement calendarXml)
{
CronCalendar calendar = new CronCalendar(parseCronExpression(calendarXml));
calendar.Description = parseDescription(calendarXml);
return(calendar);
}
public void SerializeCronCalendar()
{
var calendar = new CronCalendar("0/5 * * * * ?");
calendar.Description = "description";
CompareSerialization(calendar);
}
public void TestSqlServerStress()
{
NameValueCollection properties = new NameValueCollection();
properties["quartz.scheduler.instanceName"] = "TestScheduler";
properties["quartz.scheduler.instanceId"] = "instance_one";
properties["quartz.threadPool.type"] = "Quartz.Simpl.SimpleThreadPool, Quartz";
properties["quartz.threadPool.threadCount"] = "10";
properties["quartz.threadPool.threadPriority"] = "Normal";
properties["quartz.jobStore.misfireThreshold"] = "60000";
properties["quartz.jobStore.type"] = "Quartz.Impl.AdoJobStore.JobStoreTX, Quartz";
properties["quartz.jobStore.driverDelegateType"] = "Quartz.Impl.AdoJobStore.StdAdoDelegate, Quartz";
properties["quartz.jobStore.useProperties"] = "false";
properties["quartz.jobStore.dataSource"] = "default";
properties["quartz.jobStore.tablePrefix"] = "QRTZ_";
properties["quartz.jobStore.clustered"] = clustered.ToString();
properties["quartz.jobStore.driverDelegateType"] = "Quartz.Impl.AdoJobStore.SqlServerDelegate, Quartz";
RunAdoJobStoreTest("SqlServer-20", "SQLServer", properties);
properties["quartz.jobStore.lockHandler.type"] = "Quartz.Impl.AdoJobStore.UpdateLockRowSemaphore, Quartz";
string connectionString;
if (!dbConnectionStrings.TryGetValue("SQLServer", out connectionString))
{
throw new Exception("Unknown connection string id: " + "SQLServer");
}
properties["quartz.dataSource.default.connectionString"] = connectionString;
properties["quartz.dataSource.default.provider"] = "SqlServer-20";
// First we must get a reference to a scheduler
ISchedulerFactory sf = new StdSchedulerFactory(properties);
IScheduler sched = sf.GetScheduler();
try
{
CleanUp(sched);
if (scheduleJobs)
{
ICalendar cronCalendar = new CronCalendar("0/5 * * * * ?");
ICalendar holidayCalendar = new HolidayCalendar();
for (int i = 0; i < 100000; ++i)
{
ITrigger trigger = new SimpleTriggerImpl("calendarsTrigger", "test", SimpleTriggerImpl.RepeatIndefinitely, TimeSpan.FromSeconds(1));
JobDetailImpl jd = new JobDetailImpl("testJob", "test", typeof(NoOpJob));
sched.ScheduleJob(jd, trigger);
}
}
sched.Start();
Thread.Sleep(TimeSpan.FromSeconds(30));
}
finally
{
sched.Shutdown(false);
}
}
public void TestGetNextIncludedTimeWhenBusinessHoursExcluded()
{
string expr = string.Format("* * 8-17 ? * *");
CronCalendar calendar = new CronCalendar(expr);
DateTime tst = new DateTime(2007, 6, 28, 14, 0, 0);
Assert.AreEqual(new DateTime(2007, 6, 28, 17, 0, 0), calendar.GetNextIncludedTimeUtc(tst));
}
public void TestClone()
{
string expr = string.Format("0/15 * * * * ?");
CronCalendar calendar = new CronCalendar(expr);
CronCalendar clone = (CronCalendar)calendar.Clone();
Assert.AreEqual(calendar.CronExpression, clone.CronExpression);
}
public async Task TestSqlServerStress(string serializerType)
{
NameValueCollection properties = new NameValueCollection();
properties["quartz.scheduler.instanceName"] = "TestScheduler";
properties["quartz.scheduler.instanceId"] = "instance_one";
properties["quartz.threadPool.type"] = "Quartz.Simpl.SimpleThreadPool, Quartz";
properties["quartz.threadPool.threadCount"] = "10";
properties["quartz.serializer.type"] = TestConstants.DefaultSerializerType;
properties["quartz.jobStore.misfireThreshold"] = "60000";
properties["quartz.jobStore.type"] = "Quartz.Impl.AdoJobStore.JobStoreTX, Quartz";
properties["quartz.jobStore.driverDelegateType"] = "Quartz.Impl.AdoJobStore.StdAdoDelegate, Quartz";
properties["quartz.jobStore.useProperties"] = "false";
properties["quartz.jobStore.dataSource"] = "default";
properties["quartz.jobStore.tablePrefix"] = "QRTZ_";
properties["quartz.jobStore.clustered"] = clustered.ToString();
properties["quartz.jobStore.driverDelegateType"] = "Quartz.Impl.AdoJobStore.SqlServerDelegate, Quartz";
await RunAdoJobStoreTest(TestConstants.DefaultSqlServerProvider, "SQLServer", serializerType, properties);
string connectionString;
if (!dbConnectionStrings.TryGetValue("SQLServer", out connectionString))
{
throw new Exception("Unknown connection string id: " + "SQLServer");
}
properties["quartz.dataSource.default.connectionString"] = connectionString;
properties["quartz.dataSource.default.provider"] = TestConstants.DefaultSqlServerProvider;
// First we must get a reference to a scheduler
ISchedulerFactory sf = new StdSchedulerFactory(properties);
IScheduler sched = await sf.GetScheduler();
try
{
await sched.Clear();
if (scheduleJobs)
{
ICalendar cronCalendar = new CronCalendar("0/5 * * * * ?");
ICalendar holidayCalendar = new HolidayCalendar();
for (int i = 0; i < 100000; ++i)
{
ITrigger trigger = new SimpleTriggerImpl("calendarsTrigger", "test", SimpleTriggerImpl.RepeatIndefinitely, TimeSpan.FromSeconds(1));
JobDetailImpl jd = new JobDetailImpl("testJob", "test", typeof(NoOpJob));
await sched.ScheduleJob(jd, trigger);
}
}
await sched.Start();
await Task.Delay(TimeSpan.FromSeconds(30));
}
finally
{
await sched.Shutdown(false);
}
}
/// <summary>
/// Register new <see cref="CronCalendar"/>
/// </summary>
/// <param name="name"></param>
/// <param name="description"></param>
/// <param name="cronExpression"></param>
public void AddCronCalendar(string name, string description, string cronExpression)
{
var cronCal = new CronCalendar(cronExpression)
{
Description = description
};
_scheduler.AddCalendar(name, cronCal, true, true);
}
public void MillisecondsShouldBeIgnored()
{
var calendar = new CronCalendar("* * 1-3 ? * *")
{
TimeZone = TimeZoneInfo.Utc
};
var dateTime = new DateTimeOffset(2017, 7, 27, 2, 0, 1, 123, TimeSpan.Zero);
Assert.That(calendar.IsTimeIncluded(dateTime), Is.False);
}
/// <summary>
/// Amends existing <see cref="CronCalendar"/>
/// </summary>
/// <param name="id"></param>
/// <param name="description"></param>
/// <param name="cronExpression"></param>
public void AmendCronCalendar(Guid id, string description, string cronExpression)
{
var name = _persistanceStore.GetCalendarName(id);
var cronCal = new CronCalendar(cronExpression)
{
Description = description
};
_scheduler.AddCalendar(name, cronCal, true, true);
}
public void TestTimeIncluded()
{
CronCalendar calendar = new CronCalendar("0/15 * * * * ?");
string fault = "Time was included when it was not supposed to be";
DateTime tst = DateTime.UtcNow.AddMinutes(2);
tst = new DateTime(tst.Year, tst.Month, tst.Day, tst.Hour, tst.Minute, 30);
Assert.IsFalse(calendar.IsTimeIncluded(tst), fault);
calendar.SetCronExpressionString("0/25 * * * * ?");
fault = "Time was not included as expected";
Assert.IsTrue(calendar.IsTimeIncluded(tst), fault);
}
public void SerializeChainedCalendars()
{
var annualCalendar = new AnnualCalendar();
annualCalendar.Description = "description";
annualCalendar.SetDayExcluded(DateTime.UtcNow.Date, true);
var cronCalendar = new CronCalendar("0/5 * * * * ?");
cronCalendar.CalendarBase = annualCalendar;
CompareSerialization(cronCalendar);
}
public void CronCalendarTest()
{
XmlLoaderPlugin plugin = new XmlLoaderPlugin();
plugin.FileName = "quartz_loader_required_fields.xml";
IScheduler scheduler = new Mock <IScheduler>().Object;
plugin.Initialize("MyPlugin", scheduler);
CronCalendar cal = plugin.Calendars["name1"] as CronCalendar;
Assert.AreEqual("* * 0-20 * * ?", cal.CronExpression.CronExpressionString);
Assert.IsTrue(cal.IsTimeIncluded(new DateTimeOffset(2012, 08, 30, 17, 0, 0, new TimeSpan(0, 0, 0))));
}
public void QuartzCronCalendar_Should_ReturnTrue_When_EventTimeIsNotInQuietPeriod()
{
// Arrange
var today = DateTime.UtcNow;
var eventTime = new DateTimeOffset(
new DateTime(today.Year, today.Month, today.Day, 7, 30, 00, DateTimeKind.Local));
var calendar = new CronCalendar("* * 6 ? * * *"); // 6:00 AM until 6:59 AM, every day
// Act
var quiet = calendar.IsTimeIncluded(eventTime);
// Assert
Assert.True(quiet);
}
/// <summary>
/// 添加日历
/// </summary>
/// <param name="input"></param>
public static void AddCalendar(CalendarInput input)
{
var calendar = new BaseCalendar();
switch (input.EnumCalendar)
{
case EnumCalendar.Cron表达式:
calendar = new CronCalendar(input.Expression);
break;
}
calendar.TimeZone = TimeZoneInfo.Local;
calendar.Description = input.Description;
Scheduler.AddCalendar(input.CalendarName, calendar, input.ReplaceExists, input.UpdateTriggers);
}
/// <summary>
/// Register new <see cref="CronCalendar"/>
/// </summary>
/// <param name="name"></param>
/// <param name="description"></param>
/// <param name="cronExpression"></param>
public Guid AddCronCalendar(string name, string description, string cronExpression)
{
var cronCal = new CronCalendar(cronExpression)
{
Description = description
};
Guid id;
using (var tran = new TransactionScope())
{
id = _persistanceStore.UpsertCalendarIdMap(name);
_scheduler.AddCalendar(name, cronCal, true, true);
tran.Complete();
}
return(id);
}
public void TestQuartzCalendarExclusion()
{
DateTimeOffset startTime = DateBuilder.DateOf(0, 0, 0, 1, 1, 2011);
DailyTimeIntervalTriggerImpl trigger = new DailyTimeIntervalTriggerImpl();
trigger.StartTimeUtc = startTime;
trigger.StartTimeOfDayUtc = new TimeOfDay(8, 0);
trigger.RepeatIntervalUnit = IntervalUnit.Minute;
trigger.RepeatInterval = 60;
CronCalendar cronCal = new CronCalendar("* * 9-12 * * ?"); // exclude 9-12
IList <DateTimeOffset> fireTimes = TriggerUtils.ComputeFireTimes(trigger, cronCal, 48);
Assert.AreEqual(48, fireTimes.Count);
Assert.AreEqual(DateBuilder.DateOf(8, 0, 0, 1, 1, 2011), fireTimes[0]);
Assert.AreEqual(DateBuilder.DateOf(13, 0, 0, 1, 1, 2011), fireTimes[1]);
Assert.AreEqual(DateBuilder.DateOf(23, 0, 0, 4, 1, 2011), fireTimes[47]);
}
public void TestQuartzCalendarExclusion()
{
DateTimeOffset startTime = DateBuilder.DateOf(0, 0, 0, 1, 1, 2011);
var trigger = new DailyTimeIntervalTriggerImpl
{
StartTimeUtc = startTime.ToUniversalTime(),
StartTimeOfDay = new TimeOfDay(8, 0),
RepeatIntervalUnit = IntervalUnit.Minute,
RepeatInterval = 60
};
CronCalendar cronCal = new CronCalendar("* * 9-12 * * ?"); // exclude 9-12
var fireTimes = TriggerUtils.ComputeFireTimes(trigger, cronCal, 48);
Assert.AreEqual(48, fireTimes.Count);
Assert.AreEqual(DateBuilder.DateOf(8, 0, 0, 1, 1, 2011), fireTimes[0]);
Assert.AreEqual(DateBuilder.DateOf(13, 0, 0, 1, 1, 2011), fireTimes[1]);
Assert.AreEqual(DateBuilder.DateOf(23, 0, 0, 4, 1, 2011), fireTimes[47]);
}
public void IsQuietPeriod_Should_ReturnTrue_WhenEventTimeIsInQuietPeriod()
{
// Arrange
var today = DateTime.UtcNow;
var eventTime = new DateTimeOffset(
new DateTime(today.Year, today.Month, today.Day, 6, 30, 00, DateTimeKind.Local));
var calendar1 = new CronCalendar("* * 6 ? * * *"); // 6:00 AM until 6:59 AM, every day
var calendar2 = new CronCalendar("* * * 15 * ? *"); // all day but only the 15th of the month
var quietPeriods = new QuietPeriods();
quietPeriods.AddCalendar(calendar1);
quietPeriods.AddCalendar(calendar2);
// Act
var quiet = quietPeriods.IsQuietPeriod(eventTime);
// Assert
Assert.True(quiet);
}
static void InitializeCron(CronCalendar cronCalendar, ICronCalendar calendar)
{
cronCalendar.TimeZone = TimeZoneInfo.FindSystemTimeZoneById(RegistryTimeZoneProvider.GetRegistryKeyNameByTimeZoneId(calendar.TimeZone));
cronCalendar.CronExpression = new CronExpression(calendar.CronExpression);
}
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 CronCalendarDto(CronCalendar calendar) : base(calendar)
{
CronExpression = calendar.CronExpression.CronExpressionString;
TimeZone = new TimeZoneDto(calendar.TimeZone);
}
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);
}
}
private void RunAdoJobStoreTest(string dbProvider, string connectionStringId,
NameValueCollection extraProperties)
{
NameValueCollection properties = new NameValueCollection();
properties["quartz.scheduler.instanceName"] = "TestScheduler";
properties["quartz.scheduler.instanceId"] = "instance_one";
properties["quartz.threadPool.type"] = "Quartz.Simpl.SimpleThreadPool, Quartz";
properties["quartz.threadPool.threadCount"] = "10";
properties["quartz.threadPool.threadPriority"] = "Normal";
properties["quartz.jobStore.misfireThreshold"] = "60000";
properties["quartz.jobStore.type"] = "Quartz.Impl.AdoJobStore.JobStoreTX, Quartz";
properties["quartz.jobStore.driverDelegateType"] = "Quartz.Impl.AdoJobStore.StdAdoDelegate, Quartz";
properties["quartz.jobStore.useProperties"] = "false";
properties["quartz.jobStore.dataSource"] = "default";
properties["quartz.jobStore.tablePrefix"] = "QRTZ_";
properties["quartz.jobStore.clustered"] = clustered.ToString();
if (extraProperties != null)
{
foreach (string key in extraProperties.Keys)
{
properties[key] = extraProperties[key];
}
}
if (connectionStringId == "SQLServer" || connectionStringId == "SQLite")
{
// if running MS SQL Server we need this
properties["quartz.jobStore.lockHandler.type"] =
"Quartz.Impl.AdoJobStore.UpdateLockRowSemaphore, Quartz";
}
string connectionString;
if (!dbConnectionStrings.TryGetValue(connectionStringId, out connectionString))
{
throw new Exception("Unknown connection string id: " + connectionStringId);
}
properties["quartz.dataSource.default.connectionString"] = connectionString;
properties["quartz.dataSource.default.provider"] = dbProvider;
// First we must get a reference to a scheduler
ISchedulerFactory sf = new StdSchedulerFactory(properties);
IScheduler sched = sf.GetScheduler();
try
{
if (clearJobs)
{
CleanUp(sched);
}
if (scheduleJobs)
{
ICalendar cronCalendar = new CronCalendar("0/5 * * * * ?");
ICalendar holidayCalendar = new HolidayCalendar();
// QRTZNET-86
ITrigger t = sched.GetTrigger(new TriggerKey("NonExistingTrigger", "NonExistingGroup"));
Assert.IsNull(t);
AnnualCalendar cal = new AnnualCalendar();
sched.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));
sched.ScheduleJob(jd, calendarsTrigger);
// QRTZNET-93
sched.AddCalendar("annualCalendar", cal, true, true);
sched.AddCalendar("baseCalendar", new BaseCalendar(), false, true);
sched.AddCalendar("cronCalendar", cronCalendar, false, true);
sched.AddCalendar("dailyCalendar", new DailyCalendar(DateTime.Now.Date, DateTime.Now.AddMinutes(1)), false, true);
sched.AddCalendar("holidayCalendar", holidayCalendar, false, true);
sched.AddCalendar("monthlyCalendar", new MonthlyCalendar(), false, true);
sched.AddCalendar("weeklyCalendar", new WeeklyCalendar(), false, true);
sched.AddCalendar("cronCalendar", cronCalendar, true, true);
sched.AddCalendar("holidayCalendar", holidayCalendar, true, true);
Assert.IsNotNull(sched.GetCalendar("annualCalendar"));
JobDetailImpl lonelyJob = new JobDetailImpl("lonelyJob", "lonelyGroup", typeof(SimpleRecoveryJob));
lonelyJob.Durable = true;
lonelyJob.RequestsRecovery = true;
sched.AddJob(lonelyJob, false);
sched.AddJob(lonelyJob, true);
string schedId = sched.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.StartTimeUtc = DateTime.Now.AddMilliseconds(1000L);
sched.ScheduleJob(job, trigger);
// check that trigger was stored
ITrigger persisted = sched.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));
sched.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));
sched.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));
sched.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));
sched.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.StartTimeUtc = DateTime.Now.AddMilliseconds(1000);
sched.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("cron_trig_" + count, schedId);
nt.StartTimeUtc = DateTime.Now.Date.AddMilliseconds(1000);
nt.N = 1;
sched.ScheduleJob(job, nt);
sched.Start();
sched.PauseAll();
sched.ResumeAll();
sched.PauseJob(new JobKey("job_1", schedId));
sched.ResumeJob(new JobKey("job_1", schedId));
sched.PauseJobs(GroupMatcher <JobKey> .GroupEquals(schedId));
Thread.Sleep(1000);
sched.ResumeJobs(GroupMatcher <JobKey> .GroupEquals(schedId));
sched.PauseTrigger(new TriggerKey("trig_2", schedId));
sched.ResumeTrigger(new TriggerKey("trig_2", schedId));
sched.PauseTriggers(GroupMatcher <TriggerKey> .GroupEquals(schedId));
Assert.AreEqual(1, sched.GetPausedTriggerGroups().Count);
Thread.Sleep(1000);
sched.ResumeTriggers(GroupMatcher <TriggerKey> .GroupEquals(schedId));
Thread.Sleep(TimeSpan.FromSeconds(20));
sched.Standby();
CollectionAssert.IsNotEmpty(sched.GetCalendarNames());
CollectionAssert.IsNotEmpty(sched.GetJobKeys(GroupMatcher <JobKey> .GroupEquals(schedId)));
CollectionAssert.IsNotEmpty(sched.GetTriggersOfJob(new JobKey("job_2", schedId)));
Assert.IsNotNull(sched.GetJobDetail(new JobKey("job_2", schedId)));
sched.DeleteCalendar("cronCalendar");
sched.DeleteCalendar("holidayCalendar");
sched.DeleteJob(new JobKey("lonelyJob", "lonelyGroup"));
}
}
finally
{
sched.Shutdown(false);
}
}
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);
}
}
}
public static void TestQuarz()
{
#region 测试验证
// Common.Config.PropertiesParser.ReadFromFileResource("test.txt");
// Run();
// Set();
// Console.Read();
#endregion
// Quartzlog.LogManager.Adapter=new
IScheduler scheduler = StdSchedulerFactory.GetDefaultScheduler(); //调度者
WeeklyCalendar calendar = new WeeklyCalendar();
calendar.SetDayExcluded(DayOfWeek.Thursday, true); //设置每周五不能执行;
HolidayCalendar daycalendar = new HolidayCalendar();
daycalendar.AddExcludedDate(DateTime.Now); //只取日 DateTime.Now.Day
MonthlyCalendar monthcalendar = new MonthlyCalendar();
monthcalendar.SetDayExcluded(16, true); //只取月 DateTime.Now.Month
AnnualCalendar annualCalendar = new AnnualCalendar();
annualCalendar.SetDayExcluded(DateTime.Now, true); //只取年月日 DateTime.Now.Year
CronCalendar cronCalendar = new CronCalendar("* * * 17 6 ?"); //6月17 不执行
scheduler.AddCalendar("mycalendar", calendar, true, true); //设置每周五不能执行;
scheduler.AddCalendar("mycalendar", daycalendar, true, true); //某一天不执行
scheduler.AddCalendar("mycalendar", monthcalendar, true, true); //某每月某一天不执行
scheduler.AddCalendar("mycalendar", annualCalendar, true, true); //每年某一月某一日不执行
scheduler.AddCalendar("mycalendar", cronCalendar, true, true); //每年某一月某一日不执行
scheduler.Start();
var job = JobBuilder.Create <LxshJob>().WithDescription("Job")
.WithIdentity("lxshJob", "lxshGroup")
.UsingJobData("userName", "Joblxsh")
.Build(); //任务
var job1 = JobBuilder.Create <LxshJob>().WithDescription("Job")
.WithIdentity("lxshJob", "lxshGroup")
.UsingJobData("userName", "Joblxsh1")
.Build(); //任务
var trigger = TriggerBuilder.Create().StartNow()
.WithDescription("trigger")
.WithSimpleSchedule(x => x.WithIntervalInSeconds(1).WithRepeatCount(10))
// .WithCalendarIntervalSchedule(x=>x.WithIntervalInYears(1))
// .WithSimpleSchedule(x => x.WithIntervalInSeconds(1).RepeatForever())
.WithDailyTimeIntervalSchedule(x =>
{
x.OnDaysOfTheWeek(new DayOfWeek[2] {
DayOfWeek.Tuesday, DayOfWeek.Friday
}); //每周二或者周五执行
x.OnEveryDay()
.StartingDailyAt(TimeOfDay.HourAndMinuteOfDay(8, 00)) // 八点开始
.EndingDailyAt(TimeOfDay.HourAndMinuteOfDay(18, 00)) // 十八点开始
.WithIntervalInSeconds(1); // 每1s执行一次
})
// .ModifiedByCalendar("mycalendar")
.Build();
//秒分时日月
var trigger1 = TriggerBuilder.Create().WithCronSchedule("* * * * * ?").Build(); //1秒执行一次
var trigger2 = TriggerBuilder.Create().WithCronSchedule("0 * * * * ?").Build(); //1分钟执行一次
var trigger3 = TriggerBuilder.Create().WithCronSchedule("0 0/30 8-20 * * ?").Build(); //30分钟检查一次 8-20点
var trigger4 = TriggerBuilder.Create().WithCronSchedule("* * * * * ?").Build();
// scheduler.ListenerManager.AddJobListener(new lxshJobLinstener(), GroupMatcher<JobKey>.AnyGroup());
scheduler.ScheduleJob(job, trigger); //开始调度任务
// scheduler.GetTriggersOfJob(new JobKey("lxshJob")).Select(x =>x.Key.ToString() );
Console.Read();
#region WithCronSchedule
// --------------------------------------
// 0 0 12 * * ? 每天12点触发
// 0 15 10 ? **每天10点15分触发
// 0 15 10 * * ? 每天10点15分触发
// 0 15 10 * * ? *每天10点15分触发
// 0 15 10 * * ? 2005 2005年每天10点15分触发
// 0 * 14 * * ? 每天下午的 2点到2点59分每分触发
// 0 0 / 5 14 * * ? 每天下午的 2点到2点59分(整点开始，每隔5分触发)
// 0 0 / 5 14,18 * * ? 每天下午的 2点到2点59分(整点开始，每隔5分触发) 每天下午的 18点到18点59分(整点开始，每隔5分触发)
// 0 0 - 5 14 * * ? 每天下午的 2点到2点05分每分触发
// 0 10,44 14 ? 3 WED 3月分每周三下午的 2点10分和2点44分触发
// 0 15 10 ? *MON - FRI 从周一到周五每天上午的10点15分触发
// 0 15 10 15 * ? 每月15号上午10点15分触发
// 0 15 10 L * ? 每月最后一天的10点15分触发
// 0 15 10 ? *6L 每月最后一周的星期五的10点15分触发
// 0 15 10 ? *6L 2002 - 2005 从2002年到2005年每月最后一周的星期五的10点15分触发
// 0 15 10 ? *6#3 每月的第三周的星期五开始触发
// 0 0 12 1 / 5 * ? 每月的第一个中午开始每隔5天触发一次
// 0 11 11 11 11 ? 每年的11月11号 11点11分触发(光棍节)
//--------------------------------------
#endregion
}
