A scheduler performs scheduling of jobs according to job schedule descriptions. More...

Inheritance diagram for Ntp.Common.Process.Scheduler:

Collaboration diagram for Ntp.Common.Process.Scheduler:

Public Member Functions
	Scheduler (LogBase log)
	Initializes a new instance of the Scheduler class. More...

void	Add (JobDescription description)
	Add the specified job to the scheduler queue. More...

void	Dispose ()

IEnumerator< Job >	GetEnumerator ()
	Gets the enumerator. More...

void	RunOneCycle ()
	Run the scheduler "queue pump" method. More...

void	Stop ()

Public Attributes
IEnumerable< ScheduledJob >	Schedule => schedule
	Gets the schedule. More...

Properties
bool	Active `[get, private set]`
	Gets a value indicating whether this Scheduler is active. More...

ActivityLog	ActivityLog `[get]`
	Gets the activity log. More...

LogBase	Log `[get]`
	Gets the log used by this Scheduler. More...

ScheduledJob	NextJob `[get, private set]`
	Gets the next job to be executed. More...

DateTime	StartTime `[get]`
	Gets the start up time of this Scheduler. More...

EventWaitHandle	WaitHandle `[get]`
	Gets the wait handle of this Scheduler. More...

Properties inherited from Ntp.Common.Process.IScheduler
bool	Active `[get]`

ActivityLog	ActivityLog `[get]`

ScheduledJob	NextJob `[get]`

IEnumerable< ScheduledJob >	Schedule `[get]`

Private Member Functions
	~Scheduler ()

void	Dispose (bool disposing)

void	ExecuteJob (Job job)

IEnumerator IEnumerable.	GetEnumerator ()
	Gets the enumerator. More...

void	JobThreadStart (object stateInfo)

void	PostponeJob (Job job)
	Postpones the job when putting it to the queue. More...

void	QueueJob (Job job, DateTime run)
	Queue job for scheduled run. More...

Private Attributes
bool	disposedValue

bool	firstRun

readonly List< Job >	jobs

readonly List< Thread >	runningThreads

readonly List< ScheduledJob >	schedule

Detailed Description

A scheduler performs scheduling of jobs according to job schedule descriptions.

Definition at line 35 of file Scheduler.cs.

Constructor & Destructor Documentation

Ntp.Common.Process.Scheduler.Scheduler ( LogBase log )

inline

Initializes a new instance of the Scheduler class.

Parameters

log Log.

Definition at line 41 of file Scheduler.cs.

References Ntp.Common.Log.LogGroup.Add(), Ntp.Common.Log.LogFactory.CreateActivityLog(), and Ntp.Common.Log.LogFactory.CreateGroupLog().

         {
             StartTime = DateTime.Now;
             firstRun = true;
             Active = false;
 
             runningThreads = new List<Thread>();
             WaitHandle = new EventWaitHandle(false, EventResetMode.AutoReset);
 
             schedule = new List<ScheduledJob>();
             jobs = new List<Job>();
             ActivityLog = LogFactory.CreateActivityLog();
 
             LogGroup logGroup = LogFactory.CreateGroupLog();
             logGroup.Add(log);
             logGroup.Add(ActivityLog);
 
             Log = logGroup;
         }

Here is the call graph for this function:

Ntp.Common.Process.Scheduler.~Scheduler ( )

inlineprivate

Definition at line 363 of file Scheduler.cs.

         {
             Dispose(false);
         }

Member Function Documentation

void Ntp.Common.Process.Scheduler.Add ( JobDescription description )

inline

Add the specified job to the scheduler queue.

Parameters

description Description.

Definition at line 130 of file Scheduler.cs.

References Ntp.Common.Process.JobDescription.Configuration, Ntp.Common.Process.IJobConfiguration.FixedRun, Ntp.Common.Process.IJobConfiguration.Frequency, and Ntp.Common.Process.IJobConfiguration.InitialRun.

Referenced by Ntp.Analyzer.Process.Initializer.InitializeScheduler().

         {
             if (description.Configuration == null || description.Configuration.Frequency == -1)
                 return;
 
             var scheduleDescription = new JobScheduleDescription(
                 description.Configuration.InitialRun,
                 description.Configuration.FixedRun,
                 description.Configuration.Frequency);
 
             var job = new Job(description, scheduleDescription, Log);
             jobs.Add(job);
 
             Log.SchedulerJobAdded(description, job);
 
             QueueJob(job, StartTime);
         }

Here is the caller graph for this function:

void Ntp.Common.Process.Scheduler.Dispose ( bool disposing )

inlineprivate

Definition at line 350 of file Scheduler.cs.

         {
             if (disposedValue)
                 return;
 
             if (disposing)
             {
                 WaitHandle.Dispose();
             }
 
             disposedValue = true;
         }

void Ntp.Common.Process.Scheduler.Dispose ( )

inline

