Esempio n. 1
0
        /// <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
            {
            }
        }
Esempio n. 2
0
        public async Task TestOverwriteFlag()
        {
            // create temp file
            string tempFileName = XMLSchedulingDataProcessor.QuartzXmlFileName;

            // Use File.Create (as opposed to File.OpenWrite) so that if the file already exists, it will be completely
            // replaced instead of only overwriting the first N bytes (where N is the length of SimpleJobTrigger.xml)
            using (TextWriter writer = new StreamWriter(File.Create(tempFileName)))
            {
                using (StreamReader reader = new StreamReader(ReadJobXmlFromEmbeddedResource("SimpleJobTrigger.xml")))
                {
                    await writer.WriteAsync(await reader.ReadToEndAsync());

                    await writer.FlushAsync();
                }
            }

            IScheduler scheduler = null;

            try
            {
                var properties = new NameValueCollection();
                properties["quartz.serializer.type"] = TestConstants.DefaultSerializerType;
                StdSchedulerFactory factory = new StdSchedulerFactory(properties);
                scheduler = await factory.GetScheduler();

                // Let's setup a fixture job data that we know test is not going modify it.
                IJobDetail job = JobBuilder.Create <NoOpJob>()
                                 .WithIdentity("job1").UsingJobData("foo", "dont_chg_me").Build();
                ITrigger trigger = TriggerBuilder.Create().WithIdentity("job1").WithSchedule(SimpleScheduleBuilder.RepeatHourlyForever()).Build();
                await scheduler.ScheduleJob(job, trigger);

                XMLSchedulingDataProcessor processor = new XMLSchedulingDataProcessor(new SimpleTypeLoadHelper());
                try
                {
                    await processor.ProcessFileAndScheduleJobs(scheduler, false);

                    Assert.Fail("OverWriteExisting flag didn't work. We should get Exception when overwrite is set to false.");
                }
                catch (ObjectAlreadyExistsException)
                {
                    // This is expected. Do nothing.
                }

                // We should still have what we start with.
                var jobKeys = await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals("DEFAULT"));

                Assert.AreEqual(1, jobKeys.Count);
                var triggerKeys = await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals("DEFAULT"));

                Assert.AreEqual(1, triggerKeys.Count);

                job = await scheduler.GetJobDetail(JobKey.Create("job1"));

                string fooValue = job.JobDataMap.GetString("foo");
                Assert.AreEqual("dont_chg_me", fooValue);
            }
            finally
            {
                if (File.Exists(tempFileName))
                {
                    File.Delete(tempFileName);
                }

                // shutdown scheduler
                if (scheduler != null)
                {
                    await scheduler.Shutdown();
                }
            }
        }
Esempio n. 3
0
        public async Task TestBasicStorageFunctions()
        {
            IScheduler sched = await CreateScheduler("testBasicStorageFunctions", 2);

            await sched.Clear();

            // test basic storage functions of scheduler...
            IJobDetail job = JobBuilder.Create <TestJob>()
                             .WithIdentity("j1")
                             .StoreDurably()
                             .Build();

            Assert.That(await sched.CheckExists(new JobKey("j1")), Is.False, "Unexpected existence of job named 'j1'.");

            await sched.AddJob(job, false);

            Assert.That(await sched.CheckExists(new JobKey("j1")), "Expected existence of job named 'j1' but checkExists return false.");

            job = await sched.GetJobDetail(new JobKey("j1"));

            Assert.That(job, Is.Not.Null, "Stored job not found!");

            await sched.DeleteJob(new JobKey("j1"));

            ITrigger trigger = TriggerBuilder.Create()
                               .WithIdentity("t1")
                               .ForJob(job)
                               .StartNow()
                               .WithSimpleSchedule(x => x
                                                   .RepeatForever()
                                                   .WithIntervalInSeconds(5))
                               .Build();

            Assert.That(await sched.CheckExists(new TriggerKey("t1")), Is.False, "Unexpected existence of trigger named '11'.");

            await sched.ScheduleJob(job, trigger);

            Assert.That(await sched.CheckExists(new TriggerKey("t1")), "Expected existence of trigger named 't1' but checkExists return false.");

            job = await sched.GetJobDetail(new JobKey("j1"));

            Assert.That(job, Is.Not.Null, "Stored job not found!");

            trigger = await sched.GetTrigger(new TriggerKey("t1"));

            Assert.That(trigger, Is.Not.Null, "Stored trigger not found!");

            job = JobBuilder.Create <TestJob>()
                  .WithIdentity("j2", "g1")
                  .Build();

            trigger = TriggerBuilder.Create()
                      .WithIdentity("t2", "g1")
                      .ForJob(job)
                      .StartNow()
                      .WithSimpleSchedule(x => x
                                          .RepeatForever()
                                          .WithIntervalInSeconds(5))
                      .Build();

            await sched.ScheduleJob(job, trigger);

            job = JobBuilder.Create <TestJob>()
                  .WithIdentity("j3", "g1")
                  .Build();

            trigger = TriggerBuilder.Create()
                      .WithIdentity("t3", "g1")
                      .ForJob(job)
                      .StartNow()
                      .WithSimpleSchedule(x => x
                                          .RepeatForever()
                                          .WithIntervalInSeconds(5))
                      .Build();

            await sched.ScheduleJob(job, trigger);

            var jobGroups = await sched.GetJobGroupNames();

            var triggerGroups = await sched.GetTriggerGroupNames();

            Assert.That(jobGroups.Count, Is.EqualTo(2), "Job group list size expected to be = 2 ");
            Assert.That(triggerGroups.Count, Is.EqualTo(2), "Trigger group list size expected to be = 2 ");

            var jobKeys = await sched.GetJobKeys(GroupMatcher <JobKey> .GroupEquals(JobKey.DefaultGroup));

            var triggerKeys = await sched.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals(TriggerKey.DefaultGroup));

            Assert.That(jobKeys.Count, Is.EqualTo(1), "Number of jobs expected in default group was 1 ");
            Assert.That(triggerKeys.Count, Is.EqualTo(1), "Number of triggers expected in default group was 1 ");

            jobKeys = await sched.GetJobKeys(GroupMatcher <JobKey> .GroupEquals("g1"));

            triggerKeys = await sched.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals("g1"));

            Assert.That(jobKeys.Count, Is.EqualTo(2), "Number of jobs expected in 'g1' group was 2 ");
            Assert.That(triggerKeys.Count, Is.EqualTo(2), "Number of triggers expected in 'g1' group was 2 ");

            TriggerState s = await sched.GetTriggerState(new TriggerKey("t2", "g1"));

            Assert.That(s.Equals(TriggerState.Normal), "State of trigger t2 expected to be NORMAL ");

            await sched.PauseTrigger(new TriggerKey("t2", "g1"));

            s = await sched.GetTriggerState(new TriggerKey("t2", "g1"));

            Assert.That(s.Equals(TriggerState.Paused), "State of trigger t2 expected to be PAUSED ");

            await sched.ResumeTrigger(new TriggerKey("t2", "g1"));

            s = await sched.GetTriggerState(new TriggerKey("t2", "g1"));

            Assert.That(s.Equals(TriggerState.Normal), "State of trigger t2 expected to be NORMAL ");

            var pausedGroups = await sched.GetPausedTriggerGroups();

            Assert.That(pausedGroups, Is.Empty, "Size of paused trigger groups list expected to be 0 ");

            await sched.PauseTriggers(GroupMatcher <TriggerKey> .GroupEquals("g1"));

            // test that adding a trigger to a paused group causes the new trigger to be paused also...
            job = JobBuilder.Create <TestJob>()
                  .WithIdentity("j4", "g1")
                  .Build();

            trigger = TriggerBuilder.Create()
                      .WithIdentity("t4", "g1")
                      .ForJob(job)
                      .StartNow()
                      .WithSimpleSchedule(x => x.RepeatForever().WithIntervalInSeconds(5))
                      .Build();

            await sched.ScheduleJob(job, trigger);

            pausedGroups = await sched.GetPausedTriggerGroups();

            Assert.That(pausedGroups.Count, Is.EqualTo(1), "Size of paused trigger groups list expected to be 1 ");

            s = await sched.GetTriggerState(new TriggerKey("t2", "g1"));

            Assert.That(s.Equals(TriggerState.Paused), "State of trigger t2 expected to be PAUSED ");

            s = await sched.GetTriggerState(new TriggerKey("t4", "g1"));

            Assert.That(s.Equals(TriggerState.Paused), "State of trigger t4 expected to be PAUSED ");

            await sched.ResumeTriggers(GroupMatcher <TriggerKey> .GroupEquals("g1"));

            s = await sched.GetTriggerState(new TriggerKey("t2", "g1"));

            Assert.That(s.Equals(TriggerState.Normal), "State of trigger t2 expected to be NORMAL ");
            s = await sched.GetTriggerState(new TriggerKey("t4", "g1"));

            Assert.That(s.Equals(TriggerState.Normal), "State of trigger t4 expected to be NORMAL ");
            pausedGroups = await sched.GetPausedTriggerGroups();

            Assert.That(pausedGroups, Is.Empty, "Size of paused trigger groups list expected to be 0 ");

            Assert.That(await sched.UnscheduleJob(new TriggerKey("foasldfksajdflk")), Is.False, "Scheduler should have returned 'false' from attempt to unschedule non-existing trigger. ");

            Assert.That(await sched.UnscheduleJob(new TriggerKey("t3", "g1")), "Scheduler should have returned 'true' from attempt to unschedule existing trigger. ");

            jobKeys = await sched.GetJobKeys(GroupMatcher <JobKey> .GroupEquals("g1"));

            triggerKeys = await sched.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals("g1"));

            Assert.That(jobKeys.Count, Is.EqualTo(2), "Number of jobs expected in 'g1' group was 1 "); // job should have been deleted also, because it is non-durable
            Assert.That(triggerKeys.Count, Is.EqualTo(2), "Number of triggers expected in 'g1' group was 1 ");

            Assert.That(await sched.UnscheduleJob(new TriggerKey("t1")), "Scheduler should have returned 'true' from attempt to unschedule existing trigger. ");

            jobKeys = await sched.GetJobKeys(GroupMatcher <JobKey> .GroupEquals(JobKey.DefaultGroup));

            triggerKeys = await sched.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals(TriggerKey.DefaultGroup));

            Assert.That(jobKeys.Count, Is.EqualTo(1), "Number of jobs expected in default group was 1 "); // job should have been left in place, because it is non-durable
            Assert.That(triggerKeys, Is.Empty, "Number of triggers expected in default group was 0 ");

            await sched.Shutdown();
        }
Esempio n. 4
0
        public CommandModule()
            : base()
        {
            #region Trigger Commands
            Get["/pausetrigger/{trigger}/{group}"] = _ =>
            {
                var trigger = (string)_.trigger;
                var group   = (string)_.group;

                try
                {
                    Scheduler.PauseTrigger(new TriggerKey(trigger, group));

                    return(Response.AsJson(new { r = true }));
                }
                catch (System.Exception ex)
                {
                    return(Response.AsJson(new { r = false, m = ex.Message }));
                }
            };
            Get["/resumetrigger/{trigger}/{group}"] = _ =>
            {
                var trigger = (string)_.trigger;
                var group   = (string)_.group;

                try
                {
                    Scheduler.ResumeTrigger(new TriggerKey(trigger, group));

                    return(Response.AsJson(new { r = true }));
                }
                catch (System.Exception ex)
                {
                    return(Response.AsJson(new { r = false, m = ex.Message }));
                }
            };
            #endregion
            #region Job Commands
            Get["/pausejob/{job}/{group}"] = _ =>
            {
                var job   = (string)_.job;
                var group = (string)_.group;

                try
                {
                    Scheduler.PauseJob(new JobKey(job, group));

                    return(Response.AsJson(new { r = true }));
                }
                catch (System.Exception ex)
                {
                    return(Response.AsJson(new { r = false, m = ex.Message }));
                }
            };
            Get["/resumejob/{job}/{group}"] = _ =>
            {
                var job   = (string)_.job;
                var group = (string)_.group;

                try
                {
                    Scheduler.ResumeJob(new JobKey(job, group));

                    return(Response.AsJson(new { r = true }));
                }
                catch (System.Exception ex)
                {
                    return(Response.AsJson(new { r = false, m = ex.Message }));
                }
            };
            Get["/firejob/{job}/{group}"] = _ =>
            {
                var job   = (string)_.job;
                var group = (string)_.group;

                try
                {
                    Scheduler.TriggerJob(new JobKey(job, group));

                    return(Response.AsJson(new { r = true }));
                }
                catch (System.Exception ex)
                {
                    return(Response.AsJson(new { r = false, m = ex.Message }));
                }
            };
            #endregion
            #region Group Commands
            Get["/pausegroup/{group}"] = _ =>
            {
                var group = (string)_.group;

                try
                {
                    Scheduler.PauseJobs(GroupMatcher <JobKey> .GroupEquals(group));

                    return(Response.AsJson(new { r = true }));
                }
                catch (System.Exception ex)
                {
                    return(Response.AsJson(new { r = false, m = ex.Message }));
                }
            };

            Get["/resumegroup/{group}"] = _ =>
            {
                var group = (string)_.group;

                try
                {
                    Scheduler.ResumeJobs(GroupMatcher <JobKey> .GroupEquals(group));

                    return(Response.AsJson(new { r = true }));
                }
                catch (System.Exception ex)
                {
                    return(Response.AsJson(new { r = false, m = ex.Message }));
                }
            };
            #endregion
        }
