private void Init()
{
using (var db = new AryaServicesDbDataContext())
{
//Restart tasks that were "working" in the previous run (if any)
var workingTasks = db.AryaTasks.Where(t => t.Status == WorkerState.Working.ToString());
workingTasks.ForEach(t => t.Status = WorkerState.New.ToString());
db.SubmitChanges();
}
}
private static IEnumerable <AryaTask> GetTasks(AryaDbDataContext aryaDc,
AryaServicesDbDataContext taskDc, User currUser, Guid userGroup, IEnumerable <string> jobTypes,
bool currentUserTasksOnly)
{
var projects =
(from ug in aryaDc.UserProjects
where ug.GroupID == userGroup && ug.UserID == currUser.ID
select ug.ProjectID).ToList();
return(projects.Any()
? taskDc.AryaTasks.Where(
task =>
projects.Contains(task.ProjectID) && jobTypes.Contains(task.JobType) &&
(!currentUserTasksOnly || task.SubmittedBy == currUser.ID))
: Enumerable.Empty <AryaTask>());
}
protected void CancelCurrentJob(object sender, CommandEventArgs e)
{
var taskId = Guid.Parse(e.CommandArgument.ToString());
using (var taskDc = new AryaServicesDbDataContext())
{
var task = taskDc.AryaTasks.First(t => t.ID == taskId);
if (task.Status == WorkerState.New.ToString())
{
task.Status = WorkerState.AbortedByUser.ToString();
taskDc.SubmitChanges();
}
else
{
lblMessage.Text =
"Could not cancel Job - it had already started before cancel request was sent to server.";
}
BindGridView();
}
}
public void SubmitJobs()
{
// get data context
using (var db = new AryaServicesDbDataContext())
{
// get a list of jobs to be executed
var now = DateTime.Now;
var jobs = db.AryaSchedules.Where(s => (s.NextExecution == null || s.NextExecution <= now));
// add each job to the task queue
foreach (var job in jobs)
{
string newArgumentDirectoryPath = Path.Combine(job.ProjectID.ToString(), Guid.NewGuid().ToString());
DirectoryCopy(Path.Combine(Settings.Default.ArgumentFileBasePath, job.ArgumentDirectoryPath),
Path.Combine(Settings.Default.ArgumentFileBasePath, newArgumentDirectoryPath), true);
//File.Copy();
var newJob = new AryaTask
{
ID = Guid.NewGuid(),
ScheduleID = job.ID,
Description = job.Description,
ArgumentDirectoryPath = newArgumentDirectoryPath,
Status = "New",
SubmittedBy = job.SubmittedBy,
SubmittedOn = now,
ProjectID = job.ProjectID,
LastUpdateOn = now,
JobType = job.JobType
};
db.AryaTasks.InsertOnSubmit(newJob);
Logger.GetLogWriter().Info("SchedueJobId:" + job.ID + "was submitted as regular job");
// update the date of execution of the selected job
job.NextExecution = now.AddMinutes(job.Interval);
job.LastExecution = now;
// update the database
db.SubmitChanges();
}
}
}
private bool LoadArguments()
{
try
{
using (var taskDc = new AryaServicesDbDataContext())
using (var aryaDc = new AryaDbDataContext())
{
var task = taskDc.AryaTasks.Single(t => t.ID == TaskId);
var taskInfo = (from up in aryaDc.UserProjects
where up.Project.ID == task.ProjectID && up.User.ID == task.SubmittedBy
select
new
{
JobType = task.DisplayJobType,
Project = up.Project.DisplayName,
SubmittedBy = up.User.FullName,
SubmittedOn = task.SubmittedOn.ToString(),
Status = task.Status.Spacify()
}).First();
_status = taskInfo.Status;
var properties = taskInfo.GetType().GetProperties();
foreach (var prop in properties)
{
var value = prop.GetValue(taskInfo).ToString();
phArguments.Controls.Add(new Label {
Text = prop.Name.Spacify() + ":", CssClass = "PropertyName"
});
phArguments.Controls.Add(new Label {
Text = value, CssClass = "PropertyValue"
});
phArguments.Controls.Add(new LiteralControl("<br />"));
}
}
}
catch (Exception ex)
{
return(false);
}
try
{
var arguments = new SharpSerializer().Deserialize(Path.Combine(Basepath, ArgumentsPath, "Arguments.xml"));
var properties = (from prop in arguments.GetType().GetProperties()
let category =
prop.IsDefined(typeof(CategoryAttribute), false)
? prop.GetCustomAttributes(typeof(CategoryAttribute), false)
.Cast <CategoryAttribute>()
.Single()
.Category
: "Other"
let name =
prop.IsDefined(typeof(DisplayNameAttribute), false)
? prop.GetCustomAttributes(typeof(DisplayNameAttribute), false)
.Cast <DisplayNameAttribute>()
.Single()
.DisplayName
: prop.Name
let displayOrder =
prop.IsDefined(typeof(PropertyOrderAttribute), false)
? prop.GetCustomAttributes(typeof(PropertyOrderAttribute), false)
.Cast <PropertyOrderAttribute>()
.Single()
.Order
: 999
let shouldSerializeMethod = arguments.GetType().GetMethod("ShouldSerialize" + prop.Name)
let shouldSerialize =
shouldSerializeMethod == null || (bool)shouldSerializeMethod.Invoke(arguments, new object[] { })
where shouldSerialize
orderby displayOrder
select new { Property = prop, Category = category, Name = name, displayOrder }).ToList();
foreach (var prop in properties)
{
var propertyType = prop.Property.PropertyType;
if (propertyType == typeof(Guid) || propertyType == typeof(Guid[]))
{
continue;
}
var basevalue = prop.Property.GetValue(arguments) ?? string.Empty;
if (string.IsNullOrWhiteSpace(basevalue.ToString()))
{
continue;
}
if (propertyType.IsGenericType && propertyType.GetGenericTypeDefinition() == typeof(Dictionary <,>))
{
phArguments.Controls.Add(new Label
{
Text = prop.Name.Spacify() + ":",
CssClass = "PropertyName",
});
phArguments.Controls.Add(new LiteralControl("<br />"));
var kvps = (IDictionary)basevalue;
foreach (DictionaryEntry kvp in kvps)
{
phArguments.Controls.Add(new Label
{
Text = kvp.Key.ToString().Spacify(),
CssClass = "PropertyValueLeft"
});
phArguments.Controls.Add(new Label
{
Text = kvp.Value.ToString().Spacify(),
CssClass = "PropertyValue"
});
phArguments.Controls.Add(new LiteralControl("<br />"));
}
continue;
}
var stringValue = basevalue.ToString();
if (propertyType.IsArray)
{
stringValue = string.Empty;
var values = (Array)prop.Property.GetValue(arguments);
for (var i = 0; i < values.Length; i++)
{
stringValue += (i > 0 ? ", " : string.Empty) + values.GetValue(i);
}
}
if (string.IsNullOrWhiteSpace(stringValue) || stringValue == new DateTime().ToString())
{
continue;
}
if (prop.Name.ToLower().EndsWith("path"))
{
try
{
var path = Path.GetFullPath(stringValue);
stringValue = Path.GetFileName(stringValue);
}
catch (Exception ex)
{
}
}
phArguments.Controls.Add(new Label {
Text = prop.Name.Spacify() + ":", CssClass = "PropertyName"
});
phArguments.Controls.Add(new Label {
Text = stringValue, CssClass = "PropertyValue"
});
phArguments.Controls.Add(new LiteralControl("<br />"));
}
pnlArguments.Visible = true;
}
catch (Exception)
{
return(false);
}
return(true);
}
public async Task ProcessJobs(object processBucket)
{
//CurrentLogWriter.Debug("Job assigner has started processing jobs.");
try
{
AryaTask job;
using (var aryaServicesDb = new AryaServicesDbDataContext())
{
job =
aryaServicesDb.AryaTasks.FirstOrDefault(
s => s.Status.ToLower() == WorkerState.New.ToString().ToLower());
if (job == null)
{
return;
}
CurrentLogWriter.InfoFormat(
"Job ID: {0} Starting\tDescription:{1}\tSubmitted by:{2}\tSubmitted on:{3}\tJob type:{4}\tProcess bucket:{5}",
job.ID, job.Description, job.SubmittedBy, job.SubmittedOn, job.JobType, processBucket);
job.JobAssignedOn = DateTime.Now;
job.Status = WorkerState.Working.ToString();
aryaServicesDb.SubmitChanges();
}
string currentJobStatus, emailAddresses = string.Empty;
try
{
if (JobProcessors.ContainsKey(job.JobType))
{
//create the job instance
var currentJobType = JobProcessors[job.JobType];
var jobExecutor =
(WorkerBase)
Activator.CreateInstance(currentJobType,
new object[]
{
Path.Combine(Settings.Default.ArgumentFileBasePath,
job.ArgumentDirectoryPath)
});
jobExecutor.CurrentLogWriter = CurrentLogWriter;
jobExecutor.WorkerStatusChange += AryaServices.UpdateWorkerStatusInDb;
emailAddresses = jobExecutor.Arguments.NotificationEmailAddresses;
ProcessEmailJobStatus(emailAddresses, job, true, "Started");
await Task.Run(() => jobExecutor.Run());
jobExecutor.SaveSummary();
currentJobStatus = jobExecutor.Summary.State.ToString();
}
else
{
currentJobStatus = WorkerState.Abort.ToString();
CurrentLogWriter.ErrorFormat("{0}: {1} not found in the dll provided", job.ID, job.JobType);
}
}
catch (Exception ex)
{
var message = string.Empty;
var e = ex;
while (e != null)
{
message = Environment.NewLine + e.Message;
e = e.InnerException;
}
CurrentLogWriter.Error(ex.Source + message + Environment.NewLine + ex.StackTrace);
currentJobStatus = WorkerState.Abort.ToString();
CurrentLogWriter.Error(ex.SerializeObject());
}
using (var aryaServicesDb = new AryaServicesDbDataContext())
{
job = aryaServicesDb.AryaTasks.First(t => t.ID == job.ID);
job.Status = currentJobStatus;
ProcessEmailJobStatus(emailAddresses, job, true);
CurrentLogWriter.InfoFormat("Job Id: {0} Finished processing, Last Status: {1}", job.ID,
currentJobStatus);
job.LastUpdateOn = DateTime.Now;
aryaServicesDb.SubmitChanges();
}
}
catch (Exception ex)
{
CurrentLogWriter.Error(ex.SerializeObject());
}
CurrentLogWriter.Debug("Job assigner is exiting.");
}
private void BindGridView(bool clearAllFilters = false)
{
using (var aryaDc = new AryaDbDataContext())
{
var currUser = (from u in aryaDc.Users where u.EmailAddress == Email select u).FirstOrDefault();
if (currUser == null)
{
FormsAuthentication.RedirectToLoginPage();
return;
}
using (var taskDc = new AryaServicesDbDataContext())
{
var tasks = Enumerable.Empty <AryaTask>().AsQueryable();
if (currUser.IsAdmin)
{
tasks = taskDc.AryaTasks;
}
else
{
//Import Admin Tasks
tasks =
tasks.Union(GetTasks(aryaDc, taskDc, currUser, Group.ImportAdminGroup,
new[] { typeof(ImportWorker).Name }, false));
//Import User Tasks
tasks =
tasks.Union(GetTasks(aryaDc, taskDc, currUser, Group.ImportUserGroup,
new[] { typeof(ImportWorker).Name }, true));
var exportJobTypes = ExportWorkerBase.GetExports().Select(e => e.GetType().Name).ToList();
//Export Admin Tasks
tasks =
tasks.Union(GetTasks(aryaDc, taskDc, currUser, Group.ExportAdminGroup,
exportJobTypes.Union(typeof(CustomExportWorker).Name), false));
//Standard Export User Tasks
tasks =
tasks.Union(GetTasks(aryaDc, taskDc, currUser, Group.StandardExportUserGroup,
exportJobTypes, true));
//Custom Export User Tasks
tasks =
tasks.Union(GetTasks(aryaDc, taskDc, currUser, Group.CustomExportUserGroup,
new[] { typeof(CustomExportWorker).Name }, true));
}
if (!clearAllFilters)
{
Guid selectedProject, selectedUser;
if (Guid.TryParse(DdlProjects.SelectedValue, out selectedProject))
{
tasks = tasks.Where(task => task.ProjectID == selectedProject);
}
if (Guid.TryParse(DdlSubmittedBy.SelectedValue, out selectedUser))
{
tasks = tasks.Where(task => task.SubmittedBy == selectedUser);
}
var selectedJobType = DdlJobType.SelectedValue;
if (!string.IsNullOrWhiteSpace(selectedJobType) && selectedJobType != "ALL")
{
tasks = tasks.Where(task => task.JobType == DdlJobType.SelectedValue);
}
var selectedStatus = DdlStatus.SelectedValue;
if (!string.IsNullOrWhiteSpace(selectedStatus) && selectedStatus != "ALL")
{
tasks = tasks.Where(task => task.Status == DdlStatus.SelectedValue);
}
}
var allTasks = tasks.OrderByDescending(task => task.SubmittedOn).Take(100).ToList();
var distinctUserProjects =
allTasks.Select(t => t.SubmittedBy + "|" + t.ProjectID).Distinct().ToList();
var userProjects = (from up in aryaDc.UserProjects
//from task in tasks.ToList()
//where task.SubmittedBy == up.UserID && task.ProjectID == up.ProjectID
where distinctUserProjects.Contains(up.UserID + "|" + up.ProjectID)
select new { up.User, up.Project }).ToList();
var visibleTasks = from task in allTasks
from up in userProjects
where up.Project.ID == task.ProjectID && up.User.ID == task.SubmittedBy
let project = up.Project
let user = up.User
let state =
WorkerBase.GetFriendlyWorkerState(
(WorkerState)Enum.Parse(typeof(WorkerState), task.Status))
orderby task.SubmittedOn descending
select
new
{
task.ID,
task.ProjectID,
ProjectName = project.DisplayName,
Type = task.DisplayJobType,
task.JobType,
task.Description,
task.Status,
FriendlyStatus = state,
user.FullName,
task.SubmittedBy,
task.SubmittedOn
};
if (sortExpression != string.Empty)
{
visibleTasks = LinqExtensions.ApplyOrder(visibleTasks, sortExpression,
sortOrder == "asc" ? "OrderBy" : "OrderByDescending");
}
var visibleTaskList = visibleTasks.Distinct().ToList();
GvStatus.DataSource = visibleTaskList;
GvStatus.DataBind();
if (visibleTaskList.Count == 0)
{
return;
}
if (!Page.IsPostBack)
{
var projects =
userProjects.Select(
up =>
new DropDownListItem
{
Text = up.Project.DisplayName,
Value = up.Project.ID.ToString()
})
.Distinct(new KeyEqualityComparer <DropDownListItem>(item => item.Value))
.OrderBy(item => item.Text)
.ToList();
Session["projects"] = projects;
var users =
userProjects.Select(
up => new DropDownListItem {
Text = up.User.FullName, Value = up.User.ID.ToString()
})
.Distinct(new KeyEqualityComparer <DropDownListItem>(item => item.Value))
.OrderBy(item => item.Text)
.ToList();
Session["users"] = users;
var jobTypes =
allTasks.Select(
task => new DropDownListItem {
Text = task.DisplayJobType, Value = task.JobType
})
.Distinct(new KeyEqualityComparer <DropDownListItem>(item => item.Value))
.OrderBy(item => item.Text)
.ToList();
Session["jobTypes"] = jobTypes;
var statuses =
allTasks.Select(task => new DropDownListItem {
Text = task.Status, Value = task.Status
})
.Distinct(new KeyEqualityComparer <DropDownListItem>(item => item.Value))
.OrderBy(item => item.Text)
.ToList();
Session["statuses"] = statuses;
}
var prjs = Session["projects"] as List <DropDownListItem> ?? new List <DropDownListItem>();
var visibleProjects =
prjs.Where(prj => visibleTaskList.Any(task => task.ProjectID.ToString() == prj.Value)).ToList();
visibleProjects.Insert(visibleProjects.Count > 1 ? 0 : 1,
new DropDownListItem {
Text = "ALL", Value = "ALL"
});
visibleProjects.Add(new DropDownListItem {
Text = "-----", Value = "ALL"
});
visibleProjects.AddRange(prjs.Where(prj => !visibleProjects.Contains(prj)));
DdlProjects.DataSource = visibleProjects;
DdlProjects.DataBind();
var usrs = Session["users"] as List <DropDownListItem> ?? new List <DropDownListItem>();
var visibleusers =
usrs.Where(usr => visibleTaskList.Any(task => task.SubmittedBy.ToString() == usr.Value))
.ToList();
visibleusers.Insert(visibleusers.Count > 1 ? 0 : 1,
new DropDownListItem {
Text = "ALL", Value = "ALL"
});
visibleusers.Add(new DropDownListItem {
Text = "-----", Value = "ALL"
});
visibleusers.AddRange(usrs.Where(usr => !visibleusers.Contains(usr)));
DdlSubmittedBy.DataSource = visibleusers;
DdlSubmittedBy.DataBind();
var jbts = Session["jobTypes"] as List <DropDownListItem> ?? new List <DropDownListItem>();
var visiblejobTypes =
jbts.Where(jbt => visibleTaskList.Any(task => task.JobType == jbt.Value)).ToList();
visiblejobTypes.Insert(visiblejobTypes.Count > 1 ? 0 : 1,
new DropDownListItem {
Text = "ALL", Value = "ALL"
});
visiblejobTypes.Add(new DropDownListItem {
Text = "-----", Value = "ALL"
});
visiblejobTypes.AddRange(jbts.Where(jbt => !visiblejobTypes.Contains(jbt)));
DdlJobType.DataSource = visiblejobTypes;
DdlJobType.DataBind();
var stus = Session["statuses"] as List <DropDownListItem> ?? new List <DropDownListItem>();
var visiblestatuses =
stus.Where(stu => visibleTaskList.Any(task => task.Status == stu.Value)).ToList();
visiblestatuses.Insert(visiblestatuses.Count > 1 ? 0 : 1,
new DropDownListItem {
Text = "ALL", Value = "ALL"
});
visiblestatuses.Add(new DropDownListItem {
Text = "-----", Value = "ALL"
});
visiblestatuses.AddRange(stus.Where(stu => !visiblestatuses.Contains(stu)));
DdlStatus.DataSource = visiblestatuses;
DdlStatus.DataBind();
}
}
}
