Esempio n. 1
0
 /// <summary>
 /// 注册事件
 /// </summary>
 /// <param name="jobi"></param>
 /// <param name="groupName">监听的任务所属组</param>
 /// <param name="name">Scheduler名称</param>
 /// <returns></returns>
 public async Task AddJobListener(IJobListener jobi, string groupName, string name = defaultScheduler)
 {
     this.SchedulerList[name].ListenerManager.AddJobListener(jobi, GroupMatcher <JobKey> .GroupEquals(groupName));
 }
Esempio n. 2
0
        /// <summary>
        /// Resume (un-pause) all of the <see cref="ITrigger" />s in the
        /// given group.
        /// <para>
        /// If any <see cref="ITrigger" /> missed one or more fire-times, then the
        /// <see cref="ITrigger" />'s misfire instruction will be applied.
        /// </para>
        /// </summary>
        public virtual IList<string> ResumeTriggers(GroupMatcher<TriggerKey> matcher)
        {
            Collection.ISet<string> groups = new Collection.HashSet<string>();
            lock (lockObject)
            {
                Collection.ISet<TriggerKey> keys = this.GetTriggerKeys(matcher);

                foreach (TriggerKey triggerKey in keys)
                {
                    groups.Add(triggerKey.Group);
                    IOperableTrigger trigger = this.Triggers.FindOneByIdAs<IOperableTrigger>(triggerKey.ToBsonDocument());
                    var pausedJobGroup = this.PausedJobGroups.FindOneByIdAs<string>(trigger.JobKey.Group);
                    if (pausedJobGroup != null)
                    {
                        continue;
                    }

                    this.ResumeTrigger(triggerKey);
                }

                foreach (String group in groups)
                {
                    this.PausedTriggerGroups.Remove(
                        Query.EQ("_id", group));
                }
            }

            return new List<string>(groups);
        }
Esempio n. 3
0
        /// <summary>
        /// Pause all of the <see cref="ITrigger" />s in the given group.
        /// <para>
        /// The JobStore should "remember" that the group is paused, and impose the
        /// pause on any new triggers that are added to the group while the group is
        /// paused.
        /// </para>
        /// </summary>
        public virtual Collection.ISet<string> PauseTriggers(GroupMatcher<TriggerKey> matcher)
        {
            IList<string> pausedGroups;

            lock (lockObject)
            {
                pausedGroups = new List<string>();

                StringOperator op = matcher.CompareWithOperator;
                if (op == StringOperator.Equality)
                {
                    this.PausedTriggerGroups.Save(
                        new BsonDocument(
                            new BsonElement("_id", matcher.CompareToValue)));

                    pausedGroups.Add(matcher.CompareToValue);
                }
                else
                {
                    IList<string> groups = this.GetTriggerGroupNames();

                    foreach (string group in groups)
                    {
                        if (op.Evaluate(group, matcher.CompareToValue))
                        {
                            this.PausedTriggerGroups.Save(
                                new BsonDocument(
                                    new BsonElement("_id", matcher.CompareToValue)));

                            pausedGroups.Add(matcher.CompareToValue);
                        }
                    }
                }

                foreach (string pausedGroup in pausedGroups)
                {
                    Collection.ISet<TriggerKey> keys = this.GetTriggerKeys(GroupMatcher<TriggerKey>.GroupEquals(pausedGroup));

                    foreach (TriggerKey key in keys)
                    {
                        this.PauseTrigger(key);
                    }
                }
            }
            return new Collection.HashSet<string>(pausedGroups);
        }
Esempio n. 4
0
 /// <summary>
 /// Get the names of all of the <see cref="ITrigger" /> s
 /// that have the given group name.
 /// </summary>
 /// <remarks>
 /// If there are no triggers in the given group name, the result should be a
 /// zero-length array (not <see langword="null" />).
 /// </remarks>
 public Collection.ISet<TriggerKey> GetTriggerKeys(GroupMatcher<TriggerKey> matcher)
 {
     // no locks necessary for read...
     return (Collection.ISet<TriggerKey>)ExecuteWithoutLock(conn => GetTriggerNames(conn, matcher));
 }
Esempio n. 5
0
 /// <summary>
 /// Calls the equivalent method on the 'proxied' <see cref="QuartzScheduler" />.
 /// </summary>
 public virtual Collection.ISet<TriggerKey> GetTriggerKeys(GroupMatcher<TriggerKey> matcher)
 {
     try
     {
         return GetRemoteScheduler().GetTriggerKeys(matcher);
     }
     catch (RemotingException re)
     {
         throw InvalidateHandleCreateException("Error communicating with remote scheduler.", re);
     }
 }
        /// <summary>
        /// Resume (un-pause) all of the <see cref="T:Quartz.IJob"/>s in
        ///             the given group.
        /// <para>
        /// If any of the <see cref="T:Quartz.IJob"/> s had <see cref="T:Quartz.ITrigger"/> s that
        ///             missed one or more fire-times, then the <see cref="T:Quartz.ITrigger"/>'s
        ///             misfire instruction will be applied.
        /// </para>
        /// </summary>
        public override global::Quartz.Collection.ISet<string> ResumeJobs(GroupMatcher<JobKey> matcher)
        {
            var resumedJobGroups = new List<string>();

            if (matcher.CompareWithOperator.Equals(StringOperator.Equality))
            {
                var jobGroupSetKey = RedisJobStoreSchema.JobGroupSetKey(matcher.CompareToValue);

                var removedPausedResult = Db.SetRemove(RedisJobStoreSchema.PausedJobGroupsSetKey(), jobGroupSetKey);
                var jobsResult = Db.SetMembers(jobGroupSetKey);

                if (removedPausedResult)
                {
                    resumedJobGroups.Add(RedisJobStoreSchema.JobGroup(jobGroupSetKey));
                }

                foreach (var job in jobsResult)
                {
                    ResumeJob(RedisJobStoreSchema.JobKey(job));
                }
            }
            else
            {
                foreach (var jobGroupSetKey in Db.SetMembers(RedisJobStoreSchema.JobGroupsSetKey()))
                {
                    if (matcher.CompareWithOperator.Evaluate(RedisJobStoreSchema.JobGroup(jobGroupSetKey),
                                                            matcher.CompareToValue))
                    {

                        resumedJobGroups.AddRange(ResumeJobs(
                                GroupMatcher<JobKey>.GroupEquals(RedisJobStoreSchema.JobGroup(jobGroupSetKey))));
                    }
                }
            }

            return new global::Quartz.Collection.HashSet<string>(resumedJobGroups);
        }
Esempio n. 7
0
 public virtual IList<string> ResumeTriggers(GroupMatcher<TriggerKey> matcher)
 {
     return (IList<string>)ExecuteInLock(LockTriggerAccess, conn => ResumeTriggers(conn, matcher));
 }
Esempio n. 8
0
 /// <summary>
 /// Calls the equivalent method on the 'proxied' <see cref="QuartzScheduler" />.
 /// </summary>
 public virtual void ResumeJobs(GroupMatcher <JobKey> matcher)
 {
     sched.ResumeJobs(matcher);
 }
Esempio n. 9
0
 /// <summary>
 /// Calls the equivalent method on the 'proxied' <see cref="QuartzScheduler" />.
 /// </summary>
 public virtual Collection.ISet <JobKey> GetJobKeys(GroupMatcher <JobKey> matcher)
 {
     return(sched.GetJobKeys(matcher));
 }
Esempio n. 10
0
 /// <summary>
 /// Calls the equivalent method on the 'proxied' <see cref="QuartzScheduler" />.
 /// </summary>
 public virtual void PauseJobs(GroupMatcher <JobKey> matcher)
 {
     sched.PauseJobs(matcher);
 }
Esempio n. 11
0
 /// <summary>
 /// Calls the equivalent method on the 'proxied' <see cref="QuartzScheduler" />.
 /// </summary>
 public virtual void ResumeTriggers(GroupMatcher <TriggerKey> matcher)
 {
     sched.ResumeTriggers(matcher);
 }
Esempio n. 12
0
 /// <summary>
 /// Calls the equivalent method on the 'proxied' <see cref="QuartzScheduler" />.
 /// </summary>
 public virtual void PauseTriggers(GroupMatcher <TriggerKey> matcher)
 {
     sched.PauseTriggers(matcher);
 }
Esempio n. 13
0
        protected override void PerformOperation(GroupInput input)
        {
            var keys = Scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals(input.Group));

            Scheduler.DeleteJobs(keys.ToList());
        }