Esempio n. 5
0
        public static async Task <IScheduler> Create(bool start = true)
        {
            var scheduler = await StdSchedulerFactory.GetDefaultScheduler();

            {
                var jobData = new JobDataMap();
                jobData.Put("DateFrom", DateTime.Now);
                jobData.Put("QuartzAssembly", File.ReadAllBytes(typeof(IScheduler).Assembly.Location));

                var job = JobBuilder.Create <DummyJob>()
                          .WithIdentity("Sales", "REPORTS")
                          .WithDescription("Hello Job!")
                          .UsingJobData(jobData)
                          .StoreDurably()
                          .Build();
                var trigger = TriggerBuilder.Create()
                              .WithIdentity("MorningSales")
                              .StartNow()
                              .WithCronSchedule("0 0 8 1/1 * ? *")
                              .Build();
                await scheduler.ScheduleJob(job, trigger);

                trigger = TriggerBuilder.Create()
                          .WithIdentity("MonthlySales")
                          .ForJob(job.Key)
                          .StartNow()
                          .WithCronSchedule("0 0 12 1 1/1 ? *")
                          .Build();
                await scheduler.ScheduleJob(trigger);

                await scheduler.PauseTrigger(trigger.Key);

                trigger = TriggerBuilder.Create()
                          .WithIdentity("HourlySales")
                          .ForJob(job.Key)
                          .StartNow()
                          .WithSimpleSchedule(x => x.WithIntervalInHours(1).RepeatForever())
                          .Build();
                await scheduler.ScheduleJob(trigger);
            }

            {
                var job = JobBuilder.Create <DummyJob>().WithIdentity("Job1").StoreDurably().Build();
                await scheduler.AddJob(job, false);

                job = JobBuilder.Create <DummyJob>().WithIdentity("Job2").StoreDurably().Build();
                await scheduler.AddJob(job, false);

                job = JobBuilder.Create <DummyJob>().WithIdentity("Job3").StoreDurably().Build();
                await scheduler.AddJob(job, false);

                job = JobBuilder.Create <DummyJob>().WithIdentity("Job4").StoreDurably().Build();
                await scheduler.AddJob(job, false);

                job = JobBuilder.Create <DummyJob>().WithIdentity("Job5").StoreDurably().Build();
                await scheduler.AddJob(job, false);

                job = JobBuilder.Create <DummyJob>().WithIdentity("Send SMS", "CRITICAL").StoreDurably().RequestRecovery().Build();
                await scheduler.AddJob(job, false);

                var trigger = TriggerBuilder.Create()
                              .WithIdentity("PushAds  (US)")
                              .ForJob(job.Key)
                              .UsingJobData("Location", "US")
                              .StartNow()
                              .WithCronSchedule("0 0/5 * 1/1 * ? *")
                              .Build();
                await scheduler.ScheduleJob(trigger);

                trigger = TriggerBuilder.Create()
                          .WithIdentity("PushAds (EU)")
                          .ForJob(job.Key)
                          .UsingJobData("Location", "EU")
                          .StartNow()
                          .WithCronSchedule("0 0/7 * 1/1 * ? *")
                          .Build();
                await scheduler.ScheduleJob(trigger);

                await scheduler.PauseTriggers(GroupMatcher <TriggerKey> .GroupEquals("LONGRUNNING"));

                job = JobBuilder.Create <DummyJob>().WithIdentity("Send Push", "CRITICAL").StoreDurably().RequestRecovery().Build();
                await scheduler.AddJob(job, false);
            }

            {
                var job = JobBuilder.Create <DisallowConcurrentJob>()
                          .WithIdentity("Load CSV", "IMPORT")
                          .StoreDurably()
                          .Build();
                var trigger = TriggerBuilder.Create()
                              .WithIdentity("CSV_small", "FREQUENTLY")
                              .ForJob(job)
                              .StartNow()
                              .WithSimpleSchedule(x => x.WithIntervalInSeconds(5).RepeatForever())
                              .Build();
                await scheduler.ScheduleJob(job, trigger);

                trigger = TriggerBuilder.Create()
                          .WithIdentity("CSV_big", "LONGRUNNING")
                          .ForJob(job)
                          .StartNow()
                          .WithDailyTimeIntervalSchedule(x => x.OnMondayThroughFriday())
                          .Build();
                await scheduler.ScheduleJob(trigger);
            }
            if (start)
            {
                await scheduler.Start();
            }

            return(scheduler);
        }
Esempio n. 6
0
        /// <summary>
        /// 获取所有Job(详情信息 - 初始化页面调用)
        /// </summary>
        /// <returns></returns>
        public async Task <ApiResult <List <JobInfoEntity> > > GetAllJobAsync()
        {
            var res = new ApiResult <List <JobInfoEntity> >();

            try
            {
                List <JobKey>        jboKeyList  = new List <JobKey>();
                List <JobInfoEntity> jobInfoList = new List <JobInfoEntity>();
                var groupNames = await Scheduler.GetJobGroupNames();

                foreach (var groupName in groupNames.OrderBy(t => t))
                {
                    jboKeyList.AddRange(await Scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals(groupName)));
                    jobInfoList.Add(new JobInfoEntity()
                    {
                        GroupName = groupName
                    });
                }
                foreach (var jobKey in jboKeyList.OrderBy(t => t.Name))
                {
                    var jobDetail = await Scheduler.GetJobDetail(jobKey);

                    var triggersList = await Scheduler.GetTriggersOfJob(jobKey);

                    var triggers = triggersList.AsEnumerable().FirstOrDefault();

                    var interval = string.Empty;
                    if (triggers is SimpleTriggerImpl)
                    {
                        interval = (triggers as SimpleTriggerImpl)?.RepeatInterval.ToString();
                    }
                    else
                    {
                        interval = (triggers as CronTriggerImpl)?.CronExpressionString;
                    }

                    foreach (var jobInfo in jobInfoList)
                    {
                        if (jobInfo.GroupName == jobKey.Group)
                        {
                            jobInfo.JobInfoList.Add(new JobInfo()
                            {
                                Name             = jobKey.Name,
                                LastErrMsg       = jobDetail.JobDataMap.GetString(Constant.EXCEPTION),
                                RequestUrl       = jobDetail.JobDataMap.GetString(Constant.REQUESTURL),
                                TriggerState     = await Scheduler.GetTriggerState(triggers.Key),
                                PreviousFireTime = triggers.GetPreviousFireTimeUtc()?.LocalDateTime,
                                NextFireTime     = triggers.GetNextFireTimeUtc()?.LocalDateTime,
                                BeginTime        = triggers.StartTimeUtc.LocalDateTime,
                                Interval         = interval,
                                EndTime          = triggers.EndTimeUtc?.LocalDateTime,
                                Description      = jobDetail.Description
                            });
                            continue;
                        }
                    }
                }

                res.data = jobInfoList;
            }
            catch (Exception ex)
            {
                res.message    = ex.Message;
                res.statusCode = (int)ApiEnum.Error;
            }
            return(res);
        }
 public ICollection <JobKey> GetJobKeys()
 {
     return(_scheduler.GetJobGroupNames()
            .SelectMany(jobGroupName => _scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals(jobGroupName)))
            .ToList());
 }
Esempio n. 8
0
        protected void ExecutePreProcessCommands(IScheduler scheduler)
        {
            foreach (string group in jobGroupsToDelete)
            {
                if (group.Equals("*"))
                {
                    log.Info("Deleting all jobs in ALL groups.");
                    foreach (string groupName in scheduler.GetJobGroupNames())
                    {
                        if (!jobGroupsToNeverDelete.Contains(groupName))
                        {
                            foreach (JobKey key in scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals(groupName)))
                            {
                                scheduler.DeleteJob(key);
                            }
                        }
                    }
                }
                else
                {
                    if (!jobGroupsToNeverDelete.Contains(group))
                    {
                        log.InfoFormat("Deleting all jobs in group: {0}", group);
                        foreach (JobKey key in scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals(group)))
                        {
                            scheduler.DeleteJob(key);
                        }
                    }
                }
            }

            foreach (string group in triggerGroupsToDelete)
            {
                if (group.Equals("*"))
                {
                    log.Info("Deleting all triggers in ALL groups.");
                    foreach (string groupName in scheduler.GetTriggerGroupNames())
                    {
                        if (!triggerGroupsToNeverDelete.Contains(groupName))
                        {
                            foreach (TriggerKey key in scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals(groupName)))
                            {
                                scheduler.UnscheduleJob(key);
                            }
                        }
                    }
                }
                else
                {
                    if (!triggerGroupsToNeverDelete.Contains(group))
                    {
                        log.InfoFormat("Deleting all triggers in group: {0}", group);
                        foreach (TriggerKey key in scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals(group)))
                        {
                            scheduler.UnscheduleJob(key);
                        }
                    }
                }
            }

            foreach (JobKey key in jobsToDelete)
            {
                if (!jobGroupsToNeverDelete.Contains(key.Group))
                {
                    log.InfoFormat("Deleting job: {0}", key);
                    scheduler.DeleteJob(key);
                }
            }

            foreach (TriggerKey key in triggersToDelete)
            {
                if (!triggerGroupsToNeverDelete.Contains(key.Group))
                {
                    log.InfoFormat("Deleting trigger: {0}", key);
                    scheduler.UnscheduleJob(key);
                }
            }
        }
        public void TestGetJobKeysWithEquals()
        {
            var sched = CreateScheduler();

            sched.GetJobKeys(GroupMatcher <JobKey> .GroupEquals("bar"));
        }
