private async ValueTask DisposeImpl(bool isAsync)
{
if (ActiveTasks != null)
{
ActiveTasks.Clear();
ActiveTasks = null;
}
if (ProcessingTasks != null)
{
ProcessingTasks.Clear();
ProcessingTasks = null;
}
if (ActiveCommand != null)
{
if (isAsync)
{
await ActiveCommand.DisposeAsync().ConfigureAwait(false);
}
else
{
ActiveCommand.Dispose();
}
ActiveCommand = null;
}
NotifyDisposed();
}
public ActiveTasksViewModel(TaskData taskData)
{
if (taskData == null)
{
throw new ArgumentNullException("taskData");
}
base.DisplayName = Properties.Resources.Active_Tasks_DisplayName;
base.DisplayImage = "pack://application:,,,/TaskConqueror;Component/Assets/Images/task_list.png";
_taskData = taskData;
// Subscribe for notifications of when a new task is saved.
_taskData.TaskAdded += this.OnTaskAdded;
_taskData.TaskUpdated += this.OnTaskUpdated;
_taskData.TaskDeleted += this.OnTaskDeleted;
// Populate the AllTasks collection with TaskViewModels.
this.ActiveTasks = new ObservableCollection <TaskViewModel>();
this.ActiveTasks.CollectionChanged += this.OnCollectionChanged;
GetActiveTasks();
// select the first task
TaskViewModel firstTask = ActiveTasks.FirstOrDefault();
if (firstTask != null)
{
firstTask.IsSelected = true;
}
}
void Activate(System.Type taskType)
{
if (!ActiveTasks.ContainsKey(taskType))
{
ActiveTasks.Add(taskType, (T)tasks[taskType]);
}
}
private MessageFromServerToClient HandleRequestForJob([NotNull] MessageFromClientToServer req)
{
if (OpenTasks.IsEmpty)
{
return(new MessageFromServerToClient(ServerResponseEnum.NothingToDo, req.TaskGuid));
}
bool success = OpenTasks.TryDequeue(out var task);
if (success)
{
SaveExecuteHelper.Get().SaveExecuteWithWait(() => ActiveTasks.Add(task));
task.Client = req.ClientName;
task.ExecutionStart = DateTime.Now;
var answer = new MessageFromServerToClient(ServerResponseEnum.ServeCalcJob, task.Guid);
answer.HouseJobStr = File.ReadAllText(task.OriginalJsonFilePath ??
throw new DistSimException("Jsonpath was not found: " + task.OriginalJsonFilePath));
FileInfo fi = new FileInfo(task.OriginalJsonFilePath);
answer.OriginalFileName = fi.Name;
answer.LpgFiles = InitalizeLpgFiles(false);
return(answer);
}
return(new MessageFromServerToClient(ServerResponseEnum.NothingToDo, req.TaskGuid));
}
public void ActivateAll()
{
ActiveTasks.Clear();
foreach (var task in tasks)
{
ActiveTasks.Add(task.Key, task.Value as T);
}
}
/// <summary>
/// Deactivates the selected task.
/// </summary>
public void DeactivateTask()
{
TaskViewModel selectedTaskVM = ActiveTasks.FirstOrDefault(t => t.IsSelected == true);
if (selectedTaskVM != null)
{
selectedTaskVM.IsActive = false;
selectedTaskVM.Save();
}
}
public void AddTask(Task task)
{
System.Type taskType = task.GetType();
if (tasks.ContainsKey(taskType))
{
throw new System.Exception("The task list '" + this + "' already contains the task '" + task + "'");
}
tasks.Add(taskType, task);
ActiveTasks.Add(taskType, task as T);
}
/// <summary>
/// Launches the delete task window.
/// </summary>
public void DeleteTask()
{
TaskViewModel selectedTaskVM = ActiveTasks.FirstOrDefault(t => t.IsSelected == true);
if (selectedTaskVM != null && WPFMessageBox.Show(Properties.Resources.Delete_Confirm, Properties.Resources.Tasks_Delete_Confirm, WPFMessageBoxButtons.YesNo, WPFMessageBoxImage.Question) == WPFMessageBoxResult.Yes)
{
_taskData.DeleteTask(_taskData.GetTaskByTaskId(selectedTaskVM.TaskId));
selectedTaskVM.Dispose();
}
}
/// <summary>
/// Launches the edit task window.
/// </summary>
public void EditTask()
{
TaskView window = new TaskView();
TaskViewModel selectedTaskVM = ActiveTasks.FirstOrDefault(t => t.IsSelected == true);
using (var viewModel = new TaskViewModel(_taskData.GetTaskByTaskId(selectedTaskVM.TaskId), _taskData))
{
this.ShowWorkspaceAsDialog(window, viewModel);
}
}
public void RefreshOpenTasks()
{
if (_settings.ServerSettings.JsonDirectory == null)
{
throw new DistSimException("Jsondirectory was null");
}
if (_settings.ServerSettings.JsonDirectory.Count == 0)
{
throw new DistSimException("Jsondirectory was empty");
}
foreach (string singledir in _settings.ServerSettings.JsonDirectory)
{
if (OpenTasks.Count > 1000)
{
break;
}
DirectoryInfo di = new DirectoryInfo(singledir);
if (!di.Exists)
{
di.Create();
Thread.Sleep(100);
}
var files = di.GetFiles("*.json");
var activeFiles = ActiveTasks.Select(x => x.OriginalJsonFilePath).ToList();
var openTaskFiles = OpenTasks.Select(x => x.OriginalJsonFilePath).ToList();
foreach (var fileInfo in files)
{
if (activeFiles.Contains(fileInfo.FullName))
{
_logger.Info("Currently processing " + fileInfo.Name, _threadId);
continue;
}
if (openTaskFiles.Contains(fileInfo.FullName))
{
_logger.Info("Currently in queue " + fileInfo.Name, _threadId);
continue;
}
ServerExecutionTask set = new ServerExecutionTask(fileInfo.FullName, fileInfo.Name, Guid.NewGuid().ToString());
OpenTasks.Enqueue(set);
_logger.Info("Created a job for " + fileInfo.Name, _threadId);
if (OpenTasks.Count > 1000)
{
break;
}
}
}
}
/// <summary>
/// Deactivates all completed tasks.
/// </summary>
public void DeactivateCompletedTasks()
{
List <TaskViewModel> completedTaskList = ActiveTasks.Where(t => t.IsCompleted == true).ToList();
if (completedTaskList != null)
{
foreach (TaskViewModel taskVM in completedTaskList)
{
taskVM.IsActive = false;
taskVM.Save();
}
}
}
private void CompletedTask(ThreadTask task)
{
CompletedTasks.Add(task);
ActiveTasks.Remove(task);
if (task.IsError)
{
OnErrorTask?.Invoke(this, new ThreadManagerScheduledTaskEventArgs(task));
}
else
{
OnCompletedTask?.Invoke(this, new ThreadManagerScheduledTaskEventArgs(task));
}
}
/// <summary>
/// Moves the selected task down in order within active task list.
/// </summary>
public void MoveDownTask()
{
TaskViewModel selectedTaskVM = ActiveTasks.FirstOrDefault(t => t.IsSelected == true);
TaskViewModel nextTaskVM = ActiveTasks[ActiveTasks.IndexOf(selectedTaskVM) + 1];
if (selectedTaskVM != null && nextTaskVM != null)
{
int selectedSortOrder = selectedTaskVM.SortOrder.Value;
int nextSortOrder = nextTaskVM.SortOrder.Value;
selectedTaskVM.SortOrder = nextSortOrder;
selectedTaskVM.Save();
nextTaskVM.SortOrder = selectedSortOrder;
nextTaskVM.Save();
}
}
/// <summary>
/// Moves the selected task up in order within active task list.
/// </summary>
public void MoveUpTask()
{
TaskViewModel selectedTaskVM = ActiveTasks.FirstOrDefault(t => t.IsSelected == true);
TaskViewModel previousTaskVM = ActiveTasks[ActiveTasks.IndexOf(selectedTaskVM) - 1];
if (selectedTaskVM != null && previousTaskVM != null)
{
int selectedSortOrder = selectedTaskVM.SortOrder.Value;
int previousSortorder = previousTaskVM.SortOrder.Value;
selectedTaskVM.SortOrder = previousSortorder;
selectedTaskVM.Save();
previousTaskVM.SortOrder = selectedSortOrder;
previousTaskVM.Save();
}
}
private void RunTask(ThreadTask task)
{
task.OnCompletedTask += Task_OnCompletedTask;
task.OnErrorTask += Task_OnErrorTask;
ActiveTasks.Add(task);
QueuingTasks.Remove(task);
var thread = new System.Threading.Thread(() =>
{
System.Threading.Thread.Sleep(task.DelayMilliseconds);
task.Run();
});
thread.Start();
OnStartedTask?.Invoke(this, new ThreadManagerScheduledTaskEventArgs(task));
}
private MessageFromServerToClient HandleFailureReport([NotNull] MessageFromClientToServer req)
{
var task = ActiveTasks.FirstOrDefault(x => x.Guid == req.TaskGuid);
if (task == null)
{
throw new DistSimException("Invalid guid: " + req.TaskGuid);
}
task.FinishStatusMessage = req.ClientRequest + " " + req.Message;
SaveExecuteHelper.Get().SaveExecuteWithWait(() => ActiveTasks.Remove(task));
SaveExecuteHelper.Get().SaveExecuteWithWait(() => FinishedTasks.Add(task));
_errorLogger.Error(task.OriginalJsonFilePath + " - no output at all at client " + req.ClientName, _threadId);
Logger.Error(task.OriginalJsonFilePath + " - no output at all at client " + req.ClientName, _threadId);
return(new MessageFromServerToClient(ServerResponseEnum.JobFinishAck, req.TaskGuid));
}
public MainPage(User user)
{
InitializeComponent();
this.user = user;
if (!user.IsManager)
{
AssignedByMeTasks.Visibility = Visibility.Hidden;
assignedCB.IsEnabled = false;
}
ActiveTasks.RaiseEvent(new RoutedEventArgs(ButtonBase.ClickEvent));
using (TaskListDB db = new TaskListDB())
{
Users = db.Users.ToList();
DataContext = Users;
}
}
public void Dispose()
{
if (ActiveTasks != null)
{
ActiveTasks.Clear();
ActiveTasks = null;
}
if (ProcessingTasks != null)
{
ProcessingTasks.Clear();
ProcessingTasks = null;
}
if (ActiveCommand != null)
{
ActiveCommand.Dispose();
ActiveCommand = null;
}
NotifyDisposed();
}
private void TaskManagerWorkerLoop()
{
if (TaskManagerWorkerTask != null && TaskManagerWorkerTask.Status == TaskStatus.Running)
{
return;
}
TaskQueueStarted?.Invoke(this, new EventArgs());
var lastLog = DateTime.Now;
TaskManagerWorkerTask = Task.Run(() =>
{
Logger.LogInformation("Started QueueManagerTask loop at Task ID {0}", Task.CurrentId);
while (ActiveTasks.Any() || ScheduledTasks.Any())
{
if (!Running.Wait(500))
{
continue;
}
Thread.Sleep(500);
if ((DateTime.Now - lastLog).Seconds > WORKER_LOOP_LOGGER_INTERVAL_SECS)
{
lastLog = DateTime.Now;
Logger.LogInformation("Active: {1} <{#!#}> Running: {2} <{#!#}> Scheduled: {3}",
ActiveTasks.Count,
ActiveTasks.Count(t => t.Key.Status == TaskStatus.Running),
ScheduledTasks.Count);
}
lock (ActiveTasks)
{
foreach (var task in ActiveTasks.Where(t => t.Key.Status == TaskStatus.Created))
{
Logger.LogDebug("Starting Task ID {0}", task.Key.Id);
try
{
task.Key.Start();
task.Key.ContinueWith(t =>
{
ActiveTasks.TryRemove(t, out var emptyVar);
Logger.LogDebug("Task ID {0} has completed", t.Id);
TaskCompleted?.Invoke(this, task.Key);
});
TaskStarted?.Invoke(this, task.Key);
}
catch (Exception ex)
{
Logger.LogCritical(ex, "Error starting task {0}", task.Key.Id);
}
}
}
while (ActiveTasks.Count < MaximumConcurrentThreads && ScheduledTasks.Any())
{
// Keep TaskManager full to maximum by dequeueing scheduled tasks
// TODO: If these Try*s fail, weird things will happen; need to handle false cases
if (ScheduledTasks.TryDequeue(out var task))
{
Logger.LogDebug("Moving status of Task {0} from {1} to {2} ", task.Id, "scheduled",
"active");
ActiveTasks.TryAdd(task, false);
}
}
}
TaskManagerWorkerTask = null;
TaskQueueDrained?.Invoke(this, new EventArgs());
Logger.LogDebug("Task Queue drained");
});
//TaskManagerWorkerTask.Tag(WorkspaceId, true);
}
public bool IsTaskActive(Guid id)
{
return(ActiveTasks.FirstOrDefault(k => k.Id == id) != null);
}
void Deactivate(System.Type taskType)
{
ActiveTasks.Remove(taskType);
}
public void DeactivateAll()
{
ActiveTasks.Clear();
}
private MessageFromServerToClient HandleTaskFinishReport([NotNull] MessageFromClientToServer req)
{
try {
_logger.Info("got a finish report from " + req.ClientName + " for " + req.HouseName, _threadId);
ServerExecutionTask set = ActiveTasks.FirstOrDefault(x => x.Guid == req.TaskGuid);
if (set == null)
{
return(new MessageFromServerToClient(ServerResponseEnum.JobFinishAck, req.TaskGuid));
//if it is an old task guid from previous run, just ignore the finish report
//throw new DistSimException("No task found for guid " + req.TaskGuid);
}
set.ExecutionEnd = DateTime.Now;
SaveExecuteHelper.Get().SaveExecuteWithWait(() => ActiveTasks.Remove(set));
SaveExecuteHelper.Get().SaveExecuteWithWait(() => {
FinishedTasks.Add(set);
while (FinishedTasks.Count > 20)
{
FinishedTasks.RemoveAt(0);
}
});
set.FinishStatusMessage = req.Message;
var resultFileArchiveDirectory = MakeResultFileDirectory(req);
DirectoryInfo di = new DirectoryInfo(resultFileArchiveDirectory);
if (di.Exists)
{
_logger.Info("deleting previous results from " + di.FullName, _threadId);
SaveDelete(di);
Thread.Sleep(250);
}
di.Create();
_logger.Info("created " + di.FullName, _threadId);
bool isFailure = false;
if (req.ResultFiles != null)
{
foreach (var jsonfile in req.ResultFiles)
{
string directory = Path.Combine(resultFileArchiveDirectory, jsonfile.RelativeDirectory);
DirectoryInfo subdir = new DirectoryInfo(directory);
if (!subdir.Exists)
{
subdir.Create();
}
string dstPath = Path.Combine(directory, jsonfile.FileName);
_logger.Info("writing " + dstPath + "," + "\nresult archive dir: " + resultFileArchiveDirectory + "\n relative dir: " +
jsonfile.RelativeDirectory,
_threadId);
jsonfile.WriteBytesFromJson(dstPath, Logger);
if (jsonfile.FileName.ToLower(CultureInfo.InvariantCulture) == "calculationexceptions.txt")
{
string fileContent = File.ReadAllText(dstPath);
_errorLogger.Error(set.OriginalJsonFilePath + " - error during calc " + fileContent, _threadId);
_logger.Error(set.OriginalJsonFilePath + " - error during calc " + fileContent, _threadId);
isFailure = true;
}
}
}
else
{
_logger.Error("No result files were delivered", _threadId);
}
ArchiveJsonFile(set, isFailure);
var answer = new MessageFromServerToClient(ServerResponseEnum.JobFinishAck, req.TaskGuid);
return(answer);
}
catch (Exception ex) {
_logger.Exception(ex, "Error while handling a finish report " + ex.Message);
throw;
}
}
bool CanDeactivateTask()
{
return(ActiveTasks.Count(t => t.IsSelected == true) == 1);
}
void GongSolutions.Wpf.DragDrop.IDropTarget.Drop(DropInfo dropInfo)
{
TaskViewModel sourceTask = (TaskViewModel)dropInfo.Data;
int oldIndex = ActiveTasks.IndexOf(sourceTask);
int newIndex = dropInfo.InsertIndex;
if (oldIndex >= 0)
{
if (newIndex < oldIndex)
{
// move the item up in the list toward the top
ActiveTasks.Move(oldIndex, newIndex);
List <TaskViewModel> tasksToSave = new List <TaskViewModel>();
// update our sort order values
for (int i = newIndex; i < oldIndex; i++)
{
TaskViewModel currentTaskVM = ActiveTasks[i];
TaskViewModel nextTaskVM = ActiveTasks[i + 1];
int currentSortOrder = currentTaskVM.SortOrder.Value;
int nextSortOrder = nextTaskVM.SortOrder.Value;
currentTaskVM.SortOrder = nextSortOrder;
nextTaskVM.SortOrder = currentSortOrder;
tasksToSave.Add(currentTaskVM);
if (i + 1 == oldIndex)
{
tasksToSave.Add(nextTaskVM);
}
}
foreach (TaskViewModel updatedTask in tasksToSave)
{
updatedTask.Save();
}
}
else if (newIndex > oldIndex)
{
// move the item down in the list toward the bottom
ActiveTasks.Move(oldIndex, newIndex - 1);
List <TaskViewModel> tasksToSave = new List <TaskViewModel>();
// update our sort order values
for (int i = newIndex - 1; i > oldIndex; i--)
{
TaskViewModel currentTaskVM = ActiveTasks[i];
TaskViewModel previousTaskVM = ActiveTasks[i - 1];
int currentSortOrder = currentTaskVM.SortOrder.Value;
int previousSortOrder = previousTaskVM.SortOrder.Value;
currentTaskVM.SortOrder = previousSortOrder;
previousTaskVM.SortOrder = currentSortOrder;
tasksToSave.Add(currentTaskVM);
if (i - 1 == oldIndex)
{
tasksToSave.Add(previousTaskVM);
}
}
foreach (TaskViewModel updatedTask in tasksToSave)
{
updatedTask.Save();
}
}
}
}
bool CanMoveDownTask()
{
TaskViewModel selectedTask = ActiveTasks.Where(t => t.IsSelected == true).FirstOrDefault();
return(selectedTask != null && (ActiveTasks.IndexOf(selectedTask) < (ActiveTasks.Count - 1)) && ActiveTasks.Count(t => t.IsSelected == true) == 1);
}
bool CanDeactivateCompletedTasks()
{
return(ActiveTasks.Count(t => t.IsCompleted == true) > 0);
}
