public ScheduleHistoryItem(ScheduleItem objScheduleItem)
{
AttachToEvent = objScheduleItem.AttachToEvent;
CatchUpEnabled = objScheduleItem.CatchUpEnabled;
Enabled = objScheduleItem.Enabled;
NextStart = objScheduleItem.NextStart;
ObjectDependencies = objScheduleItem.ObjectDependencies;
ProcessGroup = objScheduleItem.ProcessGroup;
RetainHistoryNum = objScheduleItem.RetainHistoryNum;
RetryTimeLapse = objScheduleItem.RetryTimeLapse;
RetryTimeLapseMeasurement = objScheduleItem.RetryTimeLapseMeasurement;
ScheduleID = objScheduleItem.ScheduleID;
ScheduleSource = objScheduleItem.ScheduleSource;
ThreadID = objScheduleItem.ThreadID;
TimeLapse = objScheduleItem.TimeLapse;
TimeLapseMeasurement = objScheduleItem.TimeLapseMeasurement;
TypeFullName = objScheduleItem.TypeFullName;
Servers = objScheduleItem.Servers;
FriendlyName = objScheduleItem.FriendlyName;
_ScheduleHistoryID = Null.NullInteger;
_StartDate = Null.NullDate;
EndDate = Null.NullDate;
_Succeeded = Null.NullBoolean;
_LogNotes = new StringBuilder();
_Server = Null.NullString;
}
/// <summary>
/// Upgrades the module.
/// </summary>
/// <param name="version">The version.</param>
/// <returns>A success or failure message.</returns>
public string UpgradeModule(string version)
{
switch (version)
{
case "1.0.0":
var scheduleItem = new ScheduleItem
{
TypeFullName = "Engage.Dnn.Booking.EmailScheduler, EngageBooking",
TimeLapse = 5,
TimeLapseMeasurement = "m",
RetryTimeLapse = 10,
RetryTimeLapseMeasurement = "m",
RetainHistoryNum = 50,
AttachToEvent = "None",
CatchUpEnabled = true,
Enabled = true,
ObjectDependencies = string.Empty,
Servers = string.Empty
};
SchedulingProvider.Instance().AddSchedule(scheduleItem);
return "Added EmailScheduler task.";
default:
return "No tasks to perform for upgrade to version " + version;
}
}
private ScheduleItem CreateScheduleItem()
{
var scheduleItem = new ScheduleItem();
scheduleItem.TypeFullName = "Satrabel.OpenFiles.Components.Lucene.SearchEngineScheduler, OpenFiles";
scheduleItem.FriendlyName = "OpenFiles.Search";
//DNN-4964 - values for time lapse and retry frequency can't be set to 0, -1 or left empty (client side validation has been added)
scheduleItem.TimeLapse = 30;
scheduleItem.TimeLapseMeasurement = "m";
scheduleItem.RetryTimeLapse = 30;
scheduleItem.RetryTimeLapseMeasurement = "m";
scheduleItem.RetainHistoryNum = 60;
scheduleItem.AttachToEvent = "";
scheduleItem.CatchUpEnabled = false;
scheduleItem.Enabled = true;
scheduleItem.ObjectDependencies = "SearchEngine";
scheduleItem.ScheduleStartDate = Null.NullDate;
scheduleItem.Servers = "";
return scheduleItem;
}
public static void AddScheduleTask()
{
ScheduleItem oItem = SchedulingProvider.Instance().GetSchedule(typeof(Scheduler).Assembly.FullName, "");
if (oItem == null)
{
oItem = new ScheduleItem();
oItem.CatchUpEnabled = false;
oItem.Enabled = true;
oItem.FriendlyName = "ModuleTemplate.Scheduler";
oItem.NextStart = DateTime.Now.AddMinutes(4);
oItem.RetainHistoryNum = 60;
oItem.RetryTimeLapse = 30;
oItem.RetryTimeLapseMeasurement = "m";
oItem.ScheduleSource = ScheduleSource.NOT_SET;
oItem.TimeLapse = 60;
oItem.TimeLapseMeasurement = "m";
oItem.TypeFullName = typeof(Scheduler).Assembly.FullName;
SchedulingProvider.Instance().AddSchedule(oItem);
}
}
public override int AddSchedule(ScheduleItem scheduleItem)
{
//Remove item from queue
Scheduler.CoreScheduler.RemoveFromScheduleQueue(scheduleItem);
//save item
scheduleItem.ScheduleID = SchedulingController.AddSchedule(scheduleItem.TypeFullName,
scheduleItem.TimeLapse,
scheduleItem.TimeLapseMeasurement,
scheduleItem.RetryTimeLapse,
scheduleItem.RetryTimeLapseMeasurement,
scheduleItem.RetainHistoryNum,
scheduleItem.AttachToEvent,
scheduleItem.CatchUpEnabled,
scheduleItem.Enabled,
scheduleItem.ObjectDependencies,
scheduleItem.Servers,
scheduleItem.FriendlyName);
//Add schedule to queue
RunScheduleItemNow(scheduleItem);
//Return Id
return scheduleItem.ScheduleID;
}
/// <summary>
/// cmdDelete_Click runs when the Delete Button is clicked
/// </summary>
/// <remarks>
/// </remarks>
/// <history>
/// [cnurse] 9/28/2004 Updated to reflect design changes for Help, 508 support and localisation
/// </history>
protected void OnDeleteClick(Object sender, EventArgs e)
{
var objScheduleItem = new ScheduleItem {ScheduleID = Convert.ToInt32(ViewState["ScheduleID"])};
SchedulingProvider.Instance().DeleteSchedule(objScheduleItem);
var strMessage = Localization.GetString("DeleteSuccess", LocalResourceFile);
UI.Skins.Skin.AddModuleMessage(this, strMessage, ModuleMessage.ModuleMessageType.GreenSuccess);
}
public override void RunScheduleItemNow(ScheduleItem scheduleItem)
{
RunScheduleItemNow(scheduleItem, false);
}
/// <summary>
/// cmdDelete_Click runs when the Delete Button is clicked
/// </summary>
/// <returns></returns>
/// <remarks>
/// </remarks>
/// <history>
/// [cnurse] 9/28/2004 Updated to reflect design changes for Help, 508 support
/// and localisation
/// </history>
protected void cmdDelete_Click( Object sender, EventArgs e )
{
ScheduleItem objScheduleItem = new ScheduleItem();
objScheduleItem.ScheduleID = Convert.ToInt32( ViewState["ScheduleID"] );
SchedulingProvider.Instance().DeleteSchedule( objScheduleItem );
string strMessage;
strMessage = Localization.GetString( "DeleteSuccess", this.LocalResourceFile );
UI.Skins.Skin.AddModuleMessage( this, strMessage, ModuleMessageType.GreenSuccess );
pnlScheduleItem.Visible = false;
}
private ScheduleItem CreateScheduleItem()
{
var scheduleItem = new ScheduleItem();
scheduleItem.TypeFullName = txtType.Text;
scheduleItem.FriendlyName = txtFriendlyName.Text;
if (String.IsNullOrEmpty(txtTimeLapse.Text) || txtTimeLapse.Text == "0" || txtTimeLapse.Text == "-1")
{
scheduleItem.TimeLapse = Null.NullInteger;
}
else
{
scheduleItem.TimeLapse = Convert.ToInt32(txtTimeLapse.Text);
}
scheduleItem.TimeLapseMeasurement = ddlTimeLapseMeasurement.SelectedItem.Value;
if (String.IsNullOrEmpty(txtRetryTimeLapse.Text) || txtRetryTimeLapse.Text == "0" || txtRetryTimeLapse.Text == "-1")
{
scheduleItem.RetryTimeLapse = Null.NullInteger;
}
else
{
scheduleItem.RetryTimeLapse = Convert.ToInt32(txtRetryTimeLapse.Text);
}
scheduleItem.RetryTimeLapseMeasurement = ddlRetryTimeLapseMeasurement.SelectedItem.Value;
scheduleItem.RetainHistoryNum = Convert.ToInt32(ddlRetainHistoryNum.SelectedItem.Value);
scheduleItem.AttachToEvent = ddlAttachToEvent.SelectedItem.Value;
scheduleItem.CatchUpEnabled = chkCatchUpEnabled.Checked;
scheduleItem.Enabled = chkEnabled.Checked;
scheduleItem.ObjectDependencies = txtObjectDependencies.Text;
//if servers are specified, the concatenated string needs to be prefixed and suffixed by commas ( ie. ",SERVER1,SERVER2," )
var servers = Null.NullString;
var bAllSelected = true;
foreach (ListItem item in lstServers.Items)
{
if (item.Selected)
{
servers += "," + item.Value;
}
else
{
bAllSelected = Null.NullBoolean;
}
}
if (bAllSelected)
{
servers = Null.NullString;
}
if (!string.IsNullOrEmpty(servers))
{
scheduleItem.Servers = servers + ",";
}
return scheduleItem;
}
//DNN-5001 Possibility to stop already running tasks
public override void RemoveFromScheduleInProgress(ScheduleItem scheduleItem)
{
//get ScheduleHistoryItem of the running task
var runningscheduleHistoryItem = GetScheduleHistory(scheduleItem.ScheduleID).Cast<ScheduleHistoryItem>().ElementAtOrDefault(0);
Scheduler.CoreScheduler.StopScheduleInProgress(scheduleItem, runningscheduleHistoryItem);
}
public abstract void RemoveFromScheduleInProgress(ScheduleItem scheduleItem);
public override void DeleteSchedule(ScheduleItem scheduleItem)
{
SchedulingController.DeleteSchedule(scheduleItem.ScheduleID);
Scheduler.CoreScheduler.RemoveFromScheduleQueue(scheduleItem);
DataCache.RemoveCache("ScheduleLastPolled");
}
public override void UpdateScheduleWithoutExecution(ScheduleItem scheduleItem)
{
SchedulingController.UpdateSchedule(scheduleItem);
}
public abstract void UpdateSchedule(ScheduleItem scheduleItem);
public abstract void UpdateScheduleWithoutExecution(ScheduleItem scheduleItem);
public abstract int AddSchedule(ScheduleItem scheduleItem);
public virtual void RunScheduleItemNow(ScheduleItem scheduleItem)
{
//Do Nothing
}
public abstract void DeleteSchedule(ScheduleItem scheduleItem);
public virtual void RunScheduleItemNow(ScheduleItem scheduleItem, bool runNow)
{
//Do Nothing
}
public override void RunScheduleItemNow(ScheduleItem scheduleItem)
{
RunScheduleItemNow(scheduleItem, false);
}
/// <summary>
/// Removes an item from the collection of schedule items in queue.
/// </summary>
/// <param name="scheduleItem">Item to remove</param>
public static void RemoveFromScheduleQueue(ScheduleItem scheduleItem)
{
try
{
using (ScheduleQueue.GetWriteLock(LockTimeout))
{
//the scheduleitem instances may not be equal even though the scheduleids are equal
ScheduleItem item = ScheduleQueue.Where(si => si.ScheduleID == scheduleItem.ScheduleID).SingleOrDefault();
if (item != null)
{
ScheduleQueue.Remove(item);
}
}
}
catch (ApplicationException ex)
{
// The writer lock request timed out.
Interlocked.Increment(ref _writerTimeouts);
Exceptions.Exceptions.LogException(ex);
}
}
public override void DeleteSchedule(ScheduleItem scheduleItem)
{
SchedulingController.DeleteSchedule(scheduleItem.ScheduleID);
Scheduler.CoreScheduler.RemoveFromScheduleQueue(scheduleItem);
DataCache.RemoveCache("ScheduleLastPolled");
}
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");
}
//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 override void UpdateSchedule(ScheduleItem scheduleItem)
{
//Remove item from queue
Scheduler.CoreScheduler.RemoveFromScheduleQueue(scheduleItem);
//save item
SchedulingController.UpdateSchedule(scheduleItem.ScheduleID,
scheduleItem.TypeFullName,
scheduleItem.TimeLapse,
scheduleItem.TimeLapseMeasurement,
scheduleItem.RetryTimeLapse,
scheduleItem.RetryTimeLapseMeasurement,
scheduleItem.RetainHistoryNum,
scheduleItem.AttachToEvent,
scheduleItem.CatchUpEnabled,
scheduleItem.Enabled,
scheduleItem.ObjectDependencies,
scheduleItem.Servers,
scheduleItem.FriendlyName,
scheduleItem.ScheduleStartDate);
//Update items that are already scheduled
var futureHistory = GetScheduleHistory(scheduleItem.ScheduleID).Cast<ScheduleHistoryItem>().Where(h => h.NextStart > DateTime.Now);
var scheduleItemStart = scheduleItem.ScheduleStartDate > DateTime.Now
? scheduleItem.ScheduleStartDate
: scheduleItem.NextStart;
foreach (var scheduleHistoryItem in futureHistory)
{
scheduleHistoryItem.NextStart = scheduleItemStart;
SchedulingController.UpdateScheduleHistory(scheduleHistoryItem);
}
//Add schedule to queue
RunScheduleItemNow(scheduleItem);
}
private static bool IsInProgress(ScheduleItem scheduleItem)
{
try
{
using (ScheduleInProgress.GetReadLock(LockTimeout))
{
return ScheduleInProgress.Any(si => si.ScheduleID == scheduleItem.ScheduleID);
}
}
catch (ApplicationException ex)
{
// The reader lock request timed out.
Interlocked.Increment(ref _readerTimeouts);
Logger.Debug(ex);
return false;
}
}
public virtual void RunScheduleItemNow(ScheduleItem scheduleItem, bool runNow)
{
//Do Nothing
}
/// <summary>
/// Gets a schedulehistory item from the collection of schedule items in progress.
/// </summary>
/// <param name="scheduleItem"></param>
/// <remarks>Thread Safe</remarks>
private static ScheduleHistoryItem GetScheduleItemFromScheduleInProgress(ScheduleItem scheduleItem)
{
try
{
using (ScheduleInProgress.GetWriteLock(LockTimeout))
{
ScheduleHistoryItem item = ScheduleInProgress.Where(si => si.ScheduleID == scheduleItem.ScheduleID).SingleOrDefault();
return item;
}
}
catch (ApplicationException ex)
{
// The writer lock request timed out.
Interlocked.Increment(ref _writerTimeouts);
Exceptions.Exceptions.LogException(ex);
}
return null;
}
private static bool ScheduleQueueContains(ScheduleItem objScheduleItem)
{
try
{
using (ScheduleQueue.GetReadLock(LockTimeout))
{
return ScheduleQueue.Any(si => si.ScheduleID == objScheduleItem.ScheduleID);
}
}
catch (ApplicationException ex)
{
Interlocked.Increment(ref _readerTimeouts);
Exceptions.Exceptions.LogException(ex);
return false;
}
}
internal static bool IsInQueue(ScheduleItem scheduleItem)
{
try
{
using (ScheduleQueue.GetReadLock(LockTimeout))
{
return ScheduleQueue.Any(si => si.ScheduleID == scheduleItem.ScheduleID);
}
}
catch (ApplicationException)
{
// The reader lock request timed out.
Interlocked.Increment(ref _readerTimeouts);
return false;
}
}
/// <summary>
/// cmdUpdate_Click runs when the Update Button is clicked
/// </summary>
/// <returns></returns>
/// <remarks>
/// </remarks>
/// <history>
/// [cnurse] 9/28/2004 Updated to reflect design changes for Help, 508 support
/// and localisation
/// </history>
protected void cmdUpdate_Click( Object sender, EventArgs e )
{
ScheduleItem objScheduleItem = new ScheduleItem();
string strMessage;
objScheduleItem.TypeFullName = txtType.Text;
if( txtTimeLapse.Text == "" || txtTimeLapse.Text == "0" || txtTimeLapse.Text == "-1" )
{
objScheduleItem.TimeLapse = Null.NullInteger;
}
else
{
objScheduleItem.TimeLapse = Convert.ToInt32( txtTimeLapse.Text );
}
objScheduleItem.TimeLapseMeasurement = ddlTimeLapseMeasurement.SelectedItem.Value;
if( txtRetryTimeLapse.Text == "" || txtRetryTimeLapse.Text == "0" || txtRetryTimeLapse.Text == "-1" )
{
objScheduleItem.RetryTimeLapse = Null.NullInteger;
}
else
{
objScheduleItem.RetryTimeLapse = Convert.ToInt32( txtRetryTimeLapse.Text );
}
objScheduleItem.RetryTimeLapseMeasurement = ddlRetryTimeLapseMeasurement.SelectedItem.Value;
objScheduleItem.RetainHistoryNum = Convert.ToInt32( ddlRetainHistoryNum.SelectedItem.Value );
objScheduleItem.AttachToEvent = ddlAttachToEvent.SelectedItem.Value;
objScheduleItem.CatchUpEnabled = chkCatchUpEnabled.Checked;
objScheduleItem.Enabled = chkEnabled.Checked;
objScheduleItem.ObjectDependencies = txtObjectDependencies.Text;
objScheduleItem.Servers = txtServers.Text;
if( ViewState["ScheduleID"] != null )
{
objScheduleItem.ScheduleID = Convert.ToInt32( ViewState["ScheduleID"] );
SchedulingProvider.Instance().UpdateSchedule( objScheduleItem );
}
else
{
SchedulingProvider.Instance().AddSchedule( objScheduleItem );
}
strMessage = Localization.GetString( "UpdateSuccess", this.LocalResourceFile );
UI.Skins.Skin.AddModuleMessage( this, strMessage, ModuleMessageType.GreenSuccess );
if( SchedulingProvider.SchedulerMode == SchedulerMode.TIMER_METHOD )
{
SchedulingProvider.Instance().ReStart( "Change made to schedule." );
}
BindData();
cmdDelete.Visible = true;
}
public abstract int AddSchedule(ScheduleItem scheduleItem);
private ScheduleItem CreateScheduleItem()
{
var scheduleItem = new ScheduleItem();
scheduleItem.TypeFullName = txtType.Text;
scheduleItem.FriendlyName = txtFriendlyName.Text;
//DNN-4964 - values for time lapse and retry frequency can't be set to 0, -1 or left empty (client side validation has been added)
scheduleItem.TimeLapse = Convert.ToInt32(txtTimeLapse.Text);
scheduleItem.TimeLapseMeasurement = ddlTimeLapseMeasurement.SelectedItem.Value;
scheduleItem.RetryTimeLapse = Convert.ToInt32(txtRetryTimeLapse.Text);
scheduleItem.RetryTimeLapseMeasurement = ddlRetryTimeLapseMeasurement.SelectedItem.Value;
scheduleItem.RetainHistoryNum = Convert.ToInt32(ddlRetainHistoryNum.SelectedItem.Value);
scheduleItem.AttachToEvent = ddlAttachToEvent.SelectedItem.Value;
scheduleItem.CatchUpEnabled = chkCatchUpEnabled.Checked;
scheduleItem.Enabled = chkEnabled.Checked;
scheduleItem.ObjectDependencies = txtObjectDependencies.Text;
scheduleItem.ScheduleStartDate = startScheduleDatePicker.SelectedDate != null
? startScheduleDatePicker.SelectedDate.Value
: Null.NullDate;
//if servers are specified, the concatenated string needs to be prefixed and suffixed by commas ( ie. ",SERVER1,SERVER2," )
var servers = Null.NullString;
if (!String.IsNullOrEmpty(txtServers.Text))
{
servers = txtServers.Text;
}
if (!string.IsNullOrEmpty(servers))
{
if (!servers.StartsWith(","))
{
servers = "," +servers;
}
if (!servers.EndsWith(","))
{
servers = servers + ",";
}
}
scheduleItem.Servers = servers;
return scheduleItem;
}
public abstract void DeleteSchedule(ScheduleItem scheduleItem);
private static void LogWhyTaskNotRun(ScheduleItem scheduleItem)
{
if (_debug)
{
bool appended = false;
var strDebug = new StringBuilder("Task not run because ");
if (!(scheduleItem.NextStart <= DateTime.Now))
{
strDebug.Append(" task is scheduled for " + scheduleItem.NextStart);
appended = true;
}
if (!scheduleItem.Enabled)
{
if (appended)
{
strDebug.Append(" and");
}
strDebug.Append(" task is not enabled");
appended = true;
}
if (IsInProgress(scheduleItem))
{
if (appended)
{
strDebug.Append(" and");
}
strDebug.Append(" task is already in progress");
appended = true;
}
if (HasDependenciesConflict(scheduleItem))
{
if (appended)
{
strDebug.Append(" and");
}
strDebug.Append(" task has conflicting dependency");
}
var log = new LogInfo();
log.AddProperty("EVENT NOT RUN REASON", strDebug.ToString());
log.AddProperty("SCHEDULE ID", scheduleItem.ScheduleID.ToString());
log.AddProperty("TYPE FULL NAME", scheduleItem.TypeFullName);
log.LogTypeKey = "DEBUG";
LogController.Instance.AddLog(log);
}
}
public abstract void RemoveFromScheduleInProgress(ScheduleItem scheduleItem);
public abstract void UpdateSchedule(ScheduleItem scheduleItem);
private static void LogEventAddedToProcessGroup(ScheduleItem scheduleItem)
{
if (_debug)
{
var log = new LogInfo();
log.AddProperty("EVENT ADDED TO PROCESS GROUP " + scheduleItem.ProcessGroup, scheduleItem.TypeFullName);
log.AddProperty("SCHEDULE ID", scheduleItem.ScheduleID.ToString());
log.LogTypeKey = "DEBUG";
LogController.Instance.AddLog(log);
}
}
public virtual void RunScheduleItemNow(ScheduleItem scheduleItem)
{
//Do Nothing
}
public static bool HasDependenciesConflict(ScheduleItem scheduleItem)
{
try
{
using (ScheduleInProgress.GetReadLock(LockTimeout))
{
if (scheduleItem.ObjectDependencies.Any())
{
foreach (ScheduleHistoryItem item in ScheduleInProgress.Where(si => si.ObjectDependencies.Any()))
{
if (item.HasObjectDependencies(scheduleItem.ObjectDependencies))
{
return true;
}
}
}
}
return false;
}
catch (ApplicationException ex)
{
// The reader lock request timed out.
Interlocked.Increment(ref _readerTimeouts);
Logger.Debug(ex);
return false;
}
}