Esempio n. 10
0
        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddLogging(loggingBuilder =>
            {
                loggingBuilder.ClearProviders();
                loggingBuilder.AddSerilog(dispose: true);
            });

            services.AddRazorPages();

            // base configuration for DI
            services.AddQuartz(q =>
            {
                // handy when part of cluster or you want to otherwise identify multiple schedulers
                q.SchedulerId = "Scheduler-Core";

                // we take this from appsettings.json, just show it's possible
                // q.SchedulerName = "Quartz ASP.NET Core Sample Scheduler";

                // hooks LibLog to Microsoft logging without allowing it to detect concrete implementation
                // if you are using NLog, SeriLog or log4net you shouldn't need this
                // LibLog will be removed in Quartz 4 and Microsoft Logging will become the default
                q.UseMicrosoftLogging();

                // we could leave DI configuration intact and then jobs need to have public no-arg constructor

                // the MS DI is expected to produce transient job instances
                q.UseMicrosoftDependencyInjectionJobFactory(options =>
                {
                    // if we don't have the job in DI, allow fallback to configure via default constructor
                    options.AllowDefaultConstructor = true;
                });

                // or
                // q.UseMicrosoftDependencyInjectionScopedJobFactory();

                // these are the defaults
                q.UseSimpleTypeLoader();
                q.UseInMemoryStore();
                q.UseDefaultThreadPool(tp =>
                {
                    tp.ThreadCount = 10;
                });

                // configure jobs with code
                var jobKey = new JobKey("awesome job", "awesome group");
                q.AddJob <ExampleJob>(j => j
                                      .StoreDurably()
                                      .WithIdentity(jobKey)
                                      .WithDescription("my awesome job")
                                      );

                q.AddTrigger(t => t
                             .WithIdentity("Simple Trigger")
                             .ForJob(jobKey)
                             .StartNow()
                             .WithSimpleSchedule(x => x.WithInterval(TimeSpan.FromSeconds(10)).RepeatForever())
                             .WithDescription("my awesome simple trigger")
                             );

                q.AddTrigger(t => t
                             .WithIdentity("Cron Trigger")
                             .ForJob(jobKey)
                             .StartAt(DateBuilder.EvenSecondDate(DateTimeOffset.UtcNow.AddSeconds(3)))
                             .WithCronSchedule("0/3 * * * * ?")
                             .WithDescription("my awesome cron trigger")
                             );

                q.AddTrigger(t => t
                             .WithIdentity("Daily Trigger")
                             .ForJob(jobKey)
                             .StartAt(DateBuilder.EvenSecondDate(DateTimeOffset.UtcNow.AddSeconds(5)))
                             .WithDailyTimeIntervalSchedule(x => x.WithInterval(10, IntervalUnit.Second))
                             .WithDescription("my awesome daily time interval trigger")
                             );

                // also add XML configuration and poll it for changes
                q.UseXmlSchedulingConfiguration(x =>
                {
                    x.Files                 = new[] { "~/quartz_jobs.config" };
                    x.ScanInterval          = TimeSpan.FromSeconds(2);
                    x.FailOnFileNotFound    = true;
                    x.FailOnSchedulingError = true;
                });

                // convert time zones using converter that can handle Windows/Linux differences
                q.UseTimeZoneConverter();

                // add some listeners
                q.AddSchedulerListener <SampleSchedulerListener>();
                q.AddJobListener <SampleJobListener>(GroupMatcher <JobKey> .GroupEquals(jobKey.Group));
                q.AddTriggerListener <SampleTriggerListener>();

                // example of persistent job store using JSON serializer as an example

                /*
                 * q.UsePersistentStore(s =>
                 * {
                 *  s.UseProperties = true;
                 *  s.RetryInterval = TimeSpan.FromSeconds(15);
                 *  s.UseSqlServer(sqlServer =>
                 *  {
                 *      sqlServer.ConnectionString = "some connection string";
                 *      // this is the default
                 *      sqlServer.TablePrefix = "QRTZ_";
                 *  });
                 *  s.UseJsonSerializer();
                 *  s.UseClustering(c =>
                 *  {
                 *      c.CheckinMisfireThreshold = TimeSpan.FromSeconds(20);
                 *      c.CheckinInterval = TimeSpan.FromSeconds(10);
                 *  });
                 * });
                 */
            });

            // ASP.NET Core hosting
            services.AddQuartzServer(options =>
            {
                // when shutting down we want jobs to complete gracefully
                options.WaitForJobsToComplete = true;
            });

            services
            .AddHealthChecksUI()
            .AddInMemoryStorage();
        }
        private void TestMatchers(IScheduler scheduler)
        {
            scheduler.Clear();

            IJobDetail job = JobBuilder.Create <NoOpJob>().WithIdentity("job1", "aaabbbccc").StoreDurably().Build();

            scheduler.AddJob(job, true);
            SimpleScheduleBuilder schedule = SimpleScheduleBuilder.Create();
            ITrigger trigger = TriggerBuilder.Create().WithIdentity("trig1", "aaabbbccc").WithSchedule(schedule).ForJob(job).Build();

            scheduler.ScheduleJob(trigger);

            job = JobBuilder.Create <NoOpJob>().WithIdentity("job1", "xxxyyyzzz").StoreDurably().Build();
            scheduler.AddJob(job, true);
            schedule = SimpleScheduleBuilder.Create();
            trigger  = TriggerBuilder.Create().WithIdentity("trig1", "xxxyyyzzz").WithSchedule(schedule).ForJob(job).Build();
            scheduler.ScheduleJob(trigger);

            job = JobBuilder.Create <NoOpJob>().WithIdentity("job2", "xxxyyyzzz").StoreDurably().Build();
            scheduler.AddJob(job, true);
            schedule = SimpleScheduleBuilder.Create();
            trigger  = TriggerBuilder.Create().WithIdentity("trig2", "xxxyyyzzz").WithSchedule(schedule).ForJob(job).Build();
            scheduler.ScheduleJob(trigger);

            Collection.ISet <JobKey> jkeys = scheduler.GetJobKeys(GroupMatcher <JobKey> .AnyGroup());
            Assert.That(jkeys.Count, Is.EqualTo(3), "Wrong number of jobs found by anything matcher");

            jkeys = scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals("xxxyyyzzz"));
            Assert.That(jkeys.Count, Is.EqualTo(2), "Wrong number of jobs found by equals matcher");

            jkeys = scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals("aaabbbccc"));
            Assert.That(jkeys.Count, Is.EqualTo(1), "Wrong number of jobs found by equals matcher");

            jkeys = scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupStartsWith("aa"));
            Assert.That(jkeys.Count, Is.EqualTo(1), "Wrong number of jobs found by starts with matcher");

            jkeys = scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupStartsWith("xx"));
            Assert.That(jkeys.Count, Is.EqualTo(2), "Wrong number of jobs found by starts with matcher");

            jkeys = scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEndsWith("cc"));
            Assert.That(jkeys.Count, Is.EqualTo(1), "Wrong number of jobs found by ends with matcher");

            jkeys = scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEndsWith("zzz"));
            Assert.That(jkeys.Count, Is.EqualTo(2), "Wrong number of jobs found by ends with matcher");

            jkeys = scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupContains("bc"));
            Assert.That(jkeys.Count, Is.EqualTo(1), "Wrong number of jobs found by contains with matcher");

            jkeys = scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupContains("yz"));
            Assert.That(jkeys.Count, Is.EqualTo(2), "Wrong number of jobs found by contains with matcher");

            Collection.ISet <TriggerKey> tkeys = scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .AnyGroup());
            Assert.That(tkeys.Count, Is.EqualTo(3), "Wrong number of triggers found by anything matcher");

            tkeys = scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals("xxxyyyzzz"));
            Assert.That(tkeys.Count, Is.EqualTo(2), "Wrong number of triggers found by equals matcher");

            tkeys = scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals("aaabbbccc"));
            Assert.That(tkeys.Count, Is.EqualTo(1), "Wrong number of triggers found by equals matcher");

            tkeys = scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupStartsWith("aa"));
            Assert.That(tkeys.Count, Is.EqualTo(1), "Wrong number of triggers found by starts with matcher");

            tkeys = scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupStartsWith("xx"));
            Assert.That(tkeys.Count, Is.EqualTo(2), "Wrong number of triggers found by starts with matcher");

            tkeys = scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEndsWith("cc"));
            Assert.That(tkeys.Count, Is.EqualTo(1), "Wrong number of triggers found by ends with matcher");

            tkeys = scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEndsWith("zzz"));
            Assert.That(tkeys.Count, Is.EqualTo(2), "Wrong number of triggers found by ends with matcher");

            tkeys = scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupContains("bc"));
            Assert.That(tkeys.Count, Is.EqualTo(1), "Wrong number of triggers found by contains with matcher");

            tkeys = scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupContains("yz"));
            Assert.That(tkeys.Count, Is.EqualTo(2), "Wrong number of triggers found by contains with matcher");
        }
Esempio n. 12
0
        // Adding a JobListener that is interested in all jobs of two particular groups:
        public static async Task AddAJobListener3()
        {
            NameValueCollection props = new NameValueCollection
            {
                { "quartz.serializer.type", "binary" }
            };
            StdSchedulerFactory factory   = new StdSchedulerFactory(props);
            IScheduler          scheduler = await factory.GetScheduler();

            IJobListener myJobListener = new GggJobListener();

            scheduler.ListenerManager.AddJobListener(myJobListener,
                                                     OrMatcher <JobKey> .Or(GroupMatcher <JobKey> .GroupEquals("myJobGroup"), GroupMatcher <JobKey> .GroupEquals("yourGroup")));
        }
Esempio n. 13
0
        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            #region Logging

            // make sure you configure logging and open telemetry before quartz services
            services.AddLogging(loggingBuilder =>
            {
                loggingBuilder.ClearProviders();
                loggingBuilder.AddSerilog(dispose: true);
            });

            services.AddRazorPages();

            #endregion Logging

            #region Quartz

            // base configuration for DI
            services.Configure <QuartzOptions>(Configuration.GetSection("Quartz"));
            services.AddQuartz(q =>
            {
                // handy when part of cluster or you want to otherwise identify multiple schedulers
                q.SchedulerId = "Scheduler-Core";

                #region DI Job Factory

                // this is default configuration if you don't alter it
                q.UseMicrosoftDependencyInjectionJobFactory(options =>
                {
                    // if we don't have the job in DI, allow fallback to configure via default constructor
                    options.AllowDefaultConstructor = true;

                    // set to true if you want to inject scoped services like Entity Framework's DbContext
                    options.CreateScope = false;
                });

                #endregion DI Job Factory

                #region Default Config -- For InMemory Store -- Comment if uses Persist Store -- Commented

                // these are the defaults
                //q.UseSimpleTypeLoader();
                //q.UseInMemoryStore();
                //q.UseDefaultThreadPool(tp =>
                //{
                //    tp.MaxConcurrency = 10;
                //});

                #endregion Default Config -- For InMemory Store -- Comment if uses Persist Store -- Commented

                #region Simple Trigger

                //// Create a job with Single Trigger
                //q.ScheduleJob<FirstSample>(trigger => trigger
                //    .WithIdentity("SomeTrigger")
                //    .StartAt(DateBuilder.EvenSecondDate(DateTimeOffset.UtcNow.AddSeconds(5)))
                //    .WithDailyTimeIntervalSchedule(x => x.WithInterval(10, IntervalUnit.Second))
                //    .WithDescription("Say somethign Trigger configured for a SaySomethingJob with single call")
                //    );

                #endregion Simple Trigger

                #region Configure Individual Jobs And Trigger -- Commented

                // you can also configure individual jobs and triggers with code
                // this allows you to associated multiple triggers with same job
                // (if you want to have different job data map per trigger for example)
                //q.AddJob<ExampleJob>(j => j
                //    .StoreDurably() // we need to store durably if no trigger is associated
                //    .WithDescription("my awesome job")
                //);

                #endregion Configure Individual Jobs And Trigger -- Commented

                #region Second Sample Job with SampleTrigger and CronTrigger

                var secondSampleJobKey = new JobKey("Second Sample Job", "Sample Job Group");
                q.AddJob <SecondSample>(secondSampleJobKey, j => j.WithDescription("My Second Sample Job"));

                // Sample Trigger for Second Sample Job
                q.AddTrigger(trigger => trigger
                             .WithIdentity("SecondSample Sample Trigger")
                             .ForJob(secondSampleJobKey)
                             .StartNow()
                             .WithSimpleSchedule(x => x.WithInterval(TimeSpan.FromSeconds(7)).RepeatForever())
                             .WithDescription("My Second Sample Trigger")
                             );

                // Cron Trigger for Second Sample Job
                q.AddTrigger(trigger => trigger
                             .WithIdentity("My Second Sample Cron Trigger")
                             .ForJob(secondSampleJobKey)
                             .StartAt(DateBuilder.EvenSecondDate(DateTimeOffset.UtcNow.AddSeconds(3)))
                             .WithCronSchedule("0/17 * * * * ?")
                             .WithDescription("My Second Cron Trigger")
                             );

                #endregion Second Sample Job with SampleTrigger and CronTrigger

                #region TimeConverter

                q.UseTimeZoneConverter();

                #endregion TimeConverter

                #region Sample Listener

                // Add Second Sample Listener
                q.AddJobListener <SecondSampleJobListener>(GroupMatcher <JobKey> .GroupEquals(secondSampleJobKey.Group));
                q.AddTriggerListener <SecondSampleTriggerListener>();
                q.AddSchedulerListener <SecondSampleSchedulerListener>();

                #endregion Sample Listener

                #region Job Using Data

                var dataJobKey = new JobKey("AuthorInfo", "Using Data Group");
                q.AddJob <UsingDataJob>(options =>
                                        options.WithIdentity(dataJobKey)
                                        .UsingJobData("Name", "Nguyen Minh Van")
                                        .UsingJobData("Age", "24")
                                        .UsingJobData("Address", "District 12, Ho Chi Minh City")
                                        );

                q.AddTrigger(options =>
                             options.ForJob(dataJobKey)
                             .WithIdentity("DataJob-Trigger")
                             .WithCronSchedule("0/5 * * * * ?"));

                #endregion Job Using Data

                #region Calender

                //const string calendarName = "myHolidayCalendar";
                //q.AddCalendar<HolidayCalendar>(
                //    name: calendarName,
                //    replace: true,
                //    updateTriggers: true,
                //    x => x.AddExcludedDate(new DateTime(2020, 5, 15))
                //);

                //q.AddTrigger(t => t
                //    .WithIdentity("Daily Trigger")
                //    .ForJob(jobKey)
                //    .StartAt(DateBuilder.EvenSecondDate(DateTimeOffset.UtcNow.AddSeconds(5)))
                //    .WithDailyTimeIntervalSchedule(x => x.WithInterval(10, IntervalUnit.Second))
                //    .WithDescription("my awesome daily time interval trigger")
                //    .ModifiedByCalendar(calendarName)
                //);

                // convert time zones using converter that can handle Windows/Linux differences
                //q.UseTimeZoneConverter();

                #endregion Calender
            });

            #endregion Quartz

            #region Quartz Options

            // we can use options pattern to support hooking your own configuration with Quartz's
            // because we don't use service registration api, we need to manally ensure the job is present in DI
            //services.AddTransient<ExampleJob>();

            //services.Configure<SampleOptions>(Configuration.GetSection("Sample"));
            //services.AddOptions<QuartzOptions>()
            //    .Configure<IOptions<SampleOptions>>((options, dep) =>
            //    {
            //        if (!string.IsNullOrWhiteSpace(dep.Value.CronSchedule))
            //        {
            //            var jobKey = new JobKey("options-custom-job", "custom");
            //            options.AddJob<ExampleJob>(j => j.WithIdentity(jobKey));
            //            options.AddTrigger(trigger => trigger
            //                .WithIdentity("options-custom-trigger", "custom")
            //                .ForJob(jobKey)
            //                .WithCronSchedule(dep.Value.CronSchedule));
            //        }
            //    });

            #endregion Quartz Options

            #region Quartz Server

            // ASP.NET Core hosting
            services.AddQuartzServer(options =>
            {
                // when shutting down we want jobs to complete gracefully
                options.WaitForJobsToComplete = true;
            });

            #endregion Quartz Server

            #region Other Services

            services
            .AddHealthChecksUI()
            .AddInMemoryStorage();

            #endregion Other Services
        }
