public override object Clone()
{
AnnualCalendar copy = (AnnualCalendar)base.Clone();
copy.excludeDays = new List <DateTimeOffset>(excludeDays);
return(copy);
}
public void TestTriggerFireExclusion()
{
sched.Start();
TestJob.JobHasFired = false;
JobDetailImpl myDesc = new JobDetailImpl("name", "group", typeof(TestJob));
IOperableTrigger trigger = new CronTriggerImpl("trigName", "trigGroup", "0/15 * * * * ?");
AnnualCalendar calendar = new AnnualCalendar();
calendar.SetDayExcluded(DateTime.Now, true);
sched.AddCalendar("calendar", calendar, true, true);
trigger.CalendarName = "calendar";
sched.ScheduleJob(myDesc, trigger);
IOperableTrigger triggerreplace = new CronTriggerImpl("foo", "trigGroup", "name", "group", "0/15 * * * * ?");
triggerreplace.CalendarName = "calendar";
sched.RescheduleJob(new TriggerKey("trigName", "trigGroup"), triggerreplace);
Thread.Sleep(1000 * 20);
Assert.IsFalse(TestJob.JobHasFired, "task must not be neglected - it is forbidden by the calendar");
calendar.SetDayExcluded(DateTime.Now, false);
sched.AddCalendar("calendar", calendar, true, true);
Thread.Sleep(1000 * 20);
Assert.IsTrue(TestJob.JobHasFired, "task must be neglected - it is permitted by the calendar");
sched.DeleteJob(new JobKey("name", "group"));
sched.DeleteCalendar("calendar");
sched.Shutdown();
}
public override ICalendar Clone()
{
var clone = new AnnualCalendar();
CloneFields(clone);
clone.excludeDays = new SortedSet <DateTime>(excludeDays);
return(clone);
}
/// <summary>
/// Get the object to serialize when generating serialized file for future
/// tests, and against which to validate deserialized object.
/// </summary>
/// <returns></returns>
protected override object GetTargetObject()
{
AnnualCalendar c = new AnnualCalendar();
c.Description = "description";
DateTime date = new DateTime(2005, 1, 20, 10, 5, 15);
c.SetDayExcluded(date, true);
return c;
}
public bool Equals(AnnualCalendar obj)
{
if (obj == null)
{
return(false);
}
bool toReturn = GetBaseCalendar() == null || GetBaseCalendar().Equals(obj.GetBaseCalendar());
toReturn = toReturn && (DaysExcluded.Count == obj.DaysExcluded.Count);
if (toReturn)
{
foreach (DateTime date in DaysExcluded)
{
toReturn = toReturn && obj.excludeDays.Contains(date);
}
}
return(toReturn);
}
public void TestAnnualCalendarTimeZone()
{
TimeZoneInfo tz = TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time");
AnnualCalendar c = new AnnualCalendar();
c.TimeZone = tz;
DateTimeOffset excludedDay = new DateTimeOffset(2012, 11, 4, 0, 0, 0, TimeSpan.Zero);
c.SetDayExcluded(excludedDay, true);
// 11/5/2012 12:00:00 AM -04:00 translate into 11/4/2012 11:00:00 PM -05:00 (EST)
DateTimeOffset date = new DateTimeOffset(2012, 11, 5, 0, 0, 0, TimeSpan.FromHours(-4));
Assert.IsFalse(c.IsTimeIncluded(date), "date was expected to not be included.");
Assert.IsTrue(c.IsTimeIncluded(date.AddDays(1)));
DateTimeOffset expectedNextAvailable = new DateTimeOffset(2012, 11, 5, 0, 0, 0, TimeSpan.FromHours(-5));
DateTimeOffset actualNextAvailable = c.GetNextIncludedTimeUtc(date);
Assert.AreEqual(expectedNextAvailable, actualNextAvailable);
}
public void TestTriggerFireExclusion()
{
sched.Start();
TestJob.JobHasFired = false;
IJobDetail jobDetail = JobBuilder.Create<TestJob>()
.WithIdentity("name", "group")
.Build();
ITrigger trigger = TriggerBuilder.Create()
.WithIdentity("trigName", "trigGroup")
.ModifiedByCalendar("calendar")
.WithCronSchedule("0/15 * * * * ?")
.Build();
AnnualCalendar calendar = new AnnualCalendar();
calendar.SetDayExcluded(DateTime.Now, true);
sched.AddCalendar("calendar", calendar, true, true);
sched.ScheduleJob(jobDetail, trigger);
ITrigger triggerreplace = TriggerBuilder.Create()
.WithIdentity("foo", "trigGroup")
.ForJob(jobDetail)
.ModifiedByCalendar("calendar")
.WithCronSchedule("0/15 * * * * ?")
.Build();
sched.RescheduleJob(new TriggerKey("trigName", "trigGroup"), triggerreplace);
Thread.Sleep(TimeSpan.FromSeconds(20));
Assert.IsFalse(TestJob.JobHasFired, "task must not be neglected - it is forbidden by the calendar");
calendar.SetDayExcluded(DateTime.Now, false);
sched.AddCalendar("calendar", calendar, true, true);
Thread.Sleep(TimeSpan.FromSeconds(20));
Assert.IsTrue(TestJob.JobHasFired, "task must be neglected - it is permitted by the calendar");
sched.DeleteJob(new JobKey("name", "group"));
sched.DeleteCalendar("calendar");
sched.Shutdown();
}
static void InitializeAnnual(AnnualCalendar annualCalendar, IAnnualCalendar calendar) {
annualCalendar.TimeZone = TimeZoneInfo.FindSystemTimeZoneById(Persistent.Base.General.RegistryTimeZoneProvider.GetRegistryKeyNameByTimeZoneId(calendar.TimeZone));
calendar.DatesExcluded.ForEach(time => annualCalendar.SetDayExcluded(time, true));
calendar.DatesIncluded.ForEach(time => annualCalendar.SetDayExcluded(time, false));
}
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);
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);
scheduler.ScheduleJob(job, nt);
DailyTimeIntervalTriggerImpl nt2 = new DailyTimeIntervalTriggerImpl();
nt2.Key = new TriggerKey("nth_trig2_" + count, schedId);
nt2.StartTimeUtc = DateTime.Now.Date.AddMilliseconds(1000);
nt2.JobKey = job.Key;
scheduler.ScheduleJob(nt2);
// GitHub issue #92
scheduler.GetTrigger(nt2.Key);
// GitHub issue #98
nt2.StartTimeOfDay = new TimeOfDay(1, 2, 3);
nt2.EndTimeOfDay = new TimeOfDay(2, 3, 4);
scheduler.UnscheduleJob(nt2.Key);
scheduler.ScheduleJob(nt2);
var triggerFromDb = (IDailyTimeIntervalTrigger) 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;
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 TestRemoveInTheFuture()
{
AnnualCalendar annualCalendar = new AnnualCalendar();
DateTime day = new DateTime(2005, 6, 23);
annualCalendar.SetDayExcluded(day, true);
// Trying to remove the 23th of June
day = new DateTime(2008, 6, 23);
annualCalendar.SetDayExcluded(day, false);
Assert.IsFalse(annualCalendar.IsDayExcluded(day), "The day 23 June is not expected to be excluded but it is");
}
public void Setup()
{
cal = new AnnualCalendar();
cal.TimeZone = TimeZoneInfo.Utc; //assume utc if not specified.
}
public bool Equals(AnnualCalendar obj)
{
if (obj == null)
return false;
bool toReturn = GetBaseCalendar() != null ?
GetBaseCalendar().Equals(obj.GetBaseCalendar()) : true;
toReturn = toReturn && (DaysExcluded.Count == obj.DaysExcluded.Count);
if (toReturn)
{
foreach (DateTime date in DaysExcluded)
toReturn = toReturn && obj.DaysExcluded.Contains(date);
}
return toReturn;
}
public AnnualCalendarDto(AnnualCalendar calendar) : base(calendar)
{
DaysExcluded = calendar.DaysExcluded;
TimeZone = new TimeZoneDto(calendar.TimeZone);
}
public void Setup()
{
cal = new AnnualCalendar();
cal.TimeZone = TestTimeZone;
}
public bool Equals(AnnualCalendar obj)
{
if (obj == null)
{
return false;
}
bool toReturn = GetBaseCalendar() == null || GetBaseCalendar().Equals(obj.GetBaseCalendar());
toReturn = toReturn && (DaysExcluded.Count == obj.DaysExcluded.Count);
if (toReturn)
{
foreach (DateTimeOffset date in DaysExcluded)
{
toReturn = toReturn && obj.DaysExcluded.Contains(date);
}
}
return toReturn;
}
public void TestDaysExcludedOverTime()
{
AnnualCalendar annualCalendar = new AnnualCalendar();
DateTime day = new DateTime(2005, 6, 23);
annualCalendar.SetDayExcluded(day, true);
day = new DateTime(2008, 2, 1);
annualCalendar.SetDayExcluded(day, true);
Assert.IsTrue(annualCalendar.IsDayExcluded(day), "The day 1 February is expected to be excluded but it is not");
}
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 void Setup()
{
cal = new AnnualCalendar();
}
public void BaseCalendarShouldNotAffectSettingInternalDataStructures()
{
var dayToExclude = new DateTime(2015, 1, 1);
AnnualCalendar a = new AnnualCalendar();
a.SetDayExcluded(dayToExclude, true);
AnnualCalendar b = new AnnualCalendar(a);
b.SetDayExcluded(dayToExclude, true);
b.CalendarBase = null;
Assert.That(b.IsDayExcluded(dayToExclude), "day was no longer excluded after base calendar was detached");
}
public virtual void Run()
{
ILog log = LogManager.GetLogger(typeof(CalendarExample));
log.Info("------- Initializing ----------------------");
// First we must get a reference to a scheduler
ISchedulerFactory sf = new StdSchedulerFactory();
IScheduler sched = sf.GetScheduler();
log.Info("------- Initialization Complete -----------");
log.Info("------- Scheduling Jobs -------------------");
// Add the holiday calendar to the schedule
AnnualCalendar holidays = new AnnualCalendar();
// fourth of July (July 4)
DateTime fourthOfJuly = new DateTime(DateTime.UtcNow.Year, 7, 4);
holidays.SetDayExcluded(fourthOfJuly, true);
// halloween (Oct 31)
DateTime halloween = new DateTime(DateTime.UtcNow.Year, 10, 31);
holidays.SetDayExcluded(halloween, true);
// christmas (Dec 25)
DateTime christmas = new DateTime(DateTime.UtcNow.Year, 12, 25);
holidays.SetDayExcluded(christmas, true);
// tell the schedule about our holiday calendar
sched.AddCalendar("holidays", holidays, false, false);
// schedule a job to run hourly, starting on halloween
// at 10 am
DateTimeOffset runDate = DateBuilder.DateOf(0, 0, 10, 31, 10);
IJobDetail job = JobBuilder.NewJob<SimpleJob>()
.WithIdentity("job1", "group1")
.Build();
ISimpleTrigger trigger = (ISimpleTrigger) TriggerBuilder.Create()
.WithIdentity("trigger1", "group1")
.StartAt(runDate)
.WithSchedule(SimpleScheduleBuilder.Create()
.WithIntervalInHours(1)
.RepeatForever())
.ModifiedByCalendar("holidays")
.Build();
// schedule the job and print the first run date
DateTimeOffset firstRunTime = sched.ScheduleJob(job, trigger);
// print out the first execution date.
// Note: Since Halloween (Oct 31) is a holiday, then
// we will not run unti the next day! (Nov 1)
log.Info(string.Format("{0} will run at: {1} and repeat: {2} times, every {3} seconds", job.Key, firstRunTime.ToString("r"), trigger.RepeatCount, trigger.RepeatInterval.TotalSeconds));
// All of the jobs have been added to the scheduler, but none of the jobs
// will run until the scheduler has been started
log.Info("------- Starting Scheduler ----------------");
sched.Start();
// wait 30 seconds:
// note: nothing will run
log.Info("------- Waiting 30 seconds... --------------");
try
{
// wait 30 seconds to show jobs
Thread.Sleep(30 * 1000);
// executing...
}
catch (ThreadInterruptedException)
{
}
// shut down the scheduler
log.Info("------- Shutting Down ---------------------");
sched.Shutdown(true);
log.Info("------- Shutdown Complete -----------------");
SchedulerMetaData metaData = sched.GetMetaData();
log.Info(string.Format("Executed {0} jobs.", metaData.NumberOfJobsExecuted));
}
public override ICalendar Clone()
{
var clone = new AnnualCalendar();
CloneFields(clone);
clone.excludeDays = new SortedSet<DateTime>(excludeDays);
return clone;
}