Esempio n. 14
0
 public List <JobInfo> List()
 {
     try
     {
         var scheduler = QuartzSchedulerMgr.GetScheduler();
         var groups    = scheduler.GetJobGroupNames();
         var list      = new List <JobInfo>();
         foreach (var groupName in groups)
         {
             foreach (var jobKey in QuartzSchedulerMgr.GetScheduler().GetJobKeys(GroupMatcher <JobKey> .GroupEquals(groupName)))
             {
                 string         jobName  = jobKey.Name;
                 string         jobGroup = jobKey.Group;
                 DateTimeOffset?nextFire = null;
                 var            triggers = QuartzSchedulerMgr.GetScheduler().GetTriggersOfJob(jobKey);
                 foreach (ITrigger trigger in triggers)
                 {
                     nextFire = trigger.GetNextFireTimeUtc();
                 }
                 list.Add(new JobInfo
                 {
                     JobGroup = jobGroup,
                     JobName  = jobName,
                     Triggers = triggers,
                     NextFire = nextFire
                 });
             }
         }
         return(list);
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
Esempio n. 15
0
        protected virtual Collection.ISet<IJobDetail> GetScheduledJobDetails(ConnectionAndTransactionHolder conn, GroupMatcher<JobKey> matcher)
        {
            Collection.ISet<IJobDetail> jobs;

            try
            {
                jobs = Delegate.SelectScheduledJobDetailsInGroup(conn, matcher, TypeLoadHelper);
            }
            catch (Exception e)
            {
                throw new JobPersistenceException("Couldn't obtain job names: " + e.Message, e);
            }

            return jobs;
        }
Esempio n. 16
0
 /// <summary>
 /// Calls the equivalent method on the 'proxied' <see cref="QuartzScheduler" />.
 /// </summary>
 public virtual Collection.ISet <TriggerKey> GetTriggerKeys(GroupMatcher <TriggerKey> matcher)
 {
     return(sched.GetTriggerKeys(matcher));
 }
Esempio n. 17
0
        /// <summary>
        /// Pause the <see cref="T:Quartz.IJob"/> with the given key - by
        ///             pausing all of its current <see cref="T:Quartz.ITrigger"/>s.
        /// </summary>
        public override IList<string> PauseJobs(GroupMatcher<JobKey> matcher)
        {
            var pausedJobGroups = new List<string>();

            if (matcher.CompareWithOperator.Equals(StringOperator.Equality))
            {
                var jobGroupSetKey = RedisJobStoreSchema.JobGroupSetKey(matcher.CompareToValue);

                if (Db.SetAdd(RedisJobStoreSchema.PausedJobGroupsSetKey(), jobGroupSetKey))
                {
                    pausedJobGroups.Add(RedisJobStoreSchema.JobGroup(jobGroupSetKey));

                    foreach (RedisValue val in Db.SetMembers(jobGroupSetKey))
                    {
                        PauseJob(RedisJobStoreSchema.JobKey(val));
                    }
                }
            }
            else
            {
                var jobGroupSets = Db.SetMembers(RedisJobStoreSchema.JobGroupsSetKey());

                var jobGroups = jobGroupSets.Where(jobGroupSet => matcher.CompareWithOperator.Evaluate(RedisJobStoreSchema.JobGroup(jobGroupSet), matcher.CompareToValue)).ToDictionary<RedisValue, string, RedisValue[]>(jobGroupSet => jobGroupSet, jobGroupSet => Db.SetMembers(jobGroupSet.ToString()));

                foreach (var jobGroup in jobGroups)
                {
                    if (Db.SetAdd(RedisJobStoreSchema.PausedJobGroupsSetKey(), jobGroup.Key))
                    {
                        pausedJobGroups.Add(RedisJobStoreSchema.JobGroup(jobGroup.Key));

                        foreach (var jobHashKey in jobGroup.Value)
                        {
                            PauseJob(RedisJobStoreSchema.JobKey(jobHashKey));
                        }
                    }
                }
            }

            return pausedJobGroups;
        }
Esempio n. 18
0
        public void TestBasicStorageFunctions()
        {
            IScheduler sched = CreateScheduler("testBasicStorageFunctions", 2);

            sched.Clear();

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

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

            sched.AddJob(job, false);

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

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

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

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

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

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

            sched.ScheduleJob(job, trigger);

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

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

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

            trigger = 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();

            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();

            sched.ScheduleJob(job, trigger);

            IList <string> jobGroups     = sched.GetJobGroupNames();
            IList <string> triggerGroups = 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 ");

            Collection.ISet <JobKey>     jobKeys     = sched.GetJobKeys(GroupMatcher <JobKey> .GroupEquals(JobKey.DefaultGroup));
            Collection.ISet <TriggerKey> triggerKeys = 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     = sched.GetJobKeys(GroupMatcher <JobKey> .GroupEquals("g1"));
            triggerKeys = 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 = sched.GetTriggerState(new TriggerKey("t2", "g1"));

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

            sched.PauseTrigger(new TriggerKey("t2", "g1"));
            s = sched.GetTriggerState(new TriggerKey("t2", "g1"));
            Assert.That(s.Equals(TriggerState.Paused), "State of trigger t2 expected to be PAUSED ");

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

            Collection.ISet <string> pausedGroups = sched.GetPausedTriggerGroups();
            Assert.That(pausedGroups, Is.Empty, "Size of paused trigger groups list expected to be 0 ");

            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();

            sched.ScheduleJob(job, trigger);

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

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

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

            sched.ResumeTriggers(GroupMatcher <TriggerKey> .GroupEquals("g1"));
            s = sched.GetTriggerState(new TriggerKey("t2", "g1"));
            Assert.That(s.Equals(TriggerState.Normal), "State of trigger t2 expected to be NORMAL ");
            s = sched.GetTriggerState(new TriggerKey("t4", "g1"));
            Assert.That(s.Equals(TriggerState.Normal), "State of trigger t4 expected to be NORMAL ");
            pausedGroups = sched.GetPausedTriggerGroups();
            Assert.That(pausedGroups, Is.Empty, "Size of paused trigger groups list expected to be 0 ");

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

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

            jobKeys     = sched.GetJobKeys(GroupMatcher <JobKey> .GroupEquals("g1"));
            triggerKeys = 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(sched.UnscheduleJob(new TriggerKey("t1")), "Scheduler should have returned 'true' from attempt to unschedule existing trigger. ");

            jobKeys     = sched.GetJobKeys(GroupMatcher <JobKey> .GroupEquals(JobKey.DefaultGroup));
            triggerKeys = 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 ");

            sched.Shutdown();
        }
Esempio n. 19
0
        /// <summary>
        /// Get the names of all of the <see cref="T:Quartz.ITrigger"/>s
        ///             that have the given group name.
        /// <para>
        /// If there are no triggers in the given group name, the result should be a
        ///             zero-length array (not <see langword="null"/>).
        /// </para>
        /// </summary>
        public override global::Quartz.Collection.ISet<TriggerKey> TriggerKeys(GroupMatcher<TriggerKey> matcher)
        {
            var triggerKeys = new global::Quartz.Collection.HashSet<TriggerKey>();

            if (matcher.CompareWithOperator.Equals(StringOperator.Equality))
            {
                var triggerGroupSetKey =
                    this.RedisJobStoreSchema.TriggerGroupSetKey(matcher.CompareToValue);

                var triggers = this.Db.SetMembers(triggerGroupSetKey);

                foreach (var trigger in triggers)
                {
                    triggerKeys.Add(this.RedisJobStoreSchema.TriggerKey(trigger));
                }
            }
            else
            {
                var triggerGroupSets = this.Db.SetMembersAsync(this.RedisJobStoreSchema.TriggerGroupsSetKey()).Result;
                var triggerGroupsResult = (from groupSet in triggerGroupSets where matcher.CompareWithOperator.Evaluate(this.RedisJobStoreSchema.TriggerGroup(groupSet), matcher.CompareToValue) select Db.SetMembers(groupSet.ToString())).ToList();

                foreach (var triggerHashKeys in triggerGroupsResult)
                {
                    if (triggerHashKeys != null)
                    {
                        foreach (var triggerHashKey in triggerHashKeys)
                        {
                            triggerKeys.Add(this.RedisJobStoreSchema.TriggerKey(triggerHashKey));
                        }
                    }
                }
            }

            return triggerKeys;
        }
 public Task PauseJobs(string group)
 {
     Scheduler.PauseJobs(GroupMatcher <JobKey> .GroupEquals(group));
     return(Task.CompletedTask);
 }
Esempio n. 21
0
        protected virtual Collection.ISet<JobKey> GetJobNames(ConnectionAndTransactionHolder conn, GroupMatcher<JobKey> matcher)
        {
            Collection.ISet<JobKey> jobNames;

            try
            {
                jobNames = Delegate.SelectJobsInGroup(conn, matcher);
            }
            catch (Exception e)
            {
                throw new JobPersistenceException("Couldn't obtain job names: " + e.Message, e);
            }

            return jobNames;
        }
Esempio n. 22
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. 23
0
        /// <summary>
        /// Pause all of the <see cref="ITrigger" />s in the given group.
        /// </summary>
        public virtual Collection.ISet<string> PauseTriggerGroup(ConnectionAndTransactionHolder conn, GroupMatcher<TriggerKey> matcher)
        {
            try
            {
                Delegate.UpdateTriggerGroupStateFromOtherStates(conn, matcher, StatePaused,
                                                                StateAcquired, StateWaiting,
                                                                StateWaiting);

                Delegate.UpdateTriggerGroupStateFromOtherState(conn, matcher, StatePausedBlocked,
                                                               StateBlocked);

                IList<String> groups = Delegate.SelectTriggerGroups(conn, matcher);

                // make sure to account for an exact group match for a group that doesn't yet exist
                StringOperator op = matcher.CompareWithOperator;
                if (op.Equals(StringOperator.Equality) && !groups.Contains(matcher.CompareToValue))
                {
                    groups.Add(matcher.CompareToValue);
                }

                foreach (string group in groups)
                {
                    if (!Delegate.IsTriggerGroupPaused(conn, group))
                    {
                        Delegate.InsertPausedTriggerGroup(conn, group);
                    }
                }

                return new Collection.HashSet<string>(groups);
            }
            catch (Exception e)
            {
                throw new JobPersistenceException("Couldn't pause trigger group '" + matcher + "': " + e.Message, e);
            }
        }
Esempio n. 24
0
        public async Task TestGetJobKeysWithLike()
        {
            var sched = await CreateScheduler(null);

            await sched.GetJobKeys(GroupMatcher <JobKey> .GroupStartsWith("foo"));
        }
Esempio n. 25
0
 /// <summary>
 /// Calls the equivalent method on the 'proxied' <see cref="QuartzScheduler" />.
 /// </summary>
 public virtual void ResumeTriggers(GroupMatcher<TriggerKey> matcher)
 {
     try
     {
         GetRemoteScheduler().ResumeTriggers(matcher);
     }
     catch (RemotingException re)
     {
         throw InvalidateHandleCreateException("Error communicating with remote scheduler.", re);
     }
 }
Esempio n. 26
0
        public async Task TestGetJobKeysWithEquals()
        {
            var sched = await CreateScheduler(null);

            await sched.GetJobKeys(GroupMatcher <JobKey> .GroupEquals("bar"));
        }
Esempio n. 27
0
        /// <summary>
        /// Get the names of all of the <see cref="ITrigger" /> s
        /// that have the given group name.
        /// </summary>
        public virtual Collection.ISet<TriggerKey> GetTriggerKeys(GroupMatcher<TriggerKey> matcher)
        {
            lock (lockObject)
            {
                var result = this.Triggers
                    .FindAs<Spi.IOperableTrigger>(
                        Query.EQ("Group", matcher.CompareToValue))
                    .Select(t => t.Key);

                return new Collection.HashSet<TriggerKey>(result);
            }
        }
Esempio n. 28
0
        public async Task Test(IScheduler scheduler, bool clearJobs, bool scheduleJobs)
        {
            try
            {
                if (clearJobs)
                {
                    await scheduler.Clear();
                }

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

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

                    Assert.IsNull(t);

                    AnnualCalendar cal = new AnnualCalendar();
                    await 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));
                    await scheduler.ScheduleJob(jd, calendarsTrigger);

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

                    await scheduler.AddCalendar("baseCalendar", new BaseCalendar(), false, true);

                    await scheduler.AddCalendar("cronCalendar", cronCalendar, false, true);

                    await scheduler.AddCalendar("dailyCalendar", new DailyCalendar(DateTime.Now.Date, DateTime.Now.AddMinutes(1)), false, true);

                    await scheduler.AddCalendar("holidayCalendar", holidayCalendar, false, true);

                    await scheduler.AddCalendar("monthlyCalendar", new MonthlyCalendar(), false, true);

                    await scheduler.AddCalendar("weeklyCalendar", new WeeklyCalendar(), false, true);

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

                    await 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;
                    await scheduler.AddJob(lonelyJob, false);

                    await 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);
                    await scheduler.ScheduleJob(job, trigger);

                    // check that trigger was stored
                    ITrigger persisted = await 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);
                    await 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);
                    await 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);
                    await 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));
                    await 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);

                    await 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;

                    var timeZone1 = TimeZoneUtil.FindTimeZoneById("Central European Standard Time");
                    var timeZone2 = TimeZoneUtil.FindTimeZoneById("Mountain Standard Time");

                    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);
                    nt.TimeZone     = timeZone1;

                    await scheduler.ScheduleJob(job, nt);

                    var loadedNt = (IDailyTimeIntervalTrigger)await scheduler.GetTrigger(nt.Key);

                    Assert.That(loadedNt.TimeZone.Id, Is.EqualTo(timeZone1.Id));

                    nt.TimeZone = timeZone2;
                    await scheduler.RescheduleJob(nt.Key, nt);

                    loadedNt = (IDailyTimeIntervalTrigger)await scheduler.GetTrigger(nt.Key);

                    Assert.That(loadedNt.TimeZone.Id, Is.EqualTo(timeZone2.Id));

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

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

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

                    await scheduler.UnscheduleJob(nt2.Key);

                    await scheduler.ScheduleJob(nt2);

                    var triggerFromDb = (IDailyTimeIntervalTrigger)await 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;

                    await scheduler.ScheduleJob(intervalTrigger);

