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;
}