internal static void InternalRun(ExecutionCommand cmd, DebuggerEngine factory, OperationConsole c) { if (factory == null) { factory = GetFactoryForCommand(cmd); if (factory == null) { throw new InvalidOperationException("Unsupported command: " + cmd); } } if (session != null) { throw new InvalidOperationException("A debugger session is already started"); } DebuggerStartInfo startInfo = factory.CreateDebuggerStartInfo(cmd); startInfo.UseExternalConsole = c is ExternalConsole; if (startInfo.UseExternalConsole) { startInfo.CloseExternalConsoleOnExit = ((ExternalConsole)c).CloseOnDispose; } currentEngine = factory; session = factory.CreateSession(); session.ExceptionHandler = ExceptionHandler; // When using an external console, create a new internal console which will be used // to show the debugger log if (startInfo.UseExternalConsole) { console = IdeApp.Workbench.ProgressMonitors.GetRunProgressMonitor().Console; } else { console = c; } SetupSession(); SetDebugLayout(); try { session.Run(startInfo, GetUserOptions()); } catch { Cleanup(); throw; } }
public async Task <bool> Execute(ProgressMonitor monitor, WorkspaceObject entry, ExecutionContext context, ConfigurationSelector configuration) { ProcessExecutionCommand cmd = CreateExecutionCommand(entry, configuration); monitor.Log.WriteLine(GettextCatalog.GetString("Executing: {0} {1}", cmd.Command, cmd.Arguments)); if (!Directory.Exists(cmd.WorkingDirectory)) { monitor.ReportError(GettextCatalog.GetString("Custom command working directory does not exist"), null); return(false); } ProcessAsyncOperation oper = null; OperationConsole console = null; var result = true; try { if (context != null) { if (externalConsole) { console = context.ExternalConsoleFactory.CreateConsole(!pauseExternalConsole, monitor.CancellationToken); } else { console = context.ConsoleFactory.CreateConsole(monitor.CancellationToken); } oper = context.ExecutionHandler.Execute(cmd, console); } else { if (externalConsole) { console = context.ExternalConsoleFactory.CreateConsole(!pauseExternalConsole, monitor.CancellationToken); oper = Runtime.ProcessService.StartConsoleProcess(cmd.Command, cmd.Arguments, cmd.WorkingDirectory, console, null); } else { oper = Runtime.ProcessService.StartProcess(cmd.Command, cmd.Arguments, cmd.WorkingDirectory, monitor.Log, monitor.Log, null, false).ProcessAsyncOperation; } } var stopper = monitor.CancellationToken.Register(oper.Cancel); await oper.Task; stopper.Dispose(); if (oper.ExitCode != 0) { 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(false); } catch (Exception ex) { LoggingService.LogError("Command execution failed", ex); throw new UserException(GettextCatalog.GetString("Command execution failed: {0}", ex.Message)); } finally { result = oper != null && oper.ExitCode == 0; if (console != null) { console.Dispose(); } } return(result); }
/// <summary> /// Runs a command /// </summary> /// <param name="command"> /// Command to run /// </param> /// <param name="console"> /// The console where to redirect the output /// </param> /// <param name="ctx"> /// Context with execution information /// </param> /// <param name="configurationData"> /// Configuration information. Created by the IExecutionConfigurationEditor object. /// </param> public abstract ProcessAsyncOperation Execute(ExecutionCommand command, OperationConsole console, CommandExecutionContext ctx, object configurationData);
public static ProcessAsyncOperation Run(ExecutionCommand cmd, OperationConsole console, DebuggerEngine engine = null) { InternalRun(cmd, engine, console); return(currentDebugOperation); }
public static ProcessAsyncOperation Run(string file, OperationConsole console) { var cmd = Runtime.ProcessService.CreateCommand(file); return(Run(cmd, console)); }
public ProcessAsyncOperation Execute(ExecutionCommand command, OperationConsole console) { return(Handler.InternalExecute(Context, ParentMode, command, console)); }
public ProcessAsyncOperation Execute(ExecutionCommand command, OperationConsole console) { var dotNetCommand = ConvertCommand((DotNetCoreExecutionCommand)command); return(Runtime.SystemAssemblyService.DefaultRuntime.GetExecutionHandler().Execute(dotNetCommand, console)); }
public ProcessAsyncOperation Execute(ExecutionCommand command, OperationConsole console) { return(DebuggingService.Run(command, console, engine)); }
public XspBrowserLauncherConsole(OperationConsole real, Action <string> launchBrowser) { this.real = real; this.launchBrowser = launchBrowser; cancelReg = real.CancellationToken.Register(CancellationSource.Cancel); }
public DotNetCoreTestConsoleWrapper(OperationConsole console) : base(console.CancellationToken) { this.console = console; }
public Task Connect(NUnitVersion version, IExecutionHandler executionHandler = null, OperationConsole console = null) { var exePath = Path.Combine(Path.GetDirectoryName(GetType().Assembly.Location), version.ToString(), "NUnitRunner.exe"); connection = new RemoteProcessConnection(exePath, executionHandler, console, Runtime.MainSynchronizationContext); connection.AddListener(this); return(connection.Connect()); }
public OperationConsoleWrapper(OperationConsole console) { this.console = console; errorTextWriter = new WrappedTextWriter(console.Error); }
public ProcessAsyncOperation Execute(ExecutionCommand command, OperationConsole console) { return(Handler.Execute(command, console)); }
protected async override Task OnExecute(ProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration, SolutionItemRunConfiguration runConfiguration) { //check XSP is available var cfg = GetConfiguration(configuration); var cmd = CreateExecutionCommand(configuration, cfg); var browserExcTarget = context.ExecutionTarget as BrowserExecutionTarget; OperationConsole console = null; 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; } } console = context.ConsoleFactory.CreateConsole(monitor.CancellationToken); // The running Port value is now captured in the XspBrowserLauncherConsole object string url = String.Format("http://{0}", XspParameters.Address); if (isXsp) { console = new XspBrowserLauncherConsole(console, delegate(string port) { if (browserExcTarget != null) { browserExcTarget.DesktopApp.Launch(String.Format("{0}:{1}", url, port)); } else { BrowserLauncher.LaunchDefaultBrowser(String.Format("{0}:{1}", url, port)); } }); } monitor.Log.WriteLine(GettextCatalog.GetString("Running web server...")); var op = context.ExecutionHandler.Execute(cmd, console); if (!isXsp) { if (browserExcTarget != null) { browserExcTarget.DesktopApp.Launch(url); } else { BrowserLauncher.LaunchDefaultBrowser(url); } } using (monitor.CancellationToken.Register(op.Cancel)) await op.Task; monitor.Log.WriteLine(GettextCatalog.GetString("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(GettextCatalog.GetString("Could not launch web server."), ex); } finally { if (console != null) { console.Dispose(); } } }
public ProcessAsyncOperation Execute(ExecutionCommand command, OperationConsole console) { return(DebuggingService.GetExecutionHandler().Execute(command, console)); }
public ProcessAsyncOperation Execute(ExecutionCommand cmd, OperationConsole console) { // Never called throw new NotImplementedException(); }
public ProcessAsyncOperation Execute(ExecutionCommand command, OperationConsole console) { return(InternalExecute(new CommandExecutionContext(null, command), new ExecutionMode("", "", this), command, console)); }
static void Cleanup() { DebuggerSession currentSession; StatusBarIcon currentIcon; OperationConsole currentConsole; lock (cleanup_lock) { if (!IsDebugging) { return; } currentIcon = busyStatusIcon; currentSession = session; currentConsole = console; nextStatementLocations.Clear(); currentBacktrace = null; busyStatusIcon = null; session = null; console = null; pinnedWatches.InvalidateAll(); } UnsetDebugLayout(); currentSession.BusyStateChanged -= OnBusyStateChanged; currentSession.TargetEvent -= OnTargetEvent; currentSession.TargetStarted -= OnStarted; currentSession.BreakpointTraceHandler = null; currentSession.GetExpressionEvaluator = null; currentSession.TypeResolverHandler = null; currentSession.OutputWriter = null; currentSession.LogWriter = null; currentDebugOperation.Cleanup(); if (currentConsole != null) { cancelRegistration.Dispose(); currentConsole.Dispose(); } Runtime.RunInMainThread(delegate { HideExceptionCaughtDialog(); if (currentIcon != null) { currentIcon.Dispose(); currentIcon = null; } if (StoppedEvent != null) { StoppedEvent(null, new EventArgs()); } NotifyCallStackChanged(); NotifyCurrentFrameChanged(); NotifyLocationChanged(); }); currentSession.Dispose(); }
internal ProcessAsyncOperation InternalExecute(CommandExecutionContext ctx, IExecutionMode mode, ExecutionCommand command, OperationConsole console) { CustomExecutionMode cmode = ExecutionModeCommandService.ShowParamtersDialog(ctx, mode, null); if (cmode == null) { return(new CancelledProcessAsyncOperation()); } return(cmode.Execute(command, console, false, false)); }
public static ProcessAsyncOperation Run(string file, string args, string workingDir, IDictionary <string, string> envVars, OperationConsole console) { var cmd = Runtime.ProcessService.CreateCommand(file); if (args != null) { cmd.Arguments = args; } if (workingDir != null) { cmd.WorkingDirectory = workingDir; } if (envVars != null) { cmd.EnvironmentVariables = envVars; } return(Run(cmd, console)); }
public ProcessAsyncOperation Execute(ExecutionCommand command, OperationConsole console) { return(Execute(command, console, true, false)); }