public string AddScheduledJob(int interval, int repeatCount, IScheduledJob job) { Trigger trigger = new Trigger("Trigger_" + job.Name, null, DateTime.UtcNow, null, repeatCount, (long)interval); this.ScheduleJob(job, trigger); return(job.Name); }
public void StoreJob(IScheduledJob job, bool replaceExisting) { JobWrapper wrapper = new JobWrapper(job); bool flag = false; lock (this._jobLock) { if (this._jobsDictionary[wrapper.Name] != null) { if (!replaceExisting) { throw new ArgumentException("job"); } flag = true; } if (!flag) { this._jobsDictionary[wrapper.Name] = wrapper; } else { JobWrapper wrapper2 = this._jobsDictionary[wrapper.Name] as JobWrapper; wrapper2.Job = wrapper.Job; } } }
public void ScheduleDaily(IScheduledJob scheduledJob, int hour, int minutes) { // define the job and tie it to our HelloJob class IDictionary <string, object> data = new Dictionary <string, object>(); data.Add("scheduledJob", scheduledJob); IJobDetail job = JobBuilder.Create <TemplateJob>() .WithIdentity("schedule:" + scheduledJob.GetType().Name, defaultScheduleGroupName) .UsingJobData(new JobDataMap(data)) .Build(); // Trigger the job to run now, and then repeat every 10 seconds ITrigger trigger = TriggerBuilder.Create() .WithIdentity("trigger:" + scheduledJob.GetType().Name, defaultScheduleGroupName) .StartNow() .WithDailyTimeIntervalSchedule(x => x .OnEveryDay() .StartingDailyAt(TimeOfDay.HourAndMinuteOfDay(hour, minutes)) .EndingDailyAfterCount(1)) .Build(); // Tell quartz to schedule the job using our trigger this.scheduler.ScheduleJob(job, trigger).Wait(); this.tirggers.Add(scheduledJob, trigger.Key); }
public void UnSchedule(IScheduledJob scheduledJob) { if (this.tirggers.ContainsKey(scheduledJob)) { this.scheduler.UnscheduleJob(this.tirggers[scheduledJob]); } }
private static async Task ExecuteJobAsync(string id, IScheduledJob job, ILogger logger, bool tracingEnabled) { Stopwatch sw = tracingEnabled ? new Stopwatch() : null; try { sw?.Start(); await job.ExecuteAsync(); sw?.Stop(); if (tracingEnabled) { logger?.WriteInformation($"Job(Id: {id} , DisplayName: {job.DisplayName})已执行,耗时:{sw.ElapsedMilliseconds} 毫秒。"); } } catch (Exception ex) { sw?.Stop(); logger?.WriteError($"Job(Id: {id} , DisplayName: {job.DisplayName})执行作业时发生错误。", ex); ex.ThrowIfNecessary(); } finally { IDisposable disposable = job as IDisposable; disposable?.Dispose(); } }
private IJobQueueOutputMessage ProcessResult(IScheduledJob job, DateTimeOffset scheduledTime, IQueueOutputMessage result) { //no errors, so just return if (!result.HasError) { return(new JobQueueOutputMessage(result, JobQueuedStatus.Success)); } //this is not an error for the job already existing in the queue if (!JobAlreadyExistsError(result.SendingException)) { return(new JobQueueOutputMessage(result, JobQueuedStatus.Failed)); } var status = DoesJobExist(job.Name, scheduledTime); switch (status) { case QueueStatuses.Processing: return(new JobQueueOutputMessage(result, JobQueuedStatus.AlreadyQueuedProcessing)); case QueueStatuses.Waiting: return(new JobQueueOutputMessage(result, JobQueuedStatus.AlreadyQueuedWaiting)); case QueueStatuses.Processed: return(new JobQueueOutputMessage(result, JobQueuedStatus.AlreadyProcessed)); case QueueStatuses.Error: DeleteJob(job.Name); return(null); default: return(null); //try to re-queue once; if this is second try and this happens again, an error will be returned } }
/// <summary> /// Configure the background scheduler that updates the calendar in the background /// </summary> private static void SetUpBackgroundJob() { if (backgroundUpdateScheduler == null) { ISingularityFactory factory = new SingularityFactory(); backgroundUpdateScheduler = factory.GetSingularity(); } if (backgroundUpdateJob == null) { backgroundUpdateJob = new SimpleJob(scheduledTime => UpdateGoogleCalendar()); } if (scheduledUpdateJob != null) { backgroundUpdateScheduler.StopScheduledJob(scheduledUpdateJob); scheduledUpdateJob = null; backgroundUpdateScheduler.Stop(); } if (_runInMinutes > 0) { var schedule = new EveryXTimeSchedule(TimeSpan.FromMinutes(_runInMinutes)); scheduledUpdateJob = backgroundUpdateScheduler.ScheduleJob(schedule, backgroundUpdateJob, true); } backgroundUpdateScheduler.Start(); }
public void StoreJob(IScheduledJob job, bool replaceExisting) { JobWrapper jobWrapper = new JobWrapper(job); bool replace = false; lock (_jobLock) { if (_jobsDictionary[jobWrapper.Name] != null) { if (!replaceExisting) { throw new ArgumentException("job"); } replace = true; } if (!replace) { _jobsDictionary[jobWrapper.Name] = jobWrapper; } else { // update job detail JobWrapper orig = _jobsDictionary[jobWrapper.Name] as JobWrapper; orig.Job = jobWrapper.Job; } } }
public bool AddOrUpdate(IScheduledJob job) { var name = job.GetType().Name; var options = _optionsMonitor.Get(name); return(AddJob(name, job, options)); }
public void Schedule <T>(IScheduledJob <T> job, DateTimeOffset nextTime) where T : IJob { _statusMonitor.MarkScheduled <T>(nextTime); _timer.Schedule(typeof(T), nextTime, () => job.Execute(this)); _logger.InfoMessage(() => new ScheduledJobScheduled(typeof(T), nextTime)); }
public void Schedule(IScheduledJob scheduledJob, int everySeconds) { // define the job and tie it to our HelloJob class IDictionary <string, object> data = new Dictionary <string, object>(); data.Add("scheduledJob", scheduledJob); IJobDetail job = JobBuilder.Create <TemplateJob>() .WithIdentity("schedule:" + scheduledJob.GetType().Name, defaultScheduleGroupName) .UsingJobData(new JobDataMap(data)) .Build(); // Trigger the job to run now, and then repeat every 10 seconds ITrigger trigger = TriggerBuilder.Create() .WithIdentity("trigger:" + scheduledJob.GetType().Name, defaultScheduleGroupName) .StartNow() .WithSimpleSchedule(x => x .WithIntervalInSeconds(everySeconds) .RepeatForever()) .Build(); // Tell quartz to schedule the job using our trigger this.scheduler.ScheduleJob(job, trigger).Wait(); this.tirggers.Add(scheduledJob, trigger.Key); }
public string AddScheduledOnceJob(DateTime date, IScheduledJob job) { Trigger trigger = new Trigger("Trigger_" + job.Name, null, date); ScheduleJob(job, trigger); return(job.Name); }
public string AddScheduledOnceJob(long timeDelta, IScheduledJob job) { DateTime startUtc = DateTime.UtcNow; startUtc = startUtc.AddMilliseconds(timeDelta); return(AddScheduledOnceJob(startUtc, job)); }
public bool StopScheduledJob(IScheduledJob scheduledJob) { ScheduledJob job = (ScheduledJob)scheduledJob; job.PreventReschedule = true; return(_scheduledQueue.FindExtract(job)); }
public string AddScheduledJob(int interval, int repeatCount, IScheduledJob job) { // Create trigger that fires indefinitely every <interval> milliseconds Trigger trigger = new Trigger("Trigger_" + job.Name, null, DateTime.UtcNow, null, repeatCount, interval); ScheduleJob(job, trigger); return(job.Name); }
public ScheduledJobRunner(T job, IScheduleStatusMonitor monitor, IScheduledJob <T> scheduledJob, Envelope envelope) { _job = job; _monitor = monitor; _scheduledJob = scheduledJob; _envelope = envelope; }
/// <inheritdoc /> public async Task <IJobQueueOutputMessage> SendAsync(IScheduledJob job, DateTimeOffset scheduledTime, LinqExpressionToRun linqExpression) { if (!_started) { throw new DotNetWorkQueueException("Start must be called before sending jobs"); } return(await _sendJobToQueue.SendAsync(job, scheduledTime, linqExpression).ConfigureAwait(false)); }
/// <summary> /// Sends the specified dynamic linqExpression to be executed. /// </summary> /// <param name="job">The job.</param> /// <param name="scheduledTime">The scheduled time.</param> /// <param name="linqExpression">The linqExpression to execute.</param> /// <returns></returns> public async Task <IJobQueueOutputMessage> SendAsync(IScheduledJob job, DateTimeOffset scheduledTime, LinqExpressionToRun linqExpression) { using (var scope = _tracer.StartActivity("SendJobAsync")) { scope?.SetTag("JobName", job.Name); return(await _handler.SendAsync(job, scheduledTime, linqExpression)); } }
public ScheduledComponent(EntityId entityId, IScheduledJob job) : base(entityId) { Condition.Requires(job, nameof(job)).IsNotNull(); NextChangeTime = DateTime.Now; Job = job; }
/// <inheritdoc /> public async Task <IJobQueueOutputMessage> SendAsync(IScheduledJob job, DateTimeOffset scheduledTime, Expression <Action <IReceivedMessage <MessageExpression>, IWorkerNotification> > method, bool rawExpression = false) { using (IScope scope = _tracer.BuildSpan("SendJobAsync").StartActive(finishSpanOnDispose: true)) { scope.Span.SetTag("JobName", job.Name); return(await _handler.SendAsync(job, scheduledTime, method, rawExpression)); } }
/// <summary> /// Sends the specified dynamic linqExpression to be executed. /// </summary> /// <param name="job">The job.</param> /// <param name="scheduledTime">The scheduled time.</param> /// <param name="linqExpression">The linqExpression to execute.</param> /// <returns></returns> public async Task <IJobQueueOutputMessage> SendAsync(IScheduledJob job, DateTimeOffset scheduledTime, LinqExpressionToRun linqExpression) { using (IScope scope = _tracer.BuildSpan("SendJobAsync").StartActive(finishSpanOnDispose: true)) { scope.Span.SetTag("JobName", job.Name); return(await _handler.SendAsync(job, scheduledTime, linqExpression)); } }
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 SchedulerTaskWrapper( CronExpression cronExpression, IScheduledJob scheduledJob, DateTime nextRunTime) { Schedule = cronExpression; ScheduledJob = scheduledJob; NextRunTime = nextRunTime; }
static Program() { var config = new WorkerConfig() { RunImmediately = true, DataValue = "Passed value" }; // TODO ReadOptionsFromConfig(); ScheduledJob = new ScheduledJob(config, new JobKey("HelloWorldJob")); }
/// <summary> /// /// </summary> /// <param name="job"></param> public void RemoveJob(IScheduledJob job) { if (_scheduled_Jobs.ContainsKey(job.JobId)) { _scheduled_Jobs.Remove(job.JobId); } //Update the configuration for currently scheduled jobs SaveScheduledJobConfig(); }
public QuartzService() { InitializeComponent(); var config = new WorkerConfig() { RunImmediately = true, DataValue = "Passed value", TimeExecute = System.Configuration.ConfigurationManager.AppSettings["TimeExecute"] }; ScheduledJob = new ScheduledJob(config, new JobKey("HelloWorldJob")); }
public QuartzService() { InitializeComponent(); var config = new WorkerConfig() { RunImmediately = true, DataValue = "Passed value" }; ScheduledJob = new ScheduledJob(config, new JobKey("HelloWorldJob")); }
/// <summary> /// /// </summary> /// <param name="job"></param> public void AddJob(IScheduledJob job) { if (!_scheduled_Jobs.ContainsKey(job.JobId)) { _scheduled_Jobs.Add(job.JobId, job); } //Update the configuration for currently scheduled jobs SaveScheduledJobConfig(); }
public TriggerFiredBundle(IScheduledJob job, FluorineFx.Scheduling.Trigger trigger, bool jobIsRecovering, DateTime?fireTimeUtc, DateTime?scheduledFireTimeUtc, DateTime?prevFireTimeUtc, DateTime?nextFireTimeUtc) { this._job = job; this._trigger = trigger; this._jobIsRecovering = jobIsRecovering; this._fireTimeUtc = DateTimeUtils.AssumeUniversalTime(fireTimeUtc); this._scheduledFireTimeUtc = DateTimeUtils.AssumeUniversalTime(scheduledFireTimeUtc); this._prevFireTimeUtc = DateTimeUtils.AssumeUniversalTime(prevFireTimeUtc); this._nextFireTimeUtc = DateTimeUtils.AssumeUniversalTime(nextFireTimeUtc); }
/// <inheritdoc /> public async Task <IJobQueueOutputMessage> SendAsync(IScheduledJob job, DateTimeOffset scheduledTime, Expression <Action <IReceivedMessage <MessageExpression>, IWorkerNotification> > method, bool rawExpression = false) { if (!_started) { throw new DotNetWorkQueueException("Start must be called before sending jobs"); } return(await _sendJobToQueue.SendAsync(job, scheduledTime, method, rawExpression).ConfigureAwait(false)); }
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); } }
/// <summary> /// Initializes a new instance of the <see cref="SchedulerTaskWrapper"/> class. /// </summary> /// <param name="cronExpression"></param> /// <param name="scheduledJob"></param> /// <param name="nextRunTime"></param> /// <param name="timeZoneInfo"></param> public SchedulerTaskWrapper( CronExpression cronExpression, IScheduledJob scheduledJob, DateTimeOffset nextRunTime, TimeZoneInfo timeZoneInfo) { Schedule = cronExpression; ScheduledJob = scheduledJob; NextRunTime = nextRunTime; TimeZoneInfo = timeZoneInfo; }
private IJobQueueOutputMessage ProcessResult(IScheduledJob job, DateTimeOffset scheduledTime, IQueueOutputMessage result) { //no errors, so just return if (!result.HasError) return new JobQueueOutputMessage(result, JobQueuedStatus.Success); //this is not an error for the job already existing in the queue if (!JobAlreadyExistsError(result.SendingException)) return new JobQueueOutputMessage(result, JobQueuedStatus.Failed); var status = DoesJobExist(job.Name, scheduledTime); switch (status) { case QueueStatuses.Processing: return new JobQueueOutputMessage(result, JobQueuedStatus.AlreadyQueuedProcessing); case QueueStatuses.Waiting: return new JobQueueOutputMessage(result, JobQueuedStatus.AlreadyQueuedWaiting); case QueueStatuses.Processed: return new JobQueueOutputMessage(result, JobQueuedStatus.AlreadyProcessed); case QueueStatuses.Error: DeleteJob(job.Name); return null; default: return null; //try to re-queue once; if this is second try and this happens agian, an error will be returned } }
public void StoreJobAndTrigger(IScheduledJob job, Trigger trigger) { StoreJob(job, false); StoreTrigger(trigger, false); }
/// <summary> /// Ctor /// </summary> /// <param name="job"></param> public ScheduledJobModel(IScheduledJob job) { Job = job; }
/// <summary> /// Sends the specified linqExpression to be executed. /// </summary> /// <param name="job">The job.</param> /// <param name="scheduledTime">The scheduled time.</param> /// <param name="method">The linqExpression to execute.</param> /// <returns></returns> public async Task<IJobQueueOutputMessage> SendAsync(IScheduledJob job, DateTimeOffset scheduledTime, Expression<Action<IReceivedMessage<MessageExpression>, IWorkerNotification>> method) { if (!_started) throw new DotNetWorkQueueException("Start must be called before sending jobs"); return await _sendJobToQueue.SendAsync(job, scheduledTime, method).ConfigureAwait(false); }
internal JobWrapper(IScheduledJob job) { _job = job; }
public DateTime ScheduleJob(IScheduledJob job, Trigger trigger) { if (job == null) throw new SchedulerException("Job cannot be null", SchedulerException.ErrorClientError); if (trigger == null) throw new SchedulerException("Trigger cannot be null", SchedulerException.ErrorClientError); if (trigger.JobName == null) trigger.JobName = job.Name; NullableDateTime ft = trigger.ComputeFirstFireTimeUtc(); if (!ft.HasValue) throw new SchedulerException("Based on configured schedule, the given trigger will never fire.", SchedulerException.ErrorClientError); StoreJobAndTrigger(job, trigger); NotifySchedulerThread(); return ft.Value; }
public string AddScheduledOnceJob(DateTime date, IScheduledJob job) { Trigger trigger = new Trigger("Trigger_" + job.Name, null, date); ScheduleJob(job, trigger); return job.Name; }
public string AddScheduledOnceJob(long timeDelta, IScheduledJob job) { DateTime startUtc = DateTime.UtcNow; startUtc = startUtc.AddMilliseconds(timeDelta); return AddScheduledOnceJob(startUtc, job); }
public string AddScheduledJob(int interval, int repeatCount, IScheduledJob job) { // Create trigger that fires indefinitely every <interval> milliseconds Trigger trigger = new Trigger("Trigger_" + job.Name, null, DateTime.UtcNow, null, repeatCount, interval); ScheduleJob(job, trigger); return job.Name; }
public string AddScheduledJob(int interval, IScheduledJob job) { return AddScheduledJob(interval, Trigger.RepeatIndefinitely, job); }
/// <summary> /// Sends the specified dynamic linqExpression to be executed. /// </summary> /// <param name="job">The job.</param> /// <param name="scheduledTime">The scheduled time.</param> /// <param name="linqExpression">The linqExpression to execute.</param> /// <returns></returns> public async Task<IJobQueueOutputMessage> SendAsync(IScheduledJob job, DateTimeOffset scheduledTime, LinqExpressionToRun linqExpression) { if(!_started) throw new DotNetWorkQueueException("Start must be called before sending jobs"); return await _sendJobToQueue.SendAsync(job, scheduledTime, linqExpression).ConfigureAwait(false); }
/// <summary> /// Initializes a new instance of the <see cref="TriggerFiredBundle"/> class. /// </summary> /// <param name="job">The job.</param> /// <param name="trigger">The trigger.</param> /// <param name="jobIsRecovering">if set to <c>true</c> [job is recovering].</param> /// <param name="fireTimeUtc">The fire time.</param> /// <param name="scheduledFireTimeUtc">The scheduled fire time.</param> /// <param name="prevFireTimeUtc">The previous fire time.</param> /// <param name="nextFireTimeUtc">The next fire time.</param> public TriggerFiredBundle(IScheduledJob job, Trigger trigger, bool jobIsRecovering, NullableDateTime fireTimeUtc, NullableDateTime scheduledFireTimeUtc, NullableDateTime prevFireTimeUtc, NullableDateTime nextFireTimeUtc) { _job = job; _trigger = trigger; _jobIsRecovering = jobIsRecovering; _fireTimeUtc = DateTimeUtils.AssumeUniversalTime(fireTimeUtc); _scheduledFireTimeUtc = DateTimeUtils.AssumeUniversalTime(scheduledFireTimeUtc); _prevFireTimeUtc = DateTimeUtils.AssumeUniversalTime(prevFireTimeUtc); _nextFireTimeUtc = DateTimeUtils.AssumeUniversalTime(nextFireTimeUtc); }
/// <summary> /// Sends the specified action to the specified queue. /// </summary> /// <param name="job">The job.</param> /// <param name="scheduledTime">The scheduled time.</param> /// <param name="expressionToRun">The expression to run.</param> /// <returns></returns> public async Task<IJobQueueOutputMessage> SendAsync(IScheduledJob job, DateTimeOffset scheduledTime, LinqExpressionToRun expressionToRun) { var data = SendPreChecks(job.Name, scheduledTime); if (data != null) return data; var messageData = new AdditionalMessageData(); SetMetaDataForJob(job.Name, scheduledTime, new DateTimeOffset(GetTimeFactory.Create().GetCurrentUtcDate()), job.Route, messageData); var message = await Queue.SendAsync(expressionToRun, messageData).ConfigureAwait(false); var result = ProcessResult(job, scheduledTime, message); if (result != null) return result; //try one more time result = ProcessResult(job, scheduledTime, await Queue.SendAsync(expressionToRun, messageData).ConfigureAwait(false)); return result ?? new JobQueueOutputMessage(JobQueuedStatus.Failed); }
public void CompleteJob(IShift shift, IScheduledJob job) { ShiftWorkerManager[shift].CompleteJob(job.Job); ShiftToolManager[shift].CompleteJob(job.Job); }