private static async Task DoJobEvery5Minutes <T>(string jobName, string triggerName, string groupName) where T : IJob { try { // Grab the Scheduler instance from the Factory var factory = new StdSchedulerFactory(new NameValueCollection { { "quartz.serializer.type", "binary" } }); var scheduler = await factory.GetScheduler(); // and start it off await scheduler.Start(); // define the job and tie it to our HelloJob class var job = JobBuilder.CreateForAsync <T>().WithIdentity(jobName, groupName).Build(); // Trigger the job to run now, and then repeat every 10 seconds var trigger = TriggerBuilder.Create().WithIdentity(triggerName, groupName).WithCronSchedule("0 0/2 * * * ?").Build(); // Tell quartz to schedule the job using our trigger await scheduler.ScheduleJob(job, trigger); // some sleep to show what's happening // await Task.Delay(TimeSpan.FromSeconds(10)); // and last shut down the scheduler when you are ready to close your program // await scheduler.Shutdown(); } catch (System.Exception ex) { _log.Error(ex); } }
/// <summary> /// 添加任务指定实现IJob接口的类 /// </summary> /// <typeparam name="T"></typeparam> /// <param name="quartz"></param> /// <returns></returns> public async Task <String> AddJob <T>(QuartzMap quartz) where T : IJob { try { await Instance.Result.Start(); JobKey key = new JobKey(quartz.JobName, quartz.JobGroup); //任务存在则先删除 if (await Instance.Result.CheckExists(key)) { await Instance.Result.DeleteJob(key); } IJobDetail job = JobBuilder.CreateForAsync <T>().WithIdentity(quartz.JobName, quartz.JobGroup).Build(); if (!string.IsNullOrEmpty(quartz.Cron) && CronExpression.IsValidExpression(quartz.Cron)) { await Instance.Result.ScheduleJob(job, CreateCronTrigger(quartz)); } else { await Instance.Result.ScheduleJob(job, CreateSimpleTrigger(quartz)); } return("添加任务成功!"); } catch (Exception) { throw new Exception("添加任务出错!"); } }
private async Task <SchedulingResult> ScheduleScramblingJob <JobType>(string jobName, string jobGroup, string triggerDescription, string cronExpression, string description, DatabasesConfig jobConfig) where JobType : IJob { if (!CronExpression.IsValidExpression(cronExpression)) { return(new SchedulingResult { IsSuccessful = false, ErrorMessage = "The cron expression is invalid." }); } var jobDetail = _scheduler.GetJobDetail(new JobKey(jobName, jobGroup)); if (_scheduler.GetJobDetail(new JobKey(jobName, jobGroup)).Status != TaskStatus.WaitingForActivation) { return(new SchedulingResult { IsSuccessful = false, ErrorMessage = "The jobname is already taken." }); } var job = JobBuilder.CreateForAsync <JobType>() .WithIdentity(jobName, jobGroup) .UsingJobData("configStr", JsonConvert.SerializeObject(jobConfig)) .WithDescription(description) .RequestRecovery() .Build(); var trigger = (ICronTrigger)TriggerBuilder.Create() .WithDescription(triggerDescription) .WithCronSchedule(cronExpression) .Build(); //Console.WriteLine($"Trigger before: name: {trigger.Key.Name} group: {trigger.Key.Group}" ); try { await _scheduler.ScheduleJob(job, trigger); //Console.WriteLine($"Trigger after: name: {trigger.Key.Name} group: {trigger.Key.Group}"); } catch (ObjectAlreadyExistsException ex) { return(new SchedulingResult { IsSuccessful = false, ErrorMessage = ex.Message }); } catch (JobPersistenceException ex) { return(new SchedulingResult { IsSuccessful = false, ErrorMessage = ex.Message }); } return(new SchedulingResult { IsSuccessful = true, JobKey = job.Key, TriggerKey = trigger.Key }); }
/// <summary> /// 添加一个工作调度 /// </summary> /// <param name="entity"></param> /// <returns></returns> public async Task <ApiResult <string> > AddScheduleJobAsync(ScheduleEntity entity) { var result = new ApiResult <string>() { statusCode = (int)ApiEnum.Error }; try { //检查任务是否已存在 var jobKey = new JobKey(entity.JobName, entity.JobGroup); if (await Scheduler.CheckExists(jobKey)) { result.message = "任务已存在"; return(result); } //http请求配置 var httpDir = new Dictionary <string, string>() { { "RequestUrl", entity.RequestUrl }, { "RequestParameters", entity.RequestParameters }, { "RequestType", ((int)entity.RequestType).ToString() }, { Constant.HEADERS, entity.Headers }, { Constant.MAILMESSAGE, ((int)entity.MailMessage).ToString() }, }; // 定义这个工作,并将其绑定到我们的IJob实现类 IJobDetail job = JobBuilder.CreateForAsync <HttpJob>() .SetJobData(new JobDataMap(httpDir)) .WithDescription(entity.Description) .WithIdentity(entity.JobName, entity.JobGroup) .Build(); // 创建触发器 ITrigger trigger; //校验是否正确的执行周期表达式 if (entity.TriggerType == TriggerTypeEnum.Cron)//CronExpression.IsValidExpression(entity.Cron)) { trigger = CreateCronTrigger(entity); } else { trigger = CreateSimpleTrigger(entity); } // 告诉Quartz使用我们的触发器来安排作业 await Scheduler.ScheduleJob(job, trigger); //判断是否暂停的任务 if (entity.TriggerState == TriggerState.Paused) { await Scheduler.PauseJob(new JobKey(entity.JobGroup, entity.JobName)); } result.statusCode = (int)ApiEnum.Status; } catch (Exception ex) { result.message = ex.Message; } return(result); }
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); }
/// <summary> /// 添加一个工作调度 /// </summary> /// <param name="entity"></param> /// <returns></returns> public async Task <ResultValue> AddScheduleHttpJobAsync(ScheduleEntity entity) { var result = new ResultValue(); try { //检查任务是否已存在 var jobKey = new JobKey(entity.JobName, entity.JobGroup); if (await Scheduler.CheckExists(jobKey)) { result.MsgCode = 3; result.Msg = "任务已存在"; return(result); } //http请求配置 var httpDir = new Dictionary <string, string>() { { Constant.REQUESTURL, entity.RequestUrl }, { Constant.TARGETTYPE, entity.TargetType }, { Constant.REQUESTPARAMETERS, entity.RequestParameters }, { Constant.REQUESTTYPE, ((int)entity.RequestType).ToString() }, { Constant.HEADERS, entity.Headers }, { Constant.MAILMESSAGE, ((int)entity.MailMessage).ToString() }, }; // 定义这个工作,并将其绑定到我们的IJob实现类 IJobDetail job = JobBuilder.CreateForAsync <HttpJob>() .SetJobData(new JobDataMap(httpDir)) .WithDescription(entity.Description) .WithIdentity(entity.JobName, entity.JobGroup) .Build(); // 创建触发器 ITrigger trigger; //校验是否正确的执行周期表达式 if (entity.TriggerType == TriggerTypeEnum.Cron || entity.TriggerType == TriggerTypeEnum.None)//CronExpression.IsValidExpression(entity.Cron)) { trigger = CreateCronTrigger(entity); } else { trigger = CreateSimpleTrigger(entity); } // 告诉Quartz使用我们的触发器来安排作业 await Scheduler.ScheduleJob(job, trigger); result.MsgCode = 1; result.Msg = "添加成功"; } catch (Exception ex) { result.MsgCode = 3; result.Msg = ex.Message; } return(result); }
public virtual async Task Run() { ILog log = LogProvider.GetLogger(typeof(AsyncExample)); var properties = new NameValueCollection { ["quartz.serializer.type"] = "json" }; ISchedulerFactory sf = new StdSchedulerFactory(properties); IScheduler sched = await sf.GetScheduler(); log.Info("------- Initialization Complete -----------"); log.Info("------- Scheduling Jobs -------------------"); IJobDetail job = JobBuilder .CreateForAsync <AsyncJob>() .WithIdentity("asyncJob") .Build(); ITrigger trigger = TriggerBuilder.Create() .WithIdentity("triggerForAsyncJob") .StartAt(DateTimeOffset.UtcNow.AddSeconds(1)) .WithSimpleSchedule(x => x.WithIntervalInSeconds(20).RepeatForever()) .Build(); await sched.ScheduleJob(job, trigger); log.Info("------- Starting Scheduler ----------------"); // start the schedule await sched.Start(); log.Info("------- Started Scheduler -----------------"); await Task.Delay(TimeSpan.FromSeconds(5)); log.Info("------- Cancelling job via scheduler.Interrupt() -----------------"); await sched.Interrupt(job.Key); log.Info("------- Waiting five minutes... -----------"); // wait five minutes to give our job a chance to run await Task.Delay(TimeSpan.FromMinutes(5)); // shut down the scheduler log.Info("------- Shutting Down ---------------------"); await sched.Shutdown(true); log.Info("------- Shutdown Complete -----------------"); }
/// <summary> /// 添加一个工作调度 /// </summary> /// <param name="entity"></param> /// <returns></returns> public async Task <BaseResult> AddScheduleJobAsync(ScheduleEntity entity) { var result = new BaseResult(); try { //检查任务是否已存在 var jobKey = new JobKey(entity.JobName, entity.JobGroup); if (await Scheduler.CheckExists(jobKey)) { result.Code = 500; result.Msg = "任务已存在"; return(result); } //http请求配置 var httpDir = new Dictionary <string, string>() { { "RequestUrl", entity.RequestUrl }, { "RequestParameters", entity.RequestParameters }, { "RequestType", ((int)entity.RequestType).ToString() }, }; // 定义这个工作,并将其绑定到我们的IJob实现类 IJobDetail job = JobBuilder.CreateForAsync <HttpJob>() .SetJobData(new JobDataMap(httpDir)) .WithDescription(entity.Description) .WithIdentity(entity.JobName, entity.JobGroup) .Build(); // 创建触发器 ITrigger trigger; //校验是否正确的执行周期表达式 if (entity.TriggerType == TriggerTypeEnum.Cron)//CronExpression.IsValidExpression(entity.Cron)) { trigger = CreateCronTrigger(entity); } else { trigger = CreateSimpleTrigger(entity); } // 告诉Quartz使用我们的触发器来安排作业 await Scheduler.ScheduleJob(job, trigger); result.Code = 200; } catch (Exception ex) { result.Code = 505; result.Msg = ex.Message; } return(result); }
/// <summary> /// 添加任务调度(指定IJob实现类) /// </summary> /// <typeparam name="T"></typeparam> /// <param name="m"></param> /// <returns></returns> public async Task <BaseResult> AddScheduleJobAsync <T>(ScheduleEntity entity) where T : IJob { var result = new BaseResult(); try { //检查任务是否已存在 var jobKey = new JobKey(entity.JobName, entity.JobGroup); if (await Scheduler.CheckExists(jobKey)) { //删除已经存在任务 await this.Scheduler.DeleteJob(jobKey); } //http请求配置 var jobData = new JobDataMap(); jobData.Add("RequestUrl", entity.RequestUrl); // 定义这个工作,并将其绑定到我们的IJob实现类 IJobDetail job = JobBuilder.CreateForAsync <T>() .SetJobData(jobData) .WithDescription(entity.Description) .WithIdentity(entity.JobName, entity.JobGroup) .Build(); // 创建触发器 ITrigger trigger; //校验是否正确的执行周期表达式 if (!string.IsNullOrEmpty(entity.Cron) && CronExpression.IsValidExpression(entity.Cron)) { trigger = CreateCronTrigger(entity); } else { trigger = CreateSimpleTrigger(entity); } // 告诉Quartz使用我们的触发器来安排作业 await Scheduler.ScheduleJob(job, trigger); result.Code = MsgCode.Success; result.Msg = "计划任务添加成功"; } catch (Exception ex) { await Console.Out.WriteLineAsync(string.Format("添加任务出错", ex.Message)); result.Code = MsgCode.Unknow; result.Msg = ex.Message; } return(result); }
/// <summary> /// 添加任务调度(指定IJob实现类) /// </summary> /// <typeparam name="T"></typeparam> /// <param name="m"></param> /// <returns></returns> private async Task <BaseQuartzNetResult> AddScheduleJob <T>(ScheduleEntity m) where T : IJob { var result = new BaseQuartzNetResult() { Code = -1, Msg = "" }; try { //检查任务是否已存在 var jk = new JobKey(m.JobName, m.JobGroup); if (await(await Scheduler()).CheckExists(jk)) { //删除已经存在任务 await(await Scheduler()).DeleteJob(jk); ScheduleList.Remove(m.Id, out ScheduleEntity value); } // 定义这个工作,并将其绑定到我们的IJob实现类 IJobDetail job = JobBuilder.CreateForAsync <T>().WithIdentity(m.JobName, m.JobGroup).Build(); // 创建触发器 ITrigger trigger; //校验是否正确的执行周期表达式 if (!string.IsNullOrEmpty(m.Cron) && CronExpression.IsValidExpression(m.Cron)) { trigger = CreateCronTrigger(m); } else { trigger = CreateSimpleTrigger(m); } // 设置监听器 JobListener listener = new JobListener(); // IMatcher<JobKey> matcher = KeyMatcher<JobKey>.KeyEquals(job.Key); (await Scheduler()).ListenerManager.AddJobListener(listener, GroupMatcher <JobKey> .AnyGroup()); // 告诉Quartz使用我们的触发器来安排作业 await(await Scheduler()).ScheduleJob(job, trigger); ScheduleList.GetOrAdd(m.Id, m); result.Code = 200; } catch (Exception ex) { await Console.Out.WriteLineAsync(string.Format("添加任务出错", ex.Message)); result.Code = 1001; result.Msg = ex.Message; } return(result); }
/// <summary> /// 添加一个工作调度 /// </summary> /// <param name="model"></param> /// <returns></returns> public async Task <HttpResponseModel> AddScheduleJobAsync(ScheduleModel model) { var result = new HttpResponseModel(); try { //检查任务是否已存在 var jobKey = new JobKey(model.JobName, model.JobGroup); if (await Scheduler.CheckExists(jobKey)) { result.Code = HttpStatusCode.OK; result.Message = "任务已存在"; return(result); } //http请求配置 var setting = new Dictionary <string, string>() { { Constant.CmdPath, model.CmdPath.ToString() }, { Constant.IsExcuteCmd, model.IsExcuteCmd.ToString() }, { Constant.RequestUrl, model.RequestUrl }, { Constant.RequestParameters, model.RequestParameters }, { Constant.RequestType, ((int)model.RequestType).ToString() }, { Constant.Headers, model.Headers }, { Constant.MailMessage, ((int)model.MailMessage).ToString() }, }; // 定义这个工作,并将其绑定到我们的IJob实现类 var job = JobBuilder.CreateForAsync <ExcuteJob>() .SetJobData(new JobDataMap(setting)) .WithDescription(model.Description) .WithIdentity(model.JobName, model.JobGroup) .Build(); var trigger = model.TriggerType == TriggerTypeEnum.Cron ? CreateCronTrigger(model) : CreateSimpleTrigger(model); await Scheduler.ScheduleJob(job, trigger); result.Code = HttpStatusCode.OK; } catch (Exception ex) { result.Code = HttpStatusCode.InternalServerError; result.Message = ex.Message + Environment.NewLine + ex.StackTrace; } return(result); }
public Task StartJob(IScheduler scheduler) { //use JobBuilder to Create a jobDetail var jobDetails = JobBuilder .CreateForAsync <FireForgetJob>() .WithIdentity("FireForgetJob") .WithDescription("My First Fire and Forget job") .Build(); //use TriggerBuilder to create a Trigger var trigger = TriggerBuilder .Create() .StartNow() .Build(); //call the scheduler.ScheduleJob return(scheduler.ScheduleJob(jobDetails, trigger)); }
public Task StartJob(IScheduler scheduler) { //use JobBuilder to Create a jobDetail var jobDetails = JobBuilder .CreateForAsync <DelayJob>() .WithIdentity("DelayJob") .WithDescription("My First Delay job") .Build(); //use TriggerBuilder to create a Trigger var trigger = TriggerBuilder .Create() .StartAt(DateTimeOffset.Now.AddSeconds(5))// start a job after 5 seconds .Build(); //call the scheduler.ScheduleJob return(scheduler.ScheduleJob(jobDetails, trigger)); }
/// <summary> /// 添加任务调度(指定IJob实现类) /// </summary> /// <typeparam name="T"></typeparam> /// <param name="m"></param> /// <returns></returns> private async Task <BaseQuartzNetResult> AddScheduleJob <T>(ScheduleEntity m) where T : IJob { var result = new BaseQuartzNetResult(); try { //检查任务是否已存在 var jk = new JobKey(m.JobName, m.JobGroup); if (await this.Scheduler.Result.CheckExists(jk)) { //删除已经存在任务 await this.Scheduler.Result.DeleteJob(jk); } //反射获取任务执行类 // var jobType = FileHelper.GetAbsolutePath(m.AssemblyName, m.AssemblyName + "." + m.ClassName); // 定义这个工作,并将其绑定到我们的IJob实现类 //IJobDetail job = new JobDetailImpl(m.JobName, m.JobGroup, jobType); IJobDetail job = JobBuilder.CreateForAsync <T>().WithIdentity(m.JobName, m.JobGroup).Build(); // 创建触发器 ITrigger trigger; //校验是否正确的执行周期表达式 if (!string.IsNullOrEmpty(m.Cron) && CronExpression.IsValidExpression(m.Cron)) { trigger = CreateCronTrigger(m); } else { trigger = CreateSimpleTrigger(m); } // 告诉Quartz使用我们的触发器来安排作业 await this.Scheduler.Result.ScheduleJob(job, trigger); result.Code = 1000; } catch (Exception ex) { await Console.Out.WriteLineAsync(string.Format("添加任务出错", ex.Message)); result.Code = 1001; result.Msg = ex.Message; } return(result); }
private async Task <BaseResult> AddScheduleJobAsync(TaskScheduleModel entity) { var result = new BaseResult(); try { if (await this.scheduler.CheckExists(entity.JobKey)) { result.Code = 500; result.Msg = "任务已存在"; return(result); } var map = new Dictionary <string, string>() { { nameof(Constant.RequestUrl), entity.Url }, { nameof(Constant.RequestParameters), entity.Parameters }, { nameof(Constant.RequestType), entity.HttpMethod.ToString() }, { Constant.Headers, "" }, { Constant.MailMessage, entity.Id.ToString() }, }; IJobDetail job = JobBuilder.CreateForAsync <HttpJob>() .SetJobData(new JobDataMap(map)) .WithDescription(entity.Description) .WithIdentity(entity.Name, entity.Group) .Build(); ITrigger trigger = this.CreateTrigger(entity); await this.scheduler.ScheduleJob(job, trigger); result.Code = 200; } catch (Exception ex) { result.Code = 505; result.Msg = ex.Message; } return(result); }
public Task StartJob(IScheduler scheduler) { //use JobBuilder to Create a jobDetail var jobDetails = JobBuilder .CreateForAsync <RecurringJob>() .WithIdentity("RecurringJob") .WithDescription("My First Recurring job") .Build(); //use TriggerBuilder to create a Trigger var trigger = TriggerBuilder .Create() .StartNow() .WithSimpleSchedule(builder => builder.WithIntervalInSeconds(3)// start a job every 3 seconds .RepeatForever() ) .Build(); //call the scheduler.ScheduleJob return(scheduler.ScheduleJob(jobDetails, trigger)); }
public bool Start(HostControl hostControl) { _logger.LogWarning("SchedulerService started."); _scheduler.Start().ConfigureAwait(false).GetAwaiter().GetResult(); // define the job and tie it to our HelloJob class IJobDetail job = JobBuilder.CreateForAsync <FootballImportJob>() .WithIdentity("job1", "group1") .Build(); // Trigger the job to run now, and then repeat every 10 seconds ITrigger trigger = TriggerBuilder.Create() .WithIdentity("trigger1", "group1") .StartNow() .WithSimpleSchedule(x => x .WithIntervalInHours(importFootballDataIntervalInHours) .RepeatForever()) .Build(); _scheduler.ScheduleJob(job, trigger).ConfigureAwait(false).GetAwaiter().GetResult(); return(true); }
static async Task Main(string[] args) { var scheduler = await StdSchedulerFactory.GetDefaultScheduler(); await scheduler.Start(); var job = JobBuilder .CreateForAsync <WanikaniStatsJob>() .Build(); var trigger = TriggerBuilder .Create() //.StartNow() .StartAt(DateTime.UtcNow.Date.AddDays(1)) .WithSimpleSchedule(builder => builder .WithIntervalInHours(24) .RepeatForever()) .Build(); await scheduler.ScheduleJob(job, trigger); await Task.Delay(-1); }
protected override async Task ExecuteAsync(CancellationToken stoppingToken) { var scheduler = await _factory.GetScheduler(stoppingToken); scheduler.JobFactory = _jobFactory; var helloJob = JobBuilder.CreateForAsync <HelloJob>() .WithIdentity(nameof(HelloJob)) .Build(); var trigger = TriggerBuilder.Create() .WithIdentity("EveryMinuteTrigger") //.StartNow() .WithCronSchedule("0/5 * * * * ?") //.WithSimpleSchedule(builder => builder.WithIntervalInSeconds(5) // .RepeatForever()) .Build(); await scheduler.ScheduleJob(helloJob, trigger, stoppingToken); await scheduler.Start(stoppingToken); await Task.Delay(Timeout.Infinite, stoppingToken); }
/// <summary> /// 添加一个任务 /// </summary> /// <returns></returns> public async Task <ApiResult <string> > Add(ScheduleEntity entity) { var result = new ApiResult <string>() { statusCode = (int)ApiEnum.Error }; try { //检查任务是否已存在 var jobKey = new JobKey(entity.JobName, entity.JobGroup); if (await Scheduler.CheckExists(jobKey)) { result.message = "任务已存在"; return(result); } //http请求配置 var httpDir = new Dictionary <string, string>() { { "RequestUrl", entity.RequestUrl }, { "RequestParameters", entity.RequestParameters }, { "RequestType", ((int)entity.RequestType).ToString() }, { Constant.HEADERS, entity.Headers }, { Constant.MAILMESSAGE, ((int)entity.MailMessage).ToString() }, }; // 定义这个工作,并将其绑定到我们的IJob实现类 IJobDetail job = JobBuilder.CreateForAsync <HttpJob>() .SetJobData(new JobDataMap(httpDir)) .WithDescription(entity.Description) .WithIdentity(entity.JobName, entity.JobGroup) .Build(); // 创建触发器 ITrigger trigger; //校验是否正确的执行周期表达式 if (entity.TriggerType == TriggerTypeEnum.Cron)//CronExpression.IsValidExpression(entity.Cron)) { trigger = CreateCronTrigger(entity); } else { trigger = CreateSimpleTrigger(entity); } // 告诉Quartz使用我们的触发器来安排作业 await Scheduler.ScheduleJob(job, trigger); //将作业增加到Redis里面 var redisTask = RedisHelper.Get <List <ScheduleEntity> >(KeyHelper.TaskSchedulerList); if (redisTask == null) { //实例数组 redisTask = new List <ScheduleEntity>(); } if (!redisTask.Any(m => m.JobId == entity.JobId)) { entity.JobId = Utils.GetOrderNumber(); redisTask.Add(entity); //保存到Redis中 RedisHelper.Set(KeyHelper.TaskSchedulerList, redisTask); } result.statusCode = (int)ApiEnum.Status; } catch (Exception ex) { result.message = ex.Message; } return(result); }