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);
		}
示例#2
0
        // 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();
                }
            }
        }
示例#3
0
        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);
            }
        }
示例#4
0
        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);
            }
        }
示例#6
0
        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);
        }
示例#7
0
        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();
            }
        }
示例#8
0
        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();
            }
        }
示例#9
0
        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();
            }
        }
示例#10
0
        /// <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);
        }
示例#11
0
        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);
            }
        }
示例#13
0
        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();
            }
        }
示例#14
0
        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();
            }
        }
示例#15
0
        //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);
            //}
        }
示例#17
0
        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);
        }
示例#19
0
        //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);
        }
示例#20
0
        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);
        }
示例#23
0
        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();
                }
            }
        }
示例#25
0
        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();
                }
            }
        }
示例#26
0
        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);
        }
示例#30
0
        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();
                }
            }
        }