public bool ModifyJobCron(JobParamBaseModel job)
{
try
{
JobKey jobKey = CreateJobKey(job.JobName, job.JobGroupName);
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.CronSchedule(job.CronExpression);
var triggerKey = CreateTriggerKey(job.TriggerName, job.TriggerGroupName);
ITrigger trigger = TriggerBuilder.Create().StartNow()
.WithIdentity(job.TriggerName, job.TriggerGroupName)
.ForJob(jobKey)
.WithSchedule(scheduleBuilder.WithMisfireHandlingInstructionDoNothing())
.Build();
bool blxml = Xml.XmlJobManage.ModifyJobCronToXml(triggerKey, jobKey, trigger);
if (blxml)
{
_scheduler.RescheduleJob(triggerKey, trigger);
return(true);
}
}
catch (Exception ex)
{
logger.Error(ex);
}
return(false);
}
public override bool RunJob(custom_job_infoes jobInfo)
{
//Assembly assembly = Assembly.LoadFile(AppDomain.CurrentDomain.BaseDirectory + $"bin/{jobInfo.DLLName}");
//var type = assembly.GetType(jobInfo.FullJobName);
JobKey jobKey = KeyManager.CreateJobKey(jobInfo.JobName, jobInfo.JobGroupName);
if (!Scheduler.CheckExists(jobKey))
{
IJobDetail job = JobBuilder.Create <JobItem>()
.WithIdentity(jobKey)
.UsingJobData(KeyManager.CreateJobDataMap("requestUrl", jobInfo.RequestUrl))
.Build();
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.CronSchedule(jobInfo.Cron);
ITrigger trigger = TriggerBuilder.Create().StartAt(DateTimeOffset.Now.AddYears(-1))
.WithIdentity(jobInfo.TriggerName, jobInfo.TriggerGroupName)
.ForJob(jobKey)
.WithSchedule(scheduleBuilder.WithMisfireHandlingInstructionDoNothing())
.Build();
Scheduler.ScheduleJob(job, trigger);
//Task.Run(() =>
//{
// //执行更新任务所在节点信息
//});
}
return(true);
}
public async Task StartAsync()
{
try
{
_log.Info($"{nameof(MyServiceRunner)} is creating\r\n");
JobKey jobKey = new JobKey(nameof(MyServiceJob));
IJobDetail job = JobBuilder.Create(typeof(MyServiceJob))
.WithIdentity(jobKey)
.Build();
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.CronSchedule("0/1 * * * * ?");
ITrigger trigger = TriggerBuilder.Create().StartNow()
.WithIdentity(nameof(MyServiceJob) + "_Trigger")
.ForJob(jobKey)
.WithSchedule(scheduleBuilder.WithMisfireHandlingInstructionDoNothing())
.Build();
await _scheduler.ScheduleJob(job, trigger);
_log.Info($"{nameof(MyServiceRunner)} is created\r\n");
await _scheduler.Start();
_log.Info($"{nameof(MyServiceRunner)} is started\r\n");
}
catch (Exception e)
{
_log.Error(e.Message);
Console.WriteLine(e);
}
}
protected ITrigger CreateTrigger(JobParamBaseModel job, JobKey jobKey)
{
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.CronSchedule(job.CronExpression);
ITrigger trigger = TriggerBuilder.Create().StartNow()
.WithIdentity(job.TriggerName, job.TriggerGroupName)
.ForJob(jobKey)
.WithSchedule(scheduleBuilder.WithMisfireHandlingInstructionDoNothing())
.Build();
return(trigger);
}
/// <summary>
/// 更改任务运行周期
/// </summary>
/// <param name="jobInfo">任务信息</param>
/// <returns></returns>
public bool ModifyJobCron(customer_quartzjobinfo jobInfo)
{
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.CronSchedule(jobInfo.Cron);
var triggerKey = _createTriggerKey(jobInfo.TriggerName, jobInfo.TriggerGroupName);
ITrigger trigger = TriggerBuilder.Create().StartNow()
.WithIdentity(jobInfo.TriggerName, jobInfo.TriggerGroupName)
.WithSchedule(scheduleBuilder.WithMisfireHandlingInstructionDoNothing())
.Build();
_scheduler.RescheduleJob(triggerKey, trigger);
return(true);
}
public override bool ModifyJobCron(customer_quartzjobinfo jobInfo)
{
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.CronSchedule(jobInfo.Cron);
var triggerKey = KeyManager.CreateTriggerKey(jobInfo.TriggerName, jobInfo.TriggerGroupName);
ITrigger trigger = TriggerBuilder.Create().StartAt(DateTimeOffset.Now.AddYears(-1))
.WithIdentity(jobInfo.TriggerName, jobInfo.TriggerGroupName)
.WithSchedule(scheduleBuilder.WithMisfireHandlingInstructionDoNothing())
.Build();
Scheduler.RescheduleJob(triggerKey, trigger);
return(true);
}
/// <summary>
/// 更改任务运行周期
/// </summary>
/// <param name="jobInfo">任务信息</param>
/// <returns></returns>
public bool ModifyJobCron(CustomerJobInfoEntity jobInfo)
{
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.CronSchedule(jobInfo.Cron);
var triggerKey = _createTriggerKey(jobInfo.TriggerName, jobInfo.TriggerGroupName);
ITrigger trigger = TriggerBuilder.Create().StartNow()
.WithIdentity(jobInfo.TriggerName, jobInfo.TriggerGroupName)
.WithSchedule(scheduleBuilder.WithMisfireHandlingInstructionDoNothing())
.Build();
_scheduler.RescheduleJob(triggerKey, trigger);
_log.Info("ModifyJobCron: " + jobInfo.JobName + " URL: " + jobInfo.RequestUrl + " executing at " + DateTime.Now.ToString("r"));
return(true);
}
public override IScheduleBuilder GetScheduleBuilder()
{
CronScheduleBuilder cb = CronScheduleBuilder.CronSchedule(CronExpressionString).InTimeZone(TimeZone);
switch (MisfireInstruction)
{
case Quartz.MisfireInstruction.CronTrigger.DoNothing: cb.WithMisfireHandlingInstructionDoNothing();
break;
case Quartz.MisfireInstruction.CronTrigger.FireOnceNow: cb.WithMisfireHandlingInstructionFireAndProceed();
break;
}
return(cb);
}
/// <summary>
/// 更改触发器以及执行周期
/// </summary>
/// <param name="jobInfo">任务信息</param>
/// <returns>是否成功</returns>
public bool EditJobCron(SURE_QRTZ_JOBINFO jobInfo)
{
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.CronSchedule(jobInfo.Cron);
var triggerKey = new TriggerKey(jobInfo.TriggerName, jobInfo.TriggerGroupName);
ITrigger trigger = TriggerBuilder.Create()
.WithIdentity(jobInfo.TriggerName, jobInfo.TriggerGroupName)
.StartAt(jobInfo.StartTime)
.EndAt(jobInfo.EndTime)
.ForJob(new JobKey(jobInfo.JobName, jobInfo.JobGroupName))
.WithSchedule(scheduleBuilder.WithMisfireHandlingInstructionDoNothing())
.Build();
scheduler.RescheduleJob(triggerKey, trigger);
return(true);
}
/// <summary>
/// 运行任务
/// </summary>
/// <param name="id">任务信息</param>
/// <returns></returns>
public bool RunJob(int id)
{
var jobInfo = _jobDetailRepository.FirstOrDefault(x => x.Id == id);
JobKey jobKey = CreateJobKey(jobInfo.JobName, jobInfo.JobGroupName);
if (!_scheduler.CheckExists(jobKey).Result)
{
IJobDetail job = JobBuilder.Create <JobBase>()
.WithIdentity(jobKey)
//.UsingJobData(CreateJobDataMap("jobId", jobInfo.Id))
//.UsingJobData(CreateJobDataMap("requestUrl", jobInfo.RequestUrl))//添加此任务请求地址附带到Context上下文中
//.RequestRecovery(true)
.WithDescription(jobInfo.Description)
.Build();
JobDataMap map = job.JobDataMap;
map.Put("jobId", jobInfo.Id);
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.CronSchedule(jobInfo.Cron);
ITrigger trigger = TriggerBuilder.Create().StartNow()//StartAt(DateTime.SpecifyKind(jobInfo.JobStartTime, DateTimeKind.Local))
.WithIdentity(jobInfo.TriggerName, jobInfo.TriggerGroupName)
.ForJob(jobKey)
.WithSchedule(scheduleBuilder.WithMisfireHandlingInstructionDoNothing())
.WithDescription(jobInfo.Description)
.Build();
#region Quartz 任务miss之后三种操作
/*
* withMisfireHandlingInstructionDoNothing
* ——不触发立即执行
* ——等待下次Cron触发频率到达时刻开始按照Cron频率依次执行
*
* withMisfireHandlingInstructionIgnoreMisfires
* ——以错过的第一个频率时间立刻开始执行
* ——重做错过的所有频率周期后
* ——当下一次触发频率发生时间大于当前时间后，再按照正常的Cron频率依次执行
*
* withMisfireHandlingInstructionFireAndProceed
* ——以当前时间为触发频率立刻触发一次执行
* ——然后按照Cron频率依次执行*/
#endregion
_scheduler.ScheduleJob(job, trigger);
}
return(true);
}
public override bool RunJob(customer_quartzjobinfo jobInfo)
{
var jobKey = KeyManager.CreateJobKey(jobInfo.JobName, jobInfo.JobGroupName);
if (!Scheduler.CheckExists(jobKey).Result)
{
IJobDetail jobDetail = JobBuilder.Create <JobItem>().WithIdentity(jobKey).UsingJobData(KeyManager.CreateJobDataMap("requestUrl", jobInfo.RequestUrl)).Build();
CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.CronSchedule(jobInfo.Cron);
ITrigger trigger = TriggerBuilder.Create().StartAt(DateTimeOffset.Now.AddYears(-1))
.WithIdentity(jobInfo.TriggerName, jobInfo.TriggerGroupName)
.ForJob(jobKey)
.WithSchedule(cronScheduleBuilder.WithMisfireHandlingInstructionDoNothing())
.Build();
Scheduler.ScheduleJob(jobDetail, trigger);
}
return(true);
}
/// <summary>
/// 运行任务
/// </summary>
/// <param name="jobInfo">任务信息</param>
/// <returns></returns>
public bool RunJob(CustomerJobInfoEntity jobInfo)
{
Assembly assembly = Assembly.LoadFile(AppDomain.CurrentDomain.BaseDirectory + $"bin/{jobInfo.DLLName}");
var type = assembly.GetType(jobInfo.FullJobName);
JobKey jobKey = _createJobKey(jobInfo.JobName, jobInfo.JobGroupName);
if (!_scheduler.CheckExists(jobKey))
{
IJobDetail job = JobBuilder.Create(type)
.WithIdentity(jobKey)
.UsingJobData(_createJobDataMap("jobId", jobInfo.F_Id))
.UsingJobData(_createJobDataMap("requestUrl", jobInfo.RequestUrl))//添加此任务请求地址附带到Context上下文中
.UsingJobData(_createJobDataMap("webApi", jobInfo.WebApi))
.Build();
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.CronSchedule(jobInfo.Cron);
ITrigger trigger = TriggerBuilder.Create().StartNow()//StartAt(DateTime.SpecifyKind(jobInfo.JobStartTime, DateTimeKind.Local))
.WithIdentity(jobInfo.TriggerName, jobInfo.TriggerGroupName)
.ForJob(jobKey)
.WithSchedule(scheduleBuilder.WithMisfireHandlingInstructionDoNothing())
.Build();
#region Quartz 任务miss之后三种操作
/*
* withMisfireHandlingInstructionDoNothing
* ——不触发立即执行
* ——等待下次Cron触发频率到达时刻开始按照Cron频率依次执行
*
* withMisfireHandlingInstructionIgnoreMisfires
* ——以错过的第一个频率时间立刻开始执行
* ——重做错过的所有频率周期后
* ——当下一次触发频率发生时间大于当前时间后，再按照正常的Cron频率依次执行
*
* withMisfireHandlingInstructionFireAndProceed
* ——以当前时间为触发频率立刻触发一次执行
* ——然后按照Cron频率依次执行*/
#endregion
_scheduler.ScheduleJob(job, trigger);
_log.Info("RunJob: " + jobInfo.JobName + " URL: " + jobInfo.RequestUrl + " executing at " + DateTime.Now.ToString("r"));
}
return(true);
}
/// <summary>
/// 更改任务运行周期
/// </summary>
/// <param name="id"></param>
/// <param name="cron"></param>
/// <returns></returns>
public bool ModifyJobCron(int id, string cron)
{
var jobInfo = _jobDetailRepository.FirstOrDefault(x => x.Id == id);
JobKey jobKey = CreateJobKey(jobInfo.JobName, jobInfo.JobGroupName);
if (_scheduler.CheckExists(jobKey).Result)
{
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.CronSchedule(cron);
var triggerKey = CreateTriggerKey(jobInfo.TriggerName, jobInfo.TriggerGroupName);
ITrigger trigger = TriggerBuilder.Create().StartNow()
.WithIdentity(jobInfo.TriggerName, jobInfo.TriggerGroupName)
.WithSchedule(scheduleBuilder.WithMisfireHandlingInstructionDoNothing())
.Build();
_scheduler.RescheduleJob(triggerKey, trigger);
}
jobInfo.Cron = cron;
_jobDetailRepository.Update(jobInfo);
return(true);
}
/// <summary>
/// 运行任务
/// </summary>
/// <param name="jobInfo">任务信息</param>
/// <returns>是否创建成功</returns>
public static async Task <bool> RunJobAsync(CustomerJobInfo jobInfo)
{
var assembly = Assembly.LoadFile(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "bin", jobInfo.Dllname));
var type = assembly.GetType(jobInfo.FullJobName);
JobKey jobKey = CreateJobKey(jobInfo.JobName, jobInfo.JobGroupName);
if (!await _scheduler.CheckExists(jobKey))
{
IJobDetail job = JobBuilder.Create(type).WithIdentity(jobKey)
.UsingJobData(CreateJobDataMap("jobId", jobInfo.Id))
.UsingJobData(CreateJobDataMap("requestUrl", jobInfo.RequestUrl))
.Build();
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.CronSchedule(jobInfo.Cron);
ITrigger trigger =
TriggerBuilder.Create().StartNow().WithIdentity(jobInfo.TriggerName, jobInfo.TriggerGroupName)
.ForJob(jobKey)
.WithSchedule(scheduleBuilder.WithMisfireHandlingInstructionDoNothing())
.Build();
#region Quartz 任务miss之后三种操作
/*
* withMisfireHandlingInstructionDoNothing
* ——不触发立即执行
* ——等待下次Cron触发频率到达时刻开始按照Cron频率依次执行
*
* withMisfireHandlingInstructionIgnoreMisfires
* ——以错过的第一个频率时间立刻开始执行
* ——重做错过的所有频率周期后
* ——当下一次触发频率发生时间大于当前时间后，再按照正常的Cron频率依次执行
*
* withMisfireHandlingInstructionFireAndProceed
* ——以当前时间为触发频率立刻触发一次执行
* ——然后按照Cron频率依次执行*/
#endregion
await _scheduler.ScheduleJob(job, trigger);
}
return(true);
}
/// <summary>
/// 运行任务，以及创建Job
/// </summary>
/// <param name="jobInfo">任务信息</param>
/// <returns>是否成功</returns>
public bool RunJob(SURE_QRTZ_JOBINFO jobInfo)
{
try
{
Assembly assembly = Assembly.LoadFile(AppDomain.CurrentDomain.BaseDirectory + $"bin/{jobInfo.DLLName}");
JobKey jobKey = new JobKey(jobInfo.JobName, jobInfo.JobGroupName);
//只需判断Job是否存在
if (!scheduler.CheckExists(jobKey))
{
//Create Job
IJobDetail job = JobBuilder.Create(assembly.GetType(jobInfo.FullJobName))
.WithIdentity(jobKey)
.UsingJobData(createJobDataMap("jobId", jobInfo.Id))
.UsingJobData(createJobDataMap("requestUrl", jobInfo.RequestUrl))
.UsingJobData(createJobDataMap("fullJobName", jobInfo.FullJobName))
.Build();
//Create Tigger
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.CronSchedule(jobInfo.Cron);
ITrigger trigger = TriggerBuilder.Create()
.WithIdentity(jobInfo.TriggerName, jobInfo.TriggerGroupName)
.StartAt(jobInfo.StartTime)
.EndAt(jobInfo.EndTime)
.ForJob(jobKey)
.WithSchedule(scheduleBuilder.WithMisfireHandlingInstructionDoNothing())
.Build();
scheduler.ScheduleJob(job, trigger);
return(true);
}
else
{
return(false);
}
}
catch (Exception ex)
{
throw new Exception($"运行任务失败,错误:{ex.Message}");
}
}
public override IScheduleBuilder GetScheduleBuilder()
{
CronScheduleBuilder cb = null;
try
{
cb = CronScheduleBuilder.CronSchedule(CronExpressionString).InTimeZone(TimeZone);
}
catch (FormatException)
{
// can't happen (because the expression was validated to get here in the first place)
}
switch (MisfireInstruction)
{
case Quartz.MisfireInstruction.CronTrigger.DoNothing: cb.WithMisfireHandlingInstructionDoNothing();
break;
case Quartz.MisfireInstruction.CronTrigger.FireOnceNow: cb.WithMisfireHandlingInstructionFireAndProceed();
break;
}
return(cb);
}
public override bool RunJob(CronJob jobInfo)
{
var jobKey = KeyManager.CreateJobKey(jobInfo.Name, jobInfo.GroupName);
if (!Scheduler.CheckExists(jobKey).Result)
{
//创建工作
IJobDetail jobDetail = JobBuilder.Create <JobExecutor>().WithIdentity(jobKey)
.UsingJobData(KeyManager.CreateJobDataMap("requestUrl", jobInfo.RequestUrl))
.UsingJobData(KeyManager.CreateJobDataMap("jobId", jobInfo.Id))
.Build();
//创建事件表
CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.CronSchedule(jobInfo.CronExpress);
ITrigger trigger = TriggerBuilder.Create().StartAt(DateTimeOffset.Now.AddYears(-1))
.WithIdentity(jobInfo.TriggerName, jobInfo.TriggerGroupName)
.ForJob(jobKey)
.WithSchedule(cronScheduleBuilder.WithMisfireHandlingInstructionDoNothing())
.Build();
Scheduler.ScheduleJob(jobDetail, trigger);
}
return(true);
}