#if CUSTOM_TIME_ZONES
                    // custom time zone
                    const string CustomTimeZoneId = "Custom TimeZone";
                    var          webTimezone      = TimeZoneInfo.CreateCustomTimeZone(
                        CustomTimeZoneId,
                        TimeSpan.FromMinutes(22),
                        null,
                        null);

                    TimeZoneUtil.CustomResolver = id =>
                    {
                        if (id == CustomTimeZoneId)
                        {
                            return(webTimezone);
                        }
                        return(null);
                    };

                    var customTimeZoneTrigger = TriggerBuilder.Create()
                                                .WithIdentity("customTimeZoneTrigger")
                                                .WithCronSchedule("0/5 * * * * ?", x => x.InTimeZone(webTimezone))
                                                .StartNow()
                                                .ForJob(job)
                                                .Build();

                    await scheduler.ScheduleJob(customTimeZoneTrigger);

                    var loadedCustomTimeZoneTrigger = (ICronTrigger)await scheduler.GetTrigger(customTimeZoneTrigger.Key);

                    Assert.That(loadedCustomTimeZoneTrigger.TimeZone.BaseUtcOffset, Is.EqualTo(TimeSpan.FromMinutes(22)));
#endif
                    // bulk operations
                    var        info     = new Dictionary <IJobDetail, IReadOnlyCollection <ITrigger> >();
                    IJobDetail detail   = new JobDetailImpl("job_" + count, schedId, typeof(SimpleRecoveryJob));
                    ITrigger   simple   = new SimpleTriggerImpl("trig_" + count, schedId, 20, TimeSpan.FromMilliseconds(4500));
                    var        triggers = new List <ITrigger>();
                    triggers.Add(simple);
                    info[detail] = triggers;

                    await scheduler.ScheduleJobs(info, true);

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

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

                    await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEndsWith("a").DeepClone());

                    await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupStartsWith("a").DeepClone());

                    await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals("a").DeepClone());

                    await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupContains("a").DeepClone());

                    await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEndsWith("a").DeepClone());

                    await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupStartsWith("a").DeepClone());

                    await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals("a").DeepClone());

                    await scheduler.Start();

                    await Task.Delay(TimeSpan.FromSeconds(3));

                    await scheduler.PauseAll();

                    await scheduler.ResumeAll();

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

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

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

                    await Task.Delay(TimeSpan.FromSeconds(1));

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

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

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

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

                    var pausedTriggerGroups = await scheduler.GetPausedTriggerGroups();

                    Assert.AreEqual(1, pausedTriggerGroups.Count);

                    await Task.Delay(TimeSpan.FromSeconds(3));

                    await 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"));

                    var genericjobKey = new JobKey("genericJob", "genericGroup");
                    GenericJobType.Reset();
                    var genericJob = JobBuilder.Create <GenericJobType>()
                                     .WithIdentity(genericjobKey)
                                     .StoreDurably()
                                     .Build();

                    await scheduler.AddJob(genericJob, false);

                    genericJob = await scheduler.GetJobDetail(genericjobKey);

                    Assert.That(genericJob, Is.Not.Null);
                    await scheduler.TriggerJob(genericjobKey);

                    GenericJobType.WaitForTrigger(TimeSpan.FromSeconds(20));

                    Assert.That(GenericJobType.TriggeredCount, Is.EqualTo(1));
                    await scheduler.Standby();

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

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

                    await scheduler.DeleteCalendar("cronCalendar");

                    await scheduler.DeleteCalendar("holidayCalendar");

                    await scheduler.DeleteJob(new JobKey("lonelyJob", "lonelyGroup"));

                    await scheduler.DeleteJob(job.Key);

                    await scheduler.GetJobGroupNames();

                    await scheduler.GetCalendarNames();

                    await scheduler.GetTriggerGroupNames();

                    await TestMatchers(scheduler);
                }
            }
            finally
            {
                await scheduler.Shutdown(false);
            }
        }
