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);
}
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);
}
}
}
}
/// <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);
}
static Program()
{
var config = new WorkerConfig() { RunImmediately = true, DataValue = "Passed value" };
// TODO ReadOptionsFromConfig();
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>
/// 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);
}
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;
}
}
}
