public async Task DeleteById(int id)
{
QuartzOption quartzOption = _quartzOptionRepository.SelectById(id);
_quartzOptionRepository.DeleteById(id);
await _schedulerFactory.TriggerAction(quartzOption, JobAction.除);
}
public async Task <string> Run(int id)
{
QuartzOption quartzOption = _quartzOptionRepository.SelectById(id);
string result = await _schedulerFactory.TriggerAction(quartzOption, JobAction.立即执行);
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="context"></param>通过作业上下文获取作业对应的配置参数
/// <returns></returns>
public static QuartzOption GetQuartzOptions(this IJobExecutionContext context)
{
AbstractTrigger trigger = (context as JobExecutionContextImpl).Trigger as AbstractTrigger;
QuartzOption QuartzOptions = _taskList.Where(x => x.TaskName == trigger.Name && x.GroupName == trigger.Group).FirstOrDefault();
return(QuartzOptions ?? _taskList.Where(x => x.TaskName == trigger.JobName && x.GroupName == trigger.JobGroup).FirstOrDefault());
}
private static QuartzResult Exists(this QuartzOption QuartzOptions)
{
if (_taskList.Any(x => x.TaskName == QuartzOptions.TaskName && x.GroupName == QuartzOptions.GroupName))
{
return(QuartzResult.Error($"作业:{QuartzOptions.TaskName},分组：{QuartzOptions.GroupName}已经存在"));
}
return(QuartzResult.Ok("不存在"));
}
/// <summary>
/// 创建类型Cron的触发器
/// </summary>
/// <param name="m"></param>
/// <returns></returns>
private static ITrigger CreateCronTrigger(this QuartzOption QuartzOptions)
{
if (QuartzOptions is null)
{
throw new ArgumentNullException(nameof(QuartzOptions));
}
return(QuartzOptions.GetTriggerBuilder()
.WithCronSchedule(QuartzOptions.Interval, x => x.WithMisfireHandlingInstructionDoNothing()).Build());
}
public async Task Execute(IJobExecutionContext context)
{
try
{
IQuartzOptionRepository quartzOptionRepository = ServiceLocator.Get <IQuartzOptionRepository>();
IHttpClientFactory httpClientFactory = ServiceLocator.Get <IHttpClientFactory>();
AbstractTrigger trigger = (context as JobExecutionContextImpl).Trigger as AbstractTrigger;
QuartzOption quartzOption = quartzOptionRepository.SelectSingle(s => (s.JobName == trigger.Name && s.GroupName == trigger.Group) ||
(s.JobName == trigger.JobName && s.GroupName == trigger.JobGroup));
if (quartzOption == null)
{
throw new ArgumentException(string.Format("分组：{0}，作业：{1}不存在", quartzOption.GroupName, quartzOption.JobName));
}
HttpClient httpClient = httpClientFactory.CreateClient();
HttpResponseMessage responseMessage = null;
switch (quartzOption.RequestType)
{
case "GET":
responseMessage = await httpClient.GetAsync(quartzOption.Api);
responseMessage.EnsureSuccessStatusCode();
break;
case "POST":
string[] arr = quartzOption.ParameterValue.Split(',');
Dictionary <string, string> para = new Dictionary <string, string>();
foreach (var item in arr)
{
string[] itemArr = item.Split(':');
para.Add(itemArr[0], itemArr[2]);
}
FormUrlEncodedContent content = new FormUrlEncodedContent(para);
responseMessage = await httpClient.PostAsync(quartzOption.Api, content);
responseMessage.EnsureSuccessStatusCode();
break;
case "DELETE":
responseMessage = await httpClient.DeleteAsync(quartzOption.Api);
responseMessage.EnsureSuccessStatusCode();
break;
}
ApiResult apiResult = JsonConvert.DeserializeObject <ApiResult>(await responseMessage.Content.ReadAsStringAsync());
if (apiResult.Code != HttpStatusCode.SUCCESS)
{
throw new HttpRequestException(apiResult.Msg);
}
quartzOption.LastActionTime = DateTime.Now;
quartzOptionRepository.Update(quartzOption);
}
catch (Exception ex)
{
LogUtils.LogError(ex, "Blog.Quartz.Application.Quartz.Job", ex.Message);
}
}
private static IJobDetail CreateJobDetail <T>(QuartzOption QuartzOptions) where T : IJob
{
IJobDetail jobDetail = JobBuilder.CreateForAsync <T>().WithIdentity(QuartzOptions.TaskName, QuartzOptions.GroupName).Build();
if (QuartzOptions.TaskData != null)
{
jobDetail.JobDataMap.Add(typeof(T).Name, QuartzOptions.TaskData);
}
return(jobDetail);
}
public async Task <string> Stop(int id)
{
QuartzOption quartzOption = _quartzOptionRepository.SelectById(id);
quartzOption.TaskStatus = TaskStatus.暂停;
_quartzOptionRepository.Update(quartzOption);
string result = await _schedulerFactory.TriggerAction(quartzOption, JobAction.暂停);
return(result);
}
/// <summary>
/// 创建CreateJobDetail
/// </summary>
/// <param name="QuartzOptions"></param>
/// <returns></returns>
private static IJobDetail CreateJobDetail(this QuartzOption QuartzOptions)
{
if (QuartzOptions.ExecuteType == ExecuteType.Asb)
{
return(CreateJobDetailByAssembly(QuartzOptions));
}
else
{
return(CreateJobDetailByApiUrl(QuartzOptions));
}
}
public async static Task <QuartzResult> ModifyTaskEntity(this ISchedulerFactory schedulerFactory, QuartzOption QuartzOptions, JobAction action)
{
QuartzOption options = null;
switch (action)
{
case JobAction.Delete:
for (int i = 0; i < _taskList.Count; i++)
{
options = _taskList[i];
if (options.TaskName == QuartzOptions.TaskName && options.GroupName == QuartzOptions.GroupName)
{
_taskList.RemoveAt(i);
}
}
break;
case JobAction.Modify:
options = _taskList.Where(x => x.TaskName == QuartzOptions.TaskName && x.GroupName == QuartzOptions.GroupName).FirstOrDefault();
//移除以前的配置
if (options != null)
{
_taskList.Remove(options);
}
//生成任务并添加新配置
await schedulerFactory.AddJob(QuartzOptions); //.GetAwaiter().GetResult();
break;
case JobAction.Pause:
case JobAction.Start:
case JobAction.Stop:
case JobAction.StartNow:
options = _taskList.Where(x => x.TaskName == QuartzOptions.TaskName && x.GroupName == QuartzOptions.GroupName).FirstOrDefault();
if (action == JobAction.Pause)
{
options.TaskStatus = TriggerState.Paused;
}
else if (action == JobAction.Stop)
{
options.TaskStatus = (TriggerState)action;
}
else
{
options.TaskStatus = TriggerState.Normal;
}
break;
}
//生成配置文件
//FileQuartz.WriteJobConfig(_taskList);
//FileQuartz.WriteJobAction(action, QuartzOptions.TaskName, QuartzOptions.GroupName, "操作对象：" + JsonConvert.SerializeObject(QuartzOptions));
return(QuartzResult.Ok("成功"));
}
private QuartzOptionDTO ConvertToDTO(QuartzOption item)
{
QuartzOptionDTO quartzOptionDTO = new QuartzOptionDTO();
quartzOptionDTO.Id = item.Id;
quartzOptionDTO.JobName = item.JobName;
quartzOptionDTO.GroupName = item.GroupName;
quartzOptionDTO.Cron = item.Cron;
quartzOptionDTO.Api = item.Api;
quartzOptionDTO.LastActionTime = item.LastActionTime.HasValue ? item.LastActionTime.Value.ToString("yyyy-MM-dd hh:MM:ss") : "";
quartzOptionDTO.Description = item.Description;
quartzOptionDTO.RequestType = item.RequestType;
quartzOptionDTO.ParameterValue = item.ParameterValue;
quartzOptionDTO.TaskStatus = item.TaskStatus.GetEnumText();
return(quartzOptionDTO);
}
/// <summary>
/// add quartz base services
/// </summary>
/// <param name="services">service collection</param>
/// <param name="configuration">app config</param>
/// <returns></returns>
private static IServiceCollection RegisterQuartzBase(this IServiceCollection services,
IConfiguration configuration)
{
services.AddSingleton <IJobFactory, JobFactory>();
services.AddSingleton(provider =>
{
var option = new QuartzOption(configuration);
var schedulerFactory = new StdSchedulerFactory(option.ToProperties());
var scheduler = schedulerFactory.GetScheduler().Result;
scheduler.JobFactory = provider.GetService <IJobFactory>();
return(scheduler);
});
services.AddHostedService <QuartzService>();
return(services);
}
/// <summary>
/// 创建一个SimpleTrigger
/// </summary>
/// <param name="QuartzOptions"></param>
/// <returns></returns>
private static ITrigger CreateSimpleTrigger(this QuartzOption QuartzOptions)
{
if (QuartzOptions is null)
{
throw new ArgumentNullException(nameof(QuartzOptions));
}
var intervalArr = QuartzOptions.Interval.Split(',');
if (intervalArr.Length < 2 || !SimpleStrategy.Contains(intervalArr[0]) || !int.TryParse(intervalArr[1], out int time))
{
throw new IndexOutOfRangeException("CreateSimpleTrigger 轮询策略 错误，必须为 ss,时间,mm,时间,HH,时间 ");
}
var timeType = intervalArr[0];
return(QuartzOptions.GetTriggerBuilder()
.WithSimpleSchedule(scheduleBuilder =>
{
switch (timeType)
{
case "ss":
scheduleBuilder.WithIntervalInSeconds(time);
break;
case "mm":
scheduleBuilder.WithIntervalInMinutes(time);
break;
case "HH":
scheduleBuilder.WithIntervalInHours(time);
break;
default:
throw new NotImplementedException();
}
if (QuartzOptions.RunTimes > 0)
{
scheduleBuilder.WithRepeatCount(QuartzOptions.RunTimes);
}
else
{
scheduleBuilder.RepeatForever();
}
}).Build());
}
public async Task Update(int id, QuartzOptionDTO quartzOptionDTO)
{
Valid(quartzOptionDTO);
QuartzOption quartzOption = _quartzOptionRepository.SelectById(id);
await _schedulerFactory.TriggerAction(quartzOption, JobAction.修改);
quartzOption.JobName = quartzOptionDTO.JobName;
quartzOption.GroupName = quartzOptionDTO.GroupName;
quartzOption.Cron = quartzOptionDTO.Cron;
quartzOption.Api = quartzOptionDTO.Api;
quartzOption.RequestType = quartzOptionDTO.RequestType;
quartzOption.ParameterValue = quartzOptionDTO.ParameterValue;
quartzOption.Description = quartzOptionDTO.Description;
quartzOption.TaskStatus = TaskStatus.暂停;
quartzOption.UpdateTime = DateTime.Now;
_quartzOptionRepository.Update(quartzOption);
await _schedulerFactory.AddJob(quartzOption);
}
/// <summary>
/// 添加作业
/// </summary>
/// <param name="schedulerFactory"></param>
/// <param name="quartzOption"></param>
/// <returns></returns>
public static async Task AddJob(this ISchedulerFactory schedulerFactory, QuartzOption quartzOption)
{
bool validCron = quartzOption.Cron.ValidCron();
if (validCron == false)
{
throw new ArgumentException("表达式格式错误");
}
IJobDetail job = JobBuilder.Create <Job>().WithIdentity(quartzOption.JobName, quartzOption.GroupName).Build();
ITrigger trigger = TriggerBuilder.Create().WithIdentity(quartzOption.JobName, quartzOption.GroupName).
StartNow().WithDescription(quartzOption.Description).WithCronSchedule(quartzOption.Cron).Build();
IScheduler scheduler = await schedulerFactory.GetScheduler();
await scheduler.ScheduleJob(job, trigger);
await scheduler.Start();
await scheduler.PauseTrigger(trigger.Key);
}
static void Main(string[] args)
{
var host = new HostBuilder()
.ConfigureHostConfiguration(configHost =>
{
configHost.SetBasePath(Directory.GetCurrentDirectory());
configHost.AddEnvironmentVariables("ASPNETCORE_");
})
.ConfigureAppConfiguration((hostContext, configApp) =>
{
configApp.AddJsonFile("appsettings.json", true);
configApp.AddJsonFile($"appsettings.{hostContext.HostingEnvironment.EnvironmentName}.json", true);
configApp.AddEnvironmentVariables();
})
.ConfigureServices((hostContext, services) =>
{
//配置服务及依赖注入注册，注：没有Middleware的配置了。
services.AddLogging();
services.AddSingleton <IJobFactory, JobFactory>();
services.AddSingleton(provider =>
{
var option = new QuartzOption(hostContext.Configuration);
var sf = new StdSchedulerFactory(option.ToProperties());
var scheduler = sf.GetScheduler().Result;
scheduler.JobFactory = provider.GetService <IJobFactory>();
return(scheduler);
});
services.AddHostedService <QuartzService>();
services.AddSingleton <RabbitMqJob, RabbitMqJob>();
services.AddSingleton <WeatherJob, WeatherJob>();
})
.ConfigureLogging((hostContext, configLogging) =>
{
configLogging.AddConsole();
configLogging.AddDebug();
})
.UseConsoleLifetime()
.Build();
host.Run();
}
/// <summary>
///创建一个基础TriggerBuilder
/// </summary>
/// <param name="QuartzOptions"></param>
/// <returns></returns>
private static TriggerBuilder GetTriggerBuilder(this QuartzOption QuartzOptions)
{
// 作业触发器
var triggerBuilder = TriggerBuilder.Create()
.WithIdentity(QuartzOptions.TaskName, QuartzOptions.GroupName)
.ForJob(QuartzOptions.TaskName, QuartzOptions.GroupName);//作业名称
if (QuartzOptions.BeginTime == null)
{
triggerBuilder = triggerBuilder.StartNow();
}
else
{
triggerBuilder = triggerBuilder.StartAt(((DateTime)QuartzOptions.BeginTime).ToDateTimeOffset());
}
if (QuartzOptions.EndTime != null)
{
triggerBuilder = triggerBuilder.EndAt(((DateTime)QuartzOptions.EndTime).ToDateTimeOffset());
}
return(triggerBuilder);
}
public async Task AddJob(QuartzOptionDTO quartzOptionDTO)
{
Valid(quartzOptionDTO);
int count = _quartzOptionRepository.SelectCount(s => s.GroupName == quartzOptionDTO.GroupName && s.JobName == quartzOptionDTO.JobName);
if (count > 0)
{
throw new ArgumentException(string.Format("分组：{0}，作业：{1}已存在", quartzOptionDTO.GroupName, quartzOptionDTO.JobName));
}
QuartzOption quartzOption = new QuartzOption();
quartzOption.JobName = quartzOptionDTO.JobName;
quartzOption.GroupName = quartzOptionDTO.GroupName;
quartzOption.Cron = quartzOptionDTO.Cron;
quartzOption.Api = quartzOptionDTO.Api;
quartzOption.RequestType = quartzOptionDTO.RequestType;
quartzOption.ParameterValue = quartzOptionDTO.ParameterValue;
quartzOption.Description = quartzOptionDTO.Description;
quartzOption.TaskStatus = TaskStatus.暂停;
quartzOption.CreateTime = DateTime.Now;
_quartzOptionRepository.Insert(quartzOption);
await _schedulerFactory.AddJob(quartzOption);
}
/// <summary>
/// 创建基于HTTP请求的任务
/// </summary>
/// <param name="QuartzOptions"></param>
/// <returns></returns>
private static IJobDetail CreateJobDetailByApiUrl(QuartzOption QuartzOptions)
{
try
{
var requestResult = QuartzOptions.ExecuteType == ExecuteType.Get ? HttpHelper.HttpGet(QuartzOptions.TaskTarget) : HttpHelper.HttpPost(QuartzOptions.TaskTarget);
}
catch (Exception e)
{
logger.LogError(e.StackTrace);
return(null);
}
var job = JobBuilder.Create <HttpJob>()
.WithIdentity(QuartzOptions.TaskName, QuartzOptions.GroupName)
//.UsingJobData("","")--传参
.Build();
if (QuartzOptions.TaskData != null)
{
job.JobDataMap.Add(typeof(HttpJob).Name, QuartzOptions.TaskData);
}
return(job);
}
/// <summary>
/// 创建基于扩展类的任务
/// </summary>
/// <param name="QuartzOptions"></param>
/// <returns></returns>
private static IJobDetail CreateJobDetailByAssembly(QuartzOption QuartzOptions)
{
IJobDetail job;
var assemblyClassInfo = QuartzOptions.TaskTarget.Split(',');
//加载类型---Assembly,namespace.ClassName
Assembly assembly = Assembly.Load(new AssemblyName(assemblyClassInfo[0]));
Type type = assembly.GetType(assemblyClassInfo[1]);
if (type == null)
{
throw new NullReferenceException("指定类型不存在");
}
if (!typeof(IJob).IsAssignableFrom(type))
{
throw new NotImplementedException("指定类型未实现IJob接口");
}
job = new JobDetailImpl(QuartzOptions.TaskName, QuartzOptions.GroupName, type);
if (QuartzOptions.TaskData != null)
{
job.JobDataMap.Add(type.Name, QuartzOptions.TaskData);
}
return(job);
}
/// <summary>
/// 获取所有的作业
/// </summary>
/// <param name="schedulerFactory"></param>
/// <returns></returns>
public static async Task <List <QuartzOption> > GetJobs(this ISchedulerFactory schedulerFactory)
{
List <QuartzOption> list = new List <QuartzOption>();
try
{
var groups = await scheduler.GetJobGroupNames();
foreach (var groupName in groups)
{
foreach (var jobKey in await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals(groupName)))
{
QuartzOption QuartzOptions = _taskList.Where(x => x.GroupName == jobKey.Group && x.TaskName == jobKey.Name)
.FirstOrDefault();
if (QuartzOptions == null)
{
continue;
}
var triggers = await scheduler.GetTriggersOfJob(jobKey);
foreach (ITrigger trigger in triggers)
{
DateTimeOffset?dateTimeOffset = trigger.GetPreviousFireTimeUtc();
QuartzOptions.LastRunTime = Convert.ToDateTime(dateTimeOffset.ToString());
}
list.Add(QuartzOptions);
}
}
}
catch (Exception ex)
{
//FileQuartz.WriteStartLog("获取作业异常：" + ex.Message + ex.StackTrace);
}
return(list);
}
private static async Task MainAsync()
{
var host = new HostBuilder()
.ConfigureHostConfiguration(configHost =>
{
//配置根目录
configHost.SetBasePath(Directory.GetCurrentDirectory());
//读取host的配置json，和appsetting类似，暂不需要先注释掉，可根据需要开启
//configHost.AddJsonFile("hostsettings.json", true, true);
//读取环境变量，Asp.Net core默认的环境变量是以ASPNETCORE_作为前缀的，这里也采用此前缀以保持一致
configHost.AddEnvironmentVariables("ASPNETCORE_");
//可以在启动host的时候之前可传入参数，暂不需要先注释掉，可根据需要开启
//configHost.AddCommandLine(args);
})
.ConfigureAppConfiguration((hostContext, configApp) =>
{
//读取应用的配置json
configApp.AddJsonFile("appsettings.json", true);
//读取应用特定环境下的配置json
configApp.AddJsonFile($"appsettings.{hostContext.HostingEnvironment.EnvironmentName}.json", true);
//读取环境变量
configApp.AddEnvironmentVariables();
//可以在启动host的时候之前可传入参数，暂不需要先注释掉，可根据需要开启
//configApp.AddCommandLine(args);
})
.ConfigureServices((hostContext, services) =>
{
services.AddLogging();
services.AddSingleton <FirmService>();
services.AddSingleton <PassportService>();
services.AddSingleton <BaseRepository>();
services.AddSingleton <FirmRepository>();
services.AddSingleton <UserRepository>();
services.AddSingleton <TbdFirmService>();
services.AddSingleton <IJobFactory, JobFactory>();
services.AddSingleton(provider =>
{
var option = new QuartzOption(hostContext.Configuration);
var sf = new StdSchedulerFactory(option.ToProperties());
var scheduler = sf.GetScheduler().Result;
scheduler.JobFactory = provider.GetService <IJobFactory>();
return(scheduler);
});
services.AddHostedService <SyncFirmHostedService>();
services.AddSingleton <TestJob>();
services.AddSingleton <SyncFirmJob>();
})
.ConfigureLogging((hostContext, configLogging) =>
{
//输出控制台日志
configLogging.AddConsole();
configLogging.AddNLog();
NLogBuilder.ConfigureNLog("nlog.config");
//开发环境输出Debug日志
if (hostContext.HostingEnvironment.EnvironmentName == EnvironmentName.Development)
{
configLogging.AddDebug();
}
})
.UseConsoleLifetime()//使用控制台生命周期 使用Ctrl+C退出
.Build();
await host.RunAsync();
}
public static async Task <string> TriggerAction(this ISchedulerFactory schedulerFactory, QuartzOption quartzOption, JobAction action)
{
try
{
IScheduler scheduler = await schedulerFactory.GetScheduler();
List <JobKey> jobKeys = scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals(quartzOption.GroupName)).Result.ToList();
if (jobKeys == null || jobKeys.Count() == 0)
{
return(string.Format("未找到分组：{0}", quartzOption.GroupName));
}
JobKey jobKey = jobKeys.Where(s => scheduler.GetTriggersOfJob(s).Result.Any(x => (x as CronTriggerImpl).Name == quartzOption.JobName)).FirstOrDefault();
if (jobKey == null)
{
return(string.Format("未找到触发器：{0}", quartzOption.JobName));
}
var triggers = await scheduler.GetTriggersOfJob(jobKey);
ITrigger trigger = triggers?.Where(x => (x as CronTriggerImpl).Name == quartzOption.JobName).FirstOrDefault();
if (trigger == null)
{
return(string.Format("未找到触发器：{0}", quartzOption.JobName));
}
switch (action)
{
case JobAction.除:
case JobAction.修改:
await scheduler.PauseTrigger(trigger.Key);
await scheduler.UnscheduleJob(trigger.Key); // 移除触发器
await scheduler.DeleteJob(trigger.JobKey);
break;
case JobAction.暂停:
case JobAction.停止:
case JobAction.开启:
if (action == JobAction.暂停)
{
await scheduler.PauseTrigger(trigger.Key);
}
else if (action == JobAction.开启)
{
await scheduler.ResumeTrigger(trigger.Key);
//await scheduler.ResumeTrigger(trigger.Key);
}
else
{
await scheduler.Shutdown();
}
break;
case JobAction.立即执行:
await scheduler.TriggerJob(jobKey);
break;
}
return(string.Format("{0}成功", action.GetEnumText()));
}
catch (Exception ex)
{
return(string.Format("{0}失败：", action.GetEnumText(), ex.Message));
}
}
/// <summary>
/// 移除作业
/// </summary>
/// <param name="schedulerFactory"></param>
/// <returns></returns>
public async static Task <QuartzResult> Remove(this ISchedulerFactory schedulerFactory, QuartzOption QuartzOptions)
{
return(await schedulerFactory.TriggerAction(JobAction.Delete, QuartzOptions));
}
/// <summary>
/// 更新作业
/// </summary>
/// <param name="schedulerFactory"></param>
/// <param name="QuartzOptions"></param>
/// <returns></returns>
public async static Task <QuartzResult> Update(this ISchedulerFactory schedulerFactory, QuartzOption QuartzOptions)
{
return(await schedulerFactory.TriggerAction(JobAction.Modify, QuartzOptions));
}
public QuartzOptionDTO GetById(int id)
{
QuartzOption quartzOption = _quartzOptionRepository.SelectById(id);
return(ConvertToDTO(quartzOption));
}
/// <summary>
/// 立即执行一次作业
/// </summary>
/// <param name="schedulerFactory"></param>
/// <param name="QuartzOptions"></param>
/// <returns></returns>
public async static Task <QuartzResult> Run(this ISchedulerFactory schedulerFactory, QuartzOption QuartzOptions)
{
return(await schedulerFactory.TriggerAction(JobAction.StartNow, QuartzOptions));
}
/// <summary>
/// 触发新增、删除、修改、暂停、启用、立即执行事件
/// </summary>
/// <param name="schedulerFactory"></param>
/// <param name="action"></param>
/// <param name="QuartzOptions"></param>
/// <returns></returns>
public static async Task <QuartzResult> TriggerAction(this ISchedulerFactory schedulerFactory, JobAction action, QuartzOption QuartzOptions)
{
try
{
List <JobKey> jobKeys = scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals(QuartzOptions.GroupName)).Result.ToList();
if (jobKeys == null || jobKeys.Count() == 0)
{
return(QuartzResult.Error($"未找到分组[{QuartzOptions.GroupName}]"));
}
JobKey jobKey = jobKeys?.Where(x => x.Name == QuartzOptions.TaskName && x.Group == QuartzOptions.GroupName)?.FirstOrDefault();
if (jobKey == null)
{
return(QuartzResult.Error($"未找到触发器[{QuartzOptions.TaskName}]"));
}
var triggers = await scheduler.GetTriggersOfJob(jobKey);
ITrigger trigger = triggers?.Where(x => x.JobKey.Name == QuartzOptions.TaskName && x.JobKey.Group == QuartzOptions.GroupName).FirstOrDefault();
if (trigger == null)
{
return(QuartzResult.Error($"未找到触发器[{QuartzOptions.TaskName}]"));
}
object result = null;
switch (action)
{
case JobAction.Delete:
case JobAction.Modify:
await scheduler.PauseTrigger(trigger.Key);
await scheduler.UnscheduleJob(trigger.Key); // 移除触发器
await scheduler.DeleteJob(trigger.JobKey);
result = schedulerFactory.ModifyTaskEntity(QuartzOptions, action);
break;
case JobAction.Pause:
case JobAction.Stop:
case JobAction.Start:
result = schedulerFactory.ModifyTaskEntity(QuartzOptions, action);
if (action == JobAction.Pause)
{
await scheduler.PauseTrigger(trigger.Key);
}
else if (action == JobAction.Start)
{
await scheduler.ResumeTrigger(trigger.Key);
// await scheduler.RescheduleJob(trigger.Key, trigger);
}
else
{
await scheduler.Shutdown();
}
break;
case JobAction.StartNow:
await scheduler.TriggerJob(jobKey);
break;
}
return(QuartzResult.Ok("成功"));
}
catch (Exception ex)
{
return(QuartzResult.Error($"失败 {ex.StackTrace}"));
}
finally
{
}
}
public static void Main(string[] args)
{
var host = new HostBuilder()
.ConfigureHostConfiguration(configHost =>
{
configHost.SetBasePath(Directory.GetCurrentDirectory());
//configHost.AddJsonFile("hostsettings.json", true, true);
configHost.AddEnvironmentVariables("ASPNETCORE_");
//configHost.AddCommandLine(args);
})
.ConfigureAppConfiguration((hostContext, configApp) =>
{
configApp.AddJsonFile("appsettings.json", true);
//configApp.AddJsonFile($"appsettings.{hostContext.HostingEnvironment.EnvironmentName}.json", true);
configApp.AddEnvironmentVariables();
//configApp.AddCommandLine(args);
})
.ConfigureServices((hostContext, services) =>
{
services.AddLogging();
//services.AddHostedService<TimedHostedService>();
services.AddSingleton <IJobFactory, JobFactory>();
services.AddSingleton <IHello, Hello>();
services.AddSingleton(provider =>
{
var option = new QuartzOption(hostContext.Configuration);
var sf = new StdSchedulerFactory(option.ToProperties());
var scheduler = sf.GetScheduler().Result;
super_scheduler = scheduler;
////3.创建计划
//var trigger = TriggerBuilder.Create()
//.WithSimpleSchedule(x => x.WithIntervalInSeconds(2).RepeatForever())//每两秒执行一次
//.Build();
////4、创建任务
//var jobDetail = JobBuilder.Create<TibosJob>()
// .WithIdentity("job", "group4")
// .Build();
//scheduler.ScheduleJob(jobDetail, trigger);
scheduler.JobFactory = provider.GetService <IJobFactory>();
return(scheduler);
});
services.AddHostedService <QuartzService>();
services.AddSingleton <TestJob, TestJob>();
services.AddSingleton <TibosJob, TibosJob>();
RPCServer rPCServer = new RPCServer(9988);
rPCServer.RegisterService <IHello, Hello>();
rPCServer.Start();
Console.WriteLine("服务端启动了");
})
.ConfigureLogging((hostContext, configLogging) =>
{
configLogging.AddConsole();
if (hostContext.HostingEnvironment.EnvironmentName == EnvironmentName.Development)
{
configLogging.AddDebug();
}
})
.UseConsoleLifetime()
.Build();
host.Run();
Console.ReadLine();
}
/// <summary>
/// 添加任务调度（指定IJob实现类）
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="QuartzOptions"></param>
/// <returns></returns>
public static async Task <QuartzResult> AddJob <T>(this ISchedulerFactory schedulerFactory, QuartzOption QuartzOptions) where T : IJob
{
if (QuartzOptions is null)
{
throw new ArgumentNullException(nameof(QuartzOptions));
}
if (scheduler == null)
{
scheduler = schedulerFactory?.GetScheduler().Result;
}
try
{
//检查任务是否已存在
if (await scheduler.CheckExists(new JobKey(QuartzOptions.TaskName, QuartzOptions.GroupName)))
{
return(QuartzResult.Error($"任务 {QuartzOptions.TaskName},任务组 {QuartzOptions.GroupName} 已存在"));
}
// 定义这个工作，并将其绑定到我们的IJob实现类
IJobDetail jobDetail = CreateJobDetail <T>(QuartzOptions);//JobBuilder.CreateForAsync<T>().WithIdentity(Option.TaskName, Option.GroupName).Build();
// 创建触发器
ITrigger trigger;
if (QuartzOptions.IntervalType == IntervalType.Cron)
{
if (!CronExpression.IsValidExpression(QuartzOptions.Interval))
{
return(QuartzResult.Error($"请确认表达式{QuartzOptions.Interval}是否正确!"));
}
trigger = QuartzOptions.CreateCronTrigger();
}
else
{
trigger = CreateSimpleTrigger(QuartzOptions);
}
// 设置监听器
//JobListener listener = new JobListener();
//// IMatcher<JobKey> matcher = KeyMatcher<JobKey>.KeyEquals(job.Key);
//scheduler.ListenerManager.AddJobListener(listener, GroupMatcher<JobKey>.AnyGroup());
await scheduler.ScheduleJob(jobDetail, trigger);
if (QuartzOptions.TaskStatus == TriggerState.Normal)
{
await scheduler.Start();
}
else
{
await schedulerFactory.Pause(QuartzOptions);
}
logger.LogDebug($"作业:{QuartzOptions.TaskName},目标:{QuartzOptions.TaskTarget},分组:{QuartzOptions.GroupName},状态为:{QuartzOptions.TaskStatus}");
return(QuartzResult.Ok("添加成功"));
}
catch (Exception ex)
{
logger.LogError($"添加任务出错--{ex.StackTrace}");
return(QuartzResult.Error($"添加任务出错--{ex.StackTrace}"));
}
}
