/// <summary>
/// Remove (delete) the <see cref="T:Quartz.ITrigger"/> with the given key.
/// </summary>
/// <remarks>
/// <para>
/// If removal of the <see cref="T:Quartz.ITrigger"/> results in an empty group, the
/// group should be removed from the <see cref="T:Quartz.Spi.IJobStore"/>'s list of
/// known group names.
/// </para>
/// <para>
/// If removal of the <see cref="T:Quartz.ITrigger"/> results in an 'orphaned' <see cref="T:Quartz.IJob"/>
/// that is not 'durable', then the <see cref="T:Quartz.IJob"/> should be deleted
/// also.
/// </para>
/// </remarks>
/// <returns>
/// <see langword="true"/> if a <see cref="T:Quartz.ITrigger"/> with the given
/// name and group was found and removed from the store.
/// </returns>
public override bool RemoveTrigger(TriggerKey triggerKey, bool removeNonDurableJob = true)
{
var triggerHashKey = RedisJobStoreSchema.TriggerHashkey(triggerKey);
if (!Db.KeyExists(triggerHashKey))
{
return(false);
}
IOperableTrigger trigger = RetrieveTrigger(triggerKey);
var triggerGroupSetKey = RedisJobStoreSchema.TriggerGroupSetKey(triggerKey.Group);
var jobHashKey = RedisJobStoreSchema.JobHashKey(trigger.JobKey);
var jobTriggerSetkey = RedisJobStoreSchema.JobTriggersSetKey(trigger.JobKey);
Db.SetRemove(RedisJobStoreSchema.TriggersSetKey(), triggerHashKey);
Db.SetRemove(triggerGroupSetKey, triggerHashKey);
Db.SetRemove(jobTriggerSetkey, triggerHashKey);
if (Db.SetLength(triggerGroupSetKey) == 0)
{
Db.SetRemove(RedisJobStoreSchema.TriggerGroupsSetKey(), triggerGroupSetKey);
}
if (removeNonDurableJob)
{
var jobTriggerSetKeyLengthResult = Db.SetLength(jobTriggerSetkey);
var jobExistsResult = Db.KeyExists(jobHashKey);
if (jobTriggerSetKeyLengthResult == 0 && jobExistsResult)
{
var job = RetrieveJob(trigger.JobKey);
if (job.Durable == false)
{
RemoveJob(job.Key);
SchedulerSignaler.NotifySchedulerListenersJobDeleted(job.Key);
}
}
}
if (!string.IsNullOrEmpty(trigger.CalendarName))
{
Db.SetRemove(RedisJobStoreSchema.CalendarTriggersSetKey(trigger.CalendarName), triggerHashKey);
}
this.UnsetTriggerState(triggerHashKey);
return(Db.KeyDelete(triggerHashKey));
}
/// <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>
/// Store the given <see cref="T:Quartz.ITrigger"/>.
/// </summary>
/// <param name="trigger">The <see cref="T:Quartz.ITrigger"/> to be stored.</param><param name="replaceExisting">If <see langword="true"/>, any <see cref="T:Quartz.ITrigger"/> existing in
/// the <see cref="T:Quartz.Spi.IJobStore"/> with the same name and group should
/// be over-written.</param><throws>ObjectAlreadyExistsException </throws>
public override void StoreTrigger(ITrigger trigger, bool replaceExisting)
{
var triggerHashKey = RedisJobStoreSchema.TriggerHashkey(trigger.Key);
var triggerGroupSetKey = RedisJobStoreSchema.TriggerGroupSetKey(trigger.Key.Group);
var jobTriggerSetKey = RedisJobStoreSchema.JobTriggersSetKey(trigger.JobKey);
if (((trigger is ISimpleTrigger) == false) && ((trigger is ICronTrigger) == false))
{
throw new NotImplementedException("Unknown trigger, only SimpleTrigger and CronTrigger are supported");
}
var triggerExists = Db.KeyExists(triggerHashKey);
if (triggerExists && replaceExisting == false)
{
throw new ObjectAlreadyExistsException(trigger);
}
Db.HashSet(triggerHashKey, ConvertToHashEntries(trigger));
Db.SetAdd(RedisJobStoreSchema.TriggersSetKey(), triggerHashKey);
Db.SetAdd(RedisJobStoreSchema.TriggerGroupsSetKey(), triggerGroupSetKey);
Db.SetAdd(triggerGroupSetKey, triggerHashKey);
Db.SetAdd(jobTriggerSetKey, triggerHashKey);
if (!string.IsNullOrEmpty(trigger.CalendarName))
{
var calendarTriggersSetKey = RedisJobStoreSchema.CalendarTriggersSetKey(trigger.CalendarName);
Db.SetAdd(calendarTriggersSetKey, triggerHashKey);
}
//if trigger already exists, remove it from all the possible states.
if (triggerExists)
{
this.UnsetTriggerState(triggerHashKey);
}
//then update it with the new state in the its respectvie sorted set.
UpdateTriggerState(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);
}
