public void Apply(TriggerBuilder builder, TriggerPropertiesViewModel model)
{
builder.WithCronSchedule(Expression, x =>
{
if (!string.IsNullOrEmpty(TimeZone))
{
x.InTimeZone(TimeZoneInfo.FindSystemTimeZoneById(TimeZone));
}
switch (model.MisfireInstruction)
{
case InstructionNotSet:
break;
case IgnoreMisfirePolicy:
x.WithMisfireHandlingInstructionIgnoreMisfires();
break;
case CronTrigger.DoNothing:
x.WithMisfireHandlingInstructionDoNothing();
break;
case CronTrigger.FireOnceNow:
x.WithMisfireHandlingInstructionFireAndProceed();
break;
default:
throw new ArgumentException("Invalid value: " + model.MisfireInstruction, nameof(model.MisfireInstruction));
}
});
}
protected override void OnStart(string[] args)
{
string DateNow, DateNext;
base.OnStart(args);
if (Scheduler == null)
{
Scheduler = StdSchedulerFactory.GetDefaultScheduler();
}
Scheduler.Start();
TriggerBuilder Builder = TriggerBuilder.Create();
Builder = Builder.WithCronSchedule(AutoOrderEmail_CronExpr, (CronSchBuilder) => {
CronSchBuilder.InTimeZone(TimeZoneInfo.Utc);
CronSchBuilder.WithMisfireHandlingInstructionFireAndProceed();
});
ITrigger AutoEmailTrigger = Builder.Build();
IJobDetail AutoOrderEmailJob = JobBuilder.Create(typeof(TranslatorOfferEmailJob)).Build();
AutoOrderEmailJob.JobDataMap["ServiceLog"] = this.ServiceLog;
Scheduler.ScheduleJob(AutoOrderEmailJob, AutoEmailTrigger);
DateNow = DateTime.UtcNow.ToString("F");
DateNext = AutoEmailTrigger.GetNextFireTimeUtc().Value.DateTime.ToString("F");
ServiceLog.WriteEntry(string.Format(FRMT_INIT, DateNow, DateNext), EventLogEntryType.Information);
if (this.ServiceLog.MaximumKilobytes < 51200)
{
this.ServiceLog.MaximumKilobytes = 51200; // Set our custom EventLog size to 50MB
}
}
/// <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);
}
private ITrigger CreateTrigger(Customer_JobInfo jobInfo)
{
TriggerBuilder tiggerBuilder = TriggerBuilder.Create().WithIdentity(jobInfo.JobName, jobInfo.JobGroupName);
//错过的不管了，剩下的按正常执行。
//tiggerBuilder.WithCronSchedule(jobInfo.Cron, c => c.WithMisfireHandlingInstructionDoNothing());
////错过的合并为一次执行，后续正常执行。
tiggerBuilder.WithCronSchedule(jobInfo.Cron, c => c.WithMisfireHandlingInstructionFireAndProceed());
////错过的马上执行掉，后续正常执行
//tiggerBuilder.WithCronSchedule(jobInfo.Cron, c => c.WithMisfireHandlingInstructionIgnoreMisfires());
//if (jobInfo.StartTime > DateTime.Now)
//{
// tiggerBuilder.StartAt(jobInfo.StartTime);
//}
//else
//{
// tiggerBuilder.StartNow();
//}
ITrigger trigger = tiggerBuilder.Build();
return(trigger);
}
/// <summary>
/// 设置Cron表达式
/// </summary>
private void SetCron(TriggerBuilder builder, JobBase job)
{
if (job.GetCron() == null)
{
return;
}
builder.WithCronSchedule(job.GetCron());
}
public static TriggerBuilder MonthlyTriggerOnDay(this TriggerBuilder builder,
TimeOfDay fireTime,
int dayOfMonth,
int ofEvery)
{
builder.WithCronSchedule($"{fireTime.Second} {fireTime.Minute} {fireTime.Hour} {dayOfMonth} 1/{ofEvery} ? *");
return(builder);
}
public static TriggerBuilder WithCronScheduleNowIfEmpty(this TriggerBuilder triggerBuilder, string cronExpression)
{
if (string.IsNullOrWhiteSpace(cronExpression))
{
return(triggerBuilder.StartNow());
}
return(triggerBuilder.WithCronSchedule(cronExpression));
}
private ITrigger EveryDayOneTimeAt(TimeOfDay timeOfDay)
{
TriggerBuilder triggerBuilder = TriggerBuilder.Create();
triggerBuilder.WithCronSchedule(String.Format("0 {0} {1} ? * *", timeOfDay.Minute, timeOfDay.Hour));
return(triggerBuilder.Build());
}
private TriggerBuilder CronBuilder(TriggerBuilder builder, Jobs jobInfo)
{
//MisfireInstruction.CalendarIntervalTrigger.DoNothing;
string cron = jobInfo.CronExpression;
builder.WithCronSchedule(cron);
//https://www.cnblogs.com/yaopengfei/p/8542771.html
return(builder);
}
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);
}
/// <summary>
/// 创建CronTrigger
/// </summary>
/// <returns></returns>
public static ICronTrigger CreateCronTrigger(TriggerItem triggerItem)
{
TriggerBuilder triggerBuilder = TriggerBuilder.Create();
if (!string.IsNullOrEmpty(triggerItem.StartTime))
{
triggerBuilder = triggerBuilder.StartAt(Convert.ToDateTime(triggerItem.StartTime));
}
if (!string.IsNullOrEmpty(triggerItem.EndTime))
{
triggerBuilder = triggerBuilder.EndAt(Convert.ToDateTime(triggerItem.EndTime));
}
triggerBuilder = triggerBuilder.WithCronSchedule(triggerItem.CronExpression);
ICronTrigger trigger = (ICronTrigger)triggerBuilder
.WithCronSchedule(triggerItem.CronExpression)
.WithIdentity(triggerItem.Name, triggerItem.Group)
.Build();
return(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());
}
/// <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);
}
private ITrigger CreateTrigger(JobInfo jobInfo)
{
TriggerBuilder triggerBuilder = TriggerBuilder.Create().WithIdentity(jobInfo.JobName, jobInfo.JobGroup);
if (!string.IsNullOrEmpty(jobInfo.Crons))
{
//失火策略
triggerBuilder.WithCronSchedule(jobInfo.Crons);
}
triggerBuilder.StartNow();
ITrigger trigger = triggerBuilder.Build();
return(trigger);
}
/// <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);
}
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>
/// 开始工作。
/// </summary>
/// <param name="configuration">工作相关配置</param>
public void StartWork(SingleConfiguration configuration)
{
if (_jobNames.Contains(configuration.name))
{
string newName = configuration.name + Guid.NewGuid().ToString("N");
Log.Warn(string.Format("已存在名为\"{0}\"的任务，当前任务将改名为\"{1}\"。", configuration.name, newName));
configuration.name = newName;
}
_jobNames.Add(configuration.name);
if (configuration.crontab == null || configuration.crontab.Count == 0)
{
throw new ArgumentException(string.Format("任务\"{0}\"的crontab字段为空。", configuration.name));
}
JobDataMap map = new JobDataMap
{
[ConfKey] = configuration
};
IJobDetail job = JobBuilder.Create <BackupWorker>()
.WithIdentity("job_" + configuration.name, _groupName)
.UsingJobData(map)
.Build();
TriggerBuilder triggerBuilder = TriggerBuilder.Create()
.WithIdentity("trigger_" + configuration.name, _groupName)
.StartNow();
foreach (var i in configuration.crontab)
{
triggerBuilder.WithCronSchedule(i);
}
ITrigger trigger = triggerBuilder.Build();
_scheduler.ScheduleJob(job, trigger);
}
/// <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);
}
/// <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());
}
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 TriggerHelper WithCronSchedule(string cronExpression)
{
trigger.WithCronSchedule(cronExpression);
return(this);
}
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 void scheduleTask(ScheduledTask task)
{
if (!string.IsNullOrEmpty(task.ServerName) && task.ServerName.ToLower(CultureInfo.GetCultureInfo("en-US")) != System.Environment.MachineName.ToLower(CultureInfo.GetCultureInfo("en-US")))
{
return;
}
JobKey jobKey = new JobKey(task.Name);
if (!task.Enabled)
{
if (_scheduler.CheckExists(jobKey))
{
_scheduler.DeleteJob(jobKey);
}
return;
}
TriggerKey triggerkey = new TriggerKey(string.Format("{0}_trigger", task.Name));
TriggerBuilder triggerBuilder = null;
if (!_scheduler.CheckExists(triggerkey))
{
triggerBuilder = TriggerBuilder.Create().WithIdentity(triggerkey);
}
else
{
ICronTrigger oldTrigger = (ICronTrigger)_scheduler.GetTrigger(triggerkey);
if (oldTrigger.CronExpressionString == task.CronExpression)
{
return;
}
triggerBuilder = oldTrigger.GetTriggerBuilder();
}
TimeZoneInfo timeZoneInfo = TimeZoneInfo.FindSystemTimeZoneById(PxConfigurationManager.PxConfig.Schedule.TimeZoneId);
switch (task.MissedScheduleAction)
{
case MissedScheduleActionType.RunLatest:
triggerBuilder = triggerBuilder.WithCronSchedule(task.CronExpression, x => x.InTimeZone(timeZoneInfo).WithMisfireHandlingInstructionFireAndProceed());
break;
case MissedScheduleActionType.RunAll:
triggerBuilder = triggerBuilder.WithCronSchedule(task.CronExpression, x => x.InTimeZone(timeZoneInfo).WithMisfireHandlingInstructionIgnoreMisfires());
break;
case MissedScheduleActionType.NoAction:
default:
triggerBuilder = triggerBuilder.WithCronSchedule(task.CronExpression, x => x.InTimeZone(timeZoneInfo).WithMisfireHandlingInstructionDoNothing());
break;
}
if (task.StartDate != null && (DateTime)task.StartDate != DateTime.MinValue)
{
triggerBuilder = triggerBuilder.StartAt(new DateTimeOffset(task.StartDate.Value));
}
else
{
triggerBuilder = triggerBuilder.StartAt(new DateTimeOffset(DateTime.Now));
}
if (task.EndDate != null && (DateTime)task.EndDate != DateTime.MinValue)
{
triggerBuilder = triggerBuilder.EndAt(new DateTimeOffset((DateTime)task.EndDate));
}
IJobDetail job = JobBuilder.Create <PxScheduledTask>().WithIdentity(jobKey).RequestRecovery().Build();
job.JobDataMap.Put("ScheduledTask", task);
ICronTrigger trigger = (ICronTrigger)triggerBuilder.ForJob(job).Build();
if (!_scheduler.CheckExists(triggerkey))
{
_scheduler.ScheduleJob(job, trigger);
}
else
{
_scheduler.RescheduleJob(triggerkey, trigger);
}
}
/// <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);
}
/// <summary>
/// 初始化并启动
/// </summary>
public void Startup()
{
Task.Run(async() => {
NameValueCollection props = new NameValueCollection
{
{ "quartz.serializer.type", "binary" }
};
_factory = new StdSchedulerFactory(props);
_scheduler = await _factory.GetScheduler();
_scheduler.Context.Add("IServiceProvider", _provider);
await _scheduler.Start();
//读取数据库中所有定时任务
var tasks = await _service.GetListAsync(new Domain.Entity.System.TimedTaskSearch {
IsDeleted = false
}, null);
//加载程序集
assemblies = tasks.Select(x => x.AssemblyName).Distinct().Select(name => AssemblyLoadContext.Default.LoadFromAssemblyName(new AssemblyName(name))).ToList();
foreach (var task in tasks.Where(x => x.Status != Domain.Enum.System.EmTimedTaskStatus.Disable && x.Status != Domain.Enum.System.EmTimedTaskStatus.Expired))
{
//处理过期任务
if (task.ValidEndTime < DateTime.Now)
{
await _service.UpdateTaskStatusAsync(task.Id, new {
Status = Domain.Enum.System.EmTimedTaskStatus.Expired
});
continue;
}
var assembly = assemblies.FirstOrDefault(x => x.FullName.Split(',')[0].Equals(task.AssemblyName));
if (assembly == null)
{
//未正确加载程序集
await _service.UpdateTaskStatusAsync(task.Id, new
{
Status = Domain.Enum.System.EmTimedTaskStatus.Abnormal
});
continue;
}
var type = assembly.DefinedTypes.FirstOrDefault(x => x.FullName.Equals(task.TypeName));
if (type == null)
{
//未正确加载类型
await _service.UpdateTaskStatusAsync(task.Id, new
{
Status = Domain.Enum.System.EmTimedTaskStatus.Abnormal
});
continue;
}
// 定义一个 Job
IJobDetail job = JobBuilder.Create(type)
.WithIdentity(task.Name, task.Group)
.UsingJobData("TaskId", task.Id)
.Build();
// 定义一个触发器
TriggerBuilder builder = TriggerBuilder.Create().WithIdentity(task.Name, task.Group);
if (task.ValidStartTime <= DateTime.Now)
{
builder = builder.StartNow();
}
else
{
builder = builder.StartAt(task.ValidStartTime);
}
builder = builder.EndAt(task.ValidEndTime);
//Cron
builder = builder.WithCronSchedule(task.Cron);
ITrigger trigger = builder.Build();
//加入Job
await _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);
}
/// <summary>
/// 执行JOB 用于检查Job_Info表
/// </summary>
/// <param name="context"></param>
public void Execute(IJobExecutionContext context)
{
Log4NetHelper.Info("开始获取JobInfo", logger: logger);
try
{
List <Job_Info> jobList = new JobInfoBLL().GetJobList();
if (jobList != null && jobList.Count > 0)
{
JobKey jobKey = null;
foreach (var jobinfo in jobList)
{
jobKey = new JobKey(jobinfo.Job_name + JobConfig.JOBKEY_NAMEEND, "group1");
//只有正常执行状态的Job才添加到调度器中
if (!JobConfig.scheduler.CheckExists(jobKey) && jobinfo.Job_state == 0)
{
IJobDetail job = JobBuilder.Create <RunTaskDLLJob>().WithIdentity(jobKey).Build();
//创建触发器
TriggerBuilder tb = TriggerBuilder.Create()
.WithIdentity(jobinfo.Job_name + JobConfig.JOBTRIGGER_NAMEEND, "group1");
if (!string.IsNullOrEmpty(jobinfo.Job_corn))
{
tb.WithCronSchedule(jobinfo.Job_corn); //执行corn表达式
}
if (jobinfo.Job_execount > 0) //如果执行固定的次数
{
tb.WithSimpleSchedule(a => a.WithRepeatCount(jobinfo.Job_execount));
}
if (jobinfo.Job_starttime != null && jobinfo.Job_starttime > DateTime.Now)//设置Job启动时间
{
tb.StartAt(jobinfo.Job_starttime);
}
else
{
tb.StartNow();
}
ITrigger trigger = tb.Build();
//传递参数
job.JobDataMap.Add(jobKey.Name, jobinfo.Id);
JobConfig.scheduler.ScheduleJob(job, trigger);
Log4NetHelper.Info(string.Format("加入Job:{0}成功", jobKey.Name), logger: logger);
}
else if (JobConfig.scheduler.CheckExists(jobKey))
{
if (jobinfo.Job_state == 2 || jobinfo.Job_state == 3)
{
JobConfig.scheduler.PauseJob(jobKey);
Log4NetHelper.Info(string.Format("暂停Job:{0}成功", jobKey.Name), logger: logger);
}
else if (jobinfo.Job_state == 4)
{
JobConfig.scheduler.DeleteJob(jobKey);
Log4NetHelper.Info(string.Format("删除Job:{0}成功", jobKey.Name), logger: logger);
}
}
}
}
}
catch (Exception ex)
{
Log4NetHelper.Info(string.Format("LoopJob异常：{0},{1},{2}", ex.Message, ex.InnerException, ex.StackTrace), logger: logger);
}
Log4NetHelper.Info("结束获取JobInfo", logger: logger);
}
