private void OnOutputDataReceived(object sender, DataReceivedEventArgs e) { if (_isDisposed) { return; } if (e.Data == null) { bool shouldExit; lock (_seenNullLock) { _seenNullInOutput = true; shouldExit = _seenNullInError || !_process.StartInfo.RedirectStandardError; } if (shouldExit) { OnExited(_process, EventArgs.Empty); } } else if (!string.IsNullOrEmpty(e.Data)) { foreach (var line in SplitLines(e.Data)) { if (_output != null) { _output.Add(line); } if (_redirector != null) { _redirector.WriteLine(line); } } } }
private void WriteOutput(string message) { if (_output != null) { _output.WriteLine(message); } }
private static async Task ContinueCreate(IServiceProvider provider, IPythonInterpreterFactory factory, string path, bool useVEnv, Redirector output) { path = PathUtils.TrimEndSeparator(path); var name = Path.GetFileName(path); var dir = Path.GetDirectoryName(path); if (output != null) { output.WriteLine(Strings.VirtualEnvCreating.FormatUI(path)); if (provider.GetPythonToolsService().GeneralOptions.ShowOutputWindowForVirtualEnvCreate) { output.ShowAndActivate(); } else { output.Show(); } } // Ensure the target directory exists. Directory.CreateDirectory(dir); using (var proc = ProcessOutput.Run( factory.Configuration.InterpreterPath, new[] { "-m", useVEnv ? "venv" : "virtualenv", name }, dir, UnbufferedEnv, false, output )) { var exitCode = await proc; if (output != null) { if (exitCode == 0) { output.WriteLine(Strings.VirtualEnvCreationSucceeded.FormatUI(path)); } else { output.WriteLine(Strings.VirtualEnvCreationFailedExitCode.FormatUI(path, exitCode)); } if (provider.GetPythonToolsService().GeneralOptions.ShowOutputWindowForVirtualEnvCreate) { output.ShowAndActivate(); } else { output.Show(); } } if (exitCode != 0 || !Directory.Exists(path)) { throw new InvalidOperationException(Strings.VirtualEnvCreationFailed.FormatUI(path)); } } }
public void OnOutputTextReceived(ICondaEnvironmentManager sender, string text) { _outputWindow.WriteLine(text.TrimEndNewline()); _taskHandler?.Progress.Report(new TaskProgressData() { CanBeCanceled = false, ProgressText = text, PercentComplete = null }); }
public static async Task <bool> Install( IServiceProvider provider, IPythonInterpreterFactory factory, string package, IServiceProvider site, bool elevate, Redirector output = null ) { factory.ThrowIfNotRunnable("factory"); bool isScript; if (site != null && GetEasyInstallPath(factory, out isScript) == null) { await Pip.QueryInstallPip(factory, site, Strings.InstallEasyInstall, elevate, output); } if (output != null) { output.WriteLine(Strings.PackageInstalling.FormatUI(package)); if (provider.GetPythonToolsService().GeneralOptions.ShowOutputWindowForPackageInstallation) { output.ShowAndActivate(); } else { output.Show(); } } var exitCode = await ContinueRun(factory, output, elevate, package); if (output != null) { if (exitCode == 0) { output.WriteLine(Strings.PackageInstallSucceeded.FormatUI(package)); } else { output.WriteLine(Strings.PackageInstallFailedExitCode.FormatUI(package, exitCode)); } if (provider.GetPythonToolsService().GeneralOptions.ShowOutputWindowForPackageInstallation) { output.ShowAndActivate(); } else { output.Show(); } } return(exitCode == 0); }
private void PipExtensionProvider_OperationStarted(object sender, ValueEventArgs <string> e) { _outputWindow.WriteLine(e.Value); if (_statusBar != null) { _statusBar.SetText(e.Value); } if (_pyService.GeneralOptions.ShowOutputWindowForPackageInstallation) { _outputWindow.ShowAndActivate(); } }
// If the global interpreter comes from the Microsoft Store, and you try to create a venv // under %localappdata%, the venv will actually be created under the python install localcache, // and a redirect will be put in place that is only understood by the python.exe used to create // the venv. // Therefore, we have to use the python intepreter to check the real path of the venv, // in case it's been redirected. private async Task <string> GetRealPath(string path) { // if we can see the path, it hasn't been redirected, so no need to call into python if (Directory.Exists(path) || File.Exists(path)) { return(path); } // get the redirected path from python _redirector.WriteLine(Strings.LookingForRedirectedEnv.FormatUI(path)); var command = $"import os; print(os.path.realpath(r\"{ path }\"))"; var output = ProcessOutput.RunHiddenAndCapture( _interpreter.InterpreterExecutablePath, new[] { "-c", command } ); try { var result = await WaitForOutput(_interpreter.InterpreterExecutablePath, output); var redirectedPath = result.StandardOutputLines.FirstOrDefault(); if (!string.IsNullOrEmpty(redirectedPath) && Directory.Exists(redirectedPath)) { _redirector.WriteLine(Strings.LookingForRedirectedEnvFound.FormatUI(redirectedPath)); } return(redirectedPath); } catch (ProcessException p) { _redirector.WriteLine(Strings.LookingForRedirectedEnvFailed.FormatUI(path)); foreach (var line in p.Result.StandardErrorLines) { _redirector.WriteLine(line); } throw; } }
public static async Task InstallPip(IServiceProvider provider, IPythonInterpreterFactory factory, bool elevate, Redirector output = null) { factory.ThrowIfNotRunnable("factory"); var pipDownloaderPath = PythonToolsInstallPath.GetFile("pip_downloader.py"); if (output != null) { output.WriteLine(Strings.PipInstalling); if (provider.GetPythonToolsService().GeneralOptions.ShowOutputWindowForPackageInstallation) { output.ShowAndActivate(); } else { output.Show(); } } using (var proc = ProcessOutput.Run( factory.Configuration.InterpreterPath, new[] { pipDownloaderPath }, factory.Configuration.PrefixPath, null, false, output, elevate: elevate )) { var exitCode = await proc; if (output != null) { if (exitCode == 0) { output.WriteLine(Strings.PipInstallSucceeded); } else { output.WriteLine(Strings.PipInstallFailedExitCode.FormatUI(exitCode)); } if (provider.GetPythonToolsService().GeneralOptions.ShowOutputWindowForPackageInstallation) { output.ShowAndActivate(); } else { output.Show(); } } } }
public static async Task <bool> Uninstall( IServiceProvider provider, IPythonInterpreterFactory factory, string package, bool elevate, Redirector output = null ) { factory.ThrowIfNotRunnable("factory"); if (output != null) { output.WriteLine(Strings.PackageUninstalling.FormatUI(package)); if (provider.GetPythonToolsService().GeneralOptions.ShowOutputWindowForPackageInstallation) { output.ShowAndActivate(); } else { output.Show(); } } using (var proc = Run(factory, output, elevate, "uninstall", "-y", package)) { var exitCode = await proc; if (output != null) { if (exitCode == 0) { output.WriteLine(Strings.PackageUninstallSucceeded.FormatUI(package)); } else { output.WriteLine(Strings.PackageUninstallFailedExitCode.FormatUI(package, exitCode)); } if (provider.GetPythonToolsService().GeneralOptions.ShowOutputWindowForPackageInstallation) { output.ShowAndActivate(); } else { output.Show(); } } return(exitCode == 0); } }
private async Task CreateVenv() { RemoveExistingVenv(); _redirector.WriteLine(Strings.InstallingCookiecutterCreateEnv.FormatUI(_envFolderPath)); var output = ProcessOutput.Run( _interpreter.InterpreterExecutablePath, new[] { "-m", "venv", _envFolderPath }, null, null, false, _redirector ); await WaitForOutput(_interpreter.InterpreterExecutablePath, output); }
private void WriteOutput(string resourceKey, params object[] args) { if (_output != null) { _output.WriteLine(SR.GetString(resourceKey, args)); } }
private async Task <bool> DownloadTypings(IEnumerable <string> packages, Redirector redirector) { if (!packages.Any()) { return(true); } string tsdPath = await EnsureTsdInstalled(); if (string.IsNullOrEmpty(tsdPath)) { if (redirector != null) { redirector.WriteErrorLine(SR.GetString(SR.TsdNotInstalledError)); } return(false); } using (var process = ProcessOutput.Run( tsdPath, TsdInstallArguments(packages), _pathToRootProjectDirectory, null, false, redirector, quoteArgs: true)) { if (!process.IsStarted) { // Process failed to start, and any exception message has // already been sent through the redirector if (redirector != null) { redirector.WriteErrorLine("could not start tsd"); } return(false); } var i = await process; if (i == 0) { if (redirector != null) { redirector.WriteLine(SR.GetString(SR.TsdInstallCompleted)); } return(true); } else { process.Kill(); if (redirector != null) { redirector.WriteErrorLine(SR.GetString(SR.TsdInstallErrorOccurred)); } return(false); } } }
private static async Task <bool> CompileAsync(string arguments, string workingDir, Redirector redirector) { Debug.Assert(!string.IsNullOrEmpty(arguments), $"{nameof(arguments)} should not be empty."); var pathToTsc = Path.Combine(TypeScriptCompilerLocator.GetDefaultVersion(), CompilerExe); redirector?.WriteLine($"=== {Resources.TscBuildStarted}: {pathToTsc} {arguments} ==="); using (var process = ProcessOutput.Run( pathToTsc, new[] { arguments }, workingDir, env: null, visible: false, redirector: redirector, quoteArgs: false, outputEncoding: Encoding.UTF8)) { var whnd = process.WaitHandle; if (whnd == null) { // Process failed to start, and any exception message has // already been sent through the redirector redirector.WriteErrorLine(string.Format(Resources.TscBuildError, pathToTsc)); return(false); } else { var finished = await Task.Run(() => whnd.WaitOne()); if (finished) { Debug.Assert(process.ExitCode.HasValue, "tsc.exe process has not really exited"); // there seems to be a case when we're signalled as completed, but the // process hasn't actually exited process.Wait(); redirector.WriteErrorLine($"==== {Resources.TscBuildCompleted} ===="); return(process.ExitCode == 0); } else { process.Kill(); redirector.WriteErrorLine($"==== {Resources.TscBuildCanceled} ===="); return(false); } } } }
private async Task <bool> ExecuteTypingsTool(IEnumerable <string> arguments, Redirector redirector) { string typingsTool = await EnsureTypingsToolInstalled(redirector); if (string.IsNullOrEmpty(typingsTool)) { redirector?.WriteErrorLine(Resources.TypingsToolNotInstalledError); return(false); } using (var process = ProcessOutput.Run( typingsTool, arguments, _pathToRootProjectDirectory, null, false, redirector, quoteArgs: true, outputEncoding: Encoding.UTF8, errorEncoding: Encoding.UTF8)) { if (!process.IsStarted) { // Process failed to start, and any exception message has // already been sent through the redirector redirector?.WriteErrorLine(Resources.TypingsToolCouldNotStart); return(false); } var i = await process; if (i == 0) { redirector?.WriteLine(Resources.TypingsToolTypingsInstallCompleted); return(true); } else { process.Kill(); redirector?.WriteErrorLine(Resources.TypingsToolTypingsInstallErrorOccurred); return(false); } } }
private async Task ReanalyzeWorkspaceHelperAsync(IPythonInterpreterFactory factory, Redirector log) { _site.MustBeCalledFromUIThread(); try { if (!_recreatingAnalyzer.Wait(0)) { // Someone else is recreating, so wait for them to finish and return log?.WriteLine("Waiting for existing call"); await _recreatingAnalyzer.WaitAsync(); try { log?.WriteLine("Existing call complete"); } catch { _recreatingAnalyzer.Release(); throw; } if (_analyzer?.InterpreterFactory == factory) { _recreatingAnalyzer.Release(); return; } } } catch (ObjectDisposedException) { return; } IVsStatusbar statusBar = null; bool statusBarConfigured = false; try { if ((statusBar = _site.GetService(typeof(SVsStatusbar)) as IVsStatusbar) != null) { statusBar.SetText(Strings.AnalyzingProject); try { object index = (short)0; statusBar.Animation(1, ref index); } catch (ArgumentNullException) { // Issue in status bar implementation // https://github.com/Microsoft/PTVS/issues/3064 // Silently suppress since animation is not critical. } statusBar.FreezeOutput(1); statusBarConfigured = true; } var oldWatcher = _workspaceFileWatcher; _workspaceFileWatcher = new FileWatcher(_pythonWorkspace.Location) { EnableRaisingEvents = true, IncludeSubdirectories = true, NotifyFilter = NotifyFilters.FileName | NotifyFilters.LastWrite }; _workspaceFileWatcher.Changed += OnWorkspaceFileChanged; _workspaceFileWatcher.Deleted += OnWorkspaceFileDeleted; oldWatcher?.Dispose(); log?.WriteLine("Creating new workspace analyzer"); var analyzer = await CreateAnalyzerAsync(factory, _pythonWorkspace.Location); Debug.Assert(analyzer != null); log?.WriteLine($"Created workspace analyzer {analyzer}"); WorkspaceAnalyzerChanging?.Invoke(this, new AnalyzerChangingEventArgs(_analyzer, analyzer)); var oldAnalyzer = Interlocked.Exchange(ref _analyzer, analyzer); if (oldAnalyzer != null) { if (analyzer != null) { int beforeCount = analyzer.Files.Count(); log?.WriteLine($"Transferring from old analyzer {oldAnalyzer}, which has {oldAnalyzer.Files.Count()} files"); await analyzer.TransferFromOldAnalyzer(oldAnalyzer); log?.WriteLine($"Tranferred {analyzer.Files.Count() - beforeCount} files"); log?.WriteLine($"Old analyzer now has {oldAnalyzer.Files.Count()} files"); } if (oldAnalyzer.RemoveUser()) { log?.WriteLine("Disposing old analyzer"); oldAnalyzer.Dispose(); } } var files = new List <string>(); var pythonServices = _site.GetPythonToolsService(); foreach (var existing in pythonServices.GetActiveSharedAnalyzers().Select(kv => kv.Value).Where(v => !v.IsDisposed)) { foreach (var kv in existing.LoadedFiles) { files.Add(kv.Key); log?.WriteLine($"Unloading {kv.Key} from default analyzer"); foreach (var b in (kv.Value.TryGetBufferParser()?.AllBuffers).MaybeEnumerate()) { PythonTextBufferInfo.MarkForReplacement(b); } try { await existing.UnloadFileAsync(kv.Value); } catch (ObjectDisposedException) { break; } } } if (analyzer != null) { // Set search paths first, as it will save full reanalysis later log?.WriteLine("Setting search paths"); await analyzer.SetSearchPathsAsync(_pythonWorkspace.GetAbsoluteSearchPaths()); // Add all our files into our analyzer log?.WriteLine($"Adding {files.Count} files"); await analyzer.AnalyzeFileAsync(files.ToArray()); } WorkspaceAnalyzerChanged?.Invoke(this, EventArgs.Empty); } catch (ObjectDisposedException) { // Raced with disposal } catch (Exception ex) { log?.WriteErrorLine(ex.ToString()); throw; } finally { try { if (statusBar != null && statusBarConfigured) { statusBar.FreezeOutput(0); object index = (short)0; statusBar.Animation(0, ref index); statusBar.Clear(); } } finally { try { _recreatingAnalyzer.Release(); } catch (ObjectDisposedException) { } } } }
public Task DeleteTemplateAsync(TemplateViewModel template) { try { string remote = template.RemoteUrl; _outputWindow.WriteLine(string.Format(CultureInfo.CurrentUICulture, Strings.DeletingTemplateStarted, template.ClonedPath)); ShellUtils.DeleteDirectory(template.ClonedPath); _outputWindow.WriteLine(string.Empty); _outputWindow.WriteLine(string.Format(CultureInfo.CurrentUICulture, Strings.DeletingTemplateSuccess, template.ClonedPath)); _outputWindow.ShowAndActivate(); if (!string.IsNullOrEmpty(remote)) { var t = Installed.Templates.SingleOrDefault(current => (current as TemplateViewModel)?.RemoteUrl == remote) as TemplateViewModel; if (t != null) { Installed.Templates.Remove(t); } t = Recommended.Templates.SingleOrDefault(current => (current as TemplateViewModel)?.RemoteUrl == remote) as TemplateViewModel; if (t != null) { t.ClonedPath = string.Empty; } t = GitHub.Templates.SingleOrDefault(current => (current as TemplateViewModel)?.RemoteUrl == remote) as TemplateViewModel; if (t != null) { t.ClonedPath = string.Empty; } } else { if (Installed.Templates.Contains(template)) { Installed.Templates.Remove(template); } } } catch (Exception ex) when (!ex.IsCriticalException()) { _outputWindow.WriteErrorLine(ex.Message); _outputWindow.WriteLine(string.Empty); _outputWindow.WriteLine(string.Format(CultureInfo.CurrentUICulture, Strings.DeletingTemplateFailed, template.ClonedPath)); _outputWindow.ShowAndActivate(); } return Task.CompletedTask; }
public void OnOutputTextReceived(ICondaEnvironmentManager sender, string text) { _window.WriteLine(text.TrimEndNewline()); }
public static async Task <bool> Install( IServiceProvider provider, IPythonInterpreterFactory factory, string package, IServiceProvider site, bool elevate, Redirector output = null ) { factory.ThrowIfNotRunnable("factory"); if (!(await factory.FindModulesAsync("pip")).Any()) { if (site != null) { try { await QueryInstallPip(factory, site, Strings.InstallPip, elevate, output); } catch (OperationCanceledException) { return(false); } } else { await InstallPip(provider, factory, elevate, output); } } if (output != null) { output.WriteLine(Strings.PackageInstalling.FormatUI(package)); if (provider.GetPythonToolsService().GeneralOptions.ShowOutputWindowForPackageInstallation) { output.ShowAndActivate(); } else { output.Show(); } } using (var proc = Run(factory, output, elevate, "install", GetInsecureArg(factory, output), package)) { var exitCode = await proc; if (output != null) { if (exitCode == 0) { output.WriteLine(Strings.PackageInstallSucceeded.FormatUI(package)); } else { output.WriteLine(Strings.PackageInstallFailedExitCode.FormatUI(package, exitCode)); } if (provider.GetPythonToolsService().GeneralOptions.ShowOutputWindowForPackageInstallation) { output.ShowAndActivate(); } else { output.Show(); } } return(exitCode == 0); } }
public static async Task <bool> Install( IServiceProvider provider, IPythonInterpreterFactory factory, IInterpreterOptionsService service, string package, Redirector output = null ) { factory.ThrowIfNotRunnable("factory"); var condaFactory = await TryGetCondaFactoryAsync(factory, service);; if (condaFactory == null) { throw new InvalidOperationException("Cannot find conda"); } condaFactory.ThrowIfNotRunnable(); if (output != null) { output.WriteLine(SR.GetString(SR.PackageInstalling, package)); if (provider.GetPythonToolsService().GeneralOptions.ShowOutputWindowForPackageInstallation) { output.ShowAndActivate(); } else { output.Show(); } } using (var proc = ProcessOutput.Run( condaFactory.Configuration.InterpreterPath, new[] { "-m", "conda", "install", "--yes", "-n", factory.Configuration.PrefixPath, package }, factory.Configuration.PrefixPath, UnbufferedEnv, false, output )) { var exitCode = await proc; if (output != null) { if (exitCode == 0) { output.WriteLine(SR.GetString(SR.PackageInstallSucceeded, package)); } else { output.WriteLine(SR.GetString(SR.PackageInstallFailedExitCode, package, exitCode)); } if (provider.GetPythonToolsService().GeneralOptions.ShowOutputWindowForPackageInstallation) { output.ShowAndActivate(); } else { output.Show(); } } return(exitCode == 0); } }
public void OnOutputTextReceived(string text) { _outputWindow.WriteLine(text.TrimEndNewline()); }
public async Task DeleteTemplateAsync(TemplateViewModel template) { try { string remote = template.RemoteUrl; _outputWindow.ShowAndActivate(); _outputWindow.WriteLine(String.Empty); _outputWindow.WriteLine(Strings.DeletingTemplateStarted.FormatUI(template.ClonedPath)); await _installedSource.DeleteTemplateAsync(template.ClonedPath); _outputWindow.WriteLine(Strings.DeletingTemplateSuccess.FormatUI(template.ClonedPath)); ReportTemplateEvent(CookiecutterTelemetry.TelemetryArea.Template, CookiecutterTelemetry.TemplateEvents.Delete, template); if (!string.IsNullOrEmpty(remote)) { var t = Installed.Templates.SingleOrDefault(current => (current as TemplateViewModel)?.RemoteUrl == remote) as TemplateViewModel; if (t != null) { Installed.Templates.Remove(t); } t = Recommended.Templates.SingleOrDefault(current => (current as TemplateViewModel)?.RemoteUrl == remote) as TemplateViewModel; if (t != null) { t.ClonedPath = string.Empty; } t = GitHub.Templates.SingleOrDefault(current => (current as TemplateViewModel)?.RemoteUrl == remote) as TemplateViewModel; if (t != null) { t.ClonedPath = string.Empty; } } else { if (Installed.Templates.Contains(template)) { Installed.Templates.Remove(template); } } } catch (Exception ex) when(!ex.IsCriticalException()) { _outputWindow.WriteErrorLine(ex.Message); _outputWindow.WriteLine(Strings.DeletingTemplateFailed.FormatUI(template.ClonedPath)); ReportTemplateEvent(CookiecutterTelemetry.TelemetryArea.Template, CookiecutterTelemetry.TemplateEvents.Delete, template, ex); } }
private void PipExtensionProvider_OutputTextReceived(object sender, OutputEventArgs e) { _outputWindow.WriteLine(e.Data.TrimEndNewline()); }
/// <summary> /// Runs the file with the provided settings as a user with /// administrative permissions. The window is always hidden and output /// is provided to the redirector when the process terminates. /// </summary> /// <param name="filename">Executable file to run.</param> /// <param name="arguments">Arguments to pass.</param> /// <param name="workingDirectory">Starting directory.</param> /// <param name="redirector"> /// An object to receive redirected output. /// </param> /// <param name="quoteArgs"></param> /// <returns>A <see cref="ProcessOutput"/> object.</returns> public static ProcessOutput RunElevated( string filename, IEnumerable <string> arguments, string workingDirectory, IEnumerable <KeyValuePair <string, string> > env, Redirector redirector, bool quoteArgs = true, bool elevate = true, Encoding outputEncoding = null, Encoding errorEncoding = null ) { var psi = new ProcessStartInfo(PythonToolsInstallPath.GetFile("Microsoft.PythonTools.RunElevated.exe", typeof(ProcessOutput).Assembly)); psi.CreateNoWindow = true; psi.WindowStyle = ProcessWindowStyle.Hidden; var utf8 = new UTF8Encoding(false); // Send args and env as base64 to avoid newline issues string args; if (quoteArgs) { args = string.Join("|", arguments .Where(a => a != null) .Select(a => Convert.ToBase64String(utf8.GetBytes(QuoteSingleArgument(a)))) ); } else { args = string.Join("|", arguments .Where(a => a != null) .Select(a => Convert.ToBase64String(utf8.GetBytes(a))) ); } var fullEnv = env != null? string.Join("|", env.Select(kv => kv.Key + "=" + Convert.ToBase64String(utf8.GetBytes(kv.Value)))) : ""; TcpListener listener = null; Task <TcpClient> clientTask = null; try { listener = SocketUtils.GetRandomPortListener(IPAddress.Loopback, out int port); psi.Arguments = port.ToString(); clientTask = listener.AcceptTcpClientAsync(); } catch (Exception ex) { listener?.Stop(); throw new InvalidOperationException(Strings.UnableToElevate, ex); } var process = new Process(); clientTask.ContinueWith(t => { listener.Stop(); TcpClient client; try { client = t.Result; } catch (AggregateException ae) { try { process.Kill(); } catch (InvalidOperationException) { } catch (Win32Exception) { } if (redirector != null) { foreach (var ex in ae.InnerExceptions.DefaultIfEmpty(ae)) { using (var reader = new StringReader(ex.ToString())) { for (var line = reader.ReadLine(); line != null; line = reader.ReadLine()) { redirector.WriteErrorLine(line); } } } } return; } using (var writer = new StreamWriter(client.GetStream(), utf8, 4096, true)) { writer.WriteLine(filename); writer.WriteLine(args); writer.WriteLine(workingDirectory); writer.WriteLine(fullEnv); writer.WriteLine(outputEncoding?.WebName ?? ""); writer.WriteLine(errorEncoding?.WebName ?? ""); } if (redirector != null) { var reader = new StreamReader(client.GetStream(), utf8, false, 4096, true); Task.Run(() => { try { for (var line = reader.ReadLine(); line != null; line = reader.ReadLine()) { if (line.StartsWithOrdinal("OUT:")) { redirector.WriteLine(line.Substring(4)); } else if (line.StartsWithOrdinal("ERR:")) { redirector.WriteErrorLine(line.Substring(4)); } else { redirector.WriteLine(line); } } } catch (IOException) { } catch (ObjectDisposedException) { } }); } }); process.StartInfo = psi; return(new ProcessOutput(process, redirector)); }
private void WriteOutput(string message) { _output?.WriteLine(message); }
public void OnOutputTextReceived(IPackageManager sender, string text) { _outputWindow.WriteLine(text.TrimEndNewline()); }
/// <summary> /// Runs the file with the provided settings as a user with /// administrative permissions. The window is always hidden and output /// is provided to the redirector when the process terminates. /// </summary> /// <param name="filename">Executable file to run.</param> /// <param name="arguments">Arguments to pass.</param> /// <param name="workingDirectory">Starting directory.</param> /// <param name="redirector"> /// An object to receive redirected output. /// </param> /// <param name="quoteArgs"></param> /// <returns>A <see cref="ProcessOutput"/> object.</returns> public static ProcessOutput RunElevated( string filename, IEnumerable <string> arguments, string workingDirectory, Redirector redirector, bool quoteArgs = true, Encoding outputEncoding = null, Encoding errorEncoding = null ) { var outFile = Path.GetTempFileName(); var errFile = Path.GetTempFileName(); var psi = new ProcessStartInfo(Path.Combine(Environment.SystemDirectory, "cmd.exe")) { CreateNoWindow = true, WindowStyle = ProcessWindowStyle.Hidden, UseShellExecute = true, Verb = "runas" }; string args; if (quoteArgs) { args = string.Join(" ", arguments.Where(a => a != null).Select(QuoteSingleArgument)); } else { args = string.Join(" ", arguments.Where(a => a != null)); } psi.Arguments = string.Format("/S /C \"{0} {1} >>{2} 2>>{3}\"", QuoteSingleArgument(filename), args, QuoteSingleArgument(outFile), QuoteSingleArgument(errFile) ); psi.WorkingDirectory = workingDirectory; psi.CreateNoWindow = true; psi.UseShellExecute = true; var process = new Process(); process.StartInfo = psi; var result = new ProcessOutput(process, redirector); if (redirector != null) { result.Exited += (s, e) => { try { try { var lines = File.ReadAllLines(outFile, outputEncoding ?? Encoding.Default); foreach (var line in lines) { redirector.WriteLine(line); } } catch (Exception ex) { if (IsCriticalException(ex)) { throw; } redirector.WriteErrorLine("Failed to obtain standard output from elevated process."); #if DEBUG foreach (var line in SplitLines(ex.ToString())) { redirector.WriteErrorLine(line); } #else Trace.TraceError("Failed to obtain standard output from elevated process."); Trace.TraceError(ex.ToString()); #endif } try { var lines = File.ReadAllLines(errFile, errorEncoding ?? outputEncoding ?? Encoding.Default); foreach (var line in lines) { redirector.WriteErrorLine(line); } } catch (Exception ex) { if (IsCriticalException(ex)) { throw; } redirector.WriteErrorLine("Failed to obtain standard error from elevated process."); #if DEBUG foreach (var line in SplitLines(ex.ToString())) { redirector.WriteErrorLine(line); } #else Trace.TraceError("Failed to obtain standard error from elevated process."); Trace.TraceError(ex.ToString()); #endif } } finally { try { File.Delete(outFile); } catch { } try { File.Delete(errFile); } catch { } } }; } return(result); }
internal static async Task <IEnumerable <string> > ExecuteNpmCommandAsync( Redirector redirector, string pathToNpm, string executionDirectory, string[] arguments, ManualResetEvent cancellationResetEvent) { IEnumerable <string> standardOutputLines = null; using (var process = ProcessOutput.Run( pathToNpm, arguments, executionDirectory, null, false, redirector, quoteArgs: false, outputEncoding: Encoding.UTF8 // npm uses UTF-8 regardless of locale if its output is redirected )) { var whnd = process.WaitHandle; if (whnd == null) { // Process failed to start, and any exception message has // already been sent through the redirector if (redirector != null) { redirector.WriteErrorLine(Resources.ErrCannotStartNpm); } } else { var handles = cancellationResetEvent != null ? new[] { whnd, cancellationResetEvent } : new[] { whnd }; var i = await Task.Run(() => WaitHandle.WaitAny(handles)); if (i == 0) { Debug.Assert(process.ExitCode.HasValue, "npm process has not really exited"); process.Wait(); if (process.StandardOutputLines != null) { standardOutputLines = process.StandardOutputLines.ToList(); } if (redirector != null) { redirector.WriteLine(string.Format(CultureInfo.InvariantCulture, "\r\n===={0}====\r\n\r\n", string.Format(CultureInfo.InvariantCulture, Resources.NpmCommandCompletedWithExitCode, process.ExitCode ?? -1) )); } } else { process.Kill(); if (redirector != null) { redirector.WriteErrorLine(string.Format(CultureInfo.InvariantCulture, "\r\n===={0}====\r\n\r\n", Resources.NpmCommandCancelled)); } if (cancellationResetEvent != null) { cancellationResetEvent.Reset(); } throw new OperationCanceledException(); } } } return(standardOutputLines); }
public void OnOutputTextReceived(string text) { _outputWindow.WriteLine(RemoveLastNewline(text)); }