public void ResumeJobs_UseEqualOperator_Successfully()
{
//arrange
var jobsAndTriggers = CreateJobsAndTriggers(2, 2, 2, 2);
JobStore.StoreJobsAndTriggers(jobsAndTriggers, false);
var pausedGroup = jobsAndTriggers.Keys.First().Key.Group;
JobStore.PauseJobs(GroupMatcher <JobKey> .GroupEquals(pausedGroup));
global::Quartz.Collection.ISet <ITrigger> triggers = new global::Quartz.Collection.HashSet <ITrigger>();
jobsAndTriggers.TryGetValue(jobsAndTriggers.Keys.First(), out triggers);
//act
var resumedJobGroups = JobStore.ResumeJobs(GroupMatcher <JobKey> .GroupEquals(pausedGroup));
//assert
Assert.IsTrue(resumedJobGroups.Count == 1);
Assert.AreEqual(resumedJobGroups.First(), pausedGroup);
//all its triggers are back to the Normal state
foreach (var trigger in triggers)
{
Assert.AreEqual(TriggerState.Normal, JobStore.GetTriggerState(trigger.Key));
}
}
private static void ConfigureJob(ServiceConfigurator configurator, Action <QuartzConfigurator> jobConfigurator)
{
var jobConfig = new QuartzConfigurator();
jobConfigurator(jobConfig);
if (jobConfig.JobEnabled == null || jobConfig.JobEnabled() || (jobConfig.Job == null || jobConfig.Triggers == null))
{
var jobDetail = jobConfig.Job != null?jobConfig.Job() : null;
var jobTriggers = (jobConfig.Triggers ?? Enumerable.Empty <Func <ITrigger> >())
.Select(triggerFactory => triggerFactory()).Where(trigger => trigger != null).ToArray();
configurator.BeforeStartingService(() => {
_scheduler = _scheduler ?? GetScheduler();
if (_scheduler == null || jobDetail == null || !jobTriggers.Any())
{
return;
}
var triggersForJob = new global::Quartz.Collection.HashSet <ITrigger>(jobTriggers);
_scheduler.ScheduleJob(jobDetail, triggersForJob, false);
_scheduler.Start();
});
configurator.BeforeStoppingService(() => _scheduler.Shutdown(true));
}
}
/// <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);
}
public void PauseJobSuccessfully()
{
//arrange
var job = CreateJob("pausedJob", "pausedGroup");
var trigger1 = CreateTrigger("trigger1", "triggerGroup1", job.Key);
var trigger2 = CreateTrigger("trigger2", "triggerGroup2", job.Key);
var triggerSet = new global::Quartz.Collection.HashSet <ITrigger> {
trigger1, trigger2
};
this.StoreJobAndTriggers(job, triggerSet);
//act
JobStore.PauseJob(job.Key);
//assert
Assert.AreEqual(JobStore.GetTriggerState(trigger1.Key), TriggerState.Paused);
Assert.AreEqual(JobStore.GetTriggerState(trigger2.Key), TriggerState.Paused);
}
public void PauseJobs_UseContainWithsOperator_Successfully()
{
//arrange
var job = CreateJob("job1", "GroupContainsfoobar");
var trigger1 = CreateTrigger("trigger1", "triggerGroup1", job.Key);
var trigger2 = CreateTrigger("trigger2", "triggerGroup2", job.Key);
var triggerSet = new global::Quartz.Collection.HashSet <ITrigger> {
trigger1, trigger2
};
this.StoreJobAndTriggers(job, triggerSet);
//act
var pausedJobs = JobStore.PauseJobs(GroupMatcher <JobKey> .GroupContains("foobar"));
//assert
Assert.IsTrue(pausedJobs.Count == 1);
Assert.AreEqual(TriggerState.Paused, JobStore.GetTriggerState(trigger1.Key));
Assert.AreEqual(TriggerState.Paused, JobStore.GetTriggerState(trigger2.Key));
}
public void RemoveJobSuccessfully()
{
//arrange
var job = CreateJob("job1", "group1");
var trigger1 = CreateTrigger("trigger1", "triggerGroup1", job.Key);
var trigger2 = CreateTrigger("trigger2", "triggerGroup2", job.Key);
var triggerSet = new global::Quartz.Collection.HashSet <ITrigger> {
trigger1, trigger2
};
this.StoreJobAndTriggers(job, triggerSet);
//act
var result = JobStore.RemoveJob(job.Key);
//assert
Assert.IsTrue(result);
Assert.IsNull(JobStore.RetrieveJob(job.Key));
Assert.IsNull(JobStore.RetrieveTrigger(trigger1.Key));
Assert.IsNull(JobStore.RetrieveTrigger(trigger2.Key));
}
/// <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);
}
/// <summary>
/// create jobs and triggers
/// </summary>
/// <param name="jobGroups">Number of JobGroup</param>
/// <param name="jobsPerGroup">Number of jobs per Group</param>
/// <param name="triggerGroupsPerJob">number of Trigger Group per Job</param>
/// <param name="triggersPerGroup">number of triggers per group</param>
/// <param name="cronExpression">unix cron expression</param>
/// <returns>jobs and triggers</returns>
protected static IDictionary <IJobDetail, global::Quartz.Collection.ISet <ITrigger> > CreateJobsAndTriggers(int jobGroups, int jobsPerGroup, int triggerGroupsPerJob,
int triggersPerGroup, string cronExpression = "")
{
var jobsAndTriggers = new Dictionary <IJobDetail, global::Quartz.Collection.ISet <ITrigger> >();
for (int g = 0; g < jobGroups; g++)
{
var jobGroup = "jobGroup_" + g;
for (int j = 0; j < jobsPerGroup; j++)
{
var jobName = "jobName_" + j;
var job = CreateJob(jobName, jobGroup);
var triggerSet = new global::Quartz.Collection.HashSet <ITrigger>();
for (int tg = 0; tg < triggerGroupsPerJob; tg++)
{
var triggerGroup = "triggerGroup_" + tg + "_" + j + g;
for (int t = 0; t < triggersPerGroup; t++)
{
var triggerName = "trigger_" + t;
if (string.IsNullOrEmpty(cronExpression))
{
triggerSet.Add(CreateTrigger(triggerName, triggerGroup, job.Key));
}
else
{
triggerSet.Add(CreateTrigger(triggerName, triggerGroup, job.Key, cronExpression));
}
}
}
jobsAndTriggers.Add(job, triggerSet);
}
}
return(jobsAndTriggers);
}
/// <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;
}
/// <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;
}
/// <summary>
/// Gets the paused trigger groups.
/// </summary>
/// <returns/>
public global::Quartz.Collection.ISet<string> GetPausedTriggerGroups()
{
RedisValue[] triggerGroupSetKeys =
Db.SetMembers(RedisJobStoreSchema.PausedTriggerGroupsSetKey());
var groups = new global::Quartz.Collection.HashSet<string>();
foreach (var triggerGroupSetKey in triggerGroupSetKeys)
{
groups.Add(RedisJobStoreSchema.TriggerGroup(triggerGroupSetKey));
}
return groups;
}
/// <summary>
/// Get a handle to the next trigger to be fired, and mark it as 'reserved'
/// by the calling scheduler.
/// </summary>
/// <param name="noLaterThan">If > 0, the JobStore should only return a Trigger
/// that will fire no later than the time represented in this value as
/// milliseconds.</param><param name="maxCount"/><param name="timeWindow"/>
/// <returns/>
/// <seealso cref="T:Quartz.ITrigger"/>
public IList<IOperableTrigger> AcquireNextTriggers(DateTimeOffset noLaterThan, int maxCount, TimeSpan timeWindow)
{
ReleaseTriggers();
var triggers = new List<IOperableTrigger>();
bool retry = false;
do
{
var acquiredJobHashKeysForNoConcurrentExec = new global::Quartz.Collection.HashSet<string>();
var score = ToUnixTimeMilliseconds(noLaterThan.Add(timeWindow));
var waitingStateTriggers =
Db.SortedSetRangeByScoreWithScores(
RedisJobStoreSchema.TriggerStateSetKey(RedisTriggerState.Waiting), 0, score,
Exclude.None, Order.Ascending, 0, maxCount);
foreach (var sortedSetEntry in waitingStateTriggers)
{
var trigger = RetrieveTrigger(RedisJobStoreSchema.TriggerKey(sortedSetEntry.Element));
if (ApplyMisfire(trigger))
{
retry = true;
break;
}
if (trigger.GetNextFireTimeUtc() == null)
{
this.UnsetTriggerState(sortedSetEntry.Element);
continue;
}
var jobHashKey = RedisJobStoreSchema.JobHashKey(trigger.JobKey);
var job = RetrieveJob(trigger.JobKey);
if (job != null && job.ConcurrentExecutionDisallowed)
{
if (acquiredJobHashKeysForNoConcurrentExec.Contains(jobHashKey))
{
continue;
}
acquiredJobHashKeysForNoConcurrentExec.Add(jobHashKey);
}
LockTrigger(trigger.Key);
SetTriggerState(RedisTriggerState.Acquired,
sortedSetEntry.Score, sortedSetEntry.Element);
triggers.Add(trigger);
}
} while (retry);
return triggers;
}
/// <summary>
/// create jobs and triggers
/// </summary>
/// <param name="jobGroups">Number of JobGroup</param>
/// <param name="jobsPerGroup">Number of jobs per Group</param>
/// <param name="triggerGroupsPerJob">number of Trigger Group per Job</param>
/// <param name="triggersPerGroup">number of triggers per group</param>
/// <param name="cronExpression">unix cron expression</param>
/// <returns>jobs and triggers</returns>
protected static IDictionary<IJobDetail, global::Quartz.Collection.ISet<ITrigger>> CreateJobsAndTriggers(int jobGroups, int jobsPerGroup, int triggerGroupsPerJob,
int triggersPerGroup, string cronExpression = "")
{
var jobsAndTriggers = new Dictionary<IJobDetail, global::Quartz.Collection.ISet<ITrigger>>();
for (int g = 0; g < jobGroups; g++)
{
var jobGroup = "jobGroup_" + g;
for (int j = 0; j < jobsPerGroup; j++)
{
var jobName = "jobName_" + j;
var job = CreateJob(jobName, jobGroup);
var triggerSet = new global::Quartz.Collection.HashSet<ITrigger>();
for (int tg = 0; tg < triggerGroupsPerJob; tg++)
{
var triggerGroup = "triggerGroup_" + tg + "_" + j + g;
for (int t = 0; t < triggersPerGroup; t++)
{
var triggerName = "trigger_" + t;
if (string.IsNullOrEmpty(cronExpression))
{
triggerSet.Add(CreateTrigger(triggerName, triggerGroup, job.Key));
}
else
{
triggerSet.Add(CreateTrigger(triggerName, triggerGroup, job.Key, cronExpression));
}
}
}
jobsAndTriggers.Add(job, triggerSet);
}
}
return jobsAndTriggers;
}
public void RemoveJobSuccessfully()
{
//arrange
var job = CreateJob("job1", "group1");
var trigger1 = CreateTrigger("trigger1", "triggerGroup1", job.Key);
var trigger2 = CreateTrigger("trigger2", "triggerGroup2", job.Key);
var triggerSet = new global::Quartz.Collection.HashSet<ITrigger> { trigger1, trigger2 };
this.StoreJobAndTriggers(job, triggerSet);
//act
var result = JobStore.RemoveJob(job.Key);
//assert
Assert.IsTrue(result);
Assert.IsNull(JobStore.RetrieveJob(job.Key));
Assert.IsNull(JobStore.RetrieveTrigger(trigger1.Key));
Assert.IsNull(JobStore.RetrieveTrigger(trigger2.Key));
}
public void ResumeJobs_UseEqualOperator_Successfully()
{
//arrange
var jobsAndTriggers = CreateJobsAndTriggers(2, 2, 2, 2);
JobStore.StoreJobsAndTriggers(jobsAndTriggers, false);
var pausedGroup = jobsAndTriggers.Keys.First().Key.Group;
JobStore.PauseJobs(GroupMatcher<JobKey>.GroupEquals(pausedGroup));
global::Quartz.Collection.ISet<ITrigger> triggers = new global::Quartz.Collection.HashSet<ITrigger>();
jobsAndTriggers.TryGetValue(jobsAndTriggers.Keys.First(), out triggers);
//act
var resumedJobGroups = JobStore.ResumeJobs(GroupMatcher<JobKey>.GroupEquals(pausedGroup));
//assert
Assert.IsTrue(resumedJobGroups.Count == 1);
Assert.AreEqual(resumedJobGroups.First(), pausedGroup);
//all its triggers are back to the Normal state
foreach (var trigger in triggers)
{
Assert.AreEqual(TriggerState.Normal, JobStore.GetTriggerState(trigger.Key));
}
}
public void ResumeJobSuccessfully()
{
//arrange
var job = CreateJob("job1", "jobGroup1");
var trigger1 = CreateTrigger("trigger1", "triggerGroup1", job.Key);
var trigger2 = CreateTrigger("trigger2", "triggerGroup2", job.Key);
var triggerSet = new global::Quartz.Collection.HashSet<ITrigger> { trigger1, trigger2 };
this.StoreJobAndTriggers(job, triggerSet);
JobStore.PauseJob(job.Key);
//act
JobStore.ResumeJob(job.Key);
//assert
Assert.AreEqual(TriggerState.Normal, JobStore.GetTriggerState(trigger1.Key));
Assert.AreEqual(TriggerState.Normal, JobStore.GetTriggerState(trigger2.Key));
}
/// <summary>
/// 添加Job
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public static void ScheduleJob(ScheduleJobInput input)
{
#region JobDetail
JobBuilder jobBuilder = JobBuilder
.Create()
.OfType(Type.GetType(input.FullName + "," + input.AssemblyName, true))
.WithDescription(input.JobDescription)
.WithIdentity(new JobKey(input.JobName, input.JobGroup))
.UsingJobData(GetJobDataMap(input));
if (input.IsRequest)
{
//在服务器异常时候,重启调度之后,接着执行调度
jobBuilder = jobBuilder.RequestRecovery();
}
if (input.IsSave)
{
//保存到数据库中
jobBuilder.StoreDurably();
}
IJobDetail detail = jobBuilder.Build();
#endregion
#region trigger
var triggerBuilder = TriggerBuilder
.Create()
.ForJob(detail);
if (!input.ChoicedCalendar.IsNullOrEmpty())
{
triggerBuilder.ModifiedByCalendar(input.ChoicedCalendar);
}
if (!input.TriggerName.IsNullOrEmpty() && !input.TriggerGroup.IsNullOrEmpty())
{
triggerBuilder.WithDescription(input.TriggerDescription)
.WithIdentity(new TriggerKey(input.TriggerName, input.TriggerGroup));
}
#endregion
//是否替换
if (input.ReplaceExists)
{
var triggers = new global::Quartz.Collection.HashSet <ITrigger>();
//如果是Cron触发器
if (input.TriggerType == "CronTriggerImpl")
{
triggers.Add(triggerBuilder.WithCronSchedule(input.Cron).Build());
}
else
{
var simpleBuilder = SimpleScheduleBuilder.Create();
if (input.Repeat)
{
simpleBuilder.RepeatForever();
}
simpleBuilder.WithInterval(input.Interval);
triggers.Add(triggerBuilder.WithSchedule(simpleBuilder).Build());
}
ScheduleJob(detail, triggers, true);
}
else
{
//如果是Cron触发器
if (input.TriggerType == "CronTriggerImpl")
{
ScheduleJob(detail, triggerBuilder.WithCronSchedule(input.Cron).Build());
}
else
{
var simpleBuilder = SimpleScheduleBuilder.Create();
if (input.Repeat)
{
simpleBuilder.RepeatForever();
}
simpleBuilder.WithInterval(input.Interval);
ScheduleJob(detail, triggerBuilder.WithSchedule(simpleBuilder).Build());
}
}
}
public void PauseJobs_UseStartsWithOperator_Successfully()
{
//arrange
var job = CreateJob("job1", "startGroup");
var trigger1 = CreateTrigger("trigger1", "triggerGroup1", job.Key);
var trigger2 = CreateTrigger("trigger2", "triggerGroup2", job.Key);
var triggerSet = new global::Quartz.Collection.HashSet<ITrigger> { trigger1, trigger2 };
this.StoreJobAndTriggers(job, triggerSet);
//act
var pausedJobs = JobStore.PauseJobs(GroupMatcher<JobKey>.GroupStartsWith("start"));
//assert
Assert.IsTrue(pausedJobs.Count == 1);
Assert.AreEqual(TriggerState.Paused, JobStore.GetTriggerState(trigger1.Key));
Assert.AreEqual(TriggerState.Paused, JobStore.GetTriggerState(trigger2.Key));
}
