private async Task EvaluateAsync() { try { await TaskUtilities.SwitchToBackgroundThread(); var debugSession = await VsAppShell.Current.ExportProvider.GetExportedValue <IDebugSessionProvider>().GetDebugSessionAsync(_rSession); const DebugEvaluationResultFields fields = DebugEvaluationResultFields.Classes | DebugEvaluationResultFields.Expression | DebugEvaluationResultFields.TypeName | (DebugEvaluationResultFields.Repr | DebugEvaluationResultFields.ReprStr) | DebugEvaluationResultFields.Dim | DebugEvaluationResultFields.Length; var result = await debugSession.EvaluateAsync(_evaluation.Expression, fields); var wrapper = new EvaluationWrapper(result); VsAppShell.Current.DispatchOnUIThread(() => SetEvaluation(wrapper)); } catch (Exception ex) { VsAppShell.Current.DispatchOnUIThread(() => SetError(ex.Message)); } }
/// <inheritdoc /> public byte[] ReadAllBytes(string fileName, string[] path) { #region validation if (string.IsNullOrEmpty(fileName)) { throw new ArgumentNullException(nameof(fileName)); } #endregion CloudFileDirectory cloudFileDirectory = CloudFileShare.GetDirectoryReference(path: path); CloudFile cloudFile = cloudFileDirectory.GetFileReference(fileName); TaskUtilities.ExecuteSync(cloudFile.FetchAttributesAsync()); var cloudFileBytes = new byte[cloudFile.Properties.Length]; TaskUtilities.ExecuteSync(cloudFile.DownloadToByteArrayAsync(cloudFileBytes, 0)); return(cloudFileBytes); }
/// <inheritdoc /> protected override async Task CompleteAsync(CancellationToken cancellation) { if (this.inParallel) { cancellation.ThrowIfCancellationRequested(); var completions = new List <Task>(); foreach (var cancelable in this.cancelables) { cancelable.Complete(); completions.Add(cancelable.Completion); } await TaskUtilities.WhenAll(cancellation, completions).DontMarshallContext(); } else { foreach (var cancelable in this.cancelables) { cancellation.ThrowIfCancellationRequested(); await cancelable.CompleteAndAwaitAsync().DontMarshallContext(); } } }
private async Task StartHostAsyncBackground(RHostStartupInfo startupInfo, IRSessionCallback callback, IBinaryAsyncLockToken lockToken, int timeout, CancellationToken cancellationToken) { await TaskUtilities.SwitchToBackgroundThread(); _callback = callback; _startupInfo = startupInfo; RHost host; try { var connectionInfo = new BrokerConnectionInfo(startupInfo.Name, this, startupInfo.RHostCommandLineArguments, timeout); host = await BrokerClient.ConnectAsync(connectionInfo, cancellationToken); } catch (OperationCanceledException ex) { _initializationTcs.TrySetCanceled(ex); lockToken.Reset(); throw; } catch (Exception ex) { _initializationTcs.TrySetException(ex); lockToken.Reset(); throw; } await StartHostAsyncBackground(host, lockToken, cancellationToken); }
/// <summary> /// Collects filtered content of all directories and dedupes the list before returning it. /// </summary> private async Task <Possible <List <SealedDirectoryFile> > > GetUniqueFilteredDirectoryContentAsync( string[] directoryPaths, string[] directoryIds, Regex[] contentFilters, FilterKind[] filterKinds = null) { // TODO: add counter to measure the time spent getting dir content var getContentTasks = Enumerable .Range(0, directoryPaths.Length) .Select(i => GetDirectoryContentAndApplyFilterAsync(directoryPaths[i], directoryIds[i], contentFilters[i], filterKinds?[i] ?? FilterKind.Include)).ToArray(); var getContentResults = await TaskUtilities.SafeWhenAll(getContentTasks); if (getContentResults.Any(r => !r.Succeeded)) { return(new Failure <string>(string.Join("; ", getContentResults.Where(r => !r.Succeeded).Select(r => r.Failure.Describe())))); } // dedupe collected files using file artifact as a key var dedupedFiles = getContentResults.SelectMany(res => res.Result).GroupBy(file => file.Artifact).Select(group => group.First()); return(dedupedFiles.ToList()); }
private Task <IAsyncReaderWriterLockToken> ExclusiveReaderLockAsync(ExclusiveReaderLock erLock, CancellationToken cancellationToken = default(CancellationToken)) { TaskUtilities.AssertIsOnBackgroundThread(); if (cancellationToken.IsCancellationRequested) { return(Task.FromCanceled <IAsyncReaderWriterLockToken>(cancellationToken)); } var source = new ExclusiveReaderLockSource(this, erLock); _queue.AddExclusiveReader(source, out var isAddedAfterWriterOrExclusiveReader); if (isAddedAfterWriterOrExclusiveReader) { source.RegisterCancellation(cancellationToken); } else { source.Release(); } return(source.Task); }
public async Task WhenAllCancelOnFailure_NoCancellation() { var index = 0; Func <CancellationToken, Task> function1 = async ct => { await Task.Delay(100, ct); Interlocked.Exchange(ref index, 1); throw new InvalidOperationException("1"); }; Func <CancellationToken, Task> function2 = async ct => { await Task.Delay(50, ct); Interlocked.Exchange(ref index, 2); throw new InvalidOperationException("2"); }; Func <Task> f = () => TaskUtilities.WhenAllCancelOnFailure(new [] { function1, function2 }, CancellationToken.None); (await f.ShouldThrowAsync <InvalidOperationException>()).WithMessage("2"); index.Should().Be(2); }
private static async Task <bool> WaitForProcessExitAsync(Process process, CancellationToken cancellationToken) { // Helps to get notified either when the server is ready or in case server failed to initialize properly using (var safeWaitHandle = new SafeWaitHandle(process.Handle, false)) { using (var processWaitHandle = new AutoResetEvent(false) { SafeWaitHandle = safeWaitHandle }) { var completedIndex = await TaskUtilities.ToTask(new WaitHandle[] { processWaitHandle, cancellationToken.WaitHandle }); if (completedIndex == 0) { await Task.Run(() => process.WaitForExit(), cancellationToken); return(process.ExitCode == 0); } return(false); } } }
private async Task <string> ReadNextRequest(string prompt, int len, CancellationToken ct) { TaskUtilities.AssertIsOnBackgroundThread(); var requestSource = await _pendingRequestSources.ReceiveAsync(ct); TaskCompletionSource <string> requestTcs = new TaskCompletionSource <string>(); Interlocked.Exchange(ref _currentRequestSource, requestSource); requestSource.Request(_contexts, prompt, len, requestTcs); using (ct.Register(() => requestTcs.TrySetCanceled())) { var response = await requestTcs.Task; Debug.Assert(response.Length < len); // len includes null terminator if (response.Length >= len) { response = response.Substring(0, len - 1); } return(response); } }
private async Task StartHostAsyncBackground(RHostStartupInfo startupInfo, IRSessionCallback callback, IUIService ui, int timeout, CancellationToken cancellationToken) { TaskUtilities.AssertIsOnBackgroundThread(); _callback = callback; _startupInfo = startupInfo ?? new RHostStartupInfo(); RHost host; try { // ui?.LogMessage($"Making connection info {Name}"); var connectionInfo = new HostConnectionInfo(Name, this, _startupInfo.UseRHostCommandLineArguments, _startupInfo.IsInteractive, timeout); // ui?.LogMessage($"Connecting to broker {Name}"); host = await BrokerClient.ConnectAsync(connectionInfo, cancellationToken); } catch (OperationCanceledException ex) { _hostStartedTcs.TrySetCanceled(ex); throw; } catch (Exception ex) { _hostStartedTcs.TrySetException(ex); throw; } await StartHostAsyncBackground(host, cancellationToken); }
private async Task <bool> EvaluateAll(IReadOnlyList <IRContext> contexts, bool mutated, CancellationToken ct) { TaskUtilities.AssertIsOnBackgroundThread(); try { RSessionEvaluationSource source; while (!ct.IsCancellationRequested && _pendingEvaluationSources.TryReceive(out source)) { mutated |= source.IsMutating; await source.BeginEvaluationAsync(contexts, _host, ct); } } catch (OperationCanceledException) { // Host is being shut down, so there's no point in raising the event anymore. mutated = false; } finally { if (mutated) { OnMutated(); } } return(mutated); }
public virtual async Task ShutdownAsync() { await TaskUtilities.SafeWhenAll( Sessions.Select(async(session, index) => { if (!session.ShutdownCompleted) { await session.ShutdownAsync(StoreContexts[index]).ThrowIfFailure(); } })); foreach (var session in Sessions) { session.Dispose(); } if (_traceStoreStatistics) { await LogStatsAsync(); } await ShutdownStoresAsync(); }
public async Task WithTimeoutShouldTriggerGivenCancellationTokenAndFailWithTimeoutException() { bool cancellationRequested = false; var task = TaskUtilities.WithTimeoutAsync( async token => { try { await Task.Delay(/* milliseconds */ 200000, token); } catch (TaskCanceledException) { } cancellationRequested = token.IsCancellationRequested; return(42); }, TimeSpan.FromMilliseconds(10), default); // Timeout should happen here, and the callback should see that a given cancellation token is triggered await Assert.ThrowsAsync <TimeoutException>(async() => await task); XAssert.IsTrue(cancellationRequested); }
private static async Task CreateCsvAndStartProcess(IREvaluationResultInfo result, IRSession session, string fileName, IFileSystem fileSystem, IProgress <ProgressDialogData> progress) { await TaskUtilities.SwitchToBackgroundThread(); var sep = CultureInfo.CurrentCulture.TextInfo.ListSeparator; var dec = CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator; using (var e = await session.BeginEvaluationAsync()) { var csvDataBlobId = await e.EvaluateAsync <ulong>($"rtvs:::export_to_csv({result.Expression}, sep={sep.ToRStringLiteral()}, dec={dec.ToRStringLiteral()})", REvaluationKind.Normal); using (DataTransferSession dts = new DataTransferSession(session, fileSystem)) { var total = await session.GetBlobSizeAsync(csvDataBlobId, CancellationToken.None); progress.Report(new ProgressDialogData(0, statusBarText: Resources.Status_WritingCSV, waitMessage: Resources.Status_WritingCSV)); await dts.FetchFileAsync(new RBlobInfo(csvDataBlobId), fileName, true, new Progress <long>(b => { var step = (int)(b * 100 / total); progress.Report(new ProgressDialogData(step, statusBarText: Resources.Status_WritingCSV, waitMessage: Resources.Status_WritingCSV)); })); progress.Report(new ProgressDialogData(100, statusBarText: Resources.Status_WritingCSV, waitMessage: Resources.Status_WritingCSV)); } } }
/// <summary> /// Asynchronously fetches RD data on the function from R. /// </summary> public async Task<string> GetFunctionRdDataAsync(string functionName, string packageName) { if(packageName.EqualsOrdinal("rtvs")) { return GetRtvsFunctionRdData(functionName); } await TaskUtilities.SwitchToBackgroundThread(); await _host.StartSessionAsync(); string command = GetCommandText(functionName, packageName); try { return await _host.Session.EvaluateAsync<string>(command, REvaluationKind.Normal); } catch (RException) { } // Sometimes there is no information in a specific package. // For example, Matrix exports 'as.matrix' and base does it as well. // However, help('as.matrix', 'Matrix') will fail while help('as.matrix' will succeed. command = GetCommandText(functionName, null); try { return await _host.Session.EvaluateAsync<string>(command, REvaluationKind.Normal); } catch (RException) { } return string.Empty; }
public void AwaitFailure() { int i = 0; string exceptionText = "Boom"; try { var result = TaskUtilities.AwaitWithProgressReportingAsync( task: Task.Run(() => TestMethod(exceptionText)), period: TimeSpan.FromHours(24), action: (time) => Interlocked.Increment(ref i), reportImmediately: false, reportAtEnd: false).GetAwaiter().GetResult(); } catch (Exception e) { XAssert.AreEqual(exceptionText, e.GetLogEventMessage()); XAssert.AreEqual(0, i); return; } XAssert.Fail("Should have thrown an exception"); }
public static async Task <IGridData <string> > GetGridDataAsync(string expression, GridRange?gridRange, ISortOrder sortOrder = null) { await TaskUtilities.SwitchToBackgroundThread(); var rSession = VsAppShell.Current.ExportProvider.GetExportedValue <IRSessionProvider>().GetInteractiveWindowRSession(); string rows = gridRange?.Rows.ToRString(); string columns = gridRange?.Columns.ToRString(); using (var evaluator = await rSession.BeginEvaluationAsync()) { try { string exp; if (sortOrder != null && !sortOrder.IsEmpty) { if (gridRange.Value.Columns.Count > 1) { string dataFrameSortExpression = sortOrder.GetDataFrameSortFunction(); exp = Invariant($"rtvs:::grid_data({expression}, {rows}, {columns}, {dataFrameSortExpression.ToRStringLiteral()})"); } else { int sortType = sortOrder.IsPrimaryDescending ? 2 : 1; exp = Invariant($"rtvs:::grid_data({expression}, {rows}, {columns}, NULL, {sortType})"); } } else { exp = Invariant($"rtvs:::grid_data({expression}, {rows}, {columns})"); } return(await evaluator.EvaluateAsync <GridData>(exp, REvaluationKind.Normal)); } catch (RException ex) { var message = Invariant($"Grid data evaluation failed:{Environment.NewLine}{ex.Message}"); GeneralLog.Write(message); return(null); } } }
private static void InitializeUtilities(CommandLineParameters parms) { ReconciliationLib.Utilities.Init(); // wire events ReconciliationLib.Utilities.OnError += new EventHandler <ErrorEventArgs>(Utilities_OnError); ReconciliationLib.Utilities.OnInfo += new EventHandler <InfoEventArgs>(Utilities_OnInfo); TaskUtilities.OnError += new EventHandler <ErrorEventArgs>(Utilities_OnError); TaskUtilities.OnInfo += new EventHandler <InfoEventArgs>(Utilities_OnInfo); // get Hugo connection Gargoyle.Utils.DBAccess.DBAccess dbAccess = Gargoyle.Utils.DBAccess.DBAccess.GetDBAccessOfTheCurrentUser(applicationName); ReconciliationLib.Utilities.Connection = dbAccess.GetConnection(databaseName); s_taskUtilities = new TaskUtilities(ReconciliationLib.Utilities.Connection); if (s_logger != null) { s_logger.Info("Connecting to " + ReconciliationLib.Utilities.Connection.ConnectionString); } // set account group if (!String.IsNullOrEmpty(parms.AccountGroupName)) { ReconciliationLib.Utilities.AccountGroupName = parms.AccountGroupName; // if we have not specified a clearing house, use the one associated with the account group if (parms.ClearingHouse == ClearingHouse.None) { parms.ClearingHouse = ReconciliationLib.Utilities.ClearingHouse; } } // set dates ReconciliationLib.Utilities.ImportDate = parms.GetImportDateOverride() ?? DateTime.Today; ReconciliationLib.Utilities.PreviousDate = ReconciliationLib.Utilities.CalculatePreviousBusinessDay(ReconciliationLib.Utilities.ImportDate.Value); }
public TaskResult Execute(TaskInstance taskInstance) { var taskResult = new TaskResult(); Guid runId = Guid.Empty; try { StartActiveNotifier(taskInstance.Id); TaskUtilities.UpdateTaskInstanceStatus(taskInstance.Id, _repositoryFactory, TaskInstanceStatues.InProgress, null); // Read parameters runId = new Guid(taskInstance.Parameters["RunId"].ToString()); var runInstances = _runManager.AllScenariosStartRun(runId); TaskUtilities.UpdateTaskInstanceStatus(taskInstance.Id, _repositoryFactory, TaskInstanceStatues.CompletedSuccess, DateTime.UtcNow); taskResult.Status = TaskInstanceStatues.CompletedSuccess; } catch (Exception exception) { _auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForInformationMessage(0, 0, $"{exception.StackTrace}"));///testing _auditEventRepository.Insert( AuditEventFactory.CreateAuditEventForException(0, 0, $"Error executing task for start run (TaskInstanceID={taskInstance.Id.ToString()}, RunID={runId.ToString()})", exception) ); TaskUtilities.UpdateTaskInstanceStatus(taskInstance.Id, _repositoryFactory, TaskInstanceStatues.CompletedError, DateTime.UtcNow); taskResult.Status = TaskInstanceStatues.CompletedError; taskResult.Exception = exception; } finally { StopActiveNotifier(); } return(taskResult); }
private async Task ShowDialog(Message request, MessageButtons buttons, CancellationToken ct) { TaskUtilities.AssertIsOnBackgroundThread(); request.ExpectArguments(2); var contexts = GetContexts(request); var s = request.GetString(1, "s", allowNull: true); MessageButtons input = await _callbacks.ShowDialog(contexts, s, buttons, ct); ct.ThrowIfCancellationRequested(); string response; switch (input) { case MessageButtons.No: response = "N"; break; case MessageButtons.Cancel: response = "C"; break; case MessageButtons.Yes: response = "Y"; break; default: { FormattableString error = $"YesNoCancel: callback returned an invalid value: {input}"; Trace.Fail(Invariant(error)); throw new InvalidOperationException(Invariant(error)); } } await RespondAsync(request, ct, response); }
protected override Task <DependencyResult <TDependencyInstance> > ResolveNewDependencyInstanceAsync(IDependencyResolutionContext context) { try { var specs = context .EnsureNotNull(nameof(context)) .Value .Specs; // var factoryArgs = ReadDA(ref _factoryArgs); if (factoryArgs == null) { if ((factoryArgs = specs.NewInstanceFactoryArgs as IArgsTuple <TArg1, TArg2, TArg3, TArg4>) == null || factoryArgs.ArgsCount != __ArgsCount) { return(TaskUtilities.FromResult(DependencyResult <TDependencyInstance> .None)); } } else if (specs.NewInstanceFactoryArgs != null) { return(TaskUtilities.FromResult(DependencyResult <TDependencyInstance> .None)); } // return (TaskUtilities .FromResult( result: new DependencyResult <TDependencyInstance>( instance: ReadDA(ref _getDependencyCtor) () (factoryArgs.Arg1, factoryArgs.Arg2, factoryArgs.Arg3, factoryArgs.Arg4), isNewInstance: true))); } catch (Exception firstException) { return(Task.FromException <DependencyResult <TDependencyInstance> >(firstException)); } }
private static async Task CreateCsvAndStartProcess( IREvaluationResultInfo result, IRSession session, ICoreShell coreShell, string fileName, IFileSystem fileSystem, IProgress <ProgressDialogData> progress, CancellationToken cancellationToken) { await TaskUtilities.SwitchToBackgroundThread(); var sep = CultureInfo.CurrentCulture.TextInfo.ListSeparator; var dec = CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator; try { var csvDataBlobId = await session.EvaluateAsync <ulong>($"rtvs:::export_to_csv({result.Expression}, sep={sep.ToRStringLiteral()}, dec={dec.ToRStringLiteral()})", REvaluationKind.Normal, cancellationToken); using (DataTransferSession dts = new DataTransferSession(session, fileSystem)) { await dts.FetchAndDecompressFileAsync(csvDataBlobId, fileName, progress, Resources.Status_WritingCSV, cancellationToken); } } catch (RException) { await coreShell.ShowErrorMessageAsync(Resources.Error_CannotExportToCsv, cancellationToken); } }
public void Initialize() { _fileContainer = new AzureFileContainer(CONNECTION_STRING, SHARE_NAME); _cloudStorageAccount = CloudStorageAccount.Parse(CONNECTION_STRING); _cloudFileShare = _cloudStorageAccount.GetShareReference(SHARE_NAME); _cloudFileRootDirectory = _cloudFileShare.GetRootDirectoryReference(); _cloudFileSourceDirectory = _cloudFileShare.GetDirectoryReference(path: new[] { SOURCE_DIRECTORY }, createIfNotExists: true); _cloudFileShare.GetDirectoryReference(path: new[] { SOURCE_DIRECTORY, DUMMY_DIRECTORY }, createIfNotExists: true); _cloudFileShare.GetDirectoryReference(path: new[] { TARGET_DIRECTORY }, createIfNotExists: true); _cloudRootFile = _cloudFileRootDirectory.GetFileReference(FILE_NAME); _cloudSourceFile = _cloudFileSourceDirectory.GetFileReference(FILE_NAME); TaskUtilities.ExecuteSync(_cloudRootFile.UploadTextAsync(FILE_CONTENT)); TaskUtilities.ExecuteSync(_cloudSourceFile.UploadTextAsync(FILE_CONTENT)); }
protected override Task <DependencyResult <TDependencyInstance> > ResolveNewDependencyInstanceAsync(IDependencyResolutionContext context) { try { var specs = context.EnsureNotNull(nameof(context)).Value.Specs; // if ((specs.NewInstanceFactoryArgs?.ArgsCount ?? 0) != __ArgsCount) { return(TaskUtilities.FromResult(DependencyResult <TDependencyInstance> .None)); } else { return (TaskUtilities .FromResult( result: new DependencyResult <TDependencyInstance>( instance: ReadDA(ref _getDependencyCtor, considerDisposeRequest: true)()(), isNewInstance: true))); } } catch (Exception exception) { return(Task.FromException <DependencyResult <TDependencyInstance> >(exception)); } }
public async Task <bool> ExecuteBrowserCommandAsync(string command, Func <IRSessionInteraction, Task <bool> > prepare = null, CancellationToken cancellationToken = default(CancellationToken)) { ThrowIfDisposed(); await TaskUtilities.SwitchToBackgroundThread(); using (var inter = await RSession.BeginInteractionAsync(isVisible: true, cancellationToken: cancellationToken)) { if (prepare != null) { if (!await prepare(inter)) { return(false); } } if (inter.Contexts.IsBrowser()) { await inter.RespondAsync(command + "\n"); return(true); } } return(false); }
private Task RunManyForStoreAcrossServerRestartAsync(Func <Context, IContentStore, Task> requestFunc) { return(RunStoreTestAsync(async(context, store) => { // Launch a bunch of duplicate requests in the background, with server restart mixed in. var tasks = new List <Task>(101); tasks.AddRange(Enumerable.Range(0, 50).Select(i => Task.Run(() => requestFunc(new Context(Logger), store)))); tasks.Add(((ITestServiceClientContentStore)store).RestartServerAsync(context)); tasks.AddRange(Enumerable.Range(0, 50).Select(i => Task.Run(() => requestFunc(new Context(Logger), store)))); try { await TaskUtilities.SafeWhenAll(tasks); } catch (AggregateException ex) { AggregateException singleException = ex.Flatten(); string failureMessage = string.Join(",", singleException.InnerExceptions.Select(x => x.Message)); Assert.True(false, failureMessage); } })); }
private Task ValidateState(CancellationToken cancellationToken) { switch (_state) { case FrameStreamState.Open: if (cancellationToken.IsCancellationRequested) { return(TaskUtilities.GetCancelledTask(cancellationToken)); } break; case FrameStreamState.Closed: throw new ObjectDisposedException(nameof(FrameResponseStream)); case FrameStreamState.Aborted: if (cancellationToken.IsCancellationRequested) { // Aborted state only throws on write if cancellationToken requests it return(TaskUtilities.GetCancelledTask(cancellationToken)); } break; } return(null); }
/// <summary> /// Evaluates all named values that are declared locally and collects the evaluation tasks. /// </summary> private async Task <bool> EvaluateAllNamedValuesAsync(ImmutableContextBase context) { Contract.Requires(context != null); var evaluateTasks = new List <Task <object> >(); EvaluateAllNamedValues(context, evaluateTasks); object[] results = await TaskUtilities.WithCancellationHandlingAsync( context.LoggingContext, Task.WhenAll(evaluateTasks), (loggingContext) => { // Many modules are potentially being evaluated at the same time. Only log the cancelation event once. if (Interlocked.Increment(ref context.Logger.EvaluationCancelledFirstLogged) == 1) { context.Logger.EvaluationCanceled(loggingContext); } }, s_errorValueAsObjectArray, context.EvaluationScheduler.CancellationToken); return(results.All(result => !result.IsErrorValue())); }
public async Task WhenAllCancelOnFailure_CancellationThenFailure() { var index = 0; Func <CancellationToken, Task> function1 = async ct => { await Task.Delay(150, ct); Interlocked.Exchange(ref index, 1); throw new InvalidOperationException("1"); }; Func <CancellationToken, Task> function2 = async ct => { await Task.Delay(100, ct); Interlocked.Exchange(ref index, 2); throw new InvalidOperationException("2"); }; var cts = new CancellationTokenSource(50); Func <Task> f = () => TaskUtilities.WhenAllCancelOnFailure(new [] { function1, function2 }, cts.Token); await f.ShouldThrowAsync <OperationCanceledException>(); index.Should().Be(0); }
public TaskResult Execute(TaskInstance taskInstance) { var taskResult = new TaskResult(); try { StartActiveNotifier(taskInstance.Id); TaskUtilities.UpdateTaskInstanceStatus(taskInstance.Id, _repositoryFactory, TaskInstanceStatues.InProgress, null); int instanceConfigurationId = Convert.ToInt16(taskInstance.Parameters["InstanceConfigurationId"]); var newAutoBook = new AutoBookDomainObject() { TimeCreated = DateTime.UtcNow, Locked = false, Status = AutoBookStatuses.Provisioning, InstanceConfigurationId = instanceConfigurationId }; _autoBooks.Create(newAutoBook); TaskUtilities.UpdateTaskInstanceStatus(taskInstance.Id, _repositoryFactory, TaskInstanceStatues.CompletedSuccess, DateTime.UtcNow); taskResult.Status = TaskInstanceStatues.CompletedSuccess; } catch (Exception exception) { TaskUtilities.UpdateTaskInstanceStatus(taskInstance.Id, _repositoryFactory, TaskInstanceStatues.CompletedError, DateTime.UtcNow); taskResult.Status = TaskInstanceStatues.CompletedError; taskResult.Exception = exception; } finally { StopActiveNotifier(); } return(taskResult); }