protected override void DoExecute(IProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration) { IodineConfiguration config = (IodineConfiguration)GetConfiguration (configuration); IConsole console = config.ExternalConsole ? context.ExternalConsoleFactory.CreateConsole (!config.PauseConsoleOutput) : context.ConsoleFactory.CreateConsole (!config.PauseConsoleOutput); AggregatedOperationMonitor aggregatedMonitor = new AggregatedOperationMonitor (monitor); try { string param = string.Format ("\"{0}\" {1}", config.MainFile, config.CommandLineParameters); IProcessAsyncOperation op = Runtime.ProcessService.StartConsoleProcess ("iodine", param, BaseDirectory, config.EnvironmentVariables, console, null); monitor.CancelRequested += delegate { op.Cancel (); }; aggregatedMonitor.AddOperation (op); op.WaitForCompleted (); monitor.Log.WriteLine ("Iodine exited with code: " + op.ExitCode); } catch (Exception e) { monitor.ReportError (GettextCatalog.GetString ("Cannot execute \"{0}\"", config.MainFile), e); } finally { console.Dispose (); aggregatedMonitor.Dispose (); } }
public static void ExecuteProject(DubProject prj,IProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration, string dubVerb = "run") { bool isDebug = context.ExecutionHandler.GetType ().Name.StartsWith ("Debug"); var conf = prj.GetConfiguration(configuration) as DubProjectConfiguration; IConsole console; if (conf.ExternalConsole) console = context.ExternalConsoleFactory.CreateConsole(!conf.PauseConsoleOutput); else console = context.ConsoleFactory.CreateConsole(true); var operationMonitor = new AggregatedOperationMonitor(monitor); var sr = new StringBuilder(); if (!isDebug) { sr.Append (dubVerb); BuildCommonArgAppendix (sr, prj, configuration); } try { var cmd = isDebug ? prj.CreateExecutionCommand(configuration) : new NativeExecutionCommand(DubSettings.Instance.DubCommand, sr.ToString(), prj.BaseDirectory.ToString()); if (!context.ExecutionHandler.CanExecute(cmd)) { monitor.ReportError("Cannot execute \"" + cmd.Command + " " + cmd.Arguments + "\". The selected execution mode is not supported for Dub projects.", null); return; } var op = context.ExecutionHandler.Execute(cmd, console); operationMonitor.AddOperation(op); op.WaitForCompleted(); if(op.ExitCode != 0) monitor.ReportError(cmd.Command+" exited with code: "+op.ExitCode.ToString(), null); else monitor.Log.WriteLine(cmd.Command+" exited with code: {0}", op.ExitCode); } catch (Exception ex) { monitor.ReportError("Cannot execute \"" + sr.ToString() + "\"", ex); } finally { operationMonitor.Dispose(); console.Dispose(); } }
internal static void ExecuteProject(DubProject prj,IProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration) { var conf = prj.GetConfiguration(configuration) as DubProjectConfiguration; IConsole console; if (conf.ExternalConsole) console = context.ExternalConsoleFactory.CreateConsole(!conf.PauseConsoleOutput); else console = context.ConsoleFactory.CreateConsole(true); var operationMonitor = new AggregatedOperationMonitor(monitor); var sr = new StringBuilder("run"); Instance.BuildCommonArgAppendix(sr, prj, configuration); try { var cmd = new NativeExecutionCommand(Instance.DubExecutable, sr.ToString(), prj.BaseDirectory.ToString()); if (!context.ExecutionHandler.CanExecute(cmd)) { monitor.ReportError("Cannot execute \"" + "\". The selected execution mode is not supported for Dub projects.", null); return; } var op = context.ExecutionHandler.Execute(cmd, console); operationMonitor.AddOperation(op); op.WaitForCompleted(); monitor.Log.WriteLine(Instance.DubExecutable+" exited with code: {0}", op.ExitCode); } catch (Exception ex) { monitor.ReportError("Cannot execute \"" + sr.ToString() + "\"", ex); } finally { operationMonitor.Dispose(); console.Dispose(); } }
// do this directly instead of relying on the commands handler // to stop MD from opening an output pad protected override void DoExecute (IProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration) { var conf = (MoonlightProjectConfiguration) GetConfiguration (configuration); IConsole console = null; try { // The MoonlightExecutionHandler doesn't output anything to a console, so special-case it // Other handlers, like the debug handler, do need a console, so we still need to create one in that case // HACK: we can't get the type of the MoonlightExecutionHandler directly, so for now assume that // we don't want to show a console for DefaultExecutionHandler if (!(context.ExecutionHandler is MoonlightExecutionHandler) && !(context.ExecutionHandler.GetType ().Name == "DefaultExecutionHandler")) { console = conf.ExternalConsole ? context.ExternalConsoleFactory.CreateConsole (!conf.PauseConsoleOutput) : context.ConsoleFactory.CreateConsole (!conf.PauseConsoleOutput); } var cmd = CreateExecutionCommand (configuration, conf); using (var opMon = new AggregatedOperationMonitor (monitor)) { var ex = context.ExecutionHandler.Execute (cmd, console); opMon.AddOperation (ex); ex.WaitForCompleted (); } } finally { if (console != null) console.Dispose (); } }
public static void Update (ProjectFile file, bool force) { var tool = GetGenerator (file); if (tool == null) return; ProjectFile genFile = null; if (!string.IsNullOrEmpty (file.LastGenOutput)) genFile = file.Project.Files.GetFile (file.FilePath.ParentDirectory.Combine (file.LastGenOutput)); if (!force && genFile != null && File.Exists (genFile.FilePath) && File.GetLastWriteTime (file.FilePath) < File.GetLastWriteTime (genFile.FilePath)) { return; } TaskService.Errors.ClearByOwner (file); //if this file is already being run, cancel it lock (runningTasks) { IAsyncOperation runningTask; if (runningTasks.TryGetValue (file.FilePath, out runningTask)) { runningTask.Cancel (); runningTasks.Remove (file.FilePath); } } var monitor = IdeApp.Workbench.ProgressMonitors.GetToolOutputProgressMonitor (false); var result = new SingleFileCustomToolResult (); var aggOp = new AggregatedOperationMonitor (monitor); try { monitor.BeginTask (GettextCatalog.GetString ("Running generator '{0}' on file '{1}'...", file.Generator, file.Name), 1); var op = tool.Generate (monitor, file, result); runningTasks.Add (file.FilePath, op); aggOp.AddOperation (op); op.Completed += delegate { lock (runningTasks) { IAsyncOperation runningTask; if (runningTasks.TryGetValue (file.FilePath, out runningTask) && runningTask == op) { runningTasks.Remove (file.FilePath); UpdateCompleted (monitor, aggOp, file, genFile, result); } else { //it was cancelled because another was run for the same file, so just clean up aggOp.Dispose (); monitor.EndTask (); monitor.ReportWarning (GettextCatalog.GetString ("Cancelled because generator ran again for the same file")); monitor.Dispose (); } } }; } catch (Exception ex) { result.UnhandledException = ex; UpdateCompleted (monitor, aggOp, file, genFile, result); } }
public static void Run(HaxeProject project, HaxeProjectConfiguration configuration, IProgressMonitor monitor, ExecutionContext context) { ExecutionCommand cmd = CreateExecutionCommand (project, configuration); if (cmd is NativeExecutionCommand) { IConsole console; if (configuration.ExternalConsole) console = context.ExternalConsoleFactory.CreateConsole (false); else console = context.ConsoleFactory.CreateConsole (false); AggregatedOperationMonitor operationMonitor = new AggregatedOperationMonitor (monitor); try { if (!context.ExecutionHandler.CanExecute (cmd)) { monitor.ReportError (String.Format ("Cannot execute '{0}'.", cmd.CommandString), null); return; } IProcessAsyncOperation operation = context.ExecutionHandler.Execute (cmd, console); operationMonitor.AddOperation (operation); operation.WaitForCompleted (); monitor.Log.WriteLine ("Player exited with code {0}.", operation.ExitCode); } catch (Exception) { monitor.ReportError (String.Format ("Error while executing '{0}'.", cmd.CommandString), null); } finally { operationMonitor.Dispose (); console.Dispose (); } } else { Process.Start (cmd.CommandString); } }
void DoExecuteWithExe(IProgressMonitor monitor, ExecutionContext context, string exe, HaxeProjectConfiguration configuration) { monitor.Log.WriteLine("Running project using '{0}' ...", exe); if (string.IsNullOrEmpty(exe)) { monitor.ReportError(String.Format("No custom player or browser configured."), null); return; } string[] parts = exe.Split(' '); string args = "file://"+Path.GetFullPath(Path.Combine(configuration.OutputDirectory, configuration.OutputFileName)); if (parts.Length > 1) args = string.Join(" ", parts, 1, parts.Length-1) + " " + args; exe = parts[0]; IConsole console; if (configuration.ExternalConsole) console = context.ExternalConsoleFactory.CreateConsole(false); else console = context.ConsoleFactory.CreateConsole(false); AggregatedOperationMonitor operationMonitor = new AggregatedOperationMonitor(monitor); try { NativeExecutionCommand cmd = new NativeExecutionCommand(exe); cmd.Arguments = args; cmd.WorkingDirectory = Path.GetFullPath(configuration.OutputDirectory); if (!context.ExecutionHandler.CanExecute(cmd)) { monitor.ReportError(String.Format("Cannot execute '{0} {1}'.", exe, args), null); return; } IProcessAsyncOperation operation = context.ExecutionHandler.Execute(cmd, console); operationMonitor.AddOperation(operation); operation.WaitForCompleted(); monitor.Log.WriteLine("Player exited with code {0}.", operation.ExitCode); } catch (Exception) { monitor.ReportError(String.Format("Error while executing '{0} {1}'.", exe, args), null); } finally { operationMonitor.Dispose(); console.Dispose(); } }
protected override void OnExecute (IProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configSel) { var conf = (MonoDroidProjectConfiguration) GetConfiguration (configSel); if (NeedsBuilding (configSel)) { monitor.ReportError ( GettextCatalog.GetString ("Mono for Android projects must be built before uploading"), null); return; } IConsole console = null; var opMon = new AggregatedOperationMonitor (monitor); try { var handler = context.ExecutionHandler as MonoDroidExecutionHandler; bool useHandlerDevice = handler != null && handler.DeviceTarget != null; AndroidDevice device = null; if (useHandlerDevice) { device = handler.DeviceTarget; } else { var deviceId = GetDeviceTarget (conf); if (deviceId != null) device = MonoDroidFramework.DeviceManager.GetDevice (deviceId); if (device == null) SetDeviceTarget (conf, null); } var uploadOp = MonoDroidUtility.SignAndUpload (monitor, this, configSel, false, ref device); //user cancelled device selection if (device == null) return; opMon.AddOperation (uploadOp); uploadOp.WaitForCompleted (); if (!uploadOp.Success || monitor.IsCancelRequested) return; //get the activity name after signing produced the final manifest string activity; if (!GetActivityNameFromManifest (monitor, conf, out activity)) return; //successful, persist the device choice if (!useHandlerDevice) SetDeviceTarget (conf, device.ID); var command = (MonoDroidExecutionCommand) CreateExecutionCommand (configSel, conf); command.Device = device; command.Activity = activity; //FIXME: would be nice to skip this if it's a debug handler, which will set another value later var propOp = MonoDroidFramework.Toolbox.SetProperty (device, "debug.mono.extra", string.Empty); opMon.AddOperation (propOp); propOp.WaitForCompleted (); if (!propOp.Success) { monitor.ReportError (GettextCatalog.GetString ("Count not clear debug settings on device"), propOp.Error); return; } console = context.ConsoleFactory.CreateConsole (false); var executeOp = context.ExecutionHandler.Execute (command, console); opMon.AddOperation (executeOp); executeOp.WaitForCompleted (); } finally { opMon.Dispose (); if (console != null) console.Dispose (); } }
/// <summary> /// Executes a file and reports events related to the execution to the 'monitor' passed in the parameters. /// </summary> static int ExecuteCommand( string command, string args, string baseDirectory, IProgressMonitor monitor, out string errorOutput, out string programOutput) { errorOutput = string.Empty; int exitCode = -1; var swError = new StringWriter (); var swOutput = new StringWriter (); var chainedError = new LogTextWriter (); chainedError.ChainWriter (monitor.Log); chainedError.ChainWriter (swError); var chainedOutput = new LogTextWriter (); chainedOutput.ChainWriter (monitor.Log); chainedOutput.ChainWriter (swOutput); monitor.Log.WriteLine ("{0} {1}", command, args); var operationMonitor = new AggregatedOperationMonitor (monitor); var p = Runtime.ProcessService.StartProcess (command, args, baseDirectory, chainedOutput, chainedError, null); operationMonitor.AddOperation (p); //handles cancellation p.WaitForOutput (); errorOutput = swError.ToString (); programOutput = swOutput.ToString (); exitCode = p.ExitCode; p.Dispose (); if (monitor.IsCancelRequested) { monitor.Log.WriteLine (GettextCatalog.GetString ("Build cancelled")); monitor.ReportError (GettextCatalog.GetString ("Build cancelled"), null); if (exitCode == 0) exitCode = -1; } { chainedError.Close (); swError.Close (); operationMonitor.Dispose (); } return exitCode; }
void ExecuteWithNode(TypeScriptProject project, TypeScriptProjectConfiguration conf, IProgressMonitor monitor, ExecutionContext context) { if (console != null) console.Dispose (); var exe = GetNodePath (); bool pause = conf.PauseConsoleOutput; monitor.Log.WriteLine ("Running project..."); if (conf.ExternalConsole) console = context.ExternalConsoleFactory.CreateConsole (!pause); else console = context.ConsoleFactory.CreateConsole (!pause); AggregatedOperationMonitor operationMonitor = new AggregatedOperationMonitor (monitor); try { var cmd = CreateExecutionCommand (conf); if (!context.ExecutionHandler.CanExecute (cmd)) { monitor.ReportError ("Cannot execute \"" + exe + "\". The selected execution mode is not supported for TypeScript projects.", null); return; } IProcessAsyncOperation op = context.ExecutionHandler.Execute (cmd, console); operationMonitor.AddOperation (op); op.WaitForCompleted (); monitor.Log.WriteLine ("The operation exited with code: {0}", op.ExitCode); } catch (Exception ex) { monitor.ReportError ("Cannot execute \"" + exe + "\"", ex); } finally { operationMonitor.Dispose (); console.Dispose (); } }
protected void RunFuseCommand (IProgressMonitor monitor, string command, string args) { LoggingService.LogInfo ("Running FUSE command: {0} {1}", command, args); var log = new StringWriter (); var psi = new System.Diagnostics.ProcessStartInfo (command, args) { RedirectStandardError = true, RedirectStandardOutput = true, UseShellExecute = false, }; using (var opMon = new AggregatedOperationMonitor (monitor)) { using (var pWrapper = MonoDevelop.Core.Runtime.ProcessService.StartProcess (psi, log, log, null)) { opMon.AddOperation (pWrapper); pWrapper.WaitForOutput (); if (pWrapper.ExitCode != 0) throw new Exception (log.ToString ()); } } }
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 (); } } }
protected override void DoExecute (IProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration) { //check XSP is available var cfg = GetConfiguration (configuration); var cmd = CreateExecutionCommand (configuration, cfg); var browserExcTarget = (BrowserExecutionTarget) context.ExecutionTarget; IConsole console = null; var operationMonitor = new AggregatedOperationMonitor (monitor); bool isXsp = true; //FIXME: fix this when it might not be true - should delegate to the ExecutionHandler try { //HACK: check XSP exists first, because error UX is cleaner w/o displaying a blank console pad. if (isXsp) { try { AspNetExecutionHandler.GetXspPath ((AspNetExecutionCommand)cmd); } catch (UserException ex) { MessageService.ShowError ( GettextCatalog.GetString ("Could not launch ASP.NET web server"), ex.Message); throw; } } if (cfg.ExternalConsole) console = context.ExternalConsoleFactory.CreateConsole (!cfg.PauseConsoleOutput); else console = context.ConsoleFactory.CreateConsole (!cfg.PauseConsoleOutput); // The running Port value is now captured in the XspBrowserLauncherConsole object string url = String.Format ("http://{0}", XspParameters.Address); if (isXsp) { console = new XspBrowserLauncherConsole (console, delegate (string port) { if (browserExcTarget != null) browserExcTarget.DesktopApp.Launch (String.Format("{0}:{1}", url, port)); else BrowserLauncher.LaunchDefaultBrowser (String.Format("{0}:{1}", url, port)); }); } monitor.Log.WriteLine ("Running web server..."); var op = context.ExecutionHandler.Execute (cmd, console); operationMonitor.AddOperation (op); //handles cancellation if (!isXsp) { if (browserExcTarget != null) browserExcTarget.DesktopApp.Launch (url); else BrowserLauncher.LaunchDefaultBrowser (url); } op.WaitForCompleted (); monitor.Log.WriteLine ("The web server exited with code: {0}", op.ExitCode); } catch (Exception ex) { if (!(ex is UserException)) { LoggingService.LogError ("Could not launch ASP.NET web server.", ex); } monitor.ReportError ("Could not launch web server.", ex); } finally { operationMonitor.Dispose (); if (console != null) console.Dispose (); } }
protected override void Run () { var proj = DefaultUploadToDeviceHandler.GetActiveExecutableIPhoneProject (); var conf = (IPhoneProjectConfiguration)proj.GetConfiguration (IdeApp.Workspace.ActiveConfiguration); IdeApp.ProjectOperations.Build (proj).Completed += delegate (IAsyncOperation op) { if (!op.Success) { MessageService.ShowError ( GettextCatalog.GetString ("Cannot zip app bundle"), GettextCatalog.GetString ("Project did not build successfully")); return; } var dlg = new MonoDevelop.Components.SelectFileDialog ( GettextCatalog.GetString ("Save zipped app bundle"), Gtk.FileChooserAction.Save); dlg.InitialFileName = string.Format ("{0}-{1}.zip", conf.CompiledOutputName.FileNameWithoutExtension, proj.BundleVersion); dlg.DefaultFilter = dlg.AddFilter ("Zip file", "*.zip"); if (!dlg.Run ()) return; var zipFile = dlg.SelectedFile; var builder = new ProcessArgumentBuilder (); builder.Add ("-r", "-y"); builder.AddQuoted (zipFile); builder.AddQuoted (conf.AppDirectory.FileName); var cmd = builder.ToString (); var workingDirectory = conf.AppDirectory.ParentDirectory; new System.Threading.Thread (delegate () { IProgressMonitor monitor = null; AggregatedOperationMonitor opMon = null; IProcessAsyncOperation procOp = null; try { monitor = IdeApp.Workbench.ProgressMonitors.GetOutputProgressMonitor ( GettextCatalog.GetString ("Zip App Bundle"), MonoDevelop.Ide.Gui.Stock.RunProgramIcon, true, true); monitor.BeginTask (GettextCatalog.GetString ("Zipping app bundle"), 0); var console = (IConsole) monitor; console.Log.WriteLine ("zip " + cmd); //don't use StartConsoleProcess, it disposes the pad procOp = Runtime.ProcessService.StartProcess ( "zip", cmd, workingDirectory, console.Out, console.Error, null); opMon = new AggregatedOperationMonitor (monitor, procOp); procOp.WaitForCompleted (); monitor.EndTask (); if (procOp.ExitCode != 0) monitor.ReportError (GettextCatalog.GetString ("Failed to zip app"), null); else monitor.ReportSuccess (GettextCatalog.GetString ("Saved zipped app to '{0}'", zipFile)); } catch (Exception ex) { LoggingService.LogError ("Error in app zipper", ex); //be super-safe, crashing thread crashes whole app try { monitor.ReportError ("App zipping failed", ex); } catch {} } if (opMon != null) opMon.Dispose (); if (procOp != null) procOp.Dispose (); if (monitor != null) monitor.Dispose (); }).Start (); }; }
protected override void DoExecute(IProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration) { bool executeCustomCommand = ExtendedConfiguration != null && !string.IsNullOrWhiteSpace(ExtendedConfiguration.RunCommand); var conf = GetConfiguration (configuration) as DProjectConfiguration; if (conf == null) return; if (!conf.UnittestMode && (conf.CompileTarget != DCompileTarget.Executable || executeCustomCommand)) { MessageService.ShowMessage ("Compile target is not an executable!"); return; } bool pause = conf.PauseConsoleOutput; IConsole console; if (conf.ExternalConsole) console = context.ExternalConsoleFactory.CreateConsole (!pause); else console = context.ConsoleFactory.CreateConsole (!pause); monitor.Log.WriteLine("Running project..."); var operationMonitor = new AggregatedOperationMonitor (monitor); try { var cmd = CreateExecutionCommand(configuration); if (!context.ExecutionHandler.CanExecute (cmd)) { monitor.ReportError ("Cannot execute \"" + conf.Output + "\". The selected execution mode is not supported for D projects.", null); return; } var op = context.ExecutionHandler.Execute (cmd, console); operationMonitor.AddOperation (op); op.WaitForCompleted (); if(op.ExitCode != 0) monitor.ReportError(cmd.Command+" exited with code: "+op.ExitCode.ToString(), null); else monitor.Log.WriteLine(cmd.Command+" exited with code: {0}", op.ExitCode); } catch (Exception ex) { monitor.ReportError ("Cannot execute \"" + conf.Output + "\"", ex); } finally { operationMonitor.Dispose (); console.Dispose (); } if(ProfilerModeHandler.IsProfilerMode && Compiler.HasProfilerSupport) IdeApp.CommandService.DispatchCommand( "MonoDevelop.D.Profiler.Commands.ProfilerCommands.AnalyseTaceLog"); }
public static void Run(NMEProject project, NMEProjectConfiguration configuration, IProgressMonitor monitor, ExecutionContext context) { string exe = "haxelib"; string args = "run nme run " + project.TargetNMMLFile + " " + configuration.Platform.ToLower (); if (configuration.DebugMode) { args += " -debug"; } if (project.AdditionalArguments != "") { args += " " + project.AdditionalArguments; } if (configuration.AdditionalArguments != "") { args += " " + configuration.AdditionalArguments; } IConsole console; if (configuration.ExternalConsole) console = context.ExternalConsoleFactory.CreateConsole (false); else console = context.ConsoleFactory.CreateConsole (false); AggregatedOperationMonitor operationMonitor = new AggregatedOperationMonitor (monitor); try { NativeExecutionCommand cmd = new NativeExecutionCommand (exe); cmd.Arguments = args; cmd.WorkingDirectory = project.BaseDirectory.FullPath; if (!context.ExecutionHandler.CanExecute (cmd)) { monitor.ReportError (String.Format ("Cannot execute '{0} {1}'.", exe, args), null); return; } IProcessAsyncOperation operation = context.ExecutionHandler.Execute (cmd, console); operationMonitor.AddOperation (operation); operation.WaitForCompleted (); monitor.Log.WriteLine ("Player exited with code {0}.", operation.ExitCode); } catch (Exception) { monitor.ReportError (String.Format ("Error while executing '{0} {1}'.", exe, args), null); } finally { operationMonitor.Dispose (); console.Dispose (); } }
static void UpdateCompleted (IProgressMonitor monitor, AggregatedOperationMonitor aggOp, ProjectFile file, ProjectFile genFile, SingleFileCustomToolResult result) { monitor.EndTask (); aggOp.Dispose (); if (monitor.IsCancelRequested) { monitor.ReportError (GettextCatalog.GetString ("Cancelled"), null); monitor.Dispose (); return; } string genFileName; try { bool broken = false; if (result.UnhandledException != null) { broken = true; string msg = GettextCatalog.GetString ("The '{0}' code generator crashed", file.Generator); result.Errors.Add (new CompilerError (file.Name, 0, 0, "", msg + ": " + result.UnhandledException.Message)); monitor.ReportError (msg, result.UnhandledException); LoggingService.LogError (msg, result.UnhandledException); } genFileName = result.GeneratedFilePath.IsNullOrEmpty? null : result.GeneratedFilePath.ToRelative (file.FilePath.ParentDirectory); bool validName = !string.IsNullOrEmpty (genFileName) && genFileName.IndexOfAny (new char[] { '/', '\\' }) < 0 && FileService.IsValidFileName (genFileName); if (!broken && !validName) { broken = true; string msg = GettextCatalog.GetString ("The '{0}' code generator output invalid filename '{1}'", file.Generator, result.GeneratedFilePath); result.Errors.Add (new CompilerError (file.Name, 0, 0, "", msg)); monitor.ReportError (msg, null); } if (result.Errors.Count > 0) { foreach (CompilerError err in result.Errors) TaskService.Errors.Add (new Task (file.FilePath, err.ErrorText, err.Column, err.Line, err.IsWarning? TaskSeverity.Warning : TaskSeverity.Error, TaskPriority.Normal, file.Project.ParentSolution, file)); } if (broken) return; if (result.Success) monitor.ReportSuccess ("Generated file successfully."); else monitor.ReportError ("Failed to generate file. See error pad for details.", null); } finally { monitor.Dispose (); } if (!result.GeneratedFilePath.IsNullOrEmpty && File.Exists (result.GeneratedFilePath)) { Gtk.Application.Invoke (delegate { if (genFile == null) { genFile = file.Project.AddFile (result.GeneratedFilePath); } else if (result.GeneratedFilePath != genFile.FilePath) { genFile.Name = result.GeneratedFilePath; } file.LastGenOutput = genFileName; genFile.DependsOn = file.FilePath.FileName; IdeApp.ProjectOperations.Save (file.Project); }); } }
//copied from MoonlightBuildExtension public static int ExecuteCommand (IProgressMonitor monitor, System.Diagnostics.ProcessStartInfo startInfo, out string errorOutput) { startInfo.UseShellExecute = false; startInfo.RedirectStandardError = true; startInfo.RedirectStandardOutput = true; errorOutput = string.Empty; int exitCode = -1; var swError = new StringWriter (); var chainedError = new LogTextWriter (); chainedError.ChainWriter (monitor.Log); chainedError.ChainWriter (swError); var operationMonitor = new AggregatedOperationMonitor (monitor); try { var p = Runtime.ProcessService.StartProcess (startInfo, monitor.Log, chainedError, null); operationMonitor.AddOperation (p); //handles cancellation p.WaitForOutput (); errorOutput = swError.ToString (); exitCode = p.ExitCode; p.Dispose (); if (monitor.IsCancelRequested) { monitor.Log.WriteLine (GettextCatalog.GetString ("Build cancelled")); monitor.ReportError (GettextCatalog.GetString ("Build cancelled"), null); if (exitCode == 0) exitCode = -1; } } finally { chainedError.Close (); swError.Close (); operationMonitor.Dispose (); } return exitCode; }
protected override void OnExecute(IProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configSel) { var conf = (MonoBrickProjectConfiguration)GetConfiguration(configSel); var cmd = (MonoBrickExecutionCommand)CreateExecutionCommand(configSel, conf); bool debugExecution = !(context.ExecutionHandler is MonoBrickExecutionHandler); var runtime = conf.TargetRuntime; if (runtime.RuntimeId != "Mono" && debugExecution) { monitor.ReportError("You must use the Mono runtime for debugging!", null); return; } using (var opMon = new AggregatedOperationMonitor(monitor)) { IConsole console = null; try { console = conf.ExternalConsole ? context.ExternalConsoleFactory.CreateConsole(!conf.PauseConsoleOutput) : context.ConsoleFactory.CreateConsole(!conf.PauseConsoleOutput); cmd.Console = console; if (!MonoBrickUtility.GetEV3Configuration(console)) { string configError = "Invalid EV3 configuration. Check Preferences->MonoBrick for correct settings!"; console.Log.WriteLine(configError); monitor.ReportError(configError, null); return; } console.Log.WriteLine("Upload to brick..."); string EV3IPAddress = UserSettings.Instance.IPAddress; var uploadOp = MonoBrickUtility.Upload(EV3IPAddress, cmd); opMon.AddOperation(uploadOp); uploadOp.WaitForCompleted(); if (!uploadOp.Success) { console.Log.WriteLine(uploadOp.ErrorMessage); monitor.ReportError(uploadOp.ErrorMessage, null); return; } console.Log.WriteLine("Running on brick..."); var ex = context.ExecutionHandler.Execute(cmd, console); opMon.AddOperation(ex); ex.WaitForCompleted(); console.Log.WriteLine(""); console.Log.WriteLine("Finished!"); } finally { if (console != null) console.Dispose(); } } }
static bool UpdateCompleted (IProgressMonitor monitor, AggregatedOperationMonitor aggOp, ProjectFile file, ProjectFile genFile, SingleFileCustomToolResult result, bool runMultipleFiles) { monitor.EndTask (); if (aggOp != null) aggOp.Dispose (); if (monitor.IsCancelRequested) { monitor.ReportError (GettextCatalog.GetString ("Cancelled"), null); monitor.Dispose (); return false; } string genFileName; try { bool broken = false; if (result.UnhandledException != null) { broken = true; string msg = GettextCatalog.GetString ("The '{0}' code generator crashed", file.Generator); result.Errors.Add (new CompilerError (file.Name, 0, 0, "", msg + ": " + result.UnhandledException.Message)); monitor.ReportError (msg, result.UnhandledException); LoggingService.LogError (msg, result.UnhandledException); } genFileName = result.GeneratedFilePath.IsNullOrEmpty? null : result.GeneratedFilePath.ToRelative (file.FilePath.ParentDirectory); if (!string.IsNullOrEmpty (genFileName)) { bool validName = genFileName.IndexOfAny (new [] { '/', '\\' }) < 0 && FileService.IsValidFileName (genFileName); if (!broken && !validName) { broken = true; string msg = GettextCatalog.GetString ("The '{0}' code generator output invalid filename '{1}'", file.Generator, result.GeneratedFilePath); result.Errors.Add (new CompilerError (file.Name, 0, 0, "", msg)); monitor.ReportError (msg, null); } } if (result.Errors.Count > 0) { DispatchService.GuiDispatch (delegate { foreach (CompilerError err in result.Errors) TaskService.Errors.Add (new Task (file.FilePath, err.ErrorText, err.Column, err.Line, err.IsWarning? TaskSeverity.Warning : TaskSeverity.Error, TaskPriority.Normal, file.Project.ParentSolution, file)); }); } if (broken) return true; if (!runMultipleFiles) { if (result.Success) monitor.ReportSuccess ("Generated file successfully."); else if (result.SuccessWithWarnings) monitor.ReportSuccess ("Warnings in file generation."); else monitor.ReportError ("Errors in file generation.", null); } } finally { if (!runMultipleFiles) monitor.Dispose (); } if (result.GeneratedFilePath.IsNullOrEmpty || !File.Exists (result.GeneratedFilePath)) return true; // broadcast a change event so text editors etc reload the file FileService.NotifyFileChanged (result.GeneratedFilePath); // add file to project, update file properties, etc Gtk.Application.Invoke (delegate { bool projectChanged = false; if (genFile == null) { genFile = file.Project.AddFile (result.GeneratedFilePath, result.OverrideBuildAction); projectChanged = true; } else if (result.GeneratedFilePath != genFile.FilePath) { genFile.Name = result.GeneratedFilePath; projectChanged = true; } if (file.LastGenOutput != genFileName) { file.LastGenOutput = genFileName; projectChanged = true; } if (genFile.DependsOn != file.FilePath.FileName) { genFile.DependsOn = file.FilePath.FileName; projectChanged = true; } if (projectChanged) IdeApp.ProjectOperations.Save (file.Project); }); return true; }
protected override void OnExecute (IProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configSel) { var conf = (MonoDroidProjectConfiguration) GetConfiguration (configSel); if (NeedsBuilding (configSel)) { monitor.ReportError ( GettextCatalog.GetString ("MonoDroid projects must be built before uploading"), null); return; } var manifestFile = conf.ObjDir.Combine ("android", "AndroidManifest.xml"); if (!File.Exists (manifestFile)) { monitor.ReportError ("Intermediate manifest file is missing", null); return; } var manifest = AndroidAppManifest.Load (manifestFile); var activity = manifest.GetLaunchableActivityName (); if (string.IsNullOrEmpty (activity)) { monitor.ReportError ("Application does not contain a launchable activity", null); return; } activity = manifest.PackageName + "/" + activity; IConsole console = null; var opMon = new AggregatedOperationMonitor (monitor); try { var handler = context.ExecutionHandler as MonoDroidExecutionHandler; bool useHandlerDevice = handler != null && handler.DeviceTarget != null; AndroidDevice device = null; if (useHandlerDevice) { device = handler.DeviceTarget; } else { var deviceId = GetDeviceTarget (conf); if (deviceId != null) device = MonoDroidFramework.DeviceManager.GetDevice (deviceId); if (device == null) SetDeviceTarget (conf, null); } var uploadOp = MonoDroidUtility.SignAndUpload (monitor, this, configSel, false, ref device); //user cancelled device selection if (device == null) return; opMon.AddOperation (uploadOp); uploadOp.WaitForCompleted (); if (!uploadOp.Success || monitor.IsCancelRequested) return; //successful, persist the device choice if (!useHandlerDevice) SetDeviceTarget (conf, device.ID); var command = (MonoDroidExecutionCommand) CreateExecutionCommand (configSel, conf); command.Device = device; command.Activity = activity; //FIXME: would be nice to skip this if it's a debug handler, which will set another value later var propOp = MonoDroidFramework.Toolbox.SetProperty (device, "debug.mono.extra", string.Empty); opMon.AddOperation (propOp); propOp.WaitForCompleted (); if (!propOp.Success) { monitor.ReportError (GettextCatalog.GetString ("Count not clear debug settings on device"), propOp.Error); return; } console = context.ConsoleFactory.CreateConsole (false); var executeOp = context.ExecutionHandler.Execute (command, console); opMon.AddOperation (executeOp); executeOp.WaitForCompleted (); } finally { opMon.Dispose (); if (console != null) console.Dispose (); } }
protected override void DoExecute (IProgressMonitor monitor, ExecutionContext context) { CProjectConfiguration conf = (CProjectConfiguration)ActiveConfiguration; string command = conf.Output; string args = conf.CommandLineParameters; string dir = Path.GetFullPath (conf.OutputDirectory); string platform = "Native"; bool pause = conf.PauseConsoleOutput; IConsole console; if (conf.CompileTarget != CBinding.CompileTarget.Bin) { IdeApp.Services.MessageService.ShowMessage ("Compile target is not an executable!"); return; } monitor.Log.WriteLine ("Running project..."); if (conf.ExternalConsole) console = context.ExternalConsoleFactory.CreateConsole (!pause); else console = context.ConsoleFactory.CreateConsole (!pause); AggregatedOperationMonitor operationMonitor = new AggregatedOperationMonitor (monitor); try { IExecutionHandler handler = context.ExecutionHandlerFactory.CreateExecutionHandler (platform); if (handler == null) { monitor.ReportError ("Cannot execute \"" + command + "\". The selected execution mode is not supported in the " + platform + " platform.", null); return; } IProcessAsyncOperation op = handler.Execute (Path.Combine (dir, command), args, dir, console); operationMonitor.AddOperation (op); op.WaitForCompleted (); monitor.Log.WriteLine ("The operation exited with code: {0}", op.ExitCode); } catch (Exception ex) { monitor.ReportError ("Cannot execute \"" + command + "\"", ex); } finally { operationMonitor.Dispose (); console.Dispose (); } }
public static void Update (ProjectFile file, bool force) { ISingleFileCustomTool tool; ProjectFile genFile; if (!ShouldRunGenerator (file, force, out tool, out genFile)) { return; } TaskService.Errors.ClearByOwner (file); //if this file is already being run, cancel it lock (runningTasks) { IAsyncOperation runningTask; if (runningTasks.TryGetValue (file.FilePath, out runningTask)) { runningTask.Cancel (); runningTasks.Remove (file.FilePath); } } var monitor = IdeApp.Workbench.ProgressMonitors.GetToolOutputProgressMonitor (false); var result = new SingleFileCustomToolResult (); var aggOp = new AggregatedOperationMonitor (monitor); try { monitor.BeginTask (GettextCatalog.GetString ("Running generator '{0}' on file '{1}'...", file.Generator, file.Name), 1); IAsyncOperation op = tool.Generate (monitor, file, result); runningTasks.Add (file.FilePath, op); aggOp.AddOperation (op); op.Completed += delegate { lock (runningTasks) { IAsyncOperation runningTask; if (runningTasks.TryGetValue (file.FilePath, out runningTask) && runningTask == op) { runningTasks.Remove (file.FilePath); UpdateCompleted (monitor, aggOp, file, genFile, result, false); } else { //it was cancelled because another was run for the same file, so just clean up aggOp.Dispose (); monitor.EndTask (); monitor.ReportWarning (GettextCatalog.GetString ("Cancelled because generator ran again for the same file")); monitor.Dispose (); } } }; } catch (Exception ex) { result.UnhandledException = ex; UpdateCompleted (monitor, aggOp, file, genFile, result, false); } }
protected override void DoExecute(IProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration) { RubyProjectConfiguration conf = (RubyProjectConfiguration)GetConfiguration (configuration); bool pause = conf.PauseConsoleOutput; IConsole console = (conf.ExternalConsole? context.ExternalConsoleFactory: context.ConsoleFactory).CreateConsole (!pause); List<string> loadPaths = new List<string> (); loadPaths.Add (BaseDirectory.FullPath); foreach (object path in conf.LoadPaths) { if (!string.IsNullOrEmpty ((string)path)){ loadPaths.Add ((string)path); } } ExecutionCommand cmd = new NativeExecutionCommand (RubyLanguageBinding.RubyInterpreter, conf.MainFile, BaseDirectory.FullPath, new Dictionary<string,string>(){{"RUBYLIB", string.Join (Path.DirectorySeparatorChar.ToString(), loadPaths.ToArray ()) }}); monitor.Log.WriteLine ("Running {0} {1}", RubyLanguageBinding.RubyInterpreter, conf.MainFile); AggregatedOperationMonitor operationMonitor = new AggregatedOperationMonitor (monitor); try { if (!context.ExecutionHandler.CanExecute (cmd)) { monitor.ReportError (string.Format ("Cannot execute {0}.", conf.MainFile), null); return; } IProcessAsyncOperation op = context.ExecutionHandler.Execute (cmd, console); operationMonitor.AddOperation (op); op.WaitForCompleted (); monitor.Log.WriteLine ("The operation exited with code: {0}", op.ExitCode); } catch (Exception ex) { monitor.ReportError (string.Format ("Cannot execute {0}.", conf.MainFile), ex); } finally { operationMonitor.Dispose (); console.Dispose (); } }
protected override void DoExecute(IProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration) { var conf = GetConfiguration (configuration) as DProjectConfiguration; if (conf == null) return; bool pause = conf.PauseConsoleOutput; IConsole console; if (conf.CompileTarget != DCompileTarget.Executable) { MessageService.ShowMessage ("Compile target is not an executable!"); return; } monitor.Log.WriteLine ("Running project..."); if (conf.ExternalConsole) console = context.ExternalConsoleFactory.CreateConsole (!pause); else console = context.ConsoleFactory.CreateConsole (!pause); var operationMonitor = new AggregatedOperationMonitor (monitor); try { var cmd = CreateExecutionCommand (conf); if (!context.ExecutionHandler.CanExecute (cmd)) { monitor.ReportError ("Cannot execute \"" + conf.Output + "\". The selected execution mode is not supported for D projects.", null); return; } var op = context.ExecutionHandler.Execute (cmd, console); operationMonitor.AddOperation (op); op.WaitForCompleted (); monitor.Log.WriteLine ("The operation exited with code: {0}", op.ExitCode); } catch (Exception ex) { monitor.ReportError ("Cannot execute \"" + conf.Output + "\"", ex); } finally { operationMonitor.Dispose (); console.Dispose (); } }
protected override void OnExecute (IProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configSel) { var conf = (MonoDroidProjectConfiguration) GetConfiguration (configSel); if (NeedsBuilding (configSel)) { monitor.ReportError ( GettextCatalog.GetString ("MonoDroid projects must be built before uploading"), null); return; } var manifestFile = conf.ObjDir.Combine ("android", "AndroidManifest.xml"); if (!File.Exists (manifestFile)) { monitor.ReportError ("Intermediate manifest file is missing", null); return; } var manifest = AndroidAppManifest.Load (manifestFile); var activity = manifest.GetLaunchableActivityName (); if (string.IsNullOrEmpty (activity)) { monitor.ReportError ("Application does not contain a launchable activity", null); return; } activity = manifest.PackageName + "/" + activity; var opMon = new AggregatedOperationMonitor (monitor); try { AndroidDevice device; var uploadOp = MonoDroidUtility.SignAndUpload (monitor, this, configSel, false, out device); opMon.AddOperation (uploadOp); uploadOp.WaitForCompleted (); if (!uploadOp.Success) return; var command = (MonoDroidExecutionCommand) CreateExecutionCommand (configSel, conf); command.Device = device; command.Activity = activity; using (var console = context.ConsoleFactory.CreateConsole (false)) { var executeOp = context.ExecutionHandler.Execute (command, console); opMon.AddOperation (executeOp); executeOp.WaitForCompleted (); } } finally { opMon.Dispose (); } }
protected override void OnExecute (IProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configSel) { var conf = (IPhoneProjectConfiguration) GetConfiguration (configSel); bool isDevice = conf.Platform == PLAT_IPHONE; if (!Directory.Exists (conf.AppDirectory) || (isDevice && !File.Exists (conf.AppDirectory.Combine ("PkgInfo")))) { Gtk.Application.Invoke (delegate { MessageService.ShowError (GettextCatalog.GetString ("The application has not been built.")); }); return; } if (isDevice) { var deviceId = "default"; if (NeedsUploading (conf, deviceId)) { using (var opMon = new AggregatedOperationMonitor (monitor)) { using (var op = IPhoneUtility.Upload (TargetRuntime, TargetFramework, conf.AppDirectory)) { opMon.AddOperation (op); op.WaitForCompleted (); if (op.ExitCode != 0) return; } TouchUploadMarker (conf, deviceId); } } } base.OnExecute (monitor, context, configSel); }
protected override void DoExecute(IProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration) { var config = GetConfiguration (configuration) as DotNetProjectConfiguration; monitor.Log.WriteLine (GettextCatalog.GetString ("Running {0} ...", Name)); IConsole console = CreateConsole (config, context); var aggregatedOperationMonitor = new AggregatedOperationMonitor (monitor); try { try { ExecutionCommand executionCommand = CreateExecutionCommand (configuration, config); if (context.ExecutionTarget != null) executionCommand.Target = context.ExecutionTarget; IProcessAsyncOperation asyncOp = new DnxExecutionHandler ().Execute (executionCommand, console); aggregatedOperationMonitor.AddOperation (asyncOp); asyncOp.WaitForCompleted (); monitor.Log.WriteLine (GettextCatalog.GetString ("The application exited with code: {0}", asyncOp.ExitCode)); } finally { console.Dispose (); aggregatedOperationMonitor.Dispose (); } } catch (Exception ex) { LoggingService.LogError (string.Format ("Cannot execute \"{0}\"", Name), ex); monitor.ReportError (GettextCatalog.GetString ("Cannot execute \"{0}\"", Name), ex); } }
protected override void DoExecute (IProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration) { DotNetProjectConfiguration dotNetProjectConfig = GetConfiguration (configuration) as DotNetProjectConfiguration; monitor.Log.WriteLine (GettextCatalog.GetString ("Running {0} ...", dotNetProjectConfig.CompiledOutputName)); IConsole console = dotNetProjectConfig.ExternalConsole ? context.ExternalConsoleFactory.CreateConsole (!dotNetProjectConfig.PauseConsoleOutput) : context.ConsoleFactory.CreateConsole (!dotNetProjectConfig.PauseConsoleOutput); AggregatedOperationMonitor aggregatedOperationMonitor = new AggregatedOperationMonitor (monitor); try { try { ExecutionCommand executionCommand = CreateExecutionCommand (configuration, dotNetProjectConfig); if (context.ExecutionTarget != null) executionCommand.Target = context.ExecutionTarget; if (!context.ExecutionHandler.CanExecute (executionCommand)) { monitor.ReportError (GettextCatalog.GetString ("Can not execute \"{0}\". The selected execution mode is not supported for .NET projects.", dotNetProjectConfig.CompiledOutputName), null); return; } IProcessAsyncOperation asyncOp = context.ExecutionHandler.Execute (executionCommand, console); aggregatedOperationMonitor.AddOperation (asyncOp); asyncOp.WaitForCompleted (); monitor.Log.WriteLine (GettextCatalog.GetString ("The application exited with code: {0}", asyncOp.ExitCode)); } finally { console.Dispose (); aggregatedOperationMonitor.Dispose (); } } catch (Exception ex) { LoggingService.LogError (string.Format ("Cannot execute \"{0}\"", dotNetProjectConfig.CompiledOutputName), ex); monitor.ReportError (GettextCatalog.GetString ("Cannot execute \"{0}\"", dotNetProjectConfig.CompiledOutputName), ex); } }
static int DoCompilation (IProgressMonitor monitor, string compilerName, string compilerArgs, string working_dir, ExecutionEnvironment envVars, List<string> gacRoots, ref string output, ref string error) { output = Path.GetTempFileName (); error = Path.GetTempFileName (); StreamWriter outwr = new StreamWriter (output); StreamWriter errwr = new StreamWriter (error); ProcessStartInfo pinfo = new ProcessStartInfo (compilerName, compilerArgs); pinfo.StandardErrorEncoding = Encoding.UTF8; pinfo.StandardOutputEncoding = Encoding.UTF8; // The "." is a workaround for a bug in ProcessStartInfo.WorkingDirectory - not able to handle null pinfo.WorkingDirectory = working_dir ?? "."; if (gacRoots.Count > 0) { // Create the gac prefix string string gacPrefix = string.Join ("" + Path.PathSeparator, gacRoots.ToArray ()); string oldGacVar = Environment.GetEnvironmentVariable ("MONO_GAC_PREFIX"); if (!string.IsNullOrEmpty (oldGacVar)) gacPrefix += Path.PathSeparator + oldGacVar; pinfo.EnvironmentVariables ["MONO_GAC_PREFIX"] = gacPrefix; } envVars.MergeTo (pinfo); pinfo.UseShellExecute = false; pinfo.RedirectStandardOutput = true; pinfo.RedirectStandardError = true; MonoDevelop.Core.Execution.ProcessWrapper pw = Runtime.ProcessService.StartProcess (pinfo, outwr, errwr, null); using (var mon = new AggregatedOperationMonitor (monitor, pw)) { pw.WaitForOutput (); } int exitCode = pw.ExitCode; bool cancelRequested = pw.CancelRequested; outwr.Close(); errwr.Close (); pw.Dispose(); return cancelRequested ? 0 : exitCode; }