protected override void OnExecute (IProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configSel)
{
var conf = (IPhoneProjectConfiguration) GetConfiguration (configSel);
bool isDevice = conf.IsDevicePlatform;
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);
}
// 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();
}
}
}
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 OnExecute(IProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configSel)
{
var conf = (IPhoneProjectConfiguration)GetConfiguration(configSel);
if (!Directory.Exists(conf.AppDirectory))
{
Gtk.Application.Invoke(delegate {
MessageService.ShowError(GettextCatalog.GetString("The application has not been built."));
});
return;
}
if (conf.Platform == PLAT_IPHONE)
{
if (NeedsUploading(conf))
{
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);
}
}
}
base.OnExecute(monitor, context, configSel);
}
internal protected override void OnExecute(IProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration)
{
ProjectConfiguration conf = (ProjectConfiguration)GetConfiguration(configuration);
monitor.Log.WriteLine(GettextCatalog.GetString("Running {0} ...", FileName));
IConsole console = conf.ExternalConsole
? context.ExternalConsoleFactory.CreateConsole(!conf.PauseConsoleOutput)
: context.ConsoleFactory.CreateConsole(!conf.PauseConsoleOutput);
AggregatedOperationMonitor aggregatedOperationMonitor = new AggregatedOperationMonitor(monitor);
try {
try {
ExecutionCommand executionCommand = CreateExecutionCommand(configuration, conf);
if (!context.ExecutionHandler.CanExecute(executionCommand))
{
monitor.ReportError(GettextCatalog.GetString("Can not execute \"{0}\". The selected execution mode is not supported for .NET projects.", FileName), 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) {
monitor.ReportError(GettextCatalog.GetString("Cannot execute \"{0}\"", FileName), ex);
}
}
public static MonoDroidPublishOperation PublishPackage(IProgressMonitor monitor, MonoDroidProject project,
ConfigurationSelector configSel, AndroidSigningOptions options, string sourceApk, string destApk,
bool createNewKey, string dName, int keyValidity)
{
var conf = project.GetConfiguration(configSel);
var opMon = new AggregatedOperationMonitor(monitor);
IAsyncOperation packageOp = null;
// If we need signing, it means we don't have the apk ready
if (project.PackageNeedsSigning(configSel))
{
ClearUploadFlags(conf);
packageOp = project.SignPackage(configSel);
opMon.AddOperation(packageOp);
}
var outputMonitor = IdeApp.Workbench.ProgressMonitors.GetOutputProgressMonitor(
GettextCatalog.GetString("Publishing package"), MonoDevelop.Ide.Gui.Stock.RunProgramIcon, true, true);
var op = new MonoDroidPublishOperation(outputMonitor, options, sourceApk, destApk, packageOp,
createNewKey, dName, keyValidity);
op.Completed += delegate {
opMon.Dispose();
outputMonitor.Dispose();
};
op.Start();
return(op);
}
protected override void DoExecute(IProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration)
{
if (!CheckCanExecute(configuration))
{
return;
}
var config = (PythonConfiguration)GetConfiguration(configuration);
IConsole console = config.ExternalConsole ?
context.ExternalConsoleFactory.CreateConsole(!config.PauseConsoleOutput) :
context.ConsoleFactory.CreateConsole(!config.PauseConsoleOutput);
var aggregatedMonitor = new AggregatedOperationMonitor(monitor);
try {
var executionCommand = CreateExecutionCommand(configuration, config);
if (!context.ExecutionHandler.CanExecute(executionCommand))
{
monitor.ReportError(GettextCatalog.GetString("Cannot execute application. The selected execution mode " +
"is not supported for IronPython projects"), null);
return;
}
var asyncOp = context.ExecutionHandler.Execute(executionCommand, console);
aggregatedMonitor.AddOperation(asyncOp);
asyncOp.WaitForCompleted();
monitor.Log.WriteLine("The application exited with code: " + asyncOp.ExitCode);
} catch (Exception exc) {
monitor.ReportError(GettextCatalog.GetString("Cannot execute \"{0}\"", config.MainModule), exc);
} finally {
console.Dispose();
aggregatedMonitor.Dispose();
}
}
internal static void ExecuteProject(DubProject prj, IProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration)
{
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("run");
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();
}
}
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 (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();
}
}
/// <summary>
/// Executes a file and reports events related to the execution to the 'monitor' passed in the parameters.
/// </summary>
public 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);
}
protected override void DoExecute(IProgressMonitor monitor, ExecutionContext context, ConfigurationSelector config)
{
//check XSP is available
var configuration = (AspNetAppProjectConfiguration)GetConfiguration(config);
var cmd = CreateExecutionCommand(config, configuration);
IConsole console = null;
var operationMonitor = new AggregatedOperationMonitor(monitor);
try {
if (configuration.ExternalConsole)
{
console = context.ExternalConsoleFactory.CreateConsole(!configuration.PauseConsoleOutput);
}
else
{
console = context.ConsoleFactory.CreateConsole(!configuration.PauseConsoleOutput);
}
string url = String.Format("http://{0}:{1}", this.XspParameters.Address, this.XspParameters.Port);
bool isXsp = true; //FIXME: fix this when it might not be true
if (isXsp)
{
console = new XspBrowserLauncherConsole(console, delegate {
BrowserLauncher.LaunchDefaultBrowser(url);
});
}
monitor.Log.WriteLine("Running web server...");
var op = context.ExecutionHandler.Execute(cmd, console);
operationMonitor.AddOperation(op); //handles cancellation
if (!isXsp)
{
BrowserLauncher.LaunchDefaultBrowser(url);
}
op.WaitForCompleted();
monitor.Log.WriteLine("The web server exited with code: {0}", op.ExitCode);
} catch (Exception ex) {
monitor.ReportError("Could not launch web server.", ex);
} finally {
operationMonitor.Dispose();
if (console != null)
{
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)
{
PythonConfiguration config;
IConsole console;
config = (PythonConfiguration)GetConfiguration(configuration);
// Make sure we have a module to execute
if (config.Runtime == null || String.IsNullOrEmpty(config.Module))
{
MessageService.ShowMessage("No target module specified!");
return;
}
monitor.Log.WriteLine("Running project...");
// Create a console, external if needed
if (config.ExternalConsole)
{
console = context.ExternalConsoleFactory.CreateConsole(!config.PauseConsoleOutput);
}
else
{
console = context.ConsoleFactory.CreateConsole(!config.PauseConsoleOutput);
}
AggregatedOperationMonitor operationMonitor = new AggregatedOperationMonitor(monitor);
try {
PythonExecutionCommand cmd = new PythonExecutionCommand(config);
if (!context.ExecutionHandler.CanExecute(cmd))
{
monitor.ReportError("The selected execution mode is not supported for Python 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 \"" + config.Runtime.Path + "\"", ex);
}
finally {
operationMonitor.Dispose();
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();
}
}
//may block while it's showing a GUI. project MUST be built before calling this
public static MonoDroidUploadOperation SignAndUpload(IProgressMonitor monitor, MonoDroidProject project,
ConfigurationSelector configSel, bool forceReplace, ref AndroidDevice device)
{
var conf = project.GetConfiguration(configSel);
var opMon = new AggregatedOperationMonitor(monitor);
InvokeSynch(() => MonoDroidFramework.EnsureSdksInstalled());
IAsyncOperation signOp = null;
if (project.PackageNeedsSigning(configSel))
{
ClearUploadFlags(conf);
signOp = project.SignPackage(configSel);
opMon.AddOperation(signOp);
}
if (device == null)
{
device = InvokeSynch(() => ChooseDevice(null));
}
if (device == null)
{
opMon.Dispose();
return(null);
}
if (!device.IsEmulator && MonoDroidFramework.CheckTrial())
{
opMon.Dispose();
return(null);
}
//copture the device for a later anonymous method
AndroidDevice dev = device;
bool replaceIfExists = forceReplace || !GetUploadFlag(conf, device);
var uploadOp = Upload(device, conf.ApkSignedPath, conf.PackageName, signOp, replaceIfExists);
opMon.AddOperation(uploadOp);
uploadOp.Completed += delegate(IAsyncOperation op) {
if (op.Success)
{
SetUploadFlag(conf, dev);
}
opMon.Dispose();
};
return(uploadOp);
}
public static void Run(HaxeProject project, HaxeProjectConfiguration configuration, IProgressMonitor monitor, ExecutionContext context)
{
ExecutionCommand cmd = CreateExecutionCommand(project, configuration);
if (cmd is HaxeExecutionCommand)
{
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.Target), 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.Target), null);
}
finally
{
operationMonitor.Dispose();
console.Dispose();
}
}
//else
//{
// Process.Start (cmd);
//}
}
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();
}
}
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);
}
//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);
}
public static IAsyncOperation Sign(IProgressMonitor monitor, MonoDroidProject project, ConfigurationSelector configSel)
{
var conf = project.GetConfiguration(configSel);
var opMon = new AggregatedOperationMonitor(monitor);
InvokeSynch(() => MonoDroidFramework.EnsureSdksInstalled());
IAsyncOperation signOp = null;
if (project.PackageNeedsSigning(configSel))
{
ClearUploadFlags(conf);
signOp = project.SignPackage(configSel);
signOp.Completed += delegate {
opMon.Dispose();
};
return(signOp);
}
return(Core.Execution.NullProcessAsyncOperation.Success);
}
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 static IAsyncOperation SignAndCopy(IProgressMonitor monitor, MonoDroidProject project,
ConfigurationSelector configSel)
{
var conf = project.GetConfiguration(configSel);
var opMon = new AggregatedOperationMonitor(monitor);
IAsyncOperation signOp = null;
if (project.PackageNeedsSigning(configSel))
{
ClearUploadFlags(conf);
signOp = project.SignPackage(configSel);
opMon.AddOperation(signOp);
}
string packageName = project.GetPackageName(conf);
string targetFile = InvokeSynch(() => ChooseApkLocation(null, project.BaseDirectory, packageName));
if (String.IsNullOrEmpty(targetFile))
{
opMon.Dispose();
return(null);
}
if (MonoDroidFramework.CheckTrial())
{
opMon.Dispose();
return(null);
}
var copy = CopyApk(signOp, conf.ApkSignedPath, targetFile);
copy.Completed += delegate {
opMon.Dispose();
};
return(copy);
}
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");
}
}
protected override void DoExecute(IProgressMonitor monitor, ExecutionContext context, ConfigurationSelector config)
{
//check XSP is available
var configuration = (AspNetAppProjectConfiguration)GetConfiguration(config);
var cmd = CreateExecutionCommand(config, configuration);
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 (configuration.ExternalConsole)
{
console = context.ExternalConsoleFactory.CreateConsole(!configuration.PauseConsoleOutput);
}
else
{
console = context.ConsoleFactory.CreateConsole(!configuration.PauseConsoleOutput);
}
string url = String.Format("http://{0}:{1}", this.XspParameters.Address, this.XspParameters.Port);
if (isXsp)
{
console = new XspBrowserLauncherConsole(console, delegate {
BrowserLauncher.LaunchDefaultBrowser(url);
});
}
monitor.Log.WriteLine("Running web server...");
var op = context.ExecutionHandler.Execute(cmd, console);
operationMonitor.AddOperation(op); //handles cancellation
if (!isXsp)
{
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();
}
}
}
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 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();
}
}
}
}
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);
}
}
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);
});
}
}
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);
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;
}
if (!device.IsEmulator && MonoDroidFramework.CheckTrial())
{
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("Could 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();
}
}
}
