public static void Main(string[] args) { //Console.WriteLine("Hello World!"); // TODO: Implement Functionality Here //Console.Write("Press any key to continue . . . "); //Console.ReadKey(true); //初始化调度器工厂 ISchedulerFactory sf = new StdSchedulerFactory(); //获取默认调度器 IScheduler scheduler = sf.GetScheduler(); //作业 IJobDetail job = JobBuilder .Create <JobExample>() .WithIdentity("计算作业", "组1") .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("触发器1", "触发器组1") .StartAt(DateBuilder.FutureDate(1, IntervalUnit.Second)) .WithSimpleSchedule(x => x.WithRepeatCount(20).WithInterval(TimeSpan.FromSeconds(5))) .Build(); //关联任务和触发器 scheduler.ScheduleJob(job, trigger); //开始任务 scheduler.Start(); Console.Read(); }
/// <inheritdoc/> public void Configure(QuartzOptions options) { if (options is null) { throw new ArgumentNullException(nameof(options)); } options.AddJob <OpenIddictQuartzJob>(builder => { builder.StoreDurably() .WithIdentity(OpenIddictQuartzJob.Identity) .WithDescription(SR.GetResourceString(SR.ID8000)); }); options.AddTrigger(builder => { // Note: this trigger uses a quite long interval (1 hour), which means it may be potentially // never reached if the application is shut down or recycled. As such, this trigger is set up // to fire 2 minutes after the application starts to ensure it's executed at least once. builder.ForJob(OpenIddictQuartzJob.Identity) .WithSimpleSchedule(options => options.WithIntervalInHours(1).RepeatForever()) .WithDescription(SR.GetResourceString(SR.ID8001)) .StartAt(DateBuilder.FutureDate(2, IntervalUnit.Minute)); }); }
/// <summary> /// 创建计划任务 /// </summary> private static void ExecuteService() { if (_serviceScheduler == null) { ISchedulerFactory schedulerFactory = new StdSchedulerFactory(); _serviceScheduler = schedulerFactory.GetScheduler(); } foreach (var serviceKey in ServiceJobBaseByServiceKey.Keys.ToArray()) { ExecuteServiceByServiceKey(serviceKey); } var serviceMonitorJob = JobBuilder.Create <ServiceMonitorJob>() .WithIdentity("ServiceMonitorJob") .Build(); var serviceMonitorTrigger = (ISimpleTrigger)TriggerBuilder.Create() .WithIdentity("ServiceMonitorJob") .StartAt(DateBuilder.FutureDate(1, IntervalUnit.Second)) .WithSimpleSchedule(x => x.WithIntervalInSeconds(1).RepeatForever()) .Build(); _serviceScheduler.ScheduleJob(serviceMonitorJob, serviceMonitorTrigger); _serviceScheduler.Start(); }
public void InitTimer() { Common.Logging.LogManager.Adapter = new Common.Logging.Simple.ConsoleOutLoggerFactoryAdapter { Level = Common.Logging.LogLevel.Info }; // Grab the Scheduler instance from the Factory IScheduler scheduler = StdSchedulerFactory.GetDefaultScheduler(); // and start it off scheduler.Start(); // define the job and tie it to our HelloJob class IJobDetail job = JobBuilder.Create <IntervalProc>() .WithIdentity("job1", "group1") .Build(); var initialOffset = DateTimeOffset.Now; initialOffset.AddTicks(TimerPeriod.Ticks); // Trigger the job to run now, and then repeat every 10 seconds ITrigger trigger = TriggerBuilder.Create() .WithIdentity("trigger1", "group1") .StartAt(DateBuilder.FutureDate(1, IntervalUnit.Minute)) .WithSimpleSchedule(x => x .WithIntervalInSeconds((int)TimerPeriod.TotalSeconds) .RepeatForever()) .Build(); // Tell quartz to schedule the job using our trigger scheduler.ScheduleJob(job, trigger); }
public virtual async Task Run() { // First we must get a reference to a scheduler ISchedulerFactory sf = new StdSchedulerFactory(); IScheduler sched = await sf.GetScheduler(); Console.WriteLine("------- Initialization Complete -----------"); Console.WriteLine("------- Scheduling Jobs -------------------"); Random r = new Random(); // schedule 500 jobs to run for (int count = 1; count <= NumberOfJobs; count++) { IJobDetail job = JobBuilder .Create <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, IntervalUnit.Millisecond)) // space fire times a small bit .Build(); await sched.ScheduleJob(job, trigger); if (count % 25 == 0) { Console.WriteLine("...scheduled " + count + " jobs"); } } Console.WriteLine("------- Starting Scheduler ----------------"); // start the schedule await sched.Start(); Console.WriteLine("------- Started Scheduler -----------------"); Console.WriteLine("------- Waiting five minutes... -----------"); // wait five minutes to give our jobs a chance to run await Task.Delay(TimeSpan.FromMinutes(5)); // shut down the scheduler Console.WriteLine("------- Shutting Down ---------------------"); await sched.Shutdown(true); Console.WriteLine("------- Shutdown Complete -----------------"); SchedulerMetaData metaData = await sched.GetMetaData(); Console.WriteLine("Executed " + metaData.NumberOfJobsExecuted + " jobs."); }
public void TestTriggerBuilder() { 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.That(trigger.StartTimeUtc.DateTime, Is.EqualTo(DateTimeOffset.UtcNow.DateTime).Within(TimeSpan.FromSeconds(1)), "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, 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 priority: " + trigger); Assert.IsTrue(trigger.StartTimeUtc.Equals(stime), "Unexpected start-time: " + trigger.StartTimeUtc); Assert.IsTrue(trigger.EndTimeUtc != null, "Unexpected end-time: " + trigger.EndTimeUtc); }
public void Execute(IJobExecutionContext context) { Window win = context.JobDetail.JobDataMap.Get("window") as Window; if (win != null) { Application.Current.Dispatcher.Invoke((Action)(() => { win.Width = System.Windows.SystemParameters.FullPrimaryScreenWidth; win.Height = System.Windows.SystemParameters.FullPrimaryScreenHeight; win.WindowStartupLocation = WindowStartupLocation.CenterScreen; win.WindowStyle = WindowStyle.None; win.Topmost = true; win.WindowState = WindowState.Maximized; win.Show(); })); IDictionary <string, object> map = new Dictionary <string, object>(); map.Add("window", win); IJobDetail job = JobBuilder.Create <HideJob>() .WithIdentity("hideJob", "group") .UsingJobData(new JobDataMap(map)) .Build(); ITrigger trigger = TriggerBuilder.Create() .WithIdentity("hideTrigger", "group") .StartAt(DateBuilder.FutureDate(5, IntervalUnit.Second)) .Build(); context.Scheduler.ScheduleJob(job, trigger); } }
public Guid ScheduleScrapeJob(string url, string requestedElement) { var guid = Guid.NewGuid(); IScheduler sched = _schedFact.GetScheduler(); sched.Start(); IJobDetail job = JobBuilder.Create <WebScrapeJob>() .WithIdentity(guid.ToString(), "g") .UsingJobData("url", url) .UsingJobData("requestedOn", DateTime.Now.ToLongDateString()) .UsingJobData("requestedElement", requestedElement) .Build(); ITrigger trigger = TriggerBuilder.Create() .WithIdentity($"trigger{guid.ToString()}", "g") .StartAt(DateBuilder.FutureDate(Convert.ToInt32(ConfigurationManager.AppSettings["ScheduleDelay"]), IntervalUnit.Second)) .ForJob(job.Key) .Build(); sched.ScheduleJob(job, trigger); return(guid); }
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); }
private static async Task CreateRemainder <T>(ZSJobsAndTriggerInfo remainderDetails, RemainderInfoKey key) where T : IJob { IJobDetail job = null; ITrigger trigger = null; JobKey jobKey = JobKey.Create(remainderDetails.jobIdentityKey); job = JobBuilder.Create <T>(). WithIdentity(jobKey) .UsingJobData(key.ToString(), remainderDetails.jobData_Info) .Build(); //trigger = TriggerBuilder.Create() //.WithIdentity(JobandTrigger.TriggerIdentityKey) //.StartNow() //.WithSimpleSchedule(x => x.WithIntervalInSeconds(JobandTrigger.ScheduleIntervalInSec).WithRepeatCount(1) ////.RepeatForever() //) //.Build(); trigger = (ISimpleTrigger)TriggerBuilder.Create() .WithIdentity(remainderDetails.TriggerIdentityKey) .StartAt(DateBuilder.FutureDate(remainderDetails.ScheduleIntervalInSec, IntervalUnit.Second)) // use DateBuilder to create a date in the future .ForJob(jobKey) // identify job with its JobKey .Build(); await getScheduler().ScheduleJob(job, trigger); }
public async Task JobWasExecuted(IJobExecutionContext context, JobExecutionException jobException, CancellationToken ct) { if (jobException != null) { return; } if (context == null) { throw new ArgumentNullException("Completed job does not have valid Job Execution Context"); } var finishedJob = context.JobDetail; if (finishedJob.JobDataMap.Contains("_refire")) { var refire = finishedJob.JobDataMap.GetInt("_refire"); finishedJob.JobDataMap.Remove("_refire"); var trigger = TriggerBuilder.Create() .WithIdentity(Guid.NewGuid().ToString(), "group1") .StartAt(DateBuilder.FutureDate(refire, IntervalUnit.Second)) .ForJob(finishedJob.Key) .Build(); await context.Scheduler.ScheduleJob(trigger); return; } else { Log.Logger.Debug("Task is finished. Deleting"); await context.Scheduler.DeleteJob(finishedJob.Key); } var childJobs = finishedJob.JobDataMap.Get(NextJobKey) as List <JobKey> ?? new List <JobKey>(); if (childJobs.Count == 0) { await context.Scheduler.DeleteJob(finishedJob.Key); return; } foreach (var jobKey in childJobs) { var newJob = await context.Scheduler.GetJobDetail(jobKey); if (newJob == null) { Debug.WriteLine($"Could not find Job with ID: {jobKey}"); continue; } await context.Scheduler.AddJob(newJob, true, false); await context.Scheduler.TriggerJob(jobKey); } }
public void TestTriggerTimeSort() { // build trigger in expected sort order ITrigger t1 = TriggerBuilder.Create().WithIdentity("a").StartAt(DateBuilder.FutureDate(1, IntervalUnit.Minute)).Build(); ((IOperableTrigger)t1).ComputeFirstFireTimeUtc(null); ITrigger t2 = TriggerBuilder.Create().WithIdentity("b").StartAt(DateBuilder.FutureDate(2, IntervalUnit.Minute)).Build(); ((IOperableTrigger)t2).ComputeFirstFireTimeUtc(null); ITrigger t3 = TriggerBuilder.Create().WithIdentity("c").StartAt(DateBuilder.FutureDate(3, IntervalUnit.Minute)).Build(); ((IOperableTrigger)t3).ComputeFirstFireTimeUtc(null); ITrigger t4 = TriggerBuilder.Create().WithIdentity("d").StartAt(DateBuilder.FutureDate(5, IntervalUnit.Minute)).WithPriority(7).Build(); ((IOperableTrigger)t4).ComputeFirstFireTimeUtc(null); ITrigger t5 = TriggerBuilder.Create().WithIdentity("e").StartAt(DateBuilder.FutureDate(5, IntervalUnit.Minute)).Build(); ((IOperableTrigger)t5).ComputeFirstFireTimeUtc(null); ITrigger t6 = TriggerBuilder.Create().WithIdentity("g").StartAt(DateBuilder.FutureDate(5, IntervalUnit.Minute)).Build(); ((IOperableTrigger)t6).ComputeFirstFireTimeUtc(null); ITrigger t7 = TriggerBuilder.Create().WithIdentity("h").StartAt(DateBuilder.FutureDate(5, IntervalUnit.Minute)).WithPriority(2).Build(); ((IOperableTrigger)t7).ComputeFirstFireTimeUtc(null); ITrigger t8 = TriggerBuilder.Create().WithIdentity("i").StartAt(DateBuilder.FutureDate(6, IntervalUnit.Minute)).Build(); ((IOperableTrigger)t8).ComputeFirstFireTimeUtc(null); ITrigger t9 = TriggerBuilder.Create().WithIdentity("j").StartAt(DateBuilder.FutureDate(7, IntervalUnit.Minute)).Build(); ((IOperableTrigger)t9).ComputeFirstFireTimeUtc(null); List <ITrigger> ts = new List <ITrigger>(); // add triggers to list in somewhat randomized order ts.Add(t5); ts.Add(t9); ts.Add(t6); ts.Add(t8); ts.Add(t4); ts.Add(t3); ts.Add(t1); ts.Add(t7); ts.Add(t2); // sort the list ts.Sort(); // check the order of the list Assert.AreEqual(t1, ts[0]); Assert.AreEqual(t2, ts[1]); Assert.AreEqual(t3, ts[2]); Assert.AreEqual(t4, ts[3]); Assert.AreEqual(t5, ts[4]); Assert.AreEqual(t6, ts[5]); Assert.AreEqual(t7, ts[6]); Assert.AreEqual(t8, ts[7]); Assert.AreEqual(t9, ts[8]); }
public static DateTimeOffset NextRunFor(Schedule sched) { var s = sched.ToString(); var now = C.CurrTime(); switch (s) { case Schedule.HOURLY: return(DateBuilder.FutureDate(1, IntervalUnit.Hour)); case Schedule.WEEKDAILY: switch (now.DayOfWeek) { case DayOfWeek.Friday: return(Days(3)); case DayOfWeek.Saturday: return(Days(2)); default: return(Days(1)); } case Schedule.MWF: switch (now.DayOfWeek) { case DayOfWeek.Friday: return(Days(3)); case DayOfWeek.Monday: case DayOfWeek.Wednesday: case DayOfWeek.Saturday: return(Days(2)); default: return(Days(1)); } case Schedule.DAILY: return(Days(1)); case Schedule.WEEKLY: return(Days(7)); default: if (CronExpression.IsValidExpression(s)) { var next = new CronExpression(s).GetNextValidTimeAfter(now); if (next.HasValue) { return(next.Value); } } return(Days(1)); } }
public string PeriodicHttpRequestMessage(string method, Uri destination, Dictionary <string, string> headers, Dictionary <string, string> parameters, TimeSpan delay, TimeSpan period, TimeSpan timeLimit, bool fireAndForget) { if (delay == null) { throw new ArgumentNullException("delay"); } if (delay < TimeSpan.Parse("00:00:00")) { throw new ArithmeticException("delay must be positive"); } if (period == null) { throw new ArgumentNullException("period"); } if (period < TimeSpan.Parse("00:00:00")) { throw new ArithmeticException("period must be positive"); } string jobId = _idProducer.GetId(); using (ILoggingOperation log = _logger.NormalOperation().AddProperty("jobId", jobId)) { log.Wrap(() => { log.Info($"scheduling request {jobId} HttpRequestJob with parameters method={method}, destination={destination}, headaers={headers}, parameters={parameters}, delay={delay}, period={period}, timeLimit={timeLimit}, fireAndForget={fireAndForget}"); IJobDetail job = JobBuilder.Create <HttpRequestJob>() .WithIdentity(jobId, ServiceConstants.JobGroupName) .StoreDurably(false) .UsingJobData("Method", method) .UsingJobData("Destination", destination.ToString()) .UsingJobData("HeadersJSON", JsonConvert.SerializeObject(headers)) .UsingJobData("ParametersJSON", JsonConvert.SerializeObject(parameters)) .UsingJobData("RetryCount", "0") .UsingJobData("FireAndForget", fireAndForget.ToString()) .Build(); ITrigger trigger = TriggerBuilder.Create() .WithIdentity(Guid.NewGuid().ToString(), Service.ServiceConstants.TriggerGroupName) .StartAt(DateBuilder.FutureDate((int)delay.TotalMilliseconds, IntervalUnit.Millisecond)) .WithSimpleSchedule(p => p .WithMisfireHandlingInstructionFireNow() .WithInterval(period) .RepeatForever() ) .EndAt(DateBuilder.FutureDate((int)(timeLimit == null ? TimeSpan.MaxValue : timeLimit).TotalMilliseconds, IntervalUnit.Millisecond)) .Build(); DateTimeOffset t = Global.Scheduler.ScheduleJob(job, trigger); log.Info($"scheduled request {jobId} HttpRequestJob in {t.ToString("HH:mm:ss.fff")}"); }); return(jobId); } }
public string PeriodicSOAPRequestMessage(string hostname, int port, byte[] payload, TimeSpan delay, TimeSpan period, TimeSpan timeLimit, bool fireAndForget) { if (delay == null) { throw new ArgumentNullException("delay"); } if (delay < TimeSpan.Parse("00:00:00")) { throw new ArithmeticException("delay must be positive"); } if (period == null) { throw new ArgumentNullException("period"); } if (period < TimeSpan.Parse("00:00:00")) { throw new ArithmeticException("period must be positive"); } string jobId = _idProducer.GetId(); using (ILoggingOperation log = _logger.NormalOperation().AddProperty("jobId", jobId)) { log.Wrap(() => { log.Info($"scheduling request {jobId} TCPRequestJob with parameters hostname={hostname}, port={port}, payload={Convert.ToBase64String(payload)}, delay={delay}, period={period}, timeLimit={timeLimit}, fireAndForget={fireAndForget}"); IJobDetail job = JobBuilder.Create <SOAPRequestJob>() .WithIdentity(jobId, ServiceConstants.JobGroupName) .StoreDurably(false) .UsingJobData("Hostname", hostname) .UsingJobData("Port", port.ToString()) .UsingJobData("PayloadBase64", Convert.ToBase64String(payload)) .UsingJobData("RetryCount", "0") .UsingJobData("FireAndForget", fireAndForget.ToString()) .Build(); ITrigger trigger = TriggerBuilder.Create() .WithIdentity(Guid.NewGuid().ToString(), Service.ServiceConstants.TriggerGroupName) .StartAt(DateBuilder.FutureDate((int)delay.TotalMilliseconds, IntervalUnit.Millisecond)) .WithSimpleSchedule(p => p .WithMisfireHandlingInstructionFireNow() .WithInterval(period) .RepeatForever() ) .EndAt(DateBuilder.FutureDate((int)(timeLimit == null ? TimeSpan.MaxValue : timeLimit).TotalMilliseconds, IntervalUnit.Millisecond)) .Build(); DateTimeOffset t = Global.Scheduler.ScheduleJob(job, trigger); log.Info($"scheduled request {jobId} TCPRequestJob in {t.ToString("HH:mm:ss.fff")}"); }); return(jobId); } }
// Build a trigger that will fire once, five minutes in the future: public void BuildTrigger3() { JobKey myJobKey = JobKey.Create("JobKey-name", "JobKey-group"); ITrigger trigger = (ISimpleTrigger)TriggerBuilder.Create() .WithIdentity("trigger5", "group1") .StartAt(DateBuilder.FutureDate(5, IntervalUnit.Minute)) // use DateBuilder to create a date in the future .ForJob(myJobKey) // identify job with its JobKey .Build(); }
//создание тригера для таски создания доставки private ITrigger BuildCreateTrigger() { var delayTime = _random.Next(_createIntervalMin, _createIntervalMax); ITrigger trigger = TriggerBuilder.Create() .WithIdentity("createTrigger", "deliveryGroup") .StartAt(DateBuilder.FutureDate(delayTime, IntervalUnit.Second)) .Build(); return(trigger); }
/// <summary> /// Schedules the job. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="scheduler">The scheduler.</param> /// <param name="intervalinSeconds">The intervalin seconds.</param> internal static void ScheduleJob <T>(IScheduler scheduler, int intervalinSeconds) where T : IJob { var syncjob = JobBuilder.Create <T>().Build(); var synctrigger = TriggerBuilder.Create() .StartAt(DateBuilder.FutureDate(new Random().Next(3, 10), IntervalUnit.Minute)) .WithSimpleSchedule(s => s.WithIntervalInSeconds(intervalinSeconds).RepeatForever()) .Build(); scheduler.ScheduleJob(syncjob, synctrigger); }
public override async Task StartAsync(CancellationToken cancellationToken) { var everyTopOfTheHourTrigger = TriggerBuilder.Create() .WithIdentity("EveryTopOfTheHourTrigger") .StartNow() .WithCronSchedule("0 0 * * * ?") .Build(); var emergencyAccessNotificationTrigger = TriggerBuilder.Create() .WithIdentity("EmergencyAccessNotificationTrigger") .StartNow() .WithCronSchedule("0 0 * * * ?") .Build(); var emergencyAccessTimeoutTrigger = TriggerBuilder.Create() .WithIdentity("EmergencyAccessTimeoutTrigger") .StartNow() .WithCronSchedule("0 0 * * * ?") .Build(); var everyTopOfTheSixthHourTrigger = TriggerBuilder.Create() .WithIdentity("EveryTopOfTheSixthHourTrigger") .StartNow() .WithCronSchedule("0 0 */6 * * ?") .Build(); var everyTwelfthHourAndThirtyMinutesTrigger = TriggerBuilder.Create() .WithIdentity("EveryTwelfthHourAndThirtyMinutesTrigger") .StartNow() .WithCronSchedule("0 30 */12 * * ?") .Build(); var randomDailySponsorshipSyncTrigger = TriggerBuilder.Create() .WithIdentity("RandomDailySponsorshipSyncTrigger") .StartAt(DateBuilder.FutureDate(new Random().Next(24), IntervalUnit.Hour)) .WithSimpleSchedule(x => x .WithIntervalInHours(24) .RepeatForever()) .Build(); var jobs = new List <Tuple <Type, ITrigger> > { new Tuple <Type, ITrigger>(typeof(AliveJob), everyTopOfTheHourTrigger), new Tuple <Type, ITrigger>(typeof(EmergencyAccessNotificationJob), emergencyAccessNotificationTrigger), new Tuple <Type, ITrigger>(typeof(EmergencyAccessTimeoutJob), emergencyAccessTimeoutTrigger), new Tuple <Type, ITrigger>(typeof(ValidateUsersJob), everyTopOfTheSixthHourTrigger), new Tuple <Type, ITrigger>(typeof(ValidateOrganizationsJob), everyTwelfthHourAndThirtyMinutesTrigger) }; if (_globalSettings.SelfHosted && _globalSettings.EnableCloudCommunication) { jobs.Add(new Tuple <Type, ITrigger>(typeof(SelfHostedSponsorshipSyncJob), randomDailySponsorshipSyncTrigger)); } Jobs = jobs; await base.StartAsync(cancellationToken); }
private async Task RerunJobAsync(IJobExecutionContext context) { if (!_isRetrying) { var retryTrigger = TriggerBuilder.Create() .ForJob(Identity, Group) .StartAt(DateBuilder.FutureDate(30, IntervalUnit.Minute)) .Build(); var rerun = await context.Scheduler.ScheduleJob(retryTrigger).ConfigureAwait(false); _isRetrying = true; _logger.Information("Dump retrieval will be retried at {@rerun}.", rerun.ToString("O")); } }
//создание тригера для таски пометки просроченных доставок private ITrigger BuildExpireTrigger() { var delayTime = 10; ITrigger trigger = TriggerBuilder.Create() .WithIdentity("expireTrigger", "deliveryGroup") .StartAt(DateBuilder.FutureDate(delayTime, IntervalUnit.Second)) .WithSimpleSchedule(x => x .WithIntervalInSeconds(delayTime) .RepeatForever()) .Build(); return(trigger); }
/// <summary> /// Schedule job <typeparamref name="T"/> with delay <paramref name="interval"/> and data context <paramref name="dataContext"/> /// </summary> /// <typeparam name="T">Type of job to execute</typeparam> /// <typeparam name="D">Type of data context</typeparam> /// <param name="scheduler">Scheduler</param> /// <param name="delay">Delay after which jobs executes</param> /// <param name="dataContext">Data context</param> /// <param name="uid">UID for job registration</param> /// <param name="token">Cancellation token</param> public static async Task <JobKey> DelayExecution <T, D>(this IScheduler scheduler, TimeSpan delay, D dataContext, string uid, CancellationToken token = default) where T : IJob { var job = JobBuilder.Create <T>() .WithIdentity(GetUniqueName(uid)) .SetJobData(WrapJobData(dataContext)) .Build(); var tb = TriggerBuilder.Create() .WithIdentity(GetUniqueName(uid)) .StartAt(DateBuilder.FutureDate((int)delay.TotalMilliseconds, IntervalUnit.Millisecond)); await scheduler.ScheduleJob(job, tb.Build(), token); return(job.Key); }
public string CRONHttpRequestMessage(string method, Uri destination, Dictionary <string, string> headers, Dictionary <string, string> parameters, string CRONString, TimeSpan timeLimit, bool fireAndForget) { if (CRONString == null) { throw new ArgumentNullException("CRONString"); } if (!CronExpression.IsValidExpression(CRONString)) { throw new ArgumentException("CRONString is not a valid cron string"); } string jobId = _idProducer.GetId(); using (ILoggingOperation log = _logger.NormalOperation().AddProperty("jobId", jobId)) { log.Wrap(() => { log.Info($"scheduling request {jobId} HttpRequestJob with parameters method={method}, destination={destination}, headaers={headers}, parameters={parameters}, CRONString={CRONString}, timeLimit={timeLimit}, fireAndForget={fireAndForget}"); IJobDetail job = JobBuilder.Create <HttpRequestJob>() .WithIdentity(jobId, ServiceConstants.JobGroupName) .StoreDurably(false) .UsingJobData("Method", method) .UsingJobData("Destination", destination.ToString()) .UsingJobData("HeadersJSON", JsonConvert.SerializeObject(headers)) .UsingJobData("ParametersJSON", JsonConvert.SerializeObject(parameters)) .UsingJobData("RetryCount", "0") .UsingJobData("FireAndForget", fireAndForget.ToString()) .Build(); ITrigger trigger = TriggerBuilder.Create() .WithIdentity(Guid.NewGuid().ToString(), Service.ServiceConstants.TriggerGroupName) .StartAt(DateBuilder.FutureDate(0, IntervalUnit.Millisecond)) .WithCronSchedule(CRONString, p => p .WithMisfireHandlingInstructionFireAndProceed() ) .EndAt(DateBuilder.FutureDate((int)(timeLimit == null ? TimeSpan.MaxValue : timeLimit).TotalMilliseconds, IntervalUnit.Millisecond)) .Build(); DateTimeOffset t = Global.Scheduler.ScheduleJob(job, trigger); log.Info($"scheduled request {jobId} HttpRequestJob in {t.ToString("HH:mm:ss.fff")}"); }); return(jobId); } }
public void Execute() { if (!_scheduler.IsStarted) { return; } foreach (var jobKey in _scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals(JobGroupExporter.JobGroup))) { _scheduler.DeleteJob(jobKey); } foreach (var sourceAndStorage in _sourceStorageFactory.Sources.Select(s => new { Storage = _sourceStorageFactory.SourceStorageFor(s.Id), Source = s })) { IItemSource itemSource = sourceAndStorage.Source; SourceStorage sourceStorage = sourceAndStorage.Storage; var frequency = Configuration.GetFrequencyForItemSource(itemSource); if (itemSource.Persistent && frequency < Configuration.MinimumFrequencyForPersistentSources) { frequency = Configuration.MinimumFrequencyForPersistentSources; } var itemSourceName = itemSource.Id; var jobDetail = JobBuilder.Create <IndexerJob>() .WithIdentity("IndexerFor" + itemSourceName, JobGroupExporter.JobGroup) .Build(); jobDetail.JobDataMap[IndexerJob.SourceStorageKey] = sourceStorage; jobDetail.JobDataMap[IndexerJob.SourceKey] = itemSource; var trigger = TriggerBuilder.Create() .StartAt(DateBuilder.FutureDate(2, IntervalUnit.Second)) .WithSimpleSchedule(b => b.WithIntervalInSeconds(frequency) .RepeatForever() .WithMisfireHandlingInstructionNextWithRemainingCount()) .WithIdentity("Each" + frequency + "SecondsFor" + itemSource.Id) .Build(); _scheduler.ScheduleJob(jobDetail, trigger); } }
public string CRONSOAPRequestMessage(string hostname, int port, byte[] payload, string CRONString, TimeSpan timeLimit, bool fireAndForget) { if (CRONString == null) { throw new ArgumentNullException("CRONString"); } if (!CronExpression.IsValidExpression(CRONString)) { throw new ArgumentException("CRONString is not a valid cron string"); } string jobId = _idProducer.GetId(); using (ILoggingOperation log = _logger.NormalOperation().AddProperty("jobId", jobId)) { log.Wrap(() => { log.Info($"scheduling request {jobId} TCPRequestJob with parameters hostname={hostname}, port={port}, payload={Convert.ToBase64String(payload)}, CRONString={CRONString}, timeLimit={timeLimit}, fireAndForget={fireAndForget}"); IJobDetail job = JobBuilder.Create <SOAPRequestJob>() .WithIdentity(jobId, ServiceConstants.JobGroupName) .StoreDurably(false) .UsingJobData("Hostname", hostname) .UsingJobData("Port", port.ToString()) .UsingJobData("PayloadBase64", Convert.ToBase64String(payload)) .UsingJobData("RetryCount", "0") .UsingJobData("FireAndForget", fireAndForget.ToString()) .Build(); ITrigger trigger = TriggerBuilder.Create() .WithIdentity(Guid.NewGuid().ToString(), Service.ServiceConstants.TriggerGroupName) .StartAt(DateBuilder.FutureDate(0, IntervalUnit.Millisecond)) .WithCronSchedule(CRONString, p => p .WithMisfireHandlingInstructionFireAndProceed() ) .EndAt(DateBuilder.FutureDate((int)(timeLimit == null ? TimeSpan.MaxValue : timeLimit).TotalMilliseconds, IntervalUnit.Millisecond)) .Build(); DateTimeOffset t = Global.Scheduler.ScheduleJob(job, trigger); log.Info($"scheduled request {jobId} TCPRequestJob in {t.ToString("HH:mm:ss.fff")}"); }); return(jobId); } }
private void CreateBackup(string name, MySqlDatabase db, int intervalInMins) { IJobDetail job = JobBuilder.Create <BackupDBJob>() .WithIdentity("backupjob_" + name, "backup") .Build(); ITrigger trigger = TriggerBuilder.Create() .WithIdentity("backupjob_" + name, "backup") .StartAt(DateBuilder.FutureDate(intervalInMins, IntervalUnit.Minute)) .WithSimpleSchedule(x => x.RepeatForever().WithIntervalInMinutes(intervalInMins)).Build(); job.JobDataMap["backupname"] = name; job.JobDataMap["backupdb"] = db; _scheduler.ScheduleJob(job, trigger); _triggers.Add(name, trigger.Key); }
public async Task <IActionResult> QuartzTest() { // define the job detail and tie it to our job class IJobDetail job = JobBuilder.Create <ExampleJob>() //.WithIdentity("job1", "group1") // (optional) .Build(); ISimpleTrigger trigger = (ISimpleTrigger)TriggerBuilder.Create() // .WithIdentity("trigger1", "group1") // (optional) .StartAt(DateBuilder.FutureDate(5, IntervalUnit.Minute)) // use DateBuilder to create a date in the future // .ForJob(job.Key) .Build(); var scheduler = await _schedulerFactory.GetScheduler(); await scheduler.ScheduleJob(job, trigger); return(Ok("scheduled")); }
public string DelayedChannelMessage(string channelName, bool broadcast, string message, TimeSpan delay, int retryCount, bool fireAndForget) { if (delay == null) { throw new ArgumentNullException("delay"); } if (delay < TimeSpan.Parse("00:00:00")) { throw new ArithmeticException("delay must be positive"); } string jobId = _idProducer.GetId(); using (ILoggingOperation log = _logger.NormalOperation().AddProperty("jobId", jobId)) { log.Wrap(() => { log.Info($"scheduling request {jobId} ChannelsMessageJob with parameters channelName={channelName}, broadcast={broadcast}, message={message}, delay={delay}, retryCount={retryCount}, fireAndForget={fireAndForget}"); IJobDetail job = JobBuilder.Create <ChannelsMessageJob>() .WithIdentity(jobId, ServiceConstants.JobGroupName) .StoreDurably(false) .UsingJobData("ChannelName", channelName) .UsingJobData("Broadcast", broadcast) .UsingJobData("Message", message) .UsingJobData("RetryCount", retryCount.ToString()) .UsingJobData("FireAndForget", fireAndForget.ToString()) .Build(); ITrigger trigger = TriggerBuilder.Create() .WithIdentity(Guid.NewGuid().ToString(), Service.ServiceConstants.TriggerGroupName) .StartAt(DateBuilder.FutureDate((int)delay.TotalMilliseconds, IntervalUnit.Millisecond)) .WithSimpleSchedule(p => p.WithMisfireHandlingInstructionFireNow()) .Build(); DateTimeOffset t = Global.Scheduler.ScheduleJob(job, trigger); log.Info($"scheduled request {jobId} ChannelsMessageJob in {t.ToString("HH:mm:ss.fff")}"); }); return(jobId); } }
private void StartMonitoring() { ISchedulerFactory factory = new StdSchedulerFactory(); _scheduler = factory.GetScheduler(); _scheduler.Start(); IJobDetail jobDetail = JobBuilder.Create(typeof(MegaJob)) .WithIdentity("MegaJob") .Build(); ITrigger trigger = TriggerBuilder.Create() .WithIdentity("MegaTrigger") .StartAt(DateBuilder.FutureDate(2, IntervalUnit.Minute)) .WithSimpleSchedule(b => b.WithIntervalInMinutes(2)) .Build(); _scheduler.ScheduleJob(jobDetail, trigger); }
public static void StartJob <TJob>(IScheduler scheduler, TimeSpan runInterval, string userId) where TJob : IJob { var jobName = typeof(TJob).FullName; // Add Cart Expiring Job IJobDetail job = JobBuilder.Create <CartExpireJob>() .WithIdentity("cart" + userId, "carts") .Build(); //Trigger the job to run after 15 minutes ITrigger trigger = TriggerBuilder.Create() .WithIdentity("cartTrigger" + userId, "carts") .StartAt(DateBuilder.FutureDate(runInterval.Minutes, IntervalUnit.Minute)) .Build(); job.JobDataMap.Add("userId", userId); scheduler.ScheduleJob(job, trigger); }