Esempio n. 14
0
 public Task <IReadOnlyCollection <JobKey> > GetJobKeysAsync(string groupName)
 {
     return(scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals(groupName)));
 }
Esempio n. 15
0
        /// <summary>
        /// /获取任务列表
        /// </summary>
        /// <returns></returns>
        public PagedResultDto <JobDetailOutputDto> GetJobList(int pageIndex, string groupNames = "")
        {
            if (_scheduler == null)
            {
                return(null);
            }

            var jobList = _jobDetailRepository.Query().AsNoTracking()
                          .Where(x => !x.IsDeleted).ToList();

            if (!string.IsNullOrEmpty(groupNames))
            {
                jobList = jobList.Where(x => x.JobGroupName == groupNames).ToList();
            }
            var totalCount = jobList.Count;

            var result = new List <JobDetailOutputDto>();

            foreach (var groupName in _scheduler.GetJobGroupNames().Result)
            {
                foreach (JobKey jobKey in _scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals(groupName)).Result)
                {
                    var triggers = _scheduler.GetTriggersOfJob(jobKey).Result.ToList();
                    foreach (var item in triggers)
                    {
                        var jobViewModel = new JobDetailOutputDto
                        {
                            JobName          = jobKey.Name,
                            JobGroupName     = jobKey.Group,
                            TriggerGroupName = item.Key.Group,
                            TriggerName      = item.Key.Name,
                            CurrentStatus    = GetJobStatusByKey(item.Key),
                            NextRunTime      = item.GetNextFireTimeUtc() == null
                            ? "下次不会触发运行时间"
                            : item.GetNextFireTimeUtc()?.LocalDateTime.ToString("yyyy-MM-dd HH:mm:ss.fff"),
                            LastRunTime = item.GetPreviousFireTimeUtc() == null
                            ? "还未运行过"
                            : item.GetPreviousFireTimeUtc()?.LocalDateTime.ToString("yyyy-MM-dd HH:mm:ss.fff")
                        };

                        var jobInfo = jobList.FirstOrDefault(x =>
                                                             x.JobName == jobKey.Name && x.JobGroupName == jobKey.Group);
                        if (jobInfo == null)
                        {
                            continue;
                        }//
                        jobViewModel.Cron           = jobInfo.Cron;
                        jobViewModel.RequestUrl     = jobInfo.RequestUrl;
                        jobViewModel.ExceptionEmail = jobInfo.ExceptionEmail;
                        jobViewModel.Id             = jobInfo.Id;
                        jobViewModel.IsInSchedule   = true;
                        result.Add(jobViewModel);
                    }
                }
            }


            foreach (var item in result)
            {
                var jobInfo = jobList.FirstOrDefault(x => x.JobName == item.JobName && x.JobGroupName == item.JobGroupName);
                if (jobInfo != null)
                {
                    jobList.Remove(jobInfo);
                }
            }

            if (jobList.Count > 0)
            {
                foreach (var item in jobList)
                {
                    var jobViewModel = new JobDetailOutputDto();;
                    jobViewModel.JobName          = item.JobName;
                    jobViewModel.JobGroupName     = item.JobGroupName;
                    jobViewModel.TriggerGroupName = item.TriggerGroupName;
                    jobViewModel.TriggerName      = item.TriggerGroupName;
                    jobViewModel.CurrentStatus    = "还未加入计划中";
                    jobViewModel.NextRunTime      = "无";
                    jobViewModel.LastRunTime      = "无";
                    jobViewModel.Cron             = item.Cron;
                    jobViewModel.Id             = item.Id;
                    jobViewModel.IsInSchedule   = false;
                    jobViewModel.RequestUrl     = item.RequestUrl;
                    jobViewModel.ExceptionEmail = item.ExceptionEmail;
                    result.Add(jobViewModel);
                }
            }


            result = result.Skip(10 * (pageIndex - 1)).Take(pageIndex * 10).ToList();//分页默认每页大小为10
            return(new PagedResultDto <JobDetailOutputDto>(totalCount, result));
            //return result;
        }
        public async Task TestBasicStorageFunctions()
        {
            var sched = await CreateScheduler("TestBasicStorageFunctions", 2);

            await sched.Start(CancellationToken.None);

            await sched.Standby(CancellationToken.None);

            // test basic storage functions of scheduler...

            var job = JobBuilder.Create()
                      .OfType <TestJob>()
                      .WithIdentity("j1")
                      .StoreDurably()
                      .Build();

            Assert.IsFalse(await sched.CheckExists(new JobKey("j1")), "Unexpected existence of job named 'j1'.");

            await sched.AddJob(job, false);

            Assert.IsTrue(await sched.CheckExists(new JobKey("j1")),
                          "Expected existence of job named 'j1' but checkExists return false.");

            job = await sched.GetJobDetail(new JobKey("j1"));

            Assert.IsNotNull(job, "Stored job not found!");

            await sched.DeleteJob(new JobKey("j1"));

            var trigger = TriggerBuilder.Create()
                          .WithIdentity("t1")
                          .ForJob(job)
                          .StartNow()
                          .WithSimpleSchedule(x => x.RepeatForever().WithIntervalInSeconds(5))
                          .Build();

            Assert.IsFalse(await sched.CheckExists(new TriggerKey("t1")),
                           "Unexpected existence of trigger named '11'.");

            await sched.ScheduleJob(job, trigger);

            Assert.IsTrue(await sched.CheckExists(new TriggerKey("t1")),
                          "Expected existence of trigger named 't1' but checkExists return false.");

            job = await sched.GetJobDetail(new JobKey("j1"));

            Assert.IsNotNull(job, "Stored job not found!");

            trigger = await sched.GetTrigger(new TriggerKey("t1"));

            Assert.IsNotNull(trigger, "Stored trigger not found!");

            job = JobBuilder.Create()
                  .OfType <TestJob>()
                  .WithIdentity("j2", "g1")
                  .Build();

            trigger = TriggerBuilder.Create()
                      .WithIdentity("t2", "g1")
                      .ForJob(job)
                      .StartNow()
                      .WithSimpleSchedule(x => x.RepeatForever().WithIntervalInSeconds(5))
                      .Build();

            await sched.ScheduleJob(job, trigger);

            job = JobBuilder.Create()
                  .OfType <TestJob>()
                  .WithIdentity("j3", "g1")
                  .Build();

            trigger = TriggerBuilder.Create()
                      .WithIdentity("t3", "g1")
                      .ForJob(job)
                      .StartNow()
                      .WithSimpleSchedule(x => x.RepeatForever().WithIntervalInSeconds(5))
                      .Build();

            await sched.ScheduleJob(job, trigger);


            IList <string> jobGroups     = (await sched.GetJobGroupNames()).ToList();
            IList <string> triggerGroups = (await sched.GetTriggerGroupNames()).ToList();

            Assert.AreEqual(3, jobGroups.Count, "Job group list size expected to be = 2 + 1 for DEFAULT");
            Assert.AreEqual(2, triggerGroups.Count, "Trigger group list size expected to be = 2");

            ISet <JobKey> jobKeys = (await sched.GetJobKeys(GroupMatcher <JobKey> .GroupEquals(JobKey.DefaultGroup)))
                                    .ToHashSet();
            ISet <TriggerKey> triggerKeys =
                (await sched.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals(TriggerKey.DefaultGroup))).ToHashSet();

            Assert.AreEqual(1, jobKeys.Count, "Number of jobs expected in default group was 1 ");
            Assert.AreEqual(1, triggerKeys.Count, "Number of triggers expected in default group was 1 ");

            jobKeys     = (await sched.GetJobKeys(GroupMatcher <JobKey> .GroupEquals("g1"))).ToHashSet();
            triggerKeys = (await sched.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals("g1"))).ToHashSet();

            Assert.AreEqual(2, jobKeys.Count, "Number of jobs expected in 'g1' group was 2 ");
            Assert.AreEqual(2, triggerKeys.Count, "Number of triggers expected in 'g1' group was 2 ");


            var s = await sched.GetTriggerState(new TriggerKey("t2", "g1"));

            Assert.AreEqual(TriggerState.Normal, s, "State of trigger t2 expected to be NORMAL ");

            await sched.PauseTrigger(new TriggerKey("t2", "g1"));

            s = await sched.GetTriggerState(new TriggerKey("t2", "g1"));

            Assert.AreEqual(TriggerState.Paused, s, "State of trigger t2 expected to be PAUSED ");

            await sched.ResumeTrigger(new TriggerKey("t2", "g1"));

            s = await sched.GetTriggerState(new TriggerKey("t2", "g1"));

            Assert.AreEqual(TriggerState.Normal, s, "State of trigger t2 expected to be NORMAL ");

            ISet <string> pausedGroups = (await sched.GetPausedTriggerGroups()).ToHashSet();

            Assert.AreEqual(0, pausedGroups.Count, "Size of paused trigger groups list expected to be 0 ");

            await sched.PauseTriggers(GroupMatcher <TriggerKey> .GroupEquals("g1"));

            // test that adding a trigger to a paused group causes the new trigger to be paused also...
            job = JobBuilder.Create()
                  .OfType <TestJob>()
                  .WithIdentity("j4", "g1")
                  .Build();

            trigger = TriggerBuilder.Create()
                      .WithIdentity("t4", "g1")
                      .ForJob(job)
                      .StartNow()
                      .WithSimpleSchedule(x => x.RepeatForever().WithIntervalInSeconds(5))
                      .Build();

            await sched.ScheduleJob(job, trigger);

            pausedGroups = (await sched.GetPausedTriggerGroups()).ToHashSet();
            Assert.AreEqual(1, pausedGroups.Count, "Size of paused trigger groups list expected to be 1 ");

            s = await sched.GetTriggerState(new TriggerKey("t2", "g1"));

            Assert.AreEqual(TriggerState.Paused, s, "State of trigger t2 expected to be PAUSED ");

            s = await sched.GetTriggerState(new TriggerKey("t4", "g1"));

            Assert.AreEqual(TriggerState.Paused, s, "State of trigger t4 expected to be PAUSED");

            await sched.ResumeTriggers(GroupMatcher <TriggerKey> .GroupEquals("g1"));

            s = await sched.GetTriggerState(new TriggerKey("t2", "g1"));

            Assert.AreEqual(TriggerState.Normal, s, "State of trigger t2 expected to be NORMAL ");

            s = await sched.GetTriggerState(new TriggerKey("t4", "g1"));

            Assert.AreEqual(TriggerState.Normal, s, "State of trigger t2 expected to be NORMAL ");

            pausedGroups = (await sched.GetPausedTriggerGroups()).ToHashSet();
            Assert.AreEqual(0, pausedGroups.Count, "Size of paused trigger groups list expected to be 0 ");


            Assert.IsFalse(await sched.UnscheduleJob(new TriggerKey("foasldfksajdflk")),
                           "Scheduler should have returned 'false' from attempt to unschedule non-existing trigger. ");

            Assert.IsTrue(await sched.UnscheduleJob(new TriggerKey("t3", "g1")),
                          "Scheduler should have returned 'true' from attempt to unschedule existing trigger. ");

            jobKeys     = (await sched.GetJobKeys(GroupMatcher <JobKey> .GroupEquals("g1"))).ToHashSet();
            triggerKeys = (await sched.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals("g1"))).ToHashSet();

            Assert.AreEqual(2, jobKeys.Count,
                            "Number of jobs expected in 'g1' group was 2 "); // job should have been deleted also, because it is non-durable
            Assert.AreEqual(2, triggerKeys.Count, "Number of triggers expected in 'g1' group was 2 ");

            Assert.IsTrue(await sched.UnscheduleJob(new TriggerKey("t1")),
                          "Scheduler should have returned 'true' from attempt to unschedule existing trigger. ");

            jobKeys     = (await sched.GetJobKeys(GroupMatcher <JobKey> .GroupEquals(JobKey.DefaultGroup))).ToHashSet();
            triggerKeys = (await sched.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals(TriggerKey.DefaultGroup)))
                          .ToHashSet();

            Assert.AreEqual(1, jobKeys.Count,
                            "Number of jobs expected in default group was 1 "); // job should have been left in place, because it is non-durable
            Assert.AreEqual(0, triggerKeys.Count, "Number of triggers expected in default group was 0 ");

            await sched.Shutdown();
        }
