public static bool IsJobScheduledToRunNow(JobSchedule jobSchedule, DateTime NOW)
{
switch (jobSchedule.JobScheduleType)
{
case JobScheduleTypeEnum.JobScheduleDaily:
JobScheduleDaily daily = JsonConvert.DeserializeObject <JobScheduleDaily>(jobSchedule.ScheduleConfig.ToString());
return(IsTimeToRunNow(GetDailyTime(daily, NOW), NOW));
case JobScheduleTypeEnum.JobScheduleWeekly:
JobScheduleWeekly weekly = JsonConvert.DeserializeObject <JobScheduleWeekly>(jobSchedule.ScheduleConfig.ToString());
return(DoWeeklyCheck(weekly, NOW));
case JobScheduleTypeEnum.JobScheduleMonthly:
JobScheduleMonthly monthly = JsonConvert.DeserializeObject <JobScheduleMonthly>(jobSchedule.ScheduleConfig.ToString());
return(IsTimeToRunNow(GetMonthlyTime(monthly, NOW), NOW));
case JobScheduleTypeEnum.JobScheduleYearly:
JobScheduleYearly yearly = JsonConvert.DeserializeObject <JobScheduleYearly>(jobSchedule.ScheduleConfig.ToString());
return(IsTimeToRunNow(GetYearlyTime(yearly, NOW), NOW));
case JobScheduleTypeEnum.JobScheduleOneTimeOnly:
JobScheduleOneTimeOnly oneTime = JsonConvert.DeserializeObject <JobScheduleOneTimeOnly>(jobSchedule.ScheduleConfig.ToString());
return(DoOneTimeOnlyCheck(oneTime, NOW));
default:
throw new Exception("Unknown Schedule Type: " + jobSchedule.JobScheduleType.ToString());
}
}
public void WeeklyOvernightTest_Last()
{
JobScheduleWeekly schedule = new JobScheduleWeekly();
schedule.Day = new JobScheduleWeeklyDay();
schedule.Day.DayName = DayName.Sunday;
schedule.Day.Time = GetOvernightTime();
schedule.Day.WeekRecurrence = WeekRecurrence.Last;
RunForWeekly(schedule, 0);
}
public void WeeklyOvernightTest_Sixth()
{
JobScheduleWeekly schedule = new JobScheduleWeekly();
schedule.Day = new JobScheduleWeeklyDay();
schedule.Day.DayName = DayName.Sunday;
schedule.Day.Time = GetOvernightTime();
schedule.Day.WeekRecurrence = WeekRecurrence.Sixth;
RunForWeekly(schedule, (int)schedule.Day.WeekRecurrence);
}
public void WeeklyDayTest_Fifth()
{
JobScheduleWeekly schedule = new JobScheduleWeekly();
schedule.Day = new JobScheduleWeeklyDay();
schedule.Day.DayName = DayName.Sunday;
schedule.Day.Time = GetDayTime();
schedule.Day.WeekRecurrence = WeekRecurrence.Fifth;
RunForWeekly(schedule, (int)schedule.Day.WeekRecurrence);
}
private static void SetupWeeklyRunOnce()
{
weeklyRunOnceJob.JobName = "Test_WeeklyRunOnce";
weeklyRunOnceJob.ExecuteTimes = 1;
JobScheduleWeekly weekly = new JobScheduleWeekly();
weekly.Day = new JobScheduleWeeklyDay();
weekly.Day.DayName = DayName.Friday;
weekly.Day.Time = new Time();
weekly.Day.Time.StartTime = new DateTime(1, 1, 1, 2, 0, 0);
AddJobToEngine(weeklyRunOnceJob, weekly);
}
public void WeeklyRunOnce()
{
List <DateTime> expectedDates = new List <DateTime>();
JobScheduleWeekly weekly = ((JobScheduleWeekly)weeklyRunOnceJob.Schedules[0].ScheduleConfig);
DateTime s = t.StartTime.Add(weekly.Day.Time.StartTime.TimeOfDay);
while (s.DayOfWeek.ToString() != weekly.Day.DayName.ToString())
{
s = s.AddDays(1);
}
while (s <= t.EndTime)
{
expectedDates.Add(s);
s = s.AddDays(7);
}
VerifyRun(weeklyRunOnceJob.JobName, expectedDates);
}
private static bool DoWeeklyCheck(JobScheduleWeekly weekly, DateTime NOW)
{
DateTime OriginalNOW = NOW;
if (weekly.Day.Time.StartTime.TimeOfDay > weekly.Day.Time.EndTime.TimeOfDay)
{
//has overnight, if we are running for next day, set now one day back
if (NOW.TimeOfDay <= weekly.Day.Time.EndTime.TimeOfDay)
{
NOW = NOW.AddDays(-1);
}
}
if (weekly.Day.DayName.ToString() != NOW.DayOfWeek.ToString())
{
return(false);
}
int weekOfMonth = DateTimeExtensions.GetWeekOfMonth(NOW);
if (weekly.Day.WeekRecurrence != WeekRecurrence.Every)
{
if (weekly.Day.WeekRecurrence == WeekRecurrence.Last)
{
if (NOW.Day <= (DateTime.DaysInMonth(NOW.Year, NOW.Month) - 7))
{
return(false);
}
}
else if (weekOfMonth != (int)weekly.Day.WeekRecurrence)
{
return(false);
}
}
//week related checks are done, just need to check if time is fine now
weekly.Day.Time.StartTime = new DateTime(NOW.Year, NOW.Month, NOW.Day).Add(weekly.Day.Time.StartTime.TimeOfDay);
weekly.Day.Time.EndTime = new DateTime(NOW.Year, NOW.Month, NOW.Day).Add(weekly.Day.Time.EndTime.TimeOfDay);
return(IsTimeToRunNow(AdjustIfOvernight(weekly.Day.Time), OriginalNOW));
}
public void WeeklyDayTest_Every()
{
JobSchedule WeeklyDaySchedule = new JobSchedule();
JobScheduleWeekly schedule = new JobScheduleWeekly();
schedule.Day = new JobScheduleWeeklyDay();
schedule.Day.DayName = DayName.Sunday;
schedule.Day.Time = GetDayTime();
schedule.Day.WeekRecurrence = WeekRecurrence.Every;
WeeklyDaySchedule.ScheduleConfig = schedule;
DateTime dt = startTestTime.AddMonths(-2);
while ((int)dt.DayOfWeek != (int)schedule.Day.DayName)
{
dt = dt.AddDays(1);
}
System.Collections.Generic.Dictionary <DateTime, DateTime> validRanges = new System.Collections.Generic.Dictionary <DateTime, DateTime>();
while (dt <= endTestTime)
{
dt = dt.AddDays(7);
//if (DateTime.DaysInMonth(dt.Year, dt.Month) < schedule.Day.Day)
// continue;
DateTime s = new DateTime(dt.Year, dt.Month, dt.Day);
DateTime e = s;
s = s.Add(schedule.Day.Time.StartTime.TimeOfDay);
e = e.Add(schedule.Day.Time.EndTime.TimeOfDay);
validRanges.Add(s, e);
}
RunTests(WeeklyDaySchedule, validRanges);
}
private void Initialize(Engine engine)
{
try
{
SamayLogger.SetLogLevel(SamayLogger.SamayEngineLoggingGUID, engine.EngineConfig.LogLevel);
LogInfo(JsonConvert.SerializeObject(engine, Formatting.Indented));
AppDomain ad = AppDomain.CreateDomain("SamayEnginedomain" + DateTime.Now.ToString());
TaskFactory tf = (TaskFactory)ad.CreateInstanceAndUnwrap(
Assembly.GetExecutingAssembly().FullName,
"Technisient.TaskFactory");
_TaskAssemblyDict = tf.Initialize();
AppDomain.Unload(ad);
//TaskFactory.Initialize();
//at the Job level, we still use the Engine log level
foreach (SamayConfig.Job job in engine.Jobs)
{
SamayLogger.SetLogLevel(job.Id, engine.EngineConfig.LogLevel);
if ((job.TaskChain.Task == null) || (job.TaskChain.Task.Count() == 0))
{
continue;
}
foreach (SamayConfig.Task task in job.TaskChain.Task)
{
SamayLogger.SetLogLevel(task.Id, task.LogLevel);
}
}
//cache Global Exclude Dates
_GlobalExcludeDates = new List <DateTime>();
if (engine.EngineConfig.GlobalExcludeDates != null)
{
foreach (GlobalExcludeDate dt in engine.EngineConfig.GlobalExcludeDates)
{
_GlobalExcludeDates.Add(dt.Date);
}
}
_jobExcludeDates = new Dictionary <string, List <DateTime> >();
//cache JobExclude Dates
foreach (Job job in engine.Jobs)
{
List <DateTime> dtList = new List <DateTime>();
if (job.ExcludeDates != null)
{
foreach (JobExcludeDates exc in job.ExcludeDates)
{
dtList.Add(exc.Date);
}
}
_jobExcludeDates.Add(job.JobName, dtList);
// set endtime to really high number for jobs which do not run continously
if (job.ExecuteTimes != -1)
{
if (job.Schedules != null)
{
foreach (JobSchedule jobSchedule in job.Schedules)
{
Time t = new Time();
switch (jobSchedule.ScheduleConfig.GetType().Name)
{
case "EngineJobScheduleDaily":
JobScheduleDaily daily = (JobScheduleDaily)jobSchedule.ScheduleConfig;
t = daily.Time;
break;
case "EngineJobScheduleWeekly":
JobScheduleWeekly weekly = (JobScheduleWeekly)jobSchedule.ScheduleConfig;
t = weekly.Day.Time;
break;
case "EngineJobScheduleMonthly":
JobScheduleMonthly monthly = (JobScheduleMonthly)jobSchedule.ScheduleConfig;
t = monthly.Day.Time;
break;
case "EngineJobScheduleYearly":
JobScheduleYearly yearly = (JobScheduleYearly)jobSchedule.ScheduleConfig;
t = yearly.Month.Time;
break;
case "EngineJobScheduleOneTimeOnly":
JobScheduleOneTimeOnly oneTime = (JobScheduleOneTimeOnly)jobSchedule.ScheduleConfig;
if (!oneTime.EndDateTimeSpecified)
{
oneTime.EndDateTime = oneTime.StartDateTime.AddYears(10);
oneTime.EndDateTimeSpecified = true;
}
continue;
default:
throw new Exception("Unknown Schedule Type: " + jobSchedule.ScheduleConfig.GetType().Name);
}
if (!t.EndTimeSpecified)
{
if (job.ExecuteTimes == 1)
{
t.EndTime = t.StartTime.AddMinutes(1);
}
else if (job.Interval.ClockTime != null)
{
t.EndTime = t.StartTime;
int count = 0;
while (count < job.ExecuteTimes)
{
if (job.Interval.ClockTime.Contains(t.EndTime.Minute))
{
count++;
}
t.EndTime = t.EndTime.AddMinutes(1);
}
}
else
{
int interval = (int)job.Interval.Interval_msec;
t.EndTime = t.StartTime.AddMilliseconds(interval * job.ExecuteTimes).AddMinutes(1);
}
t.EndTimeSpecified = true;
}
}
}
}
}
LogInfo("Starting Up Engine");
}
catch (Exception ex)
{
string sSource = "Technisient Samay";
string sLog = "Samay Engine";
if (!EventLog.SourceExists(sSource))
{
EventLog.CreateEventSource(sSource, sLog);
}
EventLog.WriteEntry(sSource, ex.ToString());
}
}
///////////////////////////////////
private static void RunForWeekly(JobScheduleWeekly schedule, int weekNumber)
{
bool isLast = (weekNumber == 0)?true:false;
JobSchedule WeeklyDaySchedule = new JobSchedule();
WeeklyDaySchedule.ScheduleConfig = schedule;
DateTime dt = startTestTime.AddMonths(-2);
System.Collections.Generic.Dictionary <DateTime, DateTime> validRanges = new System.Collections.Generic.Dictionary <DateTime, DateTime>();
int n = 0;
DayOfWeek dw = DayOfWeek.Sunday;
while (dt <= endTestTime)
{
dt = dt.AddDays(1);
//dt = DateTime.Parse("1/22/2012 8:00:00 PM");
if (dt.Day == 1)
{
n = 0;
dw = dt.DayOfWeek;
}
if (dt.DayOfWeek == dw)
{
n++;
}
bool isValid = false;
if (isLast)
{
if ((IsLastDayOccuranceForMonth(dt)) && ((int)dt.DayOfWeek == (int)schedule.Day.DayName))
{
isValid = true;
}
}
else if ((n == weekNumber) && ((int)dt.DayOfWeek == (int)schedule.Day.DayName))
{
isValid = true;
}
if (!isValid)
{
continue;
}
DateTime s = new DateTime(dt.Year, dt.Month, dt.Day);
DateTime e = s;
s = s.Add(schedule.Day.Time.StartTime.TimeOfDay);
e = e.Add(schedule.Day.Time.EndTime.TimeOfDay);
if (s.TimeOfDay > e.TimeOfDay)
{
e = e.AddDays(1);
}
validRanges.Add(s, e);
}
RunTests(WeeklyDaySchedule, validRanges);
}
