public void Started() { WorkStarted workStarted1 = this.ProcessStartedEvent; if (workStarted1 == null) { return; } SchedulerClient schedulerClient = this; workStarted1(ref schedulerClient); }
public void Errored(ref Exception objException) { WorkErrored workErrored = this.ProcessErroredEvent; if (workErrored == null) { return; } SchedulerClient schedulerClient = this; workErrored(ref schedulerClient, ref objException); }
public void Progressing() { WorkProgressing workProgressing = this.ProcessProgressingEvent; if (workProgressing == null) { return; } SchedulerClient schedulerClient = this; workProgressing(ref schedulerClient); }
public void Completed() { WorkCompleted workCompleted = this.ProcessCompletedEvent; if (workCompleted == null) { return; } SchedulerClient schedulerClient = this; workCompleted(ref schedulerClient); }
public void Run(ScheduleHistoryItem objScheduleHistoryItem) { SchedulerClient Process = null; try { //This is called from RunPooledThread() ticksElapsed = Environment.TickCount - ticksElapsed; Process = GetSchedulerClient(objScheduleHistoryItem.TypeFullName, objScheduleHistoryItem); Process.ScheduleHistoryItem = objScheduleHistoryItem; //Set up the handlers for the CoreScheduler Process.ProcessStarted += Scheduler.CoreScheduler.WorkStarted; Process.ProcessProgressing += Scheduler.CoreScheduler.WorkProgressing; Process.ProcessCompleted += Scheduler.CoreScheduler.WorkCompleted; Process.ProcessErrored += Scheduler.CoreScheduler.WorkErrored; //This kicks off the DoWork method of the class //type specified in the configuration. Process.Started(); try { Process.ScheduleHistoryItem.Succeeded = false; Process.DoWork(); } catch (Exception exc) { //in case the scheduler client //didn't have proper exception handling //make sure we fire the Errored event Logger.Error(exc); if (Process != null) { if (Process.ScheduleHistoryItem != null) { Process.ScheduleHistoryItem.Succeeded = false; } Process.Errored(ref exc); } } if (Process.ScheduleHistoryItem.Succeeded) { Process.Completed(); } //If all processes in this ProcessGroup have //completed, set the ticksElapsed and raise //the Completed event. //I don't think this is necessary with the //other events. I'll leave it for now and //will probably take it out later. if (processesCompleted == numberOfProcesses) { if (processesCompleted == numberOfProcesses) { ticksElapsed = Environment.TickCount - ticksElapsed; if (Completed != null) { Completed(); } } } } catch (Exception exc) { //in case the scheduler client //didn't have proper exception handling //make sure we fire the Errored event if (Process != null) { if (Process.ScheduleHistoryItem != null) { Process.ScheduleHistoryItem.Succeeded = false; } Process.Errored(ref exc); } else { //when the schedule has invalid config and can't initialize the Process, //we need also trigger work errored event so that the schedule can remove from inprogress and inqueue list to prevent endless loop. Scheduler.CoreScheduler.WorkStarted(objScheduleHistoryItem); objScheduleHistoryItem.Succeeded = false; Scheduler.CoreScheduler.WorkErrored(objScheduleHistoryItem, exc); } } finally { //Track how many processes have completed for //this instanciation of the ProcessGroup numberOfProcessesInQueue -= 1; processesCompleted += 1; } }
public static void WorkStarted(SchedulerClient schedulerClient) { WorkStarted(schedulerClient.ScheduleHistoryItem); }
public static void WorkProgressing(SchedulerClient schedulerClient) { try { //A SchedulerClient is notifying us that their //process is in progress. Informational only. if (schedulerClient.ScheduleHistoryItem.RetainHistoryNum > 0) { //Write out the log entry for this event var log = new LogInfo {LogTypeKey = "SCHEDULER_EVENT_PROGRESSING"}; log.AddProperty("THREAD ID", Thread.CurrentThread.GetHashCode().ToString()); log.AddProperty("TYPE", schedulerClient.GetType().FullName); log.AddProperty("SOURCE", schedulerClient.ScheduleHistoryItem.ScheduleSource.ToString()); log.AddProperty("ACTIVE THREADS", _activeThreadCount.ToString()); log.AddProperty("FREE THREADS", FreeThreads.ToString()); log.AddProperty("READER TIMEOUTS", _readerTimeouts.ToString()); log.AddProperty("WRITER TIMEOUTS", _writerTimeouts.ToString()); log.AddProperty("IN PROGRESS", GetScheduleInProgressCount().ToString()); log.AddProperty("IN QUEUE", GetScheduleQueueCount().ToString()); LogController.Instance.AddLog(log); } } catch (Exception exc) { Exceptions.Exceptions.ProcessSchedulerException(exc); } }
public static void WorkErrored(SchedulerClient schedulerClient, Exception exception) { WorkErrored(schedulerClient.ScheduleHistoryItem, exception); }
public static void WorkCompleted(SchedulerClient schedulerClient) { try { ScheduleHistoryItem scheduleHistoryItem = schedulerClient.ScheduleHistoryItem; //Remove the object in the ScheduleInProgress collection RemoveFromScheduleInProgress(scheduleHistoryItem); //A SchedulerClient is notifying us that their //process has completed. Decrease our ActiveThreadCount Interlocked.Decrement(ref _activeThreadCount); //Update the schedule item object property //to note the end time and next start scheduleHistoryItem.EndDate = DateTime.Now; if (scheduleHistoryItem.ScheduleSource == ScheduleSource.STARTED_FROM_EVENT) { scheduleHistoryItem.NextStart = Null.NullDate; } else { if (scheduleHistoryItem.CatchUpEnabled) { switch (scheduleHistoryItem.TimeLapseMeasurement) { case "s": scheduleHistoryItem.NextStart = scheduleHistoryItem.NextStart.AddSeconds(scheduleHistoryItem.TimeLapse); break; case "m": scheduleHistoryItem.NextStart = scheduleHistoryItem.NextStart.AddMinutes(scheduleHistoryItem.TimeLapse); break; case "h": scheduleHistoryItem.NextStart = scheduleHistoryItem.NextStart.AddHours(scheduleHistoryItem.TimeLapse); break; case "d": scheduleHistoryItem.NextStart = scheduleHistoryItem.NextStart.AddDays(scheduleHistoryItem.TimeLapse); break; case "w": scheduleHistoryItem.NextStart = scheduleHistoryItem.StartDate.AddDays(scheduleHistoryItem.TimeLapse * 7); break; case "mo": scheduleHistoryItem.NextStart = scheduleHistoryItem.StartDate.AddMonths(scheduleHistoryItem.TimeLapse); break; case "y": scheduleHistoryItem.NextStart = scheduleHistoryItem.StartDate.AddYears(scheduleHistoryItem.TimeLapse); break; } } else { switch (scheduleHistoryItem.TimeLapseMeasurement) { case "s": scheduleHistoryItem.NextStart = scheduleHistoryItem.StartDate.AddSeconds(scheduleHistoryItem.TimeLapse); break; case "m": scheduleHistoryItem.NextStart = scheduleHistoryItem.StartDate.AddMinutes(scheduleHistoryItem.TimeLapse); break; case "h": scheduleHistoryItem.NextStart = scheduleHistoryItem.StartDate.AddHours(scheduleHistoryItem.TimeLapse); break; case "d": scheduleHistoryItem.NextStart = scheduleHistoryItem.StartDate.AddDays(scheduleHistoryItem.TimeLapse); break; case "w": scheduleHistoryItem.NextStart = scheduleHistoryItem.StartDate.AddDays(scheduleHistoryItem.TimeLapse * 7); break; case "mo": scheduleHistoryItem.NextStart = scheduleHistoryItem.StartDate.AddMonths(scheduleHistoryItem.TimeLapse); break; case "y": scheduleHistoryItem.NextStart = scheduleHistoryItem.StartDate.AddYears(scheduleHistoryItem.TimeLapse); break; } } } //Update the ScheduleHistory in the database UpdateScheduleHistory(scheduleHistoryItem); if (scheduleHistoryItem.NextStart != Null.NullDate) { //Put the object back into the ScheduleQueue //collection with the new NextStart date. scheduleHistoryItem.StartDate = Null.NullDate; scheduleHistoryItem.EndDate = Null.NullDate; scheduleHistoryItem.LogNotes = ""; scheduleHistoryItem.ProcessGroup = -1; AddToScheduleQueue(scheduleHistoryItem); } if (schedulerClient.ScheduleHistoryItem.RetainHistoryNum > 0) { var log = new LogInfo {LogTypeKey = "SCHEDULER_EVENT_COMPLETED"}; log.AddProperty("TYPE", schedulerClient.GetType().FullName); log.AddProperty("THREAD ID", Thread.CurrentThread.GetHashCode().ToString()); log.AddProperty("NEXT START", Convert.ToString(scheduleHistoryItem.NextStart)); log.AddProperty("SOURCE", schedulerClient.ScheduleHistoryItem.ScheduleSource.ToString()); log.AddProperty("ACTIVE THREADS", _activeThreadCount.ToString()); log.AddProperty("FREE THREADS", FreeThreads.ToString()); log.AddProperty("READER TIMEOUTS", _readerTimeouts.ToString()); log.AddProperty("WRITER TIMEOUTS", _writerTimeouts.ToString()); log.AddProperty("IN PROGRESS", GetScheduleInProgressCount().ToString()); log.AddProperty("IN QUEUE", GetScheduleQueueCount().ToString()); LogController.Instance.AddLog(log); } } catch (Exception exc) { Exceptions.Exceptions.ProcessSchedulerException(exc); } }
public static void WorkStarted(SchedulerClient schedulerClient) { bool activeThreadCountIncremented = false; try { schedulerClient.ScheduleHistoryItem.ThreadID = Thread.CurrentThread.GetHashCode(); //Put the object in the ScheduleInProgress collection //and remove it from the ScheduleQueue RemoveFromScheduleQueue(schedulerClient.ScheduleHistoryItem); AddToScheduleInProgress(schedulerClient.ScheduleHistoryItem); //A SchedulerClient is notifying us that their //process has started. Increase our ActiveThreadCount Interlocked.Increment(ref _activeThreadCount); activeThreadCountIncremented = true; //Update the schedule item //object property to note the start time. schedulerClient.ScheduleHistoryItem.StartDate = DateTime.Now; AddScheduleHistory(schedulerClient.ScheduleHistoryItem); if (schedulerClient.ScheduleHistoryItem.RetainHistoryNum > 0) { //Write out the log entry for this event var eventLogController = new EventLogController(); var eventLogInfo = new LogInfo(); eventLogInfo.AddProperty("THREAD ID", Thread.CurrentThread.GetHashCode().ToString()); eventLogInfo.AddProperty("TYPE", schedulerClient.GetType().FullName); eventLogInfo.AddProperty("SOURCE", schedulerClient.ScheduleHistoryItem.ScheduleSource.ToString()); eventLogInfo.AddProperty("ACTIVE THREADS", _activeThreadCount.ToString()); eventLogInfo.AddProperty("FREE THREADS", FreeThreads.ToString()); eventLogInfo.AddProperty("READER TIMEOUTS", _readerTimeouts.ToString()); eventLogInfo.AddProperty("WRITER TIMEOUTS", _writerTimeouts.ToString()); eventLogInfo.AddProperty("IN PROGRESS", GetScheduleInProgressCount().ToString()); eventLogInfo.AddProperty("IN QUEUE", GetScheduleQueueCount().ToString()); eventLogInfo.LogTypeKey = "SCHEDULER_EVENT_STARTED"; eventLogController.AddLog(eventLogInfo); } } catch (Exception exc) { //Decrement the ActiveThreadCount because //otherwise the number of active threads //will appear to be climbing when in fact //no tasks are being executed. if (activeThreadCountIncremented) { Interlocked.Decrement(ref _activeThreadCount); } Exceptions.Exceptions.ProcessSchedulerException(exc); } }
public static void WorkErrored(SchedulerClient schedulerClient, Exception exception) { try { ScheduleHistoryItem scheduleHistoryItem = schedulerClient.ScheduleHistoryItem; //Remove the object in the ScheduleInProgress collection RemoveFromScheduleInProgress(scheduleHistoryItem); //A SchedulerClient is notifying us that their //process has errored. Decrease our ActiveThreadCount Interlocked.Decrement(ref _activeThreadCount); Exceptions.Exceptions.ProcessSchedulerException(exception); //Update the schedule item object property //to note the end time and next start scheduleHistoryItem.EndDate = DateTime.Now; if (scheduleHistoryItem.ScheduleSource == ScheduleSource.STARTED_FROM_EVENT) { scheduleHistoryItem.NextStart = Null.NullDate; } else if (scheduleHistoryItem.RetryTimeLapse != Null.NullInteger) { switch (scheduleHistoryItem.RetryTimeLapseMeasurement) { case "s": scheduleHistoryItem.NextStart = scheduleHistoryItem.StartDate.AddSeconds(scheduleHistoryItem.RetryTimeLapse); break; case "m": scheduleHistoryItem.NextStart = scheduleHistoryItem.StartDate.AddMinutes(scheduleHistoryItem.RetryTimeLapse); break; case "h": scheduleHistoryItem.NextStart = scheduleHistoryItem.StartDate.AddHours(scheduleHistoryItem.RetryTimeLapse); break; case "d": scheduleHistoryItem.NextStart = scheduleHistoryItem.StartDate.AddDays(scheduleHistoryItem.RetryTimeLapse); break; } } //Update the ScheduleHistory in the database UpdateScheduleHistory(scheduleHistoryItem); if (scheduleHistoryItem.NextStart != Null.NullDate && scheduleHistoryItem.RetryTimeLapse != Null.NullInteger) { //Put the object back into the ScheduleQueue //collection with the new NextStart date. scheduleHistoryItem.StartDate = Null.NullDate; scheduleHistoryItem.EndDate = Null.NullDate; scheduleHistoryItem.LogNotes = ""; scheduleHistoryItem.ProcessGroup = -1; AddToScheduleQueue(scheduleHistoryItem); } if (schedulerClient.ScheduleHistoryItem.RetainHistoryNum > 0) { //Write out the log entry for this event var eventLogController = new EventLogController(); var eventLogInfo = new LogInfo(); eventLogInfo.AddProperty("THREAD ID", Thread.CurrentThread.GetHashCode().ToString()); eventLogInfo.AddProperty("TYPE", schedulerClient.GetType().FullName); if (exception != null) { eventLogInfo.AddProperty("EXCEPTION", exception.Message); } eventLogInfo.AddProperty("RESCHEDULED FOR", Convert.ToString(scheduleHistoryItem.NextStart)); eventLogInfo.AddProperty("SOURCE", schedulerClient.ScheduleHistoryItem.ScheduleSource.ToString()); eventLogInfo.AddProperty("ACTIVE THREADS", _activeThreadCount.ToString()); eventLogInfo.AddProperty("FREE THREADS", FreeThreads.ToString()); eventLogInfo.AddProperty("READER TIMEOUTS", _readerTimeouts.ToString()); eventLogInfo.AddProperty("WRITER TIMEOUTS", _writerTimeouts.ToString()); eventLogInfo.AddProperty("IN PROGRESS", GetScheduleInProgressCount().ToString()); eventLogInfo.AddProperty("IN QUEUE", GetScheduleQueueCount().ToString()); eventLogInfo.LogTypeKey = "SCHEDULER_EVENT_FAILURE"; eventLogController.AddLog(eventLogInfo); } } catch (Exception exc) { Exceptions.Exceptions.ProcessSchedulerException(exc); } }