Esempio n. 29
0
        /// <summary>
        /// Resume (un-pause) all of the <see cref="ITrigger" />s in the
        /// matching groups.
        /// <para>
        /// If any <see cref="ITrigger" /> missed one or more fire-times, then the
        /// <see cref="ITrigger" />'s misfire instruction will be applied.
        /// </para>
        /// </summary>
        public virtual void ResumeTriggers(GroupMatcher<TriggerKey> matcher)
        {
            ValidateState();

            if (matcher == null)
            {
                matcher = GroupMatcher<TriggerKey>.GroupEquals(SchedulerConstants.DefaultGroup);
            }

            ICollection<string> pausedGroups = resources.JobStore.ResumeTriggers(matcher);
            NotifySchedulerThread(null);
            foreach (string pausedGroup in pausedGroups)
            {
                NotifySchedulerListenersResumedTriggers(pausedGroup);
            }
        }
Esempio n. 30
0
        private async Task TestMatchers(IScheduler scheduler)
        {
            await scheduler.Clear();

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

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

            job = JobBuilder.Create <NoOpJob>().WithIdentity("job1", "xxxyyyzzz").StoreDurably().Build();
            await scheduler.AddJob(job, true);

            schedule = SimpleScheduleBuilder.Create();
            trigger  = TriggerBuilder.Create().WithIdentity("trig1", "xxxyyyzzz").WithSchedule(schedule).ForJob(job).Build();
            await scheduler.ScheduleJob(trigger);

            job = JobBuilder.Create <NoOpJob>().WithIdentity("job2", "xxxyyyzzz").StoreDurably().Build();
            await scheduler.AddJob(job, true);

            schedule = SimpleScheduleBuilder.Create();
            trigger  = TriggerBuilder.Create().WithIdentity("trig2", "xxxyyyzzz").WithSchedule(schedule).ForJob(job).Build();
            await scheduler.ScheduleJob(trigger);

            var jkeys = await scheduler.GetJobKeys(GroupMatcher <JobKey> .AnyGroup());

            Assert.That(jkeys.Count, Is.EqualTo(3), "Wrong number of jobs found by anything matcher");

            jkeys = await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals("xxxyyyzzz"));

            Assert.That(jkeys.Count, Is.EqualTo(2), "Wrong number of jobs found by equals matcher");

            jkeys = await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals("aaabbbccc"));

            Assert.That(jkeys.Count, Is.EqualTo(1), "Wrong number of jobs found by equals matcher");

            jkeys = await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupStartsWith("aa"));

            Assert.That(jkeys.Count, Is.EqualTo(1), "Wrong number of jobs found by starts with matcher");

            jkeys = await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupStartsWith("xx"));

            Assert.That(jkeys.Count, Is.EqualTo(2), "Wrong number of jobs found by starts with matcher");

            jkeys = await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEndsWith("cc"));

            Assert.That(jkeys.Count, Is.EqualTo(1), "Wrong number of jobs found by ends with matcher");

            jkeys = await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEndsWith("zzz"));

            Assert.That(jkeys.Count, Is.EqualTo(2), "Wrong number of jobs found by ends with matcher");

            jkeys = await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupContains("bc"));

            Assert.That(jkeys.Count, Is.EqualTo(1), "Wrong number of jobs found by contains with matcher");

            jkeys = await scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupContains("yz"));

            Assert.That(jkeys.Count, Is.EqualTo(2), "Wrong number of jobs found by contains with matcher");

            var tkeys = await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .AnyGroup());

            Assert.That(tkeys.Count, Is.EqualTo(3), "Wrong number of triggers found by anything matcher");

            tkeys = await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals("xxxyyyzzz"));

            Assert.That(tkeys.Count, Is.EqualTo(2), "Wrong number of triggers found by equals matcher");

            tkeys = await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals("aaabbbccc"));

            Assert.That(tkeys.Count, Is.EqualTo(1), "Wrong number of triggers found by equals matcher");

            tkeys = await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupStartsWith("aa"));

            Assert.That(tkeys.Count, Is.EqualTo(1), "Wrong number of triggers found by starts with matcher");

            tkeys = await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupStartsWith("xx"));

            Assert.That(tkeys.Count, Is.EqualTo(2), "Wrong number of triggers found by starts with matcher");

            tkeys = await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEndsWith("cc"));

            Assert.That(tkeys.Count, Is.EqualTo(1), "Wrong number of triggers found by ends with matcher");

            tkeys = await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEndsWith("zzz"));

            Assert.That(tkeys.Count, Is.EqualTo(2), "Wrong number of triggers found by ends with matcher");

            tkeys = await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupContains("bc"));

            Assert.That(tkeys.Count, Is.EqualTo(1), "Wrong number of triggers found by contains with matcher");

            tkeys = await scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupContains("yz"));

            Assert.That(tkeys.Count, Is.EqualTo(2), "Wrong number of triggers found by contains with matcher");
        }
 /// <summary>
 /// Resume (un-pause) all of the <see cref="T:Quartz.ITrigger"/>s in matching groups.
 /// </summary>
 /// <remarks>
 /// If any <see cref="T:Quartz.ITrigger"/> missed one or more fire-times, then the
 ///             <see cref="T:Quartz.ITrigger"/>'s misfire instruction will be applied.
 /// </remarks>
 /// <seealso cref="M:Quartz.IScheduler.PauseTriggers(Quartz.Impl.Matchers.GroupMatcher{Quartz.TriggerKey})"/>
 public void ResumeTriggers(GroupMatcher<TriggerKey> matcher)
 {
     _scheduler.ResumeTriggers(matcher);
 }
        public virtual async Task StartAsync(CancellationToken cancellationToken)
        {
            var props = new NameValueCollection
            {
                { "quartz.serializer.type", "binary" },
            };

            if (!string.IsNullOrEmpty(_globalSettings.SqlServer.JobSchedulerConnectionString))
            {
                // Ensure each project has a unique instanceName
                props.Add("quartz.scheduler.instanceName", GetType().FullName);
                props.Add("quartz.scheduler.instanceId", "AUTO");
                props.Add("quartz.jobStore.type", "Quartz.Impl.AdoJobStore.JobStoreTX");
                props.Add("quartz.jobStore.driverDelegateType", "Quartz.Impl.AdoJobStore.SqlServerDelegate");
                props.Add("quartz.jobStore.useProperties", "true");
                props.Add("quartz.jobStore.dataSource", "default");
                props.Add("quartz.jobStore.tablePrefix", "QRTZ_");
                props.Add("quartz.jobStore.clustered", "true");
                props.Add("quartz.dataSource.default.provider", "SqlServer");
                props.Add("quartz.dataSource.default.connectionString", _globalSettings.SqlServer.JobSchedulerConnectionString);
            }

            var factory = new StdSchedulerFactory(props);

            _scheduler = await factory.GetScheduler(cancellationToken);

            _scheduler.JobFactory = new JobFactory(_serviceProvider);
            _scheduler.ListenerManager.AddJobListener(new JobListener(_listenerLogger),
                                                      GroupMatcher <JobKey> .AnyGroup());
            await _scheduler.Start(cancellationToken);

            if (Jobs != null)
            {
                foreach (var(job, trigger) in Jobs)
                {
                    var dupeT = await _scheduler.GetTrigger(trigger.Key);

                    if (dupeT != null)
                    {
                        await _scheduler.RescheduleJob(trigger.Key, trigger);
                    }

                    var jobDetail = JobBuilder.Create(job)
                                    .WithIdentity(job.FullName)
                                    .Build();

                    var dupeJ = await _scheduler.GetJobDetail(jobDetail.Key);

                    if (dupeJ != null)
                    {
                        await _scheduler.DeleteJob(jobDetail.Key);
                    }

                    await _scheduler.ScheduleJob(jobDetail, trigger);
                }
            }

            // Delete old Jobs and Triggers
            var existingJobKeys = await _scheduler.GetJobKeys(GroupMatcher <JobKey> .AnyGroup());

            var jobKeys = Jobs.Select(j =>
            {
                var job = j.Item1;
                return(JobBuilder.Create(job)
                       .WithIdentity(job.FullName)
                       .Build().Key);
            });

            foreach (var key in existingJobKeys)
            {
                if (jobKeys.Contains(key))
                {
                    continue;
                }

                _logger.LogInformation($"Deleting old job with key {key}");
                await _scheduler.DeleteJob(key);
            }

            var existingTriggerKeys = await _scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .AnyGroup());

            var triggerKeys = Jobs.Select(j => j.Item2.Key);

            foreach (var key in existingTriggerKeys)
            {
                if (triggerKeys.Contains(key))
                {
                    continue;
                }

                _logger.LogInformation($"Unscheduling old trigger with key {key}");
                await _scheduler.UnscheduleJob(key);
            }
        }