Definition at line 368 of file Scheduler.cs.

         {
             Dispose(true);
             GC.SuppressFinalize(this);
         }

void Ntp.Common.Process.Scheduler.ExecuteJob ( Job job )

inlineprivate

Definition at line 256 of file Scheduler.cs.

References Ntp.Common.Process.Job.Description, e, Ntp.Common.Process.Job.Execute(), and Ntp.Common.Process.JobDescription.Name.

         {
             try
             {
                 job.Execute();
             }
             catch (Exception e)
             {
                 Log.SchedulerError(job.Description.Name, e);
             }
         }

Here is the call graph for this function:

IEnumerator<Job> Ntp.Common.Process.Scheduler.GetEnumerator ( )

inline

Gets the enumerator.

Returns: The enumerator.

Definition at line 88 of file Scheduler.cs.

         {
             return jobs.GetEnumerator();
         }

IEnumerator IEnumerable. Ntp.Common.Process.Scheduler.GetEnumerator ( )

inlineprivate

Gets the enumerator.

Returns: The enumerator.

Definition at line 97 of file Scheduler.cs.

         {
             return jobs.GetEnumerator();
         }

void Ntp.Common.Process.Scheduler.JobThreadStart ( object stateInfo )

inlineprivate

Definition at line 268 of file Scheduler.cs.

References e.

         {
             try
             {
                 lock (runningThreads)
                     runningThreads.Add(Thread.CurrentThread);
 
                 var job = (Job) stateInfo;
                 Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
                 //Thread.CurrentThread.Name = job.Description.Name;
                 job.Execute();
             }
             catch (Exception e)
             {
                 Log.SchedulerError(Thread.CurrentThread.Name, e);
             }
             finally
             {
                 lock (runningThreads)
                 {
                     if (runningThreads.Contains(Thread.CurrentThread))
                     {
                         runningThreads.Remove(Thread.CurrentThread);
                     }
                 }
             }
         }

void Ntp.Common.Process.Scheduler.PostponeJob ( Job job )

inlineprivate

Postpones the job when putting it to the queue.

Parameters

job Job.

Definition at line 300 of file Scheduler.cs.

References Ntp.Common.Process.JobScheduleDescription.CreatePostponed(), Ntp.Common.Process.Job.Postponed, Ntp.Common.Process.Job.Queued, and Ntp.Common.Process.Job.Schedule.

         {
             lock (schedule)
             {
                 ScheduledJob scheduledJob = job.Schedule.CreatePostponed(job);
                 schedule.Add(scheduledJob);
                 job.Queued = true;
                 job.Postponed = true;
                 Log.SchedulerJobStatus(scheduledJob);
             }
         }

Here is the call graph for this function:

void Ntp.Common.Process.Scheduler.QueueJob	(	Job	job,
		DateTime	run
	)

inlineprivate

Queue job for scheduled run.

Parameters

job	Job.
run	Run.

Definition at line 317 of file Scheduler.cs.

References Ntp.Common.Process.JobScheduleDescription.CalculateNextRun(), Ntp.Common.Process.JobScheduleDescription.CanMove, Ntp.Common.Process.JobScheduleDescription.CreateNew(), Ntp.Common.Process.JobScheduleDescription.Frequency, Ntp.Common.Process.Job.Postponed, Ntp.Common.Process.Job.Queued, and Ntp.Common.Process.Job.Schedule.

         {
             DateTime next = job.Schedule.CalculateNextRun(run);
             double offset = 0;
 
             // Adjust offset to avoid simultaneously job execution.
             if (job.Schedule.CanMove)
             {
                 lock (schedule)
                 {
                     while (schedule.Count(j => Math.Abs(next.Subtract(j.Run).TotalMilliseconds) < 5000) != 0)
                     {
                         double move = job.Schedule.Frequency/40.0;
                         next = next.AddMinutes(move);
                         offset += move;
                     }
                 }
             }
 
             lock (schedule)
             {
                 ScheduledJob scheduledJob = job.Schedule.CreateNew(job, run, offset);
                 schedule.Add(scheduledJob);
                 job.Queued = true;
                 job.Postponed = false;
                 Log.SchedulerJobStatus(scheduledJob);
             }
         }

Here is the call graph for this function:

void Ntp.Common.Process.Scheduler.RunOneCycle ( )

inline

Run the scheduler "queue pump" method.

Definition at line 151 of file Scheduler.cs.

