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 async Task <JobKey> ScheduleJob <T>(DateTimeOffset?startAtTime = null, JobKey?vncCheckerJobKey = null)
where T : class, IJob
{
IScheduler scheduler = await StdSchedulerFactory.GetDefaultScheduler();
await scheduler.Start();
IJobDetail jobDetail = JobBuilder.Create <T>().Build();
ITrigger trigger;
TriggerBuilder triggerBuilder = TriggerBuilder.Create().StartNow()
.WithSimpleSchedule(x => x.WithIntervalInSeconds(Constants.JobEecutionIntervalSec)
.RepeatForever());
if (vncCheckerJobKey != null)
{
triggerBuilder = triggerBuilder.UsingJobData(nameof(Checker), vncCheckerJobKey.Name);
}
if (startAtTime != null)
{
trigger = triggerBuilder.StartAt((DateTimeOffset)startAtTime).Build();
}
else
{
trigger = triggerBuilder.StartNow().Build();
}
await scheduler.ScheduleJob(jobDetail, trigger);
return(jobDetail.Key);
}
/// <summary>
/// 开启任务
/// </summary>
public void Start()
{
ISchedulerFactory factory = new StdSchedulerFactory();
IScheduler scheduler = factory.GetScheduler().Result;
foreach (TaskInfo info in tasks)
{
if (info.IsEnabled)
{
Type type = Type.GetType(info.TaskType);
if (type != null)
{
string name = type.Name + "_trigger";
IJobDetail jobDetail = JobBuilder.Create(typeof(QuartzTask)).WithIdentity(type.Name).Build();
jobDetail.JobDataMap.Add(new KeyValuePair <string, object>("Id", info.Id));
TriggerBuilder builder = TriggerBuilder.Create().WithIdentity(name).WithCronSchedule(info.TaskRule);
if (info.StartDate > DateTime.MinValue)
{
builder.StartAt(new DateTimeOffset(info.StartDate));
}
DateTime?endDate = info.EndDate;
DateTime startDate = info.StartDate;
if (endDate.HasValue ? (endDate.GetValueOrDefault() > startDate) : false)
{
DateTime?nullable2 = info.EndDate;
builder.EndAt(nullable2.HasValue ? new DateTimeOffset?(nullable2.GetValueOrDefault()) : null);
}
ICronTrigger trigger = (ICronTrigger)builder.Build();
DateTime dateTime = scheduler.ScheduleJob(jobDetail, trigger).Result.DateTime;
info.NextDate = new DateTime?(TimeZoneInfo.ConvertTime(dateTime, trigger.TimeZone));
}
}
}
scheduler.Start();
}
public static TriggerBuilder Start_(this TriggerBuilder builder, DateTimeOffset?when = null)
{
var res = when == null?
builder.StartNow() :
builder.StartAt(when.Value);
return(res);
}
public static TriggerBuilder TriggerDuration(this TriggerBuilder builder,
DateTimeOffset startTime,
DateTimeOffset?endTime = null)
{
builder
.StartAt(startTime)
.EndAt(endTime);
return(builder);
}
/// <summary>
/// 设置作业开始时间
/// </summary>
private void SetStartTime(TriggerBuilder builder, JobBase job)
{
if (job.GetStartTime() == null)
{
builder.StartNow();
return;
}
builder.StartAt(job.GetStartTime().SafeValue());
}
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>
/// 启动任务
/// </summary>
public void Start()
{
if (_tasks.Count() == 0)
{
return;
}
TaskService taskService = new TaskService();
ISchedulerFactory sf = new StdSchedulerFactory();
IScheduler sched = sf.GetScheduler();
foreach (var task in _tasks)
{
if (!task.Enabled)
{
continue;
}
Type type = Type.GetType(task.ClassType);
if (type == null)
{
continue;
}
string triggerName = type.Name + "_trigger";
IJobDetail job = JobBuilder.Create(typeof(QuartzTask))
.WithIdentity(type.Name)
.Build();
job.JobDataMap.Add(new KeyValuePair <string, object>("Id", task.Id));
TriggerBuilder tb = TriggerBuilder.Create()
.WithIdentity(triggerName)
.WithCronSchedule(task.TaskRule);
if (task.StartDate > DateTime.MinValue)
{
tb.StartAt(new DateTimeOffset(task.StartDate));
}
if (task.EndDate > task.StartDate)
{
tb.EndAt(task.EndDate);
}
ICronTrigger trigger = (ICronTrigger)tb.Build();
DateTime ft = sched.ScheduleJob(job, trigger).DateTime;
task.NextStart = TimeZoneInfo.ConvertTime(ft, trigger.TimeZone);
}
sched.Start();
}
public void Update(TaskDetail task)
{
if (task == null)
{
return;
}
int index = _tasks.FindIndex((TaskDetail n) => n.Id == task.Id);
if (_tasks[index] == null)
{
return;
}
task.ClassType = _tasks[index].ClassType;
task.LastEnd = _tasks[index].LastEnd;
task.LastStart = _tasks[index].LastStart;
task.LastIsSuccess = _tasks[index].LastIsSuccess;
_tasks[index] = task;
Type type = Type.GetType(task.ClassType);
if (type == null)
{
return;
}
Remove(type.Name);
if (!task.Enabled)
{
return;
}
string name = type.Name + "_trigger";
ISchedulerFactory schedulerFactory = new StdSchedulerFactory();
IScheduler scheduler = schedulerFactory.GetScheduler();
IJobDetail jobDetail = JobBuilder.Create(typeof(QuartzTask)).WithIdentity(type.Name).Build();
jobDetail.JobDataMap.Add(new KeyValuePair <string, object>("Id", task.Id));
TriggerBuilder triggerBuilder = TriggerBuilder.Create().WithIdentity(name).WithCronSchedule(task.TaskRule);
if (task.StartDate > DateTime.MinValue)
{
triggerBuilder.StartAt(new DateTimeOffset(task.StartDate));
}
if (task.EndDate.HasValue && task.EndDate > task.StartDate)
{
TriggerBuilder arg_233_0 = triggerBuilder;
DateTime? endDate = task.EndDate;
arg_233_0.EndAt(endDate.HasValue ? new DateTimeOffset?(endDate.GetValueOrDefault()) : null);
}
var cronTrigger = (ICronTrigger)triggerBuilder.Build();
DateTime dateTime = scheduler.ScheduleJob(jobDetail, cronTrigger).DateTime;
task.NextStart = TimeZoneInfo.ConvertTime(dateTime, cronTrigger.TimeZone);
}
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="task"></param>
public void Update(TaskInfo task)
{
if (task != null)
{
int num = tasks.FindIndex(n => n.Id == task.Id);
if (tasks[num] != null)
{
task.TaskType = tasks[num].TaskType;
task.LastEndDate = tasks[num].LastEndDate;
task.LastStartDate = tasks[num].LastStartDate;
task.LastSuccess = tasks[num].LastSuccess;
tasks[num] = task;
Type type = Type.GetType(task.TaskType);
if (type != null)
{
this.Remove(type.Name);
if (task.IsEnabled)
{
string name = type.Name + "_trigger";
ISchedulerFactory factory = new StdSchedulerFactory();
IScheduler scheduler = factory.GetScheduler().Result;
IJobDetail jobDetail = JobBuilder.Create(typeof(QuartzTask)).WithIdentity(type.Name).Build();
jobDetail.JobDataMap.Add(new KeyValuePair <string, object>("Id", task.Id));
TriggerBuilder builder = TriggerBuilder.Create().WithIdentity(name).WithCronSchedule(task.TaskRule);
if (task.StartDate > DateTime.MinValue)
{
builder.StartAt(new DateTimeOffset(task.StartDate));
}
if (task.EndDate.HasValue)
{
DateTime?endDate = task.EndDate;
DateTime startDate = task.StartDate;
if (endDate.HasValue ? (endDate.GetValueOrDefault() > startDate) : false)
{
DateTime?nullable3 = task.EndDate;
builder.EndAt(nullable3.HasValue ? new DateTimeOffset?(nullable3.GetValueOrDefault()) : null);
}
}
ICronTrigger trigger = (ICronTrigger)builder.Build();
DateTime dateTime = scheduler.ScheduleJob(jobDetail, trigger).Result.DateTime;
task.NextDate = new DateTime?(TimeZoneInfo.ConvertTime(dateTime, trigger.TimeZone));
}
}
}
}
}
/// <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);
}
/// <summary>
/// 创建cronExpression trigger
/// </summary>
/// <param name="code">唯一编码</param>
/// <param name="group">组名</param>
/// <param name="cronExpression">周期表达式</param>
/// <param name="startNow">是否立刻启动</param>
/// <param name="timeOffset">多少时间后启动</param>
/// <returns></returns>
private static ITrigger CreateTrigger(string code, string group, string cronExpression, bool startNow, DateTimeOffset timeOffset)
{
TriggerBuilder triggerBuilder = TriggerBuilder.Create()
.WithIdentity(GetTriggerIdentityName(code), GetTriggerIdentifyGroup(group))
// 运行模式
.WithCronSchedule(cronExpression);
if (startNow)
{
triggerBuilder.StartNow();
}
else
{
if (timeOffset != null)
{
triggerBuilder.StartAt(timeOffset);
}
}
return(triggerBuilder.Build());
}
public void Start()
{
if (_tasks.Count() == 0)
{
return;
}
new TaskService();
ISchedulerFactory schedulerFactory = new StdSchedulerFactory();
IScheduler scheduler = schedulerFactory.GetScheduler();
foreach (TaskDetail current in _tasks)
{
if (current.Enabled)
{
Type type = Type.GetType(current.ClassType);
if (!(type == null))
{
string name = type.Name + "_trigger";
IJobDetail jobDetail = JobBuilder.Create(typeof(QuartzTask)).WithIdentity(type.Name).Build();
jobDetail.JobDataMap.Add(new KeyValuePair <string, object>("Id", current.Id));
TriggerBuilder triggerBuilder =
TriggerBuilder.Create().WithIdentity(name).WithCronSchedule(current.TaskRule);
if (current.StartDate > DateTime.MinValue)
{
triggerBuilder.StartAt(new DateTimeOffset(current.StartDate));
}
if (current.EndDate > current.StartDate)
{
TriggerBuilder arg_14A_0 = triggerBuilder;
DateTime? endDate = current.EndDate;
arg_14A_0.EndAt(endDate.HasValue ? new DateTimeOffset?(endDate.GetValueOrDefault()) : null);
}
var cronTrigger = (ICronTrigger)triggerBuilder.Build();
DateTime dateTime = scheduler.ScheduleJob(jobDetail, cronTrigger).DateTime;
current.NextStart = TimeZoneInfo.ConvertTime(dateTime, cronTrigger.TimeZone);
}
}
}
scheduler.Start();
}
private ITrigger CreateTrigger(ScriptAbs script)
{
TriggerBuilder triggerBuilder = TriggerBuilder
.Create()
.WithIdentity(GetTriggerKeyForScript(script));
if (script is ScriptScheduled scriptScheduled)
{
triggerBuilder
.StartAt(GetTriggerStartAt(scriptScheduled.ScheduledHour))
.WithSimpleSchedule(x => x
.WithIntervalInHours(24)
.RepeatForever()
);
}
else
{
triggerBuilder.StartNow();
}
return(triggerBuilder.Build());
}
public static async void AddTaskTriggerForJob(Models.Task task, User user)
{
try
{
TriggerBuilder triggerBuilder = TriggerBuilder.Create()
.WithIdentity(task.Id.ToString())
.WithCronSchedule(task.Period);
if (DateTime.Now >= DateTime.Parse(task.StartTime))
{
triggerBuilder.StartNow();
}
else
{
triggerBuilder.StartAt(DateTimeOffset.Parse(task.StartTime));
}
ITrigger trigger = null;
if (task.ApiId == (int)APIID.COVID) // создание триггеров на задачи по получанию данных covid
{
trigger = triggerBuilder.ForJob(covidJobName).Build();
}
else if (task.ApiId == (int)APIID.FOREX) // создание триггеров на задачи по получанию данных forex
{
trigger = triggerBuilder.ForJob(forexJobName).Build();
}
else if (task.ApiId == (int)APIID.QUOTE) // создание триггеров на задачи по получанию данных quote
{
trigger = triggerBuilder.ForJob(quoteJobName).Build();
}
trigger.JobDataMap["apiParam"] = task.ApiParam;
trigger.JobDataMap["idTask"] = task.Id;
trigger.JobDataMap["userMail"] = user.Email;
await scheduler.ScheduleJob(trigger);
}
catch (Exception ex)
{
logger.Error(ex.Message);
}
}
public async Task <DateTimeOffset?> TriggerSendUnsentEventsJob(DateTime?startAt)
{
ValidateSendUnsentJobSchedule();
TriggerBuilder builder = TriggerBuilder.Create()
.WithIdentity(nameof(SendUnsentEventsJob) + Guid.NewGuid().ToString(), Constants.Group.General);
if (startAt != null)
{
builder = builder.StartAt(startAt.Value);
}
else
{
builder = builder.StartNow();
}
var trigger = builder.ForJob(SendUnsentEventsJobKey).Build();
var oldTrigger = await Scheduler.GetTrigger(SendUnsentEventsJobTriggerKey);
if (oldTrigger != null)
{
return(await Scheduler.RescheduleJob(SendUnsentEventsJobTriggerKey, trigger));
}
return(await Scheduler.ScheduleJob(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);
}
private static async void AddJob(IScheduler scheduler, TimeSpan intervalTs, DateTime?startAt, int?repeatCount, string groupName, string triggerName, IJobDetail job)
{
TriggerBuilder triggerBuilder = null;
if (repeatCount.HasValue)
{
repeatCount -= 1;
triggerBuilder = TriggerBuilder.Create()
.WithIdentity(triggerName, groupName)
.StartNow()
.WithSimpleSchedule(x => x
.WithInterval(intervalTs)
.WithRepeatCount(repeatCount.Value));
}
else
{
triggerBuilder = TriggerBuilder.Create()
.WithIdentity(triggerName, groupName)
.StartNow()
.WithSimpleSchedule(x => x
.WithInterval(intervalTs)
.RepeatForever());
}
if (!startAt.HasValue)
{
startAt = DateTime.Now + TimeSpan.FromSeconds(10);
}
triggerBuilder.StartAt(startAt.Value);
ITrigger trigger = triggerBuilder.Build();
await scheduler.ScheduleJob(job, trigger);
}
/// <summary>
/// Handles with a given text matches the Expression4 field.
/// </summary>
/// <param name="nameValueCollection">A collection of values from the named capture groups.</param>
/// <param name="results">The results.</param>
private void Expression4Handler(NameValueCollection nameValueCollection, TimeZoneInfo timeZone, TextToScheduleResults results)
{
// every [n] (days|weeks|months|years) (from [date]) (at [time])
string amountString = nameValueCollection["AMOUNT"];
string intervalString = nameValueCollection["INTERVALUNIT"];
var dateSpec = nameValueCollection["DATESPEC"];
var dayOfWeekSpecs = nameValueCollection.GetValues("DAYOFWEEK");
var timesToFire = nameValueCollection.GetValues("TIME");
DateTime?triggerStartTime = null;
if (dayOfWeekSpecs != null && GrammarHelper.GetIntervalUnitValueFromString(intervalString) != IntervalUnit.Week)
{
throw new Exception("You should only specify a day of the week, when you are using the \"week\" time interval.");
}
if (timesToFire == null) // if times are not specified assume midnight
{
timesToFire = new string[] { "00:00" }
}
;
foreach (var timeString in timesToFire)
{
if (dateSpec != null || timeString != null)
{
triggerStartTime = GrammarHelper.GetDateTimeFromDateSpecAndTime(dateSpec, timeString);
}
if (dayOfWeekSpecs != null)
{
var dayOfWeeks = GrammarHelper.GetDayOfWeekValues(dayOfWeekSpecs);
foreach (var dayOfWeek in dayOfWeeks)
{
if (triggerStartTime == null)
{
triggerStartTime = SystemTime.Now().DateTime;
}
DateTime dowTriggerStartTime = triggerStartTime.Value;
//seek
dowTriggerStartTime = SeekForwardToNextDayOfWeek(dowTriggerStartTime, dayOfWeek);
TriggerBuilder triggerBuilder = TriggerBuilder.Create();
triggerBuilder.WithSchedule(CreateScheduleWithAmountAndIntervalUnit(amountString, intervalString, timeZone));
triggerBuilder.StartAt(new DateTimeOffset(dowTriggerStartTime, timeZone.GetUtcOffset(dowTriggerStartTime)));
results.Add(triggerBuilder, null);
}
}
else
{
TriggerBuilder triggerBuilder = TriggerBuilder.Create();
triggerBuilder.WithSchedule(CreateScheduleWithAmountAndIntervalUnit(amountString, intervalString, timeZone));
//start on from time
if (triggerStartTime != null)
{
triggerBuilder.StartAt(new DateTimeOffset(triggerStartTime.Value, timeZone.GetUtcOffset(triggerStartTime.Value)));
}
results.Add(triggerBuilder, null);
}
}
}
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);
}
}
}
/// <summary>
/// 开始任务
/// </summary>
public void Start()
{
var taskService = DIContainer.Resolve <IQuartzTaskService>();
if (_tasks == null)
{
_tasks = taskService.QuartzTasks.ToList();
}
if (_tasks.Count == 0)
{
return;
}
var taskScheduler = DIContainer.Resolve <ITaskScheduler>();
foreach (var task in _tasks)
{
if (!task.Enabled)
{
continue;
}
Type type = Type.GetType(task.ClassType);
if (type == null)
{
continue;
}
string triggerName = type.Name + "_trigger";
IJobDetail job = JobBuilder.Create(typeof(JobDetail))
.WithIdentity(type.Name)
.Build();
job.JobDataMap.Add(new KeyValuePair <string, object>("Id", task.Id));
TriggerBuilder tb = TriggerBuilder.Create()
.WithIdentity(triggerName)
.WithCronSchedule(task.TaskRule);
if (task.NextStart.HasValue)
{
tb.StartAt(new DateTimeOffset(task.NextStart.Value));
}
else if (task.StartDate > DateTime.MinValue)
{
tb.StartAt(new DateTimeOffset(task.StartDate));
}
if (task.EndDate > task.StartDate)
{
tb.EndAt(task.EndDate);
}
ICronTrigger trigger = (ICronTrigger)tb.Build();
DateTime nextStart = sched.ScheduleJob(job, trigger).LocalDateTime;
if (task.NextStart == null || task.NextStart < nextStart)
{
task.NextStart = nextStart;
taskScheduler.SaveTaskStatus(task);
}
}
sched.Start();
}
private TriggerBuilder AddOneTime(TriggerBuilder triggerBuilder, ScheduleModel scheduler)
{
return(triggerBuilder.StartAt(scheduler.StarTime));
}
/// <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);
}
/// <summary>
/// 更新任务
/// </summary>
/// <param name="task"></param>
public void Update(QuartzTask task)
{
if (task == null)
{
return;
}
int index = _tasks.FindIndex(n => n.Id == task.Id);
if (_tasks[index] == null)
{
return;
}
task.ClassType = _tasks[index].ClassType;
task.LastEnd = _tasks[index].LastEnd;
task.LastStart = _tasks[index].LastStart;
task.LastIsSuccess = _tasks[index].LastIsSuccess;
_tasks[index] = task;
Type type = Type.GetType(task.ClassType);
if (type == null)
{
return;
}
Remove(type.Name);
if (!task.Enabled)
{
return;
}
string triggerName = type.Name + "_trigger";
IJobDetail job = JobBuilder.Create(typeof(JobDetail))
.WithIdentity(type.Name)
.Build();
job.JobDataMap.Add(new KeyValuePair <string, object>("Id", task.Id));
TriggerBuilder tb = TriggerBuilder.Create()
.WithIdentity(triggerName)
.WithCronSchedule(task.TaskRule);
if (task.NextStart.HasValue)
{
tb.StartAt(new DateTimeOffset(task.NextStart.Value));
}
else if (task.StartDate > DateTime.MinValue)
{
tb.StartAt(new DateTimeOffset(task.StartDate));
}
if (task.EndDate.HasValue && task.EndDate > task.StartDate)
{
tb.EndAt(task.EndDate);
}
ICronTrigger trigger = (ICronTrigger)tb.Build();
DateTime nextStart = sched.ScheduleJob(job, trigger).LocalDateTime;
if (task.NextStart.HasValue && task.NextStart < nextStart)
{
task.NextStart = nextStart;
}
}
public TriggerHelper StartAt(DateTimeOffset startTimeUtc)
{
trigger.StartAt(startTimeUtc);
return(this);
}
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>
/// Handles with a given text matches the Expression1 field.
/// </summary>
/// <param name="nameValueCollection">A collection of values from the named capture groups.</param>
/// <param name="results">The results.</param>
private void Expression1Handler(NameValueCollection nameValueCollection, TimeZoneInfo timeZone, TextToScheduleResults results)
{
var amountString = nameValueCollection["AMOUNT"];
var intervalUnitString = nameValueCollection["INTERVALUNIT"];
var startDateString = nameValueCollection["DATESPEC"];
var time = nameValueCollection["TIME"];
var fromTime = nameValueCollection["FROMTIME"];
var toTime = nameValueCollection["TOTIME"];
var dayOfWeekSpecs = nameValueCollection.GetValues("DAYOFWEEK");
var monthSpecs = nameValueCollection.GetValues("MONTH");
DateTime?triggerStartTime = null;
ICalendar calendar = null;
//DAY OF WEEK SPECS
if (dayOfWeekSpecs != null)
{
calendar = BuildCalendarOnDayOfWeek(calendar, dayOfWeekSpecs, timeZone);
}
//MONTH SPECS
if (monthSpecs != null)
{
calendar = BuildCalendarOnMonths(calendar, monthSpecs, timeZone);
}
//TIME (single or range)
//check for ranged time
if (fromTime != null && toTime != null)
{
calendar = BuildCalendarOnTimeRange(calendar, fromTime, toTime, timeZone);
//set the start date as the from time
DateTime?fromTimeStartDate = GrammarHelper.GetTimeFromTimeString(fromTime);
triggerStartTime = fromTimeStartDate;
}
//is regular time, process as single time provided
else if (time != null)
{
DateTime?timeStartDate = GrammarHelper.GetTimeFromTimeString(time);
triggerStartTime = timeStartDate;
}
//BUILD TRIGGER
TriggerBuilder triggerBuilder = TriggerBuilder.Create();
//set schedule
triggerBuilder.WithSchedule(CreateScheduleWithAmountAndIntervalUnit(amountString, intervalUnitString, timeZone));
//start on from time
if (triggerStartTime != null)
{
triggerBuilder.StartAt(new DateTimeOffset(triggerStartTime.Value, timeZone.GetUtcOffset(triggerStartTime.Value)));
}
results.Add(triggerBuilder, calendar);
}
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>
/// 初始化并启动
/// </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);
}
});
}
