/// <summary>
/// Loads all jobs from SQLDB into a template List
/// </summary>
private void loadJobsFromDB()
{
templates = new List <JobTemplate>();
try
{
DBJob dbJob = new DBJob();
var dbJobQuery = from job in db.Jobs select job;
List <DBJob> dbJobs = dbJobQuery.ToList();
if (dbJobs != null)
{
foreach (DBJob job in dbJobs)
{
JobTemplate template = new JobTemplate();
template.ID = job.JobId;
template.Name = job.JobName;
template.Group = job.JobGroup;
template.processPathStringsFromDB(job.Process, job.WorkingDirectory);
template.Arguments = job.Arguments;
template.WorkingDirectory = job.WorkingDirectory;
template.CronSchedule = job.CronSchedule;
template.Timeout = job.TimeOut.ToString();
templates.Add(template);
}
}
}
catch (Exception ex)
{
QuartzService.log("Error loading Jobs from DB: " + "Exception\n" + ex.StackTrace);
}
}
/// <summary>
/// Updates SQLDB from incoming folder JSON files
/// </summary>
/// <returns>Dictionary with Template keys and values indicating the update types</returns>
public Dictionary <JobTemplate, UpdateType> updateFromIncoming()
{
Dictionary <JobTemplate, UpdateType> jobIDs = null;
QuartzService.log("Checking for any incoming updates");
try
{
List <String> filePaths = new List <String>(Directory.GetFiles(strIncomingDirectory));
if (filePaths.Count > 0)
{
QuartzService.log("Running incoming updates");
jobIDs = new Dictionary <JobTemplate, UpdateType>();
sortIncomingFiles(filePaths);
for (int i = 0; i < filePaths.Count; i++)
{
if (filePaths[i].EndsWith(".json", StringComparison.CurrentCultureIgnoreCase))
{
try
{
JobTemplate template = JsonConvert.DeserializeObject <JobTemplate>(File.ReadAllText(filePaths[i]));
try
{
UpdateType updateType = updateDatabase(template);
QuartzService.log("Job ID " + template.ID + " set to update in DB");
db.SaveChanges();
QuartzService.log("Job ID " + template.ID + " changes saved to the DB");
jobIDs.Add(template, updateType);
try
{
File.Delete(filePaths[i]);
}
catch (Exception ex)
{
QuartzService.log("Error deleting JSON file after update Exception\n" + ex.StackTrace);
}
}
catch (Exception ex)
{
QuartzService.log("Error updating the DB Exception\n" + ex.InnerException + "\n" + ex.StackTrace);
}
}
catch (Exception ex)
{
renameToERR(filePaths[i]);
QuartzService.log("Error updating from " + filePaths[i] + "\n" + ex.StackTrace);
}
}
}
}
else
{
QuartzService.log("No Updates Found");
}
}
catch (Exception ex)
{
QuartzService.log("Error loading files from " + strIncomingDirectory + "Exception\n" + ex.StackTrace);
}
return(jobIDs);
}
/// <summary>
/// Schedules the jobs in the template list
/// </summary>
private void setUpJobs()
{
foreach (JobTemplate template in templates)
{
try
{
IJobDetail job = JobBuilder.Create <Job>().Build();
job.JobDataMap["ID"] = template.ID.ToString();
job.JobDataMap["Name"] = template.Name;
//job.JobDataMap["Group"] = template.Group;
//Defaulting all to "Default" group for now
job.JobDataMap["Group"] = "Default";
job.JobDataMap["Process"] = template.Process;
job.JobDataMap["Arguments"] = template.Arguments;
job.JobDataMap["CronSchedule"] = template.CronSchedule;
job.JobDataMap["TimeOut"] = template.Timeout;
ITrigger trigger = TriggerBuilder.Create()
.WithIdentity(job.JobDataMap["ID"].ToString(), job.JobDataMap["Group"].ToString())
.WithCronSchedule(job.JobDataMap["CronSchedule"].ToString())
.StartAt(DateTime.UtcNow)
.WithPriority(1)
.Build();
scheduler.ScheduleJob(job, trigger);
QuartzService.log("Job ID " + template.ID + " has been scheduled");
}
catch (Exception ex)
{
QuartzService.log("Error scheduling " + template.Name + "\n" + ex.StackTrace);
}
}
}
/// <summary>
/// Removes a single job from scheduler by JobID
/// </summary>
/// <param name="jobID">Job ID to be removed</param>
public void removeJobFromScheduler(String jobID)
{
IList <string> jobGroups = scheduler.GetJobGroupNames();
var groupMatcher = GroupMatcher <JobKey> .GroupContains(jobGroups[0]);
var jobKeys = scheduler.GetJobKeys(groupMatcher);
foreach (JobKey jobKey in jobKeys)
{
var detail = scheduler.GetJobDetail(jobKey);
String strID = detail.JobDataMap.GetString("ID");
if (strID == jobID)
{
try
{
scheduler.DeleteJob(jobKey);
QuartzService.log("Job ID " + jobID + " has been unscheduled");
}
catch (Exception ex)
{
QuartzService.log("Error removing job " + jobID + " from scheduler \n" + ex);
}
break;
}
}
}
public Boolean UpdateJobs(List <int> jobs)
{
bool Successful = false;
try
{
String[] jobIDs = QuartzService.scheduler.getAllJobIDS();
foreach (var job in jobs)
{
if (jobIDs.Contains(job.ToString()))
{
QuartzService.scheduler.removeJobFromScheduler(job.ToString());
JobTemplate temp = QuartzService.scheduler.loadJobFromDB(job.ToString());
if (temp.ID > 0)
{
QuartzService.scheduler.setUpJob(QuartzService.scheduler.loadJobFromDB(job.ToString()));
}
}
else
{
QuartzService.scheduler.setUpJob(QuartzService.scheduler.loadJobFromDB(job.ToString()));
}
}
}
catch (Exception ex)
{
QuartzService.log("Error Updating jobs thru IJobupdater " + "\n" + ex.StackTrace);
}
return(Successful);
}
/// <summary>
/// Loads and schedules jobs from JSON files in Jobs directory
/// </summary>
private void loadAndScheduleJobsFromFiles()
{
List <JobTemplate> fileTemplates = new List <JobTemplate>();
String[] filepaths = Directory.GetFiles(strJobsDirectory);
foreach (String file in filepaths)
{
try
{
JobTemplate template = JsonConvert.DeserializeObject <JobTemplate>(File.ReadAllText(file));
fileTemplates.Add(template);
QuartzService.log(file + " file loaded successfully...");
}
catch (Exception ex)
{
QuartzService.log("Error loading " + file + "\n" + ex.StackTrace);
}
}
foreach (JobTemplate template in fileTemplates)
{
try
{
IJobDetail job = JobBuilder.Create <Job>().Build();
job.JobDataMap["ID"] = template.ID.ToString();
job.JobDataMap["Name"] = template.Name;
//job.JobDataMap["Group"] = template.Group;
//Defaulting all to "Default" group for now
job.JobDataMap["Group"] = "Default";
job.JobDataMap["Process"] = template.Process;
job.JobDataMap["Arguments"] = template.Arguments;
job.JobDataMap["CronSchedule"] = template.CronSchedule;
job.JobDataMap["TimeOut"] = template.Timeout;
ITrigger trigger = TriggerBuilder.Create()
.WithIdentity(job.JobDataMap["ID"].ToString(), job.JobDataMap["Group"].ToString())
.WithCronSchedule(job.JobDataMap["CronSchedule"].ToString())
.StartAt(DateTime.UtcNow)
.WithPriority(1)
.Build();
scheduler.ScheduleJob(job, trigger);
QuartzService.log("Job ID " + template.ID + " has been scheduled");
}
catch (Exception ex)
{
QuartzService.log("Error scheduling " + template.Name + "\n" + ex.StackTrace);
}
}
}
/// <summary>
/// The main entry point for the application.
/// </summary>
static void Main()
{
#if (!DEBUG)
ServiceBase[] ServicesToRun;
ServicesToRun = new ServiceBase[]
{
new QuartzService()
};
ServiceBase.Run(ServicesToRun);
#else
QuartzService myServ = new QuartzService();
myServ.onStartMethod();
#endif
}
public int addNewRecord(int JobID, String JobName, DateTime startTime)
{
int iRecordID = 0;
JobRecord jobRecord = new JobRecord();
try
{
jobRecord.JobId = JobID;
jobRecord.JobName = JobName;
jobRecord.BeginTime = startTime;
db.JobRecords.Add(jobRecord);
db.SaveChanges();
iRecordID = jobRecord.RecordId;
}
catch (Exception ex)
{
QuartzService.log("Error adding job record for JobID " + JobID + " to the JobRecords DB\n" + ex);
}
return(iRecordID);
}
/// <summary>
/// Executes the JOB
/// </summary>
/// <param name="context"></param>
public void Execute(IJobExecutionContext context)
{
JobDataMap datamap = context.JobDetail.JobDataMap;
iID = datamap.GetInt("ID");
strName = datamap.GetString("Name");
strProcess = datamap.GetString("Process");
strArguments = datamap.GetString("Arguments");
strWorkingDirectory = datamap.GetString("WorkingDirectory");
iTimeOut = datamap.GetInt("TimeOut");
QuartzService.log("Job ID " + iID + " is starting...");
iRecordID = recordUpdater.addNewRecord(iID, strName, DateTime.Now);
try
{
process.StartInfo.FileName = strProcess;
process.StartInfo.Arguments = strArguments;
setWorkingDirectory();
process.Start();
iProcessID = process.Id;
process.WaitForExit(iTimeOut);
if (processStillRunning(iProcessID))
{
iTimedOut = 1;
process.Kill();
QuartzService.log("Job ID " + iID + " was stopped; Process TimeOut of " + iTimeOut + "ms Exceeded...");
}
else
{
QuartzService.log("Job ID " + iID + " has completed...");
}
recordUpdater.setRecordEnding(iRecordID, DateTime.Now, iTimedOut);
}
catch (Exception ex)
{
QuartzService.log(@"Exception When Running " + strName + "\n" +
ex.StackTrace);
}
}
public bool setRecordEnding(int RecordID, DateTime endTime, int timedOut)
{
bool bSuccessful = false;
try
{
var jobRecordQuery = from jobRecord in db.JobRecords
where jobRecord.RecordId == RecordID
select jobRecord;
JobRecord record = jobRecordQuery.Single();
record.EndTime = endTime;
record.TimedOut = timedOut;
db.SaveChanges();
bSuccessful = true;
}
catch (Exception ex)
{
QuartzService.log("Error adding job record ending time for RecordID " + RecordID + " to the JobRecords DB\n" + ex);
}
return(bSuccessful);
}
/// <summary>
/// Rename json files to err
/// </summary>
/// <param name="InputString"></param>
private void renameToERR(String InputString)
{
String strNewFileName = String.Empty;
if (InputString.Contains("."))
{
strNewFileName = InputString.Remove(InputString.LastIndexOf(".") + 1);
}
else
{
strNewFileName = String.Concat(InputString, ".");
}
strNewFileName = String.Concat(strNewFileName, "err");
try
{
File.Move(InputString, strNewFileName);
}
catch (Exception ex)
{
QuartzService.log("Error renaming " + InputString + " to .err Exception\n" + ex.StackTrace);
}
}
/// <summary>
/// Load a single job from SQLDB by JobID
/// </summary>
/// <param name="JobID"></param>
/// <returns>Template</returns>
public JobTemplate loadJobFromDB(String JobID)
{
JobTemplate template = new JobTemplate();
try
{
int iJob = Int32.Parse(JobID);
DBJob dbJob = db.Jobs.FirstOrDefault(j => j.JobId == iJob);
template.ID = dbJob.JobId;
template.Name = dbJob.JobName;
template.Group = dbJob.JobGroup;
template.processPathStringsFromDB(dbJob.Process, dbJob.WorkingDirectory);
template.Arguments = dbJob.Arguments;
template.WorkingDirectory = dbJob.WorkingDirectory;
template.CronSchedule = dbJob.CronSchedule;
template.Timeout = dbJob.TimeOut.ToString();
}
catch (Exception ex)
{
QuartzService.log("Error loading Job from DB: " + "Exception\n" + ex.StackTrace);
}
return(template);
}
/// <summary>
/// Checks for required directories and clears flags folder
/// </summary>
private void checkDirectories()
{
try
{
if (!Directory.Exists(LOGFILEDIRECTORY))
{
Directory.CreateDirectory(LOGFILEDIRECTORY);
}
}
catch (Exception ex)
{
EventLog.WriteEntry("Error checking " + LOGFILEDIRECTORY + "\n" + ex.StackTrace);
}
try
{
if (!Directory.Exists(Settings.Default.IncomingDirectory))
{
Directory.CreateDirectory(Settings.Default.IncomingDirectory);
}
}
catch (Exception ex)
{
QuartzService.log("Error checking for incoming folder " + "\n" + ex.StackTrace);
}
try
{
if (!Directory.Exists(Settings.Default.JobsDirectory))
{
Directory.CreateDirectory(Settings.Default.JobsDirectory);
}
}
catch (Exception ex)
{
EventLog.WriteEntry("Error checking " + LOGFILEDIRECTORY + "\n" + ex.StackTrace);
}
try
{
if (!Directory.Exists(strFlagsFolder))
{
Directory.CreateDirectory(strFlagsFolder);
}
else
{
try
{
String[] flagFiles = Directory.GetFiles(strFlagsFolder);
if (flagFiles.Length > 0)
{
foreach (String file in flagFiles)
{
try
{
File.Delete(file);
}
catch (Exception ex)
{
EventLog.WriteEntry("Error deleting flag " + file + " in " + strFlagsFolder + "\n" + ex.StackTrace);
}
}
}
}
catch (Exception ex)
{
EventLog.WriteEntry("Error checking for flags in " + strFlagsFolder + "\n" + ex.StackTrace);
}
}
}
catch (Exception ex)
{
EventLog.WriteEntry("Error checking " + strFlagsFolder + "\n" + ex.StackTrace);
}
}
