/// <summary>
/// Gets a list of servers to be recommended for a particular scheduler.
/// </summary>
/// <param name="schedulerId">Scheduler Id.</param>
/// <returns>List of recommended servers for specified <paramref name="schedulerId"/>.</returns>
public IEnumerable <string> GetRecommendedServers(int schedulerId)
{
var hostSettingsService = Globals.DependencyProvider.GetRequiredService <IHostSettingsService>();
var schedulerIds = hostSettingsService.GetString(SchedulersToRunOnSameWebServerKey, string.Empty)
.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
.Where(x => int.TryParse(x, out var id))
.Select(x => int.Parse(x))
.ToArray();
if (!schedulerIds.Contains(schedulerId))
{
return(new string[0]);
}
var servers = SchedulingProvider.Instance().GetSchedule()
.Cast <ScheduleItem>()
.Where(x => x.ScheduleID != schedulerId &&
x.Enabled &&
schedulerIds.Contains(x.ScheduleID) &&
!string.IsNullOrWhiteSpace(x.Servers))
.SelectMany(x => x.Servers
.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
.Select(s => s.Trim()))
.Distinct(StringComparer.OrdinalIgnoreCase)
.OrderBy(x => x);
return(servers);
}
private void BindData()
{
if (Request.QueryString["ScheduleID"] != null)
{
ViewState["ScheduleID"] = Request.QueryString["ScheduleID"];
ScheduleItem scheduleItem = SchedulingProvider.Instance().GetSchedule(Convert.ToInt32(Request.QueryString["ScheduleID"]));
txtFriendlyName.Text = scheduleItem.FriendlyName;
txtType.Enabled = false;
txtType.Text = scheduleItem.TypeFullName;
chkEnabled.Checked = scheduleItem.Enabled;
if (scheduleItem.TimeLapse == Null.NullInteger)
{
txtTimeLapse.Text = "";
}
else
{
txtTimeLapse.Text = Convert.ToString(scheduleItem.TimeLapse);
}
if (ddlTimeLapseMeasurement.FindItemByValue(scheduleItem.TimeLapseMeasurement) != null)
{
ddlTimeLapseMeasurement.FindItemByValue(scheduleItem.TimeLapseMeasurement).Selected = true;
}
if (scheduleItem.RetryTimeLapse == Null.NullInteger)
{
txtRetryTimeLapse.Text = "";
}
else
{
txtRetryTimeLapse.Text = Convert.ToString(scheduleItem.RetryTimeLapse);
}
if (ddlRetryTimeLapseMeasurement.FindItemByValue(scheduleItem.RetryTimeLapseMeasurement) != null)
{
ddlRetryTimeLapseMeasurement.FindItemByValue(scheduleItem.RetryTimeLapseMeasurement).Selected = true;
}
if (ddlRetainHistoryNum.FindItemByValue(Convert.ToString(scheduleItem.RetainHistoryNum)) != null)
{
ddlRetainHistoryNum.FindItemByValue(Convert.ToString(scheduleItem.RetainHistoryNum)).Selected = true;
}
else
{
string scheduleItemRetainHistoryNum = scheduleItem.RetainHistoryNum.ToString();
ddlRetainHistoryNum.AddItem(scheduleItemRetainHistoryNum, scheduleItemRetainHistoryNum);
ddlRetainHistoryNum.FindItemByValue(Convert.ToString(scheduleItem.RetainHistoryNum)).Selected = true;
}
if (ddlAttachToEvent.FindItemByValue(scheduleItem.AttachToEvent) != null)
{
ddlAttachToEvent.FindItemByValue(scheduleItem.AttachToEvent).Selected = true;
}
chkCatchUpEnabled.Checked = scheduleItem.CatchUpEnabled;
txtObjectDependencies.Text = scheduleItem.ObjectDependencies;
BindServers(scheduleItem.Servers);
}
else
{
cmdDelete.Visible = false;
cmdRun.Visible = false;
txtType.Enabled = true;
}
}
private void BindData()
{
ScheduleItem objScheduleItem;
if (Request.QueryString["ScheduleID"] != null)
{
ViewState["ScheduleID"] = Request.QueryString["ScheduleID"];
objScheduleItem = SchedulingProvider.Instance().GetSchedule(Convert.ToInt32(Request.QueryString["ScheduleID"]));
txtType.Enabled = false;
txtType.Text = objScheduleItem.TypeFullName;
chkEnabled.Checked = objScheduleItem.Enabled;
if (objScheduleItem.TimeLapse == Null.NullInteger)
{
txtTimeLapse.Text = "";
}
else
{
txtTimeLapse.Text = Convert.ToString(objScheduleItem.TimeLapse);
}
if (ddlTimeLapseMeasurement.Items.FindByValue(objScheduleItem.TimeLapseMeasurement) != null)
{
ddlTimeLapseMeasurement.Items.FindByValue(objScheduleItem.TimeLapseMeasurement).Selected = true;
}
if (objScheduleItem.RetryTimeLapse == Null.NullInteger)
{
txtRetryTimeLapse.Text = "";
}
else
{
txtRetryTimeLapse.Text = Convert.ToString(objScheduleItem.RetryTimeLapse);
}
if (ddlRetryTimeLapseMeasurement.Items.FindByValue(objScheduleItem.RetryTimeLapseMeasurement) != null)
{
ddlRetryTimeLapseMeasurement.Items.FindByValue(objScheduleItem.RetryTimeLapseMeasurement).Selected = true;
}
if (ddlRetainHistoryNum.Items.FindByValue(Convert.ToString(objScheduleItem.RetainHistoryNum)) != null)
{
ddlRetainHistoryNum.Items.FindByValue(Convert.ToString(objScheduleItem.RetainHistoryNum)).Selected = true;
}
else
{
ddlRetainHistoryNum.Items.Add(objScheduleItem.RetainHistoryNum.ToString());
ddlRetainHistoryNum.Items.FindByValue(Convert.ToString(objScheduleItem.RetainHistoryNum)).Selected = true;
}
if (ddlAttachToEvent.Items.FindByValue(objScheduleItem.AttachToEvent) != null)
{
ddlAttachToEvent.Items.FindByValue(objScheduleItem.AttachToEvent).Selected = true;
}
chkCatchUpEnabled.Checked = objScheduleItem.CatchUpEnabled;
txtObjectDependencies.Text = objScheduleItem.ObjectDependencies;
txtServers.Text = objScheduleItem.Servers;
}
else
{
cmdDelete.Visible = false;
txtType.Enabled = true;
}
}
private void CreateTempFileScheduledJob()
{
try
{
var scheduledJobs = SchedulingProvider.Instance().GetSchedule(); // retrieves all scheduled jobs
var jobList = ConvertArrayList(scheduledJobs);
var job = jobList.FirstOrDefault(s => s.TypeFullName == SCHEDULED_JOB_TYPE);
if (job == null || job.ScheduleID == Null.NullInteger)
{
// the scheduled job doesn't exist yet
SchedulingProvider.Instance().AddSchedule(new ScheduleItem
{
TypeFullName = SCHEDULED_JOB_TYPE,
TimeLapseMeasurement = "w", // week
TimeLapse = 1,
RetryTimeLapseMeasurement = "m", // minutes
RetryTimeLapse = 30,
RetainHistoryNum = 10,
FriendlyName = SCHEDULED_JOB_NAME,
Enabled = true,
CatchUpEnabled = false
});
Logger.Debug("Created the scheduled job to clear temporary files created by Hotcakes Commerce.");
}
}
catch (Exception ex)
{
Logger.Error(ex.Message, ex);
throw ex;
}
}
/// <inheritdoc/>
public override void AddLog(LogInfo logInfo)
{
string configPortalID = logInfo.LogPortalID != Null.NullInteger
? logInfo.LogPortalID.ToString()
: "*";
var logTypeConfigInfo = this.GetLogTypeConfigInfoByKey(logInfo.LogTypeKey, configPortalID);
if (logTypeConfigInfo == null || logTypeConfigInfo.LoggingIsActive == false)
{
return;
}
logInfo.LogConfigID = logTypeConfigInfo.ID;
var logQueueItem = new LogQueueItem {
LogInfo = logInfo, LogTypeConfigInfo = logTypeConfigInfo
};
SchedulingProvider scheduler = SchedulingProvider.Instance();
if (scheduler == null || logInfo.BypassBuffering || SchedulingProvider.Enabled == false ||
scheduler.GetScheduleStatus() == ScheduleStatus.STOPPED || !Host.EventLogBuffer)
{
WriteLog(logQueueItem);
}
else
{
LogQueue.Add(logQueueItem);
}
}
public override ConsoleResultModel Run()
{
try
{
var taskToUpdate = SchedulingProvider.Instance().GetSchedule(this.TaskId);
var tasks = new List <TaskModel>();
if (taskToUpdate == null)
{
return(new ConsoleErrorResultModel(string.Format(this.LocalizeString("Prompt_TaskNotFound"), this.TaskId)));
}
if (taskToUpdate.Enabled == this.Enabled)
{
return(new ConsoleErrorResultModel(this.LocalizeString(this.Enabled ? "Prompt_TaskAlreadyEnabled" : "Prompt_TaskAlreadyDisabled")));
}
taskToUpdate.Enabled = this.Enabled;
SchedulingProvider.Instance().UpdateSchedule(taskToUpdate);
tasks.Add(new TaskModel(taskToUpdate));
return(new ConsoleResultModel(this.LocalizeString("Prompt_TaskUpdated"))
{
Records = tasks.Count,
Data = tasks,
});
}
catch (Exception exc)
{
Logger.Error(exc);
return(new ConsoleErrorResultModel(this.LocalizeString("Prompt_TaskUpdateFailed")));
}
}
public void CreateAbandonedCartScheduler()
{
var friendlyName = "Send Abandoned Cart Emails";
var typeFullName = "Hotcakes.Modules.Core.AbandonedCartEmailJob, Hotcakes.Modules";
var schedules = SchedulingProvider.Instance().GetSchedule().OfType <ScheduleItem>();
if (!schedules.Any(s => s.FriendlyName == friendlyName))
{
var oItem = new ScheduleItem
{
FriendlyName = friendlyName,
TypeFullName = typeFullName,
Enabled = true,
CatchUpEnabled = false,
RetainHistoryNum = 0,
TimeLapse = 1,
TimeLapseMeasurement = "h",
RetryTimeLapse = 1,
RetryTimeLapseMeasurement = "h",
ScheduleSource = ScheduleSource.NOT_SET
};
SchedulingProvider.Instance().AddSchedule(oItem);
}
}
public static void RunSchedule(HttpRequest request)
{
DnnLog.MethodEntry();
//First check if we are upgrading/installing
if (request.Url.LocalPath.ToLower().EndsWith("install.aspx") ||
request.Url.LocalPath.ToLower().EndsWith("upgradewizard.aspx") ||
request.Url.LocalPath.ToLower().EndsWith("installwizard.aspx"))
{
return;
}
try
{
if (SchedulingProvider.SchedulerMode == SchedulerMode.REQUEST_METHOD && SchedulingProvider.ReadyForPoll)
{
DnnLog.Trace("Running Schedule " + (SchedulingProvider.SchedulerMode));
SchedulingProvider scheduler = SchedulingProvider.Instance();
var requestScheduleThread = new Thread(scheduler.ExecuteTasks);
requestScheduleThread.IsBackground = true;
requestScheduleThread.Start();
SchedulingProvider.ScheduleLastPolled = DateTime.Now;
}
}
catch (Exception exc)
{
Exceptions.LogException(exc);
}
}
/// <summary>
/// Application_BeginRequest
/// Executes when the request is initiated
/// </summary>
protected void Application_BeginRequest(object sender, EventArgs e)
{
//First check if we are upgrading/installing
if (Request.Url.LocalPath.EndsWith("Install.aspx"))
{
return;
}
try
{
if (SchedulingProvider.SchedulerMode == SchedulerMode.REQUEST_METHOD && SchedulingProvider.ReadyForPoll)
{
SchedulingProvider scheduler = SchedulingProvider.Instance();
Thread RequestScheduleThread;
RequestScheduleThread = new Thread(new ThreadStart(scheduler.ExecuteTasks));
RequestScheduleThread.IsBackground = true;
RequestScheduleThread.Start();
SchedulingProvider.ScheduleLastPolled = DateTime.Now;
}
}
catch (Exception exc)
{
Exceptions.LogException(exc);
}
}
/// <summary>
/// Page_Load runs when the control is loaded.
/// </summary>
/// <returns></returns>
/// <remarks>
/// </remarks>
/// <history>
/// [cnurse] 9/28/2004 Updated to reflect design changes for Help, 508 support
/// and localisation
/// </history>
protected void Page_Load(Object sender, EventArgs e)
{
try
{
if (!Page.IsPostBack)
{
int ScheduleID;
if (Request.QueryString["ScheduleID"] != null)
{
//get history for specific scheduleid
ScheduleID = Convert.ToInt32(Request.QueryString["ScheduleID"]);
}
else
{
//get history for all schedules
ScheduleID = -1;
}
ArrayList arrSchedule = SchedulingProvider.Instance().GetScheduleHistory(ScheduleID);
arrSchedule.Sort(new ScheduleHistorySortStartDate());
//Localize Grid
Localization.LocalizeDataGrid(ref dgScheduleHistory, this.LocalResourceFile);
dgScheduleHistory.DataSource = arrSchedule;
dgScheduleHistory.DataBind();
}
}
catch (Exception exc) //Module failed to load
{
Exceptions.ProcessModuleLoadException(this, exc);
}
}
public static ScheduleItem EnableScheduleItem(string typeName, string assembly)
{
var fullTypeName = typeName + ", " + assembly;
var provider = SchedulingProvider.Instance();
var item = GetScheduleItem(fullTypeName);
if (item == null)
{
item = new ScheduleItem();
item.CatchUpEnabled = false;
item.FriendlyName = typeName;
item.RetainHistoryNum = 50;
item.RetryTimeLapse = -1;
item.RetryTimeLapseMeasurement = "s";
item.TimeLapse = 5;
item.TimeLapseMeasurement = "m";
item.TypeFullName = fullTypeName;
item.ScheduleID = provider.AddSchedule(item);
}
item.Enabled = true;
provider.UpdateSchedule(item);
return(item);
}
private void SetScheduledTask(string typefullname)
{
var t = SchedulingProvider.Instance().GetSchedule(typefullname, string.Empty);
if (t != null)
{
return;
}
var i = new ScheduleItem();
i.CatchUpEnabled = false;
i.Enabled = true;
i.NextStart = DateTime.Now.AddMinutes(1);
i.RetainHistoryNum = 50;
i.TypeFullName = typefullname;
i.ScheduleSource = ScheduleSource.NOT_SET;
// set custom settings
i.FriendlyName = "AMP Runner";
i.TimeLapse = 1;
i.TimeLapseMeasurement = "d";
i.RetryTimeLapse = 1;
i.RetryTimeLapseMeasurement = "h";
SchedulingProvider.Instance().AddSchedule(i);
}
protected void UpdateSchedule()
{
var originalSchedulerMode = (SchedulerMode)Convert.ToInt32(ViewState["SelectedSchedulerMode"]);
var newSchedulerMode = (SchedulerMode)Enum.Parse(typeof(SchedulerMode), cboSchedulerMode.SelectedItem.Value);
if (originalSchedulerMode != newSchedulerMode)
{
switch (newSchedulerMode)
{
case SchedulerMode.DISABLED:
SchedulingProvider.Instance().Halt("Host Settings");
break;
case SchedulerMode.TIMER_METHOD:
var newThread = new Thread(SchedulingProvider.Instance().Start)
{
IsBackground = true
};
newThread.Start();
break;
default:
SchedulingProvider.Instance().Halt("Host Settings");
break;
}
}
}
protected void bUpdateIndex_Click(object sender, EventArgs e)
{
var sc = SchedulingProvider.Instance();
var schedule = sc.GetSchedule("Satrabel.OpenFiles.Components.Lucene.SearchEngineScheduler, OpenFiles", "");
if (schedule != null)
{
var startDate = DateTime.Now;
var lastSuccessFulDateTime = SearchHelper.Instance.GetLastSuccessfulIndexingDateTime(schedule.ScheduleID);
Log.Logger.Trace("Search: File Crawler - Starting. Content change start time " + lastSuccessFulDateTime.ToString("g"));
var searchEngine = LuceneController.Instance;
try
{
searchEngine.IndexContent(lastSuccessFulDateTime);
}
catch (Exception ex)
{
Log.Logger.ErrorFormat("Failed executing Scheduled Reindexing. Error: {0}", ex.Message);
}
finally
{
//searchEngine.Commit();
}
SearchHelper.Instance.SetLastSuccessfulIndexingDateTime(schedule.ScheduleID, startDate);
Log.Logger.Trace("Search: File Crawler - Indexing Successful");
}
}
protected void UpdateSchedule()
{
bool restartSchedule = false;
bool usersOnLineChanged = (Convert.ToBoolean(ViewState["SelectedUsersOnlineEnabled"]) != chkUsersOnline.Checked);
if (usersOnLineChanged)
{
ScheduleItem scheduleItem = SchedulingProvider.Instance().GetSchedule("DotNetNuke.Entities.Users.PurgeUsersOnline, DOTNETNUKE", Null.NullString);
if (scheduleItem != null)
{
scheduleItem.Enabled = chkUsersOnline.Checked;
SchedulingProvider.Instance().UpdateSchedule(scheduleItem);
restartSchedule = true;
}
}
bool logBufferChanged = (Convert.ToBoolean(ViewState["SelectedLogBufferEnabled"]) != chkLogBuffer.Checked);
if (logBufferChanged)
{
var scheduleItem = SchedulingProvider.Instance().GetSchedule("DotNetNuke.Services.Log.EventLog.PurgeLogBuffer, DOTNETNUKE", Null.NullString);
if (scheduleItem != null)
{
scheduleItem.Enabled = chkLogBuffer.Checked;
SchedulingProvider.Instance().UpdateSchedule(scheduleItem);
restartSchedule = true;
}
}
}
/// <summary>
/// cmdUpdate_Click runs when the Update 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 OnUpdateClick(Object sender, EventArgs e)
{
if (VerifyValidTimeLapseRetry() == false)
{
return;
}
var objScheduleItem = CreateScheduleItem();
if (ViewState["ScheduleID"] != null)
{
objScheduleItem.ScheduleID = Convert.ToInt32(ViewState["ScheduleID"]);
SchedulingProvider.Instance().UpdateSchedule(objScheduleItem);
}
else
{
SchedulingProvider.Instance().AddSchedule(objScheduleItem);
}
var strMessage = Localization.GetString("UpdateSuccess", LocalResourceFile);
UI.Skins.Skin.AddModuleMessage(this, strMessage, ModuleMessage.ModuleMessageType.GreenSuccess);
if (SchedulingProvider.SchedulerMode == SchedulerMode.TIMER_METHOD)
{
SchedulingProvider.Instance().ReStart("Change made to schedule.");
}
Response.Redirect(Globals.NavigateURL(), true);
}
/// <summary>
/// Returns the last time search indexing was completed successfully.
/// The returned value in local server time (not UTC).
/// Beware that the value stored in teh database is converted to UTC time.
/// </summary>
/// <returns></returns>
public DateTime GetLastSuccessfulIndexingDateTime(int scheduleId)
{
var settings = SchedulingProvider.Instance().GetScheduleItemSettings(scheduleId);
var lastValue = settings[Constants.SearchLastSuccessIndexName] as string;
if (string.IsNullOrEmpty(lastValue))
{
// try to fallback to old location where this was stored
var name = string.Format(LastIndexKeyFormat, Constants.SearchLastSuccessIndexName, scheduleId);
lastValue = HostController.Instance.GetString(name, Null.NullString);
}
DateTime lastTime;
if (!string.IsNullOrEmpty(lastValue) &&
DateTime.TryParseExact(lastValue, Constants.ReindexDateTimeFormat, null, DateTimeStyles.None, out lastTime))
{
// retrieves the date as UTC but returns to caller as local
lastTime = FixSqlDateTime(lastTime).ToLocalTime().ToLocalTime();
if (lastTime > DateTime.Now)
{
lastTime = DateTime.Now;
}
}
else
{
lastTime = SqlDateTime.MinValue.Value.AddDays(1);
}
return(lastTime);
}
/// <summary>
/// Returns the last time search indexing was completed successfully.
/// The returned value in local server time (not UTC).
/// </summary>
/// <param name="scheduleId"></param>
/// <returns></returns>
public DateTime GetLastSuccessfulIndexingDateTime(int scheduleId)
{
var lastSuccessfulDateTime = SqlDateTime.MinValue.Value.AddDays(1);
var settings = SchedulingProvider.Instance().GetScheduleItemSettings(scheduleId);
var lastValue = settings[Constants.SearchLastSuccessIndexName] as string;
if (string.IsNullOrEmpty(lastValue))
{
// try to fallback to old location where this was stored
var name = string.Format(LastIndexKeyFormat, Constants.SearchLastSuccessIndexName, scheduleId);
lastValue = HostController.Instance.GetString(name, Null.NullString);
}
if (!string.IsNullOrEmpty(lastValue))
{
DateTime.TryParseExact(lastValue, Constants.ReindexDateTimeFormat, null, DateTimeStyles.None, out lastSuccessfulDateTime);
if (lastSuccessfulDateTime <= SqlDateTime.MinValue.Value)
{
lastSuccessfulDateTime = SqlDateTime.MinValue.Value.AddDays(1);
}
else if (lastSuccessfulDateTime >= SqlDateTime.MaxValue.Value)
{
lastSuccessfulDateTime = SqlDateTime.MaxValue.Value.AddDays(-1);
}
}
return(lastSuccessfulDateTime);
}
private void AddBBStoreScheduler()
{
ArrayList scheduleItems = SchedulingProvider.Instance().GetSchedule();
ScheduleItem scheduleItem = null;
// find schedule item with matching TypeFullName
foreach (object item in scheduleItems)
{
if (((ScheduleItem)item).TypeFullName == "Bitboxx.DNNModules.BBStore.Components.BBStoreScheduler, Bitboxx.DNNModules.BBStore")
{
scheduleItem = (ScheduleItem)item;
break;
}
}
// If we have no scheduler Task we create one!
if (scheduleItem == null)
{
scheduleItem = new ScheduleItem();
scheduleItem.FriendlyName = "BBStore Maintenance Schedule";
scheduleItem.TypeFullName = "Bitboxx.DNNModules.BBStore.Components.BBStoreScheduler, Bitboxx.DNNModules.BBStore";
scheduleItem.TimeLapse = 6; // execution frequency
scheduleItem.TimeLapseMeasurement = "h"; // "s" for seconds, "m" for minutes, "h" for hours, "d" for days
scheduleItem.RetryTimeLapse = 10; // retry frequency
scheduleItem.RetryTimeLapseMeasurement = "m"; // "s" for seconds, "m" for minutes, "h" for hours, "d" for days
scheduleItem.RetainHistoryNum = 14;
scheduleItem.AttachToEvent = "None"; //for instance "APPLICATION_START" or "None"
scheduleItem.CatchUpEnabled = false;
scheduleItem.Enabled = true;
scheduleItem.ObjectDependencies = ""; //for example "SiteLog,Users,UsersOnline"
scheduleItem.Servers = ""; // (Optional)
scheduleItem.ScheduleID = SchedulingProvider.Instance().AddSchedule(scheduleItem);
}
}
internal static dynamic GetSchedule_Item(int scheduleId)
{
dynamic Result = new ExpandoObject();
try
{
ScheduleItem scheduleItem = SchedulingProvider.Instance().GetSchedule(scheduleId);
Result.Data = new
{
scheduleItem.ScheduleID,
scheduleItem.FriendlyName,
scheduleItem.TypeFullName,
scheduleItem.Enabled,
ScheduleStartDate = !Null.IsNull(scheduleItem.ScheduleStartDate) ? scheduleItem.ScheduleStartDate.ToString(CultureInfo.CurrentCulture.DateTimeFormat.SortableDateTimePattern) : "",
Locale = CultureInfo.CurrentCulture.TwoLetterISOLanguageName,
scheduleItem.TimeLapse,
scheduleItem.TimeLapseMeasurement,
scheduleItem.RetryTimeLapse,
scheduleItem.RetryTimeLapseMeasurement,
scheduleItem.RetainHistoryNum,
scheduleItem.AttachToEvent,
scheduleItem.CatchUpEnabled,
scheduleItem.ObjectDependencies,
scheduleItem.Servers
};
Result.Status = "Success";
return(Result);
}
catch (Exception exc)
{
Exceptions.LogException(exc);
return(Result.Status = exc.Message.ToString());
}
}
public void UpdateRecurringOrdersScheduler()
{
var friendlyName = "Update Recurring Orders";
var typeFullName = "Hotcakes.Modules.Core.UpdateRecurringOrdersJob, Hotcakes.Modules";
var schedules = SchedulingProvider.Instance().GetSchedule().OfType <ScheduleItem>();
if (!schedules.Any(s => s.FriendlyName == friendlyName))
{
var oItem = new ScheduleItem
{
FriendlyName = friendlyName,
TypeFullName = typeFullName,
Enabled = false,
CatchUpEnabled = false,
RetainHistoryNum = 0,
TimeLapse = 8,
TimeLapseMeasurement = "h",
RetryTimeLapse = 8,
RetryTimeLapseMeasurement = "h",
ScheduleSource = ScheduleSource.NOT_SET
};
SchedulingProvider.Instance().AddSchedule(oItem);
}
}
/// <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);
}
}
/// <summary>
/// Does the work.
/// </summary>
public override void DoWork()
{
try
{
// Notification that the event is progressing
this.Progressing();
// Purge schedule history
SchedulingProvider.Instance().PurgeScheduleHistory();
// Update the result to success since no exception was thrown
this.ScheduleHistoryItem.Succeeded = true;
this.ScheduleHistoryItem.AddLogNote("Purged Schedule History");
}
catch (Exception exc)
{
this.ScheduleHistoryItem.Succeeded = false;
this.ScheduleHistoryItem.AddLogNote("EXCEPTION: " + exc.ToString());
// Notification that we have errored
this.Errored(ref exc);
// Log the exception
//TODO: Throw exception
// Exceptions.LogException(exc);
}
}
public static void Install()
{
ScheduleItem item = SchedulingProvider.Instance().GetSchedule("DotNetNuke.Services.Search.SearchEngineScheduler, DOTNETNUKE", string.Empty);
if (item != null)
{
SchedulingProvider.Instance().DeleteSchedule(item);
}
if (SchedulingProvider.Instance().GetSchedule("Vanjaro.Core.Services.Search.SearchEngineScheduler,Vanjaro.Core", string.Empty) == null)
{
ScheduleItem Manager = new ScheduleItem
{
TypeFullName = "Vanjaro.Core.Services.Search.SearchEngineScheduler,Vanjaro.Core",
Enabled = true,
TimeLapse = 1,
TimeLapseMeasurement = "m",
RetryTimeLapse = 30,
RetryTimeLapseMeasurement = "s",
RetainHistoryNum = 60,
FriendlyName = "Search: Site Crawler"
};
SchedulingProvider.Instance().AddSchedule(Manager);
}
}
private void BindData()
{
lblFreeThreads.Text = SchedulingProvider.Instance().GetFreeThreadCount().ToString();
lblActiveThreads.Text = SchedulingProvider.Instance().GetActiveThreadCount().ToString();
lblMaxThreads.Text = SchedulingProvider.Instance().GetMaxThreadCount().ToString();
Collection arrScheduleQueue = SchedulingProvider.Instance().GetScheduleQueue();
if (arrScheduleQueue.Count == 0)
{
pnlScheduleQueue.Visible = false;
}
else
{
dgScheduleQueue.DataSource = arrScheduleQueue;
dgScheduleQueue.DataBind();
}
Collection arrScheduleProcessing = SchedulingProvider.Instance().GetScheduleProcessing();
if (arrScheduleProcessing.Count == 0)
{
pnlScheduleProcessing.Visible = false;
}
else
{
dgScheduleProcessing.DataSource = arrScheduleProcessing;
dgScheduleProcessing.DataBind();
}
if (arrScheduleProcessing.Count == 0 && arrScheduleQueue.Count == 0)
{
var strMessage = Localization.GetString("NoTasks", LocalResourceFile);
UI.Skins.Skin.AddModuleMessage(this, strMessage, ModuleMessage.ModuleMessageType.YellowWarning);
}
}
public HttpResponseMessage GetScheduleItemHistory(int scheduleId = -1, int pageIndex = 0, int pageSize = 20)
{
try
{
var arrSchedule = SchedulingProvider.Instance().GetScheduleHistory(scheduleId);
var query = from ScheduleHistoryItem history in arrSchedule
select new
{
history.FriendlyName,
history.LogNotes,
history.Server,
ElapsedTime = Math.Round(history.ElapsedTime, 3),
history.Succeeded,
StartDate = !Null.IsNull(history.StartDate) ? history.StartDate.ToString() : "",
EndDate = !Null.IsNull(history.EndDate) ? history.EndDate.ToString() : "",
NextStart = !Null.IsNull(history.NextStart) ? history.NextStart.ToString() : ""
};
var response = new
{
Success = true,
Results = query.Skip(pageIndex * pageSize).Take(pageSize),
TotalResults = query.Count()
};
return(Request.CreateResponse(HttpStatusCode.OK, response));
}
catch (Exception exc)
{
Logger.Error(exc);
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, exc));
}
}
/// <summary>Gets the schedule item date setting.</summary>
/// <param name="settingKey">The setting key.</param>
/// <returns>The date the schedule was ran</returns>
private DateTime GetScheduleItemDateSetting(string settingKey)
{
var colScheduleItemSettings = SchedulingProvider.Instance().GetScheduleItemSettings(ScheduleHistoryItem.ScheduleID);
var dateValue = DateTime.Now;
if (colScheduleItemSettings.Count > 0)
{
if (colScheduleItemSettings.ContainsKey(settingKey))
{
dateValue = Convert.ToDateTime(colScheduleItemSettings[settingKey], CultureInfo.InvariantCulture);
}
}
else
{
SchedulingProvider.Instance().AddScheduleItemSetting(
ScheduleHistoryItem.ScheduleID, SettingLastHourlyRun, dateValue.ToString(CultureInfo.InvariantCulture));
SchedulingProvider.Instance().AddScheduleItemSetting(
ScheduleHistoryItem.ScheduleID, SettingLastDailyRun, dateValue.ToString(CultureInfo.InvariantCulture));
SchedulingProvider.Instance().AddScheduleItemSetting(
ScheduleHistoryItem.ScheduleID, SettingLastWeeklyRun, dateValue.ToString(CultureInfo.InvariantCulture));
SchedulingProvider.Instance().AddScheduleItemSetting(
ScheduleHistoryItem.ScheduleID, SettingLastMonthlyRun, dateValue.ToString(CultureInfo.InvariantCulture));
}
return(dateValue);
}
public HttpResponseMessage CreateScheduleItem(ScheduleDto scheduleDto)
{
try
{
if (scheduleDto.RetryTimeLapse == 0)
{
scheduleDto.RetryTimeLapse = Null.NullInteger;
}
if (!VerifyValidTimeLapseRetry(scheduleDto.TimeLapse, scheduleDto.TimeLapseMeasurement, scheduleDto.RetryTimeLapse, scheduleDto.RetryTimeLapseMeasurement))
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, Localization.GetString("InvalidFrequencyAndRetry", localResourcesFile)));
}
var scheduleItem = _controller.CreateScheduleItem(scheduleDto.TypeFullName, scheduleDto.FriendlyName, scheduleDto.TimeLapse, scheduleDto.TimeLapseMeasurement,
scheduleDto.RetryTimeLapse, scheduleDto.RetryTimeLapseMeasurement, scheduleDto.RetainHistoryNum, scheduleDto.AttachToEvent, scheduleDto.CatchUpEnabled,
scheduleDto.Enabled, scheduleDto.ObjectDependencies, scheduleDto.ScheduleStartDate, scheduleDto.Servers);
SchedulingProvider.Instance().AddSchedule(scheduleItem);
return(Request.CreateResponse(HttpStatusCode.OK, new { Success = true }));
}
catch (Exception exc)
{
Logger.Error(exc);
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, exc));
}
}
protected void UpdateSchedule()
{
bool restartSchedule = false;
bool usersOnLineChanged = (Convert.ToBoolean(ViewState["SelectedUsersOnlineEnabled"]) != chkUsersOnline.Checked);
if (usersOnLineChanged)
{
ScheduleItem scheduleItem = SchedulingProvider.Instance().GetSchedule("DotNetNuke.Entities.Users.PurgeUsersOnline, DOTNETNUKE", Null.NullString);
if (scheduleItem != null)
{
scheduleItem.Enabled = chkUsersOnline.Checked;
SchedulingProvider.Instance().UpdateSchedule(scheduleItem);
restartSchedule = true;
}
}
bool logBufferChanged = (Convert.ToBoolean(ViewState["SelectedLogBufferEnabled"]) != chkLogBuffer.Checked);
if (logBufferChanged)
{
var scheduleItem = SchedulingProvider.Instance().GetSchedule("DotNetNuke.Services.Log.EventLog.PurgeLogBuffer, DOTNETNUKE", Null.NullString);
if (scheduleItem != null)
{
scheduleItem.Enabled = chkLogBuffer.Checked;
SchedulingProvider.Instance().UpdateSchedule(scheduleItem);
restartSchedule = true;
}
}
var originalSchedulerMode = (SchedulerMode)Convert.ToInt32(ViewState["SelectedSchedulerMode"]);
var newSchedulerMode = (SchedulerMode)Enum.Parse(typeof(SchedulerMode), cboSchedulerMode.SelectedItem.Value);
if (originalSchedulerMode != newSchedulerMode)
{
switch (newSchedulerMode)
{
case SchedulerMode.DISABLED:
SchedulingProvider.Instance().Halt("Host Settings");
break;
case SchedulerMode.TIMER_METHOD:
var newThread = new Thread(SchedulingProvider.Instance().Start)
{
IsBackground = true
};
newThread.Start();
break;
default:
SchedulingProvider.Instance().Halt("Host Settings");
break;
}
}
if (restartSchedule && newSchedulerMode == SchedulerMode.TIMER_METHOD)
{
SchedulingProvider.Instance().ReStart("Host Settings");
}
}
/// <summary>
/// Gets list of servers to be recommended for the particular scheduler.
/// </summary>
/// <param name="schedulerId">Scheduler Id</param>
/// <returns>List of recommended servers</returns>
public IEnumerable <string> GetRecommendedServers(int schedulerId)
{
var recommendedServers = new List <string>();
var schedulersToRunOnSameWebServer = HostController.Instance.GetString(
"SchedulersToRunOnSameWebServer",
string.Empty);
var schedulers = schedulersToRunOnSameWebServer.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
if (!schedulers.Any() || !schedulers.Select(x => x.Trim()).Contains(schedulerId.ToString()))
{
return(recommendedServers);
}
foreach (var scheduler in schedulers)
{
if (!int.TryParse(scheduler.Trim(), out int id) || id == schedulerId)
{
continue;
}
var schedule = SchedulingProvider.Instance().GetSchedule(id);
if (schedule != null && schedule.Enabled && !string.IsNullOrWhiteSpace(schedule.Servers))
{
recommendedServers.AddRange(schedule.Servers.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries));
}
}
return(recommendedServers.Distinct().OrderBy(x => x));
}
