private CommandResult Inspect(ScriptResult result) { if (result == null) { return(CommandResult.Error); } if (result.CompileExceptionInfo != null) { var ex = result.CompileExceptionInfo.SourceException; _logger.ErrorFormat("Script compilation failed: {0}.", ex, ex.Message); return(CommandResult.Error); } if (result.ExecuteExceptionInfo != null) { var ex = result.ExecuteExceptionInfo.SourceException; _logger.ErrorFormat("Script execution failed: {0}.", ex, ex.Message); return(CommandResult.Error); } if (!result.IsCompleteSubmission) { _logger.Error("The script is incomplete."); return(CommandResult.Error); } return(CommandResult.Success); }
public async Task <ScriptResult> Post([FromBody] ScriptResult result) { _dataService.AddOrUpdateScriptResult(result); if (result.HadErrors && result.SavedScriptId.HasValue) { var savedScript = await _dataService.GetSavedScript(result.SavedScriptId.Value); if (savedScript.GenerateAlertOnError) { await _dataService.AddAlert(result.DeviceID, result.OrganizationID, $"Alert triggered while running script {savedScript.Name}.", string.Join("\n", result.ErrorOutput)); } if (savedScript.SendEmailOnError) { var device = _dataService.GetDevice(result.DeviceID); await _emailSender.SendEmailAsync(savedScript.SendErrorEmailTo, "Script Run Alert", $"An alert was triggered while running script {savedScript.Name} on device {device.DeviceName}. <br /><br />" + $"Error Output: <br /><br /> " + $"{string.Join("<br /><br />", result.ErrorOutput)}"); } } if (result.ScriptRunId.HasValue) { await _dataService.AddScriptResultToScriptRun(result.ID, result.ScriptRunId.Value); } return(result); }
private AssemblyCatalog ExecuteScripts(string[] scriptFiles) { var services = CreateScriptServices(); ScriptResult result = null; if (_options.KeepScriptsSeparated && scriptFiles.Any()) { foreach (var scriptFile in scriptFiles) { var loader = GetLoader(scriptFile); result = ExecuteScript(services, loader); } } else { var loader = GetLoader(scriptFiles); result = ExecuteScript(services, loader); } AssemblyCatalog catalog = null; var marker = result.ReturnValue as Type; if (marker != null) { catalog = new AssemblyCatalog(marker.Assembly, this); } return(catalog); }
public static void SetHeader(ScriptResult result, string fieldName, string displayText, string type, string key) { if (string.IsNullOrEmpty(displayText)) { displayText = fieldName; } ScriptHeader h = new ScriptHeader() { FieldName = fieldName, DisplayText = displayText }; switch (type) { case "int": h.Type = typeof(int); break; case "string": h.Type = typeof(string); break; default: h.Type = typeof(object); break; } if (!result.DataSet.ContainsKey(key)) { result.DataSet.Add(key, new ScriptData()); } result.DataSet[key].AddHeader(h); }
protected virtual ScriptResult Execute(string code, Session session) { Guard.AgainstNullArgument("session", session); var result = new ScriptResult(); try { var submission = session.CompileSubmission <object>(code); try { result.ReturnValue = submission.Execute(); } catch (Exception ex) { result.ExecuteExceptionInfo = ExceptionDispatchInfo.Capture(ex); } } catch (Exception ex) { result.UpdateClosingExpectation(ex); if (!result.IsPendingClosingChar) { result.CompileExceptionInfo = ExceptionDispatchInfo.Capture(ex); } } return(result); }
public void VaultExecutionTest() { GrimoireScriptBlock script = TestHelper.GetSingleTestScript(); script.ExtractResult = new PatternRange() { Start = "", End = "" }; business.SaveScriptBlock(script).Wait(); GrimoireScriptBlock result = TestHelper.GetCreatedScript(config, "Test_Script.json"); result.Should().NotBeNull(); savedVault.Itens = new List <VaultItem>(); savedVault.Itens.Add(new VaultItem(true, "Key 1", "value 1")); savedVault.Itens.Add(new VaultItem(true, "Key 2", "value 2")); savedVault.Itens.Add(new VaultItem(true, "Key 3", "value 3")); business.LoadVault(); business.LoadScriptRunners().Wait(); ScriptResult scriptResult = business.ScriptRunners.First().Run().Result; scriptResult.Should().NotBeNull(); scriptResult.ResultType.Should().Be(ResultType.Success); scriptResult.FilteredResult.Should() .Contain("Single line multiple keys: value 1 - value 2") .And .Contain("Single key: value 3"); savedVault.Itens = new List <VaultItem>(); }
public void Run(string script, IDictionary <object, object> parameters, bool resetResult = true) { LastException = null; if (resetResult) { Result = new ScriptResult(); } Result.Exception = null; Parameters.Merge(parameters); Result.Title = Parameters.Replace(Result.Title); try { ScriptSource source = engine.CreateScriptSourceFromString(Parameters.Replace(script), SourceCodeKind.Statements); source.Execute(scope); } catch (Exception ex) { Result.Exception = ex; } }
private static void RethrowExceptionIfAny(ScriptResult result, string scriptPath) { if (result.CompileExceptionInfo != null) { log.ErrorFormat(CultureInfo.InvariantCulture, "Failed to compile {0}", result.CompileExceptionInfo, scriptPath); result.CompileExceptionInfo.Throw(); } if (result.ExecuteExceptionInfo != null) { // HACK: waiting on https://github.com/scriptcs/scriptcs/issues/545 if (!result.ExecuteExceptionInfo.SourceException.StackTrace.Trim() .StartsWith("at Submission#", StringComparison.OrdinalIgnoreCase)) { log.Warn( "Roslyn failed to execute the scripts. Any configuration in this script will not be available", result.ExecuteExceptionInfo.SourceException); } else { log.ErrorFormat(CultureInfo.InvariantCulture, "Failed to execute {0}", result.ExecuteExceptionInfo, scriptPath); result.ExecuteExceptionInfo.Throw(); } } }
private CommandResult Inspect(ScriptResult result) { if (result == null) { return(CommandResult.Error); } if (result.CompileExceptionInfo != null) { _logger.Error(result.CompileExceptionInfo.SourceException.Message); _logger.Debug(result.CompileExceptionInfo.SourceException); return(CommandResult.Error); } if (result.ExecuteExceptionInfo != null) { _logger.Error(result.ExecuteExceptionInfo.SourceException); return(CommandResult.Error); } if (!result.IsCompleteSubmission) { _logger.Error("The script is incomplete."); return(CommandResult.Error); } return(CommandResult.Success); }
public override void AssertScript(ScriptResult compareResult) { base.AssertScript(compareResult); var commands = compareResult.AllStatements.ToArray(); Assert.That(commands.Count(), Is.EqualTo(3)); }
/// <summary> /// Send conversation response to Osiris from web hook conversation script. /// </summary> /// <param name="passedContext"> /// The passed context. /// </param> /// <param name="generatedResult"> /// The conversation script result. /// </param> /// <returns> /// The <see cref="bool"/>. /// </returns> public bool SendWebhookResponse(ScriptContext passedContext, ScriptResult generatedResult) { var task = Task.Run(() => this.SendWebhookResponseAsync(passedContext, generatedResult)); task.Wait(); return(task.Result); }
private static bool Execute(string[] args) { bool success = true; string fileName = ConfigurationManager.AppSettings["filepath"]; if (fileName == null || fileName == "") { Console.WriteLine("No location stated in config file."); } List <ScriptResult> resultSet = new List <ScriptResult>(); List <Script> scripts = XmlHelper.MapScriptsFromXml(fileName); for (int i = 0; i < scripts.Count; i++) { var script = scripts[i]; //Get contents of a fluent script file string fileContent = FluentHelper.GetFluentScriptFileContent(script.Name); // 1. Create instance of interpreter. var ip = FluentHelper.GetInterpreter(); // 2. Check if emtpy file. if (!string.IsNullOrEmpty(fileContent)) { // 3. Execute script. Console.Write("Executing : " + script.Name); ip.Execute(fileContent); // 4. Check result. ScriptResult result = new ScriptResult(); result.FilePath = script.Name; result.Duration = ip.Result.Duration.TotalMilliseconds; result.Succeed = ip.Result.Success; if (!result.Succeed) { WriteScriptError(script.Name, ip.Result.Message); } else { Console.WriteLine(); } CheckExpectedResults(ip, fileContent, script, result); if (!result.Succeed) { success = false; WriteExpectedResultsFailedError(); // highlight } resultSet.Add(result); } } // Writes result in Xml file LogHelper.WriteInLogFile(resultSet); return(success); }
private async Task <ScriptResult> ExecutePowerShell(GrimoireScriptBlock scriptBlock, IList <Input> inputs) { ScriptResult result = null; string script = await business.ReadScript(scriptBlock); if (inputs != null && inputs.Any()) { foreach (var input in inputs) { script = script.Replace(input.Key, input.Value); } } using (PowerShell ps = PowerShell.Create()) { PSDataCollection <PSObject> outputCollection = new PSDataCollection <PSObject>(); ps.AddScript("Set-ExecutionPolicy -Scope Process Unrestricted"); ps.AddScript(script); IAsyncResult execResult = await Task.Run(() => ps.BeginInvoke <PSObject, PSObject>(null, outputCollection)); WaitExecution(scriptBlock.TimeOut, execResult); result = GetResult(scriptBlock, ps); } return(result); }
public static ScriptResult Run(string code, hostObject_ obj) { //設定 var ssr = ScriptSourceResolver.Default.WithBaseDirectory(Environment.CurrentDirectory); var options = ScriptOptions.Default .WithSourceResolver(ssr) .WithReferences(typeof(object).Assembly) //参照アセンブリを指定 .WithReferences(Assembly.GetEntryAssembly()) .WithImports( //using する名前空間を指定 "System", "System.Collections.Generic" ); //コードの生成 var script = CSharpScript.Create( code, options, typeof(hostObject_) ); //実行 var state = script.RunAsync(obj).Result; //結果の取り出し ScriptResult ret = new ScriptResult(); //ret.outputPixel = (PixelDouble)state.GetVariable("result")?.Value ?? null; //ret.outputStr = (string)state.GetVariable("resultStr")?.Value ?? ""; return(ret); }
/// <summary> /// Applies the SQL query by breaking it into stataments and executing one by one inside a transaction. /// </summary> public void ApplyScript() { ErroredOutDataRow = null; ScriptResult = MySqlStatement.StatementResultType.NotApplied; CreateActualStatementsList(); if (ActualStatementRowsList == null || ActualStatementRowsList.Count == 0) { return; } var connectionStringBuilder = _wbConnection.GetConnectionStringBuilder(); connectionStringBuilder.AllowUserVariables = true; using (var conn = new MySqlConnection(connectionStringBuilder.ConnectionString)) { conn.Open(); MySqlTransaction transaction = conn.BeginTransaction(); var command = new MySqlCommand(string.Empty, conn, transaction); uint executionOrder = 1; foreach (var mySqlRow in ActualStatementRowsList) { // Before attempting to execute the MySqlStatement object, check if the connection is still open. if (conn.State != ConnectionState.Open) { ErroredOutDataRow = mySqlRow; ErroredOutDataRow.RowError = Resources.ConnectionLostErrorText; ScriptResult = MySqlStatement.StatementResultType.ConnectionLost; break; } var rowStatement = mySqlRow.Statement; rowStatement.Execute(command, executionOrder++, _useOptimisticUpdate); ScriptResult = rowStatement.JoinResultTypes(ScriptResult); if (ScriptResult.WithoutErrors()) { continue; } ErroredOutDataRow = mySqlRow; if (ScriptResult == MySqlStatement.StatementResultType.ErrorThrown) { // Check if the result was errored out because the connection was broken and if so, flip the ScriptResult to its proper value. if (conn.State != ConnectionState.Open) { ErroredOutDataRow.RowError = Resources.ConnectionLostErrorText; ScriptResult = MySqlStatement.StatementResultType.ConnectionLost; break; } mySqlRow.ReflectError(); } break; } PostApplyScript(transaction); transaction.Dispose(); } }
public override void AssertScript(ScriptResult compareResult) { var commands = compareResult.AllStatements.ToArray(); var indexCommands = commands.Where(x => x.Contains(" INDEX ")).Count(); Assert.That(indexCommands, Is.EqualTo(2)); Assert.That(commands.Count(), Is.EqualTo(3)); }
public override void AssertScript(ScriptResult compareResult) { var commands = compareResult.AllStatements .Where(c => c.Contains(" CONSTRAINT ")) .ToArray(); Assert.That(commands, Is.Empty); }
private ScriptResult GetResult(GrimoireScriptBlock scriptBlock, PowerShell ps) { ScriptResult result = MountResults(ps); result.ResultType = GetResultStatus(scriptBlock, ps, result.RawResult); result.FilteredResult = ExtractFilteredResult(scriptBlock, result.RawResult); return(result); }
public void Execute(ScriptResult compareResult) { var commands = compareResult.AllStatements.ToArray(); var dropCommands = commands.Where(x => x.Contains(" DROP ")).Count(); var addCommands = commands.Where(x => x.Contains(" ADD ")).Count(); Assert.That(dropCommands, Is.EqualTo(3)); Assert.That(addCommands, Is.EqualTo(1)); }
/// <summary> /// Function that builds the contents of the generated file based on the contents of the input file. /// </summary> /// <param name="inputFileContent">Content of the input file</param> /// <returns>Generated file as a byte array</returns> protected override byte[] GenerateCode(string inputFileContent) { // Some good examples: https://t4toolbox.svn.codeplex.com/svn/Source/DteProcessor.cs // And https://github.com/madskristensen/ExtensibilityTools/blob/master/src/VsixManifest/Generator/ResxFileGenerator.cs try { ProjectItem projectItem = GetProjectItem(); string inputFilePath = projectItem.Properties.Item("FullPath").Value.ToString(); Project project = projectItem.ContainingProject; Solution solution = projectItem.DTE.Solution; // Run the generator and get the results ScriptSource source = new ScriptSource(inputFilePath, inputFileContent); ScriptEngine engine = new ScriptEngine(project.FullName, solution.FullName, null); ScriptResult result = engine.Evaluate(source).Result; // Report errors if (result.Errors.Count > 0) { foreach (ScriptError error in result.Errors) { GeneratorError(4, error.Message, (uint)error.Line, (uint)error.Column); } return(null); } // Add generated files to the project foreach (IOutputFileInfo outputFile in result.OutputFiles.Where(x => x.BuildAction != BuildAction.GenerateOnly)) { ProjectItem outputItem = projectItem.ProjectItems.Cast <ProjectItem>() .FirstOrDefault(x => x.Properties.Item("FullPath")?.Value?.ToString() == outputFile.FilePath) ?? projectItem.ProjectItems.AddFromFile(outputFile.FilePath); outputItem.Properties.Item("ItemType").Value = outputFile.BuildAction.ToString(); } // Remove/delete files from the last generation but not in this one string logPath = Path.ChangeExtension(inputFilePath, ".log"); if (File.Exists(logPath)) { string[] logLines = File.ReadAllLines(logPath); foreach (string fileToRemove in logLines.Where(x => result.OutputFiles.All(y => y.FilePath != x))) { solution.FindProjectItem(fileToRemove)?.Delete(); } } // Create the log file return(Encoding.UTF8.GetBytes(string.Join(Environment.NewLine, result.OutputFiles.Select(x => x.FilePath)))); } catch (Exception ex) { GeneratorError(4, ex.ToString(), 0, 0); return(null); } }
private async void Button_Click(object sender, RoutedEventArgs e) { try { SqlOutput.Text = "Generating Script..."; CSharpOutput.Text = "Generating Script..."; _CodeGenerator = new CodeGenerator(ConnectionString); await _CodeGenerator.GenerateQuerySchema(Query); var sqlResult = await _CodeGenerator.GetSqlScript(); var cSharpResult = await _CodeGenerator.GetPocoScript(); SqlOutput.Text = sqlResult; CSharpOutput.Text = cSharpResult; if (ScriptResults == null) { ScriptResults = new ScriptResultList(); } var lastResult = ScriptResults.FirstOrDefault(r => r.InputScript == Query); ScriptResult newResult = new ScriptResult(); // If there already is a matching result, update the run time if (lastResult != null) { lastResult.ScriptTime = DateTime.Now; } else { newResult.Server = Server; newResult.InputScript = Query; newResult.OutputCSharp = cSharpResult; newResult.OutputSql = sqlResult; newResult.ScriptTime = DateTime.Now; ScriptResults.CullList(newResult); ScriptResults.Add(newResult); } PriorQueryCombo.ItemsSource = ScriptResults.OrderByDescending(r => r.ScriptTime); PriorQueryCombo.Text = (lastResult == null) ? newResult.ToString() : lastResult.ToString(); SqlGenerator.Properties.Settings.Default.Save(); } catch (Exception ex) { MessageBox.Show(ex.Message); SqlOutput.Text = string.Format("/*{0}*/", ex.Message); CSharpOutput.Text = string.Format("/*{0}*/", ex.Message); } }
public SpatialReference getOutputSRS(Session session, SpatialReference terrain_srs) { if (!grid_valid || output_srs == null) { if (levels.Count > 0 && levels[0].getFilterGraph() != null) { FilterEnv env = session.createFilterEnv(); env.setTerrainSRS(terrain_srs); FilterList filters = levels[0].getFilterGraph().getFilters(); for (int ind = filters.Count - 1; ind >= 0; ind--) //reverse iterator? { if (output_srs != null) { break; } Filter i = filters[ind]; if (i is TransformFilter) { TransformFilter xf = (TransformFilter)i; if (xf.getUseTerrainSRS()) { if (env.getTerrainSRS() != null) { this.output_srs = env.getTerrainSRS(); } } else if (xf.getSRS()) { this.output_srs = (SpatialReference)(xf.getSRS()); } else if (xf.getSRSScript()) { ScriptResult r = env.getScriptEngine().run(xf.getSRSScript(), env); if (r.isValid()) { this.output_srs = session.getResources().getSRS(r.asString()); } else { env.getReport().error(r.asString()); } } } } if (output_srs == null) // no reproject..assume input srs { this.output_srs = levels[0].getFeatureLayer().getSRS(); } } } return(output_srs); }
public async Task <bool> ExecuteCode(string code, CancellationToken token = default, IScriptWriter sender = null) { string result = null; object returnedValue = null; bool isError = false; bool isCancelled = false; ScriptExecuted?.Invoke(this, new ScriptRequest { Script = code, Writer = sender }); try { if (!await InitScript(token)) { return(false); } using (await _scriptStateLock.LockAsync(token)) { if (_executionContext != null) { await _executionContext(async() => _scriptState = await _scriptState.ContinueWithAsync(code, cancellationToken: token)); } else { _scriptState = await _scriptState.ContinueWithAsync(code, cancellationToken : token); } returnedValue = _scriptState.ReturnValue; result = _scriptState.ReturnValue?.ToString(); if (_scriptState.ReturnValue != null && _scriptState.ReturnValue.GetType() == typeof(string)) { result = $"\"{result}\""; } } } catch (CompilationErrorException e) { result = e.Message; isError = true; } catch (OperationCanceledException) { result = string.Empty; isCancelled = true; } if (result != null) { var scriptResult = new ScriptResult { Result = result, ReturnedValue = returnedValue, IsError = isError, IsCancelled = isCancelled }; Results.Add(scriptResult); ScriptResultReceived?.Invoke(this, scriptResult); } return(!isError && !isCancelled); }
public override void AssertScript(ScriptResult compareResult) { base.AssertScript(compareResult); var commands = compareResult.AllStatements.ToArray(); var dropCommands = commands.Where(x => x.Contains(" DROP ")).Count(); var addCommands = commands.Where(x => x.Contains(" ADD ")).Count(); Assert.That(dropCommands, Is.EqualTo(3)); Assert.That(addCommands, Is.EqualTo(1)); }
public static IEnumerable <dynamic> GetData(ScriptResult result, string key) { if (string.IsNullOrEmpty(key)) { key = "default"; } ScriptData data = result.DataSet[key]; return(data.Items); }
public override void AssertScript(ScriptResult compareResult) { var commands = compareResult.AllStatements.ToArray(); var dropConstraintCommands = commands.Where(x => x.Contains(" DROP CONSTRAINT ")).Count(); var addUniqueCommands = commands.Where(x => x.Contains(" ADD UNIQUE ")).Count(); Assert.That(dropConstraintCommands, Is.EqualTo(1)); Assert.That(addUniqueCommands, Is.EqualTo(1)); Assert.That(commands.Count(), Is.EqualTo(3)); }
public void Execute(ScriptResult compareResult) { var commands = compareResult.AllStatements.ToArray(); var dropConstraintCommands = commands.Where(x => x.Contains(" DROP CONSTRAINT ")).Count(); var addPrimaryKeyCommands = commands.Where(x => x.Contains(" ADD PRIMARY KEY ")).Count(); Assert.That(dropConstraintCommands, Is.EqualTo(1)); Assert.That(addPrimaryKeyCommands, Is.EqualTo(1)); Assert.That(commands.Count(), Is.EqualTo(3)); }
public void Write(HtmlRenderer renderer, string script, bool inline) { if (!string.IsNullOrWhiteSpace(script)) { if (renderer.EnableHtmlForInline || !inline) { var fullScript = script; ScriptResult result = null; try { result = scriptExecutor.ExecuteScript(fullScript); if (result.CompileExceptionInfo != null) { renderer.Write(Markdown.ToHtml(BuildMarkdownExceptionMessage(result.CompileExceptionInfo.SourceException, options.ExceptionStackTrace), pipeline)); } if (MarkdownDocument.Instance.ReportObject != null) { if (MarkdownDocument.Instance.ReportObject is HtmlReportObject) { renderer.Write(((HtmlReportObject)MarkdownDocument.Instance.ReportObject).Html); } else if (MarkdownDocument.Instance.ReportObject is MarkdownReportObject) { var markdown = Markdown.ToHtml(((MarkdownReportObject)MarkdownDocument.Instance.ReportObject).Markdown, pipeline); if (inline) { if (markdown.StartsWith("<p>")) { markdown = markdown.Substring(3); } if (markdown.EndsWith("</p>\n")) { markdown = markdown.Substring(0, markdown.Length - 5); } } renderer.Write(markdown); } } MarkdownDocument.Instance.Reset(); } catch (Exception ex) { renderer.Write(Markdown.ToHtml(BuildMarkdownExceptionMessage(ex, options.ExceptionStackTrace), pipeline)); } } else { renderer.Write(script); } } }
public override void AssertScript(ScriptResult compareResult) { var commands = compareResult.AllStatements.ToArray(); var dropConstraintCommands = commands.Where(x => x.Contains(" DROP CONSTRAINT ")).Count(); var addPrimaryKeyCommands = commands.Where(x => x.Contains(" ADD PRIMARY KEY ")).Count(); var addForeignKeyCommands = commands.Where(x => x.Contains(" ADD FOREIGN KEY ")).Count(); Assert.That(dropConstraintCommands, Is.EqualTo(5)); Assert.That(addPrimaryKeyCommands, Is.EqualTo(3)); Assert.That(addForeignKeyCommands, Is.EqualTo(2)); Assert.That(commands.Count(), Is.EqualTo(11)); }
public void Execute(ScriptResult compareResult) { var commands = compareResult.AllStatements.ToArray(); var dropConstraintCommands = commands.Where(x => x.Contains(" DROP CONSTRAINT ")).Count(); var addUniqueCommands = commands.Where(x => x.Contains(" ADD UNIQUE ")).Count(); var addForeignKeyCommands = commands.Where(x => x.Contains(" ADD FOREIGN KEY ")).Count(); Assert.That(dropConstraintCommands, Is.EqualTo(2)); Assert.That(addUniqueCommands, Is.EqualTo(1)); Assert.That(addForeignKeyCommands, Is.EqualTo(1)); Assert.That(commands.Count(), Is.EqualTo(5)); }
private static void RethrowExceptionIfAny(ScriptResult result, string script) { if (result.CompileExceptionInfo != null) { log.ErrorFormat("Failed to compile {0}", result.CompileExceptionInfo, script); result.CompileExceptionInfo.Throw(); } if (result.ExecuteExceptionInfo != null) { log.ErrorFormat("Failed to execute {0}", result.ExecuteExceptionInfo, script); result.ExecuteExceptionInfo.Throw(); } }
public virtual ScriptResult ProcessCommand(string command, ScriptPackSession scriptPackSession) { _logger.Debug("Processing REPL Command [" + command + "] >>"); var scriptResult = new ScriptResult(); if (_replCommands.Count.Equals(0)) { if (scriptPackSession.ReplCommands != null && scriptPackSession.ReplCommands.Count > 0) { foreach (var scriptPackReplCommand in scriptPackSession.ReplCommands) { _replCommands.Add(scriptPackReplCommand.Key, scriptPackReplCommand.Value); } } } var script = ParseArguments(command); if (!string.IsNullOrWhiteSpace(script)) { script = NormaliseScript(script); if (_scriptEngine != null) scriptResult = _scriptEngine.Execute(script, new string[0], scriptPackSession.References, scriptPackSession.Namespaces, scriptPackSession); _logger.Debug("<< REPL Command executed."); } else { scriptResult.ReturnValue = "REPL Command not found"; _logger.Debug("<< REPL Command not defined."); } return scriptResult; }
public virtual ScriptResult Execute(string code) { var result = new ScriptResult(); try { var submission = Session.CompileSubmission<object>(code); try { result.ReturnValue = submission.Execute(); } catch (Exception ex) { result.ExecuteExceptionInfo = ExceptionDispatchInfo.Capture(ex); } } catch (Exception ex) { result.CompileExceptionInfo = ExceptionDispatchInfo.Capture(ex); } return result; }
public override ScriptResult Execute(string script, params string[] scriptArgs) { var result = new ScriptResult(); repl.EvaluateStarted(script, null); try { if (script.StartsWith(":")) { var tokens = script.Split(' '); if (tokens[0].Length > 1) { var command = replCommands.FirstOrDefault(x => x.CommandName == tokens[0].Substring(1)); if (command != null) { var argsToPass = new List<object>(); foreach (var argument in tokens.Skip(1)) { var argumentResult = ScriptEngine.Execute(argument, scriptArgs, References, Namespaces, ScriptPackSession); if (argumentResult.CompileExceptionInfo != null) { throw new Exception( GetInvalidCommandArgumentMessage(argument), argumentResult.CompileExceptionInfo.SourceException); } if (argumentResult.ExecuteExceptionInfo != null) { throw new Exception( GetInvalidCommandArgumentMessage(argument), argumentResult.ExecuteExceptionInfo.SourceException); } if (!argumentResult.IsCompleteSubmission) { throw new Exception(GetInvalidCommandArgumentMessage(argument)); } argsToPass.Add(argumentResult.ReturnValue); } var commandResult = command.Execute(this, argsToPass.ToArray()); if (commandResult is ScriptResult) result = commandResult as ScriptResult; else result = new ScriptResult(commandResult); } else { throw new Exception("Command not found: " + tokens[0].Substring(1)); } } } else { var preProcessResult = FilePreProcessor.ProcessScript(script); ImportNamespaces(preProcessResult.Namespaces.ToArray()); foreach (var reference in preProcessResult.References) { var referencePath = FileSystem.GetFullPath(Path.Combine(FileSystem.BinFolder, reference)); AddReferences(FileSystem.FileExists(referencePath) ? referencePath : reference); } result = ScriptEngine.Execute(preProcessResult.Code, scriptArgs, References, Namespaces, ScriptPackSession); if (result != null && result.IsCompleteSubmission) PrepareVariables(); } } catch (FileNotFoundException fileEx) { RemoveReferences(fileEx.FileName); result = new ScriptResult(compilationException:fileEx); } catch (Exception ex) { result = new ScriptResult(executionException:ex); } finally { repl.EvaluateCompleted(result); } return result; }
protected virtual ScriptResult Execute(string code, Session session) { Guard.AgainstNullArgument("session", session); var result = new ScriptResult(); try { var submission = session.CompileSubmission<object>(code); try { result.ReturnValue = submission.Execute(); } catch (Exception ex) { result.ExecuteExceptionInfo = ExceptionDispatchInfo.Capture(ex); } } catch (Exception ex) { result.UpdateClosingExpectation(ex); if (!result.IsPendingClosingChar) result.CompileExceptionInfo = ExceptionDispatchInfo.Capture(ex); } return result; }
private bool ProcessCoreCommand(string script, out ScriptResult scriptResult) { scriptResult = new ScriptResult(); var executedCoreCommand = false; try { if (script.StartsWith("#reset") || script.StartsWith(":reset")) { Reset(); executedCoreCommand = true; } } catch (Exception ex) { Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine("\r\n" + ex + "\r\n"); scriptResult = new ScriptResult {ExecuteExceptionInfo = ExceptionDispatchInfo.Capture(ex)}; } return executedCoreCommand; }
public override ScriptResult Execute(string script, params string[] scriptArgs) { var result = new ScriptResult(); repl.EvaluateStarted(script, null); try { if (script.StartsWith(":")) { var arguments = script.Split(' '); var command = arguments[0].Substring(1); var argsToPass = new List<object>(); foreach (var argument in arguments.Skip(1)) { try { var argumentResult = ScriptEngine.Execute(argument, scriptArgs, References, DefaultNamespaces, ScriptPackSession); //if Roslyn can evaluate the argument, use its value, otherwise assume the string argsToPass.Add(argumentResult.ReturnValue ?? argument); } catch (Exception) { argsToPass.Add(argument); } } var commandResult = HandleReplCommand(command, argsToPass.ToArray()); result = new ScriptResult(commandResult); return result; } var preProcessResult = FilePreProcessor.ProcessScript(script); ImportNamespaces(preProcessResult.Namespaces.ToArray()); var referencesToAdd = preProcessResult.References.Select(reference => { var referencePath = FileSystem.GetFullPath(Path.Combine(Constants.BinFolder, reference)); return FileSystem.FileExists(referencePath) ? referencePath : reference; }) .ToArray(); if (referencesToAdd.Length > 0) AddReferencesAndNotify(referencesToAdd); result = ScriptEngine.Execute(preProcessResult.Code, scriptArgs, References, Namespaces, ScriptPackSession); if (result == null) return new ScriptResult(); return result; } catch (FileNotFoundException fileEx) { RemoveReferences(fileEx.FileName); return new ScriptResult(compilationException:fileEx); } catch (Exception ex) { return new ScriptResult(executionException:ex); } finally { repl.EvaluateCompleted(result); } }
protected virtual ScriptResult Execute(string code, Session session) { Guard.AgainstNullArgument("session", session); var result = new ScriptResult(); try { var submission = session.CompileSubmission<object>(code); try { result.ReturnValue = submission.Execute(); } catch (Exception ex) { result.ExecuteException = ex; } } catch (Exception ex) { result.CompileException = ex; } return result; }
protected override ScriptResult Execute(string code, Session session) { Guard.AgainstNullArgument("session", session); var scriptResult = new ScriptResult(); Submission<object> submission = null; _logger.Debug("Compiling submission"); try { submission = session.CompileSubmission<object>(code); } catch (Exception compileException) { scriptResult.CompileExceptionInfo = ExceptionDispatchInfo.Capture(compileException); } var exeBytes = new byte[0]; var pdbBytes = new byte[0]; var compileSuccess = false; using (var exeStream = new MemoryStream()) using (var pdbStream = new MemoryStream()) { var result = submission.Compilation.Emit(exeStream, pdbStream: pdbStream); compileSuccess = result.Success; if (result.Success) { _logger.Debug("Compilation was successful."); exeBytes = exeStream.ToArray(); pdbBytes = pdbStream.ToArray(); } else { var errors = String.Join(Environment.NewLine, result.Diagnostics.Select(x => x.ToString())); _logger.ErrorFormat("Error occurred when compiling: {0})", errors); } } if (compileSuccess) { _logger.Debug("Loading assembly into appdomain."); var assembly = AppDomain.CurrentDomain.Load(exeBytes, pdbBytes); _logger.Debug("Retrieving compiled script class (reflection)."); var type = assembly.GetType(CompiledScriptClass); _logger.Debug("Retrieving compiled script method (reflection)."); var method = type.GetMethod(CompiledScriptMethod, BindingFlags.Static | BindingFlags.Public); try { _logger.Debug("Invoking method."); scriptResult.ReturnValue = method.Invoke(null, new[] { session }); } catch (Exception executeException) { scriptResult.ExecuteExceptionInfo = ExceptionDispatchInfo.Capture(executeException); _logger.Error("An error occurred when executing the scripts."); var message = string.Format( "Exception Message: {0} {1}Stack Trace:{2}", executeException.InnerException.Message, Environment.NewLine, executeException.InnerException.StackTrace); throw new ScriptExecutionException(message, executeException); } } return scriptResult; }
public void Execute(string scriptFile) { Result = _script.Root.Executor.Execute(scriptFile); }
private bool IsCompleteResult(ScriptResult scriptResult) { return scriptResult.ReturnValue != null && !string.IsNullOrEmpty(scriptResult.ReturnValue.ToString()); }
public void ExecuteScript(string script) { Result = _script.Root.Executor.ExecuteScript(script); }