private async void CreateProjectAndHandleErrors(
IVsStatusbar statusBar,
Microsoft.PythonTools.Project.ImportWizard.ImportWizard dlg,
bool addToExistingSolution
)
{
try {
var path = await dlg.ImportSettings.CreateRequestedProjectAsync();
if (File.Exists(path))
{
object outRef = null, pathRef = ProcessOutput.QuoteSingleArgument(path);
_serviceProvider.GetDTE().Commands.Raise(
VSConstants.GUID_VSStandardCommandSet97.ToString("B"),
addToExistingSolution
? (int)VSConstants.VSStd97CmdID.AddExistingProject
: (int)VSConstants.VSStd97CmdID.OpenProject,
ref pathRef,
ref outRef
);
statusBar.SetText("");
return;
}
} catch (UnauthorizedAccessException) {
MessageBox.Show(Strings.ErrorImportWizardUnauthorizedAccess, Strings.ProductTitle);
} catch (Exception ex) {
ActivityLog.LogError(Strings.ProductTitle, ex.ToString());
MessageBox.Show(Strings.ErrorImportWizardException.FormatUI(ex.GetType().Name), Strings.ProductTitle);
}
statusBar.SetText(Strings.StatusImportWizardError);
}
private void _save_Click(object sender, EventArgs e)
{
var path = _provider.BrowseForFileSave(
Handle,
"Text Files (*.txt)|*.txt|All Files (*.*)|*.*",
PathUtils.GetAbsoluteFilePath(
Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
string.Format("Diagnostic Info {0:yyyy-MM-dd'T'HHmmss}.txt", DateTime.Now)
)
);
if (string.IsNullOrEmpty(path))
{
return;
}
try {
TaskDialog.CallWithRetry(
_ => File.WriteAllText(path, _textBox.Text),
_provider,
Strings.ProductTitle,
Strings.FailedToSaveDiagnosticInfo,
Strings.ErrorDetail,
Strings.Retry,
Strings.Cancel
);
Process.Start("explorer.exe", "/select," + ProcessOutput.QuoteSingleArgument(path));
} catch (OperationCanceledException) {
}
}
public async Task <bool> DeleteAsync(string envPath, ICondaEnvironmentManagerUI ui, CancellationToken ct)
{
bool success = false;
using (await _working.LockAsync(ct)) {
var args = new[] {
"remove",
"-p",
ProcessOutput.QuoteSingleArgument(envPath),
"--all",
"-y",
};
var operation = "conda " + string.Join(" ", args);
ui?.OnOperationStarted(this, operation);
ui?.OnOutputTextReceived(this, Strings.CondaDeleteStarted.FormatUI(envPath));
try {
if (!Directory.Exists(envPath))
{
ui?.OnErrorTextReceived(this, Strings.CondaFolderNotFoundError.FormatUI(envPath));
success = false;
return(success);
}
success = await DoOperationAsync(args, ui, ct);
return(success);
} finally {
var msg = success ? Strings.CondaDeleteSuccess : Strings.CondaDeleteFailed;
ui?.OnOutputTextReceived(this, msg.FormatUI(envPath));
ui?.OnOperationFinished(this, operation, success);
}
}
}
public async Task <bool> CreateAsync(string newEnvNameOrPath, IEnumerable <PackageSpec> packageSpecs, ICondaEnvironmentManagerUI ui, CancellationToken ct)
{
bool success = false;
using (await _working.LockAsync(ct)) {
var args = new[] {
"create",
IsAbsolutePath(newEnvNameOrPath) ? "-p" : "-n",
ProcessOutput.QuoteSingleArgument(newEnvNameOrPath),
"-y",
}.Union(packageSpecs.Select(s => s.FullSpec));
var operation = "conda " + string.Join(" ", args);
ui?.OnOperationStarted(this, operation);
ui?.OnOutputTextReceived(this, Strings.CondaCreateStarted.FormatUI(newEnvNameOrPath));
try {
if (!PathUtils.IsValidPath(newEnvNameOrPath))
{
ui?.OnErrorTextReceived(this, Strings.CondaCreateInvalidNameOrPath.FormatUI(newEnvNameOrPath));
success = false;
return(success);
}
success = await DoOperationAsync(args, ui, ct);
return(success);
} finally {
var msg = success ? Strings.CondaCreateSuccess : Strings.CondaCreateFailed;
ui?.OnOutputTextReceived(this, msg.FormatUI(newEnvNameOrPath));
ui?.OnOperationFinished(this, operation, success);
}
}
}
private void StartPerfMon(string filename)
{
string perfToolsPath = GetPerfToolsPath();
string perfMonPath = Path.Combine(perfToolsPath, "VSPerfMon.exe");
if (!File.Exists(perfMonPath))
{
throw new InvalidOperationException(Strings.CannotLocatePerformanceTools);
}
var psi = new ProcessStartInfo(perfMonPath, "/trace /output:" + ProcessOutput.QuoteSingleArgument(filename));
psi.CreateNoWindow = true;
psi.UseShellExecute = false;
psi.RedirectStandardError = true;
psi.RedirectStandardOutput = true;
Process.Start(psi).Dispose();
string perfCmdPath = Path.Combine(perfToolsPath, "VSPerfCmd.exe");
using (var p = ProcessOutput.RunHiddenAndCapture(perfCmdPath, "/waitstart")) {
p.Wait();
if (p.ExitCode != 0)
{
throw new InvalidOperationException(Strings.StartPerfCmdError.FormatUI(
string.Join(Environment.NewLine, p.StandardOutputLines),
string.Join(Environment.NewLine, p.StandardErrorLines)
));
}
}
}
private void Save_Executed(object sender, ExecutedRoutedEventArgs e)
{
var path = _provider.BrowseForFileSave(
new WindowInteropHelper(this).Handle,
Strings.DiagnosticsWindow_TextFileFilter,
PathUtils.GetAbsoluteFilePath(
Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
Strings.DiagnosticsWindow_DefaultFileName.FormatUI(DateTime.Now)
)
);
if (string.IsNullOrEmpty(path))
{
return;
}
try {
TaskDialog.CallWithRetry(
_ => File.WriteAllText(path, _info.Result),
_provider,
Strings.ProductTitle,
Strings.FailedToSaveDiagnosticInfo,
Strings.ErrorDetail,
Strings.Retry,
Strings.Cancel
);
Process.Start("explorer.exe", "/select," + ProcessOutput.QuoteSingleArgument(path)).Dispose();
} catch (OperationCanceledException) {
}
}
private void StartPerfMon(string filename)
{
string perfToolsPath = GetPerfToolsPath();
string perfMonPath = Path.Combine(perfToolsPath, "VSPerfMon.exe");
var psi = new ProcessStartInfo(perfMonPath, "/trace /output:" + ProcessOutput.QuoteSingleArgument(filename));
psi.CreateNoWindow = true;
psi.UseShellExecute = false;
psi.RedirectStandardError = true;
psi.RedirectStandardOutput = true;
var process = Process.Start(psi);
string perfCmdPath = Path.Combine(perfToolsPath, "VSPerfCmd.exe");
psi = new ProcessStartInfo(perfCmdPath, "/waitstart");
psi.CreateNoWindow = true;
psi.UseShellExecute = false;
psi.RedirectStandardError = true;
psi.RedirectStandardOutput = true;
process = Process.Start(psi);
process.WaitForExit();
if (process.ExitCode != 0)
{
throw new InvalidOperationException("Starting perf cmd failed: " + process.StandardOutput.ReadToEnd());
}
}
/// <summary>
/// Creates language specific command line for starting the project without debigging.
/// </summary>
public string CreateCommandLineNoDebug(string startupFile, IPythonProjectLaunchProperties props)
{
return(string.Join(" ", new[] {
props.GetInterpreterArguments(),
ProcessOutput.QuoteSingleArgument(startupFile),
props.GetArguments()
}.Where(s => !string.IsNullOrEmpty(s))));
}
/// <summary>
/// Creates language specific command line for starting the project with debigging.
/// </summary>
public string CreateCommandLineDebug(string startupFile, IPythonProjectLaunchProperties props)
{
return(string.Join(" ", new[] {
(props.GetIsNativeDebuggingEnabled() ?? false) ? props.GetInterpreterArguments() : null,
ProcessOutput.QuoteSingleArgument(startupFile),
props.GetArguments()
}.Where(s => !string.IsNullOrEmpty(s))));
}
public ProfiledProcess(PythonToolsService pyService, string exe, string args, string dir, Dictionary <string, string> envVars)
{
var arch = NativeMethods.GetBinaryType(exe);
if (arch != ProcessorArchitecture.X86 && arch != ProcessorArchitecture.Amd64)
{
throw new InvalidOperationException(Strings.UnsupportedArchitecture.FormatUI(arch));
}
dir = PathUtils.TrimEndSeparator(dir);
if (string.IsNullOrEmpty(dir))
{
dir = ".";
}
_pyService = pyService;
_exe = exe;
_args = args;
_dir = dir;
_arch = arch;
ProcessStartInfo processInfo;
string pythonInstallDir = Path.GetDirectoryName(PythonToolsInstallPath.GetFile("VsPyProf.dll", typeof(ProfiledProcess).Assembly));
string dll = _arch == ProcessorArchitecture.Amd64 ? "VsPyProf.dll" : "VsPyProfX86.dll";
string arguments = string.Join(" ",
ProcessOutput.QuoteSingleArgument(Path.Combine(pythonInstallDir, "proflaun.py")),
ProcessOutput.QuoteSingleArgument(Path.Combine(pythonInstallDir, dll)),
ProcessOutput.QuoteSingleArgument(dir),
_args
);
processInfo = new ProcessStartInfo(_exe, arguments);
if (_pyService.DebuggerOptions.WaitOnNormalExit)
{
processInfo.EnvironmentVariables["VSPYPROF_WAIT_ON_NORMAL_EXIT"] = "1";
}
if (_pyService.DebuggerOptions.WaitOnAbnormalExit)
{
processInfo.EnvironmentVariables["VSPYPROF_WAIT_ON_ABNORMAL_EXIT"] = "1";
}
processInfo.CreateNoWindow = false;
processInfo.UseShellExecute = false;
processInfo.RedirectStandardOutput = false;
processInfo.WorkingDirectory = _dir;
if (envVars != null)
{
foreach (var keyValue in envVars)
{
processInfo.EnvironmentVariables[keyValue.Key] = keyValue.Value;
}
}
_process = new Process();
_process.StartInfo = processInfo;
}
public async Task <bool> InstallAsync(PackageSpec package, IPackageManagerUI ui, CancellationToken cancellationToken)
{
AbortOnInvalidConfiguration();
await AbortIfNotReady(cancellationToken);
bool success = false;
var args = new List <string>();
args.Add("install");
args.Add("-p");
args.Add(ProcessOutput.QuoteSingleArgument(_factory.Configuration.GetPrefixPath()));
args.Add("-y");
args.Add(package.FullSpec);
var name = string.IsNullOrEmpty(package.Name) ? package.FullSpec : package.Name;
var operation = string.Join(" ", args);
using (await _working.LockAsync(cancellationToken)) {
ui?.OnOperationStarted(this, operation);
ui?.OnOutputTextReceived(this, Strings.InstallingPackageStarted.FormatUI(name));
var envVars = await GetEnvironmentVariables();
try {
using (var output = ProcessOutput.Run(
_condaPath,
args,
_factory.Configuration.GetPrefixPath(),
envVars,
false,
PackageManagerUIRedirector.Get(this, ui),
quoteArgs: false,
elevate: await ShouldElevate(ui, operation)
)) {
if (!output.IsStarted)
{
return(false);
}
var exitCode = await output;
success = exitCode == 0;
}
return(success);
} catch (IOException) {
return(false);
} finally {
if (!success)
{
// Check whether we failed because conda is missing
UpdateIsReadyAsync(true, CancellationToken.None).DoNotWait();
}
var msg = success ? Strings.InstallingPackageSuccess : Strings.InstallingPackageFailed;
ui?.OnOutputTextReceived(this, msg.FormatUI(name));
ui?.OnOperationFinished(this, operation, success);
await CacheInstalledPackagesAsync(true, false, cancellationToken);
}
}
}
private static void RunVTune(SessionNode session, LaunchConfiguration config, bool openReport)
{
var interpreter = config.GetInterpreterPath();
if (!File.Exists(interpreter))
{
MessageBox.Show(Strings.CannotFindPythonInterpreter, Strings.ProductTitle);
return;
}
string outPathDir = Path.GetTempPath();
var subpath = Path.Combine(outPathDir, Path.GetRandomFileName());
while (Directory.Exists(subpath) || File.Exists(subpath))
{
subpath = Path.Combine(outPathDir, Path.GetRandomFileName());
}
outPathDir = subpath;
string outPath = Path.Combine(outPathDir, "pythontrace.diagsession");
var driver = PythonToolsInstallPath.GetFile(ExternalProfilerDriverExe, typeof(PythonProfilingPackage).Assembly);
var procInfo = new ProcessStartInfo(driver)
{
CreateNoWindow = false,
Arguments = string.Join(" ", new[] {
"-d",
ProcessOutput.QuoteSingleArgument(outPathDir),
"--",
ProcessOutput.QuoteSingleArgument(interpreter),
config.InterpreterArguments,
string.IsNullOrEmpty(config.ScriptName) ? "" : ProcessOutput.QuoteSingleArgument(config.ScriptName),
config.ScriptArguments
}),
WorkingDirectory = config.WorkingDirectory,
};
var proc = new Process {
StartInfo = procInfo
};
var dte = (EnvDTE.DTE)session._serviceProvider.GetService(typeof(EnvDTE.DTE));
proc.EnableRaisingEvents = true;
proc.Exited += (_, args) => {
if (!File.Exists(Path.Combine(outPathDir, "Sample.dwjson")))
{
MessageBox.Show(Strings.CannotFindGeneratedFile, Strings.ProductTitle);
}
else
{
PackageTrace(outPathDir);
dte.ItemOperations.OpenFile(Path.Combine(outPathDir, "trace.diagsession"));
}
};
proc.Start();
}
public async Task Run()
{
var service = _project.Site.GetComponentModel().GetService <IInterpreterRegistryService>();
IPythonInterpreterFactory factory;
try {
var baseInterp = service.FindInterpreter(_baseInterpreter);
factory = await _project.CreateOrAddVirtualEnvironment(
service,
_create,
_virtualEnvPath,
baseInterp,
_useVEnv
);
} catch (Exception ex) when(!ex.IsCriticalException())
{
WriteError(ex.Message);
factory = null;
}
if (factory == null)
{
return;
}
var txt = PathUtils.GetAbsoluteFilePath(_project.ProjectHome, "requirements.txt");
if (!_installRequirements || !File.Exists(txt))
{
return;
}
if (factory.PackageManager == null)
{
WriteError(
Strings.PackageManagementNotSupported_Package.FormatUI(PathUtils.GetFileOrDirectoryName(txt))
);
return;
}
WriteOutput(Strings.RequirementsTxtInstalling.FormatUI(txt));
if (await factory.PackageManager.InstallAsync(
PackageSpec.FromArguments("-r " + ProcessOutput.QuoteSingleArgument(txt)),
new VsPackageManagerUI(_project.Site),
CancellationToken.None
))
{
WriteOutput(Strings.PackageInstallSucceeded.FormatUI(Path.GetFileName(txt)));
}
else
{
WriteOutput(Strings.PackageInstallFailed.FormatUI(Path.GetFileName(txt)));
}
}
private void SaveToFile(bool includeAnalysisLogs)
{
string initialPath = null;
try {
initialPath = PathUtils.GetAbsoluteFilePath(
Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
Strings.DiagnosticsWindow_DefaultFileName.FormatUI(DateTime.Now)
);
} catch (Exception ex) when(!ex.IsCriticalException())
{
Debug.Fail(ex.ToUnhandledExceptionMessage(GetType()));
}
var path = Site.BrowseForFileSave(
_window.Handle,
Strings.DiagnosticsWindow_TextFileFilter,
initialPath
);
if (string.IsNullOrEmpty(path))
{
return;
}
Cursor.Current = Cursors.WaitCursor;
try {
try {
TaskDialog.CallWithRetry(
_ => {
using (var log = new StreamWriter(path, false, new UTF8Encoding(false))) {
PyService.GetDiagnosticsLog(log, includeAnalysisLogs);
}
},
Site,
Strings.ProductTitle,
Strings.FailedToSaveDiagnosticInfo,
Strings.ErrorDetail,
Strings.Retry,
Strings.Cancel
);
if (File.Exists(path))
{
Process.Start(
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Windows), "explorer.exe"),
"/select," + ProcessOutput.QuoteSingleArgument(path)
)?.Dispose();
}
} catch (OperationCanceledException) {
}
} finally {
Cursor.Current = Cursors.Arrow;
}
}
/// <summary>
/// Creates language specific command line for starting the project with debigging.
/// </summary>
public string CreateCommandLineDebug(string startupFile, bool includeInterpreterArgs)
{
string interpArgs = includeInterpreterArgs ? _project.GetProperty(PythonConstants.InterpreterArgumentsSetting) : null;
string cmdLineArgs = _project.GetProperty(CommonConstants.CommandLineArguments) ?? string.Empty;
return(string.Join(" ", new[] {
interpArgs,
ProcessOutput.QuoteSingleArgument(startupFile),
cmdLineArgs
}.Where(s => !string.IsNullOrEmpty(s))));
}
public void AddArgumentAtStart(string argument)
{
if (string.IsNullOrEmpty(Arguments))
{
Arguments = ProcessOutput.QuoteSingleArgument(argument);
}
else
{
Arguments = ProcessOutput.QuoteSingleArgument(argument) + " " + Arguments;
}
}
public void AddArgumentAtEnd(string argument)
{
if (string.IsNullOrEmpty(Arguments))
{
Arguments = ProcessOutput.QuoteSingleArgument(argument);
}
else
{
Arguments += " " + ProcessOutput.QuoteSingleArgument(argument);
}
}
public async Task <bool> ExportExplicitSpecificationFileAsync(string envPath, string destinationSpecFilePath, ICondaEnvironmentManagerUI ui, CancellationToken ct)
{
var args = new[] {
"list",
"--explicit",
"-p",
ProcessOutput.QuoteSingleArgument(envPath),
};
return(await ExportAsync(envPath, destinationSpecFilePath, args, ui, ct));
}
private static IEnumerable <string> QuotedArgumentsWithPackageName(IEnumerable <string> args, string package)
{
var quotedArgs = string.Join(" ", args.Select(a => ProcessOutput.QuoteSingleArgument(a))) + " ";
if (Directory.Exists(package) || File.Exists(package))
{
yield return(quotedArgs + ProcessOutput.QuoteSingleArgument(package));
}
else
{
yield return(quotedArgs + package);
}
}
private static string GetArgs(LaunchConfiguration config)
{
var args = string.Join(" ", new[] {
config.InterpreterArguments,
config.ScriptName == null ? "" : ProcessOutput.QuoteSingleArgument(config.ScriptName),
config.ScriptArguments
}.Where(s => !string.IsNullOrEmpty(s)));
if (config.Environment != null)
{
args = DoSubstitutions(config.Environment, args);
}
return(args);
}
private static void RunProfiler(SessionNode session, LaunchConfiguration config, bool openReport)
{
var process = new ProfiledProcess(
(PythonToolsService)session._serviceProvider.GetService(typeof(PythonToolsService)),
config.GetInterpreterPath(),
string.Join(" ", ProcessOutput.QuoteSingleArgument(config.ScriptName), config.ScriptArguments),
config.WorkingDirectory,
session._serviceProvider.GetPythonToolsService().GetFullEnvironment(config)
);
string baseName = Path.GetFileNameWithoutExtension(session.Filename);
string date = DateTime.Now.ToString("yyyyMMdd");
string outPath = Path.Combine(Path.GetTempPath(), baseName + "_" + date + ".vsp");
int count = 1;
while (File.Exists(outPath))
{
outPath = Path.Combine(Path.GetTempPath(), baseName + "_" + date + "(" + count + ").vsp");
count++;
}
process.ProcessExited += (sender, args) => {
var dte = (EnvDTE.DTE)session._serviceProvider.GetService(typeof(EnvDTE.DTE));
_profilingProcess = null;
_stopCommand.Enabled = false;
_startCommand.Enabled = true;
if (openReport && File.Exists(outPath))
{
for (int retries = 10; retries > 0; --retries)
{
try {
using (new FileStream(outPath, FileMode.Open, FileAccess.Read, FileShare.None)) { }
break;
} catch (IOException) {
Thread.Sleep(100);
}
}
dte.ItemOperations.OpenFile(outPath);
}
};
session.AddProfile(outPath);
process.StartProfiling(outPath);
_profilingProcess = process;
_stopCommand.Enabled = true;
_startCommand.Enabled = false;
}
public async Task <CondaCreateDryRunResult> PreviewCreateAsync(string newEnvNameOrPath, IEnumerable <PackageSpec> packageSpecs, CancellationToken ct)
{
using (await _working.LockAsync(ct)) {
var args = new[] {
"create",
IsAbsolutePath(newEnvNameOrPath) ? "-p" : "-n",
ProcessOutput.QuoteSingleArgument(newEnvNameOrPath),
"-y",
"--dry-run",
"--json",
}.Union(packageSpecs.Select(s => s.FullSpec));
return(await DoPreviewOperationAsync(args, ct));
}
}
public async Task Run()
{
var service = _project.Site.GetComponentModel().GetService <IInterpreterRegistryService>();
IPythonInterpreterFactory factory;
try {
factory = await _project.CreateOrAddVirtualEnvironment(
service,
_create,
_virtualEnvPath,
_baseInterpreter,
_useVEnv
);
} catch (Exception ex) when(!ex.IsCriticalException())
{
WriteError(ex.Message);
factory = null;
}
if (factory == null)
{
return;
}
var txt = PathUtils.GetAbsoluteFilePath(_project.ProjectHome, "requirements.txt");
if (!_installRequirements || !File.Exists(txt))
{
return;
}
WriteOutput(Strings.RequirementsTxtInstalling.FormatUI(txt));
if (await Pip.Install(
_project.Site,
factory,
"-r " + ProcessOutput.QuoteSingleArgument(txt),
false, // never elevate for a virtual environment
_output
))
{
WriteOutput(Strings.PackageInstallSucceeded.FormatUI(Path.GetFileName(txt)));
}
else
{
WriteOutput(Strings.PackageInstallFailed.FormatUI(Path.GetFileName(txt)));
}
}
public async Task <bool> CreateFromEnvironmentFileAsync(string newEnvNameOrPath, string sourceEnvFilePath, ICondaEnvironmentManagerUI ui, CancellationToken ct)
{
bool success = false;
using (await _working.LockAsync(ct)) {
await EnsureActivatedAsync();
var args = new[] {
"env",
"create",
IsAbsolutePath(newEnvNameOrPath) ? "-p" : "-n",
ProcessOutput.QuoteSingleArgument(newEnvNameOrPath),
"-f",
ProcessOutput.QuoteSingleArgument(sourceEnvFilePath),
};
var operation = "conda " + string.Join(" ", args);
ui?.OnOperationStarted(this, operation);
ui?.OnOutputTextReceived(this, Strings.CondaCreateStarted.FormatUI(newEnvNameOrPath));
try {
if (!PathUtils.IsValidPath(newEnvNameOrPath))
{
ui?.OnErrorTextReceived(this, Strings.CondaCreateInvalidNameOrPath.FormatUI(newEnvNameOrPath));
success = false;
return(success);
}
if (!File.Exists(sourceEnvFilePath))
{
ui?.OnErrorTextReceived(this, Strings.CondaFileNotFoundError.FormatUI(sourceEnvFilePath));
success = false;
return(success);
}
success = await DoOperationAsync(args, ui, ct);
return(success);
} finally {
var msg = success ? Strings.CondaCreateSuccess : Strings.CondaCreateFailed;
ui?.OnOutputTextReceived(this, msg.FormatUI(newEnvNameOrPath));
ui?.OnOperationFinished(this, operation, success);
}
}
}
public void ArgumentQuoting()
{
foreach (var testCase in new[] {
new { Source = "Abc", Expected = "Abc" },
new { Source = "Abc 123", Expected = "\"Abc 123\"" },
// A"B"C => "A\"B\"C"
new { Source = "A\"B\"C", Expected = "\"A\\\"B\\\"C\"" },
// "AB\"C" => "AB\"C"
new { Source = "\"AB\\\"C\"", Expected = "\"AB\\\"C\"" },
// "AB"C" => "\"AB\"C\""
new { Source = "\"AB\"C\"", Expected = "\"\\\"AB\\\"C\\\"\"" },
// C:\Program Files\Application Path\ => "C:\Program Files\Application Path\\"
new { Source = @"C:\Program Files\Application Path\", Expected = "\"C:\\Program Files\\Application Path\\\\\"" },
// C:\Program Files\Application Path => "C:\Program Files\Application Path"
new { Source = @"C:\Program Files\Application Path", Expected = "\"C:\\Program Files\\Application Path\"" },
}) {
Assert.AreEqual(testCase.Expected, ProcessOutput.QuoteSingleArgument(testCase.Source), string.Format("Source:<{0}>", testCase.Source));
}
}
public async Task Run()
{
var service = _project.Site.GetComponentModel().GetService <IInterpreterOptionsService>();
var factory = await _project.CreateOrAddVirtualEnvironment(
service,
_create,
_virtualEnvPath,
_baseInterpreter,
_useVEnv
);
if (factory == null)
{
return;
}
var txt = CommonUtils.GetAbsoluteFilePath(_project.ProjectHome, "requirements.txt");
if (!_installRequirements || !File.Exists(txt))
{
return;
}
WriteOutput(SR.RequirementsTxtInstalling, txt);
if (await Pip.Install(
_project.Site,
factory,
"-r " + ProcessOutput.QuoteSingleArgument(txt),
false, // never elevate for a virtual environment
_output
))
{
WriteOutput(SR.PackageInstallSucceeded, Path.GetFileName(txt));
}
else
{
WriteOutput(SR.PackageInstallFailed, Path.GetFileName(txt));
}
}
private void SaveToFile(bool includeAnalysisLogs)
{
var path = PyService.Site.BrowseForFileSave(
_window.Handle,
Strings.DiagnosticsWindow_TextFileFilter,
PathUtils.GetAbsoluteFilePath(
Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
Strings.DiagnosticsWindow_DefaultFileName.FormatUI(DateTime.Now)
)
);
if (string.IsNullOrEmpty(path))
{
return;
}
Cursor.Current = Cursors.WaitCursor;
try {
try {
var log = PyService.GetDiagnosticsLog(includeAnalysisLogs);
TaskDialog.CallWithRetry(
_ => File.WriteAllText(path, log),
PyService.Site,
Strings.ProductTitle,
Strings.FailedToSaveDiagnosticInfo,
Strings.ErrorDetail,
Strings.Retry,
Strings.Cancel
);
Process.Start("explorer.exe", "/select," + ProcessOutput.QuoteSingleArgument(path)).Dispose();
} catch (OperationCanceledException) {
}
} finally {
Cursor.Current = Cursors.Arrow;
}
}
public async Task InstallPackagesAsync()
{
WriteOutput(Strings.RequirementsTxtInstalling.FormatUI(_reqsPath));
bool success = false;
try {
var ui = new VsPackageManagerUI(_site);
if (!_pm.IsReady)
{
await _pm.PrepareAsync(ui, CancellationToken.None);
}
success = await _pm.InstallAsync(
PackageSpec.FromArguments("-r " + ProcessOutput.QuoteSingleArgument(_reqsPath)),
ui,
CancellationToken.None
);
} catch (InvalidOperationException ex) {
WriteOutput(ex.Message);
throw;
} catch (Exception ex) when(!ex.IsCriticalException())
{
WriteOutput(ex.Message);
Debug.Fail(ex.ToUnhandledExceptionMessage(GetType()));
throw;
} finally {
if (success)
{
WriteOutput(Strings.PackageInstallSucceeded.FormatUI(Path.GetFileName(_reqsPath)));
}
else
{
var msg = Strings.PackageInstallFailed.FormatUI(Path.GetFileName(_reqsPath));
WriteOutput(msg);
throw new ApplicationException(msg);
}
}
}
private static async Task <int> ContinueRun(
IPythonInterpreterFactory factory,
Redirector output,
bool elevate,
params string[] cmd
)
{
bool isScript;
var easyInstallPath = GetEasyInstallPath(factory, out isScript);
if (easyInstallPath == null)
{
throw new FileNotFoundException("Cannot find setuptools ('easy_install.exe')");
}
var args = cmd.ToList();
args.Insert(0, "--always-copy");
args.Insert(0, "--always-unzip");
if (isScript)
{
args.Insert(0, ProcessOutput.QuoteSingleArgument(easyInstallPath));
easyInstallPath = factory.Configuration.InterpreterPath;
}
using (var proc = ProcessOutput.Run(
easyInstallPath,
args,
factory.Configuration.PrefixPath,
UnbufferedEnv,
false,
output,
false,
elevate
)) {
return(await proc);
}
}
private static string BuildArguments(IEnumerable <string> values)
{
// Examples of valid results:
// "C:\My Folder\"
// C:\MyFolder\MyFile.txt /e:"Source Code (text) Editor"
//
// Examples of invalid results:
// C:\My Folder
// C:\MyFolder\MyFile.txt "/e:Source Code (text) Editor"
// C:\MyFolder\MyFile.txt /e: "Source Code (text) Editor"
// C:\MyFolder\MyFile.txt /e:Source Code (text) Editor
StringBuilder args = new StringBuilder();
bool insertSpace = false;
foreach (var val in values)
{
if (insertSpace)
{
args.Append(" ");
}
if (val.EndsWith(":"))
{
args.Append(val);
// no space after a switch that takes a value
insertSpace = false;
}
else
{
args.Append(ProcessOutput.QuoteSingleArgument(val));
insertSpace = true;
}
}
return(args.ToString());
}