public void TestClone()
{
SimpleTriggerImpl simpleTrigger = new SimpleTriggerImpl();
// Make sure empty sub-objects are cloned okay
ITrigger clone = (ITrigger)simpleTrigger.Clone();
Assert.AreEqual(0, clone.JobDataMap.Count);
// Make sure non-empty sub-objects are cloned okay
simpleTrigger.JobDataMap.Put("K1", "V1");
simpleTrigger.JobDataMap.Put("K2", "V2");
clone = (ITrigger)simpleTrigger.Clone();
Assert.AreEqual(2, clone.JobDataMap.Count);
Assert.AreEqual("V1", clone.JobDataMap.Get("K1"));
Assert.AreEqual("V2", clone.JobDataMap.Get("K2"));
// Make sure sub-object collections have really been cloned by ensuring
// their modification does not change the source Trigger
clone.JobDataMap.Remove("K1");
Assert.AreEqual(1, clone.JobDataMap.Count);
Assert.AreEqual(2, simpleTrigger.JobDataMap.Count);
Assert.AreEqual("V1", simpleTrigger.JobDataMap.Get("K1"));
Assert.AreEqual("V2", simpleTrigger.JobDataMap.Get("K2"));
}
/// <summary>
/// Called when the associated <see cref="IScheduler"/> is started, in order
/// to let the plug-in know it can now make calls into the scheduler if it
/// needs to.
/// </summary>
public virtual async Task Start(CancellationToken cancellationToken = default(CancellationToken))
{
try
{
if (jobFiles.Count > 0)
{
if (ScanInterval > TimeSpan.Zero)
{
Scheduler.Context.Put(JobInitializationPluginName + '_' + Name, this);
}
foreach (KeyValuePair <string, JobFile> pair in jobFiles)
{
JobFile jobFile = pair.Value;
if (ScanInterval > TimeSpan.Zero)
{
string jobTriggerName = BuildJobTriggerName(jobFile.FileBasename);
TriggerKey tKey = new TriggerKey(jobTriggerName, JobInitializationPluginName);
// remove pre-existing job/trigger, if any
await Scheduler.UnscheduleJob(tKey, cancellationToken).ConfigureAwait(false);
// TODO: convert to use builder
var trig = new SimpleTriggerImpl();
trig.Name = jobTriggerName;
trig.Group = JobInitializationPluginName;
trig.StartTimeUtc = SystemTime.UtcNow();
trig.EndTimeUtc = null;
trig.RepeatCount = SimpleTriggerImpl.RepeatIndefinitely;
trig.RepeatInterval = ScanInterval;
// TODO: convert to use builder
JobDetailImpl job = new JobDetailImpl(
jobTriggerName,
JobInitializationPluginName,
typeof(FileScanJob));
job.JobDataMap.Put(FileScanJob.FileName, jobFile.FilePath);
job.JobDataMap.Put(FileScanJob.FileScanListenerName, JobInitializationPluginName + '_' + Name);
await Scheduler.ScheduleJob(job, trig, cancellationToken).ConfigureAwait(false);
Log.DebugFormat("Scheduled file scan job for data file: {0}, at interval: {1}", jobFile.FileName, ScanInterval);
}
await ProcessFile(jobFile, cancellationToken).ConfigureAwait(false);
}
}
}
catch (SchedulerException se)
{
Log.ErrorException("Error starting background-task for watching jobs file.", se);
}
finally
{
started = true;
}
}
public void TestMisfireInstructionValidity()
{
SimpleTriggerImpl trigger = new SimpleTriggerImpl();
try
{
trigger.MisfireInstruction = MisfireInstruction.IgnoreMisfirePolicy;
trigger.MisfireInstruction = MisfireInstruction.SmartPolicy;
trigger.MisfireInstruction = MisfireInstruction.SimpleTrigger.FireNow;
trigger.MisfireInstruction = MisfireInstruction.SimpleTrigger.RescheduleNextWithExistingCount;
trigger.MisfireInstruction = MisfireInstruction.SimpleTrigger.RescheduleNextWithRemainingCount;
trigger.MisfireInstruction = MisfireInstruction.SimpleTrigger.RescheduleNowWithExistingRepeatCount;
trigger.MisfireInstruction = MisfireInstruction.SimpleTrigger.RescheduleNowWithRemainingRepeatCount;
}
catch (Exception)
{
Assert.Fail("Unexpected exception while setting misfire instruction.");
}
try
{
trigger.MisfireInstruction = MisfireInstruction.SimpleTrigger.RescheduleNextWithExistingCount + 1;
Assert.Fail("Expected exception while setting invalid misfire instruction but did not get it.");
}
catch (Exception ex)
{
if (ex is AssertionException)
{
throw;
}
}
}
public async Task TestSameDefaultPriority()
{
NameValueCollection config = new NameValueCollection();
config["quartz.threadPool.threadCount"] = "1";
config["quartz.threadPool.type"] = "Quartz.Simpl.SimpleThreadPool";
config["quartz.serializer.type"] = TestConstants.DefaultSerializerType;
IScheduler sched = await new StdSchedulerFactory(config).GetScheduler();
DateTime n = DateTime.UtcNow;
DateTime cal = new DateTime(n.Year, n.Month, n.Day, n.Hour, n.Minute, 1, n.Millisecond, DateTimeKind.Utc);
IMutableTrigger trig1 = new SimpleTriggerImpl("T1", null, cal);
IMutableTrigger trig2 = new SimpleTriggerImpl("T2", null, cal);
JobDetailImpl jobDetail = new JobDetailImpl("JD", null, typeof(TestJob));
await sched.ScheduleJob(jobDetail, trig1);
trig2.JobKey = new JobKey(jobDetail.Key.Name);
await sched.ScheduleJob(trig2);
await sched.Start();
await Task.Delay(2000);
Assert.AreEqual("T1T2", result.ToString());
await sched.Shutdown();
}
/// <summary>
/// Called when the associated <see cref="IScheduler"/> is started, in order
/// to let the plug-in know it can now make calls into the scheduler if it
/// needs to.
/// </summary>
public virtual void Start()
{
try
{
if (jobFiles.Count > 0)
{
if (scanInterval > TimeSpan.Zero)
{
scheduler.Context.Put(JobInitializationPluginName + '_' + Name, this);
}
foreach (KeyValuePair <string, JobFile> pair in jobFiles)
{
JobFile jobFile = pair.Value;
if (scanInterval > TimeSpan.Zero)
{
string jobTriggerName = BuildJobTriggerName(jobFile.FileBasename);
TriggerKey tKey = new TriggerKey(jobTriggerName, JobInitializationPluginName);
// remove pre-existing job/trigger, if any
Scheduler.UnscheduleJob(tKey);
// TODO: convert to use builder
SimpleTriggerImpl trig = (SimpleTriggerImpl)Scheduler.GetTrigger(tKey);
trig = new SimpleTriggerImpl();
trig.Name = (jobTriggerName);
trig.Group = (JobInitializationPluginName);
trig.StartTimeUtc = SystemTime.UtcNow();
trig.EndTimeUtc = (null);
trig.RepeatCount = (SimpleTriggerImpl.RepeatIndefinitely);
trig.RepeatInterval = (scanInterval);
// TODO: convert to use builder
JobDetailImpl job = new JobDetailImpl(
jobTriggerName,
JobInitializationPluginName,
typeof(FileScanJob));
job.JobDataMap.Put(FileScanJob.FileName, jobFile.FilePath);
job.JobDataMap.Put(FileScanJob.FileScanListenerName, JobInitializationPluginName + '_' + Name);
scheduler.ScheduleJob(job, trig);
Log.DebugFormat("Scheduled file scan job for data file: {0}, at interval: {1}", jobFile.FileName, scanInterval);
}
ProcessFile(jobFile);
}
}
}
catch (SchedulerException se)
{
Log.Error("Error starting background-task for watching jobs file.", se);
}
finally
{
started = true;
}
}
public void RegisterJobs()
{
try
{
new Thread(delegate()
{
WindsorBootstrapper.Register();
IScheduler scheduler = new StdSchedulerFactory().GetScheduler();
JobDetailImpl jobdetailLiveScore = new JobDetailImpl("rssJob", null, typeof(RssParserService));
SimpleTriggerImpl triggerLiveScore = new SimpleTriggerImpl(string.Format("{0}Trigger_", "rssJob"), DateTime.Now.AddSeconds(1), null, SimpleTriggerImpl.RepeatIndefinitely, TimeSpan.FromSeconds(10));
scheduler.ScheduleJob(jobdetailLiveScore, triggerLiveScore);
scheduler.Start();
var resetEvent = new ManualResetEvent(false);
resetEvent.WaitOne();
}).Start();
}
catch (Exception ex)
{
System.Diagnostics.EventLog.WriteEntry("err",
$"{ex.Message} - {ex.StackTrace}", System.Diagnostics.EventLogEntryType.Error);
throw;
}
}
/// <summary>
/// Schedule next job for the specified campaign.
/// </summary>
/// <param name="schema">The <see cref="Terrasoft.Core.Campaign.CampaignSchema"/> object for wich Job plans.</param>
/// <param name="fireTimeConfig">Fire time config for job.</param>
public void ScheduleJob(CoreCampaignSchema schema, CampaignFireTimeConfig fireTimeConfig)
{
try {
schema.CheckArgumentNull(nameof(schema));
fireTimeConfig.CheckArgumentNull(nameof(fireTimeConfig));
Guid campaignId = schema.EntityId;
var campaignJobName = GetCampaignJobName(campaignId, fireTimeConfig.Time);
var sysUserConnection = _userConnection.AppConnection.SystemUserConnection;
var parameters = new Dictionary <string, object> {
{ "CampaignSchemaUId", schema.UId },
{ "ScheduledUtcFireTime", fireTimeConfig.Time },
{ "SchemaGeneratorStrategy", fireTimeConfig.ExecutionStrategy },
{ "ScheduledAction", (int)fireTimeConfig.ScheduledAction }
};
IJobDetail job = AppScheduler.CreateClassJob <CampaignJobExecutor>(campaignJobName,
CampaignConsts.CampaignJobGroupName, sysUserConnection, parameters);
ITrigger trigger = new SimpleTriggerImpl(campaignJobName + "Trigger",
CampaignConsts.CampaignJobGroupName, fireTimeConfig.Time)
{
MisfireInstruction = MisfireInstruction.IgnoreMisfirePolicy
};
AppScheduler.Instance.ScheduleJob(job, trigger);
LogScheduledJob(schema.EntityId, fireTimeConfig);
} catch (Exception ex) {
string message = CampaignHelper.GetLczStringValue(nameof(CampaignJobDispatcher), "ScheduleException");
Logger.ErrorFormat(message, ex, schema == null ? Guid.Empty : schema.EntityId);
throw;
}
}
public async Task TestRescheduleJob_SchedulerListenersCalledOnReschedule()
{
const string TriggerName = "triggerName";
const string TriggerGroup = "triggerGroup";
const string JobName = "jobName";
const string JobGroup = "jobGroup";
NameValueCollection properties = new NameValueCollection();
properties["quartz.serializer.type"] = TestConstants.DefaultSerializerType;
ISchedulerFactory sf = new StdSchedulerFactory(properties);
IScheduler scheduler = await sf.GetScheduler();
DateTime startTimeUtc = DateTime.UtcNow.AddSeconds(2);
JobDetailImpl jobDetail = new JobDetailImpl(JobName, JobGroup, typeof(NoOpJob));
SimpleTriggerImpl jobTrigger = new SimpleTriggerImpl(TriggerName, TriggerGroup, JobName, JobGroup, startTimeUtc, null, 1, TimeSpan.FromMilliseconds(1000));
ISchedulerListener listener = A.Fake <ISchedulerListener>();
await scheduler.ScheduleJob(jobDetail, jobTrigger);
// add listener after scheduled
scheduler.ListenerManager.AddSchedulerListener(listener);
// act
await scheduler.RescheduleJob(new TriggerKey(TriggerName, TriggerGroup), jobTrigger);
// assert
// expect unschedule and schedule
A.CallTo(() => listener.JobUnscheduled(new TriggerKey(TriggerName, TriggerGroup))).MustHaveHappened();
A.CallTo(() => listener.JobScheduled(jobTrigger)).MustHaveHappened();
}
public async Task TestSchedulingWhenUpdatingScheduleBasedOnExistingTrigger()
{
DateTimeOffset startTime = new DateTimeOffset(2012, 12, 30, 1, 0, 0, TimeSpan.Zero);
DateTimeOffset previousFireTime = new DateTimeOffset(2013, 2, 15, 15, 0, 0, TimeSpan.Zero);
SimpleTriggerImpl existing = new SimpleTriggerImpl("triggerToReplace", "groupToReplace", startTime, null, SimpleTriggerImpl.RepeatIndefinitely, TimeSpan.FromHours(1));
existing.JobKey = new JobKey("jobName1", "jobGroup1");
existing.SetPreviousFireTimeUtc(previousFireTime);
existing.GetNextFireTimeUtc();
A.CallTo(() => mockScheduler.GetTrigger(existing.Key, A <CancellationToken> ._)).Returns(existing);
Stream s = ReadJobXmlFromEmbeddedResource("ScheduleRelativeToOldTrigger.xml");
await processor.ProcessStream(s, null);
await processor.ScheduleJobs(mockScheduler);
// check that last fire time was taken from existing trigger
A.CallTo(() => mockScheduler.RescheduleJob(null, null, A <CancellationToken> ._)).WhenArgumentsMatch(args =>
{
ITrigger argumentTrigger = (ITrigger)args[1];
// replacement trigger should have same start time and next fire relative to old trigger's last fire time
Assert.That(argumentTrigger, Is.Not.Null);
Assert.That(argumentTrigger.StartTimeUtc, Is.EqualTo(startTime));
Assert.That(argumentTrigger.GetNextFireTimeUtc(), Is.EqualTo(previousFireTime.AddSeconds(10)));
return(true);
}).MustHaveHappened();
}
private void StartJob(JobDefinition jobDefinition, bool runNow = false)
{
this.EventReporter.Trace("Creating " + jobDefinition.JobName);
var jobType = this.TypeLoader.LoadType(jobDefinition.AssemblyName, jobDefinition.ClassName);
var configType = jobType.BaseType.GetGenericArguments()[0];
var wrapperType = typeof(JobWrapper <,>).MakeGenericType(jobType, configType);
var jobDetail = new JobDetailImpl(jobDefinition.JobName, wrapperType);
jobDetail.JobDataMap.Add("Configuration", jobDefinition.Configuration);
if (runNow)
{
var trigger = new SimpleTriggerImpl(jobDefinition.JobName + "Trigger", DateBuilder.FutureDate(0, IntervalUnit.Minute), null, 1, TimeSpan.FromMinutes(int.MaxValue));
this.Scheduler.ScheduleJob(jobDetail, trigger);
}
else if (jobDefinition.Schedule is JobSimpleSchedule)
{
var schedule = (JobSimpleSchedule)jobDefinition.Schedule;
var trigger = new SimpleTriggerImpl(jobDefinition.JobName + "Trigger", DateBuilder.FutureDate(schedule.DelayStartMinutes, IntervalUnit.Minute), null, SimpleTriggerImpl.RepeatIndefinitely, TimeSpan.FromMinutes(schedule.IntervalMinutes));
this.Scheduler.ScheduleJob(jobDetail, trigger);
}
else if (jobDefinition.Schedule is JobCronSchedule)
{
var schedule = (JobCronSchedule)jobDefinition.Schedule;
var trigger = new CronTriggerImpl(jobDefinition.JobName + "Trigger", jobDefinition.JobName + "Group", schedule.CronScheduleExpression);
this.Scheduler.ScheduleJob(jobDetail, trigger);
}
this.EventReporter.Trace("Done Creating " + jobDefinition.JobName);
}
public void TestSchedulingWhenUpdatingScheduleBasedOnExistingTrigger()
{
DateTimeOffset startTime = new DateTimeOffset(2012, 12, 30, 1, 0, 0, TimeSpan.Zero);
DateTimeOffset previousFireTime = new DateTimeOffset(2013, 2, 15, 15, 0, 0, TimeSpan.Zero);
SimpleTriggerImpl existing = new SimpleTriggerImpl("triggerToReplace", "groupToReplace", startTime, null, SimpleTriggerImpl.RepeatIndefinitely, TimeSpan.FromHours(1));
existing.JobKey = new JobKey("jobName1", "jobGroup1");
existing.SetPreviousFireTimeUtc(previousFireTime);
existing.GetNextFireTimeUtc();
mockScheduler.Stub(x => x.GetTrigger(existing.Key)).Return(existing);
Stream s = ReadJobXmlFromEmbeddedResource("ScheduleRelativeToOldTrigger.xml");
processor.ProcessStream(s, null);
processor.ScheduleJobs(mockScheduler);
// check that last fire time was taken from existing trigger
mockScheduler.Stub(x => x.RescheduleJob(null, null)).IgnoreArguments();
var args = mockScheduler.GetArgumentsForCallsMadeOn(x => x.RescheduleJob(null, null));
ITrigger argumentTrigger = (ITrigger)args[0][1];
// replacement trigger should have same start time and next fire relative to old trigger's last fire time
Assert.That(argumentTrigger, Is.Not.Null);
Assert.That(argumentTrigger.StartTimeUtc, Is.EqualTo(startTime));
Assert.That(argumentTrigger.GetNextFireTimeUtc(), Is.EqualTo(previousFireTime.AddSeconds(10)));
}
public void TestStoreTriggerReplacesTrigger()
{
string jobName = "StoreTriggerReplacesTrigger";
string jobGroup = "StoreTriggerReplacesTriggerGroup";
JobDetailImpl detail = new JobDetailImpl(jobName, jobGroup, typeof(NoOpJob));
fJobStore.StoreJob(detail, false);
string trName = "StoreTriggerReplacesTrigger";
string trGroup = "StoreTriggerReplacesTriggerGroup";
IOperableTrigger tr = new SimpleTriggerImpl(trName, trGroup, DateTimeOffset.Now);
tr.JobKey = new JobKey(jobName, jobGroup);
tr.CalendarName = null;
fJobStore.StoreTrigger(tr, false);
Assert.AreEqual(tr, fJobStore.RetrieveTrigger(new TriggerKey(trName, trGroup)));
tr.CalendarName = "NonExistingCalendar";
fJobStore.StoreTrigger(tr, true);
Assert.AreEqual(tr, fJobStore.RetrieveTrigger(new TriggerKey(trName, trGroup)));
Assert.AreEqual(tr.CalendarName, fJobStore.RetrieveTrigger(new TriggerKey(trName, trGroup)).CalendarName, "StoreJob doesn't replace triggers");
bool exeptionRaised = false;
try
{
fJobStore.StoreTrigger(tr, false);
}
catch (ObjectAlreadyExistsException)
{
exeptionRaised = true;
}
Assert.IsTrue(exeptionRaised, "an attempt to store duplicate trigger succeeded");
}
public void TestAcquireNextTrigger()
{
DateTimeOffset d = DateBuilder.EvenMinuteDateAfterNow();
IOperableTrigger trigger1 = new SimpleTriggerImpl("trigger1", "triggerGroup1", fJobDetail.Name, fJobDetail.Group, d.AddSeconds(200), d.AddSeconds(200), 2, TimeSpan.FromSeconds(2));
IOperableTrigger trigger2 = new SimpleTriggerImpl("trigger2", "triggerGroup1", fJobDetail.Name, fJobDetail.Group, d.AddSeconds(50), d.AddSeconds(200), 2, TimeSpan.FromSeconds(2));
IOperableTrigger trigger3 = new SimpleTriggerImpl("trigger1", "triggerGroup2", fJobDetail.Name, fJobDetail.Group, d.AddSeconds(100), d.AddSeconds(200), 2, TimeSpan.FromSeconds(2));
trigger1.ComputeFirstFireTimeUtc(null);
trigger2.ComputeFirstFireTimeUtc(null);
trigger3.ComputeFirstFireTimeUtc(null);
fJobStore.StoreTrigger(trigger1, false);
fJobStore.StoreTrigger(trigger2, false);
fJobStore.StoreTrigger(trigger3, false);
DateTimeOffset firstFireTime = trigger1.GetNextFireTimeUtc().Value;
Assert.AreEqual(0, fJobStore.AcquireNextTriggers(d.AddMilliseconds(10), 1, TimeSpan.Zero).Count);
Assert.AreEqual(trigger2, fJobStore.AcquireNextTriggers(firstFireTime.AddSeconds(10), 1, TimeSpan.Zero)[0]);
Assert.AreEqual(trigger3, fJobStore.AcquireNextTriggers(firstFireTime.AddSeconds(10), 1, TimeSpan.Zero)[0]);
Assert.AreEqual(trigger1, fJobStore.AcquireNextTriggers(firstFireTime.AddSeconds(10), 1, TimeSpan.Zero)[0]);
Assert.AreEqual(0, fJobStore.AcquireNextTriggers(firstFireTime.AddSeconds(10), 1, TimeSpan.Zero).Count);
// release trigger3
fJobStore.ReleaseAcquiredTrigger(trigger3);
Assert.AreEqual(trigger3, fJobStore.AcquireNextTriggers(firstFireTime.AddSeconds(10), 1, TimeSpan.FromMilliseconds(1))[0]);
}
public void TestRescheduleJob_SchedulerListenersCalledOnReschedule()
{
const string TriggerName = "triggerName";
const string TriggerGroup = "triggerGroup";
const string JobName = "jobName";
const string JobGroup = "jobGroup";
ISchedulerFactory sf = new StdSchedulerFactory();
IScheduler scheduler = sf.GetScheduler();
DateTime startTimeUtc = DateTime.UtcNow.AddSeconds(2);
JobDetailImpl jobDetail = new JobDetailImpl(JobName, JobGroup, typeof(NoOpJob));
SimpleTriggerImpl jobTrigger = new SimpleTriggerImpl(TriggerName, TriggerGroup, JobName, JobGroup, startTimeUtc, null, 1, TimeSpan.FromMilliseconds(1000));
ISchedulerListener listener = MockRepository.GenerateMock <ISchedulerListener>();
scheduler.ScheduleJob(jobDetail, jobTrigger);
// add listener after scheduled
scheduler.ListenerManager.AddSchedulerListener(listener);
// act
scheduler.RescheduleJob(new TriggerKey(TriggerName, TriggerGroup), jobTrigger);
// assert
// expect unschedule and schedule
listener.AssertWasCalled(l => l.JobUnscheduled(new TriggerKey(TriggerName, TriggerGroup)));
listener.AssertWasCalled(l => l.JobScheduled(jobTrigger));
}
public async Task PauseJobGroupPausesNewJob()
{
string jobName1 = "PauseJobGroupPausesNewJob";
string jobName2 = "PauseJobGroupPausesNewJob2";
string jobGroup = "PauseJobGroupPausesNewJobGroup";
JobDetailImpl detail = new JobDetailImpl(jobName1, jobGroup, typeof(NoOpJob));
detail.Durable = true;
await fJobStore.StoreJob(detail, false);
await fJobStore.PauseJobs(GroupMatcher <JobKey> .GroupEquals(jobGroup));
detail = new JobDetailImpl(jobName2, jobGroup, typeof(NoOpJob));
detail.Durable = true;
await fJobStore.StoreJob(detail, false);
string trName = "PauseJobGroupPausesNewJobTrigger";
string trGroup = "PauseJobGroupPausesNewJobTriggerGroup";
IOperableTrigger tr = new SimpleTriggerImpl(trName, trGroup, DateTimeOffset.UtcNow);
tr.JobKey = new JobKey(jobName2, jobGroup);
await fJobStore.StoreTrigger(tr, false);
Assert.AreEqual(TriggerState.Paused, await fJobStore.GetTriggerState(tr.Key));
}
public async Task TestTriggerStates()
{
IOperableTrigger trigger = new SimpleTriggerImpl("trigger1", "triggerGroup1", fJobDetail.Name, fJobDetail.Group, DateTimeOffset.Now.AddSeconds(100), DateTimeOffset.Now.AddSeconds(200), 2, TimeSpan.FromSeconds(2));
trigger.ComputeFirstFireTimeUtc(null);
Assert.AreEqual(TriggerState.None, await fJobStore.GetTriggerState(trigger.Key));
await fJobStore.StoreTrigger(trigger, false);
Assert.AreEqual(TriggerState.Normal, await fJobStore.GetTriggerState(trigger.Key));
await fJobStore.PauseTrigger(trigger.Key);
Assert.AreEqual(TriggerState.Paused, await fJobStore.GetTriggerState(trigger.Key));
await fJobStore.ResumeTrigger(trigger.Key);
Assert.AreEqual(TriggerState.Normal, await fJobStore.GetTriggerState(trigger.Key));
trigger = (await fJobStore.AcquireNextTriggers(trigger.GetNextFireTimeUtc().Value.AddSeconds(10), 1, TimeSpan.FromMilliseconds(1))).First();
Assert.IsNotNull(trigger);
await fJobStore.ReleaseAcquiredTrigger(trigger);
trigger = (await fJobStore.AcquireNextTriggers(trigger.GetNextFireTimeUtc().Value.AddSeconds(10), 1, TimeSpan.FromMilliseconds(1))).First();
Assert.IsNotNull(trigger);
Assert.AreEqual(0, (await fJobStore.AcquireNextTriggers(trigger.GetNextFireTimeUtc().Value.AddSeconds(10), 1, TimeSpan.FromMilliseconds(1))).Count);
}
private void StartJob(JobDefinition job)
{
this.EventReporter.Trace("Creating job: " + job.JobName);
if (job.Schedule is JobCronSchedule)
{
}
else if (job.Schedule is JobSimpleSchedule)
{
var type = this.TypeLoader.LoadType(job.AssemblyName, job.ClassName);
var genericJobWrapperType = typeof(JobWrapper <,>);
var combinedJobType = genericJobWrapperType.MakeGenericType(type);
var jobDetail = new JobDetailImpl(job.JobName, combinedJobType);
var simpleSchedule = (JobSimpleSchedule)job.Schedule;
ITrigger trigger;
if (simpleSchedule.DelayStartMinutes != 0)
{
trigger = new SimpleTriggerImpl(job.JobName + "Trigger", DateBuilder.FutureDate(simpleSchedule.DelayStartMinutes, IntervalUnit.Minute), null, SimpleTriggerImpl.RepeatIndefinitely, TimeSpan.FromMinutes(simpleSchedule.IntervalMinutes));
}
else
{
trigger = new SimpleTriggerImpl(job.JobName + "Trigger", null, SimpleTriggerImpl.RepeatIndefinitely, TimeSpan.FromMinutes(simpleSchedule.IntervalMinutes));
}
this.Scheduler.ScheduleJob(jobDetail, trigger);
}
this.EventReporter.Trace("Done Creating " + job.JobName);
}
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 DarkModeChangeTrigger()
{
ITrigger trigger = new SimpleTriggerImpl("trigger-dark-mode", "notification", new DateTimeOffset(DateTime.Now));
IJobDetail jobDetail = new JobDetailImpl("notification-dark-mode", "notification", typeof(DarkModeChangeJob));
_scheduler.ScheduleJob(jobDetail, trigger);
}
public void UnlockWindowsTrigger()
{
ITrigger trigger = new SimpleTriggerImpl("trigger-unlock-windows", "notification", new DateTimeOffset(DateTime.Now));
IJobDetail jobDetail = new JobDetailImpl("notification-unlock", "notification", typeof(UnlockWindowsJob));
_scheduler.ScheduleJob(jobDetail, trigger);
}
/// <summary>
/// 修改触发器时间,需要job名,以及修改结果
/// SimpleTriggerImpl类型触发器
/// </summary>
public static void UpdateTime(string jobName, TimeSpan SimpleTime)
{
TriggerKey TKey = new TriggerKey(jobName + "_SimpleTrigger", jobName + "_TriggerGroup");
SimpleTriggerImpl STI = Sched.GetTrigger(TKey).Result as SimpleTriggerImpl;
STI.RepeatInterval = SimpleTime;
Sched.RescheduleJob(TKey, STI);
}
public void TestPrecision()
{
IOperableTrigger trigger = new SimpleTriggerImpl();
trigger.StartTimeUtc = new DateTimeOffset(1982, 6, 28, 13, 5, 5, 233, TimeSpan.Zero);
Assert.IsTrue(trigger.HasMillisecondPrecision);
Assert.AreEqual(233, trigger.StartTimeUtc.Millisecond);
}
/// <summary>
/// 修改触发器时间,需要job名,以及修改结果
/// SimpleTriggerImpl类型触发器
/// </summary>
public static async Task UpdateTime(string jobName, TimeSpan SimpleTime)
{
TriggerKey TKey = new TriggerKey(jobName + "_SimpleTrigger", jobName + "_TriggerGroup");
SimpleTriggerImpl sti = await sched.GetTrigger(TKey) as SimpleTriggerImpl;
sti.RepeatInterval = SimpleTime;
await sched.RescheduleJob(TKey, sti);
}
private static TriggerFiredBundle ConstructMinimalTriggerFiredBundle()
{
IJobDetail jd = new JobDetailImpl("jobName", "jobGroup", typeof(NoOpJob));
IOperableTrigger trigger = new SimpleTriggerImpl("triggerName", "triggerGroup");
TriggerFiredBundle retValue = new TriggerFiredBundle(jd, trigger, null, false, null, null, null, null);
return(retValue);
}
private static TriggerFiredBundle NewMinimalTriggerFiredBundle(bool isRecovering)
{
IJobDetail jd = new JobDetailImpl("jobName", "jobGroup", typeof(NoOpJob));
IOperableTrigger trigger = new SimpleTriggerImpl("triggerName", "triggerGroup");
TriggerFiredBundle retValue = new TriggerFiredBundle(jd, trigger, null, isRecovering, DateTimeOffset.UtcNow, null, null, null);
return(retValue);
}
protected virtual ICancellableJobExecutionContext CreateJobExecutionContext()
{
IOperableTrigger t = new SimpleTriggerImpl("name", "group");
TriggerFiredBundle firedBundle = TestUtil.CreateMinimalFiredBundleWithTypedJobDetail(typeof(NoOpJob), t);
ICancellableJobExecutionContext ctx = new JobExecutionContextImpl(null, firedBundle, null);
return(ctx);
}
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>
/// Build the actual Trigger -- NOT intended to be invoked by end users,
/// but will rather be invoked by a TriggerBuilder which this
/// ScheduleBuilder is given to.
/// </summary>
/// <remarks>
/// </remarks>
/// <seealso cref="TriggerBuilder.WithSchedule(IScheduleBuilder)" />
public override IMutableTrigger Build()
{
SimpleTriggerImpl st = new SimpleTriggerImpl();
st.RepeatInterval = (interval);
st.RepeatCount = (repeatCount);
return(st);
}
/// <summary>
/// Build the actual Trigger -- NOT intended to be invoked by end users,
/// but will rather be invoked by a TriggerBuilder which this
/// ScheduleBuilder is given to.
/// </summary>
/// <remarks>
/// </remarks>
/// <seealso cref="TriggerBuilder.WithSchedule(IScheduleBuilder)" />
public override IMutableTrigger Build()
{
SimpleTriggerImpl st = new SimpleTriggerImpl();
st.RepeatInterval = interval;
st.RepeatCount = repeatCount;
st.MisfireInstruction = misfireInstruction;
return st;
}
public void TestCreateJobInstance_SimpleDefaults()
{
IOperableTrigger trigger = new SimpleTriggerImpl();
TriggerFiredBundle bundle = TestUtil.CreateMinimalFiredBundleWithTypedJobDetail(typeof(NoOpJob), trigger);
IJob job = factory.NewJob(bundle, null);
Assert.IsNotNull(job, "Created job was null");
}