private void SetAllTriggersOfJobToState(string jobName, InternalTriggerState state)
{
ArrayList tws = GetTriggerWrappersForJob(jobName);
foreach (TriggerWrapper tw in tws)
{
tw.State = state;
if (state != InternalTriggerState.Waiting)
{
_timeTriggers.Remove(tw);
}
}
}
private void SetAllTriggersOfJobToState(string jobName, InternalTriggerState state)
{
ArrayList triggerWrappersForJob = this.GetTriggerWrappersForJob(jobName);
foreach (TriggerWrapper wrapper in triggerWrappersForJob)
{
wrapper.State = state;
if (state != InternalTriggerState.Waiting)
{
this._timeTriggers.Remove(wrapper);
}
}
}
protected virtual async Task SetAllTriggersOfJobToState(JobKey jobKey, InternalTriggerState state,
CancellationToken cancellationToken)
{
using var session = Store.OpenAsyncSession();
var triggers = session.Query <Trigger>()
.Where(t => Equals(t.Group, jobKey.Group) && Equals(t.JobName, jobKey.Name));
foreach (var trig in triggers)
{
var triggerToUpdate = await session.LoadAsync <Trigger>(trig.Key, cancellationToken);
triggerToUpdate.State = state;
}
await session.SaveChangesAsync(cancellationToken);
}
private void SetAllTriggersOfJobToState(string jobName, InternalTriggerState state)
{
ArrayList tws = GetTriggerWrappersForJob(jobName);
foreach (TriggerWrapper tw in tws)
{
tw.State = state;
if (state != InternalTriggerState.Waiting)
{
_timeTriggers.Remove(tw);
}
}
}
/// <summary>
/// Sets the state of all triggers of job to specified state.
/// </summary>
/// <param name="jobName">Name of the job.</param>
/// <param name="jobGroup">The job group.</param>
/// <param name="state">The internal state to set.</param>
protected internal virtual void SetAllTriggersOfJobToState(string jobName, string jobGroup, InternalTriggerState state)
{
ArrayList tws = GetTriggerWrappersForJob(jobName, jobGroup);
foreach (TriggerWrapper tw in tws)
{
tw.state = state;
if (state != InternalTriggerState.Waiting)
{
timeTriggers.Remove(tw);
}
}
}
public TriggerInfo(TriggerKey id, InternalTriggerState state, IOperableTrigger trigger)
{
Id = id;
State = state;
Trigger = trigger;
}
/// <summary>
/// Update the given trigger to the given new state, if it is in the given
/// old state.
/// </summary>
/// <param name="triggerKey">the key of the trigger</param>
/// <param name="newState">the new state for the trigger</param>
/// <param name="oldState">the old state the trigger must be in</param>
/// <returns>
/// int the number of rows updated
/// </returns>
private void UpdateTriggerStateFromOtherState(TriggerKey triggerKey, InternalTriggerState newState, InternalTriggerState oldState)
{
var query = Query.ElemMatch("Triggers", Query.And(Query.EQ("_id", triggerKey.ToBsonDocument()), Query.EQ("State", oldState)));
var update = Update.Set("Triggers.$.State", newState);
JobCollection.Update(query, update);
}
private void UpdateTriggerState(TriggerKey triggerKey, InternalTriggerState newState)
{
var id = triggerKey.ToBsonDocument();
var query = Query.ElemMatch("Triggers", Query.EQ("_id", id));
var update = Update.Set("Triggers.$.State", newState);
JobCollection.Update(query, update);
}
private void UpdateTriggerGroupStateFromOtherStates(GroupMatcher<TriggerKey> matcher, InternalTriggerState newState, params InternalTriggerState[] oldStates)
{
var values = oldStates.Select(x => BsonValue.Create(x)).ToArray();
var query = Query.ElemMatch("Triggers", Query.And(GetTriggerGroupMatcherQuery(matcher), Query.In("State", values)));
var update = Update.Set("Triggers.$.State", newState);
JobCollection.Update(query, update, UpdateFlags.Multi);
}
private void DoUpdateOfMisfiredTrigger(IOperableTrigger trig, bool forceState, InternalTriggerState newStateIfNotComplete, bool recovering)
{
ICalendar cal = null;
if (trig.CalendarName != null)
{
cal = RetrieveCalendar(trig.CalendarName);
}
signaler.NotifyTriggerListenersMisfired(trig);
trig.UpdateAfterMisfire(cal);
// TODO: Decide if we need to replace the whole trigger or could just update the status and next-fire-time
if (!trig.GetNextFireTimeUtc().HasValue)
{
StoreTrigger(trig, null, true, InternalTriggerState.Complete, forceState, recovering);
}
else
{
StoreTrigger(trig, null, true, newStateIfNotComplete, forceState, false);
}
}
/// <summary>
/// Determines if a Trigger for the given job should be blocked.
/// State can only transition to StatePausedBlocked/StateBlocked from
/// StatePaused/StateWaiting respectively.
/// </summary>
/// <returns>StatePausedBlocked, StateBlocked, or the currentState. </returns>
private InternalTriggerState CheckBlockedState(JobKey jobKey, InternalTriggerState currentState)
{
// State can only transition to BLOCKED from PAUSED or WAITING.
if ((currentState.Equals(InternalTriggerState.Waiting) == false) && (currentState.Equals(InternalTriggerState.Paused) == false))
{
return currentState;
}
try
{
IList<FiredTriggerRecord> lst = SelectFiredTriggerRecordsByJob(jobKey.Name, jobKey.Group);
if (lst.Count > 0)
{
FiredTriggerRecord rec = lst[0];
if (rec.JobDisallowsConcurrentExecution) // TODO: worry about failed/recovering/volatile job states?
{
return (currentState == InternalTriggerState.Paused) ? InternalTriggerState.PausedAndBlocked : InternalTriggerState.Blocked;
}
}
return currentState;
}
catch (Exception e)
{
throw new JobPersistenceException("Couldn't determine if trigger should be in a blocked state '" + jobKey + "': " + e.Message, e);
}
}
protected virtual bool UpdateMisfiredTrigger(TriggerKey triggerKey, InternalTriggerState newStateIfNotComplete, bool forceState)
{
try
{
IOperableTrigger trig = RetrieveTrigger(triggerKey);
DateTimeOffset misfireTime = SystemTime.UtcNow();
if (MisfireThreshold > TimeSpan.Zero)
{
misfireTime = misfireTime.AddMilliseconds(-1 * MisfireThreshold.TotalMilliseconds);
}
if (trig.GetNextFireTimeUtc().Value > misfireTime)
{
return false;
}
DoUpdateOfMisfiredTrigger(trig, forceState, newStateIfNotComplete, false);
signaler.NotifySchedulerListenersFinalized(trig);
return true;
}
catch (Exception e)
{
throw new JobPersistenceException(
string.Format("Couldn't update misfired trigger '{0}': {1}", triggerKey, e.Message), e);
}
}
protected virtual void StoreTrigger(IOperableTrigger newTrigger, IJobDetail job, bool replaceExisting, InternalTriggerState state, bool forceState, bool recovering)
{
bool existingTrigger = CheckExists(newTrigger.Key);
if ((existingTrigger) && (!replaceExisting))
{
throw new ObjectAlreadyExistsException(newTrigger);
}
try
{
if (!forceState)
{
bool shouldBepaused = IsTriggerGroupPaused(newTrigger.Key.Group);
if (!shouldBepaused)
{
shouldBepaused = IsTriggerGroupPaused(AllGroupsPaused);
if (shouldBepaused)
{
InsertPausedTriggerGroup(newTrigger.Key.Group);
}
}
if (shouldBepaused && (state.Equals(InternalTriggerState.Waiting) || state.Equals(InternalTriggerState.Acquired)))
{
state = InternalTriggerState.Paused;
}
}
if (job == null)
{
var jobId = newTrigger.JobKey.ToBsonDocument();
var jobInfo = JobCollection.FindOneById(jobId);
job = jobInfo.Job;
}
if (job == null)
{
throw new JobPersistenceException("The job (" + newTrigger.JobKey + ") referenced by the trigger does not exist.");
}
if (job.ConcurrentExectionDisallowed && !recovering)
{
state = CheckBlockedState(job.Key, state);
}
var triggerInfo = new TriggerInfo(newTrigger.Key, state, newTrigger);
if (existingTrigger)
{
var id = job.Key.ToBsonDocument();
var query = Query.And(Query.EQ("_id", id), Query.EQ("Triggers._id", newTrigger.Key.ToBsonDocument()));
var update = Update.Set("Triggers.$", triggerInfo.ToBsonDocument());
JobCollection.Update(query, update);
}
else
{
var id = job.Key.ToBsonDocument();
var query = Query.EQ("_id", id);
var update = Update.Push("Triggers", triggerInfo.ToBsonDocument()).Inc("TriggerCount", 1);
JobCollection.Update(query, update);
}
}
catch (Exception ex)
{
// throw new ObjectAlreadyExistsException(newJob)
string message = String.Format("Couldn't store trigger '{0}' for '{1}' job: {2}", newTrigger.Key, newTrigger.JobKey, ex.Message);
throw new JobPersistenceException(message, ex);
}
}