Esempio n. 17
0
        public async Task <List <List <JobModel> > > Get()
        {
            List <JobModel> jobs   = new List <JobModel>();
            var             groups = await QuartzHostedService.Scheduler.GetJobGroupNames();

            foreach (var groupName in groups)
            {
                foreach (var jobKey in  await QuartzHostedService.Scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals(groupName)))
                {
                    JobModel jobModel = new JobModel
                    {
                        JobName  = jobKey.Name,
                        JobGroup = groupName
                    };
                    jobModel.JobUrl = _jobSchedules.First(x => x.JobName == jobKey.Name)?.JobUrl;
                    // string jobName = jobKey.Name;
                    // string jobGroup = jobKey.Group;
                    List <TriggerModel> triggerModels = new List <TriggerModel>();

                    var triggers = await QuartzHostedService.Scheduler.GetTriggersOfJob(jobKey);

                    foreach (ITrigger trigger in triggers)
                    {
                        var state = await QuartzHostedService.Scheduler.GetTriggerState(trigger.Key);

                        TriggerModel triggerModel = new TriggerModel
                        {
                            Name         = trigger.Key.Name,
                            Cron         = trigger.Description,
                            State        = Enum.GetName(state.GetType(), state),
                            NextExecTime = trigger.GetNextFireTimeUtc().Value.ToLocalTime().ToString("yyyy/MM/dd HH:mm:ss"),
                            Result       = _jobTriggerInfo.triggersInfo.FirstOrDefault(x => x.Name == trigger.Key.Name)?.Result
                        };
                        triggerModels.Add(triggerModel);
                        // string name = trigger.Key.Name;
                        // string cron = trigger.Description;
                        // string next_time = trigger.GetNextFireTimeUtc().Value.ToLocalTime().ToString("yyyy/MM/dd HH:mm:ss");
                    }

                    jobModel.Triggers = triggerModels;
                    jobs.Add(jobModel);
                }
            }

            var d = jobs.GroupBy(x => x.JobGroup).Select(x => x.ToList()).ToList();

            return(await Task.FromResult(d));

            //return _jobSchedules;
        }
Esempio n. 18
0
        /// <summary>
        /// 获取所有Job(详情信息 - 初始化页面调用)
        /// </summary>
        /// <returns></returns>
        public async Task <IResponseOutput> GetAllJobAsync()
        {
            List <JobKey>        jboKeyList        = new List <JobKey>();
            List <JobInfoEntity> jobInfoEntityList = new List <JobInfoEntity>();
            var groupNames = await scheduler.GetJobGroupNames();

            foreach (var groupName in groupNames.OrderBy(t => t))
            {
                jboKeyList.AddRange(await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals(groupName)));
                jobInfoEntityList.Add(new JobInfoEntity()
                {
                    GroupName = groupName
                });
            }

            List <JobInfo> jobInfoList = new List <JobInfo>();

            foreach (var jobKey in jboKeyList.OrderBy(t => t.Name))
            {
                var jobDetail = await scheduler.GetJobDetail(jobKey);

                var triggersList = await scheduler.GetTriggersOfJob(jobKey);

                var triggers = triggersList.AsEnumerable().FirstOrDefault();

                var interval = string.Empty;
                if (triggers is SimpleTriggerImpl)
                {
                    interval = (triggers as SimpleTriggerImpl)?.RepeatInterval.ToString();
                }
                else
                {
                    interval = (triggers as CronTriggerImpl)?.CronExpressionString;
                }

                // foreach (var jobInfo in jobInfoEntityList)
                // {
                // if (jobInfo.GroupName == jobKey.Group)
                //{
                //旧代码没有保存JobTypeEnum,所以None可以默认为Url。
                var jobType = (JobTypeEnum)jobDetail.JobDataMap.GetLong(JobConstant.JobTypeEnum);
                jobType = jobType == JobTypeEnum.None ? JobTypeEnum.Url : jobType;

                var triggerAddress = string.Empty;
                if (jobType == JobTypeEnum.Url)
                {
                    triggerAddress = jobDetail.JobDataMap.GetString(JobConstant.REQUESTURL);
                }
                else if (jobType == JobTypeEnum.Emial)
                {
                    triggerAddress = jobDetail.JobDataMap.GetString(JobConstant.MailTo);
                }
                else if (jobType == JobTypeEnum.Mqtt)
                {
                    triggerAddress = jobDetail.JobDataMap.GetString(JobConstant.Topic);
                }
                else if (jobType == JobTypeEnum.RabbitMQ)
                {
                    triggerAddress = jobDetail.JobDataMap.GetString(JobConstant.RabbitQueue);
                }

                //Constant.MailTo
                jobInfoList.Add(new JobInfo()
                {
                    Name             = jobKey.Name,
                    GroupName        = jobKey.Group,
                    LastErrMsg       = jobDetail.JobDataMap.GetString(JobConstant.EXCEPTION),
                    TriggerAddress   = triggerAddress,
                    TriggerState     = await scheduler.GetTriggerState(triggers.Key),
                    PreviousFireTime = triggers.GetPreviousFireTimeUtc()?.LocalDateTime,
                    NextFireTime     = triggers.GetNextFireTimeUtc()?.LocalDateTime,
                    BeginTime        = triggers.StartTimeUtc.LocalDateTime,
                    Interval         = interval,
                    EndTime          = triggers.EndTimeUtc?.LocalDateTime,
                    Description      = jobDetail.Description,
                    RequestType      = jobDetail.JobDataMap.GetString(JobConstant.REQUESTTYPE),
                    RunNumber        = jobDetail.JobDataMap.GetLong(JobConstant.RUNNUMBER),
                    JobType          = (long)jobType
                                       //(triggers as SimpleTriggerImpl)?.TimesTriggered
                                       //CronTriggerImpl 中没有 TimesTriggered 所以自己RUNNUMBER记录
                });
                continue;
                //  }
                //}
            }
            return(ResponseOutput.Ok(jobInfoList));
        }
Esempio n. 19
0
        public async Task TestBasicStorageFunctions()
        {
            NameValueCollection config = new NameValueCollection();

            config["quartz.scheduler.instanceName"] = "SchedulerTest_Scheduler";
            config["quartz.scheduler.instanceId"]   = "AUTO";
            config["quartz.threadPool.threadCount"] = "2";
            config["quartz.threadPool.type"]        = "Quartz.Simpl.SimpleThreadPool, Quartz";
            config["quartz.serializer.type"]        = TestConstants.DefaultSerializerType;
            IScheduler sched = await new StdSchedulerFactory(config).GetScheduler();

            // test basic storage functions of scheduler...

            IJobDetail job = JobBuilder.Create()
                             .OfType <TestJob>()
                             .WithIdentity("j1")
                             .StoreDurably()
                             .Build();

            var exists = await sched.CheckExists(new JobKey("j1"));

            Assert.IsFalse(exists, "Unexpected existence of job named 'j1'.");

            await sched.AddJob(job, false);

            exists = await sched.CheckExists(new JobKey("j1"));

            Assert.IsTrue(exists, "Expected existence of job named 'j1' but checkExists return false.");

            job = await sched.GetJobDetail(new JobKey("j1"));

            Assert.IsNotNull(job, "Stored job not found!");

            await sched.DeleteJob(new JobKey("j1"));

            ITrigger trigger = TriggerBuilder.Create()
                               .WithIdentity("t1")
                               .ForJob(job)
                               .StartNow()
                               .WithSimpleSchedule(x => x.RepeatForever().WithIntervalInSeconds(5))
                               .Build();

            exists = await sched.CheckExists(new TriggerKey("t1"));

            Assert.IsFalse(exists, "Unexpected existence of trigger named '11'.");

            await sched.ScheduleJob(job, trigger);

            exists = await sched.CheckExists(new TriggerKey("t1"));

            Assert.IsTrue(exists, "Expected existence of trigger named 't1' but checkExists return false.");

            job = await sched.GetJobDetail(new JobKey("j1"));

            Assert.IsNotNull(job, "Stored job not found!");

            trigger = await sched.GetTrigger(new TriggerKey("t1"));

            Assert.IsNotNull(trigger, "Stored trigger not found!");

            job = JobBuilder.Create()
                  .OfType <TestJob>()
                  .WithIdentity("j2", "g1")
                  .Build();

            trigger = TriggerBuilder.Create()
                      .WithIdentity("t2", "g1")
                      .ForJob(job)
                      .StartNow()
                      .WithSimpleSchedule(x => x.RepeatForever().WithIntervalInSeconds(5))
                      .Build();

            await sched.ScheduleJob(job, trigger);

            job = JobBuilder.Create()
                  .OfType <TestJob>()
                  .WithIdentity("j3", "g1")
                  .Build();

            trigger = TriggerBuilder.Create()
                      .WithIdentity("t3", "g1")
                      .ForJob(job)
                      .StartNow()
                      .WithSimpleSchedule(x => x.RepeatForever().WithIntervalInSeconds(5))
                      .Build();

            await sched.ScheduleJob(job, trigger);

            var jobGroups = await sched.GetJobGroupNames();

            var triggerGroups = await sched.GetTriggerGroupNames();

            Assert.AreEqual(2, jobGroups.Count, "Job group list size expected to be = 2 ");
            Assert.AreEqual(2, triggerGroups.Count, "Trigger group list size expected to be = 2 ");

            var jobKeys = await sched.GetJobKeys(GroupMatcher <JobKey> .GroupEquals(JobKey.DefaultGroup));

            var triggerKeys = await sched.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals(TriggerKey.DefaultGroup));

            Assert.AreEqual(1, jobKeys.Count, "Number of jobs expected in default group was 1 ");
            Assert.AreEqual(1, triggerKeys.Count, "Number of triggers expected in default group was 1 ");

            jobKeys = await sched.GetJobKeys(GroupMatcher <JobKey> .GroupEquals("g1"));

            triggerKeys = await sched.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals("g1"));

            Assert.AreEqual(2, jobKeys.Count, "Number of jobs expected in 'g1' group was 2 ");
            Assert.AreEqual(2, triggerKeys.Count, "Number of triggers expected in 'g1' group was 2 ");

            TriggerState s = await sched.GetTriggerState(new TriggerKey("t2", "g1"));

            Assert.AreEqual(TriggerState.Normal, s, "State of trigger t2 expected to be NORMAL ");

            await sched.PauseTrigger(new TriggerKey("t2", "g1"));

            s = await sched.GetTriggerState(new TriggerKey("t2", "g1"));

            Assert.AreEqual(TriggerState.Paused, s, "State of trigger t2 expected to be PAUSED ");

            await sched.ResumeTrigger(new TriggerKey("t2", "g1"));

            s = await sched.GetTriggerState(new TriggerKey("t2", "g1"));

            Assert.AreEqual(TriggerState.Normal, s, "State of trigger t2 expected to be NORMAL ");

            var pausedGroups = await sched.GetPausedTriggerGroups();

            Assert.AreEqual(0, pausedGroups.Count, "Size of paused trigger groups list expected to be 0 ");

            await sched.PauseTriggers(GroupMatcher <TriggerKey> .GroupEquals("g1"));

            // test that adding a trigger to a paused group causes the new trigger to be paused also...
            job = JobBuilder.Create()
                  .OfType <TestJob>()
                  .WithIdentity("j4", "g1")
                  .Build();

            trigger = TriggerBuilder.Create()
                      .WithIdentity("t4", "g1")
                      .ForJob(job)
                      .StartNow()
                      .WithSimpleSchedule(x => x.RepeatForever().WithIntervalInSeconds(5))
                      .Build();

            await sched.ScheduleJob(job, trigger);

            pausedGroups = await sched.GetPausedTriggerGroups();

            Assert.AreEqual(1, pausedGroups.Count, "Size of paused trigger groups list expected to be 1 ");

            s = await sched.GetTriggerState(new TriggerKey("t2", "g1"));

            Assert.AreEqual(TriggerState.Paused, s, "State of trigger t2 expected to be PAUSED ");

            s = await sched.GetTriggerState(new TriggerKey("t4", "g1"));

            Assert.AreEqual(TriggerState.Paused, s, "State of trigger t4 expected to be PAUSED");

            await sched.ResumeTriggers(GroupMatcher <TriggerKey> .GroupEquals("g1"));

            s = await sched.GetTriggerState(new TriggerKey("t2", "g1"));

            Assert.AreEqual(TriggerState.Normal, s, "State of trigger t2 expected to be NORMAL ");

            s = await sched.GetTriggerState(new TriggerKey("t4", "g1"));

            Assert.AreEqual(TriggerState.Normal, s, "State of trigger t2 expected to be NORMAL ");

            pausedGroups = await sched.GetPausedTriggerGroups();

            Assert.AreEqual(0, pausedGroups.Count, "Size of paused trigger groups list expected to be 0 ");

            Assert.IsFalse(await sched.UnscheduleJob(new TriggerKey("foasldfksajdflk")), "Scheduler should have returned 'false' from attempt to unschedule non-existing trigger. ");

            Assert.IsTrue(await sched.UnscheduleJob(new TriggerKey("t3", "g1")), "Scheduler should have returned 'true' from attempt to unschedule existing trigger. ");

            jobKeys = await sched.GetJobKeys(GroupMatcher <JobKey> .GroupEquals("g1"));

            triggerKeys = await sched.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals("g1"));

            Assert.AreEqual(2, jobKeys.Count, "Number of jobs expected in 'g1' group was 1 "); // job should have been deleted also, because it is non-durable
            Assert.AreEqual(2, triggerKeys.Count, "Number of triggers expected in 'g1' group was 1 ");

            Assert.IsTrue(await sched.UnscheduleJob(new TriggerKey("t1")), "Scheduler should have returned 'true' from attempt to unschedule existing trigger. ");

            jobKeys = await sched.GetJobKeys(GroupMatcher <JobKey> .GroupEquals(JobKey.DefaultGroup));

            triggerKeys = await sched.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals(TriggerKey.DefaultGroup));

            Assert.AreEqual(1, jobKeys.Count, "Number of jobs expected in default group was 1 "); // job should have been left in place, because it is non-durable
            Assert.AreEqual(0, triggerKeys.Count, "Number of triggers expected in default group was 0 ");

            await sched.Shutdown();
        }
