public static TriggerBuilder TriggerFrequency(this TriggerBuilder triggerBuilder, IooinPlan plan)
{
if (plan.WithRepeatCount == 0)
{
return(triggerBuilder.WithSimpleSchedule(x => x.WithIntervalInSeconds(plan.WithIntervalInSeconds).RepeatForever()));
}
return(triggerBuilder.WithSimpleSchedule(x => x.WithIntervalInSeconds(plan.WithIntervalInSeconds).WithRepeatCount(plan.WithRepeatCount)));
}
/// <summary>
/// 启动定时器框架-自动扫描注入启动
/// </summary>
/// <param name="app"></param>
public static void UseQuartz(this IApplicationBuilder app)
{
var serviceProvider = app.ApplicationServices;
var scheduler = serviceProvider.GetRequiredService <IScheduler>();
var jobFactory = serviceProvider.GetRequiredService <IJobFactory>();
scheduler.JobFactory = jobFactory;
// add jobdetail with trigger to scheduler
var jobs = app.ApplicationServices.GetServices <IJob>();
foreach (var job in jobs)
{
var jobDesc = job.GetType().GetCustomAttribute <JobDescriptionAttribute>();
var jobBuilder = JobBuilder.Create(job.GetType());
if (jobDesc != null)
{
jobBuilder.WithIdentity(jobDesc.Key, jobDesc.Group).WithDescription(jobDesc.Description);
}
var jobDetail = jobBuilder.Build();
ITrigger trigger;
var triggerDesc = job.GetType().GetCustomAttribute <IntervalTriggerAttribute>();
if (triggerDesc == null)
{
// default trigger
trigger = TriggerBuilder.Create().StartNow()
.WithSimpleSchedule(x => x.WithIntervalInSeconds(60).RepeatForever()).Build();
}
else
{
TriggerBuilder temp = TriggerBuilder.Create().WithIdentity(triggerDesc.Key, triggerDesc.Group).WithDescription(triggerDesc.Description);
if (triggerDesc.StartNow)
{
temp = temp.StartNow();
}
if (triggerDesc.IsRepeatForever)
{
temp = temp.WithSimpleSchedule(x => x.WithIntervalInSeconds(triggerDesc.IntervalInSeconds)
.RepeatForever());
}
else
{
temp = temp.WithSimpleSchedule(x => x.WithIntervalInSeconds(triggerDesc.IntervalInSeconds)
.WithRepeatCount(triggerDesc.RepeatCount));
}
trigger = temp.Build();
}
scheduler.ScheduleJob(jobDetail, trigger).Wait();
}
scheduler.Start().Wait();
}
static IScheduler scheduler = null;// sf.GetScheduler();
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="jobName"></param>
/// <param name="triggerName"></param>
/// <param name="item"></param>
/// <param name="seconds">多久执行一次,</param>
/// <param name="count">执行多少次</param>
/// <param name="date"></param>
public static void JobsEx <T>(string jobName, string triggerName, KeyValuePair <string, object>?item = null,
int seconds = 1, int count = 1, DateTimeOffset?date = null)
{
#if NET40 || NET45
scheduler = sf.GetScheduler();
#else
scheduler = sf.GetScheduler().Result;
#endif
scheduler.Start();
IJobDetail detail = JobBuilder.Create(typeof(T)).WithIdentity(jobName).Build(); //new JobDetailImpl(jobName, typeof(T));
if (item.HasValue)
{
detail.JobDataMap.Add(item.Value);
}
TriggerBuilder builder = TriggerBuilder.Create().WithIdentity(triggerName); //TriggerBuilder.Create().WithIdentity(triggerName).StartAt(date.HasValue ? date.Value : DateTimeOffset.Now);
if (date.HasValue)
{
builder = builder.StartAt(date.Value);
}
else
{
builder = builder.StartNow();
}
if (count > 1)
{
if (seconds < 1)
{
seconds = 1;
}
builder = builder.WithSimpleSchedule(x => x.WithIntervalInSeconds(seconds).WithRepeatCount(count - 1));
}
else
{
builder = builder.WithSimpleSchedule();
}
ITrigger trigger = builder.Build();
scheduler.ScheduleJob(detail, trigger);
LogHelper.Info("scheduler is start " + DateTime.Now.ToStringEx());
//if (item.HasValue)
// logger.Info("scheduler param[" + JsonConvert.SerializeObject(item.Value) + "]", nameof(JobExtend));
//logger.Info("scheduler is shutdown:" + scheduler.IsShutdown);
//Console.WriteLine("scheduler is start" + DateTime.Now.ToString());
}
/// <summary>
/// 应用触发器数据
/// </summary>
/// <param name="triggerName"></param>
/// <param name="trigger"></param>
/// <param name="triggerBuilder"></param>
/// <returns></returns>
private static TriggerBuilder ApplyTriggerData(string triggerName, TriggerType trigger, TriggerBuilder triggerBuilder)
{
if (!string.IsNullOrEmpty(triggerName))
{
triggerBuilder = triggerBuilder.WithIdentity(triggerName);
}
if (trigger is SimpleTriggerType simpleTrigger)
{
triggerBuilder = triggerBuilder.WithSimpleSchedule(x =>
{
if (simpleTrigger.RepeatCount == -1)
{
x.RepeatForever();
}
else
{
x.WithRepeatCount(simpleTrigger.RepeatCount);
}
x.WithInterval(TimeSpan.FromMilliseconds(simpleTrigger.RepeatInterval));
});
}
else if (trigger is CronTriggerType cronTriggerType)
{
triggerBuilder = triggerBuilder.WithCronSchedule(cronTriggerType.CronExpression);
}
else
{
throw new Exception("不支持的 trigger type: " + trigger.Code);
}
return(triggerBuilder);
}
public async Task <DateTimeOffset?> ScheduleRemoveOldEventsJob(int intervalSecs, DateTime?startAt)
{
ValidateRemoveOldEventsJobSchedule();
TriggerBuilder builder = TriggerBuilder.Create()
.WithIdentity(RemoveOldEventsTriggerKey);
if (startAt != null)
{
builder = builder.StartAt(startAt.Value);
}
else
{
builder = builder.StartNow();
}
builder = builder.WithSimpleSchedule(x => x
.WithInterval(TimeSpan.FromSeconds(intervalSecs))
.RepeatForever());
var trigger = builder.ForJob(RemoveOldEventsJobKey).Build();
var oldTrigger = await Scheduler.GetTrigger(RemoveOldEventsTriggerKey);
if (oldTrigger != null)
{
return(await Scheduler.RescheduleJob(RemoveOldEventsTriggerKey, trigger));
}
return(await Scheduler.ScheduleJob(trigger));
}
public void Add(Task task)
{
if (task.next_date > DateTime.Now)
{
IJobDetail taskToNotify = JobBuilder.Create <Notification>().WithIdentity(task.JobKey).Build();
taskToNotify.JobDataMap["Task"] = task;
TriggerBuilder builder = TriggerBuilder.Create()
.StartAt(task.next_date);
if (task.period_min > 0)
{
builder.WithSimpleSchedule(x => x
.WithIntervalInMinutes(task.period_min)
.RepeatForever())
.EndAt(task.next_date.AddMinutes(task.duration_min));
}
ITrigger trigger = builder
.Build();
scheduler.ScheduleJob(taskToNotify, trigger);
}
}
/// <summary>
/// Load DB Job and Trigger
/// </summary>
public virtual void GetJobTriggerFromDb()
{
var item = GetJobList();
_logger.Info(string.Format("创建任务触发，JobUID={0}，JobName={1}", item.JobUID, item.JobName));
Type type = Type.GetType(item.JobClass);
var job = JobBuilder.Create(type)
.WithIdentity(item.JobUID)
.UsingJobData("JobName", item.JobName)
.Build();
TriggerBuilder simpleTriggerBuilder = TriggerBuilder.Create()
.WithIdentity(Guid.NewGuid().ToString())
.ForJob(job).StartNow();
int simpleRepeatInterval = 6;
if (!string.IsNullOrWhiteSpace(item.SimpleRepeatInterval))
{
simpleRepeatInterval = Convert.ToInt32(item.SimpleRepeatInterval);
}
simpleTriggerBuilder = simpleTriggerBuilder.WithSimpleSchedule(x => x
.WithIntervalInSeconds(simpleRepeatInterval)//触发时间，秒
.RepeatForever());
var trigger = simpleTriggerBuilder.Build();
if (scheduler.CheckExists(job.Key))
{
//schedule the job
scheduler.ScheduleJob(trigger);
}
else
{
scheduler.ScheduleJob(job, trigger);
}
}
public async override Task StartAsync(CancellationToken cancellationToken)
{
Log.Information("Starting JobWorker...");
await _fFmpegInitializer.Intitialize();
IScheduler scheduler = await _schedulerFactory
.GetScheduler(cancellationToken);
scheduler.JobFactory = _jobFactory;
foreach (IJob job in _jobs)
{
Type jobType = job.GetType();
Log.Information("Scheduling job {Name}", jobType.Name);
JobScheduleOptions?options = _scheduleOptions
.FirstOrDefault(x => x.Name == jobType.Name);
if (options != null && options.Enabled)
{
IJobDetail jobDetail = JobBuilder
.Create(jobType)
.WithIdentity(jobType.Name)
.Build();
TriggerBuilder triggerBuilder = TriggerBuilder
.Create()
.WithIdentity(jobType.Name);
if (options.Interval.HasValue)
{
triggerBuilder.WithSimpleSchedule(s => s
.WithInterval(options.Interval.Value)
.RepeatForever());
Log.Information("Schedule job {Name} with intervall: {Interval}",
jobType.Name,
options.Interval);
}
else
{
triggerBuilder.WithCronSchedule(options.Cron !);
Log.Information("Schedule job {Name} with cron expression: {Cron}",
jobType.Name,
options.Cron);
}
await scheduler.ScheduleJob(jobDetail, triggerBuilder.Build(), cancellationToken);
}
else
{
Log.Information("Job {Name} is not enabled", jobType.Name);
}
}
await scheduler.Start();
}
public BaseResult AddTrigger(AddTriggerInput input)
{
var result = new BaseResult();
try
{
TriggerBuilder triggerBuilder = TriggerBuilder
.Create()
.ForJob(input.Job, input.Group);
if (!string.IsNullOrEmpty(input.Name))
{
triggerBuilder = triggerBuilder.WithIdentity(input.Name);
}
switch (input.TriggerType)
{
case "Simple":
triggerBuilder = triggerBuilder.WithSimpleSchedule(x =>
{
if (input.RepeatForever)
{
x.RepeatForever();
}
else
{
x.WithRepeatCount(input.RepeatCount);
}
x.WithInterval(TimeSpan.FromMilliseconds(input.RepeatInterval));
});
if (!string.IsNullOrEmpty(input.StartDate))
{
var startDate = DateTimeOffset.Parse(input.StartDate);
triggerBuilder.StartAt(startDate);
}
break;
case "Cron":
triggerBuilder = triggerBuilder.WithCronSchedule(input.CronExpression);
break;
default:
throw new ArgumentOutOfRangeException();
}
_schedulerProvider.Scheduler.ScheduleJob(triggerBuilder.Build());
result.Success = true;
}
catch (Exception ex)
{
result.ErrorMessage = ex.Message;
}
return(result);
}
public static ITrigger GetTrigger()
{
//创建一个触发器
TriggerBuilder triggerBuilder = TriggerBuilder.Create();
triggerBuilder.StartNow(); //现在开始
//triggerBuilder.WithCronSchedule("/5 * * ? * *");//时间表达式
triggerBuilder.WithSimpleSchedule(x => x.WithIntervalInSeconds(5).RepeatForever()); //触发时间，5秒一次。
ITrigger jobTrigger = triggerBuilder.Build();
return(jobTrigger);
}
public static void ActivateSchedule(Schedule schedule)
{
TriggerBuilder builder = TriggerBuilder.Create()
.WithIdentity(schedule.GetTriggerKey())
.ForJob(schedule.GetJobKey());
if (schedule.Type == ScheduleType.Daily)
{
builder.WithSimpleSchedule(x => x
.WithIntervalInHours(24)
.WithMisfireHandlingInstructionFireNow()
.RepeatForever()
)
.StartAt(DateBuilder.DateOf(schedule.TimeSpan.Hours, schedule.TimeSpan.Minutes, schedule.TimeSpan.Seconds));
}
else if (schedule.Type == ScheduleType.Hourly)
{
builder.WithSimpleSchedule(x => x
.WithIntervalInHours(1)
.WithMisfireHandlingInstructionFireNow()
.RepeatForever()
)
.StartAt(NextDateForHour(schedule.TimeSpan.Minutes, schedule.TimeSpan.Seconds));
}
else if (schedule.Type == ScheduleType.Minute)
{
builder.WithSimpleSchedule(x => x
.WithIntervalInMinutes(schedule.TimeSpan.Minutes)
.WithMisfireHandlingInstructionFireNow()
.RepeatForever()
)
.StartAt(DateBuilder.DateOf(((DateTime.Now.Minute + schedule.TimeSpan.Minutes > 59) ? DateTime.Now.Hour + 1 : DateTime.Now.Hour) % 24, (DateTime.Now.Minute + schedule.TimeSpan.Minutes) % 60, DateTime.Now.Second));
}
ITrigger trigger = builder.Build();
DefaultScheduler.UnscheduleJob(trigger.Key);
DefaultScheduler.ScheduleJob(trigger);
}
public void TriggerJob(
string jobName,
string jobGroup,
string triggerName,
TriggerType trigger,
IDictionary <string, object> jobData)
{
TriggerBuilder triggerBuilder = TriggerBuilder
.Create()
.ForJob(jobName, jobGroup);
if (!string.IsNullOrEmpty(triggerName))
{
triggerBuilder = triggerBuilder.WithIdentity(triggerName);
}
SimpleTriggerType simpleTrigger = trigger as SimpleTriggerType;
if (simpleTrigger != null)
{
triggerBuilder = triggerBuilder.WithSimpleSchedule(x =>
{
if (simpleTrigger.RepeatCount == -1)
{
x.RepeatForever();
}
else
{
x.WithRepeatCount(simpleTrigger.RepeatCount);
}
x.WithInterval(TimeSpan.FromMilliseconds(simpleTrigger.RepeatInterval));
});
}
else
{
CronTriggerType cronTriggerType = trigger as CronTriggerType;
if (cronTriggerType != null)
{
triggerBuilder = triggerBuilder.WithCronSchedule(cronTriggerType.CronExpression);
}
}
if (jobData != null)
{
triggerBuilder = triggerBuilder.UsingJobData(new JobDataMap(jobData));
}
_scheduler.ScheduleJob(triggerBuilder.Build());
}
//WithSimpleSchedule
private static void Scheduler1()
{
try
{
Console.ReadLine();
//开启日志输出
Common.Logging.LogManager.Adapter = new Common.Logging.Simple.ConsoleOutLoggerFactoryAdapter {
Level = Common.Logging.LogLevel.Info
};
ILog log = LogManager.GetLogger(typeof(Program));
//从计划器工作实例化一个计划实例；
IScheduler scheduler = StdSchedulerFactory.GetDefaultScheduler();
//定义一个job
IJobDetail job = JobBuilder.Create <Job1>()
.WithIdentity("job1", "grop1")
.UsingJobData("jobSays", "Hello World!")
.UsingJobData("myFloatValue", 3.141f)
.Build();
//定义一个trigger
ITrigger trigger = null;
TriggerBuilder triggerBuilder = TriggerBuilder.Create();
triggerBuilder.WithIdentity("trigger1", "group1");
triggerBuilder.StartNow(); //按当前时间立即执行
triggerBuilder.WithSimpleSchedule(x => x.WithIntervalInSeconds(3).RepeatForever()); //每3秒执行，永远重复
trigger = triggerBuilder.Build();
//开始为任务做计划
DateTimeOffset dto = scheduler.ScheduleJob(job, trigger);
// 计划任务开始
scheduler.Start();
// some sleep to show what's happening
//Thread.Sleep(TimeSpan.FromSeconds(2));
// and last shut down the scheduler when you are ready to close your program
//scheduler.Shutdown();
//Console.ReadLine();
}
catch (SchedulerException se)
{
Console.WriteLine(se);
}
}
/// <summary>
/// Adds new job to current Quartz scheduler
/// Job executes at @period with @type units (e.g. 5 Seconds)
/// 5 is the period, Seconds is the unit
/// </summary>
/// <param name="name">Name of job (same as profile)</param>
/// <param name="group">Name of group (name of profile + '_Group')</param>
/// <param name="period">Run Frequency</param>
/// <param name="type">Run Frequency Type</param>
/// <param name="profile">Profile</param>
public static void AddJob(string name, string group, int period, Time type, object profile)
{
// Creating a custom JobDataMap to pass Profile to IJobdetail
IDictionary <string, object> tmpDict = new Dictionary <string, object>();
tmpDict.Add("profile", profile);
JobDataMap jdmIncProfile = new JobDataMap(tmpDict);
// Creating job object
IJobDetail job = JobBuilder.Create <UpdateJob>()
.WithIdentity(name, group)
.SetJobData(jdmIncProfile)
.Build();
// Building trigger, which runs for a duration of @period @type
TriggerBuilder triggerBuild = TriggerBuilder.Create().WithIdentity(name + "_t", group);
switch (type)
{
case Time.Hours:
triggerBuild.WithSimpleSchedule(x => x.WithIntervalInHours(period).RepeatForever());
break;
case Time.Minutes:
triggerBuild.WithSimpleSchedule(x => x.WithIntervalInMinutes(period).RepeatForever());
break;
case Time.Seconds:
triggerBuild.WithSimpleSchedule(x => x.WithIntervalInSeconds(period).WithRepeatCount(10));
break;
}
ITrigger builtTrigger = triggerBuild.Build();
s.ScheduleJob(job, builtTrigger);
}
/// <summary>
/// 两个问题有QuartzModel 有了对象还要这个做什么？二考虑把 QuartzModelList 这个分出去
/// </summary>
public bool Update(string jobName)
{
if (this.QuartzSchedule == null || string.IsNullOrEmpty(jobName))
{
return(false);
}
string dllName = jobName + "QuartzTask.dll";
string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, jobName, dllName);
byte[] assemblyBuf = File.ReadAllBytes(path);
Assembly assembly = Assembly.Load(assemblyBuf);
Type type = assembly.GetType(dllName + "." + jobName);
if (type == null)
{
return(false);
}
object[] objs = type.GetCustomAttributes(typeof(ScanSignal), true);
if (objs != null && objs.Length > 0)
{
JobBase job1 = Activator.CreateInstance(type) as JobBase;
QuartzModel model = null;
ScanSignal customScanSignal = objs[0] as ScanSignal;
if (customScanSignal != null)
{
IJobDetail job = JobBuilder.Create(type)
.WithIdentity(customScanSignal.JobName, QuartzGroupLevel.GetGroupLevelName(customScanSignal.GroupLevel))
.UsingJobData(new JobDataMap(job1.map))
.Build();
TriggerBuilder triggerBuilder = TriggerBuilder.Create()
.WithIdentity(customScanSignal.JobName + "trigger", QuartzGroupLevel.GetGroupLevelName(customScanSignal.GroupLevel))
.StartNow();
if (String.IsNullOrEmpty(customScanSignal.CronExpression))
{
triggerBuilder.WithSimpleSchedule(x => x.WithInterval(customScanSignal.TimeSpan).RepeatForever());
}
else
{
triggerBuilder.WithCronSchedule(customScanSignal.CronExpression);
}
ITrigger trigger = triggerBuilder.Build();
model = new QuartzModel(customScanSignal.JobName, job, trigger);
return(this.QuartzSchedule.UpdateJob(model, model) != null);
}
}
return(false);
}
/// <summary>
/// 根据数据采集计划来创建作业触发器
/// </summary>
/// <param name="jobDetail">采集计划</param>
/// <param name="clMethod">数据采集方法</param>
/// <param name="forJob">将此触发器添加到哪个作业</param>
/// <returns></returns>
public static ITrigger CreateTrigger(ScheduleJob_Details_Triggers trigger, IJobDetail forJob = null)
{
if (trigger == null)
{
throw new ArgumentNullException("『CreateTrigger』的trigger参数为空！");
}
TriggerBuilder builder = TriggerBuilder.Create();
builder =
builder
.WithIdentity(GetTriggerKey(trigger))
.WithDescription(trigger.description);
builder =
trigger.trigger_type.ToUpper() == "cron".ToUpper() ? (
string.IsNullOrEmpty(trigger.cronexpression) ?
builder.WithSimpleSchedule(x => x.WithIntervalInMinutes(string.IsNullOrEmpty(trigger.repeat_interval) ? 30 : int.Parse(trigger.repeat_interval)).WithRepeatCount(string.IsNullOrEmpty(trigger.repeat_count) ? 10 : int.Parse(trigger.repeat_count)))
: builder.WithCronSchedule(trigger.cronexpression)
) : builder.WithSimpleSchedule(x => x.WithIntervalInMinutes(string.IsNullOrEmpty(trigger.repeat_interval) ? 30 : int.Parse(trigger.repeat_interval)).WithRepeatCount(string.IsNullOrEmpty(trigger.repeat_count) ? 10 : int.Parse(trigger.repeat_count)));
if (forJob != null)
{
builder.ForJob(forJob);
}
return(builder.Build());
}
public void Apply(TriggerBuilder builder, TriggerPropertiesViewModel model)
{
builder.WithSimpleSchedule(x =>
{
x.WithInterval(GetRepeatIntervalTimeSpan());
if (RepeatForever)
{
x.RepeatForever();
}
else
{
x.WithRepeatCount(RepeatCount.Value);
}
switch (model.MisfireInstruction)
{
case InstructionNotSet:
break;
case IgnoreMisfirePolicy:
x.WithMisfireHandlingInstructionIgnoreMisfires();
break;
case SimpleTrigger.FireNow:
x.WithMisfireHandlingInstructionFireNow();
break;
case SimpleTrigger.RescheduleNowWithExistingRepeatCount:
x.WithMisfireHandlingInstructionNowWithExistingCount();
break;
case SimpleTrigger.RescheduleNowWithRemainingRepeatCount:
x.WithMisfireHandlingInstructionNowWithRemainingCount();
break;
case SimpleTrigger.RescheduleNextWithRemainingCount:
x.WithMisfireHandlingInstructionNextWithExistingCount();
break;
default:
throw new ArgumentException("Invalid value: " + model.MisfireInstruction, nameof(model.MisfireInstruction));
}
});
}
/// <summary>
/// 创建任务触发器
/// </summary>
/// <param name="job"></param>
/// <param name="group"></param>
/// <returns></returns>
private static ITrigger CeateTrigger(ScheduleJobsInfo job, string group)
{
string triggerName = "trigger_" + job.Id.ToString();
TriggerBuilder triggerBuilder = TriggerBuilder.Create().WithIdentity(triggerName, "trigger_" + group);
if (job.Mode == JobMode.OnlyOnce || job.Mode == JobMode.OnceWhenServieStart)
{
triggerBuilder = triggerBuilder.WithSimpleSchedule(x => x.WithRepeatCount(0)).StartNow();
}
else
{
triggerBuilder = triggerBuilder.WithCronSchedule(job.RunPlan);
}
ITrigger trigger = triggerBuilder.Build();
return(trigger);
}
/// <summary>
/// Утановить интервал для триггера
/// </summary>
/// <param name="triggerBuilder">Билдер триггера</param>
/// <param name="settings">Настройки триггера</param>
/// <returns>Билдер триггера</returns>
public static TriggerBuilder SetInterval(this TriggerBuilder triggerBuilder, TriggerSettings settings)
=> triggerBuilder.WithSimpleSchedule(builder =>
{
switch (settings.IntervalUnit)
{
case IntervalUnit.Millisecond:
builder.WithInterval(TimeSpan.FromMilliseconds(settings.Interval));
break;
case IntervalUnit.Second:
builder.WithIntervalInSeconds(settings.Interval);
break;
case IntervalUnit.Minute:
builder.WithIntervalInMinutes(settings.Interval);
break;
case IntervalUnit.Hour:
builder.WithIntervalInHours(settings.Interval);
break;
case IntervalUnit.Day:
builder.WithInterval(TimeSpan.FromDays(settings.Interval));
break;
case IntervalUnit.Week:
builder.WithInterval(TimeSpan.FromDays(settings.Interval * 7));
break;
case IntervalUnit.Month:
builder.WithInterval(TimeSpan.FromDays(settings.Interval * 30));
break;
case IntervalUnit.Year:
builder.WithInterval(TimeSpan.FromDays(settings.Interval * 365));
break;
default:
throw new ArgumentOutOfRangeException();
}
builder.RepeatForever();
});
public static TriggerBuilder TriggerInterval_(this TriggerBuilder builder,
TimeSpan interval, string name, string group = null, DateTimeOffset?start = null, int?repeat_count = null)
{
builder = builder.WithIdentity_(name, group);
builder = builder.WithSimpleSchedule(x =>
{
x = x.WithIntervalInSeconds((int)interval.TotalSeconds);
if (repeat_count == null)
{
x = x.RepeatForever();
}
else
{
x = x.WithRepeatCount(repeat_count.Value);
}
});
builder = builder.Start_(start);
return(builder);
}
protected override async Task InternalExecute(AddTriggerInput input, CommandResultWithErrorDetails output)
{
TriggerBuilder triggerBuilder = TriggerBuilder
.Create()
.ForJob(input.Job, input.Group);
if (!string.IsNullOrEmpty(input.Name))
{
triggerBuilder = triggerBuilder.WithIdentity(input.Name);
}
switch (input.TriggerType)
{
case "Simple":
triggerBuilder = triggerBuilder.WithSimpleSchedule(x =>
{
if (input.RepeatForever)
{
x.RepeatForever();
}
else
{
x.WithRepeatCount(input.RepeatCount);
}
x.WithInterval(TimeSpan.FromMilliseconds(input.RepeatInterval));
});
break;
case "Cron":
triggerBuilder = triggerBuilder.WithCronSchedule(input.CronExpression);
break;
default:
throw new ArgumentOutOfRangeException();
}
await(await Scheduler().ConfigureAwait(false)).ScheduleJob(triggerBuilder.Build()).ConfigureAwait(false);
}
/// <summary>
/// 创建 Trigger
/// </summary>
/// <param name="jobInfo"></param>
/// <returns></returns>
private ITrigger CreateTrigger(JobInfo jobInfo)
{
TriggerBuilder tiggerBuilder = TriggerBuilder.Create().WithIdentity(jobInfo.JobName, jobInfo.JobGroup);
if (!string.IsNullOrWhiteSpace(jobInfo.Cron))
{
//错过的不管了，剩下的按正常执行。
//tiggerBuilder.WithCronSchedule(jobInfo.Cron, c => c.WithMisfireHandlingInstructionDoNothing());
////错过的合并为一次执行，后续正常执行。
tiggerBuilder.WithCronSchedule(jobInfo.Cron, c => c.WithMisfireHandlingInstructionFireAndProceed());
////错过的马上执行掉，后续正常执行
//tiggerBuilder.WithCronSchedule(jobInfo.Cron, c => c.WithMisfireHandlingInstructionIgnoreMisfires());
}
else
{
tiggerBuilder.WithSimpleSchedule(simple =>
{
//按正常频率执行未执行过的次数
simple.WithIntervalInSeconds(jobInfo.Second).RepeatForever().WithMisfireHandlingInstructionNextWithExistingCount();
});
}
if (jobInfo.StartTime > DateTime.Now)
{
tiggerBuilder.StartAt(jobInfo.StartTime);
}
else
{
tiggerBuilder.StartNow();
}
ITrigger trigger = tiggerBuilder.Build();
return(trigger);
}
private TriggerBuilder SimpleBuilder(TriggerBuilder builder, Jobs jobInfo)
{
builder.WithSimpleSchedule(s =>
{
var interval = jobInfo.TriggerInterval;
var count = jobInfo.Intervals;
if (interval == TriggerInterval.seconds)
{
s.WithIntervalInSeconds(count);
}
else if (interval == TriggerInterval.minutes)
{
s.WithIntervalInMinutes(count);
}
else
{
s.WithIntervalInHours(count);
}
s.RepeatForever();
//哑火策略,当前默认
s.WithMisfireHandlingInstructionNextWithExistingCount();
});
return(builder);
}
public override TriggerBuilder GetSchedule(TriggerBuilder trigger)
{
return(trigger.WithSimpleSchedule(x => x.WithIntervalInSeconds(2).WithRepeatCount(5)));
}
/// <summary>
/// 成功返回true ,false 失败有可能是已经存在或找不到jobname
/// </summary>
/// <param name="jobName"></param>
/// <returns></returns>
public IQuartzTask Add(string jobName)
{
if (this.QuartzSchedule == null || String.IsNullOrWhiteSpace(jobName))
{
return(null);
}
string dllName = jobName + "QuartzTask.dll";
string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, jobName, dllName);
string plugName = string.Concat(jobName, "Plug.txt");
string plugNamepath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, jobName, plugName);
var plugdic = configurationReader.Read(plugNamepath);
byte[] assemblyBuf = File.ReadAllBytes(path);
Assembly assembly = Assembly.Load(assemblyBuf);
Type type = assembly.GetType(Path.GetFileNameWithoutExtension(dllName) + "." + jobName);
if (type.GetInterface("IQuartzService") != null)
{
QuartzModel model = null;
AssemblyDynamicLoader dyNamicLoader = new AssemblyDynamicLoader(jobName);
dyNamicLoader.LoadAssembly(path);
TaskBase task = new TaskBase();
IDictionary <string, object> dic = task.map;
dic.Add("DyNamicLoader", dyNamicLoader);
dic.Add("DyNamicMethod", Path.GetFileNameWithoutExtension(dllName) + "." + jobName);
string timePression = "";
long timelongPression = 1000;
bool bl = false;
bl = plugdic.TryGetValue("CRONEXPRESSION", out timePression);
if (!bl)
{
if (plugdic.TryGetValue("TIMESPAN", out timePression))
{
if (!long.TryParse(timePression, out timelongPression))
{
timePression = "1000";
}
}
}
IJobDetail job = JobBuilder.Create(task.GetType())
.WithIdentity(plugdic["JOBNAME"], plugdic["GROUPNAME"])
.UsingJobData(new JobDataMap(dic))
.Build();
TriggerBuilder triggerBuilder = TriggerBuilder.Create()
.WithIdentity(plugdic["JOBNAME"] + "TRIGGER", plugdic["GROUPNAME"])
.StartNow();
if (bl)
{
triggerBuilder.WithCronSchedule(timePression);
}
else
{
triggerBuilder.WithSimpleSchedule
(x => x.WithInterval(new TimeSpan(timelongPression))
.RepeatForever());
}
ITrigger trigger = triggerBuilder.Build();
model = new QuartzModel(plugdic["JOBNAME"], job, trigger);
if (!this.QuartzSchedule.CheckExists(model))
{
this.QuartzSchedule.AddJob(model);
}
}
return(null);
}
internal void ScanQuartzExterior()
{
string runroot = AppDomain.CurrentDomain.BaseDirectory;
var subDir = Directory.GetDirectories(runroot);
foreach (var dir in subDir)
{
var dinfo = new DirectoryInfo(dir);
string dllName = string.Concat(dinfo.Name, "QuartzTask.dll");
string path = Path.Combine(dir, dllName);
string plugName = string.Concat(dinfo.Name, "Plug.txt");
string plugNamepath = Path.Combine(dir, plugName);
if (!File.Exists(plugNamepath))
{
continue;
}
var plugdic = configurationReader.Read(plugNamepath);
try
{
byte[] assemblyBuf = File.ReadAllBytes(path);
Assembly assembly = Assembly.Load(assemblyBuf);
Type[] types = assembly.GetTypes();
foreach (var item in types)
{
if (item.GetInterface("IQuartzService") != null)
{
QuartzModel model = null;
AssemblyDynamicLoader dyNamicLoader = new AssemblyDynamicLoader(dinfo.Name);
dyNamicLoader.LoadAssembly(path);
TaskBase task = new TaskBase();
IDictionary <string, object> dic = task.map;
dic.Add("DyNamicLoader", dyNamicLoader);
dic.Add("DyNamicMethod", Path.GetFileNameWithoutExtension(dllName) + "." + dinfo.Name);
string timePression = "";
int timelongPression = 1000;
bool bl = false;
bl = plugdic.TryGetValue("CRONEXPRESSION", out timePression);
if (!bl)
{
if (plugdic.TryGetValue("TIMESPAN", out timePression))
{
if (!int.TryParse(timePression, out timelongPression))
{
timePression = "1000";
}
}
}
IJobDetail job = JobBuilder.Create(task.GetType())
.WithIdentity(plugdic["JOBNAME"], plugdic["GROUPNAME"])
.UsingJobData(new JobDataMap(dic))
.Build();
TriggerBuilder triggerBuilder = TriggerBuilder.Create()
.WithIdentity(plugdic["JOBNAME"] + "TRIGGER", plugdic["GROUPNAME"])
.StartNow();
if (bl)
{
triggerBuilder.WithCronSchedule(timePression);
}
else
{
triggerBuilder.WithSimpleSchedule
(x => x.WithInterval(new TimeSpan(0, 0, 0, 0, timelongPression))
.RepeatForever());
}
ITrigger trigger = triggerBuilder.Build();
model = new QuartzModel(plugdic["JOBNAME"], job, trigger);
if (!this.QuartzSchedule.CheckExists(model))
{
this.QuartzSchedule.AddJob(model);
}
}
}
}
catch (Exception oe)
{
Debug.WriteLine(oe.Message);
}
}
}
public IQuartzTask Add(PlugModel plug)
{
if (this.QuartzSchedule == null || plug == null)
{
return(null);
}
string runroot = AppDomain.CurrentDomain.BaseDirectory;
string path = Path.Combine(
runroot,
plug.DllRelativeDir,
plug.DllIQuartzServiceImplementFile
);
if (!File.Exists(path))
{
throw new ArgumentException("找不到需要载入的目录或文件", path);
}
byte[] assemblyBuf = File.ReadAllBytes(path);
Assembly assembly = null;
if (assemblyBuf.Length > 0)
{
assembly = Assembly.Load(assemblyBuf);
}
else
{
return(null);
}
Type[] types = assembly.GetTypes();
try
{
foreach (var type in types)
{
if (type.GetInterface("IQuartzService") != null)
{
QuartzModel model = null;
AssemblyDynamicLoader dyNamicLoader = new AssemblyDynamicLoader(plug.DllRelativeDir);
dyNamicLoader.LoadAssembly(path);
TaskBase task = new TaskBase();
IDictionary <string, object> dic = task.map;
dic.Add("DyNamicLoader", dyNamicLoader);
dic.Add("DyNamicMethod", type.FullName);
IJobDetail job = JobBuilder.Create(task.GetType())
.WithIdentity(plug.JobName, plug.GroupName)
.UsingJobData(new JobDataMap(dic))
.Build();
TriggerBuilder triggerBuilder = TriggerBuilder.Create()
.WithIdentity(plug.JobName + "Trigger", plug.GroupName)
.StartNow();
if (!string.IsNullOrEmpty(plug.CronexPression))
{
triggerBuilder.WithCronSchedule(plug.CronexPression);
}
else
{
triggerBuilder.WithSimpleSchedule
(x => x.WithInterval(new TimeSpan(0, 0, 0, 0, plug.TimeSpan))
.RepeatForever());
}
ITrigger trigger = triggerBuilder.Build();
model = new QuartzModel(plug.JobName, job, trigger);
return(Add(model));
}
}
}
catch (Exception oe)
{
Debug.WriteLine(oe.Message);
}
return(null);
}
public async Task CreateOrUpdate(JobCreateOrUpdateRequest request)
{
request.Name = request.Name.Trim();
request.Group = request.Group.Trim();
JobKey key = new JobKey(request.Name, request.Group);
if (await _scheduler.CheckExists(key))
{
if (!request.IsUpdate)
{
throw new Exception("已存在相同名称的任务"); // 新增时，存在相同任务，不创建
}
else
{
await _scheduler.DeleteJob(key); // 更新时，先删除，再创建
}
}
;
/******Data*****/
JobDataMap dataMap = new JobDataMap();
dataMap.Put(DataKeys.HttpMethod, request.HttpMethod);
dataMap.Put(DataKeys.RequestUrl, request.RequestUrl);
dataMap.Put(DataKeys.TriggerType, request.TriggerType);
dataMap.Put(DataKeys.RepeatCount, request.RepeatCount);
dataMap.Put(DataKeys.Interval, request.Interval);
dataMap.Put(DataKeys.IntervalType, request.IntervalType);
dataMap.Put(DataKeys.Cron, request.Cron);
dataMap.Put(DataKeys.RequestBody, request.RequestBody);
dataMap.Put(DataKeys.CreateTime, DateTime.Now.ToString());
dataMap.Put(DataKeys.StartTime, request.StartTime.ToString());
dataMap.Put(DataKeys.EndTime, request.EndTime.HasValue ? request.EndTime.Value.ToString() : string.Empty);
/******Job*****/
IJobDetail job = JobBuilder.Create <HttpJob>()
.StoreDurably(true) // 是否持久化， 无关联触发器时是否移除，false：移除
.RequestRecovery() // 重启后是否恢复任务
.WithDescription(request.Description ?? string.Empty)
.WithIdentity(request.Name, request.Group)
.UsingJobData(dataMap)
.Build();
/******Trigger*****/
TriggerBuilder builder = TriggerBuilder.Create()
.WithIdentity(request.Name, request.Group)
.StartAt(request.StartTime.Value)
.ForJob(job);
if (request.EndTime.HasValue)
{
builder.EndAt(request.EndTime.Value);
}
if (request.TriggerType == (int)TriggerTypeEnum.Simple)
{
builder.WithSimpleSchedule(simple =>
{
if (request.IntervalType == (int)IntervalTypeEnum.Second)
{
simple.WithIntervalInSeconds(request.Interval);
}
if (request.IntervalType == (int)IntervalTypeEnum.Minute)
{
simple.WithIntervalInMinutes(request.Interval);
}
if (request.IntervalType == (int)IntervalTypeEnum.Hour)
{
simple.WithIntervalInHours(request.Interval);
}
if (request.IntervalType == (int)IntervalTypeEnum.Day)
{
simple.WithIntervalInHours(request.Interval * 24);
}
if (request.RepeatCount > 0)
{
simple.WithRepeatCount(request.RepeatCount);
}
else
{
simple.RepeatForever();
}
simple.WithMisfireHandlingInstructionFireNow(); // 如果延迟执行了
});
}
else
{
builder.WithCronSchedule(request.Cron, cron =>
{
cron.WithMisfireHandlingInstructionFireAndProceed();
});
}
ITrigger trigger = builder.Build();
await _scheduler.ScheduleJob(job, trigger); // 加入调度，并持久化
FlushCache();
}
private static void ScheduleJobs()
{
int priority = Jobs.Count;
foreach (var tsk in Jobs.Where(x => x.TaskType == "S" && x.Status == "Queued")) // O - On Demand ; S- Scheduled.
{
var schedule = Schedules.FirstOrDefault(x => x.taskID == tsk.taskID);
var client = Machines.FirstOrDefault(x => x.ID == tsk.ClientID);
IJobDetail job = JobBuilder.Create <Job>().WithIdentity(tsk.TaskName, tsk.ClientID.ToString()).Build();
job.JobDataMap["command"] = tsk.Command;
job.JobDataMap["taskname"] = tsk.TaskName;
job.JobDataMap["TaskId"] = tsk.taskID;
if (client != null)
{
job.JobDataMap["remotepc"] = "\\\\" + client.HostName;
job.JobDataMap["username"] = client.Username;
job.JobDataMap["password"] = client.Password;
}
if (schedule != null)
{
TriggerBuilder tb = TriggerBuilder.Create();
tb.WithIdentity(tsk.TaskName);
if (schedule.repeatforever <= 0)
{
tb.WithSimpleSchedule(a => a.WithIntervalInHours(schedule.intHours));
tb.WithSimpleSchedule(a => a.WithIntervalInSeconds(schedule.intSec));
tb.WithSimpleSchedule(a => a.WithIntervalInMinutes(schedule.intMin));
}
else
{
if (schedule.intHours > 0)
{
tb.WithSimpleSchedule(a => a.WithIntervalInHours(schedule.intHours).RepeatForever());
}
if (schedule.intHours > 0)
{
tb.WithSimpleSchedule(a => a.WithIntervalInSeconds(schedule.intSec).RepeatForever());
}
if (schedule.intHours > 0)
{
tb.WithSimpleSchedule(a => a.WithIntervalInMinutes(schedule.intMin).RepeatForever());
}
}
if (schedule.startAt != null)
{
tb.StartAt(new DateTimeOffset((DateTime)schedule.startAt));
}
if (schedule.endAt != null)
{
tb.EndAt(new DateTimeOffset((DateTime)schedule.endAt));
}
tb.ForJob(job);
ITrigger trigger = tb.Build();
Scheduler.ScheduleJob(job, trigger);
}
}
}
public void AddJob(JobInfo jobInfo)
{
if (string.IsNullOrEmpty(jobInfo.JobName) || string.IsNullOrEmpty(jobInfo.GroupName))
{
throw new Exception("job名称与组名都不能为空");
}
if (jobInfo.StartTime < new DateTime(1900, 1, 1))
{
throw new Exception("开始时间不正确");
}
if (string.IsNullOrEmpty(jobInfo.FileName) || string.IsNullOrEmpty(jobInfo.ClassName))
{
throw new Exception("程序集地址和类名都不能为空");
}
// 反射获取job实例
Assembly assembly = Consts.GetAssembly(jobInfo.FileName);
BaseJob job = assembly.CreateInstance(jobInfo.ClassName) as BaseJob;
if (job == null)
{
throw new Exception("无法实例化job类");
}
JobBuilder jobBuilder = null;
if (jobInfo.CanConcurrent)
{
jobBuilder = JobBuilder.Create <HostJob>(); // 可以多线程
}
else
{
jobBuilder = JobBuilder.Create <HostJob>(); // 不能多线程
}
IJobDetail innerJob = jobBuilder
.WithIdentity(jobInfo.JobName, jobInfo.GroupName)
.UsingJobData(Consts.JobParameter, jobInfo.Parameter)
.UsingJobData(Consts.JobAssemblyPath, jobInfo.FileName)
.UsingJobData(Consts.JobClassName, jobInfo.ClassName)
.RequestRecovery(true)
.Build();
TriggerBuilder builder = TriggerBuilder.Create().WithIdentity(jobInfo.JobName, jobInfo.GroupName);
if (jobInfo.RepeatMode == RepeatModeEnum.Interval)
{
if (jobInfo.Interval <= 0)
{
throw new Exception("时间间隔必须大于0");
}
switch (jobInfo.CycleUnit)
{
case CycleUnitEnum.Day:
builder = builder.WithSimpleSchedule(x => x.WithIntervalInHours(24 * jobInfo.Interval).RepeatForever().WithMisfireHandlingInstructionIgnoreMisfires());
break;
case CycleUnitEnum.Hour:
builder = builder.WithSimpleSchedule(x => x.WithIntervalInHours(jobInfo.Interval).RepeatForever().WithMisfireHandlingInstructionIgnoreMisfires());
break;
case CycleUnitEnum.Minute:
builder = builder.WithSimpleSchedule(x => x.WithIntervalInMinutes(jobInfo.Interval).RepeatForever().WithMisfireHandlingInstructionIgnoreMisfires());
break;
case CycleUnitEnum.Second:
builder = builder.WithSimpleSchedule(x => x.WithIntervalInSeconds(jobInfo.Interval).RepeatForever().WithMisfireHandlingInstructionIgnoreMisfires());
break;
}
}
else if (jobInfo.RepeatMode == RepeatModeEnum.FixedTime)
{
if (string.IsNullOrEmpty(jobInfo.FixedExpression))
{
throw new Exception("Job按固定时间配置时，固定时间的表达式不能为空");
}
var expression = string.Empty;
var fixedExs = jobInfo.FixedExpression.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
var localParts = fixedExs[0].Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
switch (jobInfo.FixedUnit)
{
case FixedUnitEnum.Day:
var localMinute = Convert.ToInt32(localParts[1]);
var localSecond = Convert.ToInt32(localParts[2]);
var localHourList = new List <int>();
foreach (var item in fixedExs)
{
localParts = item.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
localHourList.Add(Convert.ToInt32(localParts[0]));
}
var localHours = string.Join(",", localHourList);
expression = string.Format("{0} {1} {2} * * ?", localSecond, localMinute, localHours);
break;
case FixedUnitEnum.Hour:
localSecond = Convert.ToInt32(localParts[1]);
var localMinuteList = new List <int>();
foreach (var item in fixedExs)
{
localParts = item.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
localMinuteList.Add(Convert.ToInt32(localParts[0]));
}
var localMinutes = string.Join(",", localMinuteList);
expression = string.Format("{0} {1} * * * ?", localSecond, localMinutes);
break;
}
builder = builder.WithCronSchedule(expression,
x => x.WithMisfireHandlingInstructionIgnoreMisfires().InTimeZone(TimeZoneInfo.Local));
}
else if (jobInfo.RepeatMode == RepeatModeEnum.CronExp)
{
builder = builder.WithCronSchedule(jobInfo.FixedExpression,
x => x.WithMisfireHandlingInstructionIgnoreMisfires().InTimeZone(TimeZoneInfo.Local));
}
if (jobInfo.StartTime < DateTime.Now.AddMinutes(1))
{
jobInfo.StartTime = DateTime.Now.AddMinutes(1);
}
builder.StartAt(jobInfo.StartTime);
ITrigger trigger = builder.Build();
HostScheduler.RegisterJob(innerJob, trigger);
}
