public SchedulerClient()
{
SchedulerEventGUID = Null.NullString;
aProcessMethod = Null.NullString;
Status = Null.NullString;
ScheduleHistoryItem = new ScheduleHistoryItem();
}
public SchedulerClient()
{
//Assign the event a unique ID for tracking purposes.
this._SchedulerEventGUID = Null.NullString;
this._ProcessMethod = Null.NullString;
this._Status = Null.NullString;
this._ScheduleHistoryItem = new DotNetNuke.Services.Scheduling.ScheduleHistoryItem();
}
// Add a queue request to Threadpool with a
// callback to RunPooledThread which calls Run()
public void AddQueueUserWorkItem(ScheduleItem s)
{
numberOfProcessesInQueue += 1;
numberOfProcesses += 1;
var obj = new ScheduleHistoryItem(s);
try
{
// Create a callback to subroutine RunPooledThread
WaitCallback callback = this.RunPooledThread;
// And put in a request to ThreadPool to run the process.
ThreadPool.QueueUserWorkItem(callback, obj);
}
catch (Exception exc)
{
Exceptions.Exceptions.ProcessSchedulerException(exc);
}
}
private SchedulerClient GetSchedulerClient(string strProcess, ScheduleHistoryItem objScheduleHistoryItem)
{
//This is a method to encapsulate returning
//an object whose class inherits SchedulerClient.
Type t = BuildManager.GetType(strProcess, true, true);
var param = new ScheduleHistoryItem[1];
param[0] = objScheduleHistoryItem;
var types = new Type[1];
//Get the constructor for the Class
types[0] = typeof(ScheduleHistoryItem);
ConstructorInfo objConstructor;
objConstructor = t.GetConstructor(types);
//Return an instance of the class as an object
return((SchedulerClient)objConstructor.Invoke(param));
}
public override void RunScheduleItemNow(ScheduleItem scheduleItem, bool runNow)
{
//Remove item from queue
Scheduler.CoreScheduler.RemoveFromScheduleQueue(scheduleItem);
var scheduleHistoryItem = new ScheduleHistoryItem(scheduleItem)
{
NextStart = runNow ? DateTime.Now : (scheduleItem.ScheduleStartDate != Null.NullDate ? scheduleItem.ScheduleStartDate : DateTime.Now)
};
if (scheduleHistoryItem.TimeLapse != Null.NullInteger &&
scheduleHistoryItem.TimeLapseMeasurement != Null.NullString &&
scheduleHistoryItem.Enabled &&
SchedulingController.CanRunOnThisServer(scheduleItem.Servers))
{
scheduleHistoryItem.ScheduleSource = ScheduleSource.STARTED_FROM_SCHEDULE_CHANGE;
Scheduler.CoreScheduler.AddToScheduleQueue(scheduleHistoryItem);
}
DataCache.RemoveCache("ScheduleLastPolled");
}
public static int AddScheduleHistory(ScheduleHistoryItem objScheduleHistoryItem)
{
return(DataProvider.Instance().AddScheduleHistory(objScheduleHistoryItem.ScheduleID, objScheduleHistoryItem.StartDate, ServerController.GetExecutingServerName()));
}
public PurgeModuleCache(ScheduleHistoryItem objScheduleHistoryItem)
{
ScheduleHistoryItem = objScheduleHistoryItem; //REQUIRED
}
private SchedulerClient GetSchedulerClient(IServiceProvider services, string strProcess, ScheduleHistoryItem objScheduleHistoryItem)
{
// This is a method to encapsulate returning
// an object whose class inherits SchedulerClient.
Type t = BuildManager.GetType(strProcess, true, true);
return((SchedulerClient)ActivatorUtilities.CreateInstance(services, t, objScheduleHistoryItem));
}
public DNNSnapshotScheduledTask(DotNetNuke.Services.Scheduling.ScheduleHistoryItem objScheduleHistoryItem)
: base()
{
this.ScheduleHistoryItem = objScheduleHistoryItem;
}
public SynchronizeFileSystem(ScheduleHistoryItem objScheduleHistoryItem)
{
ScheduleHistoryItem = objScheduleHistoryItem;
}
public BattleFramework_SkirmishManagement(ScheduleHistoryItem oItem)
: base()
{
this.ScheduleHistoryItem = oItem;
}
public static void LoadQueueFromEvent(EventName eventName)
{
var executingServer = ServerController.GetExecutingServerName();
List<ScheduleItem> schedule = SchedulingController.GetScheduleByEvent(eventName.ToString(), executingServer);
var thisServer = GetServer(executingServer);
bool runningInAGroup = !String.IsNullOrEmpty(thisServer.ServerGroup);
var serverGroupServers = ServerGroupServers(thisServer);
foreach (ScheduleItem scheduleItem in schedule)
{
if (runningInAGroup && String.IsNullOrEmpty(scheduleItem.Servers))
{
scheduleItem.Servers = serverGroupServers;
}
var historyItem = new ScheduleHistoryItem(scheduleItem);
if (!IsInQueue(historyItem) &&
!IsInProgress(historyItem) &&
!HasDependenciesConflict(historyItem) &&
historyItem.Enabled)
{
historyItem.ScheduleSource = ScheduleSource.STARTED_FROM_EVENT;
AddToScheduleQueue(historyItem);
}
}
}
public static void WorkErrored(ScheduleHistoryItem scheduleHistoryItem, Exception exception)
{
try
{
//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;
case "w":
scheduleHistoryItem.NextStart = scheduleHistoryItem.StartDate.AddDays(scheduleHistoryItem.RetryTimeLapse * 7);
break;
case "mo":
scheduleHistoryItem.NextStart = scheduleHistoryItem.StartDate.AddMonths(scheduleHistoryItem.RetryTimeLapse);
break;
case "y":
scheduleHistoryItem.NextStart = scheduleHistoryItem.StartDate.AddYears(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 (scheduleHistoryItem.RetainHistoryNum > 0)
{
//Write out the log entry for this event
var log = new LogInfo {LogTypeKey = "SCHEDULER_EVENT_FAILURE"};
log.AddProperty("THREAD ID", Thread.CurrentThread.GetHashCode().ToString());
log.AddProperty("TYPE", scheduleHistoryItem.TypeFullName);
if (exception != null)
{
log.AddProperty("EXCEPTION", exception.Message);
}
log.AddProperty("RESCHEDULED FOR", Convert.ToString(scheduleHistoryItem.NextStart));
log.AddProperty("SOURCE", 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 ScheduleHistoryItem AddScheduleHistory(ScheduleHistoryItem scheduleHistoryItem)
{
try
{
int scheduleHistoryID = SchedulingController.AddScheduleHistory(scheduleHistoryItem);
scheduleHistoryItem.ScheduleHistoryID = scheduleHistoryID;
}
catch (Exception exc)
{
Exceptions.Exceptions.ProcessSchedulerException(exc);
}
return scheduleHistoryItem;
}
/// <summary>
/// Adds an item to the collection of schedule items in queue.
/// </summary>
/// <param name="scheduleHistoryItem"></param>
/// <remarks>Thread Safe</remarks>
public static void AddToScheduleQueue(ScheduleHistoryItem scheduleHistoryItem)
{
if (!ScheduleQueueContains(scheduleHistoryItem))
{
try
{
//objQueueReadWriteLock.AcquireWriterLock(WriteTimeout)
using (ScheduleQueue.GetWriteLock(LockTimeout))
{
//Do a second check just in case
if (!ScheduleQueueContains(scheduleHistoryItem) &&
!IsInProgress(scheduleHistoryItem))
{
// It is safe for this thread to read or write
// from the shared resource.
ScheduleQueue.Add(scheduleHistoryItem);
}
}
}
catch (ApplicationException ex)
{
// The writer lock request timed out.
Interlocked.Increment(ref _writerTimeouts);
Exceptions.Exceptions.LogException(ex);
}
}
}
private static bool ScheduleInProgressContains(ScheduleHistoryItem scheduleHistoryItem)
{
try
{
using (ScheduleInProgress.GetReadLock(LockTimeout))
{
return ScheduleInProgress.Any(si => si.ScheduleID == scheduleHistoryItem.ScheduleID);
}
}
catch (ApplicationException ex)
{
Interlocked.Increment(ref _readerTimeouts);
Exceptions.Exceptions.LogException(ex);
return false;
}
}
//DNN-5001
public static void StopScheduleInProgress(ScheduleItem scheduleItem, ScheduleHistoryItem runningscheduleHistoryItem)
{
try
{
//attempt to stop task only if it is still in progress
if (GetScheduleItemFromScheduleInProgress(scheduleItem) != null)
{
var scheduleHistoryItem = GetScheduleItemFromScheduleInProgress(scheduleItem);
scheduleHistoryItem.ScheduleHistoryID = runningscheduleHistoryItem.ScheduleHistoryID;
scheduleHistoryItem.StartDate = runningscheduleHistoryItem.StartDate;
//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);
}
//Write out the log entry for this event
var log = new LogInfo {LogTypeKey = "SCHEDULER_EVENT_COMPLETED"};
log.AddProperty("REASON", "Scheduler task has been stopped manually");
log.AddProperty("TYPE", scheduleHistoryItem.TypeFullName);
log.AddProperty("THREAD ID", Thread.CurrentThread.GetHashCode().ToString());
log.AddProperty("NEXT START", Convert.ToString(scheduleHistoryItem.NextStart));
LogController.Instance.AddLog(log);
}
}
catch (Exception exc)
{
Exceptions.Exceptions.ProcessSchedulerException(exc);
}
}
public static void WorkStarted(ScheduleHistoryItem scheduleHistoryItem)
{
bool activeThreadCountIncremented = false;
try
{
scheduleHistoryItem.ThreadID = Thread.CurrentThread.GetHashCode();
//Put the object in the ScheduleInProgress collection
//and remove it from the ScheduleQueue
RemoveFromScheduleQueue(scheduleHistoryItem);
AddToScheduleInProgress(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.
scheduleHistoryItem.StartDate = DateTime.Now;
AddScheduleHistory(scheduleHistoryItem);
if (scheduleHistoryItem.RetainHistoryNum > 0)
{
//Write out the log entry for this event
var log = new LogInfo {LogTypeKey = "SCHEDULER_EVENT_STARTED"};
log.AddProperty("THREAD ID", Thread.CurrentThread.GetHashCode().ToString());
log.AddProperty("TYPE", scheduleHistoryItem.TypeFullName);
log.AddProperty("SOURCE", 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)
{
//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 MessagingScheduler(ScheduleHistoryItem objScheduleHistoryItem)
{
ScheduleHistoryItem = objScheduleHistoryItem;
}
public static void LoadQueueFromTimer()
{
_forceReloadSchedule = false;
var executingServer = ServerController.GetExecutingServerName();
List<ScheduleItem> schedule = SchedulingController.GetSchedule(executingServer);
var thisServer = GetServer(executingServer);
bool runningInAGroup = !String.IsNullOrEmpty(thisServer.ServerGroup);
var serverGroupServers = ServerGroupServers(thisServer);
foreach (ScheduleItem scheduleItem in schedule)
{
if (runningInAGroup && String.IsNullOrEmpty(scheduleItem.Servers))
{
scheduleItem.Servers = serverGroupServers;
}
var historyItem = new ScheduleHistoryItem(scheduleItem);
if (!IsInQueue(historyItem) &&
historyItem.TimeLapse != Null.NullInteger &&
historyItem.TimeLapseMeasurement != Null.NullString &&
historyItem.Enabled)
{
if (SchedulingProvider.SchedulerMode == SchedulerMode.TIMER_METHOD)
{
historyItem.ScheduleSource = ScheduleSource.STARTED_FROM_TIMER;
}
else if (SchedulingProvider.SchedulerMode == SchedulerMode.REQUEST_METHOD)
{
historyItem.ScheduleSource = ScheduleSource.STARTED_FROM_BEGIN_REQUEST;
}
AddToScheduleQueue(historyItem);
}
}
}
public static int AddScheduleHistory(ScheduleHistoryItem objScheduleHistoryItem)
{
return DataProvider.Instance().AddScheduleHistory(objScheduleHistoryItem.ScheduleID, objScheduleHistoryItem.StartDate, ServerController.GetExecutingServerName());
}
public static void UpdateScheduleHistory(ScheduleHistoryItem scheduleHistoryItem)
{
try
{
SchedulingController.UpdateScheduleHistory(scheduleHistoryItem);
}
catch (Exception exc)
{
Exceptions.Exceptions.ProcessSchedulerException(exc);
}
}
public PurgeLogBuffer(ScheduleHistoryItem objScheduleHistoryItem)
{
ScheduleHistoryItem = objScheduleHistoryItem;
}
public override void RunScheduleItemNow(ScheduleItem scheduleItem, bool runNow)
{
//Remove item from queue
Scheduler.CoreScheduler.RemoveFromScheduleQueue(scheduleItem);
var scheduleHistoryItem = new ScheduleHistoryItem(scheduleItem) { NextStart = runNow ? DateTime.Now : (scheduleItem.ScheduleStartDate != Null.NullDate ? scheduleItem.ScheduleStartDate : DateTime.Now) };
if (scheduleHistoryItem.TimeLapse != Null.NullInteger
&& scheduleHistoryItem.TimeLapseMeasurement != Null.NullString
&& scheduleHistoryItem.Enabled
&& CanRunOnThisServer(scheduleItem.Servers))
{
scheduleHistoryItem.ScheduleSource = ScheduleSource.STARTED_FROM_SCHEDULE_CHANGE;
Scheduler.CoreScheduler.AddToScheduleQueue(scheduleHistoryItem);
}
DataCache.RemoveCache("ScheduleLastPolled");
}
/// -----------------------------------------------------------------------------
/// <summary>
/// Constructs a PurgeUsesOnline SchedulerClient
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="objScheduleHistoryItem">A SchedulerHistiryItem</param>
/// <history>
/// [cnurse] 03/14/2006 documented
/// </history>
/// -----------------------------------------------------------------------------
public PurgeUsersOnline(ScheduleHistoryItem objScheduleHistoryItem)
{
ScheduleHistoryItem = objScheduleHistoryItem;
}
public PublishScheduledTasks(ScheduleHistoryItem shi)
{
this.ScheduleHistoryItem = shi;
}
public PurgeScheduleHistory(ScheduleHistoryItem objScheduleHistoryItem)
{
ScheduleHistoryItem = objScheduleHistoryItem;
}
public NotificationSchedule(DotNetNuke.Services.Scheduling.ScheduleHistoryItem objScheduleHistoryItem)
: base()
{
this.ScheduleHistoryItem = objScheduleHistoryItem;
}
public DeleteMessages(ScheduleHistoryItem objScheduleHistoryItem)
{
ScheduleHistoryItem = objScheduleHistoryItem;
}
internal bool CompactSearchIndexIfNeeded(ScheduleHistoryItem scheduleItem)
{
var shelper = SearchHelper.Instance;
if (shelper.GetSearchCompactFlag())
{
shelper.SetSearchReindexRequestTime(false);
var stopWatch = System.Diagnostics.Stopwatch.StartNew();
if (InternalSearchController.Instance.OptimizeSearchIndex())
{
stopWatch.Stop();
scheduleItem.AddLogNote(string.Format("<br/><b>Compacted Index, total time {0}</b>", stopWatch.Elapsed));
}
}
return false;
}
/// <summary>
/// Initializes a new instance of the <see cref="PurgeScheduleHistory"/> class.
/// </summary>
/// <param name="objScheduleHistoryItem"></param>
public PurgeScheduleHistory(ScheduleHistoryItem objScheduleHistoryItem)
{
this.ScheduleHistoryItem = objScheduleHistoryItem;
}
public EmailInviteManagement(ScheduleHistoryItem oItem)
: base()
{
this.ScheduleHistoryItem = oItem;
}
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 SchedulerHelper(DotNetNuke.Services.Scheduling.ScheduleHistoryItem objScheduleHistoryItem)
: base()
{
this.ScheduleHistoryItem = objScheduleHistoryItem;
}
public PurgeSiteLog(ScheduleHistoryItem objScheduleHistoryItem)
{
ScheduleHistoryItem = objScheduleHistoryItem;
}
public SearchEngineScheduler(ScheduleHistoryItem objScheduleHistoryItem)
{
ScheduleHistoryItem = objScheduleHistoryItem;
}
public static void UpdateScheduleHistory(ScheduleHistoryItem objScheduleHistoryItem)
{
DataProvider.Instance().UpdateScheduleHistory(objScheduleHistoryItem.ScheduleHistoryID,
objScheduleHistoryItem.EndDate,
objScheduleHistoryItem.Succeeded,
objScheduleHistoryItem.LogNotes,
objScheduleHistoryItem.NextStart);
}
public SendLogNotifications(ScheduleHistoryItem objScheduleHistoryItem)
{
ScheduleHistoryItem = objScheduleHistoryItem;
}
public SkirmishManagement(ScheduleHistoryItem oItem)
: base()
{
this.ScheduleHistoryItem = oItem;
}
/// <summary>
/// adds an item to the collection of schedule items in progress.
/// </summary>
/// <param name="scheduleHistoryItem">Item to add</param>
/// <remarks>Thread Safe</remarks>
private static void AddToScheduleInProgress(ScheduleHistoryItem scheduleHistoryItem)
{
if (!(ScheduleInProgressContains(scheduleHistoryItem)))
{
try
{
using (ScheduleInProgress.GetWriteLock(LockTimeout))
{
if (!(ScheduleInProgressContains(scheduleHistoryItem)))
{
ScheduleInProgress.Add(scheduleHistoryItem);
}
}
}
catch (ApplicationException ex)
{
// The writer lock request timed out.
Interlocked.Increment(ref _writerTimeouts);
Exceptions.Exceptions.LogException(ex);
}
}
}