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);
}