Esempio n. 20
0
        /// <summary>
        /// 查询所有任务
        /// </summary>
        /// <returns></returns>
        public async Task <ApiResult <List <JobListEntity> > > GetList()
        {
            var result = new ApiResult <List <JobListEntity> >()
            {
                statusCode = (int)ApiEnum.Error
            };

            try
            {
                List <JobKey>        jboKeyList  = new List <JobKey>();
                List <JobListEntity> jobInfoList = new List <JobListEntity>();
                //查询redis的任务
                var redisTask = RedisHelper.Get <List <ScheduleEntity> >(KeyHelper.TaskSchedulerList);
                if (redisTask == null || redisTask.Count == 0)
                {
                    result.statusCode = (int)ApiEnum.Status;
                    result.data       = jobInfoList;
                    return(result);
                }

                var groupNames = await Scheduler.GetJobGroupNames();

                if (groupNames.Count == 0)
                {
                    //说明第一次打开,增加到任务调度里面
                    foreach (var item in redisTask)
                    {
                        if (item.TriggerState == TriggerState.Normal)
                        {
                            await Add(item);
                        }
                    }
                    //阻塞下
                    System.Threading.Thread.Sleep(500);
                    //阻塞后,重新获得在任务中的组信息
                    groupNames = await Scheduler.GetJobGroupNames();
                }

                foreach (var groupName in groupNames.OrderBy(t => t))
                {
                    jboKeyList.AddRange(await Scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals(groupName)));
                    jobInfoList.Add(new JobListEntity()
                    {
                        GroupName = groupName
                    });
                }
                //定义一个空数组,接受已存在任务里面的任务名字,提供下面,判断是否存在
                var jobNameArr = new List <string>();
                foreach (var jobKey in jboKeyList.OrderBy(t => t.Name))
                {
                    var jobDetail = await Scheduler.GetJobDetail(jobKey);

                    var triggersList = await Scheduler.GetTriggersOfJob(jobKey);

                    var triggers = triggersList.AsEnumerable().FirstOrDefault();
                    foreach (var jobInfo in jobInfoList)
                    {
                        if (jobInfo.GroupName == jobKey.Group)
                        {
                            //在redis里面查询任务
                            var cacheTask = redisTask.Where(m => m.JobName == jobKey.Name && m.JobGroup == jobKey.Group).FirstOrDefault();
                            if (cacheTask != null)
                            {
                                jobNameArr.Add(cacheTask.JobName);
                                cacheTask.LastErrMsg       = jobDetail.JobDataMap.GetString(Constant.EXCEPTION);
                                cacheTask.PreviousFireTime = triggers.GetPreviousFireTimeUtc()?.LocalDateTime;
                                cacheTask.NextFireTime     = triggers.GetNextFireTimeUtc()?.LocalDateTime;
                                jobInfo.jobList.Add(cacheTask);
                            }
                        }
                    }
                }
                //查询Redis中,不在运行的任务项目
                var noTaskList = redisTask.Where(m => !jobNameArr.Contains(m.JobName)).ToList();
                //将不运行的任务,增加到List中
                if (noTaskList.Any())
                {
                    //查询组
                    var noRunTaskGroup = noTaskList.GroupBy(m => m.JobGroup).Select(m => m.Key).ToList();
                    if (noRunTaskGroup != null && noRunTaskGroup.Count > 0)
                    {
                        foreach (var item in noRunTaskGroup)
                        {
                            //根据组获得任务详细信息
                            var jobList       = new List <ScheduleEntity>();
                            var noRunTaskList = noTaskList.Where(m => m.JobGroup == item).ToList();
                            foreach (var job in noRunTaskList)
                            {
                                jobList.Add(job);
                            }
                            jobInfoList.Add(new JobListEntity()
                            {
                                GroupName = item,
                                jobList   = jobList
                            });
                        }
                    }
                }
                result.data       = jobInfoList;
                result.statusCode = (int)ApiEnum.Status;
            }
            catch (Exception ex)
            {
                result.message = ex.Message;
            }
            return(result);
        }
Esempio n. 21
0
        public async Task <IEnumerable <JobResponse> > Jobs(JobSearchRequest request)
        {
            GroupMatcher <JobKey> matcher = GroupMatcher <JobKey> .AnyGroup();

            if (!string.IsNullOrWhiteSpace(request.Group))
            {
                matcher = GroupMatcher <JobKey> .GroupEquals(request.Group.Trim());
            }

            IReadOnlyCollection <JobKey> jobKeys = await _scheduler.GetJobKeys(matcher); // 根据分组查询条件 获取所有JobKey

            List <JobResponse> items = new List <JobResponse>();

            foreach (JobKey key in jobKeys)
            {
                // 过滤掉邮件通知配置job,NLog日志文件清除Job
                if (string.Equals(key.Name, EmailJobKeys.NameKey, StringComparison.InvariantCultureIgnoreCase) || string.Equals(key.Name, NLogJobKey.NameKey, StringComparison.InvariantCultureIgnoreCase))
                {
                    continue;
                }

                IJobDetail job = await _scheduler.GetJobDetail(key);

                if (job == null)
                {
                    continue;
                }

                JobResponse item = new JobResponse
                {
                    Name          = job.Key.Name,
                    Group         = job.Key.Group,
                    TriggerState  = TriggerState.Complete,
                    HttpMethod    = job.JobDataMap.GetInt(DataKeys.HttpMethod),
                    RequestUrl    = job.JobDataMap.GetString(DataKeys.RequestUrl),
                    TriggerType   = job.JobDataMap.GetInt(DataKeys.TriggerType),
                    Interval      = job.JobDataMap.GetInt(DataKeys.Interval),
                    IntervalType  = job.JobDataMap.GetInt(DataKeys.IntervalType),
                    RepeatCount   = job.JobDataMap.GetInt(DataKeys.RepeatCount),
                    Cron          = job.JobDataMap.GetString(DataKeys.Cron),
                    RequestBody   = job.JobDataMap.GetString(DataKeys.RequestBody),
                    Description   = job.Description,
                    CreateTime    = job.JobDataMap.GetDateTime(DataKeys.CreateTime),
                    StartTime     = job.JobDataMap.GetDateTime(DataKeys.StartTime),
                    EndTime       = string.IsNullOrWhiteSpace(job.JobDataMap.GetString(DataKeys.EndTime)) ? null : job.JobDataMap.GetDateTime(DataKeys.EndTime),
                    LastException = job.JobDataMap.GetString(DataKeys.LastException)
                };

                IReadOnlyCollection <ITrigger> triggers = await _scheduler.GetTriggersOfJob(key);

                ITrigger trigger = triggers.FirstOrDefault();   // 获取当前job关联的第一个 trigger
                if (trigger != null)
                {
                    TriggerState triggerState = await _scheduler.GetTriggerState(trigger.Key);  // trigger 状态

                    /****计算时间差***/
                    DateTime?prevFire = trigger.GetPreviousFireTimeUtc()?.LocalDateTime;
                    DateTime?nextFire = trigger.GetNextFireTimeUtc()?.LocalDateTime;
                    TimeSpan span     = TimeSpan.FromSeconds(0);
                    if (prevFire.HasValue && nextFire.HasValue)
                    {
                        span = (nextFire.Value - prevFire.Value);
                    }
                    item.TriggerState = triggerState;
                    item.FirePlan     = $"{span.Days}天{span.Hours}小时{span.Minutes}分{span.Seconds}秒"; // 执行频率
                    item.PrevFireTime = prevFire;
                    item.NextFireTime = nextFire;
                }
                ;

                items.Add(item);
            }

            return(items.WhereIf(!string.IsNullOrWhiteSpace(request.Name), x => x.Name.Contains(request.Name.Trim())).OrderByDescending(x => x.CreateTime));
        }