Esempio n. 33
0
 public Collection.ISet<IJobDetail> GetScheduledJobDetails(GroupMatcher<JobKey> matcher)
 {
     // no locks necessary for read...
     return (Collection.ISet<IJobDetail>)ExecuteWithoutLock(conn => GetScheduledJobDetails(conn, matcher));
 }
Esempio n. 34
0
        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            // make sure you configure logging and open telemetry before quartz services

            services.AddLogging(loggingBuilder =>
            {
                loggingBuilder.ClearProviders();
                loggingBuilder.AddSerilog(dispose: true);
            });

            services.AddOpenTelemetryTracing(builder =>
            {
                builder
                .AddQuartzInstrumentation()
                .AddZipkinExporter(o =>
                {
                    o.Endpoint    = new Uri("http://localhost:9411/api/v2/spans");
                    o.ServiceName = "Quartz.Examples.AspNetCore";
                })
                .AddJaegerExporter(o =>
                {
                    o.ServiceName = "Quartz.Examples.AspNetCore";

                    // these are the defaults
                    o.AgentHost = "localhost";
                    o.AgentPort = 6831;
                });
            });

            services.AddRazorPages();

            // 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";

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

                // this is default configuration if you don't alter it
                q.UseMicrosoftDependencyInjectionJobFactory(options =>
                {
                    // set to true if you want to inject scoped services like Entity Framework's DbContext
                    options.CreateScope = false;
                });

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

                // quickest way to create a job with single trigger is to use ScheduleJob
                q.ScheduleJob <ExampleJob>(trigger => trigger
                                           .WithIdentity("Combined Configuration Trigger")
                                           .StartAt(DateBuilder.EvenSecondDate(DateTimeOffset.UtcNow.AddSeconds(7)))
                                           .WithDailyTimeIntervalSchedule(x => x.WithInterval(10, IntervalUnit.Second))
                                           .WithDescription("my awesome trigger configured for a job with single call")
                                           );

                // 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")
                                      );

                // here's a known job for triggers
                var jobKey = new JobKey("awesome job", "awesome group");
                q.AddJob <ExampleJob>(jobKey, j => j
                                      .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")
                             );

                // auto-interrupt long-running job
                q.UseJobAutoInterrupt(options =>
                {
                    // this is the default
                    options.DefaultMaxRunTime = TimeSpan.FromMinutes(5);
                });
                q.ScheduleJob <SlowJob>(
                    triggerConfigurator => triggerConfigurator
                    .WithIdentity("slowJobTrigger")
                    .StartNow()
                    .WithSimpleSchedule(x => x.WithIntervalInSeconds(5).RepeatForever()),
                    jobConfigurator => jobConfigurator
                    .WithIdentity("slowJob")
                    .UsingJobData(JobInterruptMonitorPlugin.JobDataMapKeyAutoInterruptable, true)
                    // allow only five seconds for this job, overriding default configuration
                    .UsingJobData(JobInterruptMonitorPlugin.JobDataMapKeyMaxRunTime, TimeSpan.FromSeconds(5).TotalMilliseconds.ToString(CultureInfo.InvariantCulture)));

                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)
                             );

                // also add XML configuration and poll it for changes
                q.UseXmlSchedulingConfiguration(x =>
                {
                    x.Files                 = new[] { "~/quartz_jobs.config" };
                    x.ScanInterval          = TimeSpan.FromMinutes(1);
                    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);
                 *  });
                 * });
                 */
            });

            // 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));
                }
            });


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

            services
            .AddHealthChecksUI()
            .AddInMemoryStorage();
        }
Esempio n. 35
0
        /// <summary>
        /// Pause all of the <see cref="T:Quartz.ITrigger"/>s in the
        ///             given group.
        /// </summary>
        /// <remarks>
        /// The JobStore should "remember" that the group is paused, and impose the
        ///             pause on any new triggers that are added to the group while the group is
        ///             paused.
        /// </remarks>
        public override IList<string> PauseTriggers(GroupMatcher<TriggerKey> matcher)
        {
            var pausedTriggerGroups = new List<string>();
            if (matcher.CompareWithOperator.Equals(StringOperator.Equality))
            {
                var triggerGroupSetKey = this.RedisJobStoreSchema.TriggerGroupSetKey(matcher.CompareToValue);
                var addResult = this.Db.SetAdd(this.RedisJobStoreSchema.PausedTriggerGroupsSetKey(), triggerGroupSetKey);

                if (addResult)
                {
                    foreach (var triggerHashKey in this.Db.SetMembers(triggerGroupSetKey))
                    {
                        this.PauseTrigger(this.RedisJobStoreSchema.TriggerKey(triggerHashKey));
                    }

                    pausedTriggerGroups.Add(this.RedisJobStoreSchema.TriggerGroup(triggerGroupSetKey));
                }
            }
            else
            {
                var allTriggerGroups = this.Db.SetMembers(this.RedisJobStoreSchema.TriggerGroupsSetKey());

                var triggerGroupsResult = allTriggerGroups.Where(groupHashKey => matcher.CompareWithOperator.Evaluate(this.RedisJobStoreSchema.TriggerGroup(groupHashKey), matcher.CompareToValue)).ToDictionary<RedisValue, string, RedisValue[]>(groupHashKey => groupHashKey, groupHashKey => Db.SetMembers(groupHashKey.ToString()));

                foreach (var triggerGroup in triggerGroupsResult)
                {
                    var addResult = this.Db.SetAdd(this.RedisJobStoreSchema.PausedTriggerGroupsSetKey(), triggerGroup.Key);

                    if (addResult)
                    {
                        foreach (var triggerHashKey in triggerGroup.Value)
                        {
                            this.PauseTrigger(this.RedisJobStoreSchema.TriggerKey(triggerHashKey));
                        }
                        pausedTriggerGroups.Add(this.RedisJobStoreSchema.TriggerGroup(triggerGroup.Key));
                    }
                }

            }

            return pausedTriggerGroups;
        }
