private static TResult PushFrame <TResult>([NotNull] IDispatcherService dispatcher, Func <Task <TResult> > task)
{
return(dispatcher.Invoke(() =>
{
var frame = new DispatcherFrame();
var frameTask = task().ContinueWith(x => { frame.Continue = false; return x.Result; });
ComponentDispatcher.PushModal();
Dispatcher.PushFrame(frame);
ComponentDispatcher.PopModal();
return frameTask.Result;
}));
}
/// <summary>
/// Writes a line to the output window.
/// </summary>
/// <param name="message">Message to write.</param>
/// <param name="eventType">Type of the event.</param>
private void WriteLine(string message, TraceEventType eventType)
{
_dispatcherService.Invoke(() =>
{
var traceEntry = new TraceEntry(TraceHelper.ConvertTraceEventTypeToTraceLevel(eventType), message);
_traceEntries.Add(traceEntry);
if (EntryMatchesLevel(traceEntry))
{
TraceEntryCollection.Add(traceEntry);
}
});
}
private async Task OnRemoveExecuteAsync()
{
var selectedPerson = SelectedPerson;
if (await _messageService.ShowAsync(string.Format("Are you sure you want to remove person '{0}'?", selectedPerson), "Are you sure?", MessageButton.YesNo, MessageImage.Question) == MessageResult.Yes)
{
Log.Info("Removing person '{0}'", selectedPerson);
_dispatcherService.Invoke(() =>
{
Persons.Remove(selectedPerson);
SelectedPerson = Persons.FirstOrDefault();
}, true);
}
}
internal static async Task DownloadAndInstallNewVersion(IDispatcherService dispatcher, IDialogService dialogService, string strideInstallerUrl)
{
try
{
// Diplay progress window
var mainWindow = dispatcher.Invoke(() => Application.Current.MainWindow as LauncherWindow);
dispatcher.InvokeAsync(() =>
{
selfUpdateWindow = new SelfUpdateWindow {
Owner = mainWindow
};
selfUpdateWindow.LockWindow();
selfUpdateWindow.ShowDialog();
}).Forget();
var strideInstaller = Path.Combine(Path.GetTempPath(), $"StrideSetup-{Guid.NewGuid()}.exe");
using (WebClient webClient = new WebClient())
{
webClient.DownloadFile(strideInstallerUrl, strideInstaller);
}
var startInfo = new ProcessStartInfo(strideInstaller)
{
UseShellExecute = true
};
// Release the mutex before starting the new process
Launcher.Mutex.Dispose();
Process.Start(startInfo);
Environment.Exit(0);
}
catch (Exception e)
{
await dispatcher.InvokeAsync(() =>
{
if (selfUpdateWindow != null)
{
selfUpdateWindow.ForceClose();
}
});
await dialogService.MessageBox(string.Format(Strings.NewVersionDownloadError, e.Message), MessageBoxButton.OK, MessageBoxImage.Error);
}
}
/// <summary>
/// fires the property changed event
/// </summary>
/// <param name="value"></param>
protected void RaisePropertyChanged <T>(Expression <Func <T> > propertyExpression)
{
PropertyChangedEventHandler handler = this.PropertyChanged;
if (handler != null)
{
MemberExpression memberExpression = propertyExpression.Body as MemberExpression;
if (memberExpression != null)
{
dispatcher.Invoke(() =>
handler(this, new PropertyChangedEventArgs(memberExpression.Member.Name))
);
}
else
{
throw new ArgumentException("RaisePropertyChanged event was not raised with a property: " + propertyExpression);
}
}
}
private void OnRemoveExecute()
{
var selectedPerson = SelectedPerson;
var task = _messageService.Show(string.Format("Are you sure you want to remove person '{0}'?", selectedPerson), "Are you sure?", MessageButton.YesNo, MessageImage.Question);
task.ContinueWith(result =>
{
if (result.Result == MessageResult.Yes)
{
Log.Info("Removing person '{0}'", selectedPerson);
_dispatcherService.Invoke(() =>
{
Persons.Remove(selectedPerson);
SelectedPerson = Persons.FirstOrDefault();
});
}
});
}
private void SubscribeLogListener()
{
if (!_isViewModelActive)
{
return;
}
var logListenerType = LogListenerType;
if (logListenerType is null)
{
return;
}
if (logListenerType == typeof(LogViewerLogListener))
{
var logViewerLogListener = _logViewerLogListener;
if (logViewerLogListener is not null)
{
_logListener = logViewerLogListener;
_dispatcherService.Invoke(() => AddLogEntries(logViewerLogListener.GetLogEntries().ToList(), true));
}
}
else
{
var logListener = _typeFactory.CreateInstance(logListenerType) as ILogListener;
if (logListener is not null)
{
LogManager.AddListener(logListener);
_logListener = logListener;
}
}
if (_logListener is null)
{
return;
}
_logListener.IgnoreCatelLogging = IgnoreCatelLogging;
_logListener.LogMessage += OnLogMessage;
}
protected override void OnChecked(RoutedEventArgs e)
{
base.OnChecked(e);
var dropDown = DropDown;
if (dropDown is null)
{
return;
}
_dispatcherService.Invoke(() =>
{
dropDown.SetCurrentValue(ContextMenu.PlacementTargetProperty, this);
dropDown.SetCurrentValue(ContextMenu.PlacementProperty, PlacementMode.Custom);
dropDown.SetCurrentValue(ContextMenu.MinWidthProperty, ActualWidth);
dropDown.SetCurrentValue(ContextMenu.CustomPopupPlacementCallbackProperty, (CustomPopupPlacementCallback)CustomPopupPlacementCallback);
});
dropDown.SetCurrentValue(ContextMenu.IsOpenProperty, true);
}
public void LoadFileNode(FileNode fileNode)
{
Log.Debug("Loading file node '{0}'", fileNode);
try
{
_dispatcherService.Invoke(() =>
{
var fileRecords = _logReaderService.LoadRecordsFromFileAsync(fileNode).Result;
var logRecords = fileNode.Records;
using (logRecords.SuspendChangeNotifications())
{
((ICollection <LogRecord>)logRecords).ReplaceRange(fileRecords);
}
}, true);
}
catch (Exception ex)
{
Log.Warning(ex, "Failed to load file node '{0}'", fileNode);
}
}
public async Task PrepareForPresentation(IDispatcherService dispatcher)
{
Task <BitmapImage> task;
lock (ComputingThumbnails)
{
if (!ComputingThumbnails.TryGetValue(thumbnailId, out task))
{
task = Task.Run(() => BuildBitmapImage(thumbnailId, thumbnailStream));
ComputingThumbnails.Add(thumbnailId, task);
}
}
var result = await task;
dispatcher.Invoke(() => Presenter = result);
thumbnailStream = null;
lock (ComputingThumbnails)
{
ComputingThumbnails.Remove(thumbnailId);
}
}
public async Task PrepareForPresentation(IDispatcherService dispatcher)
{
Task <ImageSource> task;
lock (ComputingThumbnails)
{
if (!ComputingThumbnails.TryGetValue(thumbnailId, out task))
{
task = Task.Run(() => BuildImageSource());
ComputingThumbnails.Add(thumbnailId, task);
}
}
var result = await task;
dispatcher.Invoke(() => Presenter = result);
FreeBuildingResources();
lock (ComputingThumbnails)
{
ComputingThumbnails.Remove(thumbnailId);
}
}
/// <summary>
/// Executes the specified action asynchronously with the specified arguments on the thread that the Dispatcher was created on if required.
/// <para />
/// To check whether this is necessary, it will check whether the current thread has access to the dispatcher.
/// </summary>
/// <param name="dispatcherService">The dispatcher service.</param>
/// <param name="action">The action.</param>
/// <exception cref="ArgumentNullException">The <paramref name="action" /> is <c>null</c>.</exception>
public static void InvokeIfRequired(this IDispatcherService dispatcherService, Action action)
{
dispatcherService.Invoke(action, true);
}
/// <summary>
/// The execute.
/// </summary>
private void Execute()
{
IsRunning = true;
lock (_syncObj)
{
IsCommitting = false;
}
try
{
bool aborted = false;
int progress = 0;
int total = _tasks.Count;
var processedTasks = new Stack <ITask>();
while (!aborted && _tasks.Count > 0)
{
ITask task = _tasks.Peek();
try
{
Log.Debug("Executing task '{0}'. ", task.Name);
if (_progressNotifyableViewModel != null)
{
_progressNotifyableViewModel.UpdateStatus(progress++, total, task);
}
else
{
// TODO: Display smooth detailed progress using the PleasWaitService
// ReSharper disable AccessToModifiedClosure
_dispatcherService.BeginInvoke(() => _pleaseWaitService.UpdateStatus(progress++, total, task.Name));
// ReSharper restore AccessToModifiedClosure
}
if (task.AutomaticallyDispatch)
{
_dispatcherService.Invoke(task.Execute);
}
else
{
task.Execute();
}
processedTasks.Push(_tasks.Dequeue());
}
catch (Exception ex)
{
Log.Error(ex);
if (!_exceptionService.HandleException(ex))
{
processedTasks.Push(_tasks.Dequeue());
aborted = true;
}
else
{
processedTasks.Push(_tasks.Dequeue());
}
}
}
if (aborted)
{
progress = processedTasks.Count;
while (processedTasks.Count > 0)
{
ITask task = processedTasks.Pop();
Log.Debug("Rolling back task '{0}'. ", task.Name);
try
{
task.Rollback();
}
catch (Exception e)
{
Log.Warning("Rollback of task '{0}' failed", task.Name);
Log.Error(e);
}
finally
{
if (_progressNotifyableViewModel != null)
{
_progressNotifyableViewModel.UpdateStatus(--progress, total, task);
}
else
{
_dispatcherService.BeginInvoke(() => _pleaseWaitService.UpdateStatus(--progress, total, string.Format("Rollback '{0}'", task.Name)));
}
}
}
}
}
finally
{
if (_pleaseWaitService != null)
{
_dispatcherService.Invoke(() => _pleaseWaitService.Hide());
}
IsRunning = false;
if (_progressNotifyableViewModel != null && CloseViewModelOnTerminated)
{
_dispatcherService.Invoke(() => _progressNotifyableViewModel.CloseViewModel(null));
}
if (_completedCallback != null)
{
_dispatcherService.Invoke(() => _completedCallback.Invoke());
}
}
}
private async Task AnalyzePlugins(IList <Plugin> pluginsToScan, CancellationToken cancellationToken)
{
foreach (var plugin in pluginsToScan)
{
if (!plugin.IsPresent)
{
continue;
}
if (!plugin.HasMetadata)
{
continue;
}
LogTo.Debug($"Begin analysis of {plugin.DllFilename}");
if (cancellationToken.IsCancellationRequested)
{
return;
}
_globalFrontendService.SelectedPlugin = plugin;
try
{
using (var remotePluginInstance = _remoteVstService.GetRemotePluginInstance(plugin))
{
_applicationService.UpdateApplicationOperationStatus(
pluginsToScan.IndexOf(plugin), $"Scanning {plugin.DllFilename}");
if (!plugin.HasMetadata)
{
if (plugin.LoadError)
{
LogTo.Debug($"Skipping {plugin.DllPath} because a load error occured");
}
else
{
throw new Exception(
$"Plugin {plugin.DllPath} has no metadata and was loaded correctly.");
}
}
if (plugin.PresetParser == null)
{
throw new Exception(
$"Plugin {plugin.DllPath} has no preset parser. Please report this as a bug.");
}
var wasLoaded = remotePluginInstance.IsLoaded;
plugin.PresetParser.PluginInstance = remotePluginInstance;
plugin.PresetParser.DataPersistence = _presetDataPersisterService;
await _presetDataPersisterService.OpenDatabase();
_presetDataPersisterService.PresetUpdated += ContextOnPresetUpdated;
_currentPluginIndex = pluginsToScan.IndexOf(plugin);
_currentPlugin = plugin;
plugin.PresetParser.RootBank = plugin.RootBank.First();
plugin.PresetParser.Logger.MirrorTo(plugin.Logger);
_totalPresets = plugin.PresetParser.GetNumPresets();
_currentPresetIndex = 0;
await plugin.PresetParser.DoScan();
await _presetDataPersisterService.CloseDatabase();
_dataPersisterService.SavePresetsForPlugin(plugin);
await _dispatcherService.InvokeAsync(() => { plugin.NativeInstrumentsResource.Load(plugin); });
if (GlobalService.RuntimeConfiguration.AutoCreateResources &&
_resourceGeneratorService.ShouldCreateScreenshot(remotePluginInstance))
{
plugin.Logger.Debug(
$"Auto-generating resources for {plugin.DllFilename} - Opening Editor");
_applicationService.UpdateApplicationOperationStatus(
pluginsToScan.IndexOf(plugin),
$"Auto-generating resources for {plugin.DllFilename} - Opening Editor");
if (!remotePluginInstance.IsLoaded)
{
await remotePluginInstance.LoadPlugin();
}
remotePluginInstance.OpenEditorHidden();
_dispatcherService.Invoke(() => Application.Current.MainWindow.BringWindowToTop());
await Task.Delay(1000);
}
await _dispatcherService.InvokeAsync(() =>
{
if (GlobalService.RuntimeConfiguration.AutoCreateResources &&
_resourceGeneratorService.NeedToGenerateResources(remotePluginInstance))
{
plugin.Logger.Debug(
$"Auto-generating resources for {plugin.DllFilename} - Creating screenshot and applying magic");
_applicationService.UpdateApplicationOperationStatus(
pluginsToScan.IndexOf(plugin),
$"Auto-generating resources for {plugin.DllFilename} - Creating screenshot and applying magic");
_resourceGeneratorService.AutoGenerateResources(remotePluginInstance);
}
});
wasLoaded = remotePluginInstance.IsLoaded;
_applicationService.UpdateApplicationOperationStatus(
pluginsToScan.IndexOf(plugin),
$"{plugin.DllFilename} - Updating Database");
_dataPersisterService.SavePlugin(plugin);
if (wasLoaded)
{
plugin.Logger.Debug($"Unloading {plugin.DllFilename}");
remotePluginInstance.UnloadPlugin();
}
}
}
catch (Exception e)
{
plugin.LogPluginError("loading presets", e);
var errorMessage =
$"Unable to analyze {plugin.DllFilename} because of {e.GetType().FullName}: {e.Message}";
_applicationService.AddApplicationOperationError(errorMessage + " - see plugin log for details");
}
if (plugin.PresetParser != null && plugin.PresetParser.Logger.HasLoggedEntries(LogLevel.Error))
{
var errors = plugin.PresetParser.Logger.GetFilteredLogEntries(new List <LogLevel> {
LogLevel.Error
});
foreach (var error in errors)
{
_applicationService.AddApplicationOperationError(error.Message);
}
}
// Remove the event handler here, so we can be absolutely sure we removed this.
_presetDataPersisterService.PresetUpdated -= ContextOnPresetUpdated;
LogTo.Debug($"End analysis of {plugin.DllFilename}");
}
}
private void RequestShowMainWindow()
{
dispatcher.EnsureAccess(false);
dispatcher.Invoke(ShowMainWindow);
}
/// <summary>
/// The execute.
/// </summary>
private void Execute()
{
IsRunning = true;
lock (_syncObj)
{
IsCommitting = false;
}
try
{
bool aborted = false;
int progress = 0;
int total = _tasks.Count;
var processedTasks = new Stack <ITask>();
while (!aborted && _tasks.Count > 0)
{
ITask task = _tasks.Peek();
try
{
Log.Debug("Executing task '{0}'. ", task.Name);
if (_progressNotifyableViewModel != null)
{
_progressNotifyableViewModel.UpdateStatus(progress++, total, task);
}
else
{
// TODO: Display smooth detailed progress using the PleasWaitService
// ReSharper disable AccessToModifiedClosure
_dispatcherService.Invoke(() => _pleaseWaitService.UpdateStatus(progress++, total, task.Name));
// ReSharper restore AccessToModifiedClosure
}
if (task.AutomaticallyDispatch)
{
_dispatcherService.Invoke(task.Execute);
}
else
{
task.Execute();
}
processedTasks.Push(_tasks.Dequeue());
}
catch (Exception e)
{
Log.Error(e);
var messageResult = MessageResult.None;
_dispatcherService.Invoke(() =>
{
messageResult = _messageService.Show(string.Format(TaskExecutionErrorMessagePattern, task.Name), "Error", MessageButton.YesNoCancel, MessageImage.Error);
});
switch (messageResult)
{
case MessageResult.Yes:
progress--;
break;
case MessageResult.No:
processedTasks.Push(_tasks.Dequeue());
break;
case MessageResult.Cancel:
processedTasks.Push(_tasks.Dequeue());
aborted = true;
break;
}
}
}
if (aborted)
{
progress = processedTasks.Count;
while (processedTasks.Count > 0)
{
ITask task = processedTasks.Pop();
Log.Debug("Rolling back task '{0}'. ", task.Name);
try
{
task.Rollback();
}
catch (Exception e)
{
Log.Warning("Rollback of task '{0}' failed", task.Name);
Log.Error(e);
}
finally
{
if (_progressNotifyableViewModel != null)
{
_progressNotifyableViewModel.UpdateStatus(--progress, total, task);
}
else
{
_dispatcherService.Invoke(() => _pleaseWaitService.UpdateStatus(--progress, total, string.Format("Rollback '{0}'", task.Name)));
}
}
}
}
}
finally
{
if (_pleaseWaitService != null)
{
_dispatcherService.Invoke(() => _pleaseWaitService.Hide());
}
IsRunning = false;
if (_progressNotifyableViewModel != null && CloseViewModelOnTerminated)
{
_dispatcherService.Invoke(() => _progressNotifyableViewModel.CloseViewModel(null));
}
if (_completedCallback != null)
{
_dispatcherService.Invoke(() => _completedCallback.Invoke());
}
}
}
private void AddValue(Key key, NotificationWithLastTime item)
{
_notificationDic.Add(key, item);
_dispatcherService.Invoke(() => _notificationList.Add(item.Notification));
}
private void OnSearchTimerElapsed(object sender, EventArgs e)
{
_textSelectTimer.Stop();
_dispatcherService.Invoke(() => AssociatedObject?.SelectAll());
}
/// <inheritdoc/>
protected override void UndoAction()
{
dispatcher.Invoke(() => innerActionItem.Undo());
}
static void ShutdownDispatcher(IDispatcherService dispatcher)
{
dispatcher.Invoke(() => Dispatcher.CurrentDispatcher.InvokeShutdown());
}
private static async Task UpdateLauncherFiles(IDispatcherService dispatcher, IDialogService dialogService, NugetStore store, CancellationToken cancellationToken)
{
var version = new PackageVersion(Version);
var productAttribute = (typeof(SelfUpdater).Assembly).GetCustomAttribute <AssemblyProductAttribute>();
var packageId = productAttribute.Product;
var packages = (await store.GetUpdates(new PackageName(packageId, version), true, true, cancellationToken)).OrderBy(x => x.Version);
try
{
// First, check if there is a package forcing us to download new installer
const string ReinstallUrlPattern = @"force-reinstall:\s*(\S+)\s*(\S+)";
var reinstallPackage = packages.LastOrDefault(x => x.Version > version && Regex.IsMatch(x.Description, ReinstallUrlPattern));
if (reinstallPackage != null)
{
var regexMatch = Regex.Match(reinstallPackage.Description, ReinstallUrlPattern);
var minimumVersion = PackageVersion.Parse(regexMatch.Groups[1].Value);
if (version < minimumVersion)
{
var installerDownloadUrl = regexMatch.Groups[2].Value;
await DownloadAndInstallNewVersion(dispatcher, dialogService, installerDownloadUrl);
return;
}
}
}
catch (Exception e)
{
await dialogService.MessageBox(string.Format(Strings.NewVersionDownloadError, e.Message), MessageBoxButton.OK, MessageBoxImage.Error);
}
// If there is a mandatory intermediate upgrade, take it, otherwise update straight to latest version
var package = (packages.FirstOrDefault(x => x.Version > version && x.Version.SpecialVersion == "req") ?? packages.LastOrDefault());
// Check to see if an update is needed
if (package != null && version < new PackageVersion(package.Version.Version, package.Version.SpecialVersion))
{
var windowCreated = new TaskCompletionSource <SelfUpdateWindow>();
var mainWindow = dispatcher.Invoke(() => Application.Current.MainWindow as LauncherWindow);
if (mainWindow == null)
{
throw new ApplicationException("Update requested without a Launcher Window. Cannot continue!");
}
dispatcher.InvokeAsync(() =>
{
selfUpdateWindow = new SelfUpdateWindow {
Owner = mainWindow
};
windowCreated.SetResult(selfUpdateWindow);
selfUpdateWindow.ShowDialog();
}).Forget();
var movedFiles = new List <string>();
// Download package
var installedPackage = await store.InstallPackage(package.Id, package.Version, null);
// Copy files from tools\ to the current directory
var inputFiles = installedPackage.GetFiles();
var window = windowCreated.Task.Result;
dispatcher.Invoke(window.LockWindow);
// TODO: We should get list of previous files from nuspec (store it as a resource and open it with NuGet API maybe?)
// TODO: For now, we deal only with the App.config file since we won't be able to fix it afterward.
var exeLocation = Launcher.GetExecutablePath();
var exeDirectory = Path.GetDirectoryName(exeLocation);
const string directoryRoot = "tools/"; // Important!: this is matching where files are store in the nuspec
try
{
if (File.Exists(exeLocation))
{
Move(exeLocation, exeLocation + ".old");
movedFiles.Add(exeLocation);
}
var configLocation = exeLocation + ".config";
if (File.Exists(configLocation))
{
Move(configLocation, configLocation + ".old");
movedFiles.Add(configLocation);
}
foreach (var file in inputFiles.Where(file => file.Path.StartsWith(directoryRoot) && !file.Path.EndsWith("/")))
{
var fileName = Path.Combine(exeDirectory, file.Path.Substring(directoryRoot.Length));
// Move previous files to .old
if (File.Exists(fileName))
{
Move(fileName, fileName + ".old");
movedFiles.Add(fileName);
}
// Update the file
UpdateFile(fileName, file);
}
}
catch (Exception)
{
// Revert all olds files if a file didn't work well
foreach (var oldFile in movedFiles)
{
Move(oldFile + ".old", oldFile);
}
throw;
}
// Remove .old files
foreach (var oldFile in movedFiles)
{
try
{
var renamedPath = oldFile + ".old";
if (File.Exists(renamedPath))
{
File.Delete(renamedPath);
}
}
catch (Exception)
{
// All the files have been replaced, we let it go even if we cannot remove all the old files.
}
}
// Clean cache from files obtain via package.GetFiles above.
store.PurgeCache();
dispatcher.Invoke(RestartApplication);
}
}
/// <summary>
/// Executes the specified delegate asynchronously with the specified arguments on the thread that the Dispatcher was created on if required.
/// <para />
/// To check whether this is necessary, it will check whether the current thread has access to the dispatcher.
/// </summary>
/// <param name="dispatcherService">The dispatcher service.</param>
/// <param name="method">A delegate to a method that takes parameters specified in args, which is pushed onto the Dispatcher event queue.</param>
/// <param name="args">An array of objects to pass as arguments to the given method. Can be <c>null</c>.</param>
/// <exception cref="ArgumentNullException">The <paramref name="method" /> is <c>null</c>.</exception>
public static void InvokeIfRequired(this IDispatcherService dispatcherService, Delegate method, params object[] args)
{
Argument.IsNotNull("method", method);
dispatcherService.Invoke(() => method.DynamicInvoke(args), true);
}
public void Run(IService service)
{
_dispatcherService.Invoke(Raise);
}
/// <summary>
/// The execute.
/// </summary>
private void Execute()
{
IsRunning = true;
lock (_syncObj)
{
IsCommitting = false;
}
IPleaseWaitService pleaseWaitService = null;
if (_viewModelType == null)
{
pleaseWaitService = GetService <IPleaseWaitService>();
}
try
{
bool aborted = false, retry = false;
int progress = 0;
int total = _tasks.Count;
var processedTasks = new Stack <ITask>();
while (!aborted && _tasks.Count > 0)
{
if (!retry)
{
processedTasks.Push(_tasks.Dequeue());
}
retry = false;
ITask task = processedTasks.Peek();
try
{
Log.Debug("Executing task '{0}'. ", task.Name);
if (pleaseWaitService != null)
{
pleaseWaitService.UpdateStatus(++progress, total, task.Name);
}
else if (_progressNotifyableViewModel != null)
{
_progressNotifyableViewModel.UpdateStatus(progress++, total, task);
}
_dispatcherService.Invoke(task.Execute);
}
catch (Exception e)
{
Log.Error(e);
var messageResult = _messageService.Show(string.Format(TaskExecutionErrorMessagePattern, task.Name), "Error", MessageButton.YesNoCancel, MessageImage.Error);
switch (messageResult)
{
case MessageResult.Yes:
retry = true;
break;
case MessageResult.Cancel:
aborted = true;
break;
}
}
}
if (aborted)
{
while (processedTasks.Count > 0)
{
ITask task = processedTasks.Pop();
Log.Debug("Rolling back task '{0}'. ", task.Name);
try
{
if (pleaseWaitService != null)
{
pleaseWaitService.UpdateStatus(progress--, total, string.Format("Rollback '{0}'", task.Name));
}
else if (_progressNotifyableViewModel != null)
{
_progressNotifyableViewModel.UpdateStatus(progress--, total, task);
}
task.Rollback();
}
catch (Exception e)
{
Log.Warning("Rollback of task '{0}' failed", task.Name);
Log.Error(e);
}
}
}
}
finally
{
if (pleaseWaitService != null)
{
pleaseWaitService.Hide();
}
IsRunning = false;
_dispatcherService.Invoke(() =>
{
if (_progressNotifyableViewModel != null)
{
_progressNotifyableViewModel.CloseViewModel(null);
}
});
if (_completedCallback != null)
{
_dispatcherService.Invoke(() => _completedCallback.Invoke());
}
}
}
private async Task <string> OnCommandReceivedAsync(RemoteParameter parameter)
{
switch (parameter.Command)
{
case RemoteCommands.MiriotConfiguring:
_dispatcherService.Invoke(() =>
{
_vm.HasNoConfiguration = false;
_vm.IsConfiguring = true;
});
return(string.Empty);
case RemoteCommands.LoadUser:
_dispatcherService.Invoke(async() =>
{
await _vm.LoadUser(_vm.User);
});
return(string.Empty);
case RemoteCommands.GetUser:
_dispatcherService.Invoke(() =>
{
_vm.HasNoConfiguration = false;
_vm.IsConfiguring = true;
});
return(_vm.User.Id.ToString());
case RemoteCommands.GraphService_Initialize:
Messenger.Default.Send(new GraphServiceMessage(false));
return(null);
case RemoteCommands.GraphService_GetUser:
Messenger.Default.Send(new GraphServiceMessage(true));
var _graphService = SimpleIoc.Default.GetInstance <IGraphService>();
await _graphService.LoginAsync();
var graphUser = await _graphService.GetUserAsync();
return(JsonConvert.SerializeObject(graphUser));
case RemoteCommands.GoToCameraPage:
SimpleIoc.Default.GetInstance <INavigationService>().NavigateTo(PageKeys.CameraSettings);
return(null);
case RemoteCommands.MiriotConnect:
//_socketService.ListenTcp();
return(null);
case RemoteCommands.MiriotDiscovery:
default:
// Reply back
var id = _platformService.GetSystemIdentifier();
var sys = new RomeRemoteSystem(null)
{
Id = id,
DisplayName = Environment.MachineName
};
return(JsonConvert.SerializeObject(sys));
}
}
protected override void OnInfo(object sender, NuGetLogRecordEventArgs e)
{
_dispatcherService.Invoke(() => _echo.Lines.Add(string.Format("Info: {0}", e.Message)), true);
}
public FolderNode LoadFileSystemContent(string path, bool isNavigationRoot = false)
{
Argument.IsNotNullOrEmpty(() => path);
Log.Debug("Loading file system content '{0}'", path);
var directoryInfo = new DirectoryInfo(path);
FolderNode folder = null;
_dispatcherService.Invoke(() => { folder = new FolderNode(directoryInfo); }, true);
var logFiles = Directory.GetFiles(path, _wildcardsFilter, SearchOption.TopDirectoryOnly).Where(x => x.IsSupportedFile(_regexFilter)).OrderBy(x => new FileInfo(x).Name).ToList();
var fileNodes = new List <FileNode>();
#if LOADFILES_PARALLEL
var fileTasks = new List <Action>();
foreach (var logFile in logFiles)
{
var file = logFile;
fileTasks.Add(() =>
{
var fileNode = LoadFileFromFileSystem(Path.Combine(path, file));
lock (fileTasks)
{
fileNodes.AddDescendingly(fileNode, CompareFileNodes);
}
});
}
// Parse all files parallel
TaskHelper.RunAndWait(fileTasks.ToArray());
#else
foreach (var logFile in logFiles)
{
var fileNode = LoadFileFromFileSystem(Path.Combine(path, logFile));
fileNodes.Add(fileNode);
}
#endif
_dispatcherService.Invoke(() => folder.Files = new ObservableCollection <FileNode>(fileNodes.OrderByDescending(x => x.FileInfo.CreationTime)), true);
var logDirectories = Directory.GetDirectories(path).Select(x => Path.Combine(path, x));
#if LOADDIRECTORIES_PARALLEL
var directoryTasks = new List <Action>();
foreach (var directory in logDirectories)
{
var dir = directory;
directoryTasks.Add(() =>
{
var folderNode = LoadFileSystemContent(Path.Combine(path, dir));
_dispatcherService.Invoke(() => folder.Directories.Add(folderNode));
});
}
// Parse all directories parallel
TaskHelper.RunAndWait(directoryTasks.ToArray());
#else
foreach (var directory in logDirectories)
{
var fileSystemContent = LoadFileSystemContent(directory);
_dispatcherService.Invoke(() => folder.Directories.Add(fileSystemContent), true);
}
#endif
if (isNavigationRoot)
{
_fileSystemWatchingService.BeginDirectoryWatching(folder.FullName, _wildcardsFilter);
}
else
{
folder.UpdateVisibility();
}
_navigationNodeCacheService.AddToCache(folder);
return(folder);
}
static void ShutdownDispatcher(IDispatcherService dispatcher)
{
dispatcher.Invoke(() => Dispatcher.CurrentDispatcher.InvokeShutdown());
}
public void HandleError([NotNull] Exception exception)
{
if (exception == null)
{
throw new ArgumentNullException("exception");
}
GameLog.Server.General.Error(BuildErrorMessage(exception));
string header;
string message;
var gameDataException = exception as GameDataException;
if (gameDataException != null)
{
header = _resourceManager.GetString("GAME_DATA_ERROR_HEADER");
message = _resourceManager.GetStringFormat(
"GAME_DATA_ERROR_MESSAGE_FORMAT",
gameDataException.Message,
gameDataException.FileName);
}
else
{
header = _resourceManager.GetString("GENERIC_ERROR_HEADER");
message = _resourceManager.GetStringFormat(
"GENERIC_ERROR_MESSAGE_FORMAT",
exception.Message);
}
_dispatcherService.Invoke(
(Action)
(() =>
{
var formattedTextConverter = new FormattedTextConverter();
var messageText = new TextBlock {
TextWrapping = TextWrapping.Wrap
};
BindingHelpers.SetInlines(
messageText,
(Inline[])formattedTextConverter.Convert(message));
MessageDialog.Show(
header,
messageText,
MessageDialogButtons.Ok);
var supremacyException = exception as SupremacyException;
if (supremacyException == null)
{
ClientCommands.Exit.Execute(false);
return;
}
switch (supremacyException.Action)
{
case SupremacyExceptionAction.Continue:
break;
case SupremacyExceptionAction.Exit:
ClientCommands.Exit.Execute(false);
break;
default:
case SupremacyExceptionAction.Undefined:
case SupremacyExceptionAction.Disconnect:
ClientCommands.EndGame.Execute(false);
break;
}
}));
}
