internal Task ExecuteAsync(IInteractiveWindow interactiveWindow, string title) { if (GetProjectProperties(out var references, out var referenceSearchPaths, out var sourceSearchPaths, out var projectNamespaces, out var projectDirectory, out var platform)) { // Now, we're going to do a bunch of async operations. So create a wait // indicator so the user knows something is happening, and also so they cancel. var waitIndicator = GetWaitIndicator(); var waitContext = waitIndicator.StartWait(title, InteractiveEditorFeaturesResources.Building_Project, allowCancel: true, showProgress: false); var resetInteractiveTask = ResetInteractiveAsync( interactiveWindow, references, referenceSearchPaths, sourceSearchPaths, projectNamespaces, projectDirectory, platform, waitContext); // Once we're done resetting, dismiss the wait indicator and focus the REPL window. return(resetInteractiveTask.SafeContinueWith( _ => { waitContext.Dispose(); ExecutionCompleted?.Invoke(this, new EventArgs()); }, TaskScheduler.FromCurrentSynchronizationContext())); } return(Task.CompletedTask); }
private void RaiseExecutionCompleted(string file, uint[] lines, bool isStepping, BreakState breakState) { var args = new ExecutionCompletedEventArgs(file, lines, isStepping); ExecutionCompleted?.Invoke(this, args); _breakLineTagger.OnExecutionCompleted(args); BreakEntered(this, breakState); }
public Completion Execute(Class m) { _current = m; if (_current == null) { return(null); } Completion c = Completion.Void; foreach (var func in _current.Functions) { if ("main".Equals(func.Format, StringComparison.OrdinalIgnoreCase)) { foreach (var v in _current.Variables) { RegisterValue(v.Name, v.Value); } var parameter = func.Params; ExecutionEnvironment current = new ExecutionEnvironment(this); ExecutionStarted?.Invoke(this, null); foreach (var p in parameter) { current.RegisterValue(p.Name, null); } try { IsCompleted = false; c = func.Execute(current); break; }catch (Exception e) { IsCompleted = true; Console.WriteLine(e.Message); Console.WriteLine(e.StackTrace); ExecutionAborted?.Invoke(this, new Completion(e.Message, CompletionType.Exception)); return(Completion.Void); } } } IsCompleted = true; if (c.Type == CompletionType.Value) { ExecutionCompleted?.Invoke(this, c); } else if (c.Type == CompletionType.Exception) { ExecutionAborted?.Invoke(this, c); } else { ExecutionAborted?.Invoke(this, Completion.Exception("Unknown exception", null)); } return(c); }
public void ExecuteScript(Node behaviorTree, Entity entity) { _currentTree = behaviorTree; _currentTree.Owner = entity; _executionToken = new CancellationTokenSource(); Task.Run(() => { while (!_executionToken.IsCancellationRequested && _currentTree.Execute() == ExecutingStatus.Running) { } }, _executionToken.Token).ContinueWith((t) => { if (t.IsFaulted) { Exception ex = t.Exception; while (ex is AggregateException && ex.InnerException != null) { ex = ex.InnerException; } Log.Write("The script execution failed: " + ex.Message); } else if (t.IsCanceled) { Log.Write("The script execution cancelled !"); } else { Log.Write("The script is executed successfully !"); } if (!t.IsFaulted) { _currentTree.Deactivate(); } ExecutionCompleted?.Invoke(_currentTree, EventArgs.Empty); _currentTree = null; }, TaskScheduler.FromCurrentSynchronizationContext()); }
private TaskResult RunTask() { try { BeforeExecution?.Invoke(this, new JobEventArgs { Context = Context }); Context.ExecutionStartedOn = DateTime.UtcNow; var result = Context.Task.Run(Context.JobName, Context.ScheduleName, Context.Parameters); Context.ExecutionFinishedOn = DateTime.UtcNow; ExecutionCompleted?.Invoke(this, new JobEventArgs { Context = Context }); return(result); } catch (Exception e) { ErrorHandler.HandleException(e); return(TaskResult.Aborted); } }
protected void Run(SurgeBranchManager branchManager, MessageConnection connection, string cacheDirectory, KeyManager keyManager) { BranchManager = branchManager; Connection = connection; try { KeyManager = keyManager; Started = DateTime.UtcNow; if (cacheDirectory != null) { ReportMessage(new ExecutionStarted(this)); } this.PostMortemMetaData["ManagedThreadId"] = System.Threading.Thread.CurrentThread.ManagedThreadId.ToString(System.Globalization.CultureInfo.CurrentCulture); PrepareSet(); int iNum = 0; while (true) { if (_Instructions.Count <= iNum) { break; } if (_Stop) { return; } PrepareSet(); _Instructions[iNum].Message = ""; _Instructions[iNum].Start = DateTime.UtcNow; if (_Instructions[iNum].Stage == STEM.Surge.Stage.Skip || _Instructions[iNum].Stage == STEM.Surge.Stage.Completed) { string xml = SerializeWithLimitedRefresh(iNum - 1); if (cacheDirectory != null) { File.WriteAllText(Path.Combine(cacheDirectory, ID.ToString() + ".is"), xml); } _Instructions[iNum].Finish = DateTime.UtcNow; iNum++; continue; } else { string xml = SerializeWithLimitedRefresh(iNum - 1, iNum); if (cacheDirectory != null) { File.WriteAllText(Path.Combine(cacheDirectory, ID.ToString() + ".is"), xml); } } try { _Instructions[iNum].PopulatePostMortemMeta = _Instructions[iNum].PopulatePostMortemMeta && CachePostMortem; _Instructions[iNum].Run(); } catch (Exception ex) { _Instructions[iNum].Exceptions.Add(ex); STEM.Sys.EventLog.WriteEntry(ProcessName, ex.ToString(), STEM.Sys.EventLog.EventLogEntryType.Error); } _Instructions[iNum].Finish = DateTime.UtcNow; iNum++; } SerializeWithLimitedRefresh(iNum - 1, iNum); } catch (Exception ex) { STEM.Sys.EventLog.WriteEntry("_InstructionSet.Run", ex.ToString(), STEM.Sys.EventLog.EventLogEntryType.Error); } finally { Completed = DateTime.UtcNow; _Stop = true; if (cacheDirectory != null) { try { ExecutionCompleted ec = new ExecutionCompleted(this); foreach (Instruction i in _Instructions) { foreach (Exception e in i.Exceptions) { STEM.Sys.EventLog.WriteEntry(ProcessName, e.ToString(), STEM.Sys.EventLog.EventLogEntryType.Error); } } ReportMessage(ec); } catch (Exception ex) { STEM.Sys.EventLog.WriteEntry("_InstructionSet.Run", ex.ToString(), STEM.Sys.EventLog.EventLogEntryType.Error); } } bool error = false; try { foreach (Instruction i in _Instructions) { if (i.Exceptions.Count > 0) { error = true; break; } } } catch (Exception ex) { STEM.Sys.EventLog.WriteEntry("InstructionSet.Run", ex.ToString(), STEM.Sys.EventLog.EventLogEntryType.Error); } if (branchManager != null) { try { branchManager.EndRun(this, error); } catch (Exception ex) { STEM.Sys.EventLog.WriteEntry("InstructionSet.Run", ex.ToString(), STEM.Sys.EventLog.EventLogEntryType.Error); } } Dispose(); } }
protected virtual void OnCompleted() { ExecutionCompleted?.Invoke(this, EventArgs.Empty); }
/// <summary> /// Fires the execution completed event. /// </summary> private void FireExecutionCompletedEvent() { Status = EngineStatus.Completed; ExecutionCompleted?.Invoke(this, new ExecutionCompletedEventArgs()); }
public Completion Execute(Class m) { IsAborting = false; IsCompleted = false; _current = m; if (_current == null) { return(null); } Completion c = Completion.Void; ExecutionEnvironment baseEnv = this.GetBaseEnvironment(); ExecutionEnvironment classEnv = new ExecutionEnvironment(baseEnv); ExecutionEnvironment instanceEnv = new ExecutionEnvironment(classEnv); foreach (var v in m.Variables) { instanceEnv.RegisterValue(v.Name, v.Value); } foreach (var func in _current.Functions) { if ("main".Equals(func.Name, StringComparison.OrdinalIgnoreCase)) { var parameter = func.Params; ExecutionEnvironment functionEnv = new ExecutionEnvironment(instanceEnv); ExecutionStarted?.Invoke(this, null); foreach (var p in parameter) { functionEnv.RegisterValue(p.Name, null); } foreach (var block in m.BlockStatements) { foreach (var s in block.Body) { if (s is ExpressionStatement) { Expression exp = (s as ExpressionStatement).Expression; if (exp is VariableDeclarationExpression) { exp.Execute(instanceEnv); } } } } try { IsCompleted = false; c = func.Execute(functionEnv); break; }catch (Exception e) { IsCompleted = true; Console.WriteLine(e.Message); Console.WriteLine(e.StackTrace); ExecutionAborted?.Invoke(this, new Completion(e.Message, CompletionType.Exception)); return(Completion.Void); } } } IsCompleted = true; if (c.Type == CompletionType.Value) { ExecutionCompleted?.Invoke(this, c); } else if (c.Type == CompletionType.Exception) { ExecutionAborted?.Invoke(this, c); } else { ExecutionAborted?.Invoke(this, Completion.Exception(Properties.Language.UnknowException, null)); } return(c); }