Esempio n. 36
0
        /// <summary>
        /// Updates the scheduled jobs.
        /// </summary>
        /// <param name="context">The context.</param>
        private void UpdateScheduledJobs(IJobExecutionContext context)
        {
            var scheduler           = context.Scheduler;
            int jobsDeleted         = 0;
            int jobsScheduleUpdated = 0;

            var rockContext = new Rock.Data.RockContext();
            ServiceJobService    jobService          = new ServiceJobService(rockContext);
            List <ServiceJob>    activeJobList       = jobService.GetActiveJobs().ToList();
            List <Quartz.JobKey> scheduledQuartzJobs = scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupStartsWith(string.Empty)).ToList();

            // delete any jobs that are no longer exist (are are not set to active) in the database
            var quartsJobsToDelete = scheduledQuartzJobs.Where(a => !activeJobList.Any(j => j.Guid.Equals(a.Name.AsGuid())));

            foreach (JobKey jobKey in quartsJobsToDelete)
            {
                scheduler.DeleteJob(jobKey);
                jobsDeleted++;
            }

            // add any jobs that are not yet scheduled
            var newActiveJobs = activeJobList.Where(a => !scheduledQuartzJobs.Any(q => q.Name.AsGuid().Equals(a.Guid)));

            foreach (Rock.Model.ServiceJob job in newActiveJobs)
            {
                const string errorSchedulingStatus = "Error scheduling Job";
                try
                {
                    IJobDetail jobDetail  = jobService.BuildQuartzJob(job);
                    ITrigger   jobTrigger = jobService.BuildQuartzTrigger(job);

                    // Schedule the job (unless the cron expression is set to never run for an on-demand job like rebuild streaks)
                    if (job.CronExpression != ServiceJob.NeverScheduledCronExpression)
                    {
                        scheduler.ScheduleJob(jobDetail, jobTrigger);
                        jobsScheduleUpdated++;
                    }

                    if (job.LastStatus == errorSchedulingStatus)
                    {
                        job.LastStatusMessage = string.Empty;
                        job.LastStatus        = string.Empty;
                        rockContext.SaveChanges();
                    }
                }
                catch (Exception ex)
                {
                    ExceptionLogService.LogException(ex, null);

                    // create a friendly error message
                    string message = string.Format("Error scheduling the job: {0}.\n\n{2}", job.Name, job.Assembly, ex.Message);
                    job.LastStatusMessage = message;
                    job.LastStatus        = errorSchedulingStatus;
                }
            }

            rockContext.SaveChanges();

            // reload the jobs in case any where added/removed
            scheduledQuartzJobs = scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupStartsWith(string.Empty)).ToList();

            // update schedule if the schedule has changed
            foreach (var jobKey in scheduledQuartzJobs)
            {
                var jobCronTrigger = scheduler.GetTriggersOfJob(jobKey).OfType <ICronTrigger>().FirstOrDefault();
                if (jobCronTrigger != null)
                {
                    var activeJob = activeJobList.FirstOrDefault(a => a.Guid.Equals(jobKey.Name.AsGuid()));
                    if (activeJob != null)
                    {
                        bool rescheduleJob = false;

                        // fix up the schedule if it has changed
                        if (activeJob.CronExpression != jobCronTrigger.CronExpressionString)
                        {
                            rescheduleJob = true;
                        }

                        // update the job detail if it has changed
                        var scheduledJobDetail = scheduler.GetJobDetail(jobKey);
                        var jobDetail          = jobService.BuildQuartzJob(activeJob);

                        if (scheduledJobDetail != null && jobDetail != null)
                        {
                            if (scheduledJobDetail.JobType != jobDetail.JobType)
                            {
                                rescheduleJob = true;
                            }

                            if (scheduledJobDetail.JobDataMap.ToJson() != jobDetail.JobDataMap.ToJson())
                            {
                                rescheduleJob = true;
                            }
                        }

                        if (rescheduleJob)
                        {
                            const string errorReschedulingStatus = "Error re-scheduling Job";
                            try
                            {
                                ITrigger newJobTrigger       = jobService.BuildQuartzTrigger(activeJob);
                                bool     deletedSuccessfully = scheduler.DeleteJob(jobKey);
                                scheduler.ScheduleJob(jobDetail, newJobTrigger);
                                jobsScheduleUpdated++;

                                if (activeJob.LastStatus == errorReschedulingStatus)
                                {
                                    activeJob.LastStatusMessage = string.Empty;
                                    activeJob.LastStatus        = string.Empty;
                                    rockContext.SaveChanges();
                                }
                            }
                            catch (Exception ex)
                            {
                                ExceptionLogService.LogException(ex, null);

                                // create a friendly error message
                                string message = string.Format("Error re-scheduling the job: {0}.\n\n{2}", activeJob.Name, activeJob.Assembly, ex.Message);
                                activeJob.LastStatusMessage = message;
                                activeJob.LastStatus        = errorReschedulingStatus;
                            }
                        }
                    }
                }
            }

            context.Result = string.Empty;

            if (jobsDeleted > 0)
            {
                context.Result += string.Format("Deleted {0} job schedule(s)", jobsDeleted);
            }

            if (jobsScheduleUpdated > 0)
            {
                context.Result += (string.IsNullOrEmpty(context.Result as string) ? "" : " and ") + string.Format("Updated {0} schedule(s)", jobsScheduleUpdated);
            }
        }
Esempio n. 37
0
        /// <summary>
        /// Resume (un-pause) all of the <see cref="T:Quartz.ITrigger"/>s
        ///             in the given group.
        /// <para>
        /// If any <see cref="T:Quartz.ITrigger"/> missed one or more fire-times, then the
        ///             <see cref="T:Quartz.ITrigger"/>'s misfire instruction will be applied.
        /// </para>
        /// </summary>
        public override IList<string> ResumeTriggers(GroupMatcher<TriggerKey> matcher)
        {
            var resumedTriggerGroups = new List<string>();

            if (matcher.CompareWithOperator.Equals(StringOperator.Equality))
            {
                var triggerGroupSetKey =
                    RedisJobStoreSchema.TriggerGroupSetKey(matcher.CompareToValue);

                Db.SetRemove(RedisJobStoreSchema.PausedTriggerGroupsSetKey(), triggerGroupSetKey);

                var triggerHashKeysResult = Db.SetMembers(triggerGroupSetKey);

                foreach (var triggerHashKey in triggerHashKeysResult)
                {
                    var trigger = RetrieveTrigger(RedisJobStoreSchema.TriggerKey(triggerHashKey));

                    ResumeTrigger(trigger.Key);

                    if(!resumedTriggerGroups.Contains(trigger.Key.Group)) {
                        resumedTriggerGroups.Add(trigger.Key.Group);
                    }
                }
            }
            else
            {
                foreach (var triggerGroupSetKy in Db.SetMembersAsync(RedisJobStoreSchema.TriggerGroupsSetKey()).Result)
                {
                    if (matcher.CompareWithOperator.Evaluate(RedisJobStoreSchema.TriggerGroup(triggerGroupSetKy),
                                                            matcher.CompareToValue))
                    {
                        resumedTriggerGroups.AddRange(ResumeTriggers(GroupMatcher<TriggerKey>.GroupEquals(RedisJobStoreSchema.TriggerGroup(triggerGroupSetKy))));
                    }
                }
            }

            return resumedTriggerGroups;
        }
Esempio n. 38
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. 39
0
        /// <summary>
        /// Get the names of all of the <see cref="T:Quartz.IJob"/> s that
        ///             have the given group name.
        /// <para>
        /// If there are no jobs in the given group name, the result should be a
        ///             zero-length array (not <see langword="null"/>).
        /// </para>
        /// </summary>
        /// <param name="matcher"/>
        /// <returns/>
        public override global::Quartz.Collection.ISet<JobKey> JobKeys(GroupMatcher<JobKey> matcher)
        {
            var jobKeys = new global::Quartz.Collection.HashSet<JobKey>();

            if (matcher.CompareWithOperator.Equals(StringOperator.Equality))
            {
                var jobGroupSetKey = this.RedisJobStoreSchema.JobGroupSetKey(matcher.CompareToValue);
                var jobHashKeys = this.Db.SetMembers(jobGroupSetKey);
                if (jobHashKeys != null)
                {
                    foreach (var jobHashKey in jobHashKeys)
                    {
                        jobKeys.Add(this.RedisJobStoreSchema.JobKey(jobHashKey));
                    }
                }
            }
            else
            {
                var jobGroupSets = this.Db.SetMembers(this.RedisJobStoreSchema.JobGroupsSetKey());

                var jobGroupsResult = (from groupSet in jobGroupSets where matcher.CompareWithOperator.Evaluate(this.RedisJobStoreSchema.JobGroup(groupSet), matcher.CompareToValue) select Db.SetMembers(groupSet.ToString())).ToList();

                foreach (var jobHashKey in jobGroupsResult.Where(jobHashKeys => jobHashKeys != null).SelectMany(jobHashKeys => jobHashKeys))
                {
                    jobKeys.Add(this.RedisJobStoreSchema.JobKey(jobHashKey));
                }
            }

            return jobKeys;
        }
Esempio n. 40
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();
                }
            }
        }
Esempio n. 41
0
        /// <summary>
        /// Resume (un-pause) all of the <see cref="ITrigger" />s
        /// in the given group.
        /// <para>
        /// If any <see cref="ITrigger" /> missed one or more fire-times, then the
        /// <see cref="ITrigger" />'s misfire instruction will be applied.
        /// </para>
        /// </summary>
        public virtual IList<string> ResumeTriggers(ConnectionAndTransactionHolder conn, GroupMatcher<TriggerKey> matcher)
        {
            try
            {
                Delegate.DeletePausedTriggerGroup(conn, matcher);
                Collection.HashSet<string> groups = new Collection.HashSet<string>();

                Collection.ISet<TriggerKey> keys = Delegate.SelectTriggersInGroup(conn, matcher);

                foreach (TriggerKey key in keys)
                {
                    ResumeTrigger(conn, key);
                    groups.Add(key.Group);
                }

                return new List<string>(groups);

                // TODO: find an efficient way to resume triggers (better than the
                // above)... logic below is broken because of
                // findTriggersToBeBlocked()
                /*
                * int res =
                * getDelegate().UpdateTriggerGroupStateFromOtherState(conn,
                * groupName, StateWaiting, StatePaused);
                *
                * if(res > 0) {
                *
                * long misfireTime = System.currentTimeMillis();
                * if(getMisfireThreshold() > 0) misfireTime -=
                * getMisfireThreshold();
                *
                * Key[] misfires =
                * getDelegate().SelectMisfiredTriggersInGroupInState(conn,
                * groupName, StateWaiting, misfireTime);
                *
                * List blockedTriggers = findTriggersToBeBlocked(conn,
                * groupName);
                *
                * Iterator itr = blockedTriggers.iterator(); while(itr.hasNext()) {
                * Key key = (Key)itr.next();
                * getDelegate().UpdateTriggerState(conn, key.getName(),
                * key.getGroup(), StateBlocked); }
                *
                * for(int i=0; i < misfires.length; i++) {               String
                * newState = StateWaiting;
                * if(blockedTriggers.contains(misfires[i])) newState =
                * StateBlocked; UpdateMisfiredTrigger(conn,
                * misfires[i].getName(), misfires[i].getGroup(), newState, true); } }
                */
            }
            catch (Exception e)
            {
                throw new JobPersistenceException("Couldn't pause trigger group '" + matcher + "': " + e.Message, e);
            }
        }
