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);
}
}
}
}
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(
"\r\n===={0}====\r\n\r\n",
string.Format(Resources.NpmCommandCompletedWithExitCode, process.ExitCode ?? -1)
));
}
} else {
process.Kill();
if (redirector != null) {
redirector.WriteErrorLine(string.Format(
"\r\n===={0}====\r\n\r\n",
Resources.NpmCommandCancelled));
}
if (cancellationResetEvent != null) {
cancellationResetEvent.Reset();
}
throw new OperationCanceledException();
}
}
}
return standardOutputLines;
}
private void OnOutputDataReceived(object sender, DataReceivedEventArgs e)
{
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 static async Task ContinueCreate(IServiceProvider provider, IPythonInterpreterFactory factory, string path, bool useVEnv, Redirector output) {
path = CommonUtils.TrimEndSeparator(path);
var name = Path.GetFileName(path);
var dir = Path.GetDirectoryName(path);
if (output != null) {
output.WriteLine(SR.GetString(SR.VirtualEnvCreating, 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(SR.GetString(SR.VirtualEnvCreationSucceeded, path));
} else {
output.WriteLine(SR.GetString(SR.VirtualEnvCreationFailedExitCode, path, exitCode));
}
if (provider.GetPythonToolsService().GeneralOptions.ShowOutputWindowForVirtualEnvCreate) {
output.ShowAndActivate();
} else {
output.Show();
}
}
if (exitCode != 0 || !Directory.Exists(path)) {
throw new InvalidOperationException(SR.GetString(SR.VirtualEnvCreationFailed, path));
}
}
}
/// <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("cmd.exe")
{
WindowStyle = ProcessWindowStyle.Hidden,
Verb = "runas",
CreateNoWindow = true,
UseShellExecute = true,
Arguments = string.Format(@"/S /C pushd {0} & ""{1} {2} >>{3} 2>>{4}""",
QuoteSingleArgument(workingDirectory),
QuoteSingleArgument(filename),
GetArguments(arguments, quoteArgs),
QuoteSingleArgument(outFile),
QuoteSingleArgument(errFile))
};
var process = new 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);
}
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;
}
}
/// <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("cmd.exe");
psi.CreateNoWindow = true;
psi.WindowStyle = ProcessWindowStyle.Hidden;
psi.UseShellExecute = true;
psi.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;
}
private async Task<bool> DownloadTypings(IEnumerable<string> packages, Redirector redirector) {
if (!packages.Any()) {
return true;
}
string typingsTool = await EnsureTypingsToolInstalled();
if (string.IsNullOrEmpty(typingsTool)) {
if (redirector != null) {
redirector.WriteErrorLine(SR.GetString(SR.TypingsToolNotInstalledError));
}
return false;
}
using (var process = ProcessOutput.Run(
typingsTool,
GetTypingsToolInstallArguments(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 'typings'");
}
return false;
}
var i = await process;
if (i == 0) {
if (redirector != null) {
redirector.WriteLine(SR.GetString(SR.TypingsToolInstallCompleted));
}
return true;
} else {
process.Kill();
if (redirector != null) {
redirector.WriteErrorLine(SR.GetString(SR.TypingsToolInstallErrorOccurred));
}
return false;
}
}
}
/// <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)
{
var outFile = Path.GetTempFileName();
var errFile = Path.GetTempFileName();
var psi = new ProcessStartInfo("cmd.exe");
psi.CreateNoWindow = true;
psi.WindowStyle = ProcessWindowStyle.Hidden;
psi.UseShellExecute = true;
psi.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);
foreach (var line in lines)
{
redirector.WriteLine(line);
}
} catch (Exception) {
redirector.WriteErrorLine("Failed to obtain standard output from elevated process.");
}
try {
var lines = File.ReadAllLines(errFile);
foreach (var line in lines)
{
redirector.WriteErrorLine(line);
}
} catch (Exception) {
redirector.WriteErrorLine("Failed to obtain standard error from elevated process.");
}
} finally {
try {
File.Delete(outFile);
} catch { }
try {
File.Delete(errFile);
} catch { }
}
};
}
return(result);
}
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, SR.GetString(SR.InstallEasyInstall), elevate, output);
}
if (output != null) {
output.WriteLine(SR.GetString(SR.PackageInstalling, 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(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 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(SR.GetString(SR.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(SR.GetString(SR.PipInstallSucceeded));
} else {
output.WriteLine(SR.GetString(SR.PipInstallFailedExitCode, 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(SR.GetString(SR.PackageUninstalling, 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(SR.GetString(SR.PackageUninstallSucceeded, package));
} else {
output.WriteLine(SR.GetString(SR.PackageUninstallFailedExitCode, 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,
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, SR.GetString(SR.InstallPip), elevate, output);
} catch (OperationCanceledException) {
return false;
}
} else {
await InstallPip(provider, factory, elevate, output);
}
}
if (output != null) {
output.WriteLine(SR.GetString(SR.PackageInstalling, 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(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;
}
}