Esempio n. 22
0
        public void Test(IScheduler scheduler, bool clearJobs, bool scheduleJobs)
        {
            try
            {
                if (clearJobs)
                {
                    scheduler.Clear();
                }

                if (scheduleJobs)
                {
                    ICalendar cronCalendar    = new CronCalendar("0/5 * * * * ?");
                    ICalendar holidayCalendar = new HolidayCalendar();

                    // QRTZNET-86
                    ITrigger t = scheduler.GetTrigger(new TriggerKey("NonExistingTrigger", "NonExistingGroup"));
                    Assert.IsNull(t);

                    AnnualCalendar cal = new AnnualCalendar();
                    scheduler.AddCalendar("annualCalendar", cal, false, true);

                    IOperableTrigger calendarsTrigger = new SimpleTriggerImpl("calendarsTrigger", "test", 20, TimeSpan.FromMilliseconds(5));
                    calendarsTrigger.CalendarName = "annualCalendar";

                    JobDetailImpl jd = new JobDetailImpl("testJob", "test", typeof(NoOpJob));
                    scheduler.ScheduleJob(jd, calendarsTrigger);

                    // QRTZNET-93
                    scheduler.AddCalendar("annualCalendar", cal, true, true);

                    scheduler.AddCalendar("baseCalendar", new BaseCalendar(), false, true);
                    scheduler.AddCalendar("cronCalendar", cronCalendar, false, true);
                    scheduler.AddCalendar("dailyCalendar", new DailyCalendar(DateTime.Now.Date, DateTime.Now.AddMinutes(1)), false, true);
                    scheduler.AddCalendar("holidayCalendar", holidayCalendar, false, true);
                    scheduler.AddCalendar("monthlyCalendar", new MonthlyCalendar(), false, true);
                    scheduler.AddCalendar("weeklyCalendar", new WeeklyCalendar(), false, true);

                    scheduler.AddCalendar("cronCalendar", cronCalendar, true, true);
                    scheduler.AddCalendar("holidayCalendar", holidayCalendar, true, true);

                    Assert.IsNotNull(scheduler.GetCalendar("annualCalendar"));

                    JobDetailImpl lonelyJob = new JobDetailImpl("lonelyJob", "lonelyGroup", typeof(SimpleRecoveryJob));
                    lonelyJob.Durable          = true;
                    lonelyJob.RequestsRecovery = true;
                    scheduler.AddJob(lonelyJob, false);
                    scheduler.AddJob(lonelyJob, true);

                    string schedId = scheduler.SchedulerInstanceId;

                    int count = 1;

                    JobDetailImpl job = new JobDetailImpl("job_" + count, schedId, typeof(SimpleRecoveryJob));

                    // ask scheduler to re-Execute this job if it was in progress when
                    // the scheduler went down...
                    job.RequestsRecovery = true;
                    IOperableTrigger trigger = new SimpleTriggerImpl("trig_" + count, schedId, 20, TimeSpan.FromSeconds(5));
                    trigger.JobDataMap.Add("key", "value");
                    trigger.EndTimeUtc = DateTime.UtcNow.AddYears(10);

                    trigger.StartTimeUtc = DateTime.Now.AddMilliseconds(1000L);
                    scheduler.ScheduleJob(job, trigger);

                    // check that trigger was stored
                    ITrigger persisted = scheduler.GetTrigger(new TriggerKey("trig_" + count, schedId));
                    Assert.IsNotNull(persisted);
                    Assert.IsTrue(persisted is SimpleTriggerImpl);

                    count++;
                    job = new JobDetailImpl("job_" + count, schedId, typeof(SimpleRecoveryJob));
                    // ask scheduler to re-Execute this job if it was in progress when
                    // the scheduler went down...
                    job.RequestsRecovery = (true);
                    trigger = new SimpleTriggerImpl("trig_" + count, schedId, 20, TimeSpan.FromSeconds(5));

                    trigger.StartTimeUtc = (DateTime.Now.AddMilliseconds(2000L));
                    scheduler.ScheduleJob(job, trigger);

                    count++;
                    job = new JobDetailImpl("job_" + count, schedId, typeof(SimpleRecoveryStatefulJob));
                    // ask scheduler to re-Execute this job if it was in progress when
                    // the scheduler went down...
                    job.RequestsRecovery = (true);
                    trigger = new SimpleTriggerImpl("trig_" + count, schedId, 20, TimeSpan.FromSeconds(3));

                    trigger.StartTimeUtc = (DateTime.Now.AddMilliseconds(1000L));
                    scheduler.ScheduleJob(job, trigger);

                    count++;
                    job = new JobDetailImpl("job_" + count, schedId, typeof(SimpleRecoveryJob));
                    // ask scheduler to re-Execute this job if it was in progress when
                    // the scheduler went down...
                    job.RequestsRecovery = (true);
                    trigger = new SimpleTriggerImpl("trig_" + count, schedId, 20, TimeSpan.FromSeconds(4));

                    trigger.StartTimeUtc = (DateTime.Now.AddMilliseconds(1000L));
                    scheduler.ScheduleJob(job, trigger);

                    count++;
                    job = new JobDetailImpl("job_" + count, schedId, typeof(SimpleRecoveryJob));
                    // ask scheduler to re-Execute this job if it was in progress when
                    // the scheduler went down...
                    job.RequestsRecovery = (true);
                    trigger = new SimpleTriggerImpl("trig_" + count, schedId, 20, TimeSpan.FromMilliseconds(4500));
                    scheduler.ScheduleJob(job, trigger);

                    count++;
                    job = new JobDetailImpl("job_" + count, schedId, typeof(SimpleRecoveryJob));
                    // ask scheduler to re-Execute this job if it was in progress when
                    // the scheduler went down...
                    job.RequestsRecovery = (true);
                    IOperableTrigger ct = new CronTriggerImpl("cron_trig_" + count, schedId, "0/10 * * * * ?");
                    ct.JobDataMap.Add("key", "value");
                    ct.StartTimeUtc = DateTime.Now.AddMilliseconds(1000);

                    scheduler.ScheduleJob(job, ct);

                    count++;
                    job = new JobDetailImpl("job_" + count, schedId, typeof(SimpleRecoveryJob));
                    // ask scheduler to re-Execute this job if it was in progress when
                    // the scheduler went down...
                    job.RequestsRecovery = (true);
                    DailyTimeIntervalTriggerImpl nt = new DailyTimeIntervalTriggerImpl("nth_trig_" + count, schedId, new TimeOfDay(1, 1, 1), new TimeOfDay(23, 30, 0), IntervalUnit.Hour, 1);
                    nt.StartTimeUtc = DateTime.Now.Date.AddMilliseconds(1000);

                    scheduler.ScheduleJob(job, nt);

                    DailyTimeIntervalTriggerImpl nt2 = new DailyTimeIntervalTriggerImpl();
                    nt2.Key          = new TriggerKey("nth_trig2_" + count, schedId);
                    nt2.StartTimeUtc = DateTime.Now.Date.AddMilliseconds(1000);
                    nt2.JobKey       = job.Key;
                    scheduler.ScheduleJob(nt2);

                    // GitHub issue #92
                    scheduler.GetTrigger(nt2.Key);

                    // GitHub issue #98
                    nt2.StartTimeOfDay = new TimeOfDay(1, 2, 3);
                    nt2.EndTimeOfDay   = new TimeOfDay(2, 3, 4);

                    scheduler.UnscheduleJob(nt2.Key);
                    scheduler.ScheduleJob(nt2);

                    var triggerFromDb = (IDailyTimeIntervalTrigger)scheduler.GetTrigger(nt2.Key);
                    Assert.That(triggerFromDb.StartTimeOfDay.Hour, Is.EqualTo(1));
                    Assert.That(triggerFromDb.StartTimeOfDay.Minute, Is.EqualTo(2));
                    Assert.That(triggerFromDb.StartTimeOfDay.Second, Is.EqualTo(3));

                    Assert.That(triggerFromDb.EndTimeOfDay.Hour, Is.EqualTo(2));
                    Assert.That(triggerFromDb.EndTimeOfDay.Minute, Is.EqualTo(3));
                    Assert.That(triggerFromDb.EndTimeOfDay.Second, Is.EqualTo(4));

                    job.RequestsRecovery = (true);
                    CalendarIntervalTriggerImpl intervalTrigger = new CalendarIntervalTriggerImpl(
                        "calint_trig_" + count,
                        schedId,
                        DateTime.UtcNow.AddMilliseconds(300),
                        DateTime.UtcNow.AddMinutes(1),
                        IntervalUnit.Second,
                        8);
                    intervalTrigger.JobKey = job.Key;

                    scheduler.ScheduleJob(intervalTrigger);

                    // bulk operations
                    var        info     = new Dictionary <IJobDetail, Collection.ISet <ITrigger> >();
                    IJobDetail detail   = new JobDetailImpl("job_" + count, schedId, typeof(SimpleRecoveryJob));
                    ITrigger   simple   = new SimpleTriggerImpl("trig_" + count, schedId, 20, TimeSpan.FromMilliseconds(4500));
                    var        triggers = new Collection.HashSet <ITrigger>();
                    triggers.Add(simple);
                    info[detail] = triggers;

                    scheduler.ScheduleJobs(info, true);

                    Assert.IsTrue(scheduler.CheckExists(detail.Key));
                    Assert.IsTrue(scheduler.CheckExists(simple.Key));

                    // QRTZNET-243
                    scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupContains("a").DeepClone());
                    scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEndsWith("a").DeepClone());
                    scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupStartsWith("a").DeepClone());
                    scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals("a").DeepClone());

                    scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupContains("a").DeepClone());
                    scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEndsWith("a").DeepClone());
                    scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupStartsWith("a").DeepClone());
                    scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals("a").DeepClone());

                    scheduler.Start();

                    Thread.Sleep(TimeSpan.FromSeconds(3));

                    scheduler.PauseAll();

                    scheduler.ResumeAll();

                    scheduler.PauseJob(new JobKey("job_1", schedId));

                    scheduler.ResumeJob(new JobKey("job_1", schedId));

                    scheduler.PauseJobs(GroupMatcher <JobKey> .GroupEquals(schedId));

                    Thread.Sleep(TimeSpan.FromSeconds(1));

                    scheduler.ResumeJobs(GroupMatcher <JobKey> .GroupEquals(schedId));

                    scheduler.PauseTrigger(new TriggerKey("trig_2", schedId));
                    scheduler.ResumeTrigger(new TriggerKey("trig_2", schedId));

                    scheduler.PauseTriggers(GroupMatcher <TriggerKey> .GroupEquals(schedId));

                    Assert.AreEqual(1, scheduler.GetPausedTriggerGroups().Count);

                    Thread.Sleep(TimeSpan.FromSeconds(3));
                    scheduler.ResumeTriggers(GroupMatcher <TriggerKey> .GroupEquals(schedId));

                    Assert.IsNotNull(scheduler.GetTrigger(new TriggerKey("trig_2", schedId)));
                    Assert.IsNotNull(scheduler.GetJobDetail(new JobKey("job_1", schedId)));
                    Assert.IsNotNull(scheduler.GetMetaData());
                    Assert.IsNotNull(scheduler.GetCalendar("weeklyCalendar"));

                    Thread.Sleep(TimeSpan.FromSeconds(20));

                    scheduler.Standby();

                    CollectionAssert.IsNotEmpty(scheduler.GetCalendarNames());
                    CollectionAssert.IsNotEmpty(scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals(schedId)));

                    CollectionAssert.IsNotEmpty(scheduler.GetTriggersOfJob(new JobKey("job_2", schedId)));
                    Assert.IsNotNull(scheduler.GetJobDetail(new JobKey("job_2", schedId)));

                    scheduler.DeleteCalendar("cronCalendar");
                    scheduler.DeleteCalendar("holidayCalendar");
                    scheduler.DeleteJob(new JobKey("lonelyJob", "lonelyGroup"));
                    scheduler.DeleteJob(job.Key);

                    scheduler.GetJobGroupNames();
                    scheduler.GetCalendarNames();
                    scheduler.GetTriggerGroupNames();
                }
            }
            finally
            {
                scheduler.Shutdown(false);
            }
        }
Esempio n. 23
0
        public async Task TestGetJobKeysWithEquals()
        {
            var sched = await CreateScheduler(null);

            await sched.GetJobKeys(GroupMatcher <JobKey> .GroupEquals("bar"));
        }
        protected async Task ExecutePreProcessCommands(
            IScheduler scheduler,
            CancellationToken cancellationToken = default(CancellationToken))
        {
            foreach (string group in jobGroupsToDelete)
            {
                if (group.Equals("*"))
                {
                    Log.Info("Deleting all jobs in ALL groups.");
                    foreach (string groupName in await scheduler.GetJobGroupNames(cancellationToken).ConfigureAwait(false))
                    {
                        if (!jobGroupsToNeverDelete.Contains(groupName))
                        {
                            foreach (JobKey key in await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals(groupName), cancellationToken).ConfigureAwait(false))
                            {
                                await scheduler.DeleteJob(key, cancellationToken).ConfigureAwait(false);
                            }
                        }
                    }
                }
                else
                {
                    if (!jobGroupsToNeverDelete.Contains(group))
                    {
                        Log.InfoFormat("Deleting all jobs in group: {0}", group);
                        foreach (JobKey key in await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals(group), cancellationToken).ConfigureAwait(false))
                        {
                            await scheduler.DeleteJob(key, cancellationToken).ConfigureAwait(false);
                        }
                    }
                }
            }

            foreach (string group in triggerGroupsToDelete)
            {
                if (group.Equals("*"))
                {
                    Log.Info("Deleting all triggers in ALL groups.");
                    foreach (string groupName in await scheduler.GetTriggerGroupNames(cancellationToken).ConfigureAwait(false))
                    {
                        if (!triggerGroupsToNeverDelete.Contains(groupName))
                        {
                            foreach (TriggerKey key in await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals(groupName), cancellationToken).ConfigureAwait(false))
                            {
                                await scheduler.UnscheduleJob(key, cancellationToken).ConfigureAwait(false);
                            }
                        }
                    }
                }
                else
                {
                    if (!triggerGroupsToNeverDelete.Contains(group))
                    {
                        Log.InfoFormat("Deleting all triggers in group: {0}", group);
                        foreach (TriggerKey key in await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals(group), cancellationToken).ConfigureAwait(false))
                        {
                            await scheduler.UnscheduleJob(key, cancellationToken).ConfigureAwait(false);
                        }
                    }
                }
            }

            foreach (JobKey key in jobsToDelete)
            {
                if (!jobGroupsToNeverDelete.Contains(key.Group))
                {
                    Log.InfoFormat("Deleting job: {0}", key);
                    await scheduler.DeleteJob(key, cancellationToken).ConfigureAwait(false);
                }
            }

            foreach (TriggerKey key in triggersToDelete)
            {
                if (!triggerGroupsToNeverDelete.Contains(key.Group))
                {
                    Log.InfoFormat("Deleting trigger: {0}", key);
                    await scheduler.UnscheduleJob(key, cancellationToken).ConfigureAwait(false);
                }
            }
        }
Esempio n. 25
0
 protected override void PerformOperation(GroupInput input)
 {
     Scheduler.PauseJobs(GroupMatcher <JobKey> .GroupEquals(input.Group));
 }
Esempio n. 26
0
        public override void Update(IScheduler scheduler)
        {
            this.Scheduler = scheduler;

            var grps = this.Scheduler.GetJobGroupNames();

            this.Jobs = new BindableCollection <IJobDetail>(grps.SelectMany(grp => this.Scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals(grp)))
                                                            .Select(key => this.Scheduler.GetJobDetail(key)));
            this.NotifyOfPropertyChange(() => this.Jobs);
        }
