public override async System.Threading.Tasks.Task RefreshAsync(ModelRefreshType refreshType, bool showTrackedOperation = true)
{
Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.UpperRight, true));
if (refreshType.HasFlag(ModelRefreshType.Basic))
{
try
{
System.Threading.Tasks.Task asyncTask = this.Job.RefreshAsync(OptionsModel.Instance.ListDetailLevel);
if (showTrackedOperation)
{
AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel(
asyncTask,
new JobOperation(JobOperation.Refresh, this.Job.Id)));
}
else
{
AsyncOperationTracker.Instance.AddTrackedInternalOperation(asyncTask);
}
await asyncTask;
this.LastUpdatedTime = DateTime.UtcNow;
//
// Fire property change events for this models properties
//
this.FireChangesOnRefresh(ModelRefreshType.Basic);
}
catch (Exception e)
{
this.HandleException(e);
}
}
if (refreshType.HasFlag(ModelRefreshType.Children))
{
try
{
//Set this before the children load so that on revisit we know we have loaded the children (or are in the process)
this.HasLoadedChildren = true;
System.Threading.Tasks.Task <List <TaskModel> > asyncTask = this.ListTasksAsync();
AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel(
asyncTask,
new JobOperation(JobOperation.ListTasks, this.Job.Id)));
this.Tasks = await asyncTask;
this.TaskCollection = CollectionViewSource.GetDefaultView(this.Tasks);
this.UpdateTaskView();
}
catch (Exception e)
{
this.HasLoadedChildren = false; //On exception, we failed to load children so try again next time
this.HandleException(e);
}
}
Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.UpperRight, false));
Messenger.Default.Send(new JobUpdateCompleteMessage());
}
public override async Task RefreshAsync(ModelRefreshType refreshType, bool showTrackedOperation = true)
{
if (refreshType.HasFlag(ModelRefreshType.Basic))
{
try
{
Task asyncTask = this.JobSchedule.RefreshAsync();
if (showTrackedOperation)
{
AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel(
asyncTask,
new JobScheduleOperation(JobScheduleOperation.Refresh, this.JobSchedule.Id)));
}
else
{
AsyncOperationTracker.Instance.AddTrackedInternalOperation(asyncTask);
}
await asyncTask;
this.LastUpdatedTime = DateTime.UtcNow;
//
// Fire property change events for this models properties
//
this.FireChangesOnRefresh(ModelRefreshType.Basic);
}
catch (Exception e)
{
this.HandleException(e);
}
}
}
public override async Task RefreshAsync(ModelRefreshType refreshType, bool showTrackedOperation = true)
{
if (refreshType.HasFlag(ModelRefreshType.Basic))
{
try
{
Task asyncTask = this.JobSchedule.RefreshAsync();
if (showTrackedOperation)
{
AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel(
asyncTask,
new JobScheduleOperation(JobScheduleOperation.Refresh, this.JobSchedule.Id)));
}
else
{
AsyncOperationTracker.Instance.AddTrackedInternalOperation(asyncTask);
}
await asyncTask;
this.LastUpdatedTime = DateTime.UtcNow;
//
// Fire property change events for this models properties
//
this.FireChangesOnRefresh(ModelRefreshType.Basic);
}
catch (Exception e)
{
this.HandleException(e);
}
}
}
public override async System.Threading.Tasks.Task RefreshAsync(ModelRefreshType refreshType, bool showTrackedOperation = true)
{
if (refreshType.HasFlag(ModelRefreshType.Basic))
{
try
{
System.Threading.Tasks.Task asyncTask = this.WorkItem.RefreshAsync();
if (showTrackedOperation)
{
AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel(
asyncTask,
new WorkItemOperation(WorkItemOperation.Refresh, this.WorkItem.Name)));
}
else
{
AsyncOperationTracker.Instance.AddTrackedInternalOperation(asyncTask);
}
await asyncTask;
this.LastUpdatedTime = DateTime.UtcNow;
//
// Fire property change events for this models properties
//
this.FireChangesOnRefresh(ModelRefreshType.Basic);
}
catch (Exception e)
{
this.HandleException(e);
}
}
if (refreshType.HasFlag(ModelRefreshType.Children))
{
try
{
//Set this before the children load so that on revisit we know we have loaded the children (or are in the process)
this.HasLoadedChildren = true;
System.Threading.Tasks.Task <List <JobModel> > asyncTask = this.ListJobsAsync();
AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel(
asyncTask,
new WorkItemOperation(WorkItemOperation.ListJobs, this.WorkItem.Name)));
this.Jobs = await asyncTask;
this.FireChangesOnRefresh(ModelRefreshType.Children);
}
catch (Exception e)
{
this.HasLoadedChildren = false; //On exception, we failed to load children so try again next time
this.HandleException(e);
}
}
}
/// <summary>
/// Fires a set of property changes on refresh based on the refresh type
/// </summary>
/// <param name="refreshType"></param>
protected void FireChangesOnRefresh(ModelRefreshType refreshType)
{
Type myType = this.GetType();
//Get all the public properties of this type
PropertyInfo[] properties = myType.GetProperties(BindingFlags.Public | BindingFlags.Instance);
foreach (PropertyInfo property in properties)
{
//Find all attributes on this property
Attribute[] attributes = Attribute.GetCustomAttributes(property, true);
IEnumerable <ChangeTrackedAttribute> changeTrackedAttributes = attributes.OfType <ChangeTrackedAttribute>();
bool hasPropertyChanged = changeTrackedAttributes.Any() && changeTrackedAttributes.All(attribute => attribute.HasChanged(refreshType));
if (hasPropertyChanged)
{
this.FirePropertyChangedEvent(property.Name); //Fire the event associated with this property on change
}
}
}
public override async Task RefreshAsync(ModelRefreshType refreshType, bool showTrackedOperation = true)
{
Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.UpperRight, true));
if (refreshType.HasFlag(ModelRefreshType.Basic))
{
try
{
System.Threading.Tasks.Task asyncTask = this.Certificate.RefreshAsync(OptionsModel.Instance.ListDetailLevel);
if (showTrackedOperation)
{
AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel(
asyncTask,
new CertificateOperation(CertificateOperation.Refresh, this.Certificate.Thumbprint, this.Certificate.ThumbprintAlgorithm)));
}
else
{
AsyncOperationTracker.Instance.AddTrackedInternalOperation(asyncTask);
}
await asyncTask;
this.LastUpdatedTime = DateTime.UtcNow;
//
// Fire property change events for this models properties
//
this.FireChangesOnRefresh(ModelRefreshType.Basic);
}
catch (Exception e)
{
this.HandleException(e);
}
}
Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.UpperRight, false));
Messenger.Default.Send(new CertificateUpdateCompleteMessage());
}
public override async Task RefreshAsync(ModelRefreshType refreshType, bool showTrackedOperation = true)
{
Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.UpperRight, true));
if (refreshType.HasFlag(ModelRefreshType.Basic))
{
try
{
System.Threading.Tasks.Task asyncTask = this.Certificate.RefreshAsync(OptionsModel.Instance.ListDetailLevel);
if (showTrackedOperation)
{
AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel(
asyncTask,
new CertificateOperation(CertificateOperation.Refresh, this.Certificate.Thumbprint, this.Certificate.ThumbprintAlgorithm)));
}
else
{
AsyncOperationTracker.Instance.AddTrackedInternalOperation(asyncTask);
}
await asyncTask;
this.LastUpdatedTime = DateTime.UtcNow;
//
// Fire property change events for this models properties
//
this.FireChangesOnRefresh(ModelRefreshType.Basic);
}
catch (Exception e)
{
this.HandleException(e);
}
}
Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.UpperRight, false));
Messenger.Default.Send(new CertificateUpdateCompleteMessage());
}
public override async System.Threading.Tasks.Task RefreshAsync(ModelRefreshType refreshType, bool showTrackedOperation = true)
{
if (refreshType.HasFlag(ModelRefreshType.Basic))
{
try
{
//await this.Task.RefreshAsync(); TODO: This doesnt' work right now due to bug with OM, so must do GetTask directly
Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.UpperRight, true));
System.Threading.Tasks.Task <CloudTask> asyncTask = MainViewModel.dataProvider.Service.GetTaskAsync(
this.ParentJob.Id,
this.Task.Id,
OptionsModel.Instance.ListDetailLevel);
if (showTrackedOperation)
{
AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel(
asyncTask,
new TaskOperation(TaskOperation.Refresh, this.ParentJob.Id, this.Task.Id)));
}
else
{
AsyncOperationTracker.Instance.AddTrackedInternalOperation(asyncTask);
}
this.Task = await asyncTask;
this.LastUpdatedTime = DateTime.UtcNow;
//
// Fire property change events for this models properties
//
this.FireChangesOnRefresh(ModelRefreshType.Basic);
}
catch (Exception e)
{
this.HandleException(e);
}
finally
{
Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.UpperRight, false));
}
}
if (refreshType.HasFlag(ModelRefreshType.Children))
{
try
{
Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.LowerRight, true));
//Set this before the children load so that on revisit we know we have loaded the children (or are in the process)
this.HasLoadedChildren = true;
try
{
System.Threading.Tasks.Task <List <NodeFile> > asyncTask = this.ListTaskFilesAsync();
AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel(
asyncTask,
new TaskOperation(TaskOperation.ListFiles, this.ParentJob.Id, this.Task.Id)));
this.OutputFiles = await asyncTask;
}
catch (Exception)
{
this.HasLoadedChildren = false; //On exception, we failed to load children so try again next time
//Swallow the exception to stop popups from occuring for every bad VM
}
this.FireChangesOnRefresh(ModelRefreshType.Children);
}
catch (Exception e)
{
this.HasLoadedChildren = false; //On exception, we failed to load children so try again next time
this.HandleException(e);
}
finally
{
Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.LowerRight, false));
}
}
}
public override async System.Threading.Tasks.Task RefreshAsync(ModelRefreshType refreshType, bool showTrackedOperation = true)
{
Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.UpperRight, true));
if (refreshType.HasFlag(ModelRefreshType.Basic))
{
try
{
System.Threading.Tasks.Task asyncTask = this.Job.RefreshAsync(OptionsModel.Instance.ListDetailLevel);
if (showTrackedOperation)
{
AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel(
asyncTask,
new JobOperation(JobOperation.Refresh, this.Job.Id)));
}
else
{
AsyncOperationTracker.Instance.AddTrackedInternalOperation(asyncTask);
}
await asyncTask;
this.LastUpdatedTime = DateTime.UtcNow;
//
// Fire property change events for this models properties
//
this.FireChangesOnRefresh(ModelRefreshType.Basic);
}
catch (Exception e)
{
this.HandleException(e);
}
}
if (refreshType.HasFlag(ModelRefreshType.Children))
{
try
{
//Set this before the children load so that on revisit we know we have loaded the children (or are in the process)
this.HasLoadedChildren = true;
System.Threading.Tasks.Task<List<TaskModel>> asyncTask = this.ListTasksAsync();
AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel(
asyncTask,
new JobOperation(JobOperation.ListTasks, this.Job.Id)));
this.Tasks = await asyncTask;
this.TaskCollection = CollectionViewSource.GetDefaultView(this.Tasks);
this.UpdateTaskView();
}
catch (Exception e)
{
this.HasLoadedChildren = false; //On exception, we failed to load children so try again next time
this.HandleException(e);
}
}
Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.UpperRight, false));
Messenger.Default.Send(new JobUpdateCompleteMessage());
}
/// <summary>
/// Fires a set of property changes on refresh based on the refresh type
/// </summary>
/// <param name="refreshType"></param>
protected void FireChangesOnRefresh(ModelRefreshType refreshType)
{
Type myType = this.GetType();
//Get all the public properties of this type
PropertyInfo[] properties = myType.GetProperties(BindingFlags.Public | BindingFlags.Instance);
foreach (PropertyInfo property in properties)
{
//Find all attributes on this property
Attribute[] attributes = Attribute.GetCustomAttributes(property, true);
IEnumerable<ChangeTrackedAttribute> changeTrackedAttributes = attributes.OfType<ChangeTrackedAttribute>();
bool hasPropertyChanged = changeTrackedAttributes.Any() && changeTrackedAttributes.All(attribute => attribute.HasChanged(refreshType));
if (hasPropertyChanged)
{
this.FirePropertyChangedEvent(property.Name); //Fire the event associated with this property on change
}
}
}
/// <summary>
/// Returns true if this property has been changed based on the refresh type
/// </summary>
/// <param name="changeRefreshType">The type of refresh which was performed</param>
/// <returns></returns>
public bool HasChanged(ModelRefreshType changeRefreshType)
{
return(this.refreshType.HasFlag(changeRefreshType));
}
public ChangeTrackedAttribute(ModelRefreshType refreshType)
{
this.refreshType = refreshType;
}
public override async System.Threading.Tasks.Task RefreshAsync(ModelRefreshType refreshType, bool showTrackedOperation = true)
{
if (refreshType.HasFlag(ModelRefreshType.Basic))
{
try
{
//await this.Task.RefreshAsync(); TODO: This doesnt' work right now due to bug with OM, so must do GetTask directly
Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.UpperRight, true));
System.Threading.Tasks.Task<CloudTask> asyncTask = MainViewModel.dataProvider.Service.GetTaskAsync(
this.ParentJob.Id,
this.Task.Id,
OptionsModel.Instance.ListDetailLevel);
if (showTrackedOperation)
{
AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel(
asyncTask,
new TaskOperation(TaskOperation.Refresh, this.ParentJob.Id, this.Task.Id)));
}
else
{
AsyncOperationTracker.Instance.AddTrackedInternalOperation(asyncTask);
}
this.Task = await asyncTask;
this.LastUpdatedTime = DateTime.UtcNow;
//
// Fire property change events for this models properties
//
this.FireChangesOnRefresh(ModelRefreshType.Basic);
}
catch (Exception e)
{
this.HandleException(e);
}
finally
{
Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.UpperRight, false));
}
}
if (refreshType.HasFlag(ModelRefreshType.Children))
{
try
{
Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.LowerRight, true));
//Set this before the children load so that on revisit we know we have loaded the children (or are in the process)
this.HasLoadedChildren = true;
try
{
System.Threading.Tasks.Task<List<NodeFile>> asyncTask = this.ListTaskFilesAsync();
AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel(
asyncTask,
new TaskOperation(TaskOperation.ListFiles, this.ParentJob.Id, this.Task.Id)));
this.OutputFiles = await asyncTask;
}
catch (Exception)
{
this.HasLoadedChildren = false; //On exception, we failed to load children so try again next time
//Swallow the exception to stop popups from occuring for every bad VM
}
this.FireChangesOnRefresh(ModelRefreshType.Children);
}
catch (Exception e)
{
this.HasLoadedChildren = false; //On exception, we failed to load children so try again next time
this.HandleException(e);
}
finally
{
Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.LowerRight, false));
}
}
}
/// <summary>
/// Returns true if this property has been changed based on the refresh type
/// </summary>
/// <param name="changeRefreshType">The type of refresh which was performed</param>
/// <returns></returns>
public bool HasChanged(ModelRefreshType changeRefreshType)
{
return this.refreshType.HasFlag(changeRefreshType);
}
/// <summary> /// Refreshes this model with the specified refresh type /// </summary> /// <param name="refreshType">The refresh type to use</param> /// <param name="showTrackedOperation">Show the refresh row in the tracking list</param> /// <returns></returns> public abstract System.Threading.Tasks.Task RefreshAsync(ModelRefreshType refreshType, bool showTrackedOperation = true);
/// <summary> /// Refreshes this model with the specified refresh type /// </summary> /// <param name="refreshType">The refresh type to use</param> /// <param name="showTrackedOperation">Show the refresh row in the tracking list</param> /// <returns></returns> public abstract System.Threading.Tasks.Task RefreshAsync(ModelRefreshType refreshType, bool showTrackedOperation = true);
public override async System.Threading.Tasks.Task RefreshAsync(ModelRefreshType refreshType, bool showTrackedOperation = true)
{
this.attemptToLoadOutputs = true;
if (refreshType.HasFlag(ModelRefreshType.Basic))
{
try
{
//await this.Task.RefreshAsync(); TODO: This doesnt' work right now due to bug with OM, so must do GetTask directly
Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.UpperRight, true));
System.Threading.Tasks.Task <CloudTask> asyncTask = MainViewModel.dataProvider.Service.GetTaskAsync(
this.ParentJob.Id,
this.Task.Id,
OptionsModel.Instance.ListDetailLevel);
if (showTrackedOperation)
{
AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel(
asyncTask,
new TaskOperation(TaskOperation.Refresh, this.ParentJob.Id, this.Task.Id)));
}
else
{
AsyncOperationTracker.Instance.AddTrackedInternalOperation(asyncTask);
}
this.Task = await asyncTask;
this.LastUpdatedTime = DateTime.UtcNow;
IPagedEnumerable <SubtaskInformation> subtasks = this.Task.ListSubtasks(OptionsModel.Instance.ListDetailLevel);
this.SubtasksInfo = new List <SubtaskModel>();
await subtasks.ForEachAsync(item => this.SubtasksInfo.Add(new SubtaskModel(item)));
//
// Fire property change events for this models properties
//
this.FireChangesOnRefresh(ModelRefreshType.Basic);
}
catch (Exception e)
{
this.HandleException(e);
}
finally
{
Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.UpperRight, false));
}
}
if (refreshType.HasFlag(ModelRefreshType.Children))
{
try
{
Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.LowerRight, true));
//Set this before the children load so that on revisit we know we have loaded the children (or are in the process)
this.HasLoadedChildren = true;
try
{
System.Threading.Tasks.Task <List <NodeFile> > asyncTask = this.ListTaskFilesAsync();
AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel(
asyncTask,
new TaskOperation(TaskOperation.ListFiles, this.ParentJob.Id, this.Task.Id)));
this.OutputFiles = await asyncTask;
}
catch (BatchException be)
{
StringBuilder noOutputReasonBuilder = new StringBuilder();
if (be.RequestInformation != null && be.RequestInformation.AzureError != null)
{
if (!string.IsNullOrEmpty(be.RequestInformation.AzureError.Code))
{
noOutputReasonBuilder.AppendLine(be.RequestInformation.AzureError.Code);
}
if (be.RequestInformation.AzureError.Message != null && !string.IsNullOrEmpty(be.RequestInformation.AzureError.Message.Value))
{
noOutputReasonBuilder.AppendLine(be.RequestInformation.AzureError.Message.Value);
}
if (be.RequestInformation.AzureError.Values != null)
{
noOutputReasonBuilder.AppendLine();
foreach (var errorDetail in be.RequestInformation.AzureError.Values)
{
noOutputReasonBuilder.AppendLine(string.Format("{0}: {1}", errorDetail.Key, errorDetail.Value));
}
}
this.NoOutputFilesReason = noOutputReasonBuilder.ToString();
}
}
catch (Exception)
{
this.HasLoadedChildren = false; //On exception, we failed to load children so try again next time
//Swallow the exception to stop popups from occuring for every bad VM
}
this.FireChangesOnRefresh(ModelRefreshType.Children);
}
catch (Exception e)
{
this.HasLoadedChildren = false; //On exception, we failed to load children so try again next time
this.HandleException(e);
}
finally
{
Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.LowerRight, false));
}
}
}
public override async System.Threading.Tasks.Task RefreshAsync(ModelRefreshType refreshType, bool showTrackedOperation = true)
{
if (refreshType.HasFlag(ModelRefreshType.Basic))
{
try
{
System.Threading.Tasks.Task asyncTask = this.WorkItem.RefreshAsync();
if (showTrackedOperation)
{
AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel(
asyncTask,
new WorkItemOperation(WorkItemOperation.Refresh, this.WorkItem.Name)));
}
else
{
AsyncOperationTracker.Instance.AddTrackedInternalOperation(asyncTask);
}
await asyncTask;
this.LastUpdatedTime = DateTime.UtcNow;
//
// Fire property change events for this models properties
//
this.FireChangesOnRefresh(ModelRefreshType.Basic);
}
catch (Exception e)
{
this.HandleException(e);
}
}
if (refreshType.HasFlag(ModelRefreshType.Children))
{
try
{
//Set this before the children load so that on revisit we know we have loaded the children (or are in the process)
this.HasLoadedChildren = true;
System.Threading.Tasks.Task<List<JobModel>> asyncTask = this.ListJobsAsync();
AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel(
asyncTask,
new WorkItemOperation(WorkItemOperation.ListJobs, this.WorkItem.Name)));
this.Jobs = await asyncTask;
this.FireChangesOnRefresh(ModelRefreshType.Children);
}
catch (Exception e)
{
this.HasLoadedChildren = false; //On exception, we failed to load children so try again next time
this.HandleException(e);
}
}
}
public override async Task RefreshAsync(ModelRefreshType refreshType, bool showTrackedOperation = true)
{
if (refreshType.HasFlag(ModelRefreshType.Basic))
{
try
{
Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.UpperRight, true));
System.Threading.Tasks.Task asyncTask = this.VM.RefreshAsync();
if (showTrackedOperation)
{
AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel(
asyncTask,
new VMOperation(VMOperation.Refresh, this.ParentPool.Name, this.VM.Name)));
}
else
{
AsyncOperationTracker.Instance.AddTrackedInternalOperation(asyncTask);
}
await asyncTask;
this.LastUpdatedTime = DateTime.UtcNow;
//
// Fire property change events for this models properties
//
this.FireChangesOnRefresh(ModelRefreshType.Basic);
}
catch (Exception e)
{
this.HandleException(e);
}
finally
{
Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.UpperRight, false));
}
}
if (refreshType.HasFlag(ModelRefreshType.Children))
{
try
{
Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.LowerRight, true));
//Set this before the children load so that on revisit we know we have loaded the children (or are in the process)
this.HasLoadedChildren = true;
try
{
System.Threading.Tasks.Task <List <ITaskFile> > asyncTask = this.ListFilesAsync();
AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel(
asyncTask,
new VMOperation(VMOperation.ListVMFiles, this.ParentPool.Name, this.VM.Name)));
this.Files = await asyncTask;
}
catch (Exception)
{
this.HasLoadedChildren = false; //On exception, we failed to load children so try again next time
//Swallow the exception to stop popups from occuring for every bad VM
}
this.FireChangesOnRefresh(ModelRefreshType.Children);
}
catch (Exception e)
{
this.HasLoadedChildren = false; //On exception, we failed to load children so try again next time
this.HandleException(e);
}
finally
{
Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.LowerRight, false));
}
}
}
public override async System.Threading.Tasks.Task RefreshAsync(ModelRefreshType refreshType, bool showTrackedOperation = true)
{
this.attemptToLoadOutputs = true;
if (refreshType.HasFlag(ModelRefreshType.Basic))
{
try
{
//await this.Task.RefreshAsync(); TODO: This doesnt' work right now due to bug with OM, so must do GetTask directly
Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.UpperRight, true));
System.Threading.Tasks.Task<CloudTask> asyncTask = MainViewModel.dataProvider.Service.GetTaskAsync(
this.ParentJob.Id,
this.Task.Id,
OptionsModel.Instance.ListDetailLevel);
if (showTrackedOperation)
{
AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel(
asyncTask,
new TaskOperation(TaskOperation.Refresh, this.ParentJob.Id, this.Task.Id)));
}
else
{
AsyncOperationTracker.Instance.AddTrackedInternalOperation(asyncTask);
}
this.Task = await asyncTask;
this.LastUpdatedTime = DateTime.UtcNow;
//
// Fire property change events for this models properties
//
this.FireChangesOnRefresh(ModelRefreshType.Basic);
}
catch (Exception e)
{
this.HandleException(e);
}
finally
{
Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.UpperRight, false));
}
}
if (refreshType.HasFlag(ModelRefreshType.Children))
{
try
{
Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.LowerRight, true));
//Set this before the children load so that on revisit we know we have loaded the children (or are in the process)
this.HasLoadedChildren = true;
try
{
System.Threading.Tasks.Task<List<NodeFile>> asyncTask = this.ListTaskFilesAsync();
AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel(
asyncTask,
new TaskOperation(TaskOperation.ListFiles, this.ParentJob.Id, this.Task.Id)));
this.OutputFiles = await asyncTask;
}
catch (BatchException be)
{
StringBuilder noOutputReasonBuilder = new StringBuilder();
if (be.RequestInformation != null && be.RequestInformation.BatchError != null)
{
if (!string.IsNullOrEmpty(be.RequestInformation.BatchError.Code))
{
noOutputReasonBuilder.AppendLine(be.RequestInformation.BatchError.Code);
}
if (be.RequestInformation.BatchError.Message != null && !string.IsNullOrEmpty(be.RequestInformation.BatchError.Message.Value))
{
noOutputReasonBuilder.AppendLine(be.RequestInformation.BatchError.Message.Value);
}
if (be.RequestInformation.BatchError.Values != null)
{
noOutputReasonBuilder.AppendLine();
foreach (var errorDetail in be.RequestInformation.BatchError.Values)
{
noOutputReasonBuilder.AppendLine(string.Format("{0}: {1}", errorDetail.Key, errorDetail.Value));
}
}
this.NoOutputFilesReason = noOutputReasonBuilder.ToString();
}
}
catch (Exception)
{
this.HasLoadedChildren = false; //On exception, we failed to load children so try again next time
//Swallow the exception to stop popups from occuring for every bad VM
}
IPagedEnumerable<SubtaskInformation> subtasks = this.Task.ListSubtasks(OptionsModel.Instance.ListDetailLevel);
this.SubtasksInfo = new List<SubtaskModel>();
System.Threading.Tasks.Task asyncListSubtasksTask = subtasks.ForEachAsync(item => this.SubtasksInfo.Add(new SubtaskModel(item)));
AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel(
asyncListSubtasksTask,
new TaskOperation(TaskOperation.ListSubtasks, this.ParentJob.Id, this.Task.Id)));
await asyncListSubtasksTask;
this.FireChangesOnRefresh(ModelRefreshType.Children);
}
catch (Exception e)
{
this.HasLoadedChildren = false; //On exception, we failed to load children so try again next time
this.HandleException(e);
}
finally
{
Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.LowerRight, false));
}
}
}
public override async Task RefreshAsync(ModelRefreshType refreshType, bool showTrackedOperation = true)
{
if (refreshType.HasFlag(ModelRefreshType.Basic))
{
try
{
Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.UpperRight, true));
Task asyncTask = this.ComputeNode.RefreshAsync();
if (showTrackedOperation)
{
AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel(
asyncTask,
new ComputeNodeOperation(ComputeNodeOperation.Refresh, this.ParentPool.Id, this.ComputeNode.Id)));
}
else
{
AsyncOperationTracker.Instance.AddTrackedInternalOperation(asyncTask);
}
await asyncTask;
this.LastUpdatedTime = DateTime.UtcNow;
//
// Fire property change events for this models properties
//
this.FireChangesOnRefresh(ModelRefreshType.Basic);
}
catch (Exception e)
{
this.HandleException(e);
}
finally
{
Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.UpperRight, false));
}
}
if (refreshType.HasFlag(ModelRefreshType.Children))
{
try
{
Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.LowerRight, true));
//Set this before the children load so that on revisit we know we have loaded the children (or are in the process)
this.HasLoadedChildren = true;
try
{
Task<List<NodeFile>> asyncTask = this.ListFilesAsync();
AsyncOperationTracker.Instance.AddTrackedOperation(new AsyncOperationModel(
asyncTask,
new ComputeNodeOperation(ComputeNodeOperation.ListFiles, this.ParentPool.Id, this.ComputeNode.Id)));
this.Files = await asyncTask;
}
catch (Exception)
{
this.HasLoadedChildren = false; //On exception, we failed to load children so try again next time
//Swallow the exception to stop popups from occuring for every bad ComputeNode
}
this.FireChangesOnRefresh(ModelRefreshType.Children);
}
catch (Exception e)
{
this.HasLoadedChildren = false; //On exception, we failed to load children so try again next time
this.HandleException(e);
}
finally
{
Messenger.Default.Send(new UpdateWaitSpinnerMessage(WaitSpinnerPanel.LowerRight, false));
}
}
}
public ChangeTrackedAttribute(ModelRefreshType refreshType)
{
this.refreshType = refreshType;
}
