public ProcessExecutionCommand CreateExecutionCommand(IWorkspaceObject entry, ConfigurationSelector configuration) { string exe, args; StringTagModel tagSource = GetTagModel(entry, configuration); ParseCommand(tagSource, out exe, out args); ProjectConfiguration config = null; if (entry is IConfigurationTarget) { config = configuration.GetConfiguration((IConfigurationTarget)entry) as ProjectConfiguration; } //if the executable name matches an executable in the project directory, use that, for back-compat //else fall back and let the execution handler handle it via PATH, working directory, etc. if (!Path.IsPathRooted(exe)) { string localPath = ((FilePath)exe).ToAbsolute(entry.BaseDirectory).FullPath; if (File.Exists(localPath)) { exe = localPath; } } ProcessExecutionCommand cmd = Runtime.ProcessService.CreateCommand(exe); cmd.Arguments = args; FilePath workingDir = this.workingdir; if (!workingDir.IsNullOrEmpty) { workingDir = StringParserService.Parse(workingDir, tagSource); } cmd.WorkingDirectory = workingDir.IsNullOrEmpty ? entry.BaseDirectory : workingDir.ToAbsolute(entry.BaseDirectory); if (environmentVariables != null) { var vars = new Dictionary <string, string> (); foreach (var v in environmentVariables) { vars [v.Key] = StringParserService.Parse(v.Value, tagSource); } if (config != null) { foreach (var v in config.EnvironmentVariables) { vars [v.Key] = StringParserService.Parse(v.Value, tagSource); } } cmd.EnvironmentVariables = vars; } return(cmd); }
public ExternalProcessDesktopApplication( ProcessExecutionCommand command, string displayName, bool isDefault) : base(command.Command, displayName, isDefault) { this.command = command; Arguments = command.Arguments ?? string.Empty; }
public ProcessExecutionCommand CreateExecutionCommand(IWorkspaceObject entry, ConfigurationSelector configuration) { if (string.IsNullOrEmpty(command)) { throw new UserException(GettextCatalog.GetString("Invalid custom command for '{0}' step: the path to the command to execute has not been provided.", TypeLabel)); } string exe, args; StringTagModel tagSource = GetTagModel(entry, configuration); ParseCommand(tagSource, out exe, out args); //if the executable name matches an executable in the project directory, use that, for back-compat //else fall back and let the execution handler handle it via PATH, working directory, etc. if (!Path.IsPathRooted(exe)) { string localPath = ((FilePath)exe).ToAbsolute(entry.BaseDirectory).FullPath; if (File.Exists(localPath)) { exe = localPath; } } ProcessExecutionCommand cmd = Runtime.ProcessService.CreateCommand(exe); cmd.Arguments = args; FilePath workingDir = this.workingdir; if (!workingDir.IsNullOrEmpty) { workingDir = StringParserService.Parse(workingDir, tagSource); } cmd.WorkingDirectory = workingDir.IsNullOrEmpty ? entry.BaseDirectory : workingDir.ToAbsolute(entry.BaseDirectory); if (environmentVariables != null) { var vars = new Dictionary <string, string> (); foreach (var v in environmentVariables) { vars [v.Key] = StringParserService.Parse(v.Value, tagSource); } cmd.EnvironmentVariables = vars; } return(cmd); }
public void Customize(ExecutionCommand command, object configurationData) { CustomArgsExecutionModeData data = (CustomArgsExecutionModeData)configurationData; // Customize the command ProcessExecutionCommand cmd = (ProcessExecutionCommand)command; if (!string.IsNullOrEmpty(data.Arguments)) { cmd.Arguments = data.Arguments; } if (!string.IsNullOrEmpty(data.WorkingDirectory)) { cmd.WorkingDirectory = data.WorkingDirectory; } foreach (KeyValuePair <string, string> var in data.EnvironmentVariables) { cmd.EnvironmentVariables [var.Key] = var.Value; } }
ExecutionCommand CreateCommand(SolutionEntityItem item) { DotNetProject project = item as DotNetProject; if (project == null || project.CompileTarget != CompileTarget.Library || project.ParentSolution == null) { return(null); } SolutionAddinData sdata = project.ParentSolution.GetAddinData(); if (sdata == null || project.GetAddinData() == null || project.GetAddinData().IsRoot) { return(null); } RegistryInfo ri = sdata.ExternalRegistryInfo; if (ri == null || string.IsNullOrEmpty(ri.TestCommand)) { return(null); } FilePath cmd; string args; if (ri.TestCommand [0] == '"') { // If the file name is quoted, unquote it int i = ri.TestCommand.IndexOf('"', 1); if (i == -1) { throw new UserException("Invalid add-in test command: " + ri.TestCommand); } cmd = ri.TestCommand.Substring(1, i - 1); args = ri.TestCommand.Substring(i + 1).Trim(); } else { int i = ri.TestCommand.IndexOf(' '); if (i == -1) { cmd = ri.TestCommand; args = string.Empty; } else { cmd = ri.TestCommand.Substring(0, i); args = ri.TestCommand.Substring(i + 1).Trim(); } } // If the command is an absolute file, take it // It not, consider it is a file relative to the startup path // If a relative file can't be found, use it as is if (!cmd.IsAbsolute) { FilePath absCmd = cmd.ToAbsolute(ri.ApplicationPath); if (System.IO.File.Exists(absCmd)) { cmd = absCmd; } } ProcessExecutionCommand pcmd = Runtime.ProcessService.CreateCommand(cmd) as ProcessExecutionCommand; if (pcmd == null) { return(null); } pcmd.Arguments = args; pcmd.EnvironmentVariables ["MONO_ADDINS_REGISTRY"] = sdata.TestRegistryPath; return(pcmd); }
public void Execute(IProgressMonitor monitor, IWorkspaceObject entry, ExecutionContext context, ConfigurationSelector configuration) { ProcessExecutionCommand cmd = CreateExecutionCommand(entry, configuration); monitor.Log.WriteLine(GettextCatalog.GetString("Executing: {0} {1}", cmd.Command, cmd.Arguments)); if (!Directory.Exists(cmd.WorkingDirectory)) { monitor.ReportError(GettextCatalog.GetString("Custom command working directory does not exist"), null); return; } AggregatedOperationMonitor aggMon = null; IProcessAsyncOperation oper = null; IConsole console = null; try { if (context != null) { if (externalConsole) { console = context.ExternalConsoleFactory.CreateConsole(!pauseExternalConsole); } else { console = context.ConsoleFactory.CreateConsole(!pauseExternalConsole); } oper = context.ExecutionHandler.Execute(cmd, console); } else { if (externalConsole) { console = ExternalConsoleFactory.Instance.CreateConsole(!pauseExternalConsole); oper = Runtime.ProcessService.StartConsoleProcess(cmd.Command, cmd.Arguments, cmd.WorkingDirectory, console, null); } else { oper = Runtime.ProcessService.StartProcess(cmd.Command, cmd.Arguments, cmd.WorkingDirectory, monitor.Log, monitor.Log, null, false); } } aggMon = new AggregatedOperationMonitor(monitor, oper); oper.WaitForCompleted(); if (!oper.Success) { monitor.ReportError("Custom command failed (exit code: " + oper.ExitCode + ")", null); } } catch (Win32Exception w32ex) { monitor.ReportError(GettextCatalog.GetString("Failed to execute custom command '{0}': {1}", cmd.Command, w32ex.Message), null); return; } catch (Exception ex) { LoggingService.LogError("Command execution failed", ex); throw new UserException(GettextCatalog.GetString("Command execution failed: {0}", ex.Message)); } finally { if (oper == null || !oper.Success) { monitor.AsyncOperation.Cancel(); } if (oper != null) { oper.Dispose(); } if (console != null) { console.Dispose(); } if (aggMon != null) { aggMon.Dispose(); } } }
public async Task <bool> Execute(ProgressMonitor monitor, WorkspaceObject entry, ExecutionContext context, ConfigurationSelector configuration) { ProcessExecutionCommand cmd = CreateExecutionCommand(entry, configuration); monitor.Log.WriteLine(GettextCatalog.GetString("Executing: {0} {1}", cmd.Command, cmd.Arguments)); if (!Directory.Exists(cmd.WorkingDirectory)) { monitor.ReportError(GettextCatalog.GetString("Custom command working directory does not exist"), null); return(false); } ProcessAsyncOperation oper = null; OperationConsole console = null; var result = true; try { if (context != null) { if (externalConsole) { console = context.ExternalConsoleFactory.CreateConsole(!pauseExternalConsole, monitor.CancellationToken); } else { console = context.ConsoleFactory.CreateConsole(monitor.CancellationToken); } oper = context.ExecutionHandler.Execute(cmd, console); } else { if (externalConsole) { console = ExternalConsoleFactory.Instance.CreateConsole(!pauseExternalConsole, monitor.CancellationToken); oper = Runtime.ProcessService.StartConsoleProcess(cmd.Command, cmd.Arguments, cmd.WorkingDirectory, console, null); } else { oper = Runtime.ProcessService.StartProcess(cmd.Command, cmd.Arguments, cmd.WorkingDirectory, monitor.Log, monitor.Log, null, false).ProcessAsyncOperation; } } using (var stopper = monitor.CancellationToken.Register(oper.Cancel)) { await oper.Task; } if (oper.ExitCode != 0) { monitor.ReportError(GettextCatalog.GetString("Custom command failed (exit code: {0})", oper.ExitCode), null); } } catch (Win32Exception w32ex) { monitor.ReportError(GettextCatalog.GetString("Failed to execute custom command '{0}': {1}", cmd.Command, w32ex.Message), null); return(false); } catch (Exception ex) { LoggingService.LogError("Command execution failed", ex); throw new UserException(GettextCatalog.GetString("Command execution failed: {0}", ex.Message)); } finally { result = oper != null && oper.ExitCode == 0; if (console != null) { console.Dispose(); } } return(result); }
UnitTestResult RunWithConsoleRunner(ProcessExecutionCommand cmd, UnitTest test, string suiteName, string pathName, string testName, TestContext testContext) { var outFile = Path.GetTempFileName(); LocalConsole cons = new LocalConsole(); try { MonoDevelop.NUnit.External.TcpTestListener tcpListener = null; LocalTestMonitor localMonitor = new LocalTestMonitor(testContext, test, suiteName, testName != null); if (!string.IsNullOrEmpty(cmd.Arguments)) { cmd.Arguments += " "; } cmd.Arguments += "\"-xml=" + outFile + "\" " + AssemblyPath; bool automaticUpdates = cmd.Command.Contains("GuiUnit") || (cmd.Command.Contains("mdtool.exe") && cmd.Arguments.Contains("run-md-tests")); if (!string.IsNullOrEmpty(pathName)) { cmd.Arguments += " -run=" + pathName; } if (automaticUpdates) { tcpListener = new MonoDevelop.NUnit.External.TcpTestListener(localMonitor, suiteName); cmd.Arguments += " -port=" + tcpListener.Port; } // Note that we always dispose the tcp listener as we don't want it listening // forever if the test runner does not try to connect to it using (tcpListener) { var p = testContext.ExecutionContext.Execute(cmd, cons); testContext.Monitor.CancelRequested += p.Cancel; if (testContext.Monitor.IsCancelRequested) { p.Cancel(); } p.WaitForCompleted(); if (new FileInfo(outFile).Length == 0) { throw new Exception("Command failed"); } } // mdtool.exe does not necessarily guarantee we get automatic updates. It just guarantees // that if guiunit is being used then it will give us updates. If you have a regular test // assembly compiled against nunit.framework.dll if (automaticUpdates && tcpListener.HasReceivedConnection) { if (testName != null) { return(localMonitor.SingleTestResult); } return(test.GetLastResult()); } XDocument doc = XDocument.Load(outFile); if (doc.Root != null) { var root = doc.Root.Elements("test-suite").FirstOrDefault(); if (root != null) { cons.SetDone(); var ot = cons.Out.ReadToEnd(); var et = cons.Error.ReadToEnd(); testContext.Monitor.WriteGlobalLog(ot); if (!string.IsNullOrEmpty(et)) { testContext.Monitor.WriteGlobalLog("ERROR:\n"); testContext.Monitor.WriteGlobalLog(et); } bool macunitStyle = doc.Root.Element("environment") != null && doc.Root.Element("environment").Attribute("macunit-version") != null; var result = ReportXmlResult(localMonitor, root, "", macunitStyle); if (testName != null) { result = localMonitor.SingleTestResult; } return(result); } } throw new Exception("Test results could not be parsed."); } catch (Exception ex) { cons.SetDone(); var ot = cons.Out.ReadToEnd(); var et = cons.Error.ReadToEnd(); testContext.Monitor.WriteGlobalLog(ot); if (!string.IsNullOrEmpty(et)) { testContext.Monitor.WriteGlobalLog("ERROR:\n"); testContext.Monitor.WriteGlobalLog(et); } testContext.Monitor.ReportRuntimeError("Test execution failed.\n" + ot + "\n" + et, ex); return(UnitTestResult.CreateIgnored("Test execution failed")); } finally { File.Delete(outFile); } }
UnitTestResult RunWithConsoleRunner(ProcessExecutionCommand cmd, UnitTest test, string suiteName, string pathName, string testName, TestContext testContext) { var outFile = Path.GetTempFileName(); LocalConsole cons = new LocalConsole(); try { if (!string.IsNullOrEmpty(cmd.Arguments)) { cmd.Arguments += " "; } cmd.Arguments += "\"-xml=" + outFile + "\" " + AssemblyPath; if (!string.IsNullOrEmpty(testName)) { cmd.Arguments += " -run=" + suiteName + "." + testName; } else if (!string.IsNullOrEmpty(suiteName)) { cmd.Arguments += " -run=" + suiteName; } var p = testContext.ExecutionContext.Execute(cmd, cons); testContext.Monitor.CancelRequested += p.Cancel; if (testContext.Monitor.IsCancelRequested) { p.Cancel(); } p.WaitForCompleted(); if (new FileInfo(outFile).Length == 0) { throw new Exception("Command failed"); } LocalTestMonitor localMonitor = new LocalTestMonitor(testContext, test, suiteName, testName != null); XDocument doc = XDocument.Load(outFile); if (doc.Root != null) { var root = doc.Root.Elements("test-suite").FirstOrDefault(); if (root != null) { cons.SetDone(); var ot = cons.Out.ReadToEnd(); var et = cons.Error.ReadToEnd(); testContext.Monitor.WriteGlobalLog(ot); if (!string.IsNullOrEmpty(et)) { testContext.Monitor.WriteGlobalLog("ERROR:\n"); testContext.Monitor.WriteGlobalLog(et); } return(ReportXmlResult(localMonitor, root, "")); } } throw new Exception("Test results could not be parsed."); } catch (Exception ex) { cons.SetDone(); var ot = cons.Out.ReadToEnd(); var et = cons.Error.ReadToEnd(); testContext.Monitor.WriteGlobalLog(ot); if (!string.IsNullOrEmpty(et)) { testContext.Monitor.WriteGlobalLog("ERROR:\n"); testContext.Monitor.WriteGlobalLog(et); } testContext.Monitor.ReportRuntimeError("Test execution failed.\n" + ot + "\n" + et, ex); return(UnitTestResult.CreateIgnored("Test execution failed")); } finally { File.Delete(outFile); } }
UnitTestResult RunWithConsoleRunner(ProcessExecutionCommand cmd, UnitTest test, string suiteName, string pathName, string testName, TestContext testContext) { var outFile = Path.GetTempFileName(); LocalConsole cons = new LocalConsole(); try { LocalTestMonitor localMonitor = new LocalTestMonitor(testContext, test, suiteName, testName != null); if (!string.IsNullOrEmpty(cmd.Arguments)) { cmd.Arguments += " "; } cmd.Arguments += "\"-xml=" + outFile + "\" " + AssemblyPath; bool automaticUpdates = cmd.Command.Contains("GuiUnit") || (cmd.Command.Contains("mdtool.exe") && cmd.Arguments.Contains("run-md-tests")); if (!string.IsNullOrEmpty(testName)) { cmd.Arguments += " -run=" + suiteName + "." + testName; } else if (!string.IsNullOrEmpty(suiteName)) { cmd.Arguments += " -run=" + suiteName; } if (automaticUpdates) { var tcpListener = new MonoDevelop.NUnit.External.TcpTestListener(localMonitor, suiteName); cmd.Arguments += " -port=" + tcpListener.Port; } var p = testContext.ExecutionContext.Execute(cmd, cons); testContext.Monitor.CancelRequested += p.Cancel; if (testContext.Monitor.IsCancelRequested) { p.Cancel(); } p.WaitForCompleted(); if (new FileInfo(outFile).Length == 0) { throw new Exception("Command failed"); } if (automaticUpdates) { if (testName != null) { return(localMonitor.SingleTestResult); } return(test.GetLastResult()); } XDocument doc = XDocument.Load(outFile); if (doc.Root != null) { var root = doc.Root.Elements("test-suite").FirstOrDefault(); if (root != null) { cons.SetDone(); var ot = cons.Out.ReadToEnd(); var et = cons.Error.ReadToEnd(); testContext.Monitor.WriteGlobalLog(ot); if (!string.IsNullOrEmpty(et)) { testContext.Monitor.WriteGlobalLog("ERROR:\n"); testContext.Monitor.WriteGlobalLog(et); } bool macunitStyle = doc.Root.Element("environment") != null && doc.Root.Element("environment").Attribute("macunit-version") != null; var result = ReportXmlResult(localMonitor, root, "", macunitStyle); if (testName != null) { result = localMonitor.SingleTestResult; } return(result); } } throw new Exception("Test results could not be parsed."); } catch (Exception ex) { cons.SetDone(); var ot = cons.Out.ReadToEnd(); var et = cons.Error.ReadToEnd(); testContext.Monitor.WriteGlobalLog(ot); if (!string.IsNullOrEmpty(et)) { testContext.Monitor.WriteGlobalLog("ERROR:\n"); testContext.Monitor.WriteGlobalLog(et); } testContext.Monitor.ReportRuntimeError("Test execution failed.\n" + ot + "\n" + et, ex); return(UnitTestResult.CreateIgnored("Test execution failed")); } finally { File.Delete(outFile); } }
UnitTestResult RunWithConsoleRunner(ProcessExecutionCommand cmd, UnitTest test, string suiteName, string pathName, string testName, TestContext testContext) { var outFile = Path.GetTempFileName(); var xmlOutputConsole = new LocalConsole(); var appDebugOutputConsole = testContext.ExecutionContext.ConsoleFactory.CreateConsole( OperationConsoleFactory.CreateConsoleOptions.Default.WithTitle(GettextCatalog.GetString("Unit Tests"))); OperationConsole cons; if (appDebugOutputConsole != null) { cons = new MultipleOperationConsoles(appDebugOutputConsole, xmlOutputConsole); } else { cons = xmlOutputConsole; } try { MonoDevelop.UnitTesting.NUnit.External.TcpTestListener tcpListener = null; LocalTestMonitor localMonitor = new LocalTestMonitor(testContext, test, suiteName, testName != null); if (!string.IsNullOrEmpty(cmd.Arguments)) { cmd.Arguments += " "; } cmd.Arguments += "\"-xml=" + outFile + "\" " + AssemblyPath; bool automaticUpdates = cmd.Command != null && (cmd.Command.Contains("GuiUnit") || (cmd.Command.Contains("mdtool.exe") && cmd.Arguments.Contains("run-md-tests"))); if (!string.IsNullOrEmpty(pathName)) { cmd.Arguments += " -run=\"" + test.TestId.Replace("\"", "\\\"") + "\""; } if (automaticUpdates) { tcpListener = new MonoDevelop.UnitTesting.NUnit.External.TcpTestListener(localMonitor, suiteName); cmd.Arguments += " -port=" + tcpListener.Port; } cmd.WorkingDirectory = Path.GetDirectoryName(AssemblyPath); // Note that we always dispose the tcp listener as we don't want it listening // forever if the test runner does not try to connect to it using (tcpListener) { var handler = testContext.ExecutionContext.ExecutionHandler; if (handler == null) { handler = Runtime.ProcessService.DefaultExecutionHandler; } var p = handler.Execute(cmd, cons); using (testContext.Monitor.CancellationToken.Register(p.Cancel)) p.Task.Wait(); if (new FileInfo(outFile).Length == 0) { throw new Exception("Command failed"); } } // mdtool.exe does not necessarily guarantee we get automatic updates. It just guarantees // that if guiunit is being used then it will give us updates. If you have a regular test // assembly compiled against nunit.framework.dll if (automaticUpdates && tcpListener.HasReceivedConnection) { if (testName != null) { return(localMonitor.SingleTestResult); } return(test.GetLastResult()); } XDocument doc = XDocument.Load(outFile); if (doc.Root != null) { var root = doc.Root.Elements("test-suite").FirstOrDefault(); if (root != null) { xmlOutputConsole.SetDone(); var ot = xmlOutputConsole.OutReader.ReadToEnd(); var et = xmlOutputConsole.ErrorReader.ReadToEnd(); testContext.Monitor.WriteGlobalLog(ot); if (!string.IsNullOrEmpty(et)) { testContext.Monitor.WriteGlobalLog("ERROR:\n"); testContext.Monitor.WriteGlobalLog(et); } bool macunitStyle = doc.Root.Element("environment") != null && doc.Root.Element("environment").Attribute("macunit-version") != null; var result = ReportXmlResult(localMonitor, root, "", macunitStyle); if (testName != null) { result = localMonitor.SingleTestResult; } return(result); } } throw new Exception("Test results could not be parsed."); } catch (Exception ex) { xmlOutputConsole.SetDone(); var ot = xmlOutputConsole.OutReader.ReadToEnd(); var et = xmlOutputConsole.ErrorReader.ReadToEnd(); testContext.Monitor.WriteGlobalLog(ot); if (!string.IsNullOrEmpty(et)) { testContext.Monitor.WriteGlobalLog("ERROR:\n"); testContext.Monitor.WriteGlobalLog(et); } testContext.Monitor.ReportRuntimeError("Test execution failed.\n" + ot + "\n" + et, ex); return(UnitTestResult.CreateIgnored("Test execution failed")); } finally { File.Delete(outFile); cons.Dispose(); } }
private static ExecutionCommand CreateExecutionCommand(HaxeProject project, HaxeProjectConfiguration configuration) { string hxmlPath = Path.GetFullPath(project.TargetHXMLFile); if (!File.Exists(hxmlPath)) { hxmlPath = Path.Combine(project.BaseDirectory, project.TargetHXMLFile); } string hxml = File.ReadAllText(hxmlPath); hxml = hxml.Replace(Environment.NewLine, " "); string[] hxmlArgs = hxml.Split(' '); List <string> platforms = new List <string> (); List <string> platformOutputs = new List <string> (); bool addNext = false; bool nextIsMain = false; string main = ""; foreach (string hxmlArg in hxmlArgs) { if (addNext) { if (!hxmlArg.StartsWith("-")) { if (nextIsMain) { main = hxmlArg; nextIsMain = false; } else { platformOutputs.Add(hxmlArg); } } else { if (!nextIsMain) { platforms.RemoveAt(platforms.Count - 1); } } } addNext = true; switch (hxmlArg) { case "-cpp": platforms.Add("cpp"); break; case "-swf": case "-swf9": platforms.Add("flash"); break; case "-js": platforms.Add("js"); break; case "-neko": platforms.Add("neko"); break; case "-php": platforms.Add("php"); break; case "-main": nextIsMain = true; break; default: addNext = false; break; } } int i = 0; //for (int i = 0; i < platforms.Count; i++) //{ string platform = platforms[i]; string output = platformOutputs[i]; if (platform == "cpp" || platform == "neko") { if (platform == "cpp") { output = Path.Combine(output, main); if (configuration.DebugMode) { output += "-debug"; } } if (!File.Exists(Path.GetFullPath(output))) { output = Path.Combine(project.BaseDirectory, output); } string exe = ""; string args = ""; if (platform == "cpp") { exe = output; } else { exe = "neko"; args = "\"" + output + "\""; } //NativeExecutionCommand cmd = new NativeExecutionCommand (exe); HaxeExecutionCommand cmd = new HaxeExecutionCommand(exe); cmd.Arguments = args; cmd.WorkingDirectory = Path.GetDirectoryName(output); if (configuration.DebugMode) { // cmd.EnvironmentVariables.Add ("HXCPP_DEBUG_HOST", "gdb"); cmd.EnvironmentVariables.Add("HXCPP_DEBUG", "1"); } //cmd.WorkingDirectory = project.BaseDirectory.FullPath; //MonoDevelop.Ide.MessageService.ShowMessage (cmd.Command); //MonoDevelop.Ide.MessageService.ShowMessage (cmd.Arguments); //MonoDevelop.Ide.MessageService.ShowMessage (cmd.WorkingDirectory); return(cmd); } else if (platform == "flash" || platform == "js") { if (!File.Exists(Path.GetFullPath(output))) { output = Path.Combine(project.BaseDirectory, output); } if (platform == "js") { output = Path.Combine(Path.GetDirectoryName(output), "index.html"); } //string target = output; switch (Environment.OSVersion.Platform) { case PlatformID.MacOSX: //target = "open \"" + output + "\""; break; case PlatformID.Unix: //target = "xdg-open \"" + output + "\""; break; } ProcessExecutionCommand cmd = new ProcessExecutionCommand(); cmd.Command = output; return(cmd); } //} return(null); }
public void Execute(IProgressMonitor monitor, IWorkspaceObject entry, ExecutionContext context, ConfigurationSelector configuration) { if (string.IsNullOrEmpty(command)) { return; } StringTagModel tagSource = GetTagModel(entry, configuration); string exe, args; ParseCommand(tagSource, out exe, out args); monitor.Log.WriteLine(GettextCatalog.GetString("Executing: {0} {1}", exe, args)); FilePath dir = GetCommandWorkingDir(entry, configuration); FilePath localPath = entry.BaseDirectory.Combine(exe); if (File.Exists(localPath)) { exe = localPath; } IProcessAsyncOperation oper; try { if (context != null) { IConsole console; if (externalConsole) { console = context.ExternalConsoleFactory.CreateConsole(!pauseExternalConsole); } else { console = context.ConsoleFactory.CreateConsole(!pauseExternalConsole); } ExecutionCommand cmd = Runtime.ProcessService.CreateCommand(exe); ProcessExecutionCommand pcmd = cmd as ProcessExecutionCommand; if (pcmd != null) { pcmd.Arguments = args; pcmd.WorkingDirectory = dir; } oper = context.ExecutionHandler.Execute(cmd, console); } else { if (externalConsole) { IConsole console = ExternalConsoleFactory.Instance.CreateConsole(!pauseExternalConsole); oper = Runtime.ProcessService.StartConsoleProcess(exe, args, dir, console, null); } else { oper = Runtime.ProcessService.StartProcess(exe, args, dir, monitor.Log, monitor.Log, null, false); } } } catch (Exception ex) { throw new UserException(GettextCatalog.GetString("Command execution failed: {0}", ex.Message)); } monitor.CancelRequested += delegate { if (!oper.IsCompleted) { oper.Cancel(); } }; oper.WaitForCompleted(); if (!oper.Success) { monitor.ReportError("Custom command failed (exit code: " + oper.ExitCode + ")", null); monitor.AsyncOperation.Cancel(); } }
public void Execute(IProgressMonitor monitor, IWorkspaceObject entry, ExecutionContext context, ConfigurationSelector configuration) { StringTagModel tagSource; if (entry is SolutionItem) { tagSource = ((SolutionItem)entry).GetStringTagModel(configuration); } else if (entry is WorkspaceItem) { tagSource = ((WorkspaceItem)entry).GetStringTagModel(); } else { tagSource = new StringTagModel(); } if (string.IsNullOrEmpty(command)) { return; } int i = command.IndexOf(' '); string exe; string args = string.Empty; if (i == -1) { exe = command; args = string.Empty; } else { exe = command.Substring(0, i); args = StringParserService.Parse(command.Substring(i + 1), tagSource); } monitor.Log.WriteLine(GettextCatalog.GetString("Executing: {0} {1}", exe, args)); FilePath dir = (string.IsNullOrEmpty(workingdir) ? entry.BaseDirectory : (FilePath)StringParserService.Parse(workingdir, tagSource)); FilePath localPath = entry.BaseDirectory.Combine(exe); if (File.Exists(localPath)) { exe = localPath; } IProcessAsyncOperation oper; if (context != null) { IConsole console; if (externalConsole) { console = context.ExternalConsoleFactory.CreateConsole(!pauseExternalConsole); } else { console = context.ConsoleFactory.CreateConsole(!pauseExternalConsole); } ExecutionCommand cmd = Runtime.ProcessService.CreateCommand(exe); ProcessExecutionCommand pcmd = cmd as ProcessExecutionCommand; if (pcmd != null) { pcmd.Arguments = args; pcmd.WorkingDirectory = dir; } oper = context.ExecutionHandler.Execute(cmd, console); } else { if (externalConsole) { IConsole console = ExternalConsoleFactory.Instance.CreateConsole(!pauseExternalConsole); oper = Runtime.ProcessService.StartConsoleProcess(exe, args, dir, console, null); } else { oper = Runtime.ProcessService.StartProcess(exe, args, dir, monitor.Log, monitor.Log, null, false); } } monitor.CancelRequested += delegate { if (!oper.IsCompleted) { oper.Cancel(); } }; oper.WaitForCompleted(); if (!oper.Success) { monitor.ReportError("Custom command failed (exit code: " + oper.ExitCode + ")", null); monitor.AsyncOperation.Cancel(); } }