Esempio n. 27
0
        public async Task TesDirectivesNoOverwriteWithIgnoreDups()
        {
            // create temp file
            string tempFileName = XMLSchedulingDataProcessor.QuartzXmlFileName;

            using (TextWriter writer = new StreamWriter(File.OpenWrite(tempFileName)))
            {
                using (StreamReader reader = new StreamReader(ReadJobXmlFromEmbeddedResource("directives_overwrite_no-ignoredups.xml")))
                {
                    await writer.WriteAsync(await reader.ReadToEndAsync());

                    await writer.FlushAsync();
                }
            }

            IScheduler scheduler = null;

            try
            {
                NameValueCollection properties = new NameValueCollection();
                properties["quartz.serializer.type"] = TestConstants.DefaultSerializerType;

                StdSchedulerFactory factory = new StdSchedulerFactory(properties);
                scheduler = await factory.GetScheduler();

                // Setup existing job with same names as in xml data.
                IJobDetail job = JobBuilder.Create <NoOpJob>()
                                 .WithIdentity("job1")
                                 .Build();

                ITrigger trigger = TriggerBuilder.Create()
                                   .WithIdentity("job1")
                                   .WithSchedule(SimpleScheduleBuilder.RepeatHourlyForever()).Build();

                await scheduler.ScheduleJob(job, trigger);

                job = JobBuilder.Create <NoOpJob>()
                      .WithIdentity("job2")
                      .Build();

                trigger = TriggerBuilder.Create().WithIdentity("job2").WithSchedule(SimpleScheduleBuilder.RepeatHourlyForever()).Build();
                await scheduler.ScheduleJob(job, trigger);

                // Now load the xml data with directives: overwrite-existing-data=false, ignore-duplicates=true
                ITypeLoadHelper loadHelper = new SimpleTypeLoadHelper();
                loadHelper.Initialize();
                XMLSchedulingDataProcessor processor = new XMLSchedulingDataProcessor(loadHelper);
                await processor.ProcessFileAndScheduleJobs(tempFileName, scheduler);

                var jobKeys = await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals("DEFAULT"));

                Assert.AreEqual(2, jobKeys.Count);
                var triggerKeys = await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals("DEFAULT"));

                Assert.AreEqual(2, triggerKeys.Count);
            }
            finally
            {
                if (scheduler != null)
                {
                    await scheduler.Shutdown();
                }
            }
        }
        public void TestOverwriteFlag()
        {
            // create temp file
            string tempFileName = XMLSchedulingDataProcessor.QuartzXmlFileName;

            using (TextWriter writer = new StreamWriter(tempFileName, false))
            {
                using (StreamReader reader = new StreamReader(ReadJobXmlFromEmbeddedResource("SimpleJobTrigger.xml")))
                {
                    writer.Write(reader.ReadToEnd());
                    writer.Flush();
                    writer.Close();
                }
            }

            IScheduler scheduler = null;

            try
            {
                StdSchedulerFactory factory = new StdSchedulerFactory();
                scheduler = StdSchedulerFactory.GetDefaultScheduler();

                // Let's setup a fixture job data that we know test is not going modify it.
                IJobDetail job = JobBuilder.Create <NoOpJob>()
                                 .WithIdentity("job1").UsingJobData("foo", "dont_chg_me").Build();
                ITrigger trigger = TriggerBuilder.Create().WithIdentity("job1").WithSchedule(SimpleScheduleBuilder.RepeatHourlyForever()).Build();
                scheduler.ScheduleJob(job, trigger);

                XMLSchedulingDataProcessor processor = new XMLSchedulingDataProcessor(new SimpleTypeLoadHelper());
                try
                {
                    processor.ProcessFileAndScheduleJobs(scheduler, false);
                    Assert.Fail("OverWriteExisting flag didn't work. We should get Exception when overwrite is set to false.");
                }
                catch (ObjectAlreadyExistsException)
                {
                    // This is expected. Do nothing.
                }

                // We should still have what we start with.
                Assert.AreEqual(1, scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals("DEFAULT")).Count);
                Assert.AreEqual(1, scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals("DEFAULT")).Count);

                job = scheduler.GetJobDetail(JobKey.Create("job1"));
                String fooValue = job.JobDataMap.GetString("foo");
                Assert.AreEqual("dont_chg_me", fooValue);
            }
            finally
            {
                if (File.Exists(tempFileName))
                {
                    File.Delete(tempFileName);
                }

                // shutdown scheduler
                if (scheduler != null)
                {
                    scheduler.Shutdown();
                }
            }
        }
        public async Task Action([FromBody] ActionArgs args)
        {
            switch (args.Action.ToLower())
            {
            case "shutdown":
                await Scheduler.Shutdown();

                break;

            case "standby":
                await Scheduler.Standby();

                break;

            case "start":
                await Scheduler.Start();

                break;

            case "pause":
                if (string.IsNullOrEmpty(args.Name))
                {
                    await Scheduler.PauseAll();
                }
                else
                {
                    if (args.Groups == "trigger-groups")
                    {
                        await Scheduler.PauseTriggers(GroupMatcher <TriggerKey> .GroupEquals(args.Name));
                    }
                    else if (args.Groups == "job-groups")
                    {
                        await Scheduler.PauseJobs(GroupMatcher <JobKey> .GroupEquals(args.Name));
                    }
                    else
                    {
                        throw new InvalidOperationException("Invalid groups: " + args.Groups);
                    }
                }
                break;

            case "resume":
                if (string.IsNullOrEmpty(args.Name))
                {
                    await Scheduler.ResumeAll();
                }
                else
                {
                    if (args.Groups == "trigger-groups")
                    {
                        await Scheduler.ResumeTriggers(GroupMatcher <TriggerKey> .GroupEquals(args.Name));
                    }
                    else if (args.Groups == "job-groups")
                    {
                        await Scheduler.ResumeJobs(GroupMatcher <JobKey> .GroupEquals(args.Name));
                    }
                    else
                    {
                        throw new InvalidOperationException("Invalid groups: " + args.Groups);
                    }
                }
                break;

            default:
                throw new InvalidOperationException("Invalid action: " + args.Action);
            }
        }
Esempio n. 30
0
        public void Execute(IJobExecutionContext context)
        {
            #region 添加脚本任务
            ISchedulerFactory schedulerFactory = new StdSchedulerFactory();
            IScheduler        scheduler        = schedulerFactory.GetScheduler();

            string jobGroupName = "ScriptJobGroup";
            string triGroupName = "ScriptTriGroup";
            string jobNamePex   = "ScriptJob_";
            string triNamePex   = "ScriptTri_";

            //所有需要运行的脚本
            var allScript = AllScript();
            var triKeyArr = scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals("ScriptTriGroup"));
            //删除触发器,删除这个触发器没有在运行的脚本里
            foreach (var t in triKeyArr)
            {
                var        trigger = scheduler.GetTrigger(t);
                IJobDetail job     = scheduler.GetJobDetail(trigger.JobKey);
                var        tmp     = allScript.SingleOrDefault(x => t.Name == triNamePex + x.ID.ToString());
                if (tmp == null)
                {
                    StopTask(Convert.ToInt32(t.Name.Replace(triNamePex, "")));
                    scheduler.DeleteJob(trigger.JobKey);
                    logger.InfoFormat("脚本服务 移除触发器ID{0}", t.Name);
                }
            }

            foreach (var t in allScript)
            {
                try
                {
                    //新任务
                    if (triKeyArr.SingleOrDefault(x => x.Name == triNamePex + t.ID.ToString()) == null)
                    {
                        IJobDetail job = JobBuilder.Create <ScriptTaskAddQuartz>()
                                         .WithIdentity(new JobKey(jobNamePex + t.ID.ToString(), jobGroupName))
                                         .StoreDurably()
                                         .Build();

                        ICronTrigger trigger = (ICronTrigger)TriggerBuilder.Create()
                                               .WithIdentity(new TriggerKey(triNamePex + t.ID.ToString(), triGroupName))
                                               .ForJob(job)
                                               .StartNow().WithCronSchedule(t.RUN_WHEN)
                                               .Build();
                        logger.InfoFormat("脚本服务 添加脚本触发器ID{0}", trigger.Key.Name);
                        scheduler.ScheduleJob(job, trigger);
                    }
                    else
                    {
                        ICronTrigger trigger = (ICronTrigger)scheduler.GetTrigger(new TriggerKey(triNamePex + t.ID.ToString(), triGroupName));
                        IJobDetail   job     = scheduler.GetJobDetail(trigger.JobKey);
                        if (trigger.CronExpressionString != t.RUN_WHEN)
                        {
                            logger.InfoFormat("脚本服务 修改触发器【{0}】的时间表达式【{1}】为【{2}】", trigger.Key.Name, trigger.CronExpressionString, t.RUN_WHEN);
                            trigger.CronExpressionString = t.RUN_WHEN;
                            scheduler.DeleteJob(trigger.JobKey);
                            scheduler.ScheduleJob(job, trigger);
                        }
                    }
                }
                catch (Exception e) {
                    Dictionary <string, object> dicStart = new Dictionary <string, object>();
                    dicStart.Add("STATUS", "禁用");
                    FunSqlToClass.UpData <SCRIPT>(
                        ConfigurationManager.AppSettings["dbType"],
                        ConfigurationManager.AppSettings["dbConnSt"],
                        dicStart,
                        string.Format("where ID={0} ", t.ID),
                        ConfigurationManager.AppSettings["dbPrefix"]);

                    logger.InfoFormat("脚本服务 添加脚本触发器任务【{0}】,失败【{1}】", t.CODE, e.Message);
                }
            }
            #endregion

            #region 运行脚本任务


            //获取正在等待的任务
            foreach (var task in AllScriptTask())
            {
                try
                {
                    #region 检测运算实例是否存在,并把结束了的线程终止
                    QuartzRunStatus         nowQrs = new QuartzRunStatus();
                    IList <QuartzRunStatus> qrs    = new List <QuartzRunStatus>();

                    try
                    {
                        qrs = ProInterface.JSON.EncodeToEntity <IList <QuartzRunStatus> >(System.IO.File.ReadAllText(statusLogPath));
                    }
                    catch { }
                    //清理2小时还没有远行完的口径
                    foreach (var t in qrs.Where(x => x.StatusTime.AddHours(2) < DateTime.Now).ToList())
                    {
                        qrs.Remove(t);
                    }
                    if (qrs == null)
                    {
                        qrs = new List <QuartzRunStatus>();
                    }
                    nowQrs = qrs.SingleOrDefault(x => x.JobName == "ScriptID_" + task.SCRIPT_ID);
                    if (nowQrs == null)
                    {
                        nowQrs = new QuartzRunStatus();
                    }
                    //表示该脚本正在运行,则退出
                    if (nowQrs.IsRun)
                    {
                        continue;
                    }
                    if (qrs.Count > ProInterface.AppSet.ScriptRunMaxNum)
                    {
                        logger.InfoFormat("执行脚本数【{0}】已经超过最大任务数【{1}】了", qrs.Count, ProInterface.AppSet.ScriptRunMaxNum);
                        return;
                    }
                    nowQrs.IsRun      = true;
                    nowQrs.JobName    = "ScriptID_" + task.SCRIPT_ID;
                    nowQrs.StatusTime = DateTime.Now;
                    if (qrs.SingleOrDefault(x => x.JobName == "ScriptID_" + task.SCRIPT_ID) == null)
                    {
                        qrs.Add(nowQrs);
                    }
                    Fun.WriteAllText(statusLogPath, ProInterface.JSON.DecodeToStr(qrs));

                    #endregion

                    logger.InfoFormat("执行脚本 开始脚本【{0}】,任务ID【{1}】", task.SCRIPT_ID, task.ID);
                    Dictionary <string, object> dicStart = new Dictionary <string, object>();
                    dicStart.Add("RUN_STATE", "运行");
                    dicStart.Add("START_TIME", DateTime.Now);
                    dicStart.Add("RETURN_CODE", null);
                    dicStart.Add("END_TIME", null);
                    dicStart.Add("DISABLE_DATE", null);
                    dicStart.Add("DISABLE_REASON", null);
                    FunSqlToClass.UpData <SCRIPT_TASK>(
                        ConfigurationManager.AppSettings["dbType"],
                        ConfigurationManager.AppSettings["dbConnSt"],
                        dicStart,
                        string.Format("where ID={0} ", task.ID),
                        ConfigurationManager.AppSettings["dbPrefix"]);
                    FunSqlToClass.NonQuery("DELETE FROM YL_SCRIPT_TASK_LOG where SCRIPT_TASK_ID=" + task.ID,
                                           ConfigurationManager.AppSettings["dbType"],
                                           ConfigurationManager.AppSettings["dbConnSt"],
                                           ConfigurationManager.AppSettings["dbPrefix"]);

                    ProServer.Service      db    = new Service();
                    ProInterface.ErrorInfo error = new ProInterface.ErrorInfo();
                    object obj = db.ScriptTaskStart(ref error, Convert.ToInt32(task.ID));
                    if (error.IsError)
                    {
                        Dictionary <string, object> dic = new Dictionary <string, object>();
                        dic.Add("RUN_STATE", "停止");
                        dic.Add("RETURN_CODE", "失败");
                        dic.Add("END_TIME", DateTime.Now);
                        dic.Add("DISABLE_DATE", DateTime.Now);
                        if (error.Message != null)
                        {
                            if (error.Message.Length > 25)
                            {
                                dic.Add("DISABLE_REASON", error.Message.Substring(0, 25));
                            }
                            else
                            {
                                dic.Add("DISABLE_REASON", error.Message);
                            }
                        }
                        FunSqlToClass.UpData <SCRIPT_TASK>(
                            ConfigurationManager.AppSettings["dbType"],
                            ConfigurationManager.AppSettings["dbConnSt"],
                            dic,
                            string.Format("where ID={0} ", task.ID),
                            ConfigurationManager.AppSettings["dbPrefix"]);
                        logger.InfoFormat("执行脚本 脚本【{0}】,任务ID【{1}】 出错:{2}", task.SCRIPT_ID, task.ID, error.Message);
                    }
                    else
                    {
                        logger.InfoFormat("执行脚本 结束脚本【{0}】,任务ID【{1}】", task.SCRIPT_ID, task.ID);
                    }
                }
                catch (Exception e)
                {
                    logger.InfoFormat("分析 结束脚本【{0}】,任务ID【{1}】,出错:{2}", task.SCRIPT_ID, task.ID, e.ToString());
                }

                var qrsEnd    = ProInterface.JSON.EncodeToEntity <IList <QuartzRunStatus> >(System.IO.File.ReadAllText(statusLogPath));
                var nowQrsEnd = qrsEnd.SingleOrDefault(x => x.JobName == "ScriptID_" + task.SCRIPT_ID);
                if (nowQrsEnd != null)
                {
                    qrsEnd.Remove(nowQrsEnd);
                    Fun.WriteAllText(statusLogPath, ProInterface.JSON.DecodeToStr(qrsEnd));
                }
            }
            #endregion
        }