Esempio n. 42
0
 /// <summary>
 /// 获取所有作业键集合
 /// </summary>
 /// <param name="key"></param>
 /// <returns></returns>
 public static global::Quartz.Collection.ISet <JobKey> GetJobKeys(GroupMatcher <JobKey> key)
 {
     return(Scheduler.GetJobKeys(key));
 }
Esempio n. 43
0
        protected virtual Collection.ISet<TriggerKey> GetTriggerNames(ConnectionAndTransactionHolder conn, GroupMatcher<TriggerKey> matcher)
        {
            Collection.ISet<TriggerKey> triggerNames;

            try
            {
                triggerNames = Delegate.SelectTriggersInGroup(conn, matcher);
            }
            catch (Exception e)
            {
                throw new JobPersistenceException("Couldn't obtain trigger names: " + e.Message, e);
            }

            return triggerNames;
        }
Esempio n. 44
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: {}", 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);
                }
            }
        }
Esempio n. 45
0
        /// <summary>
        /// Pause all of the <see cref="IJob" />s in the given
        /// group - by pausing all of their <see cref="ITrigger" />s.
        /// </summary>
        /// <seealso cref="ResumeJobs" />
        public virtual IList<string> PauseJobs(GroupMatcher<JobKey> matcher)
        {
            return (IList<string>)ExecuteInLock(LockTriggerAccess, conn =>
                {
                    Collection.ISet<string> groupNames = new Collection.HashSet<string>();
                    Collection.ISet<JobKey> jobNames = GetJobNames(conn, matcher);

                    foreach (JobKey jobKey in jobNames)
                    {
                        IList<IOperableTrigger> triggers = GetTriggersForJob(conn, jobKey);
                        foreach (IOperableTrigger trigger in triggers)
                        {
                            PauseTrigger(conn, trigger.Key);
                        }
                        groupNames.Add(jobKey.Group);
                    }

                    return new List<string>(groupNames);
                });
        }
Esempio n. 46
0
        static void TestQuarz()
        {
            #region 测试验证
            //  Common.Config.PropertiesParser.ReadFromFileResource("test.txt");
            // Run();
            //    Set();
            //     Console.Read();
            #endregion


            //  Quartzlog.LogManager.Adapter=new

            IScheduler scheduler = StdSchedulerFactory.GetDefaultScheduler();  //调度者


            WeeklyCalendar calendar = new WeeklyCalendar();
            calendar.SetDayExcluded(DayOfWeek.Thursday, true);      //设置每周五不能执行;


            HolidayCalendar daycalendar = new HolidayCalendar();
            daycalendar.AddExcludedDate(DateTime.Now);             //只取日   DateTime.Now.Day


            MonthlyCalendar monthcalendar = new MonthlyCalendar();
            monthcalendar.SetDayExcluded(16, true);                //只取月   DateTime.Now.Month

            AnnualCalendar annualCalendar = new AnnualCalendar();
            annualCalendar.SetDayExcluded(DateTime.Now, true);               //只取年月日   DateTime.Now.Year

            CronCalendar cronCalendar = new CronCalendar("* * * 17 6 ?");    //6月17 不执行

            scheduler.AddCalendar("mycalendar", calendar, true, true);       //设置每周五不能执行;
            scheduler.AddCalendar("mycalendar", daycalendar, true, true);    //某一天不执行
            scheduler.AddCalendar("mycalendar", monthcalendar, true, true);  //某每月某一天不执行
            scheduler.AddCalendar("mycalendar", annualCalendar, true, true); //每年某一月某一日不执行

            scheduler.AddCalendar("mycalendar", cronCalendar, true, true);   //每年某一月某一日不执行



            scheduler.Start();
            var job = JobBuilder.Create <lxshJob>().WithDescription("Job")
                      .WithIdentity("lxshJob", "lxshGroup")
                      .UsingJobData("userName", "Joblxsh")
                      .Build();                             //任务

            var job1 = JobBuilder.Create <lxshJob>().WithDescription("Job")
                       .WithIdentity("lxshJob", "lxshGroup")
                       .UsingJobData("userName", "Joblxsh1")
                       .Build();                        //任务

            var trigger = TriggerBuilder.Create().StartNow()
                          .WithDescription("trigger")
                          .WithSimpleSchedule(x => x.WithIntervalInSeconds(1).WithRepeatCount(10))
                          // .WithCalendarIntervalSchedule(x=>x.WithIntervalInYears(1))
                          //   .WithSimpleSchedule(x => x.WithIntervalInSeconds(1).RepeatForever())
                          .WithDailyTimeIntervalSchedule(x =>
            {
                x.OnDaysOfTheWeek(new DayOfWeek[2] {
                    DayOfWeek.Tuesday, DayOfWeek.Friday
                });                                                   //每周二或者周五执行
                x.OnEveryDay()
                .StartingDailyAt(TimeOfDay.HourAndMinuteOfDay(8, 00)) //   八点开始
                .EndingDailyAt(TimeOfDay.HourAndMinuteOfDay(18, 00))  //    十八点开始
                .WithIntervalInSeconds(1);                            // 每1s执行一次
            })
                                                                      // .ModifiedByCalendar("mycalendar")
                          .Build();
            //秒分时日月
            var trigger1 = TriggerBuilder.Create().WithCronSchedule("* * * * * ?").Build();       //1秒执行一次
            var trigger2 = TriggerBuilder.Create().WithCronSchedule("0 * * * * ?").Build();       //1分钟执行一次
            var trigger3 = TriggerBuilder.Create().WithCronSchedule("0 0/30 8-20 * * ?").Build(); //30分钟检查一次 8-20点
            var trigger4 = TriggerBuilder.Create().WithCronSchedule("* * * * * ?").Build();

            scheduler.ListenerManager.AddJobListener(new lxshJobLinstener(), GroupMatcher <JobKey> .AnyGroup());

            scheduler.ScheduleJob(job, trigger);  //开始调度任务
                                                  //    scheduler.GetTriggersOfJob(new JobKey("lxshJob")).Select(x =>x.Key.ToString() );
            Console.Read();

            #region WithCronSchedule
            //           --------------------------------------
            //   0 0 12 * * ? 每天12点触发

            //   0 15 10 ? **每天10点15分触发

            //   0 15 10 * * ? 每天10点15分触发

            //   0 15 10 * * ? *每天10点15分触发

            //   0 15 10 * * ? 2005 2005年每天10点15分触发

            // 0 * 14 * * ? 每天下午的 2点到2点59分每分触发

            // 0 0 / 5 14 * * ? 每天下午的 2点到2点59分(整点开始,每隔5分触发)

            // 0 0 / 5 14,18 * * ? 每天下午的 2点到2点59分(整点开始,每隔5分触发) 每天下午的 18点到18点59分(整点开始,每隔5分触发)

            // 0 0 - 5 14 * * ? 每天下午的 2点到2点05分每分触发

            // 0 10,44 14 ? 3 WED 3月分每周三下午的 2点10分和2点44分触发

            // 0 15 10 ? *MON - FRI 从周一到周五每天上午的10点15分触发

            // 0 15 10 15 * ? 每月15号上午10点15分触发

            // 0 15 10 L * ? 每月最后一天的10点15分触发

            // 0 15 10 ? *6L 每月最后一周的星期五的10点15分触发

            // 0 15 10 ? *6L 2002 - 2005 从2002年到2005年每月最后一周的星期五的10点15分触发

            // 0 15 10 ? *6#3         每月的第三周的星期五开始触发
            //    0 0 12 1 / 5 * ? 每月的第一个中午开始每隔5天触发一次

            // 0 11 11 11 11 ? 每年的11月11号 11点11分触发(光棍节)
            //--------------------------------------


            #endregion
        }