References Ntp.Common.Process.Job.Description, Ntp.Common.Process.JobScheduleDescription.Frequency, Ntp.Common.Process.ScheduledJob.Job, Ntp.Common.Process.Job.Queued, Ntp.Common.Process.ScheduledJob.Run, Ntp.Common.Process.Job.Schedule, and Ntp.Common.Process.JobDescription.ThreadType.

         {
             Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
 
             if (firstRun)
             {
                 firstRun = false;
                 Active = true;
 
                 lock (schedule)
                 {
                     Log.SchedulerStart(schedule.Count);
                 }
             }
 
             // Take the next job of the queue
             ScheduledJob next;
             lock (schedule)
             {
                 next = schedule.OrderBy(j => j.Run).ThenBy(j => j.Job.Description.Priority).First();
                 schedule.Remove(next);
                 next.Job.Queued = false;
                 NextJob = next;
             }
 
             // Wait until job should be run
             int wait = Convert.ToInt32(next.Run.Subtract(DateTime.Now).TotalMilliseconds);
             if (wait < 0)
             {
                 if (wait < -5000)
                     Log.SchedulerBehind();
 
                 wait = 0;
             }
 
             bool signal = WaitHandle.WaitOne(wait);
             if (signal)
             {
                 // Abort
                 return;
             }
 
             // Check if the job is already running and postpone if needed
             lock (schedule)
             {
                 if (next.Job.Description.ThreadType == ThreadType.SingleThreaded &&
                     schedule.Count(j => j.Job.Description.ThreadType == ThreadType.SingleThreaded && j.Job.Running) != 0)
                 {
                     PostponeJob(next.Job);
                     return;
                 }
             }
 
             Log.SchedulerJobExecuting(next);
             if (next.Job.Description.ThreadType != ThreadType.NoThread)
             {
                 // Queue the job on the threadpool
                 ThreadPool.QueueUserWorkItem(JobThreadStart, next.Job);
             }
             else
             {
                 // Execute directly in scheduler thread
                 ExecuteJob(next.Job);
             }
 
             // Dont re-schedule "run-only-once" jobs.
             if (next.Job.Schedule.Frequency == 0)
                 return;
 
             QueueJob(next.Job, DateTime.Now);
         }

void Ntp.Common.Process.Scheduler.Stop ( )

inline

Definition at line 223 of file Scheduler.cs.

         {
             int count;
 
             // Remove finished threads
             lock (runningThreads)
             {
                 foreach (var finished in runningThreads.Where(t => !t.IsAlive).ToList())
                     runningThreads.Remove(finished);
 
                 count = runningThreads.Count;
             }
 
             if (count != 0)
                 Log.SchedulerWaiting(count);
 
             lock (runningThreads)
             {
                 foreach (var thread in runningThreads.ToList())
                 {
                     // Wait maximum 15 seconds
                     thread.Join(15000/count);
                     if (!thread.IsAlive)
                         continue;
 
                     Log.SchedulerAbort(thread);
                     thread.Abort();
                 }
             }
 
             Log.SchedulerFinished();
         }

Member Data Documentation

bool Ntp.Common.Process.Scheduler.disposedValue

private

Definition at line 348 of file Scheduler.cs.

bool Ntp.Common.Process.Scheduler.firstRun

private

Definition at line 64 of file Scheduler.cs.

readonly List<Job> Ntp.Common.Process.Scheduler.jobs

private

Definition at line 61 of file Scheduler.cs.

readonly List<Thread> Ntp.Common.Process.Scheduler.runningThreads

private

Definition at line 62 of file Scheduler.cs.

readonly List<ScheduledJob> Ntp.Common.Process.Scheduler.schedule

private

Definition at line 63 of file Scheduler.cs.

IEnumerable<ScheduledJob> Ntp.Common.Process.Scheduler.Schedule => schedule

Gets the schedule.

The schedule.

Definition at line 118 of file Scheduler.cs.

Property Documentation

bool Ntp.Common.Process.Scheduler.Active

getprivate set

Gets a value indicating whether this Scheduler is active.

true if active; otherwise, false.

Definition at line 106 of file Scheduler.cs.

ActivityLog Ntp.Common.Process.Scheduler.ActivityLog

get

Gets the activity log.

The activity log.

Definition at line 112 of file Scheduler.cs.

LogBase Ntp.Common.Process.Scheduler.Log

get

Gets the log used by this Scheduler.

The log.

Definition at line 82 of file Scheduler.cs.

Referenced by Ntp.Analyzer.Process.Initializer.InitializeScheduler().

ScheduledJob Ntp.Common.Process.Scheduler.NextJob

getprivate set

Gets the next job to be executed.

The next job.

Definition at line 124 of file Scheduler.cs.

DateTime Ntp.Common.Process.Scheduler.StartTime

get

Gets the start up time of this Scheduler.

The start up time.

Definition at line 76 of file Scheduler.cs.

Referenced by Ntp.Analyzer.Process.Initializer.InitializeScheduler().

EventWaitHandle Ntp.Common.Process.Scheduler.WaitHandle

get

Gets the wait handle of this Scheduler.

The wait handle.

Definition at line 70 of file Scheduler.cs.

Referenced by Ntp.Common.Process.Cluster.Cluster().

The documentation for this class was generated from the following file:

Ntp.Common/Process/Scheduler.cs

Public Member Functions

Public Attributes

Properties

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

Property Documentation