public void TriggerComplete(Trigger trigger, JobExecutionContext context, SchedulerInstruction triggerInstructionCode) { if (!trigger.Name.Equals("TimerTrigger")) { Account account = (Account)trigger.JobDataMap.Get("account"); if (account != null) { SimpleTrigger triggerObject = new SimpleTrigger(account.Login + "Trigger", "account", DateTime.MinValue, null, 0, TimeSpan.Zero); triggerObject.JobName = account.Login + "Job"; triggerObject.StartTimeUtc = DateTime.UtcNow.AddSeconds(new Random().Next(account.Settings.NextTimeLoginMin, account.Settings.NextTimeLoginMax)); account.SchedulerTrigger = triggerObject; triggerObject.JobDataMap.Add("account", account); m_accountManager.SetNextLoginTimeForAccount(account); } } }
protected void btnOk_Click(object sender, EventArgs e) { try { SchedulableRpt rpt = SchedulableRpt.GetSchedulableRptByRptName(this.ReportType); int existTriggerCount = rpt.GetTriggerCount(this.UserID, this.SelectedFrequency); int maxTriggerCount; Quartz.Trigger trigger = this.GetTrigger(out maxTriggerCount); if (existTriggerCount >= maxTriggerCount) { this.ShowMessage(existTriggerCount + " " + this.SelectedFrequency + " schedule setted. No more allowed."); } else { rpt.AddToScheduler( trigger, this.UserID, this.SelectedFrequency, this.Parameters, this.Availability, this.PastType, this.PastUnit, this.ckbMonitor.Checked, this.CheckTriggerID); this.RadGrid2.Rebind(); this.ShowMessage("Report schedule trigger set successful"); } } catch (Exception ex) { this.ShowMessage("Add trigger error! \r\n => " + ex.Message); } }
/// <summary> /// Add the given trigger to the Scheduler, if it doesn't already exist. /// Overwrites the trigger in any case if "overwriteExistingJobs" is set. /// </summary> /// <param name="trigger">the trigger to add</param> /// <returns><code>true</code> if the trigger was actually added, <code>false</code> if it already existed before</returns> private bool AddTriggerToScheduler(Trigger trigger) { bool triggerExists = (GetScheduler().GetTrigger(trigger.Name, trigger.Group) != null); if (!triggerExists || this.overwriteExistingJobs) { // Check if the Trigger is aware of an associated JobDetail. if (trigger is IJobDetailAwareTrigger) { JobDetail jobDetail = ((IJobDetailAwareTrigger) trigger).JobDetail; // Automatically register the JobDetail too. if (!jobDetails.Contains(jobDetail) && AddJobToScheduler(jobDetail)) { jobDetails.Add(jobDetail); } } if (!triggerExists) { try { GetScheduler().ScheduleJob(trigger); } catch (ObjectAlreadyExistsException ex) { if (logger.IsDebugEnabled) { logger.Debug( "Unexpectedly found existing trigger, assumably due to cluster race condition: " + ex.Message + " - can safely be ignored"); } if (overwriteExistingJobs) { GetScheduler().RescheduleJob(trigger.Name, trigger.Group, trigger); } } } else { GetScheduler().RescheduleJob(trigger.Name, trigger.Group, trigger); } return true; } else { return false; } }
public TimeTriggerCommandArgs(string jobName, Trigger timeTrigger, Action action) { this.ActionName = jobName; this.TimeTrigger = timeTrigger; this.Action = action; }
/// <summary> /// Returns a list of Dates that are the next fire times of a /// <see cref="Trigger" />. /// The input trigger will be cloned before any work is done, so you need /// not worry about its state being altered by this method. /// </summary> /// <param name="trigg">The trigger upon which to do the work</param> /// <param name="cal">The calendar to apply to the trigger's schedule</param> /// <param name="numTimes">The number of next fire times to produce</param> /// <returns>List of java.util.Date objects</returns> public static IList ComputeFireTimes(Trigger trigg, ICalendar cal, int numTimes) { ArrayList lst = new ArrayList(); Trigger t = (Trigger) trigg.Clone(); if (t.GetNextFireTimeUtc() == null || !t.GetNextFireTimeUtc().HasValue) { t.ComputeFirstFireTimeUtc(cal); } for (int i = 0; i < numTimes; i++) { NullableDateTime d = t.GetNextFireTimeUtc(); if (d.HasValue) { lst.Add(d); t.Triggered(cal); } else { break; } } return ArrayList.ReadOnly(new ArrayList(lst)); }
/// <summary> /// Set the given <see cref="Trigger" />'s name to the given value, and its /// group to the default group (<see cref="SchedulerConstants.DefaultGroup" />). /// </summary> /// <param name="trig">the tigger to change name to</param> /// <param name="name">the new trigger name</param> public static void SetTriggerIdentity(Trigger trig, string name) { SetTriggerIdentity(trig, name, SchedulerConstants.DefaultGroup); }
/// <summary> /// Schedule the given <see cref="Trigger" /> with the /// <see cref="IJob" /> identified by the <see cref="Trigger" />'s settings. /// </summary> public virtual DateTime ScheduleJob(SchedulingContext ctxt, Trigger trigger) { ValidateState(); if (trigger == null) { throw new SchedulerException("Trigger cannot be null", SchedulerException.ErrorClientError); } trigger.Validate(); ICalendar cal = null; if (trigger.CalendarName != null) { cal = resources.JobStore.RetrieveCalendar(ctxt, trigger.CalendarName); if (cal == null) { throw new SchedulerException(string.Format(CultureInfo.InvariantCulture, "Calendar not found: {0}", trigger.CalendarName), SchedulerException.ErrorPersistenceCalendarDoesNotExist); } } NullableDateTime ft = trigger.ComputeFirstFireTimeUtc(cal); if (!ft.HasValue) { throw new SchedulerException("Based on configured schedule, the given trigger will never fire.", SchedulerException.ErrorClientError); } resources.JobStore.StoreTrigger(ctxt, trigger, false); NotifySchedulerThread(trigger.GetNextFireTimeUtc()); NotifySchedulerListenersScheduled(trigger); return ft.Value; }
/// <summary> /// Notifies the scheduler listeners about finalized trigger. /// </summary> /// <param name="trigger">The trigger.</param> public virtual void NotifySchedulerListenersFinalized(Trigger trigger) { // build a list of all scheduler listeners that are to be notified... IList schedListeners = SchedulerListeners; // notify all scheduler listeners foreach (ISchedulerListener sl in schedListeners) { try { sl.TriggerFinalized(trigger); } catch (Exception e) { Log.Error(string.Format(CultureInfo.InvariantCulture, "Error while notifying SchedulerListener of finalized trigger. Triger={0}", trigger.FullName), e); } } }
/// <summary> /// Notifies the job store job complete. /// </summary> /// <param name="ctxt">The job scheduling context.</param> /// <param name="trigger">The trigger.</param> /// <param name="detail">The detail.</param> /// <param name="instCode">The instruction code.</param> protected internal virtual void NotifyJobStoreJobComplete(SchedulingContext ctxt, Trigger trigger, JobDetail detail, SchedulerInstruction instCode) { resources.JobStore.TriggeredJobComplete(ctxt, trigger, detail, instCode); }
protected virtual void ReleaseAcquiredTrigger(ConnectionAndTransactionHolder conn, SchedulingContext ctxt, Trigger trigger) { try { Delegate.UpdateTriggerStateFromOtherState(conn, trigger.Name, trigger.Group, StateWaiting, StateAcquired); Delegate.DeleteFiredTrigger(conn, trigger.FireInstanceId); } catch (Exception e) { throw new JobPersistenceException("Couldn't release acquired trigger: " + e.Message, e); } }
/// <summary> /// Inform the <see cref="IJobStore" /> that the scheduler no longer plans to /// fire the given <see cref="Trigger" />, that it had previously acquired /// (reserved). /// </summary> public void ReleaseAcquiredTrigger(SchedulingContext ctxt, Trigger trigger) { ExecuteInNonManagedTXLock(LockTriggerAccess, new ReleaseAcquiredTriggerCallback(this, ctxt, trigger)); }
protected virtual bool ReplaceTrigger(ConnectionAndTransactionHolder conn, SchedulingContext ctxt, string triggerName, string groupName, Trigger newTrigger) { try { // this must be called before we delete the trigger, obviously JobDetail job = Delegate.SelectJobForTrigger(conn, triggerName, groupName, TypeLoadHelper); if (job == null) { return false; } if (!newTrigger.JobName.Equals(job.Name) || !newTrigger.JobGroup.Equals(job.Group)) { throw new JobPersistenceException("New trigger is not related to the same job as the old trigger."); } bool removedTrigger = DeleteTriggerAndChildren(conn, triggerName, groupName); StoreTrigger(conn, ctxt, newTrigger, job, false, StateWaiting, false, false); return removedTrigger; } catch (Exception e) { throw new JobPersistenceException("Couldn't remove trigger: " + e.Message, e); } }
public ReplaceTriggerCallback(JobStoreSupport js, SchedulingContext ctxt, string triggerName, string groupName, Trigger newTrigger) : base(js) { this.ctxt = ctxt; this.triggerName = triggerName; this.groupName = groupName; this.newTrigger = newTrigger; }
/// <see cref="IJobStore.ReplaceTrigger(SchedulingContext, string, string, Trigger)" /> public bool ReplaceTrigger(SchedulingContext ctxt, string triggerName, string groupName, Trigger newTrigger) { return (bool) ExecuteInLock(LockTriggerAccess, new ReplaceTriggerCallback(this, ctxt, triggerName, groupName, newTrigger)); }
/// <summary> /// Insert or update a trigger. /// </summary> protected virtual void StoreTrigger(ConnectionAndTransactionHolder conn, SchedulingContext ctxt, Trigger newTrigger, JobDetail job, bool replaceExisting, string state, bool forceState, bool recovering) { if (newTrigger.Volatile && Clustered) { Log.Info("note: volatile triggers are effectively non-volatile in a clustered environment."); } bool existingTrigger = TriggerExists(conn, newTrigger.Name, newTrigger.Group); if ((existingTrigger) && (!replaceExisting)) { throw new ObjectAlreadyExistsException(newTrigger); } try { if (!forceState) { bool shouldBepaused = Delegate.IsTriggerGroupPaused(conn, newTrigger.Group); if (!shouldBepaused) { shouldBepaused = Delegate.IsTriggerGroupPaused(conn, AllGroupsPaused); if (shouldBepaused) { Delegate.InsertPausedTriggerGroup(conn, newTrigger.Group); } } if (shouldBepaused && (state.Equals(StateWaiting) || state.Equals(StateAcquired))) { state = StatePaused; } } if (job == null) { job = Delegate.SelectJobDetail(conn, newTrigger.JobName, newTrigger.JobGroup, TypeLoadHelper); } if (job == null) { throw new JobPersistenceException("The job (" + newTrigger.FullJobName + ") referenced by the trigger does not exist."); } if (job.Volatile && !newTrigger.Volatile) { throw new JobPersistenceException("It does not make sense to " + "associate a non-volatile Trigger with a volatile Job!"); } if (job.Stateful && !recovering) { state = CheckBlockedState(conn, ctxt, job.Name, job.Group, state); } if (existingTrigger) { if (newTrigger is SimpleTrigger && !newTrigger.HasAdditionalProperties) { Delegate.UpdateSimpleTrigger(conn, (SimpleTrigger)newTrigger); } else if (newTrigger is CronTrigger && !newTrigger.HasAdditionalProperties) { Delegate.UpdateCronTrigger(conn, (CronTrigger)newTrigger); } else { Delegate.UpdateBlobTrigger(conn, newTrigger); } Delegate.UpdateTrigger(conn, newTrigger, state, job); } else { Delegate.InsertTrigger(conn, newTrigger, state, job); if (newTrigger is SimpleTrigger && !newTrigger.HasAdditionalProperties) { Delegate.InsertSimpleTrigger(conn, (SimpleTrigger)newTrigger); } else if (newTrigger is CronTrigger && !newTrigger.HasAdditionalProperties) { Delegate.InsertCronTrigger(conn, (CronTrigger)newTrigger); } else { Delegate.InsertBlobTrigger(conn, newTrigger); } } } catch (Exception e) { string message = String.Format("Couldn't store trigger '{0}' for '{1}' job: {2}", newTrigger.Name, newTrigger.JobName, e.Message); throw new JobPersistenceException(message, e); } }
public StoreJobAndTriggerCallback(JobStoreSupport js, JobDetail newJob, Trigger newTrigger, SchedulingContext ctxt) : base(js) { this.newJob = newJob; this.newTrigger = newTrigger; this.ctxt = ctxt; }
public virtual TriggerFiredBundle TriggerFired(SchedulingContext ctxt, Trigger trigger) { return (TriggerFiredBundle) ExecuteInNonManagedTXLock(LockTriggerAccess, new TriggerFiredCallback(this, ctxt, trigger)); }
/// <summary> /// Notifies the trigger listeners about misfired trigger. /// </summary> /// <param name="trigger">The trigger.</param> public virtual void NotifyTriggerListenersMisfired(Trigger trigger) { // build a list of all trigger listeners that are to be notified... IList listeners = BuildTriggerListenerList(trigger.TriggerListenerNames); // notify all trigger listeners in the list foreach (ITriggerListener tl in listeners) { try { tl.TriggerMisfired(trigger); } catch (Exception e) { SchedulerException se = new SchedulerException(string.Format(CultureInfo.InvariantCulture, "TriggerListener '{0}' threw exception: {1}", tl.Name, e.Message), e); se.ErrorCode = SchedulerException.ErrorTriggerListener; throw se; } } }
public TriggerFiredCallback(JobStoreSupport js, SchedulingContext ctxt, Trigger trigger) : base(js) { this.ctxt = ctxt; this.trigger = trigger; }
/// <summary> /// Add the <see cref="IJob" /> identified by the given /// <see cref="JobDetail" /> to the Scheduler, and /// associate the given <see cref="Trigger" /> with it. /// <p> /// If the given Trigger does not reference any <see cref="IJob" />, then it /// will be set to reference the Job passed with it into this method. /// </p> /// </summary> public virtual DateTime ScheduleJob(SchedulingContext ctxt, JobDetail jobDetail, Trigger trigger) { ValidateState(); if (jobDetail == null) { throw new SchedulerException("JobDetail cannot be null", SchedulerException.ErrorClientError); } if (trigger == null) { throw new SchedulerException("Trigger cannot be null", SchedulerException.ErrorClientError); } jobDetail.Validate(); if (trigger.JobName == null) { trigger.JobName = jobDetail.Name; trigger.JobGroup = jobDetail.Group; } else if (trigger.JobName != null && !trigger.JobName.Equals(jobDetail.Name)) { throw new SchedulerException("Trigger does not reference given job!", SchedulerException.ErrorClientError); } else if (trigger.JobGroup != null && !trigger.JobGroup.Equals(jobDetail.Group)) { throw new SchedulerException("Trigger does not reference given job!", SchedulerException.ErrorClientError); } trigger.Validate(); ICalendar cal = null; if (trigger.CalendarName != null) { cal = resources.JobStore.RetrieveCalendar(ctxt, trigger.CalendarName); if (cal == null) { throw new SchedulerException(string.Format(CultureInfo.InvariantCulture, "Calendar not found: {0}", trigger.CalendarName), SchedulerException.ErrorPersistenceCalendarDoesNotExist); } } NullableDateTime ft = trigger.ComputeFirstFireTimeUtc(cal); if (!ft.HasValue) { throw new SchedulerException("Based on configured schedule, the given trigger will never fire.", SchedulerException.ErrorClientError); } resources.JobStore.StoreJobAndTrigger(ctxt, jobDetail, trigger); NotifySchedulerThread(trigger.GetNextFireTimeUtc()); NotifySchedulerListenersScheduled(trigger); return ft.Value; }
protected virtual TriggerFiredBundle TriggerFired(ConnectionAndTransactionHolder conn, SchedulingContext ctxt, Trigger trigger) { JobDetail job; ICalendar cal = null; // Make sure trigger wasn't deleted, paused, or completed... try { // if trigger was deleted, state will be StateDeleted String state = Delegate.SelectTriggerState(conn, trigger.Name, trigger.Group); if (!state.Equals(StateAcquired)) { return null; } } catch (Exception e) { throw new JobPersistenceException("Couldn't select trigger state: " + e.Message, e); } try { job = RetrieveJob(conn, ctxt, trigger.JobName, trigger.JobGroup); if (job == null) { return null; } } catch (JobPersistenceException jpe) { try { Log.Error("Error retrieving job, setting trigger state to ERROR.", jpe); Delegate.UpdateTriggerState(conn, trigger.Name, trigger.Group, StateError); } catch (Exception sqle) { Log.Error("Unable to set trigger state to ERROR.", sqle); } throw; } if (trigger.CalendarName != null) { cal = RetrieveCalendar(conn, ctxt, trigger.CalendarName); if (cal == null) { return null; } } try { Delegate.DeleteFiredTrigger(conn, trigger.FireInstanceId); Delegate.InsertFiredTrigger(conn, trigger, StateExecuting, job); } catch (Exception e) { throw new JobPersistenceException("Couldn't insert fired trigger: " + e.Message, e); } NullableDateTime prevFireTime = trigger.GetPreviousFireTimeUtc(); // call triggered - to update the trigger's next-fire-time state... trigger.Triggered(cal); String state2 = StateWaiting; bool force = true; if (job.Stateful) { state2 = StateBlocked; force = false; try { Delegate.UpdateTriggerStatesForJobFromOtherState(conn, job.Name, job.Group, StateBlocked, StateWaiting); Delegate.UpdateTriggerStatesForJobFromOtherState(conn, job.Name, job.Group, StateBlocked, StateAcquired); Delegate.UpdateTriggerStatesForJobFromOtherState(conn, job.Name, job.Group, StatePausedBlocked, StatePaused); } catch (Exception e) { throw new JobPersistenceException("Couldn't update states of blocked triggers: " + e.Message, e); } } if (!trigger.GetNextFireTimeUtc().HasValue) { state2 = StateComplete; force = true; } StoreTrigger(conn, ctxt, trigger, job, true, state2, force, false); job.JobDataMap.ClearDirtyFlag(); return new TriggerFiredBundle( job, trigger, cal, trigger.Group.Equals(SchedulerConstants.DefaultRecoveryGroup), DateTime.UtcNow, trigger.GetPreviousFireTimeUtc(), prevFireTime, trigger.GetNextFireTimeUtc()); }
/// <summary> /// Remove (delete) the <see cref="Trigger" /> with the /// given name, and store the new given one - which must be associated /// with the same job. /// </summary> /// <param name="ctxt">The scheduling context.</param> /// <param name="triggerName">The name of the <see cref="Trigger" /> to be removed.</param> /// <param name="groupName">The group name of the <see cref="Trigger" /> to be removed.</param> /// <param name="newTrigger">The new <see cref="Trigger" /> to be stored.</param> /// <returns> /// <see langword="null" /> if a <see cref="Trigger" /> with the given /// name and group was not found and removed from the store, otherwise /// the first fire time of the newly scheduled trigger. /// </returns> public virtual NullableDateTime RescheduleJob(SchedulingContext ctxt, string triggerName, string groupName, Trigger newTrigger) { ValidateState(); if (groupName == null) { groupName = SchedulerConstants.DefaultGroup; } newTrigger.Validate(); ICalendar cal = null; if (newTrigger.CalendarName != null) { cal = resources.JobStore.RetrieveCalendar(ctxt, newTrigger.CalendarName); } NullableDateTime ft = newTrigger.ComputeFirstFireTimeUtc(cal); if (!ft.HasValue) { throw new SchedulerException("Based on configured schedule, the given trigger will never fire.", SchedulerException.ErrorClientError); } if (resources.JobStore.ReplaceTrigger(ctxt, triggerName, groupName, newTrigger)) { NotifySchedulerThread(newTrigger.GetNextFireTimeUtc()); NotifySchedulerListenersUnscheduled(triggerName, groupName); NotifySchedulerListenersScheduled(newTrigger); } else { return null; } return ft; }
/// <summary> /// Inform the <see cref="IJobStore" /> that the scheduler has completed the /// firing of the given <see cref="Trigger" /> (and the execution its /// associated <see cref="IJob" />), and that the <see cref="JobDataMap" /> /// in the given <see cref="JobDetail" /> should be updated if the <see cref="IJob" /> /// is stateful. /// </summary> public virtual void TriggeredJobComplete(SchedulingContext ctxt, Trigger trigger, JobDetail jobDetail, SchedulerInstruction triggerInstCode) { ExecuteInNonManagedTXLock(LockTriggerAccess, new TriggeredJobCompleteCallback(this, ctxt, trigger, triggerInstCode, jobDetail)); }
/// <summary> /// Set the given <see cref="Trigger" />'s name to the given value, and its /// group to the given group. /// </summary> /// <param name="trig">the tigger to change name to</param> /// <param name="name">the new trigger name</param> /// <param name="group">the new trigger group</param> public static void SetTriggerIdentity(Trigger trig, string name, string group) { trig.Name = name; trig.Group = group; }
public TriggeredJobCompleteCallback(JobStoreSupport js, SchedulingContext ctxt, Trigger trigger, SchedulerInstruction triggerInstCode, JobDetail jobDetail) : base(js) { this.ctxt = ctxt; this.trigger = trigger; this.triggerInstCode = triggerInstCode; this.jobDetail = jobDetail; }
/// <summary> /// Returns a list of Dates that are the next fire times of a <see cref="Trigger" /> /// that fall within the given date range. The input trigger will be cloned /// before any work is done, so you need not worry about its state being /// altered by this method. /// <p> /// NOTE: if this is a trigger that has previously fired within the given /// date range, then firings which have already occured will not be listed /// in the output List. /// </p> /// </summary> /// <param name="trigg">The trigger upon which to do the work</param> /// <param name="cal">The calendar to apply to the trigger's schedule</param> /// <param name="from">The starting date at which to find fire times</param> /// <param name="to">The ending date at which to stop finding fire times</param> /// <returns>List of java.util.Date objects</returns> public static IList ComputeFireTimesBetween(Trigger trigg, ICalendar cal, DateTime from, DateTime to) { ArrayList lst = new ArrayList(); Trigger t = (Trigger) trigg.Clone(); if (t.GetNextFireTimeUtc() == null || !t.GetNextFireTimeUtc().HasValue) { t.StartTimeUtc = from; t.EndTimeUtc = to; t.ComputeFirstFireTimeUtc(cal); } // TODO: this method could be more efficient by using logic specific // to the type of trigger ... while (true) { NullableDateTime d = t.GetNextFireTimeUtc(); if (d.HasValue) { if (d.Value < from) { t.Triggered(cal); continue; } if (d.Value > to) { break; } lst.Add(d); t.Triggered(cal); } else { break; } } return ArrayList.ReadOnly(new ArrayList(lst)); }
protected virtual void TriggeredJobComplete(ConnectionAndTransactionHolder conn, SchedulingContext ctxt, Trigger trigger, JobDetail jobDetail, SchedulerInstruction triggerInstCode) { try { if (triggerInstCode == SchedulerInstruction.DeleteTrigger) { if (!trigger.GetNextFireTimeUtc().HasValue) { // double check for possible reschedule within job // execution, which would cancel the need to delete... TriggerStatus stat = Delegate.SelectTriggerStatus(conn, trigger.Name, trigger.Group); if (stat != null && !stat.NextFireTimeUtc.HasValue) { RemoveTrigger(conn, ctxt, trigger.Name, trigger.Group); } } else { RemoveTrigger(conn, ctxt, trigger.Name, trigger.Group); signaler.SignalSchedulingChange(null); } } else if (triggerInstCode == SchedulerInstruction.SetTriggerComplete) { Delegate.UpdateTriggerState(conn, trigger.Name, trigger.Group, StateComplete); signaler.SignalSchedulingChange(null); } else if (triggerInstCode == SchedulerInstruction.SetTriggerError) { Log.Info("Trigger " + trigger.FullName + " set to ERROR state."); Delegate.UpdateTriggerState(conn, trigger.Name, trigger.Group, StateError); signaler.SignalSchedulingChange(null); } else if (triggerInstCode == SchedulerInstruction.SetAllJobTriggersComplete) { Delegate.UpdateTriggerStatesForJob(conn, trigger.JobName, trigger.JobGroup, StateComplete); signaler.SignalSchedulingChange(null); } else if (triggerInstCode == SchedulerInstruction.SetAllJobTriggersError) { Log.Info("All triggers of Job " + trigger.FullJobName + " set to ERROR state."); Delegate.UpdateTriggerStatesForJob(conn, trigger.JobName, trigger.JobGroup, StateError); signaler.SignalSchedulingChange(null); } if (jobDetail.Stateful) { Delegate.UpdateTriggerStatesForJobFromOtherState(conn, jobDetail.Name, jobDetail.Group, StateWaiting, StateBlocked); Delegate.UpdateTriggerStatesForJobFromOtherState(conn, jobDetail.Name, jobDetail.Group, StatePaused, StatePausedBlocked); signaler.SignalSchedulingChange(null); try { if (jobDetail.JobDataMap.Dirty) { Delegate.UpdateJobData(conn, jobDetail); } } catch (IOException e) { throw new JobPersistenceException("Couldn't serialize job data: " + e.Message, e); } catch (Exception e) { throw new JobPersistenceException("Couldn't update job data: " + e.Message, e); } } } catch (Exception e) { throw new JobPersistenceException("Couldn't update trigger state(s): " + e.Message, e); } try { Delegate.DeleteFiredTrigger(conn, trigger.FireInstanceId); } catch (Exception e) { throw new JobPersistenceException("Couldn't delete fired trigger: " + e.Message, e); } }
/// <summary> /// Create a JobExcecutionContext with the given context data. /// </summary> public JobExecutionContext(IScheduler scheduler, TriggerFiredBundle firedBundle, IJob job) { this.scheduler = scheduler; trigger = firedBundle.Trigger; calendar = firedBundle.Calendar; jobDetail = firedBundle.JobDetail; this.job = job; recovering = firedBundle.Recovering; fireTimeUtc = firedBundle.FireTimeUtc; scheduledFireTimeUtc = firedBundle.ScheduledFireTimeUtc; prevFireTimeUtc = firedBundle.PrevFireTimeUtc; nextFireTimeUtc = firedBundle.NextFireTimeUtc; jobDataMap = new JobDataMap(); jobDataMap.PutAll(jobDetail.JobDataMap); jobDataMap.PutAll(trigger.JobDataMap); }
private void DoUpdateOfMisfiredTrigger(ConnectionAndTransactionHolder conn, SchedulingContext ctxt, Trigger trig, bool forceState, string newStateIfNotComplete, bool recovering) { ICalendar cal = null; if (trig.CalendarName != null) { cal = RetrieveCalendar(conn, ctxt, trig.CalendarName); } signaler.NotifyTriggerListenersMisfired(trig); trig.UpdateAfterMisfire(cal); if (!trig.GetNextFireTimeUtc().HasValue) { StoreTrigger(conn, ctxt, trig, null, true, StateComplete, forceState, recovering); } else { StoreTrigger(conn, ctxt, trig, null, true, newStateIfNotComplete, forceState, false); } }
/// <summary> /// Creates a simple fired bundle /// </summary> /// <param name="jobType">Type of job.</param> /// <param name="trigger">Trigger instance</param> /// <returns>Simple TriggerFiredBundle</returns> public static TriggerFiredBundle CreateFiredBundleWithTypedJobDetail(Type jobType, Trigger trigger) { JobDetail jobDetail = new JobDetail("jobName", "jobGroup", jobType); TriggerFiredBundle bundle = new TriggerFiredBundle( jobDetail, trigger, null, false, null, null, null, null); return bundle; }
/// <summary> /// Store the given <see cref="JobDetail" /> and <see cref="Trigger" />. /// </summary> /// <param name="ctxt">SchedulingContext</param> /// <param name="newJob">Job to be stored.</param> /// <param name="newTrigger">Trigger to be stored.</param> public void StoreJobAndTrigger(SchedulingContext ctxt, JobDetail newJob, Trigger newTrigger) { ExecuteInLock((LockOnInsert) ? LockTriggerAccess : null, new StoreJobAndTriggerCallback(this, newJob, newTrigger, ctxt)); }