Esempio n. 47
0
 /// <summary>
 /// Pause all of the <see cref="ITrigger" />s in the given group.
 /// </summary>
 /// <seealso cref="ResumeTriggers(Quartz.Impl.Matchers.GroupMatcher{Quartz.TriggerKey})" />
 public virtual Collection.ISet<string> PauseTriggers(GroupMatcher<TriggerKey> matcher)
 {
     return (Collection.ISet<string>)ExecuteInLock(LockTriggerAccess, conn => PauseTriggerGroup(conn, matcher));
 }
        public async Task StartAsync(CancellationToken cancellationToken)
        {
            this.scheduler = await this.schedulerFactory.GetScheduler();
            this.scheduler.JobFactory = this.jobFactory;
            this.scheduler.ListenerManager.AddTriggerListener(new CommonTriggerListener(), GroupMatcher<TriggerKey>.AnyGroup());
            await this.scheduler.Start();
            Log.Debug("QuartzHostedService.Scheduler started.");

            if (this.jobs == null || !this.jobs.Any())
            {
                Log.Warning("QuartzHostedService no jobs found.");
                return;
            }

            foreach (var job in this.jobs)
            {
                var jobDetail = job.GetJobDetail();
                if (jobDetail != null)
                {
                    await this.scheduler.AddJob(jobDetail, true);
                    Log.Debug(string.Format("Add job({0}) into the scheduler.", jobDetail.Key));

                    var triggers = job.GetTriggers();
                    if (triggers != null)
                    {
                        foreach (var trigger in triggers)
                        {
                            await this.scheduler.ScheduleJob(trigger);
                            Log.Debug(string.Format("Schedule the job({0}) with trigger({1})", trigger.JobKey, GetTriggerDesc(trigger)));
                        }
                    }
                }
            }
        }
Esempio n. 49
0
 /// <summary>
 /// Calls the equivalent method on the 'proxied' <see cref="QuartzScheduler" />.
 /// </summary>
 public virtual void PauseJobs(GroupMatcher<JobKey> matcher)
 {
     try
     {
         GetRemoteScheduler().PauseJobs(matcher);
     }
     catch (RemotingException re)
     {
         throw InvalidateHandleCreateException("Error communicating with remote scheduler.", re);
     }
 }
Esempio n. 50
0
 /// <summary>
 /// 根据组名开启作业
 /// </summary>
 /// <param name="groupName">组名</param>
 public static void ResumeJobGroup(string groupName)
 {
     Scheduler.ResumeJobs(GroupMatcher <JobKey> .GroupEquals(groupName));
 }
Esempio n. 51
0
        /// <summary>
        /// Resume (un-pause) all of the <see cref="IJobDetail" />s
        /// in the given group.
        /// <para>
        /// If any of the <see cref="IJob" /> s had <see cref="ITrigger" /> s that
        /// missed one or more fire-times, then the <see cref="ITrigger" />'s
        /// misfire instruction will be applied.
        /// </para>
        /// </summary>
        public virtual Collection.ISet<string> ResumeJobs(GroupMatcher<JobKey> matcher)
        {
            Collection.ISet<string> resumedGroups = new Collection.HashSet<string>();
            lock (lockObject)
            {
                Collection.ISet<JobKey> keys = GetJobKeys(matcher);

                foreach (string pausedJobGroup in this.PausedJobGroups.FindAllAs<string>())
                {
                    if (matcher.CompareWithOperator.Evaluate(pausedJobGroup, matcher.CompareToValue))
                    {
                        resumedGroups.Add(pausedJobGroup);
                    }
                }

                this.PausedTriggerGroups.Remove(
                        Query.All("_id", new BsonArray(resumedGroups)));

                foreach (JobKey key in keys)
                {
                    IList<IOperableTrigger> triggers = GetTriggersForJob(key);
                    foreach (IOperableTrigger trigger in triggers)
                    {
                        ResumeTrigger(trigger.Key);
                    }
                }
            }

            return resumedGroups;
        }
Esempio n. 52
0
 /// <summary>
 /// 根据触发器组名开启作业
 /// </summary>
 /// <param name="groupName">组名</param>
 public static void ResumeTriggerGroup(string groupName)
 {
     Scheduler.ResumeTriggers(GroupMatcher <TriggerKey> .GroupEquals(groupName));
 }
Esempio n. 53
0
        /// <summary>
        /// Get the names of all of the <see cref="IJob" /> s that
        /// match the given group matcher.
        /// </summary>
        public virtual Collection.ISet<JobKey> GetJobKeys(GroupMatcher<JobKey> matcher)
        {
            lock (lockObject)
            {
                var result = this.Jobs
                    .FindAs<IJobDetail>(
                        Query.EQ("Group", matcher.CompareToValue))
                    .Select(j => j.Key);

                return new Collection.HashSet<JobKey>(result);
            }
        }
Esempio n. 54
0
 /// <summary>
 /// 根据组名暂停作业
 /// </summary>
 /// <param name="groupName">组名</param>
 public static async Task PauseJobGroup(string groupName)
 {
     await Scheduler.PauseJobs(GroupMatcher <JobKey> .GroupEquals(groupName));
 }
Esempio n. 55
0
        /// <summary>
        /// Pause all of the <see cref="IJobDetail" />s in the
        /// given group - by pausing all of their <see cref="ITrigger" />s.
        /// <para>
        /// The JobStore should "remember" that the group is paused, and impose the
        /// pause on any new jobs that are added to the group while the group is
        /// paused.
        /// </para>
        /// </summary>
        public virtual IList<string> PauseJobs(GroupMatcher<JobKey> matcher)
        {
            List<string> pausedGroups = new List<String>();
            lock (lockObject)
            {
                StringOperator op = matcher.CompareWithOperator;
                if (op == StringOperator.Equality)
                {
                    this.PausedJobGroups.Save(
                        new BsonDocument(
                            new BsonElement("_id", matcher.CompareToValue)));

                    pausedGroups.Add(matcher.CompareToValue);
                }
                else
                {
                    IList<string> groups = this.GetJobGroupNames();

                    foreach (string group in groups)
                    {
                        if (op.Evaluate(group, matcher.CompareToValue))
                        {
                            this.PausedJobGroups.Save(
                                new BsonDocument(
                                    new BsonElement("_id", matcher.CompareToValue)));

                            pausedGroups.Add(matcher.CompareToValue);
                        }
                    }
                }

                foreach (string groupName in pausedGroups)
                {
                    foreach (JobKey jobKey in GetJobKeys(GroupMatcher<JobKey>.GroupEquals(groupName)))
                    {
                        IList<IOperableTrigger> triggers = this.GetTriggersForJob(jobKey);
                        foreach (IOperableTrigger trigger in triggers)
                        {
                            this.PauseTrigger(trigger.Key);
                        }
                    }
                }
            }

            return pausedGroups;
        }
Esempio n. 56
0
 /// <summary>
 /// 根据组名暂停触发器
 /// </summary>
 /// <param name="groupName">组名</param>
 public static async Task PauseTriggerGroup(string groupName)
 {
     await Scheduler.PauseTriggers(GroupMatcher <TriggerKey> .GroupEquals(groupName));
 }
Esempio n. 57
0
        /// <summary>
        /// Pause all of the <see cref="IJobDetail" />s in the
        /// given group - by pausing all of their <see cref="ITrigger" />s.
        /// </summary>
        public virtual void PauseJobs(GroupMatcher<JobKey> groupMatcher)
        {
            ValidateState();

            if (groupMatcher == null)
            {
                groupMatcher = GroupMatcher<JobKey>.GroupEquals(SchedulerConstants.DefaultGroup);
            }

            ICollection<string> pausedGroups = resources.JobStore.PauseJobs(groupMatcher);
            NotifySchedulerThread(null);
            foreach (string pausedGroup in pausedGroups)
            {
                NotifySchedulerListenersPausedJobs(pausedGroup);
            }
        }
 /// <summary>
 /// Resume (un-pause) all of the <see cref="T:Quartz.IJobDetail"/>s
 ///             in matching groups.
 /// </summary>
 /// <remarks>
 /// If any of the <see cref="T:Quartz.IJob"/> s had <see cref="T:Quartz.ITrigger"/> s that
 ///             missed one or more fire-times, then the <see cref="T:Quartz.ITrigger"/>'s
 ///             misfire instruction will be applied.
 /// </remarks>
 /// <seealso cref="M:Quartz.IScheduler.PauseJobs(Quartz.Impl.Matchers.GroupMatcher{Quartz.JobKey})"/>
 public void ResumeJobs(GroupMatcher<JobKey> matcher)
 {
     _scheduler.ResumeJobs(matcher);
 }
Esempio n. 59
0
        /// <summary>
        /// Get the names of all the <see cref="ITrigger" />s in
        /// the matching groups.
        /// </summary>
        public virtual Collection.ISet<TriggerKey> GetTriggerKeys(GroupMatcher<TriggerKey> matcher)
        {
            ValidateState();

            if (matcher == null)
            {
                matcher = GroupMatcher<TriggerKey>.GroupEquals(SchedulerConstants.DefaultGroup);
            }

            return resources.JobStore.GetTriggerKeys(matcher);
        }
Esempio n. 60
0
        public void TestGetJobKeysWithEquals()
        {
            var sched = CreateScheduler();

            sched.GetJobKeys(GroupMatcher <JobKey> .GroupEquals("bar"));
        }