public virtual void JobWasExecuted(IJobExecutionContext inContext, JobExecutionException inException) { log.Info("Job1Listener says: Job was executed."); // Simple job #2 IJobDetail job2 = JobBuilder.NewJob <SimpleJob2>() .WithIdentity("job2") .Build(); ITrigger trigger = TriggerBuilder.Create() .WithIdentity("job2Trigger") .StartNow() .Build(); try { // schedule the job to run! inContext.Scheduler.ScheduleJob(job2, trigger); } catch (SchedulerException e) { log.Warn("Unable to schedule job2!"); Console.Error.WriteLine(e.StackTrace); } }
public JobBuilder GetJobBuilder() { JobBuilder b = JobBuilder.NewJob() .OfType(JobType) .RequestRecovery(RequestsRecovery) .StoreDurably(Durable) .UsingJobData(JobDataMap) .WithDescription(description) .WithIdentity(Key); return(b); }
public virtual void Run() { ILog log = LogManager.GetLogger(typeof(SimpleExample)); log.Info("------- Initializing ----------------------"); // First we must get a reference to a scheduler ISchedulerFactory sf = new StdSchedulerFactory(); IScheduler sched = sf.GetScheduler(); log.Info("------- Initialization Complete -----------"); // computer a time that is on the next round minute DateTimeOffset runTime = DateBuilder.EvenMinuteDate(DateTimeOffset.UtcNow); log.Info("------- Scheduling Job -------------------"); // define the job and tie it to our HelloJob class IJobDetail job = JobBuilder.NewJob <HelloJob>() .WithIdentity("job1", "group1") .Build(); // Trigger the job to run on the next round minute ITrigger trigger = TriggerBuilder.Create() .WithIdentity("trigger1", "group1") .StartAt(runTime) .Build(); // Tell quartz to schedule the job using our trigger sched.ScheduleJob(job, trigger); log.Info(string.Format("{0} will run at: {1}", job.Key, runTime.ToString("r"))); // Start up the scheduler (nothing can actually run until the // scheduler has been started) sched.Start(); log.Info("------- Started Scheduler -----------------"); // wait long enough so that the scheduler as an opportunity to // run the job! log.Info("------- Waiting 65 seconds... -------------"); // wait 65 seconds to show jobs Thread.Sleep(TimeSpan.FromSeconds(65)); // shut down the scheduler log.Info("------- Shutting Down ---------------------"); sched.Shutdown(true); log.Info("------- Shutdown Complete -----------------"); }
public void TestJobBuilder() { IJobDetail job = JobBuilder.NewJob() .OfType <TestJob>() .WithIdentity("j1") .StoreDurably() .Build(); Assert.AreEqual("j1", job.Key.Name, "Unexpected job name: " + job.Key.Name); Assert.IsTrue(job.Key.Group.Equals(JobKey.DefaultGroup), "Unexpected job group: " + job.Key.Group); Assert.IsTrue(job.Key.Equals(new JobKey("j1")), "Unexpected job key: " + job.Key); Assert.IsTrue(job.Description == null, "Unexpected job description: " + job.Description); Assert.IsTrue(job.Durable, "Expected isDurable == true "); Assert.IsFalse(job.RequestsRecovery, "Expected requestsRecovery == false "); Assert.IsFalse(job.ConcurrentExectionDisallowed, "Expected isConcurrentExectionDisallowed == false "); Assert.IsFalse(job.PersistJobDataAfterExecution, "Expected isPersistJobDataAfterExecution == false "); Assert.IsTrue(job.JobType.Equals(typeof(TestJob)), "Unexpected job class: " + job.JobType) ; job = JobBuilder.NewJob() .OfType <TestAnnotatedJob>() .WithIdentity("j1") .WithDescription("my description") .StoreDurably(true) .RequestRecovery() .Build(); Assert.IsTrue(job.Description.Equals("my description"), "Unexpected job description: " + job.Description); Assert.IsTrue(job.Durable, "Expected isDurable == true "); Assert.IsTrue(job.RequestsRecovery, "Expected requestsRecovery == true "); Assert.IsTrue(job.ConcurrentExectionDisallowed, "Expected isConcurrentExectionDisallowed == true "); Assert.IsTrue(job.PersistJobDataAfterExecution, "Expected isPersistJobDataAfterExecution == true "); job = JobBuilder.NewJob() .OfType <TestStatefulJob>() . WithIdentity("j1", "g1") .RequestRecovery(false) .Build(); Assert.IsTrue(job.Key.Group.Equals("g1"), "Unexpected job group: " + job.Key.Name); Assert.IsFalse(job.Durable, "Expected isDurable == false "); Assert.IsFalse(job.RequestsRecovery, "Expected requestsRecovery == false "); Assert.IsTrue(job.ConcurrentExectionDisallowed, "Expected isConcurrentExectionDisallowed == true "); Assert.IsTrue(job.PersistJobDataAfterExecution, "Expected isPersistJobDataAfterExecution == true "); }
public virtual void Run() { ILog log = LogManager.GetLogger(typeof(RemoteClientExample)); NameValueCollection properties = new NameValueCollection(); properties["quartz.scheduler.instanceName"] = "RemoteClient"; // set thread pool info properties["quartz.threadPool.type"] = "Quartz.Simpl.SimpleThreadPool, Quartz"; properties["quartz.threadPool.threadCount"] = "5"; properties["quartz.threadPool.threadPriority"] = "Normal"; // set remoting expoter properties["quartz.scheduler.proxy"] = "true"; properties["quartz.scheduler.proxy.address"] = "tcp://127.0.0.1:555/QuartzScheduler"; // First we must get a reference to a scheduler ISchedulerFactory sf = new StdSchedulerFactory(properties); IScheduler sched = sf.GetScheduler(); // define the job and ask it to run IJobDetail job = JobBuilder.NewJob <SimpleJob>() .WithIdentity("remotelyAddedJob", "default") .Build(); JobDataMap map = job.JobDataMap; map.Put("msg", "Your remotely added job has executed!"); ITrigger trigger = TriggerBuilder.Create() .WithIdentity("remotelyAddedTrigger", "default") .ForJob(job.Key) .WithSchedule(CronScheduleBuilder.CronSchedule("/5 * * ? * *")) .Build(); // schedule the job sched.ScheduleJob(job, trigger); log.Info("Remote job scheduled."); }
public void TestTriggerBuilder() { IJobDetail job = JobBuilder.NewJob() .OfType <TestJob>() .WithIdentity("j1") .StoreDurably() .Build(); ITrigger trigger = TriggerBuilder.Create() .Build(); Assert.IsTrue(trigger.Key.Name != null, "Expected non-null trigger name "); Assert.IsTrue(trigger.Key.Group.Equals(JobKey.DefaultGroup), "Unexpected trigger group: " + trigger.Key.Group); Assert.IsTrue(trigger.JobKey == null, "Unexpected job key: " + trigger.JobKey); Assert.IsTrue(trigger.Description == null, "Unexpected job description: " + trigger.Description); Assert.IsTrue(trigger.Priority == TriggerConstants.DefaultPriority, "Unexpected trigger priority: " + trigger.Priority); Assert.IsTrue(trigger.StartTimeUtc != null, "Unexpected start-time: " + trigger.StartTimeUtc); Assert.IsTrue(trigger.EndTimeUtc == null, "Unexpected end-time: " + trigger.EndTimeUtc); DateTimeOffset stime = DateBuilder.EvenSecondDateAfterNow(); trigger = TriggerBuilder.Create() .WithIdentity("t1") .WithDescription("my description") .WithPriority(2) .EndAt(DateBuilder.FutureDate(10, DateBuilder.IntervalUnit.Week)) .StartAt(stime) .Build(); Assert.IsTrue(trigger.Key.Name.Equals("t1"), "Unexpected trigger name " + trigger.Key.Name); Assert.IsTrue(trigger.Key.Group.Equals(JobKey.DefaultGroup), "Unexpected trigger group: " + trigger.Key.Group); Assert.IsTrue(trigger.JobKey == null, "Unexpected job key: " + trigger.JobKey); Assert.IsTrue(trigger.Description.Equals("my description"), "Unexpected job description: " + trigger.Description); Assert.IsTrue(trigger.Priority == 2, "Unexpected trigger priortiy: " + trigger); Assert.IsTrue(trigger.StartTimeUtc.Equals(stime), "Unexpected start-time: " + trigger.StartTimeUtc); Assert.IsTrue(trigger.EndTimeUtc != null, "Unexpected end-time: " + trigger.EndTimeUtc); }
public void ExceptionPolicyRestartImmediately() { sched.Start(); JobKey jobKey = new JobKey("ExceptionPolicyRestartJob", "ExceptionPolicyRestartGroup"); IJobDetail exceptionJob = JobBuilder.NewJob <ExceptionJob>() .WithIdentity(jobKey) .StoreDurably() .Build(); sched.AddJob(exceptionJob, false); ExceptionJob.ThrowsException = true; ExceptionJob.Refire = true; ExceptionJob.UnscheduleAllTriggers = false; ExceptionJob.UnscheduleFiringTrigger = false; ExceptionJob.LaunchCount = 0; sched.TriggerJob(jobKey); int i = 10; while ((i > 0) && (ExceptionJob.LaunchCount <= 1)) { i--; Thread.Sleep(200); if (ExceptionJob.LaunchCount > 1) { break; } } // to ensure job will not be refired in consequent tests // in fact, it would be better to have a separate class ExceptionJob.ThrowsException = false; sched.DeleteJob(jobKey); Thread.Sleep(1000); Assert.Greater(ExceptionJob.LaunchCount, 1, "The job should have been refired after exception"); }
public virtual void Run(bool inClearJobs, bool inScheduleJobs) { 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"] = "5"; properties["quartz.threadPool.threadPriority"] = "Normal"; properties["quartz.jobStore.misfireThreshold"] = "60000"; properties["quartz.jobStore.type"] = "Quartz.Impl.AdoJobStore.JobStoreTX, Quartz"; properties["quartz.jobStore.useProperties"] = "false"; properties["quartz.jobStore.dataSource"] = "default"; properties["quartz.jobStore.tablePrefix"] = "QRTZ_"; properties["quartz.jobStore.clustered"] = "true"; // if running SQLite we need this // properties["quartz.jobStore.lockHandler.type"] = "Quartz.Impl.AdoJobStore.UpdateLockRowSemaphore, Quartz"; properties["quartz.dataSource.default.connectionString"] = "Server=(local);Database=quartz;Trusted_Connection=True;"; 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(); if (inClearJobs) { log.Warn("***** Deleting existing jobs/triggers *****"); sched.Clear(); } log.Info("------- Initialization Complete -----------"); if (inScheduleJobs) { log.Info("------- Scheduling Jobs ------------------"); string schedId = sched.SchedulerInstanceId; int count = 1; IJobDetail job = JobBuilder.NewJob <SimpleRecoveryJob>() .WithIdentity("job_" + count, schedId) // put triggers in group named after the cluster node instance just to distinguish (in logging) what was scheduled from where .RequestRecovery() // ask scheduler to re-execute this job if it was in progress when the scheduler went down... .Build(); ISimpleTrigger trigger = (ISimpleTrigger)TriggerBuilder.Create() .WithIdentity("triger_" + count, schedId) .StartAt(DateBuilder.FutureDate(1, DateBuilder.IntervalUnit.Second)) .WithSchedule(SimpleScheduleBuilder.Create() .WithRepeatCount(20) .WithInterval(TimeSpan.FromSeconds(5))) .Build(); log.InfoFormat("{0} will run at: {1} and repeat: {2} times, every {3} seconds", job.Key, trigger.GetNextFireTimeUtc(), trigger.RepeatCount, trigger.RepeatInterval.TotalSeconds); count++; job = JobBuilder.NewJob <SimpleRecoveryJob>() .WithIdentity("job_" + count, schedId) // put triggers in group named after the cluster node instance just to distinguish (in logging) what was scheduled from where .RequestRecovery() // ask scheduler to re-execute this job if it was in progress when the scheduler went down... .Build(); trigger = (ISimpleTrigger)TriggerBuilder.Create() .WithIdentity("triger_" + count, schedId) .StartAt(DateBuilder.FutureDate(2, DateBuilder.IntervalUnit.Second)) .WithSchedule(SimpleScheduleBuilder.Create() .WithRepeatCount(20) .WithInterval(TimeSpan.FromSeconds(5))) .Build(); log.Info(string.Format("{0} will run at: {1} and repeat: {2} times, every {3} seconds", job.Key, trigger.GetNextFireTimeUtc(), trigger.RepeatCount, trigger.RepeatInterval.TotalSeconds)); sched.ScheduleJob(job, trigger); count++; job = JobBuilder.NewJob <SimpleRecoveryStatefulJob>() .WithIdentity("job_" + count, schedId) // put triggers in group named after the cluster node instance just to distinguish (in logging) what was scheduled from where .RequestRecovery() // ask scheduler to re-execute this job if it was in progress when the scheduler went down... .Build(); trigger = (ISimpleTrigger)TriggerBuilder.Create() .WithIdentity("triger_" + count, schedId) .StartAt(DateBuilder.FutureDate(1, DateBuilder.IntervalUnit.Second)) .WithSchedule(SimpleScheduleBuilder.Create() .WithRepeatCount(20) .WithInterval(TimeSpan.FromSeconds(3))) .Build(); log.Info(string.Format("{0} will run at: {1} and repeat: {2} times, every {3} seconds", job.Key, trigger.GetNextFireTimeUtc(), trigger.RepeatCount, trigger.RepeatInterval.TotalSeconds)); sched.ScheduleJob(job, trigger); count++; job = JobBuilder.NewJob <SimpleRecoveryJob>() .WithIdentity("job_" + count, schedId) // put triggers in group named after the cluster node instance just to distinguish (in logging) what was scheduled from where .RequestRecovery() // ask scheduler to re-execute this job if it was in progress when the scheduler went down... .Build(); trigger = (ISimpleTrigger)TriggerBuilder.Create() .WithIdentity("triger_" + count, schedId) .StartAt(DateBuilder.FutureDate(1, DateBuilder.IntervalUnit.Second)) .WithSchedule(SimpleScheduleBuilder.Create() .WithRepeatCount(20) .WithInterval(TimeSpan.FromSeconds(4))) .Build(); log.Info(string.Format("{0} will run at: {1} & repeat: {2}/{3}", job.Key, trigger.GetNextFireTimeUtc(), trigger.RepeatCount, trigger.RepeatInterval)); sched.ScheduleJob(job, trigger); count++; job = JobBuilder.NewJob <SimpleRecoveryJob>() .WithIdentity("job_" + count, schedId) // put triggers in group named after the cluster node instance just to distinguish (in logging) what was scheduled from where .RequestRecovery() // ask scheduler to re-execute this job if it was in progress when the scheduler went down... .Build(); trigger = (ISimpleTrigger)TriggerBuilder.Create() .WithIdentity("triger_" + count, schedId) .StartAt(DateBuilder.FutureDate(1, DateBuilder.IntervalUnit.Second)) .WithSchedule(SimpleScheduleBuilder.Create() .WithRepeatCount(20) .WithInterval(TimeSpan.FromMilliseconds(4500))) .Build(); log.Info(string.Format("{0} will run at: {1} & repeat: {2}/{3}", job.Key, trigger.GetNextFireTimeUtc(), trigger.RepeatCount, trigger.RepeatInterval)); sched.ScheduleJob(job, trigger); } // jobs don't start firing until start() has been called... log.Info("------- Starting Scheduler ---------------"); sched.Start(); log.Info("------- Started Scheduler ----------------"); log.Info("------- Waiting for one hour... ----------"); Thread.Sleep(TimeSpan.FromHours(1)); log.Info("------- Shutting Down --------------------"); sched.Shutdown(); log.Info("------- Shutdown Complete ----------------"); }
public virtual void Run() { ILog log = LogManager.GetLogger(typeof(CronTriggerExample)); 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 ----------------"); // jobs can be scheduled before sched.start() has been called // job 1 will run every 20 seconds IJobDetail job = JobBuilder.NewJob <SimpleJob>() .WithIdentity("job1", "group1") .Build(); ICronTrigger trigger = (ICronTrigger)TriggerBuilder.Create() .WithIdentity("trigger1", "group1") .WithSchedule(CronScheduleBuilder.CronSchedule("0/20 * * * * ?")) .Build(); DateTimeOffset ft = sched.ScheduleJob(job, trigger); log.Info(job.Key + " has been scheduled to run at: " + ft + " and repeat based on expression: " + trigger.CronExpressionString); // job 2 will run every other minute (at 15 seconds past the minute) job = JobBuilder.NewJob <SimpleJob>() .WithIdentity("job2", "group1") .Build(); trigger = (ICronTrigger)TriggerBuilder.Create() .WithIdentity("trigger2", "group1") .WithSchedule(CronScheduleBuilder.CronSchedule("15 0/2 * * * ?")) .Build(); ft = sched.ScheduleJob(job, trigger); log.Info(job.Key + " has been scheduled to run at: " + ft + " and repeat based on expression: " + trigger.CronExpressionString); // job 3 will run every other minute but only between 8am and 5pm job = JobBuilder.NewJob <SimpleJob>() .WithIdentity("job3", "group1") .Build(); trigger = (ICronTrigger)TriggerBuilder.Create() .WithIdentity("trigger3", "group1") .WithSchedule(CronScheduleBuilder.CronSchedule("0 0/2 8-17 * * ?")) .Build(); ft = sched.ScheduleJob(job, trigger); log.Info(job.Key + " has been scheduled to run at: " + ft + " and repeat based on expression: " + trigger.CronExpressionString); // job 4 will run every three minutes but only between 5pm and 11pm job = JobBuilder.NewJob <SimpleJob>() .WithIdentity("job4", "group1") .Build(); trigger = (ICronTrigger)TriggerBuilder.Create() .WithIdentity("trigger4", "group1") .WithSchedule(CronScheduleBuilder.CronSchedule("0 0/3 17-23 * * ?")) .Build(); ft = sched.ScheduleJob(job, trigger); log.Info(job.Key + " has been scheduled to run at: " + ft + " and repeat based on expression: " + trigger.CronExpressionString); // job 5 will run at 10am on the 1st and 15th days of the month job = JobBuilder.NewJob <SimpleJob>() .WithIdentity("job5", "group1") .Build(); trigger = (ICronTrigger)TriggerBuilder.Create() .WithIdentity("trigger5", "group1") .WithSchedule(CronScheduleBuilder.CronSchedule("0 0 10am 1,15 * ?")) .Build(); ft = sched.ScheduleJob(job, trigger); log.Info(job.Key + " has been scheduled to run at: " + ft + " and repeat based on expression: " + trigger.CronExpressionString); // job 6 will run every 30 seconds but only on Weekdays (Monday through Friday) job = JobBuilder.NewJob <SimpleJob>() .WithIdentity("job6", "group1") .Build(); trigger = (ICronTrigger)TriggerBuilder.Create() .WithIdentity("trigger6", "group1") .WithSchedule(CronScheduleBuilder.CronSchedule("0,30 * * ? * MON-FRI")) .Build(); ft = sched.ScheduleJob(job, trigger); log.Info(job.Key + " has been scheduled to run at: " + ft + " and repeat based on expression: " + trigger.CronExpressionString); // job 7 will run every 30 seconds but only on Weekends (Saturday and Sunday) job = JobBuilder.NewJob <SimpleJob>() .WithIdentity("job7", "group1") .Build(); trigger = (ICronTrigger)TriggerBuilder.Create() .WithIdentity("trigger7", "group1") .WithSchedule(CronScheduleBuilder.CronSchedule("0,30 * * ? * SAT,SUN")) .Build(); ft = sched.ScheduleJob(job, trigger); log.Info(job.Key + " has been scheduled to run at: " + ft + " and repeat based on expression: " + trigger.CronExpressionString); log.Info("------- Starting Scheduler ----------------"); // All of the jobs have been added to the scheduler, but none of the // jobs // will run until the scheduler has been started sched.Start(); log.Info("------- Started Scheduler -----------------"); log.Info("------- Waiting five minutes... ------------"); try { // wait five minutes to show jobs Thread.Sleep(300 * 1000); // executing... } catch (ThreadInterruptedException) { } log.Info("------- Shutting Down ---------------------"); sched.Shutdown(true); log.Info("------- Shutdown Complete -----------------"); SchedulerMetaData metaData = sched.GetMetaData(); log.Info(string.Format("Executed {0} jobs.", metaData.NumberOfJobsExecuted)); }
protected virtual void ProcessInternal(string xml) { PrepForProcessing(); ValidateXml(xml); MaybeThrowValidationException(); // deserialize as object model XmlSerializer xs = new XmlSerializer(typeof(QuartzXmlConfiguration20)); QuartzXmlConfiguration20 data = (QuartzXmlConfiguration20)xs.Deserialize(new StringReader(xml)); if (data == null) { throw new SchedulerConfigException("Job definition data from XML was null after deserialization"); } // // Extract pre-processing commands // if (data.preprocessingcommands != null) { foreach (preprocessingcommandsType command in data.preprocessingcommands) { if (command.deletejobsingroup != null) { foreach (string s in command.deletejobsingroup) { string deleteJobGroup = s.NullSafeTrim(); if (!String.IsNullOrEmpty(deleteJobGroup)) { jobGroupsToDelete.Add(deleteJobGroup); } } } if (command.deletetriggersingroup != null) { foreach (string s in command.deletetriggersingroup) { string deleteTriggerGroup = s.NullSafeTrim(); if (!String.IsNullOrEmpty(deleteTriggerGroup)) { triggerGroupsToDelete.Add(deleteTriggerGroup); } } } if (command.deletejob != null) { foreach (preprocessingcommandsTypeDeletejob s in command.deletejob) { string name = s.name.TrimEmptyToNull(); string group = s.group.TrimEmptyToNull(); if (name == null) { throw new SchedulerConfigException("Encountered a 'delete-job' command without a name specified."); } jobsToDelete.Add(new JobKey(name, group)); } } if (command.deletetrigger != null) { foreach (preprocessingcommandsTypeDeletetrigger s in command.deletetrigger) { string name = s.name.TrimEmptyToNull(); string group = s.group.TrimEmptyToNull(); if (name == null) { throw new SchedulerConfigException("Encountered a 'delete-trigger' command without a name specified."); } triggersToDelete.Add(new TriggerKey(name, group)); } } } } log.Debug("Found " + jobGroupsToDelete.Count + " delete job group commands."); log.Debug("Found " + triggerGroupsToDelete.Count + " delete trigger group commands."); log.Debug("Found " + jobsToDelete.Count + " delete job commands."); log.Debug("Found " + triggersToDelete.Count + " delete trigger commands."); // // Extract directives // if (data.processingdirectives != null && data.processingdirectives.Length > 0) { bool overWrite = data.processingdirectives[0].overwriteexistingdata; log.Debug("Directive 'overwrite-existing-data' specified as: " + overWrite); OverWriteExistingData = overWrite; } else { log.Debug("Directive 'ignore-duplicates' not specified, defaulting to " + OverWriteExistingData); } if (data.processingdirectives != null && data.processingdirectives.Length > 0) { bool ignoreduplicates = data.processingdirectives[0].ignoreduplicates; log.Debug("Directive 'ignore-duplicates' specified as: " + ignoreduplicates); IgnoreDuplicates = ignoreduplicates; } else { log.Debug("Directive 'overwrite-existing-data' not specified, defaulting to " + IgnoreDuplicates); } // // Extract Job definitions... // List <jobdetailType> jobNodes = new List <jobdetailType>(); if (data.schedule != null && data.schedule.Length > 0 && data.schedule[0].job != null) { jobNodes.AddRange(data.schedule[0].job); } log.Debug("Found " + jobNodes.Count + " job definitions."); foreach (jobdetailType jobDetailType in jobNodes) { string jobName = jobDetailType.name.TrimEmptyToNull(); string jobGroup = jobDetailType.group.TrimEmptyToNull(); string jobDescription = jobDetailType.description.TrimEmptyToNull(); string jobTypeName = jobDetailType.jobtype.TrimEmptyToNull(); bool jobDurability = jobDetailType.durable; bool jobRecoveryRequested = jobDetailType.recover; Type jobType = typeLoadHelper.LoadType(jobTypeName); IJobDetail jobDetail = JobBuilder.NewJob(jobType) .WithIdentity(jobName, jobGroup) .WithDescription(jobDescription) .StoreDurably(jobDurability) .RequestRecovery(jobRecoveryRequested) .Build(); if (jobDetailType.jobdatamap != null && jobDetailType.jobdatamap.entry != null) { foreach (entryType entry in jobDetailType.jobdatamap.entry) { string key = entry.key.TrimEmptyToNull(); string value = entry.value.TrimEmptyToNull(); jobDetail.JobDataMap.Add(key, value); } } if (log.IsDebugEnabled) { log.Debug("Parsed job definition: " + jobDetail); } AddJobToSchedule(jobDetail); } // // Extract Trigger definitions... // List <triggerType> triggerEntries = new List <triggerType>(); if (data.schedule != null && data.schedule.Length > 0 && data.schedule[0].trigger != null) { triggerEntries.AddRange(data.schedule[0].trigger); } log.Debug("Found " + triggerEntries.Count + " trigger definitions."); foreach (triggerType triggerNode in triggerEntries) { string triggerName = triggerNode.Item.name.TrimEmptyToNull(); string triggerGroup = triggerNode.Item.group.TrimEmptyToNull(); string triggerDescription = triggerNode.Item.description.TrimEmptyToNull(); string triggerMisfireInstructionConst; string triggerCalendarRef = triggerNode.Item.calendarname.TrimEmptyToNull(); string triggerJobName = triggerNode.Item.jobname.TrimEmptyToNull(); string triggerJobGroup = triggerNode.Item.jobgroup.TrimEmptyToNull(); int triggerPriority = TriggerConstants.DefaultPriority; if (!triggerNode.Item.priority.IsNullOrWhiteSpace()) { triggerPriority = Convert.ToInt32(triggerNode.Item.priority); } DateTimeOffset triggerStartTime = SystemTime.UtcNow(); if (triggerNode.Item.Item != null) { if (triggerNode.Item.Item is DateTime) { triggerStartTime = new DateTimeOffset((DateTime)triggerNode.Item.Item); } else { triggerStartTime = triggerStartTime.AddSeconds(Convert.ToInt32(triggerNode.Item.Item)); } } DateTime?triggerEndTime = triggerNode.Item.endtimeSpecified ? triggerNode.Item.endtime : (DateTime?)null; TriggerKey triggerKey = new TriggerKey(triggerName, triggerGroup); IScheduleBuilder sched = null; if (triggerNode.Item is simpleTriggerType) { simpleTriggerType simpleTrigger = (simpleTriggerType)triggerNode.Item; triggerMisfireInstructionConst = simpleTrigger.misfireinstruction; string repeatCountString = simpleTrigger.repeatcount.TrimEmptyToNull(); string repeatIntervalString = simpleTrigger.repeatinterval.TrimEmptyToNull(); int repeatCount = ParseSimpleTriggerRepeatCount(repeatCountString); TimeSpan repeatInterval = repeatIntervalString == null ? TimeSpan.Zero : TimeSpan.FromMilliseconds(Convert.ToInt64(repeatIntervalString)); sched = SimpleScheduleBuilder.Create() .WithInterval(repeatInterval) .WithRepeatCount(repeatCount); if (!simpleTrigger.misfireinstruction.IsNullOrWhiteSpace()) { ((SimpleScheduleBuilder)sched).WithMisfireHandlingInstruction(ReadMisfireInstructionFromString(simpleTrigger.misfireinstruction)); } } else if (triggerNode.Item is cronTriggerType) { cronTriggerType cronTrigger = (cronTriggerType)triggerNode.Item; triggerMisfireInstructionConst = cronTrigger.misfireinstruction; string cronExpression = cronTrigger.cronexpression.TrimEmptyToNull(); string timezoneString = cronTrigger.timezone.TrimEmptyToNull(); TimeZoneInfo tz = timezoneString != null?TimeZoneInfo.FindSystemTimeZoneById(timezoneString) : null; sched = CronScheduleBuilder.CronSchedule(cronExpression) .InTimeZone(tz); if (!cronTrigger.misfireinstruction.IsNullOrWhiteSpace()) { ((CronScheduleBuilder)sched).WithMisfireHandlingInstruction(ReadMisfireInstructionFromString(cronTrigger.misfireinstruction)); } } else if (triggerNode.Item is calendarIntervalTriggerType) { calendarIntervalTriggerType calendarIntervalTrigger = (calendarIntervalTriggerType)triggerNode.Item; string repeatIntervalString = calendarIntervalTrigger.repeatinterval.TrimEmptyToNull(); triggerMisfireInstructionConst = calendarIntervalTrigger.misfireinstruction; IntervalUnit intervalUnit = ParseDateIntervalTriggerIntervalUnit(calendarIntervalTrigger.repeatintervalunit.TrimEmptyToNull()); int repeatInterval = repeatIntervalString == null ? 0 : Convert.ToInt32(repeatIntervalString); sched = CalendarIntervalScheduleBuilder.Create() .WithInterval(repeatInterval, intervalUnit); if (!calendarIntervalTrigger.misfireinstruction.IsNullOrWhiteSpace()) { ((CalendarIntervalScheduleBuilder)sched).WithMisfireHandlingInstruction(ReadMisfireInstructionFromString(calendarIntervalTrigger.misfireinstruction)); } } else { throw new SchedulerConfigException("Unknown trigger type in XML configuration"); } IMutableTrigger trigger = (IMutableTrigger)TriggerBuilder.Create() .WithIdentity(triggerName, triggerGroup) .WithDescription(triggerDescription) .ForJob(triggerJobName, triggerJobGroup) .StartAt(triggerStartTime) .EndAt(triggerEndTime) .WithPriority(triggerPriority) .ModifiedByCalendar(triggerCalendarRef) .WithSchedule(sched) .Build(); if (triggerNode.Item.jobdatamap != null && triggerNode.Item.jobdatamap.entry != null) { foreach (entryType entry in triggerNode.Item.jobdatamap.entry) { string key = entry.key.TrimEmptyToNull(); string value = entry.value.TrimEmptyToNull(); trigger.JobDataMap.Add(key, value); } } if (log.IsDebugEnabled) { log.Debug("Parsed trigger definition: " + trigger); } AddTriggerToSchedule(trigger); } }
public virtual void Run() { ILog log = LogManager.GetLogger(typeof(MisfireExample)); 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 -----------"); // jobs can be scheduled before start() has been called // get a "nice round" time a few seconds in the future... DateTimeOffset startTime = DateBuilder.NextGivenSecondDate(null, 15); // statefulJob1 will run every three seconds // (but it will delay for ten seconds) IJobDetail job = JobBuilder.NewJob <StatefulDumbJob>() .WithIdentity("statefulJob1", "group1") .UsingJobData(StatefulDumbJob.ExecutionDelay, 10000L) .Build(); ISimpleTrigger trigger = (ISimpleTrigger)TriggerBuilder.Create() .WithIdentity("trigger1", "group1") .StartAt(startTime) .WithSchedule(SimpleScheduleBuilder.Create() .WithIntervalInSeconds(3) .RepeatForever()) .Build(); DateTimeOffset ft = sched.ScheduleJob(job, trigger); log.Info(string.Format("{0} will run at: {1} and repeat: {2} times, every {3} seconds", job.Key, ft.ToString("r"), trigger.RepeatCount, trigger.RepeatInterval.TotalSeconds)); // statefulJob2 will run every three seconds // (but it will delay for ten seconds - and therefore purposely misfire after a few iterations) job = JobBuilder.NewJob <StatefulDumbJob>() .WithIdentity("statefulJob2", "group1") .UsingJobData(StatefulDumbJob.ExecutionDelay, 10000L) .Build(); trigger = (ISimpleTrigger)TriggerBuilder.Create() .WithIdentity("trigger2", "group1") .StartAt(startTime) .WithSchedule(SimpleScheduleBuilder.Create() .WithIntervalInSeconds(3) .RepeatForever() .WithMisfireHandlingInstructionNowWithExistingCount()) // set misfire instructions .Build(); ft = sched.ScheduleJob(job, trigger); log.Info(string.Format("{0} will run at: {1} and repeat: {2} times, every {3} seconds", job.Key, ft.ToString("r"), trigger.RepeatCount, trigger.RepeatInterval.TotalSeconds)); log.Info("------- Starting Scheduler ----------------"); // jobs don't start firing until start() has been called... sched.Start(); log.Info("------- Started Scheduler -----------------"); try { // sleep for ten minutes for triggers to file.... Thread.Sleep(TimeSpan.FromMinutes(10)); } catch (ThreadInterruptedException) { } 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 void Run() { ILog log = LogManager.GetLogger(typeof(PriorityExample)); log.Info("------- Initializing ----------------------"); // First we must get a reference to a scheduler NameValueCollection properties = new NameValueCollection(); properties["quartz.scheduler.instanceName"] = "PriorityExampleScheduler"; // Set thread count to 1 to force Triggers scheduled for the same time to // to be ordered by priority. properties["quartz.threadPool.threadCount"] = "1"; properties["quartz.threadPool.type"] = "Quartz.Simpl.SimpleThreadPool, Quartz"; properties["quartz.jobStore.type"] = "Quartz.Simpl.RAMJobStore, Quartz"; ISchedulerFactory sf = new StdSchedulerFactory(properties); IScheduler sched = sf.GetScheduler(); log.Info("------- Initialization Complete -----------"); log.Info("------- Scheduling Jobs -------------------"); IJobDetail job = JobBuilder.NewJob <TriggerEchoJob>() .WithIdentity("TriggerEchoJob") .Build(); // All three triggers will fire their first time at the same time, // ordered by their priority, and then repeat once, firing in a // staggered order that therefore ignores priority. // // We should see the following firing order: // 1. Priority10Trigger15SecondRepeat // 2. Priority5Trigger10SecondRepeat // 3. PriorityNeg5Trigger5SecondRepeat // 4. PriorityNeg5Trigger5SecondRepeat // 5. Priority5Trigger10SecondRepeat // 6. Priority10Trigger15SecondRepeat // Calculate the start time of all triggers as 5 seconds from now DateTimeOffset startTime = DateBuilder.FutureDate(5, DateBuilder.IntervalUnit.Second); // First trigger has priority of 1, and will repeat after 5 seconds ITrigger trigger1 = TriggerBuilder.Create() .WithIdentity("PriorityNeg5Trigger5SecondRepeat") .StartAt(startTime) .WithSchedule(SimpleScheduleBuilder.Create().WithRepeatCount(1).WithIntervalInSeconds(5)) .WithPriority(1) .ForJob(job) .Build(); // Second trigger has default priority of 5 (default), and will repeat after 10 seconds ITrigger trigger2 = TriggerBuilder.Create() .WithIdentity("Priority5Trigger10SecondRepeat") .StartAt(startTime) .WithSchedule(SimpleScheduleBuilder.Create().WithRepeatCount(1).WithIntervalInSeconds(10)) .ForJob(job) .Build(); // Third trigger has priority 10, and will repeat after 15 seconds ITrigger trigger3 = TriggerBuilder.Create() .WithIdentity("Priority10Trigger15SecondRepeat") .StartAt(startTime) .WithSchedule(SimpleScheduleBuilder.Create().WithRepeatCount(1).WithIntervalInSeconds(15)) .WithPriority(10) .ForJob(job) .Build(); // Tell quartz to schedule the job using our trigger sched.ScheduleJob(job, trigger1); sched.ScheduleJob(trigger2); sched.ScheduleJob(trigger3); // Start up the scheduler (nothing can actually run until the // scheduler has been started) sched.Start(); log.Info("------- Started Scheduler -----------------"); // wait long enough so that the scheduler as an opportunity to // fire the triggers log.Info("------- Waiting 30 seconds... -------------"); try { Thread.Sleep(TimeSpan.FromSeconds(30)); } catch (ThreadInterruptedException) { } // shut down the scheduler log.Info("------- Shutting Down ---------------------"); sched.Shutdown(true); log.Info("------- Shutdown Complete -----------------"); }
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 virtual void Run() { ILog log = LogManager.GetLogger(typeof(JobStateExample)); 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 ----------------"); // get a "nice round" time a few seconds in the future.... DateTimeOffset startTime = DateBuilder.NextGivenSecondDate(null, 10); // job1 will only run 5 times (at start time, plus 4 repeats), every 10 seconds IJobDetail job1 = JobBuilder.NewJob <ColorJob>() .WithIdentity("job1", "group1") .Build(); ISimpleTrigger trigger1 = (ISimpleTrigger)TriggerBuilder.Create() .WithIdentity("trigger1", "group1") .StartAt(startTime) .WithSchedule(SimpleScheduleBuilder.Create() .WithIntervalInSeconds(10) .WithRepeatCount(4)) .Build(); // pass initialization parameters into the job job1.JobDataMap.Put(ColorJob.FavoriteColor, "Green"); job1.JobDataMap.Put(ColorJob.ExecutionCount, 1); // schedule the job to run DateTimeOffset scheduleTime1 = sched.ScheduleJob(job1, trigger1); log.Info(string.Format("{0} will run at: {1} and repeat: {2} times, every {3} seconds", job1.Key, scheduleTime1.ToString("r"), trigger1.RepeatCount, trigger1.RepeatInterval.TotalSeconds)); // job2 will also run 5 times, every 10 seconds IJobDetail job2 = JobBuilder.NewJob <ColorJob>() .WithIdentity("job2", "group1") .Build(); ISimpleTrigger trigger2 = (ISimpleTrigger)TriggerBuilder.Create() .WithIdentity("trigger2", "group1") .StartAt(startTime) .WithSchedule(SimpleScheduleBuilder.Create() .WithIntervalInSeconds(10) .WithRepeatCount(4)) .Build(); // pass initialization parameters into the job // this job has a different favorite color! job2.JobDataMap.Put(ColorJob.FavoriteColor, "Red"); job2.JobDataMap.Put(ColorJob.ExecutionCount, 1); // schedule the job to run DateTimeOffset scheduleTime2 = sched.ScheduleJob(job2, trigger2); log.Info(string.Format("{0} will run at: {1} and repeat: {2} times, every {3} seconds", job2.Key, scheduleTime2.ToString("r"), trigger2.RepeatCount, trigger2.RepeatInterval.TotalSeconds)); log.Info("------- Starting Scheduler ----------------"); // All of the jobs have been added to the scheduler, but none of the jobs // will run until the scheduler has been started sched.Start(); log.Info("------- Started Scheduler -----------------"); log.Info("------- Waiting 60 seconds... -------------"); try { // wait five minutes to show jobs Thread.Sleep(300 * 1000); // executing... } catch (ThreadInterruptedException) { } 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 virtual void Run() { 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 -------------------"); // get a "nice round" time a few seconds in the future... DateTimeOffset startTime = DateBuilder.NextGivenSecondDate(null, 15); IJobDetail job = JobBuilder.NewJob <DumbInterruptableJob>() .WithIdentity("interruptableJob1", "group1") .Build(); ISimpleTrigger trigger = (ISimpleTrigger)TriggerBuilder.Create() .WithIdentity("trigger1", "group1") .StartAt(startTime) .WithSchedule(SimpleScheduleBuilder.Create() .WithIntervalInSeconds(5) .RepeatForever()) .Build(); DateTimeOffset ft = sched.ScheduleJob(job, trigger); log.Info(string.Format("{0} will run at: {1} and repeat: {2} times, every {3} seconds", job.Key, ft.ToString("r"), trigger.RepeatCount, trigger.RepeatInterval.TotalSeconds)); // start up the scheduler (jobs do not start to fire until // the scheduler has been started) sched.Start(); log.Info("------- Started Scheduler -----------------"); log.Info("------- Starting loop to interrupt job every 7 seconds ----------"); for (int i = 0; i < 50; i++) { try { Thread.Sleep(TimeSpan.FromSeconds(7)); // tell the scheduler to interrupt our job sched.Interrupt(job.Key); } catch (Exception ex) { Console.WriteLine(ex); } } 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 virtual void Run() { ILog log = LogManager.GetLogger(typeof(JobExceptionExample)); 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 -------------------"); // jobs can be scheduled before start() has been called // get a "nice round" time a few seconds in the future... DateTimeOffset startTime = DateBuilder.NextGivenSecondDate(null, 15); // badJob1 will run every three seconds // this job will throw an exception and refire // immediately IJobDetail job = JobBuilder.NewJob <BadJob1>() .WithIdentity("badJob1", "group1") .Build(); ISimpleTrigger trigger = (ISimpleTrigger)TriggerBuilder.Create() .WithIdentity("trigger1", "group1") .StartAt(startTime) .WithSchedule(SimpleScheduleBuilder.Create() .WithIntervalInSeconds(3) .RepeatForever()) .Build(); DateTimeOffset ft = sched.ScheduleJob(job, trigger); log.Info(job.Key + " will run at: " + ft + " and repeat: " + trigger.RepeatCount + " times, every " + trigger.RepeatInterval.TotalSeconds + " seconds"); // badJob2 will run every three seconds // this job will throw an exception and never // refire job = JobBuilder.NewJob <BadJob2>() .WithIdentity("badJob2", "group1") .Build(); trigger = (ISimpleTrigger)TriggerBuilder.Create() .WithIdentity("trigger2", "group1") .StartAt(startTime) .WithSchedule(SimpleScheduleBuilder.Create() .WithIntervalInSeconds(3) .RepeatForever()) .Build(); ft = sched.ScheduleJob(job, trigger); log.Info(string.Format("{0} will run at: {1} and repeat: {2} times, every {3} seconds", job.Key, ft.ToString("r"), trigger.RepeatCount, trigger.RepeatInterval.TotalSeconds)); log.Info("------- Starting Scheduler ----------------"); // jobs don't start firing until start() has been called... sched.Start(); log.Info("------- Started Scheduler -----------------"); // sleep for 60 seconds try { Thread.Sleep(TimeSpan.FromSeconds(60)); } catch (ThreadInterruptedException) { } 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 virtual void Run() { ILog log = LogManager.GetLogger(typeof(SimpleTriggerExample)); 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 ----------------"); // jobs can be scheduled before sched.start() has been called // get a "nice round" time a few seconds in the future... DateTimeOffset startTime = DateBuilder.NextGivenSecondDate(null, 15); // job1 will only fire once at date/time "ts" IJobDetail job = JobBuilder.NewJob <SimpleJob>() .WithIdentity("job1", "group1") .Build(); ISimpleTrigger trigger = (ISimpleTrigger)TriggerBuilder.Create() .WithIdentity("trigger1", "group1") .StartAt(startTime) .Build(); // schedule it to run! DateTimeOffset?ft = sched.ScheduleJob(job, trigger); log.Info(job.Key + " will run at: " + ft + " and repeat: " + trigger.RepeatCount + " times, every " + trigger.RepeatInterval.TotalSeconds + " seconds"); // job2 will only fire once at date/time "ts" job = JobBuilder.NewJob <SimpleJob>() .WithIdentity("job2", "group1") .Build(); trigger = (ISimpleTrigger)TriggerBuilder.Create() .WithIdentity("trigger2", "group1") .StartAt(startTime) .Build(); ft = sched.ScheduleJob(job, trigger); log.Info(job.Key + " will run at: " + ft + " and repeat: " + trigger.RepeatCount + " times, every " + trigger.RepeatInterval.TotalSeconds + " seconds"); // job3 will run 11 times (run once and repeat 10 more times) // job3 will repeat every 10 seconds job = JobBuilder.NewJob <SimpleJob>() .WithIdentity("job3", "group1") .Build(); trigger = (ISimpleTrigger)TriggerBuilder.Create() .WithIdentity("trigger3", "group1") .StartAt(startTime) .WithSchedule(SimpleScheduleBuilder.Create() .WithIntervalInSeconds(10) .WithRepeatCount(10)) .Build(); ft = sched.ScheduleJob(job, trigger); log.Info(job.Key + " will run at: " + ft + " and repeat: " + trigger.RepeatCount + " times, every " + trigger.RepeatInterval.TotalSeconds + " seconds"); // the same job (job3) will be scheduled by a another trigger // this time will only repeat twice at a 70 second interval trigger = (ISimpleTrigger)TriggerBuilder.Create() .WithIdentity("trigger3", "group2") .StartAt(startTime) .WithSchedule(SimpleScheduleBuilder.Create() .WithIntervalInSeconds(10) .WithRepeatCount(2)) .ForJob(job) .Build(); ft = sched.ScheduleJob(trigger); log.Info(job.Key + " will [also] run at: " + ft + " and repeat: " + trigger.RepeatCount + " times, every " + trigger.RepeatInterval.TotalSeconds + " seconds"); // job4 will run 6 times (run once and repeat 5 more times) // job4 will repeat every 10 seconds job = JobBuilder.NewJob <SimpleJob>() .WithIdentity("job4", "group1") .Build(); trigger = (ISimpleTrigger)TriggerBuilder.Create() .WithIdentity("trigger4", "group1") .StartAt(startTime) .WithSchedule(SimpleScheduleBuilder.Create() .WithIntervalInSeconds(10) .WithRepeatCount(5)) .Build(); ft = sched.ScheduleJob(job, trigger); log.Info(job.Key + " will run at: " + ft + " and repeat: " + trigger.RepeatCount + " times, every " + trigger.RepeatInterval.TotalSeconds + " seconds"); // job5 will run once, five minutes in the future job = JobBuilder.NewJob <SimpleJob>() .WithIdentity("job5", "group1") .Build(); trigger = (ISimpleTrigger)TriggerBuilder.Create() .WithIdentity("trigger5", "group1") .StartAt(DateBuilder.FutureDate(5, DateBuilder.IntervalUnit.Minute)) .Build(); ft = sched.ScheduleJob(job, trigger); log.Info(job.Key + " will run at: " + ft + " and repeat: " + trigger.RepeatCount + " times, every " + trigger.RepeatInterval.TotalSeconds + " seconds"); // job6 will run indefinitely, every 40 seconds job = JobBuilder.NewJob <SimpleJob>() .WithIdentity("job6", "group1") .Build(); trigger = (ISimpleTrigger)TriggerBuilder.Create() .WithIdentity("trigger6", "group1") .StartAt(startTime) .WithSchedule(SimpleScheduleBuilder.Create() .WithIntervalInSeconds(40) .RepeatForever()) .Build(); ft = sched.ScheduleJob(job, trigger); log.Info(job.Key + " will run at: " + ft + " and repeat: " + trigger.RepeatCount + " times, every " + trigger.RepeatInterval.TotalSeconds + " seconds"); log.Info("------- Starting Scheduler ----------------"); // All of the jobs have been added to the scheduler, but none of the jobs // will run until the scheduler has been started sched.Start(); log.Info("------- Started Scheduler -----------------"); // jobs can also be scheduled after start() has been called... // job7 will repeat 20 times, repeat every five minutes job = JobBuilder.NewJob <SimpleJob>() .WithIdentity("job7", "group1") .Build(); trigger = (ISimpleTrigger)TriggerBuilder.Create() .WithIdentity("trigger7", "group1") .StartAt(startTime) .WithSchedule(SimpleScheduleBuilder.Create() .WithIntervalInMinutes(5) .WithRepeatCount(20)) .Build(); ft = sched.ScheduleJob(job, trigger); log.Info(job.Key + " will run at: " + ft + " and repeat: " + trigger.RepeatCount + " times, every " + trigger.RepeatInterval.TotalSeconds + " seconds"); // jobs can be fired directly... (rather than waiting for a trigger) job = JobBuilder.NewJob <SimpleJob>() .WithIdentity("job8", "group1") .StoreDurably() .Build(); sched.AddJob(job, true); log.Info("'Manually' triggering job8..."); sched.TriggerJob(new JobKey("job8", "group1")); log.Info("------- Waiting 30 seconds... --------------"); try { // wait 30 seconds to show jobs Thread.Sleep(TimeSpan.FromSeconds(30)); // executing... } catch (ThreadInterruptedException) { } // jobs can be re-scheduled... // job 7 will run immediately and repeat 10 times for every second log.Info("------- Rescheduling... --------------------"); trigger = (ISimpleTrigger)TriggerBuilder.Create() .WithIdentity("trigger7", "group1") .StartAt(startTime) .WithSchedule(SimpleScheduleBuilder.Create() .WithIntervalInMinutes(5) .WithRepeatCount(20)) .Build(); ft = sched.RescheduleJob(trigger.Key, trigger); log.Info("job7 rescheduled to run at: " + ft); log.Info("------- Waiting five minutes... ------------"); try { // wait five minutes to show jobs Thread.Sleep(TimeSpan.FromMinutes(5)); // executing... } catch (ThreadInterruptedException) { } log.Info("------- Shutting Down ---------------------"); sched.Shutdown(true); log.Info("------- Shutdown Complete -----------------"); // display some stats about the schedule that just ran SchedulerMetaData metaData = sched.GetMetaData(); log.Info(string.Format("Executed {0} jobs.", metaData.NumberOfJobsExecuted)); }
public virtual void Run() { ILog log = LogManager.GetLogger(typeof(ListenerExample)); 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 -------------------"); // schedule a job to run immediately IJobDetail job = JobBuilder.NewJob <SimpleJob1>() .WithIdentity("job1") .Build(); ITrigger trigger = TriggerBuilder.Create() .WithIdentity("trigger1") .StartNow() .Build(); // Set up the listener IJobListener listener = new Job1Listener(); IMatcher <JobKey> matcher = KeyMatcher <JobKey> .KeyEquals(job.Key); sched.ListenerManager.AddJobListener(listener, matcher); // schedule the job to run sched.ScheduleJob(job, trigger); // 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(TimeSpan.FromSeconds(30)); // 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 void TestBasicStorageFunctions() { NameValueCollection config = new NameValueCollection(); config["quartz.threadPool.threadCount"] = "2"; config["quartz.threadPool.type"] = "Quartz.Simpl.SimpleThreadPool, Quartz"; IScheduler sched = new StdSchedulerFactory(config).GetScheduler(); // test basic storage functions of scheduler... IJobDetail job = JobBuilder.NewJob() .OfType <TestJob>() .WithIdentity("j1") .StoreDurably() .Build(); Assert.IsFalse(sched.CheckExists(new JobKey("j1")), "Unexpected existence of job named 'j1'."); sched.AddJob(job, false); Assert.IsTrue(sched.CheckExists(new JobKey("j1")), "Expected existence of job named 'j1' but checkExists return false."); job = sched.GetJobDetail(new JobKey("j1")); Assert.IsNotNull(job, "Stored job not found!"); sched.DeleteJob(new JobKey("j1")); ITrigger trigger = TriggerBuilder.Create() .WithIdentity("t1") .ForJob(job) .StartNow() .WithSchedule(SimpleScheduleBuilder.Create() .RepeatForever() .WithIntervalInSeconds(5)) .Build(); Assert.IsFalse(sched.CheckExists(new TriggerKey("t1")), "Unexpected existence of trigger named '11'."); sched.ScheduleJob(job, trigger); Assert.IsTrue(sched.CheckExists(new TriggerKey("t1")), "Expected existence of trigger named 't1' but checkExists return false."); job = sched.GetJobDetail(new JobKey("j1")); Assert.IsNotNull(job, "Stored job not found!"); trigger = sched.GetTrigger(new TriggerKey("t1")); Assert.IsNotNull(trigger, "Stored trigger not found!"); job = JobBuilder.NewJob() .OfType <TestJob>() .WithIdentity("j2", "g1") .Build(); trigger = TriggerBuilder.Create() .WithIdentity("t2", "g1") .ForJob(job) .StartNow() .WithSchedule(SimpleScheduleBuilder.Create() .RepeatForever() .WithIntervalInSeconds(5)) .Build(); sched.ScheduleJob(job, trigger); job = JobBuilder.NewJob() .OfType <TestJob>() .WithIdentity("j3", "g1") .Build(); trigger = TriggerBuilder.Create() .WithIdentity("t3", "g1") .ForJob(job) .StartNow() .WithSchedule(SimpleScheduleBuilder.Create() .RepeatForever() .WithIntervalInSeconds(5)) .Build(); sched.ScheduleJob(job, trigger); IList <string> jobGroups = sched.GetJobGroupNames(); IList <string> triggerGroups = sched.GetTriggerGroupNames(); Assert.AreEqual(2, jobGroups.Count, "Job group list size expected to be = 2 "); Assert.AreEqual(2, triggerGroups.Count, "Trigger group list size expected to be = 2 "); Collection.ISet <JobKey> jobKeys = sched.GetJobKeys(GroupMatcher <JobKey> .GroupEquals(JobKey.DefaultGroup)); Collection.ISet <TriggerKey> triggerKeys = sched.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals(TriggerKey.DefaultGroup)); Assert.AreEqual(1, jobKeys.Count, "Number of jobs expected in default group was 1 "); Assert.AreEqual(1, triggerKeys.Count, "Number of triggers expected in default group was 1 "); jobKeys = sched.GetJobKeys(GroupMatcher <JobKey> .GroupEquals("g1")); triggerKeys = sched.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals("g1")); Assert.AreEqual(2, jobKeys.Count, "Number of jobs expected in 'g1' group was 2 "); Assert.AreEqual(2, triggerKeys.Count, "Number of triggers expected in 'g1' group was 2 "); TriggerState s = sched.GetTriggerState(new TriggerKey("t2", "g1")); Assert.AreEqual(TriggerState.Normal, s, "State of trigger t2 expected to be NORMAL "); sched.PauseTrigger(new TriggerKey("t2", "g1")); s = sched.GetTriggerState(new TriggerKey("t2", "g1")); Assert.AreEqual(TriggerState.Paused, s, "State of trigger t2 expected to be PAUSED "); sched.ResumeTrigger(new TriggerKey("t2", "g1")); s = sched.GetTriggerState(new TriggerKey("t2", "g1")); Assert.AreEqual(TriggerState.Normal, s, "State of trigger t2 expected to be NORMAL "); Collection.ISet <string> pausedGroups = sched.GetPausedTriggerGroups(); Assert.AreEqual(0, pausedGroups.Count, "Size of paused trigger groups list expected to be 0 "); sched.PauseTriggers(GroupMatcher <TriggerKey> .GroupEquals("g1")); // test that adding a trigger to a paused group causes the new trigger to be paused also... job = JobBuilder.NewJob() .OfType <TestJob>() .WithIdentity("j4", "g1") .Build(); trigger = TriggerBuilder.Create() .WithIdentity("t4", "g1") .ForJob(job) .StartNow() .WithSchedule(SimpleScheduleBuilder.Create() .RepeatForever() .WithIntervalInSeconds(5)) .Build(); sched.ScheduleJob(job, trigger); pausedGroups = sched.GetPausedTriggerGroups(); Assert.AreEqual(1, pausedGroups.Count, "Size of paused trigger groups list expected to be 1 "); s = sched.GetTriggerState(new TriggerKey("t2", "g1")); Assert.AreEqual(TriggerState.Paused, s, "State of trigger t2 expected to be PAUSED "); s = sched.GetTriggerState(new TriggerKey("t4", "g1")); Assert.AreEqual(TriggerState.Paused, s, "State of trigger t4 expected to be PAUSED"); sched.ResumeTriggers(GroupMatcher <TriggerKey> .GroupEquals("g1")); s = sched.GetTriggerState(new TriggerKey("t2", "g1")); Assert.AreEqual(TriggerState.Normal, s, "State of trigger t2 expected to be NORMAL "); s = sched.GetTriggerState(new TriggerKey("t4", "g1")); Assert.AreEqual(TriggerState.Normal, s, "State of trigger t2 expected to be NORMAL "); pausedGroups = sched.GetPausedTriggerGroups(); Assert.AreEqual(0, pausedGroups.Count, "Size of paused trigger groups list expected to be 0 "); Assert.IsFalse(sched.UnscheduleJob(new TriggerKey("foasldfksajdflk")), "Scheduler should have returned 'false' from attempt to unschedule non-existing trigger. "); Assert.IsTrue(sched.UnscheduleJob(new TriggerKey("t3", "g1")), "Scheduler should have returned 'true' from attempt to unschedule existing trigger. "); jobKeys = sched.GetJobKeys(GroupMatcher <JobKey> .GroupEquals("g1")); triggerKeys = sched.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals("g1")); Assert.AreEqual(2, jobKeys.Count, "Number of jobs expected in 'g1' group was 1 "); // job should have been deleted also, because it is non-durable Assert.AreEqual(2, triggerKeys.Count, "Number of triggers expected in 'g1' group was 1 "); Assert.IsTrue(sched.UnscheduleJob(new TriggerKey("t1")), "Scheduler should have returned 'true' from attempt to unschedule existing trigger. "); jobKeys = sched.GetJobKeys(GroupMatcher <JobKey> .GroupEquals(JobKey.DefaultGroup)); triggerKeys = sched.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals(TriggerKey.DefaultGroup)); Assert.AreEqual(1, jobKeys.Count, "Number of jobs expected in default group was 1 "); // job should have been left in place, because it is non-durable Assert.AreEqual(0, triggerKeys.Count, "Number of triggers expected in default group was 0 "); }
public virtual void Run() { ILog log = LogManager.GetLogger(typeof(LoadExample)); // First we must get a reference to a scheduler ISchedulerFactory sf = new StdSchedulerFactory(); IScheduler sched = sf.GetScheduler(); log.Info("------- Initialization Complete -----------"); log.Info("------- (Not Scheduling any Jobs - relying on XML definitions --"); Random r = new Random(); // schedule 500 jobs to run for (int count = 1; count <= numberOfJobs; count++) { IJobDetail job = JobBuilder .NewJob <SimpleJob>() .WithIdentity("job" + count, "group_1") .RequestRecovery() // ask scheduler to re-execute this job if it was in progress when the scheduler went down... .Build(); // tell the job to delay some small amount... to simulate work... long timeDelay = (long)(r.NextDouble() * 2500); job.JobDataMap.Put(SimpleJob.DelayTime, timeDelay); ITrigger trigger = TriggerBuilder.Create() .WithIdentity("trigger_" + count, "group_1") .StartAt(DateBuilder.FutureDate((10000 + (count * 100)), DateBuilder.IntervalUnit.Millisecond)) // space fire times a small bit .Build(); sched.ScheduleJob(job, trigger); if (count % 25 == 0) { log.Info("...scheduled " + count + " jobs"); } } log.Info("------- Starting Scheduler ----------------"); // start the schedule sched.Start(); log.Info("------- Started Scheduler -----------------"); log.Info("------- Waiting five minutes... -----------"); // wait five minutes to give our jobs a chance to run try { Thread.Sleep(TimeSpan.FromMinutes(5)); } catch (ThreadInterruptedException) { } // shut down the scheduler log.Info("------- Shutting Down ---------------------"); sched.Shutdown(true); log.Info("------- Shutdown Complete -----------------"); SchedulerMetaData metaData = sched.GetMetaData(); log.Info("Executed " + metaData.NumberOfJobsExecuted + " jobs."); }