/// <summary>
/// Resume (un-pause) the <see cref="T:Quartz.ITrigger"/> with the
/// given key.
/// <para>
/// If the <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>
/// <seealso cref="T:System.String"/>
public override void ResumeTrigger(TriggerKey triggerKey)
{
var triggerHashKey = RedisJobStoreSchema.TriggerHashkey(triggerKey);
var triggerExists = Db.SetContains(RedisJobStoreSchema.TriggersSetKey(), triggerHashKey);
var isPausedTrigger =
Db.SortedSetScore(RedisJobStoreSchema.TriggerStateSetKey(RedisTriggerState.Paused),
triggerHashKey);
var isPausedBlockedTrigger =
Db.SortedSetScore(RedisJobStoreSchema.TriggerStateSetKey(RedisTriggerState.PausedBlocked),
triggerHashKey);
if (triggerExists == false)
{
return;
}
//Trigger is not paused, cant be resumed then.
if (!isPausedTrigger.HasValue && !isPausedBlockedTrigger.HasValue)
{
return;
}
var trigger = RetrieveTrigger(triggerKey);
var jobHashKey = RedisJobStoreSchema.JobHashKey(trigger.JobKey);
var nextFireTime = trigger.GetNextFireTimeUtc();
if (nextFireTime.HasValue)
{
if (Db.SetContains(RedisJobStoreSchema.BlockedJobsSet(), jobHashKey))
{
SetTriggerState(RedisTriggerState.Blocked, nextFireTime.Value.DateTime.ToUnixTimeMilliSeconds(), triggerHashKey);
}
else
{
SetTriggerState(RedisTriggerState.Waiting, nextFireTime.Value.DateTime.ToUnixTimeMilliSeconds(), triggerHashKey);
}
}
ApplyMisfire(trigger);
}
/// <summary>
/// Pause the <see cref="T:Quartz.ITrigger"/> with the given key.
/// </summary>
public override void PauseTrigger(TriggerKey triggerKey)
{
var triggerHashKey = RedisJobStoreSchema.TriggerHashkey(triggerKey);
var triggerExistsResult = Db.KeyExists(triggerHashKey);
var completedScoreResult =
Db.SortedSetScore(RedisJobStoreSchema.TriggerStateSetKey(RedisTriggerState.Completed),
triggerHashKey);
var nextFireTimeResult = Db.HashGet(triggerHashKey, RedisJobStoreSchema.NextFireTime);
var blockedScoreResult =
Db.SortedSetScore(RedisJobStoreSchema.TriggerStateSetKey(RedisTriggerState.Blocked),
triggerHashKey);
if (!triggerExistsResult)
{
return;
}
if (completedScoreResult.HasValue)
{
return;
}
var nextFireTime = double.Parse(string.IsNullOrEmpty(nextFireTimeResult) ? "-1" : nextFireTimeResult.ToString());
if (blockedScoreResult.HasValue)
{
SetTriggerState(RedisTriggerState.PausedBlocked, nextFireTime, triggerHashKey);
}
else
{
SetTriggerState(RedisTriggerState.Paused, nextFireTime, triggerHashKey);
}
}
/// <summary>
/// Inform the <see cref="T:Quartz.Spi.IJobStore"/> that the scheduler is now firing the
/// given <see cref="T:Quartz.ITrigger"/> (executing its associated <see cref="T:Quartz.IJob"/>),
/// that it had previously acquired (reserved).
/// </summary>
/// <returns>
/// May return null if all the triggers or their calendars no longer exist, or
/// if the trigger was not successfully put into the 'executing'
/// state. Preference is to return an empty list if none of the triggers
/// could be fired.
/// </returns>
public override IList <TriggerFiredResult> TriggersFired(IList <IOperableTrigger> triggers)
{
var result = new List <TriggerFiredResult>();
foreach (var trigger in triggers)
{
var triggerHashKey = RedisJobStoreSchema.TriggerHashkey(trigger.Key);
var triggerExistResult = Db.KeyExists(triggerHashKey);
var triggerAcquiredResult =
Db.SortedSetScore(RedisJobStoreSchema.TriggerStateSetKey(RedisTriggerState.Acquired),
triggerHashKey);
if (triggerExistResult == false)
{
Logger.WarnFormat("Trigger {0} does not exist", triggerHashKey);
continue;
}
if (!triggerAcquiredResult.HasValue)
{
Logger.WarnFormat("Trigger {0} was not acquired", triggerHashKey);
continue;
}
ICalendar calendar = null;
string calendarname = trigger.CalendarName;
if (!string.IsNullOrEmpty(calendarname))
{
calendar = this.RetrieveCalendar(calendarname);
if (calendar == null)
{
continue;
}
}
var previousFireTime = trigger.GetPreviousFireTimeUtc();
trigger.Triggered(calendar);
var job = this.RetrieveJob(trigger.JobKey);
var triggerFireBundle = new TriggerFiredBundle(job, trigger, calendar, false, DateTimeOffset.UtcNow,
previousFireTime, previousFireTime, trigger.GetNextFireTimeUtc());
if (job.ConcurrentExecutionDisallowed)
{
var jobHasKey = this.RedisJobStoreSchema.JobHashKey(trigger.JobKey);
var jobTriggerSetKey = this.RedisJobStoreSchema.JobTriggersSetKey(job.Key);
foreach (var nonConcurrentTriggerHashKey in this.Db.SetMembers(jobTriggerSetKey))
{
var score =
this.Db.SortedSetScore(this.RedisJobStoreSchema.TriggerStateSetKey(RedisTriggerState.Waiting),
nonConcurrentTriggerHashKey);
if (score.HasValue)
{
this.SetTriggerState(RedisTriggerState.Blocked, score.Value, nonConcurrentTriggerHashKey);
}
else
{
score = this.Db.SortedSetScore(this.RedisJobStoreSchema.TriggerStateSetKey(RedisTriggerState.Paused),
nonConcurrentTriggerHashKey);
if (score.HasValue)
{
this.SetTriggerState(RedisTriggerState.PausedBlocked, score.Value, nonConcurrentTriggerHashKey);
}
}
}
Db.SetAdd(this.RedisJobStoreSchema.JobBlockedKey(job.Key), this.SchedulerInstanceId);
Db.SetAdd(this.RedisJobStoreSchema.BlockedJobsSet(), jobHasKey);
}
//release the fired triggers
var nextFireTimeUtc = trigger.GetNextFireTimeUtc();
if (nextFireTimeUtc != null)
{
var nextFireTime = nextFireTimeUtc.Value;
this.Db.HashSet(triggerHashKey, RedisJobStoreSchema.NextFireTime, nextFireTime.DateTime.ToUnixTimeMilliSeconds());
this.SetTriggerState(RedisTriggerState.Waiting, nextFireTime.DateTime.ToUnixTimeMilliSeconds(), triggerHashKey);
}
else
{
this.Db.HashSet(triggerHashKey, RedisJobStoreSchema.NextFireTime, "");
this.UnsetTriggerState(triggerHashKey);
}
result.Add(new TriggerFiredResult(triggerFireBundle));
}
return(result);
}
/// <summary>
/// remove the trigger from all the possible state in the its respective sorted set.
/// </summary>
/// <param name="triggerHashKey">trigger hash key</param>
/// <returns>succeeds or not</returns>
public override bool UnsetTriggerState(string triggerHashKey)
{
var removedList = (from RedisTriggerState state in Enum.GetValues(typeof(RedisTriggerState)) select Db.SortedSetRemove(RedisJobStoreSchema.TriggerStateSetKey(state), triggerHashKey)).ToList();
if (removedList.Any(x => x))
{
return(Db.KeyDelete(
RedisJobStoreSchema.TriggerLockKey(RedisJobStoreSchema.TriggerKey(triggerHashKey))));
}
return(false);
}
