public IReadOnlyCollection <Schedule> FilterBy(string description) => _scheduler .GetTriggerKeys(GroupMatcher <TriggerKey> .AnyGroup()) .Select(k => _scheduler.GetTrigger(k)) .Where(t => t.Description.StartsWith(description, true, CultureInfo.CurrentCulture)) .Select(Convert) .ToList();
public JsonResult RemoveCalendar(string calendarname)
{
try
{
//遍历所有的trigger，然后删除 deleteCalendar
var triggerkeys = scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .AnyGroup());
foreach (var tkey in triggerkeys)
{
var trigger = scheduler.GetTrigger(tkey);
if (trigger.CalendarName == calendarname)
{
var newtrigger = trigger.GetTriggerBuilder().ModifiedByCalendar(null).Build();
scheduler.RescheduleJob(newtrigger.Key, newtrigger);
}
}
//只有先解除引用，才能删除calendar
var isSuccess = scheduler.DeleteCalendar(calendarname);
return(Json(1));
}
catch (Exception ex)
{
throw;
}
}
/// <summary>
/// 删除指定分组的Jobs
/// </summary>
/// <param name="group">Job分组名称</param>
/// <param name="compareWith">分组名称匹配规则</param>
/// <returns>true if all of the Jobs were found and deleted, false if one or more were not</returns>
public static async Task <bool> DeleteJobsAsync(string group, StringOperator compareWith)
{
GroupMatcher <JobKey> matcher;
if (Equals(compareWith, StringOperator.Contains))
{
matcher = GroupMatcher <JobKey> .GroupContains(group);
}
else if (Equals(compareWith, StringOperator.EndsWith))
{
matcher = GroupMatcher <JobKey> .GroupEndsWith(group);
}
else if (Equals(compareWith, StringOperator.Equality))
{
matcher = GroupMatcher <JobKey> .GroupEquals(group);
}
else if (Equals(compareWith, StringOperator.StartsWith))
{
matcher = GroupMatcher <JobKey> .GroupStartsWith(group);
}
else
{
matcher = GroupMatcher <JobKey> .AnyGroup();
}
return(await GetScheduler().DeleteJobs((await GetScheduler().GetJobKeys(matcher)).ToList()));
}
public async Task <IActionResult> Index()
{
var keys = (await Scheduler.GetJobKeys(GroupMatcher <JobKey> .AnyGroup())).OrderBy(x => x.ToString());
var list = new List <JobListItem>();
var knownTypes = new List <string>();
foreach (var key in keys)
{
var detail = await GetJobDetail(key);
var item = new JobListItem()
{
Concurrent = !detail.ConcurrentExecutionDisallowed,
Persist = detail.PersistJobDataAfterExecution,
Recovery = detail.RequestsRecovery,
JobName = key.Name,
Group = key.Group,
Type = detail.JobType.FullName,
History = Histogram.Empty,
Description = detail.Description,
};
knownTypes.Add(detail.JobType.RemoveAssemblyDetails());
list.Add(item);
}
Services.Cache.UpdateJobTypes(knownTypes);
ViewBag.Groups = (await Scheduler.GetJobGroupNames()).GroupArray();
return(View(list));
}
/// <summary>
/// 返回job对应的trigger
/// </summary>
/// <param name="jobName">任务名称</param>
/// <returns></returns>
public async Task <List <ITrigger> > GetJobToTrig(string jobName)
{
JobKey jobKey = (await sched.GetJobKeys(GroupMatcher <JobKey> .AnyGroup())).Where(b => b.Name == jobName).FirstOrDefault();
List <ITrigger> triggerList = (await sched.GetTriggersOfJob(jobKey)).ToList();
return(triggerList);
}
/// <summary>
/// Get a specified number of upcoming jobs
/// </summary>
/// <param name="count"></param>
/// <returns></returns>
public IEnumerable <FireInstance> GetUpcomingJobs(int count)
{
IList <FireInstance> temp = new List <FireInstance>();
var allTriggerKeys = _scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .AnyGroup());
foreach (var triggerKey in allTriggerKeys)
{
ITrigger trigger = _scheduler.GetTrigger(triggerKey);
ICalendar cal = null;
if (!string.IsNullOrEmpty(trigger.CalendarName))
{
cal = _scheduler.GetCalendar(trigger.CalendarName);
}
var fireTimes = TriggerUtils.ComputeFireTimes(trigger as IOperableTrigger, cal, count);
foreach (var dateTimeOffset in fireTimes)
{
temp.Add(new FireInstance
{
FireTimeUtc = dateTimeOffset,
JobName = trigger.JobKey.Name,
JobGroup = trigger.JobKey.Group,
TriggerName = trigger.Key.Name,
TriggerGroup = trigger.Key.Group,
JobId = _persistanceStore.GetJobId(trigger.JobKey)
});
}
}
IList <FireInstance> retval = temp.OrderBy(i => i.FireTimeUtc).Take(count).ToList();
return(retval);
}
public async Task <List <JobInfo> > GetAllTasks()
{
var jobList = new List <JobInfo>();
if (string.IsNullOrEmpty(SchedulerName))
{
return(jobList);
}
Scheduler = await _factory.GetScheduler(SchedulerName);
if (Scheduler != null)
{
var tasks = await Scheduler.GetJobKeys(GroupMatcher <JobKey> .AnyGroup());
foreach (var task in tasks)
{
var detail = await Scheduler.GetJobDetail(task);
var triggers = await Scheduler.GetTriggersOfJob(task);
jobList.Add(new JobInfo
{
Name = task.Name,
Description = detail?.Description,
Trigger = ProcessTriggers(triggers)
});
}
}
return(jobList);
}
public async Task JobExecution()
{
Assert.That(TestJob.Executed, Is.False);
var jobDetail = JobBuilder
.Create <TestJob>()
.Build();
var trigger = TriggerBuilder.Create()
.StartNow()
.Build();
var scheduler = _container.Resolve <IScheduler>();
scheduler.ListenerManager.AddJobListener(
_container.Resolve <IJobListener>(),
GroupMatcher <JobKey> .AnyGroup());
await scheduler.Start();
await scheduler.ScheduleJob(jobDetail, trigger);
Assert.That(await Task.Run(() => TestJob.AutoResetEvent.WaitOne(1000)), Is.True);
Assert.That(TestJob.Executed, Is.True);
await scheduler.Shutdown();
}
static async Task MainAsync()
{
var schedulerFactory = new StdSchedulerFactory();
var scheduler = await schedulerFactory.GetScheduler();
await scheduler.Start();
Console.WriteLine($"任务调度器已启动");
//添加Listener
scheduler.ListenerManager.AddJobListener(new MyJobListener(), GroupMatcher <JobKey> .AnyGroup());
scheduler.ListenerManager.AddTriggerListener(new MyTriggerListener(), GroupMatcher <TriggerKey> .AnyGroup());
//await ScheduleHelloQuartzJob(scheduler);
await ScheduleSayHelloJob(scheduler);
await Task.Delay(TimeSpan.FromSeconds(5));
//获取JobDetail
var jobDetail = await scheduler.GetJobDetail(new JobKey("SayHelloJob-Tom", "DemoGroup"));
if (jobDetail != null)
{
var runSuccess = jobDetail.JobDataMap.Get("RunSuccess");
Console.WriteLine($"{jobDetail.Key} run success: {runSuccess}");
}
else
{
Console.WriteLine($"获取JobDetail失败");
}
}
static void Main(string[] args)
{
var scheduler = new StdSchedulerFactory().GetScheduler();
// add scheduler listener
scheduler.ListenerManager.AddSchedulerListener(new SchedulerListener());
// add global job listener
scheduler.ListenerManager.AddJobListener(new JobListener(), GroupMatcher <JobKey> .AnyGroup());
// add global trigger listener
scheduler.ListenerManager.AddTriggerListener(new TriggerListener(), GroupMatcher <TriggerKey> .AnyGroup());
// add jobs & triggers
scheduler.ScheduleJob(
JobBuilder.Create <ExampleJob>().WithIdentity("MyJob", "MyJobGroup").Build(),
TriggerBuilder.Create().WithIdentity("MyTrigger", "MyTriggerGroup")
.WithSimpleSchedule(s => s.WithIntervalInSeconds(2).RepeatForever()).Build());
scheduler.Start(); // start scheduler
Thread.Sleep(5000); // sleep the main thread (Quartz will fire the job 3x on other threads)
scheduler.Shutdown(true); // stop the scheduler
Console.ReadLine();
}
static void Main(string[] args)
{
var properties = new NameValueCollection();
properties["quartz.scheduler.instanceName"] = "RemoteServer";
properties["quartz.threadPool.type"] = "Quartz.Simpl.SimpleThreadPool, Quartz";
properties["quartz.threadPool.threadCount"] = "5";
properties["quartz.threadPool.threadPriority"] = "Normal";
//properties["quartz.scheduler.exporter.type"] = "Quartz.Simpl.RemotingSchedulerExporter, Quartz";
properties["quartz.scheduler.exporter.port"] = "555"; //端口号
properties["quartz.scheduler.exporter.bindName"] = "QuartzScheduler"; //名称
properties["quartz.scheduler.exporter.channelType"] = "tcp"; //通道类型
properties["quartz.scheduler.exporter.channelName"] = "httpQuartz";
properties["quartz.scheduler.exporter.rejectRemoteRequests"] = "true";
properties["quartz.jobStore.clustered"] = "true"; //集群配置
//指定quartz持久化数据库的配置
properties["quartz.jobStore.type"] = "Quartz.Impl.AdoJobStore.JobStoreTX, Quartz"; //存储类型
properties["quartz.serializer.type"] = "json";
properties["quartz.jobStore.tablePrefix"] = "Qrtz_"; //表名前缀
properties["quartz.jobStore.driverDelegateType"] = "Quartz.Impl.AdoJobStore.SqlServerDelegate, Quartz"; //驱动类型
properties["quartz.jobStore.dataSource"] = "myDS"; //数据源名称
properties["quartz.dataSource.myDS.connectionString"] = @"Data Source=.;Initial Catalog=QuartzManager;User ID=sa;Password=123456"; //连接字符串
properties["quartz.dataSource.myDS.provider"] = "SqlServer"; //数据库版本
properties["quartz.scheduler.instanceId"] = "AUTO";
var schedulerFactory = new StdSchedulerFactory(properties);
var scheduler = schedulerFactory.GetScheduler().Result;
scheduler.ListenerManager.AddJobListener(new QuartzJobListener(), GroupMatcher <JobKey> .AnyGroup());
scheduler.Start();
Console.ReadKey();
}
public async Task StartAsync()
{
_scheduler = await new StdSchedulerFactory().GetScheduler();
await _serviceProvider.DoDapperServiceAsync(DefaultDbConfig, async (unitOfWork) =>
{
IJobConfigRepository jobConfigRepository = ConnectionFactory.GetConnectionProvider(DefaultDbConfig.ConnectionType).GetRepository <IJobConfigRepository>(unitOfWork);
IHolidayCalendarRepository holidayCalendarRepository = ConnectionFactory.GetConnectionProvider(DefaultDbConfig.ConnectionType).GetRepository <IHolidayCalendarRepository>(unitOfWork);
var activeJobConfigs = await jobConfigRepository.GetActiveJobConfigs();
List <HolidayCalendar> holidayCalendars = new List <HolidayCalendar>();
if (activeJobConfigs.Any(r => r.HolidayCalendarId.HasValue))
{
holidayCalendars = (await holidayCalendarRepository.GetAllAsync()).ToList();
Quartz.Impl.Calendar.HolidayCalendar calendar = new Quartz.Impl.Calendar.HolidayCalendar();
foreach (var holidayCalendar in holidayCalendars)
{
if (activeJobConfigs.Any(r => r.HolidayCalendarId == holidayCalendar.Id))
{
await AddCalendar(holidayCalendar);
}
}
}
foreach (var activeJobConfig in activeJobConfigs)
{
IJobDetail job = CreateJobDetail(activeJobConfig);
ITrigger trigger = CreateJobTriggerAsync(activeJobConfig, holidayCalendars);
await _scheduler.ScheduleJob(job, trigger);
}
_scheduler.ListenerManager.AddJobListener(QuartzJobListener, GroupMatcher <JobKey> .AnyGroup());
await _scheduler.Start();
});
}
public async Task <List <QuartzJobInfo> > GetAllQuartzJobConfigs()
{
List <QuartzJobInfo> quartzJobInfos = new List <QuartzJobInfo>();
var allJobKeys = await _scheduler.GetJobKeys(GroupMatcher <JobKey> .AnyGroup());
foreach (JobKey jobKey in allJobKeys)
{
var detail = await _scheduler.GetJobDetail(jobKey);
var triggers = await _scheduler.GetTriggersOfJob(jobKey);
var temptrigger = triggers.FirstOrDefault();
quartzJobInfos.Add(new QuartzJobInfo()
{
JobGroup = jobKey.Group,
JobName = jobKey.Name,
Description = detail.Description,
TriggerName = temptrigger.Key.Name,
StrTriggerState = _scheduler.GetTriggerState(temptrigger.Key).ToString(),
NextFireTime = temptrigger.GetNextFireTimeUtc()?.LocalDateTime,
PreviousFireTime = temptrigger.GetPreviousFireTimeUtc()?.LocalDateTime,
CalendarName = temptrigger.CalendarName,
Priority = temptrigger.Priority
});
}
return(quartzJobInfos);
}
public static IScheduler AddQuartzAndStart(this IServiceCollection services, string filename)
{
string connstr = BuildDatabase(filename);
NameValueCollection quartzProps = new NameValueCollection
{
{ "quartz.serializer.type", "json" },
{ "quartz.threadPool.type", "Quartz.Simpl.SimpleThreadPool, Quartz" },
{ "quartz.threadPool.threadCount", "10" },
{ "quartz.jobStore.type", "Quartz.Impl.AdoJobStore.JobStoreTX, Quartz" },
{ "quartz.jobStore.misfireThreshold", "60000" },
{ "quartz.jobStore.lockHandler.type", "Quartz.Impl.AdoJobStore.UpdateLockRowSemaphore, Quartz" },
{ "quartz.jobStore.dataSource", "default" },
{ "quartz.jobStore.tablePrefix", "qrtz_" },
{ "quartz.jobStore.driverDelegateType", "Quartz.Impl.AdoJobStore.SQLiteDelegate, Quartz" },
{ "quartz.dataSource.default.provider", "SQLite-Microsoft" },
{ "quartz.dataSource.default.connectionString", connstr }
};
StdSchedulerFactory factory = new StdSchedulerFactory(quartzProps);
IScheduler scheduler = factory.GetScheduler().GetAwaiter().GetResult();
services.AddSingleton(scheduler);
scheduler.ListenerManager.AddJobListener(new JobChainHandler(), GroupMatcher <JobKey> .AnyGroup());
scheduler.StartDelayed(TimeSpan.FromSeconds(5));
return(scheduler);
}
public async Task <IActionResult> AdditionalData()
{
var list = new List <object>();
if (histStore != null)
{
var keys = await Scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .AnyGroup());
//var history = await HistoryStore.FilterLastOfEveryTrigger(10);
var history = await histStore.FilterLastOfEveryJob(10);
var historyByTrigger = history.ToLookup(x => x.Trigger);
foreach (var key in keys)
{
list.Add(new
{
TriggerName = key.Name,
TriggerGroup = key.Group,
History = historyByTrigger.TryGet(key.ToString()).ToHistogram(),
});
}
}
return(View(list));
}
/// <summary>
/// Get all the fire times within a specified date range
/// </summary>
/// <param name="start"></param>
/// <param name="end"></param>
/// <returns></returns>
public IEnumerable <TriggerFireTime> GetFireTimesBetween(DateTime start, DateTime end)
{
IList <TriggerFireTime> retval = new List <TriggerFireTime>();
var allTriggerKeys = _scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .AnyGroup());
foreach (var triggerKey in allTriggerKeys)
{
ITrigger trigger = _scheduler.GetTrigger(triggerKey);
ICalendar cal = null;
if (!string.IsNullOrEmpty(trigger.CalendarName))
{
cal = _scheduler.GetCalendar(trigger.CalendarName);
}
var fireTimes = TriggerUtils.ComputeFireTimesBetween(trigger as IOperableTrigger, cal, start, end);
foreach (var fireTime in fireTimes)
{
retval.Add(new TriggerFireTime
{
FireDateTime = fireTime,
JobName = trigger.JobKey.Name,
JobGroup = trigger.JobKey.Group,
TriggerName = trigger.Key.Name,
TriggerGroup = trigger.Key.Group
});
}
}
return(retval);
}
public void GetJobNames_ForPresentJobs_ReturnsNames()
{
_mockScheduler.Expect(s => s.GetJobKeys(GroupMatcher <JobKey> .AnyGroup()))
.Return(new Quartz.Collection.HashSet <JobKey>()
{
JobKey.Create("job1", "SOD"), JobKey.Create("job2", "SOD")
});
IJobDetail job1 = GetMockJob("job1", "SOD");
IJobDetail job2 = GetMockJob("job2", "SOD");
var trigger = MockRepository.GenerateMock <ITrigger>();
trigger.Expect(t => t.GetNextFireTimeUtc()).Return(new DateTimeOffset(DateTime.UtcNow.AddMinutes(5))).Repeat.Twice();
trigger.Expect(t => t.Key).Return(new TriggerKey("someKey")).Repeat.Twice();
var triggers = new List <ITrigger>()
{
trigger
};
_mockScheduler.Expect(s => s.GetJobDetail(Arg <JobKey> .Is.TypeOf)).Return(job1).Repeat.Once();
_mockScheduler.Expect(s => s.GetJobDetail(Arg <JobKey> .Is.TypeOf)).Return(job2).Repeat.Once();
_mockScheduler.Expect(s => s.GetTriggersOfJob(Arg <JobKey> .Is.TypeOf)).Return(triggers).Repeat.Times(4);
_mockScheduler.Expect(s => s.GetTriggerState(Arg <TriggerKey> .Is.TypeOf)).Return(TriggerState.Normal).Repeat.Twice();
var result = _interactor.GetJobs();
Assert.AreEqual(2, result.Count);
Assert.AreEqual("SOD.job1", result[0].Name);
Assert.AreEqual("SOD.job2", result[1].Name);
job1.VerifyAllExpectations();
job2.VerifyAllExpectations();
}
public static List <TriggerInfo> GetAllTriggers(this IScheduler scheduler)
{
List <TriggerInfo> tr = new List <TriggerInfo>();
var allTriggerKeys = scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .AnyGroup());
foreach (var triggerKey in allTriggerKeys)
{
var triggerdetails = scheduler.GetTrigger(triggerKey);
var Jobdetails = scheduler.GetJobDetail(triggerdetails.JobKey);
var state = scheduler.GetTriggerState(triggerKey);
TriggerInfo ti = new TriggerInfo();
ti.TriggerKey = triggerdetails.Key.Name;
ti.JobName = triggerdetails.JobKey.Name;
ti.State = state.ToString();
var date = triggerdetails.GetNextFireTimeUtc()?.DateTime;
if (date.HasValue)
{
ti.NextFireTimeUTC = date.Value.ToLocalTime().ToString();
}
tr.Add(ti);
// Console.WriteLine("IsCompleted -" + triggerdetails.IsCompleted + " | TriggerKey - " + triggerdetails.Result.Key.Name + " Job key -" + triggerdetails.Result.JobKey.Name);
}
return(tr);
}
public async Task Start()
{
IServiceProvider serviceProvider = GetServiceProvider();
ISchedulerFactory sf = new StdSchedulerFactory();
_scheduler = await sf.GetScheduler();
await _scheduler.Start();
JobListener listener = serviceProvider.GetService <JobListener>();
_scheduler.ListenerManager.AddJobListener(listener, GroupMatcher <JobKey> .AnyGroup());//注册监听器
_scheduler.JobFactory = serviceProvider.GetService <JobFactory>();
IJobDetail job = JobBuilder.Create <JobService>()
.WithIdentity(JobHelper.BaseJobName, JobHelper.BaseJobGroup)
.Build();
ITrigger trigger = TriggerBuilder.Create()
.WithIdentity(JobHelper.BaseTriggerName, JobHelper.BaseTriggerGroup)
.StartNow()
.WithSimpleSchedule(x => x
.WithIntervalInSeconds(60)
.RepeatForever())
.Build();
await _scheduler.ScheduleJob(job, trigger);
}
public async Task <ActionResult <IEnumerable <JobDto> > > GetSchedulerJobs()
{
var jobKeys = await this._scheduler.GetJobKeys(GroupMatcher <JobKey> .AnyGroup());
var asyncJobs = jobKeys.Select(async key =>
{
var detail = await GetJobDetail(key.Name, key.Group);
var triggers = await this._scheduler.GetTriggersOfJob(key);
var nextFires = triggers.Select(x => x.GetNextFireTimeUtc()?.UtcDateTime).ToArray();
Dictionary <string, ExecutionHistoryEntry> historyByJob = await GetJobHistory();
return(new JobDto
{
Name = key.Name,
Group = key.Group,
Concurrent = !detail.ConcurrentExecutionDisallowed,
Persist = detail.PersistJobDataAfterExecution,
Recovery = detail.RequestsRecovery,
Type = detail.JobType.FullName,
Description = detail.Description,
// History = historyByJob?.GetValueOrDefault(key.ToString(), null), //.ToHistogram(),
NextFireTime = nextFires.Where(x => x != null).OrderBy(x => x).FirstOrDefault()
});
});
var jobTuples = await Task.WhenAll(asyncJobs);
return(Ok(jobTuples));
}
public async Task <IActionResult> AdditionalData()
{
var keys = await Scheduler.GetJobKeys(GroupMatcher <JobKey> .AnyGroup());
var history = await Scheduler.Context.GetExecutionHistoryStore().FilterLastOfEveryJob(10);
var historyByJob = history.ToLookup(x => x.Job);
var list = new List <object>();
foreach (var key in keys)
{
var triggers = await Scheduler.GetTriggersOfJob(key);
var nextFires = triggers.Select(x => x.GetNextFireTimeUtc()?.UtcDateTime).ToArray();
list.Add(new
{
JobName = key.Name, key.Group,
History = historyByJob.TryGet(key.ToString()).ToHistogram(),
NextFireTime = nextFires.Where(x => x != null).OrderBy(x => x).FirstOrDefault()?.ToDefaultFormat(),
});
}
return(View(list));
}
public static string[] list_jobs()
{
var a = m_scheduler.GetJobKeys(GroupMatcher <JobKey> .AnyGroup())
.GetAwaiter().GetResult().Select(x => x.Name).ToArray();
return(a);
}
/// <summary>
/// 返回所有任务键
/// </summary>
/// <returns></returns>
public async Task <List <JobKey> > GetJobAll()
{
//获取所有job
List <JobKey> jobKeys = (await sched.GetJobKeys(GroupMatcher <JobKey> .AnyGroup())).ToList();
return(jobKeys);
}
public async Task <ICollection <QuartzJob> > GetScheduledJobs()
{
var jobKeys = await _scheduler.GetJobKeys(GroupMatcher <JobKey> .AnyGroup());
return(jobKeys.Aggregate(new List <QuartzJob>(), (jobs, jobKey) =>
{
var jobDetail = _scheduler.GetJobDetail(jobKey).Result;
var quartzJob = new QuartzJob();
quartzJob.Name = jobDetail.Key.Name;
quartzJob.Group = jobDetail.Key.Group;
quartzJob.Parameters = GetParameters(jobDetail).ToArray();
var triggers = _scheduler.GetTriggersOfJob(jobDetail.Key).Result;
quartzJob.Triggers = triggers.Select(trigger => new QuartzTrigger()
{
Name = trigger.Key.Name,
Group = trigger.Key.Group,
NextFireTime = trigger.GetNextFireTimeUtc()
}).ToList();
jobs.Add(quartzJob);
return jobs;
}));
}
public JsonResult TriggerList()
{
List <CronTriggerImpl> triggerList = new List <CronTriggerImpl>();
//第一步：获取所有的trigger信息
var triggerKeys = scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .AnyGroup());
foreach (var triggerkey in triggerKeys)
{
var triggerDetail = (CronTriggerImpl)scheduler.GetTrigger(triggerkey);
triggerList.Add(triggerDetail);
}
var json = JsonConvert.SerializeObject(triggerList.Select(i => new
{
i.FullName,
i.FullJobName,
i.CronExpressionString,
JobClassName = scheduler.GetJobDetail(i.JobKey).JobType.FullName,
StartFireTime = i.StartTimeUtc.LocalDateTime.ToString("yyyy-MM-dd HH:mm:ss"),
PrevFireTime = i.GetPreviousFireTimeUtc()?.LocalDateTime.ToString("yyyy-MM-dd HH:mm:ss"),
NextFireTime = i.GetNextFireTimeUtc()?.LocalDateTime.ToString("yyyy-MM-dd HH:mm:ss"),
TriggerStatus = scheduler.GetTriggerState(new TriggerKey(i.Name, i.Group)).ToString(),
i.Priority,
i.Description,
i.Name,
i.Group,
i.CalendarName
}));
return(Json(json));
}
public async Task <IEnumerable <string> > GetAllJobGroups()
{
var jobGroups = (await _scheduler.GetJobKeys(GroupMatcher <JobKey> .AnyGroup()))
.Select(k => k.Group).Distinct();
return(jobGroups);
}
protected void AddJobListener()
{
//scheduler.ListenerManager.AddTriggerListener(new MyTriggerListener(), GroupMatcher<TriggerKey>.AnyGroup());
scheduler.ListenerManager.AddJobListener(new MyJobListener(), GroupMatcher <JobKey> .AnyGroup());
scheduler.ListenerManager.AddSchedulerListener(new MySchedulerListener());
}
public async Task <List <JobKeyWithDescription> > GetAllJobKeysWithDescription()
{
var jobKeys = await _scheduler.GetJobKeys(GroupMatcher <JobKey> .AnyGroup());
var jobKeysWithDescription = new List <JobKeyWithDescription>();
foreach (var jobKey in jobKeys)
{
var jobDetail = await _scheduler.GetJobDetail(jobKey);
var triggers = await _scheduler.GetTriggersOfJob(jobKey);
jobKeysWithDescription.Add(
new JobKeyWithDescription
{
JobName = jobKey.Name,
JobGroup = jobKey.Group,
Description = jobDetail.Description,
RequestRecovery = jobDetail.RequestsRecovery,
IsDurable = jobDetail.Durable,
Triggers = _mapper.Map <List <ITrigger>, List <TriggerKeyWithDescription> >(triggers.ToList())
});
}
return(jobKeysWithDescription);
}
public SchedulerData GetSchedulerData()
{
IScheduler scheduler = _scheduler;
SchedulerMetaData metadata = scheduler.GetMetaData();
IList <ExecutingJobInfo> inProgressJobs = metadata.SchedulerRemote ? (IList <ExecutingJobInfo>) new ExecutingJobInfo[0] :
scheduler
.GetCurrentlyExecutingJobs()
.Select(x => new ExecutingJobInfo
{
UniqueTriggerKey = x.Trigger.Key.ToString(),
FireInstanceId = x.FireInstanceId
})
.ToList();
return(new SchedulerData
{
Name = scheduler.SchedulerName,
InstanceId = scheduler.SchedulerInstanceId,
JobGroups = GetJobGroups(scheduler),
Status = GetSchedulerStatus(scheduler),
JobsExecuted = metadata.NumberOfJobsExecuted,
JobsTotal = scheduler.IsShutdown ? 0 : scheduler.GetJobKeys(GroupMatcher <JobKey> .AnyGroup()).Count,
RunningSince = metadata.RunningSince.ToDateTime(),
InProgress = inProgressJobs
});
}
/// <summary>
///
/// </summary>
/// <typeparam name="TJob"></typeparam>
/// <param name="keyValues"></param>
/// <param name="schedulerName"></param>
/// <returns></returns>
public async Task RunJobAsync <TJob>(JobDataMap keyValues = null, string schedulerName = "DefaultQuartzScheduler") where TJob : IJob
{
foreach (QuartzJobAttribute quartzJob in typeof(TJob).GetCustomAttributes(typeof(QuartzJobAttribute), true))
{
var scheduler = await _schedulerFactory.GetScheduler(schedulerName);
var jobKey = new JobKey(quartzJob.Name, quartzJob.Group);
scheduler.ListenerManager.AddJobListener(new JobListener(), GroupMatcher <JobKey> .AnyGroup());
if (await scheduler.CheckExists(jobKey))
{
await scheduler.ResumeJob(jobKey);
continue;
}
var jobDetail = JobBuilder.Create <TJob>()
.WithIdentity(quartzJob.Name, quartzJob.Group)
.Build();
var trigger = TriggerBuilder.Create()
.WithIdentity(quartzJob.Name, quartzJob.Group)
.StartNow();
if (!string.IsNullOrEmpty(quartzJob.Cron))
{
trigger.WithCronSchedule(quartzJob.Cron);
}
else
{
trigger.WithSimpleSchedule(x => x.WithRepeatCount(0));
}
await scheduler.ScheduleJob(jobDetail, trigger.Build());
}
}
