public bool RemoveTrigger(string triggerName, bool deleteOrphanedJob)
{
bool flag;
lock (this._triggerLock)
{
object obj2 = this._triggersDictionary[triggerName];
this._triggersDictionary.Remove(triggerName);
flag = obj2 != null;
if (!flag)
{
return(flag);
}
TriggerWrapper wrapper = null;
for (int i = 0; i < this._triggers.Count; i++)
{
wrapper = this._triggers[i] as TriggerWrapper;
if (triggerName.Equals(wrapper.Name))
{
this._triggers.RemoveAt(i);
break;
}
}
this._timeTriggers.Remove(wrapper);
JobWrapper wrapper2 = this._jobsDictionary[wrapper.Trigger.JobName] as JobWrapper;
Trigger[] triggersForJob = this.GetTriggersForJob(wrapper.Trigger.JobName);
if (((triggersForJob == null) || (triggersForJob.Length == 0)) && deleteOrphanedJob)
{
this.RemoveJob(wrapper.Trigger.JobName);
}
}
return(flag);
}
protected bool ApplyMisfire(TriggerWrapper tw)
{
DateTime misfireTime = DateTime.UtcNow;
if (MisfireThreshold > 0)
{
misfireTime = misfireTime.AddMilliseconds(-1 * MisfireThreshold);
}
NullableDateTime tnft = tw.Trigger.GetNextFireTimeUtc();
if (!tnft.HasValue || tnft.Value > misfireTime)
{
return(false);
}
tw.Trigger.UpdateAfterMisfire();
if (!tw.Trigger.GetNextFireTimeUtc().HasValue)
{
tw.State = InternalTriggerState.Complete;
lock (_triggerLock)
{
_timeTriggers.Remove(tw);
}
}
else if (tnft.Equals(tw.Trigger.GetNextFireTimeUtc()))
{
return(false);
}
return(true);
}
protected bool ApplyMisfire(TriggerWrapper tw)
{
DateTime utcNow = DateTime.UtcNow;
if (this.MisfireThreshold > 0L)
{
utcNow = utcNow.AddMilliseconds((double)(-1L * this.MisfireThreshold));
}
DateTime?nextFireTimeUtc = tw.Trigger.GetNextFireTimeUtc();
if (!(nextFireTimeUtc.HasValue && (nextFireTimeUtc.Value <= utcNow)))
{
return(false);
}
tw.Trigger.UpdateAfterMisfire();
if (!tw.Trigger.GetNextFireTimeUtc().HasValue)
{
tw.State = InternalTriggerState.Complete;
lock (this._triggerLock)
{
this._timeTriggers.Remove(tw);
}
}
else if (nextFireTimeUtc.Equals(tw.Trigger.GetNextFireTimeUtc()))
{
return(false);
}
return(true);
}
public Trigger RetrieveTrigger(string triggerName)
{
lock (_triggersDictionary)
{
TriggerWrapper tw = _triggersDictionary[triggerName] as TriggerWrapper;
return((tw != null) ? tw.Trigger : null);
}
}
public Trigger RetrieveTrigger(string triggerName)
{
lock (this._triggersDictionary)
{
TriggerWrapper wrapper = this._triggersDictionary[triggerName] as TriggerWrapper;
return((wrapper != null) ? wrapper.Trigger : null);
}
}
public void TriggeredJobComplete(Trigger trigger, IScheduledJob job, SchedulerInstruction triggerInstCode)
{
lock (_triggerLock)
{
JobWrapper jw = _jobsDictionary[job.Name] as JobWrapper;
TriggerWrapper tw = _triggersDictionary[trigger.Name] as TriggerWrapper;
// even if it was deleted, there may be cleanup to do
_blockedJobs.Remove(job.Name);
// check for trigger deleted during execution...
if (tw != null)
{
if (triggerInstCode == SchedulerInstruction.DeleteTrigger)
{
//log.Debug("Deleting trigger");
NullableDateTime d = trigger.GetNextFireTimeUtc();
if (!d.HasValue)
{
// double check for possible reschedule within job
// execution, which would cancel the need to delete...
d = tw.Trigger.GetNextFireTimeUtc();
if (!d.HasValue)
{
RemoveTrigger(trigger.Name);
}
else
{
log.Debug("Deleting cancelled - trigger still active");
}
}
else
{
RemoveTrigger(trigger.Name);
}
}
else if (triggerInstCode == SchedulerInstruction.SetTriggerComplete)
{
tw.State = InternalTriggerState.Complete;
_timeTriggers.Remove(tw);
}
else if (triggerInstCode == SchedulerInstruction.SetTriggerError)
{
log.Info(string.Format(CultureInfo.InvariantCulture, "Trigger {0} set to ERROR state.", trigger.Name));
tw.State = InternalTriggerState.Error;
}
else if (triggerInstCode == SchedulerInstruction.SetAllJobTriggersError)
{
log.Info(string.Format(CultureInfo.InvariantCulture, "All triggers of Job {0} set to ERROR state.", trigger.Name));
SetAllTriggersOfJobToState(trigger.Name, InternalTriggerState.Error);
}
else if (triggerInstCode == SchedulerInstruction.SetAllJobTriggersComplete)
{
SetAllTriggersOfJobToState(trigger.Name, InternalTriggerState.Complete);
}
}
}
}
public TriggerFiredBundle TriggerFired(Trigger trigger)
{
lock (_triggerLock)
{
TriggerWrapper tw = _triggersDictionary[trigger.Name] as TriggerWrapper;
// was the trigger deleted since being acquired?
if (tw == null || tw.Trigger == null)
{
return(null);
}
// was the trigger completed since being acquired?
if (tw.State == InternalTriggerState.Complete)
{
return(null);
}
// was the trigger paused since being acquired?
if (tw.State == InternalTriggerState.Paused)
{
return(null);
}
// was the trigger blocked since being acquired?
if (tw.State == InternalTriggerState.Blocked)
{
return(null);
}
// was the trigger paused and blocked since being acquired?
if (tw.State == InternalTriggerState.PausedAndBlocked)
{
return(null);
}
NullableDateTime prevFireTime = trigger.GetPreviousFireTimeUtc();
// in case trigger was replaced between acquiring and firering
_timeTriggers.Remove(tw);
trigger.Triggered();
//tw.state = TriggerWrapper.StateExecuting;
tw.State = InternalTriggerState.Waiting;
IScheduledJob job = RetrieveJob(trigger.JobName);
TriggerFiredBundle bndle = new TriggerFiredBundle(job, trigger, false, DateTime.UtcNow,
trigger.GetPreviousFireTimeUtc(), prevFireTime, trigger.GetNextFireTimeUtc());
NullableDateTime d = tw.Trigger.GetNextFireTimeUtc();
if (d.HasValue)
{
lock (_triggerLock)
{
_timeTriggers.Add(tw);
}
}
return(bndle);
}
}
public void ReleaseAcquiredTrigger(Trigger trigger)
{
lock (_triggerLock)
{
TriggerWrapper tw = _triggersDictionary[trigger.Name] as TriggerWrapper;
if (tw != null && tw.State == InternalTriggerState.Acquired)
{
tw.State = InternalTriggerState.Waiting;
_timeTriggers.Add(tw);
}
}
}
public void ReleaseAcquiredTrigger(Trigger trigger)
{
lock (this._triggerLock)
{
TriggerWrapper wrapper = this._triggersDictionary[trigger.Name] as TriggerWrapper;
if ((wrapper != null) && (wrapper.State == InternalTriggerState.Acquired))
{
wrapper.State = InternalTriggerState.Waiting;
this._timeTriggers.Add(wrapper);
}
}
}
public override bool Equals(object obj)
{
if (obj is TriggerWrapper)
{
TriggerWrapper wrapper = (TriggerWrapper)obj;
if (wrapper.Name.Equals(this.Name))
{
return(true);
}
}
return(false);
}
public void TriggeredJobComplete(Trigger trigger, IScheduledJob job, SchedulerInstruction triggerInstCode)
{
lock (this._triggerLock)
{
JobWrapper wrapper = this._jobsDictionary[job.Name] as JobWrapper;
TriggerWrapper wrapper2 = this._triggersDictionary[trigger.Name] as TriggerWrapper;
this._blockedJobs.Remove(job.Name);
if (wrapper2 != null)
{
if (triggerInstCode == SchedulerInstruction.DeleteTrigger)
{
if (!trigger.GetNextFireTimeUtc().HasValue)
{
if (!wrapper2.Trigger.GetNextFireTimeUtc().HasValue)
{
this.RemoveTrigger(trigger.Name);
}
else
{
log.Debug("Deleting cancelled - trigger still active");
}
}
else
{
this.RemoveTrigger(trigger.Name);
}
}
else if (triggerInstCode == SchedulerInstruction.SetTriggerComplete)
{
wrapper2.State = InternalTriggerState.Complete;
this._timeTriggers.Remove(wrapper2);
}
else if (triggerInstCode == SchedulerInstruction.SetTriggerError)
{
log.Info(string.Format(CultureInfo.InvariantCulture, "Trigger {0} set to ERROR state.", new object[] { trigger.Name }));
wrapper2.State = InternalTriggerState.Error;
}
else if (triggerInstCode == SchedulerInstruction.SetAllJobTriggersError)
{
log.Info(string.Format(CultureInfo.InvariantCulture, "All triggers of Job {0} set to ERROR state.", new object[] { trigger.Name }));
this.SetAllTriggersOfJobToState(trigger.Name, InternalTriggerState.Error);
}
else if (triggerInstCode == SchedulerInstruction.SetAllJobTriggersComplete)
{
this.SetAllTriggersOfJobToState(trigger.Name, InternalTriggerState.Complete);
}
}
}
}
public void StoreTrigger(Trigger trigger, bool replaceExisting)
{
TriggerWrapper tw = new TriggerWrapper(trigger);
lock (_triggerLock)
{
if (_triggersDictionary.Contains(tw.Name))
{
if (!replaceExisting)
{
throw new NotSupportedException("Object already exists " + trigger.Name);
}
// don't delete orphaned job, this trigger has the job anyways
RemoveTrigger(trigger.Name, false);
}
if (RetrieveJob(trigger.JobName) == null)
{
throw new ApplicationException("The job (" + trigger.JobName + ") referenced by the trigger does not exist.");
}
// add to triggers array
_triggers.Add(tw);
_triggersDictionary[tw.Name] = tw;
lock (_pausedTriggers)
{
if (_pausedTriggers.Contains(trigger.Name) || _pausedJobs.Contains(trigger.JobName))
{
tw.State = InternalTriggerState.Paused;
if (_blockedJobs.Contains(trigger.JobName))
{
tw.State = InternalTriggerState.PausedAndBlocked;
}
}
else if (_blockedJobs.Contains(trigger.JobName))
{
tw.State = InternalTriggerState.Blocked;
}
else
{
_timeTriggers.Add(tw);
}
}
}
}
private ArrayList GetTriggerWrappersForJob(string jobName)
{
ArrayList trigList = new ArrayList();
lock (_triggerLock)
{
for (int i = 0; i < _triggers.Count; i++)
{
TriggerWrapper tw = _triggers[i] as TriggerWrapper;
if (tw.JobName.Equals(jobName))
{
trigList.Add(tw);
}
}
}
return(trigList);
}
public virtual int Compare(object obj1, object obj2)
{
TriggerWrapper wrapper = (TriggerWrapper)obj1;
TriggerWrapper wrapper2 = (TriggerWrapper)obj2;
int num = wrapper.Trigger.CompareTo(wrapper2.Trigger);
if (num != 0)
{
return(num);
}
num = wrapper2.Trigger.Priority - wrapper.Trigger.Priority;
if (num != 0)
{
return(num);
}
return(wrapper.Trigger.Name.CompareTo(wrapper2.Trigger.Name));
}
private ArrayList GetTriggerWrappersForJob(string jobName)
{
ArrayList list = new ArrayList();
lock (this._triggerLock)
{
for (int i = 0; i < this._triggers.Count; i++)
{
TriggerWrapper wrapper = this._triggers[i] as TriggerWrapper;
if (wrapper.JobName.Equals(jobName))
{
list.Add(wrapper);
}
}
}
return(list);
}
public virtual Trigger[] GetTriggersForJob(string jobName)
{
ArrayList list = new ArrayList();
lock (this._triggerLock)
{
for (int i = 0; i < this._triggers.Count; i++)
{
TriggerWrapper wrapper = this._triggers[i] as TriggerWrapper;
if (wrapper.JobName.Equals(jobName))
{
list.Add(wrapper.Trigger);
}
}
}
return((Trigger[])list.ToArray(typeof(Trigger)));
}
/// <summary>
/// Get all of the Triggers that are associated to the given Job.
/// <p>
/// If there are no matches, a zero-length array should be returned.
/// </p>
/// </summary>
public virtual Trigger[] GetTriggersForJob(string jobName)
{
ArrayList result = new ArrayList();
lock (_triggerLock)
{
for (int i = 0; i < _triggers.Count; i++)
{
TriggerWrapper tw = _triggers[i] as TriggerWrapper;
if (tw.JobName.Equals(jobName))
{
result.Add(tw.Trigger);
}
}
}
return((Trigger[])result.ToArray(typeof(Trigger)));
}
public Trigger AcquireNextTrigger(DateTime noLaterThan)
{
TriggerWrapper wrapper = null;
lock (this._triggerLock)
{
while (wrapper == null)
{
if (this._timeTriggers.Count > 0)
{
wrapper = this._timeTriggers[0] as TriggerWrapper;
}
if (wrapper == null)
{
return(null);
}
if (!wrapper.Trigger.GetNextFireTimeUtc().HasValue)
{
this._timeTriggers.Remove(wrapper);
wrapper = null;
}
else
{
this._timeTriggers.Remove(wrapper);
if (this.ApplyMisfire(wrapper))
{
if (wrapper.Trigger.GetNextFireTimeUtc().HasValue)
{
this._timeTriggers.Add(wrapper);
}
wrapper = null;
continue;
}
if (wrapper.Trigger.GetNextFireTimeUtc().Value > noLaterThan)
{
this._timeTriggers.Add(wrapper);
return(null);
}
wrapper.State = InternalTriggerState.Acquired;
return(wrapper.Trigger);
}
}
}
return(null);
}
public Trigger AcquireNextTrigger(DateTime noLaterThan)
{
TriggerWrapper tw = null;
lock (_triggerLock)
{
while (tw == null)
{
if (_timeTriggers.Count > 0)
{
tw = _timeTriggers[0] as TriggerWrapper;
}
if (tw == null)
{
return(null);
}
if (!tw.Trigger.GetNextFireTimeUtc().HasValue)
{
_timeTriggers.Remove(tw);
tw = null;
continue;
}
_timeTriggers.Remove(tw);
if (ApplyMisfire(tw))
{
if (tw.Trigger.GetNextFireTimeUtc().HasValue)
{
_timeTriggers.Add(tw);
}
tw = null;
continue;
}
if (tw.Trigger.GetNextFireTimeUtc().Value > noLaterThan)
{
_timeTriggers.Add(tw);
return(null);
}
tw.State = InternalTriggerState.Acquired;
//tw.Trigger.FireInstanceId = FiredTriggerRecordId;
return(tw.Trigger);
}
}
return(null);
}
public virtual int Compare(object obj1, object obj2)
{
TriggerWrapper trig1 = (TriggerWrapper)obj1;
TriggerWrapper trig2 = (TriggerWrapper)obj2;
int comp = trig1.Trigger.CompareTo(trig2.Trigger);
if (comp != 0)
{
return(comp);
}
comp = trig2.Trigger.Priority - trig1.Trigger.Priority;
if (comp != 0)
{
return(comp);
}
return(trig1.Trigger.Name.CompareTo(trig2.Trigger.Name));
}
public void StoreTrigger(Trigger trigger, bool replaceExisting)
{
TriggerWrapper wrapper = new TriggerWrapper(trigger);
lock (this._triggerLock)
{
if (this._triggersDictionary.Contains(wrapper.Name))
{
if (!replaceExisting)
{
throw new NotSupportedException("Object already exists " + trigger.Name);
}
this.RemoveTrigger(trigger.Name, false);
}
if (this.RetrieveJob(trigger.JobName) == null)
{
throw new ApplicationException("The job (" + trigger.JobName + ") referenced by the trigger does not exist.");
}
this._triggers.Add(wrapper);
this._triggersDictionary[wrapper.Name] = wrapper;
lock (this._pausedTriggers)
{
if (this._pausedTriggers.Contains(trigger.Name) || this._pausedJobs.Contains(trigger.JobName))
{
wrapper.State = InternalTriggerState.Paused;
if (this._blockedJobs.Contains(trigger.JobName))
{
wrapper.State = InternalTriggerState.PausedAndBlocked;
}
}
else if (this._blockedJobs.Contains(trigger.JobName))
{
wrapper.State = InternalTriggerState.Blocked;
}
else
{
this._timeTriggers.Add(wrapper);
}
}
}
}
public TriggerFiredBundle TriggerFired(Trigger trigger)
{
lock (this._triggerLock)
{
TriggerWrapper wrapper = this._triggersDictionary[trigger.Name] as TriggerWrapper;
if ((wrapper == null) || (wrapper.Trigger == null))
{
return(null);
}
if (wrapper.State == InternalTriggerState.Complete)
{
return(null);
}
if (wrapper.State == InternalTriggerState.Paused)
{
return(null);
}
if (wrapper.State == InternalTriggerState.Blocked)
{
return(null);
}
if (wrapper.State == InternalTriggerState.PausedAndBlocked)
{
return(null);
}
DateTime?previousFireTimeUtc = trigger.GetPreviousFireTimeUtc();
this._timeTriggers.Remove(wrapper);
trigger.Triggered();
wrapper.State = InternalTriggerState.Waiting;
TriggerFiredBundle bundle = new TriggerFiredBundle(this.RetrieveJob(trigger.JobName), trigger, false, new DateTime?(DateTime.UtcNow), trigger.GetPreviousFireTimeUtc(), previousFireTimeUtc, trigger.GetNextFireTimeUtc());
if (wrapper.Trigger.GetNextFireTimeUtc().HasValue)
{
lock (this._triggerLock)
{
this._timeTriggers.Add(wrapper);
}
}
return(bundle);
}
}
public bool RemoveTrigger(string triggerName, bool deleteOrphanedJob)
{
bool found;
lock (_triggerLock)
{
// remove from triggers
object tempObject;
tempObject = _triggersDictionary[triggerName];
_triggersDictionary.Remove(triggerName);
found = (tempObject == null) ? false : true;
if (found)
{
TriggerWrapper tw = null;
// remove from triggers array
for (int i = 0; i < _triggers.Count; ++i)
{
tw = _triggers[i] as TriggerWrapper;
if (triggerName.Equals(tw.Name))
{
_triggers.RemoveAt(i);
break;
}
}
_timeTriggers.Remove(tw);
JobWrapper jw = _jobsDictionary[tw.Trigger.JobName] as JobWrapper;
Trigger[] triggers = GetTriggersForJob(tw.Trigger.JobName);
if ((triggers == null || triggers.Length == 0) && deleteOrphanedJob)
{
RemoveJob(tw.Trigger.JobName);
}
}
}
return(found);
}
protected bool ApplyMisfire(TriggerWrapper tw)
{
DateTime misfireTime = DateTime.UtcNow;
if (MisfireThreshold > 0)
{
misfireTime = misfireTime.AddMilliseconds(-1 * MisfireThreshold);
}
NullableDateTime tnft = tw.Trigger.GetNextFireTimeUtc();
if (!tnft.HasValue || tnft.Value > misfireTime)
return false;
tw.Trigger.UpdateAfterMisfire();
if (!tw.Trigger.GetNextFireTimeUtc().HasValue)
{
tw.State = InternalTriggerState.Complete;
lock (_triggerLock)
{
_timeTriggers.Remove(tw);
}
}
else if (tnft.Equals(tw.Trigger.GetNextFireTimeUtc()))
{
return false;
}
return true;
}
public void StoreTrigger(Trigger trigger, bool replaceExisting)
{
TriggerWrapper tw = new TriggerWrapper(trigger);
lock(_triggerLock)
{
if (_triggersDictionary.Contains(tw.Name))
{
if (!replaceExisting)
{
throw new NotSupportedException("Object already exists " + trigger.Name);
}
// don't delete orphaned job, this trigger has the job anyways
RemoveTrigger(trigger.Name, false);
}
if (RetrieveJob(trigger.JobName) == null)
{
throw new ApplicationException("The job (" + trigger.JobName + ") referenced by the trigger does not exist.");
}
// add to triggers array
_triggers.Add(tw);
_triggersDictionary[tw.Name] = tw;
lock (_pausedTriggers)
{
if (_pausedTriggers.Contains(trigger.Name) || _pausedJobs.Contains(trigger.JobName))
{
tw.State = InternalTriggerState.Paused;
if (_blockedJobs.Contains(trigger.JobName))
{
tw.State = InternalTriggerState.PausedAndBlocked;
}
}
else if (_blockedJobs.Contains(trigger.JobName))
{
tw.State = InternalTriggerState.Blocked;
}
else
{
_timeTriggers.Add(tw);
}
}
}
}
