public async Task PrepareAsync(IPackageManagerUI ui, CancellationToken cancellationToken) { if (IsReady) { return; } AbortOnInvalidConfiguration(); await UpdateIsReadyAsync(false, cancellationToken); if (IsReady) { return; } var operation = "pip_downloader.py"; var args = _extraInterpreterArgs .Concat(new[] { PythonToolsInstallPath.GetFile("pip_downloader.py", GetType().Assembly) }); using (await _working.LockAsync(cancellationToken)) { ui?.OnOperationStarted(this, operation); ui?.OnOutputTextReceived(this, Strings.InstallingPipStarted); using (var proc = ProcessOutput.Run( _factory.Configuration.InterpreterPath, args, _factory.Configuration.PrefixPath, UnbufferedEnv, false, PackageManagerUIRedirector.Get(this, ui), elevate: await ShouldElevate(ui, operation) )) { try { IsReady = (await proc == 0); } catch (OperationCanceledException) { IsReady = false; } } ui?.OnOutputTextReceived(this, IsReady ? Strings.InstallingPipSuccess : Strings.InstallingPackageFailed); ui?.OnOperationFinished(this, operation, IsReady); } }
/// <summary> /// Attaches to the specified PID and returns a DebugAttach object indicating the result. /// </summary> internal static DebugAttach AttachAD7Worker(int pid, int portNum, Guid debugId, string debugOptions, EventWaitHandle attachDoneEvent = null) { var hProcess = NativeMethods.OpenProcess(ProcessAccessFlags.All, false, pid); if (hProcess != IntPtr.Zero) { string dllPath; if (IntPtr.Size == 4) { dllPath = PythonToolsInstallPath.GetFile("PyDebugAttachX86.dll"); } else { dllPath = PythonToolsInstallPath.GetFile("PyDebugAttach.dll"); } if (!File.Exists(dllPath)) { return(new DebugAttach(ConnErrorMessages.PyDebugAttachNotFound)); } // load our code into the process... // http://msdn.microsoft.com/en-us/library/windows/desktop/ms682631(v=vs.85).aspx // If the module list in the target process is corrupted or not yet initialized, // or if the module list changes during the function call as a result of DLLs // being loaded or unloaded, EnumProcessModules may fail or return incorrect // information. // So we'll retry a handful of times to get the attach... ConnErrorMessages error = ConnErrorMessages.None; for (int i = 0; i < 5; i++) { IntPtr hKernel32; if ((error = FindKernel32(hProcess, out hKernel32)) == ConnErrorMessages.None) { return(InjectDebugger(dllPath, hProcess, hKernel32, portNum, pid, debugId, debugOptions, attachDoneEvent)); } } return(new DebugAttach(error)); } return(new DebugAttach(ConnErrorMessages.CannotOpenProcess)); }
/// <summary> /// Returns true if a missing package is detected. A package could be missing and not be detected (Git+...) /// Returns false when a missing package is not detected such as file not found exception or invalid file, etc /// </summary> /// <param name="interpreterPath"></param> /// <param name="reqTxtPath"></param> /// <returns></returns> internal static async Task <bool> DetectMissingPackagesAsync(string interpreterPath, string reqTxtPath) { try { var processOutput = ProcessOutput.RunHiddenAndCapture( interpreterPath, PythonToolsInstallPath.GetFile("missing_req_packages.py"), reqTxtPath ); await processOutput; if (processOutput.ExitCode == 1) { return(true); } } catch (Exception) { // Do nothing. End of function will return false because no missing packages detected due to exception } return(false); }
public async Task InstallPip() { AbortOnInvalidConfiguration(); using (await WaitAndLockPip()) { OnOperationStarted(Resources.InstallingPipStarted); using (var output = ProcessOutput.Run( _factory.Configuration.InterpreterPath, new[] { PythonToolsInstallPath.GetFile("pip_downloader.py") }, _factory.Configuration.PrefixPath, UnbufferedEnv, false, _output, elevate: ShouldElevate )) { bool success = true; try { var exitCode = await output; if (exitCode != 0) { success = false; throw new PipException(Resources.InstallationFailed); } } catch (OperationCanceledException) { success = false; } catch (Exception ex) { success = false; if (ex.IsCriticalException()) { throw; } ToolWindow.UnhandledException.Execute(ExceptionDispatchInfo.Capture(ex), WpfObject); } finally { OnOperationFinished( success ? Resources.InstallingPipSuccess : Resources.InstallingPipFailed ); } } } }
public void ProjectItemFinishedGenerating(ProjectItem projectItem) { if (!projectItem.Name.Equals("web.debug.config", StringComparison.OrdinalIgnoreCase)) { return; } var projectDir = PathUtils.GetParent(projectItem.FileNames[0]); // Also copy Microsoft.PythonTools.WebRole.dll and ptvsd into the project var ptvsdSource = PythonToolsInstallPath.TryGetFile("ptvsd\\__init__.py", GetType().Assembly); var ptvsdDest = PathUtils.GetAbsoluteDirectoryPath(projectDir, "ptvsd"); if (File.Exists(ptvsdSource) && !Directory.Exists(ptvsdDest)) { Directory.CreateDirectory(ptvsdDest); var sourceDir = PathUtils.GetParent(ptvsdSource); foreach (var file in PathUtils.EnumerateFiles(sourceDir, pattern: "*.py", fullPaths: false)) { var destFile = PathUtils.GetAbsoluteFilePath(ptvsdDest, file); if (!Directory.Exists(PathUtils.GetParent(destFile))) { Directory.CreateDirectory(PathUtils.GetParent(destFile)); } File.Copy(PathUtils.GetAbsoluteFilePath(sourceDir, file), destFile, true); } projectItem.ContainingProject.ProjectItems.AddFromDirectory(PathUtils.TrimEndSeparator(ptvsdDest)); } var webRoleSource = PythonToolsInstallPath.TryGetFile("Microsoft.PythonTools.WebRole.dll", GetType().Assembly); if (File.Exists(webRoleSource)) { projectItem.ContainingProject.ProjectItems.AddFromFileCopy(webRoleSource); } }
protected override void Connect() { _serviceProvider.GetUIThread().MustBeCalledFromUIThread(); var configurableOptions = CurrentOptions as ConfigurablePythonReplOptions; if (configurableOptions != null) { _interpreter = configurableOptions.InterpreterFactory ?? _interpreter; } if (Interpreter == null || Interpreter is UnavailableFactory) { Window.WriteError(SR.GetString(SR.ReplEvaluatorInterpreterNotFound)); return; } else if (String.IsNullOrWhiteSpace(Interpreter.Configuration.InterpreterPath)) { Window.WriteError(SR.GetString(SR.ReplEvaluatorInterpreterNotConfigured, Interpreter.Description)); return; } var processInfo = new ProcessStartInfo(Interpreter.Configuration.InterpreterPath); #if DEBUG bool debugMode = Environment.GetEnvironmentVariable("DEBUG_REPL") != null; processInfo.CreateNoWindow = !debugMode; processInfo.UseShellExecute = debugMode; processInfo.RedirectStandardOutput = !debugMode; processInfo.RedirectStandardError = !debugMode; processInfo.RedirectStandardInput = !debugMode; #else processInfo.CreateNoWindow = true; processInfo.UseShellExecute = false; processInfo.RedirectStandardOutput = true; processInfo.RedirectStandardError = true; processInfo.RedirectStandardInput = true; #endif Socket conn; int portNum; CreateConnection(out conn, out portNum); List <string> args = new List <string>(); if (!String.IsNullOrWhiteSpace(CurrentOptions.InterpreterOptions)) { args.Add(CurrentOptions.InterpreterOptions); } var workingDir = CurrentOptions.WorkingDirectory; if (!string.IsNullOrEmpty(workingDir)) { processInfo.WorkingDirectory = workingDir; } else if (configurableOptions != null && configurableOptions.Project != null) { processInfo.WorkingDirectory = configurableOptions.Project.GetWorkingDirectory(); } else { processInfo.WorkingDirectory = Interpreter.Configuration.PrefixPath; } #if DEBUG if (!debugMode) { #endif var envVars = CurrentOptions.EnvironmentVariables; if (envVars != null) { foreach (var keyValue in envVars) { processInfo.EnvironmentVariables[keyValue.Key] = keyValue.Value; } } string pathEnvVar = Interpreter.Configuration.PathEnvironmentVariable ?? ""; if (!string.IsNullOrWhiteSpace(pathEnvVar)) { var searchPaths = CurrentOptions.SearchPaths; if (string.IsNullOrEmpty(searchPaths)) { if (_serviceProvider.GetPythonToolsService().GeneralOptions.ClearGlobalPythonPath) { processInfo.EnvironmentVariables[pathEnvVar] = ""; } } else if (_serviceProvider.GetPythonToolsService().GeneralOptions.ClearGlobalPythonPath) { processInfo.EnvironmentVariables[pathEnvVar] = searchPaths; } else { processInfo.EnvironmentVariables[pathEnvVar] = searchPaths + ";" + Environment.GetEnvironmentVariable(pathEnvVar); } } #if DEBUG } #endif var interpreterArgs = CurrentOptions.InterpreterArguments; if (!String.IsNullOrWhiteSpace(interpreterArgs)) { args.Add(interpreterArgs); } var analyzer = CurrentOptions.ProjectAnalyzer; if (analyzer != null && analyzer.InterpreterFactory == _interpreter) { if (_replAnalyzer != null && _replAnalyzer != analyzer) { analyzer.SwitchAnalyzers(_replAnalyzer); } _replAnalyzer = analyzer; _ownsAnalyzer = false; } args.Add(ProcessOutput.QuoteSingleArgument(PythonToolsInstallPath.GetFile("visualstudio_py_repl.py"))); args.Add("--port"); args.Add(portNum.ToString()); if (!String.IsNullOrWhiteSpace(CurrentOptions.StartupScript)) { args.Add("--launch_file"); args.Add(ProcessOutput.QuoteSingleArgument(CurrentOptions.StartupScript)); } _enableAttach = CurrentOptions.EnableAttach; if (CurrentOptions.EnableAttach) { args.Add("--enable-attach"); } bool multipleScopes = true; if (!String.IsNullOrWhiteSpace(CurrentOptions.ExecutionMode)) { // change ID to module name if we have a registered mode var modes = Microsoft.PythonTools.Options.ExecutionMode.GetRegisteredModes(_serviceProvider); string modeValue = CurrentOptions.ExecutionMode; foreach (var mode in modes) { if (mode.Id == CurrentOptions.ExecutionMode) { modeValue = mode.Type; multipleScopes = mode.SupportsMultipleScopes; _supportsMultipleCompleteStatementInputs = mode.SupportsMultipleCompleteStatementInputs; break; } } args.Add("--execution_mode"); args.Add(modeValue); } SetMultipleScopes(multipleScopes); processInfo.Arguments = String.Join(" ", args); var process = new Process(); process.StartInfo = processInfo; try { if (!File.Exists(processInfo.FileName)) { throw new Win32Exception(Microsoft.VisualStudioTools.Project.NativeMethods.ERROR_FILE_NOT_FOUND); } process.Start(); } catch (Exception e) { if (e.IsCriticalException()) { throw; } Win32Exception wex = e as Win32Exception; if (wex != null && wex.NativeErrorCode == Microsoft.VisualStudioTools.Project.NativeMethods.ERROR_FILE_NOT_FOUND) { Window.WriteError(SR.GetString(SR.ReplEvaluatorInterpreterNotFound)); } else { Window.WriteError(SR.GetString(SR.ErrorStartingInteractiveProcess, e.ToString())); } return; } CreateCommandProcessor(conn, processInfo.RedirectStandardOutput, process); }
protected virtual Task <CommandProcessorThread> ConnectAsync(CancellationToken ct) { _serviceProvider.GetUIThread().MustBeCalledFromUIThreadOrThrow(); var interpreterPath = Configuration?.GetInterpreterPath(); if (string.IsNullOrWhiteSpace(interpreterPath)) { WriteError(Strings.ReplEvaluatorInterpreterNotConfigured.FormatUI(DisplayName)); return(null); } else if (!File.Exists(interpreterPath)) { WriteError(Strings.ReplEvaluatorInterpreterNotFound); return(null); } var processInfo = new ProcessStartInfo(interpreterPath); #if DEBUG bool debugMode = Environment.GetEnvironmentVariable("_PTVS_DEBUG_REPL") != null; processInfo.CreateNoWindow = !debugMode; processInfo.UseShellExecute = debugMode; processInfo.RedirectStandardOutput = !debugMode; processInfo.RedirectStandardError = !debugMode; processInfo.RedirectStandardInput = !debugMode; #else processInfo.CreateNoWindow = true; processInfo.UseShellExecute = false; processInfo.RedirectStandardOutput = true; processInfo.RedirectStandardError = true; processInfo.RedirectStandardInput = true; #endif var conn = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP); conn.Bind(new IPEndPoint(IPAddress.Loopback, 0)); conn.Listen(0); var portNum = ((IPEndPoint)conn.LocalEndPoint).Port; var workingDirectory = Configuration.WorkingDirectory; if (!string.IsNullOrEmpty(workingDirectory)) { processInfo.WorkingDirectory = workingDirectory; } else { processInfo.WorkingDirectory = CommonUtils.GetParent(processInfo.FileName); } #if DEBUG if (!debugMode) { #endif var env = processInfo.Environment; foreach (var kv in _serviceProvider.GetPythonToolsService().GetFullEnvironment(Configuration)) { env[kv.Key] = kv.Value; } #if DEBUG } #endif var args = new List <string>(); var interpreterArguments = Configuration.InterpreterArguments; if (!string.IsNullOrWhiteSpace(interpreterArguments)) { args.Add(interpreterArguments); } args.Add(ProcessOutput.QuoteSingleArgument(PythonToolsInstallPath.GetFile("visualstudio_py_repl.py"))); args.Add("--port"); args.Add(portNum.ToString()); args.Add("--execution-mode"); args.Add(string.IsNullOrEmpty(BackendName) ? "standard" : BackendName); processInfo.Arguments = string.Join(" ", args); Process process; try { if (!File.Exists(processInfo.FileName)) { throw new Win32Exception(Microsoft.VisualStudioTools.Project.NativeMethods.ERROR_FILE_NOT_FOUND); } process = Process.Start(processInfo); if (process.WaitForExit(100)) { throw new Win32Exception(process.ExitCode); } } catch (Win32Exception e) { if (e.NativeErrorCode == Microsoft.VisualStudioTools.Project.NativeMethods.ERROR_FILE_NOT_FOUND) { WriteError(Strings.ReplEvaluatorInterpreterNotFound); } else { WriteError(Strings.ErrorStartingInteractiveProcess.FormatUI(e.ToString())); } return(null); } catch (Exception e) when(!e.IsCriticalException()) { return(null); } return(Task.FromResult(CommandProcessorThread.Create(this, conn, process))); }
private async Task <ProcessOutputResult> RunCheckScript(string interpreterPath) { var scriptPath = PythonToolsInstallPath.GetFile("cookiecutter_check.py"); return(await RunPythonScript(interpreterPath, scriptPath, "")); }
/// <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 static async Task <ProcessOutputResult> RunRenderContextScript(Redirector redirector, string interpreterPath, string templateFolderPath, string userConfigFilePath, string outputFolderPath, string contextPath) { var scriptPath = PythonToolsInstallPath.GetFile("cookiecutter_render.py"); return(await RunPythonScript(redirector, interpreterPath, scriptPath, "\"{0}\" \"{1}\" \"{2}\" \"{3}\"".FormatInvariant(templateFolderPath, userConfigFilePath, PathUtils.TrimEndSeparator(outputFolderPath), contextPath))); }
private string GenerateDbFile(IPythonInterpreterFactory interpreter, ModulePath moduleName, List <string> existingModules, string dbFile, FileStream fs) { // we need to generate the DB file dbFile = Path.Combine(ReferencesDatabasePath, moduleName + ".$project.idb"); int retryCount = 0; while (File.Exists(dbFile)) { dbFile = Path.Combine(ReferencesDatabasePath, moduleName + "." + ++retryCount + ".$project.idb"); } var args = new List <string> { PythonToolsInstallPath.GetFile("ExtensionScraper.py"), "scrape", }; if (moduleName.IsNativeExtension) { args.Add("-"); args.Add(moduleName.SourceFile); } else { args.Add(moduleName.ModuleName); args.Add(moduleName.LibraryPath); } args.Add(Path.ChangeExtension(dbFile, null)); using (var output = ProcessOutput.RunHiddenAndCapture(interpreter.Configuration.InterpreterPath, args.ToArray())) { if (_cancel.CanBeCanceled) { if (WaitHandle.WaitAny(new[] { _cancel.WaitHandle, output.WaitHandle }) != 1) { // we were cancelled return(null); } } else { output.Wait(); } if (output.ExitCode == 0) { // [FileName]|interpGuid|interpVersion|DateTimeStamp|[db_file.idb] // save the new entry in the DB file existingModules.Add( String.Format("{0}|{1}|{2}|{3}", moduleName.SourceFile, interpreter.Configuration.Id, new FileInfo(moduleName.SourceFile).LastWriteTime.ToString("O"), dbFile ) ); fs.Seek(0, SeekOrigin.Begin); fs.SetLength(0); using (var sw = new StreamWriter(fs)) { sw.Write(String.Join(Environment.NewLine, existingModules)); sw.Flush(); } } else { throw new CannotAnalyzeExtensionException(string.Join(Environment.NewLine, output.StandardErrorLines)); } } return(dbFile); }
/// <summary> /// Gets the set of search paths by running the interpreter. /// </summary> /// <param name="interpreter">Path to the interpreter.</param> /// <returns>A list of search paths for the interpreter.</returns> /// <remarks>Added in 2.2</remarks> public static async Task <List <PythonLibraryPath> > GetUncachedDatabaseSearchPathsAsync(string interpreter) { List <string> lines; // sys.path will include the working directory, so we make an empty // path that we can filter out later var tempWorkingDir = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName()); Directory.CreateDirectory(tempWorkingDir); var srcGetSearchPaths = PythonToolsInstallPath.GetFile("get_search_paths.py", typeof(PythonTypeDatabase).Assembly); var getSearchPaths = PathUtils.GetAbsoluteFilePath(tempWorkingDir, PathUtils.GetFileOrDirectoryName(srcGetSearchPaths)); File.Copy(srcGetSearchPaths, getSearchPaths); try { using (var proc = ProcessOutput.Run( interpreter, new[] { "-S", // don't import site - we do that in code "-E", // ignore environment getSearchPaths }, tempWorkingDir, null, false, null )) { int exitCode = -1; try { exitCode = await proc; } catch (OperationCanceledException) { } if (exitCode != 0) { throw new InvalidOperationException(string.Format( "Cannot obtain list of paths{0}{1}", Environment.NewLine, string.Join(Environment.NewLine, proc.StandardErrorLines)) ); } lines = proc.StandardOutputLines.ToList(); } } finally { try { Directory.Delete(tempWorkingDir, true); } catch (Exception ex) { if (ex.IsCriticalException()) { throw; } } } return(lines.Select(s => { if (s.StartsWith(tempWorkingDir, StringComparison.OrdinalIgnoreCase)) { return null; } try { return PythonLibraryPath.Parse(s); } catch (FormatException) { Debug.Fail("Invalid format for search path: " + s); return null; } }).Where(p => p != null).ToList()); }
public void Imported(IModuleContext context) { if (_scraped) { return; } _scraped = true; var interp = context as AstPythonInterpreter; var fact = interp?.Factory; if (fact == null || !File.Exists(fact.Configuration.InterpreterPath)) { return; } ModulePath mp = AstPythonInterpreterFactory.FindModule(fact, _filePath); if (string.IsNullOrEmpty(mp.FullName)) { return; } var sm = PythonToolsInstallPath.TryGetFile("scrape_module.py", GetType().Assembly); if (!File.Exists(sm)) { return; } Stream code = null; using (var p = ProcessOutput.RunHiddenAndCapture( fact.Configuration.InterpreterPath, "-E", sm, mp.LibraryPath, mp.ModuleName )) { p.Wait(); if (p.ExitCode == 0) { var ms = new MemoryStream(); code = ms; using (var sw = new StreamWriter(ms, Encoding.UTF8, 4096, true)) { foreach (var line in p.StandardOutputLines) { sw.WriteLine(line); } } } } if (code == null) { return; } PythonAst ast; code.Seek(0, SeekOrigin.Begin); using (var sr = new StreamReader(code, Encoding.UTF8)) using (var parser = Parser.CreateParser(sr, fact.GetLanguageVersion())) { ast = parser.ParseFile(); } lock (_members) { var walker = new AstAnalysisWalker(interp, ast, this, _filePath, _members, false); ast.Walk(walker); } }
/// <summary> /// Publishes the project if the user has configured the publish on run. /// </summary> private bool TryPublishProject(ClusterEnvironment environment, string publishOverrideUrl) { if (_project.PublishBeforeRun() || environment.HeadNode == "localhost") { string msg = null; try { var vsInstallDir = (string)HpcSupportPackage.Instance.ApplicationRegistryRoot.GetValue("InstallDir"); List <IPublishFile> allFiles = new List <IPublishFile>(); // add python debugger files string pyInstallDir = Path.GetDirectoryName(PythonToolsInstallPath.GetFile(_pyDebuggerFiles[0])); foreach (var file in _pyDebuggerFiles) { allFiles.Add(new CopyFile(Path.Combine(pyInstallDir, file), file)); } string pyHpcInstallDir = Path.GetDirectoryName(PythonToolsInstallPath.GetFile(MpiShimExe)); foreach (var file in _hpcDebuggerFiles) { allFiles.Add(new CopyFile(Path.Combine(pyHpcInstallDir, file), file)); } // add VS components that we need to run foreach (var file in _vsAssemblies) { allFiles.Add(new CopyFile(file, Path.GetFileName(file))); } // Add vs remote debugger components. string basePath = Path.Combine(Path.Combine(vsInstallDir, "Remote Debugger"), _project.TargetPlatform().ToString()); if (!Directory.Exists(basePath)) { basePath = Path.Combine( (string)HpcSupportPackage.Instance.ApplicationRegistryRoot.GetValue("ShellFolder", ""), "Common7", "Packages", "Debugger", _project.TargetPlatform().ToString() ); } basePath += "\\"; foreach (var file in Directory.GetFiles(basePath, "*", SearchOption.AllDirectories)) { allFiles.Add(new CopyFile(file, file.Substring(basePath.Length))); } if (!_project.Publish(new PublishProjectOptions(allFiles.ToArray(), publishOverrideUrl))) { msg = "Publishing not configured or unknown publishing schema"; } } catch (PublishFailedException e) { msg = e.InnerException.Message; } if (msg != null && CancelLaunch(msg)) { return(false); } } return(true); }
private static string GetServerLocation() { var filePath = PythonToolsInstallPath.GetFile(@"pylance\dist\pylance-langserver.bundle.js"); return(File.Exists(filePath) ? filePath : null); }
private static async Task <ProcessOutputResult> RunGenerateContextScript(Redirector redirector, string interpreterPath, string templateFolderPath, string userConfigFilePath) { var scriptPath = PythonToolsInstallPath.GetFile("cookiecutter_load.py"); return(await RunPythonScript(redirector, interpreterPath, scriptPath, "\"{0}\" \"{1}\"".FormatInvariant(templateFolderPath, userConfigFilePath))); }
private void StartProcess(string launchJson) { var connection = InitializeListenerSocket(); var json = JObject.Parse(launchJson); var exe = json["exe"].Value <string>(); var args = json["args"].Value <string>(); var cwd = json["cwd"].Value <string>(); ParseOptions(json["options"].Value <string>()); var argsList = new List <string> { string.IsNullOrWhiteSpace(_interpreterOptions) ? "" : _interpreterOptions, PythonToolsInstallPath.GetFile("ptvsd_launcher.py"), cwd.Trim('\\'), $"{_listenerPort}", $"{_processGuid}", $"{_debugOptions}", "-g", args }; var arguments = string.Join(" ", argsList.Where(a => !string.IsNullOrWhiteSpace(a)).Select(ProcessOutput.QuoteSingleArgument)); ProcessStartInfo psi = new ProcessStartInfo { FileName = exe, Arguments = arguments, WorkingDirectory = cwd, RedirectStandardError = false, RedirectStandardInput = false, RedirectStandardOutput = false, UseShellExecute = false, CreateNoWindow = false, }; var env = json["env"].Value <JArray>(); foreach (JObject curValue in env) { var name = curValue["name"].Value <string>(); var value = curValue["value"].Value <string>(); if (!string.IsNullOrWhiteSpace(name)) { psi.EnvironmentVariables[name] = value; } } _process = new Process { EnableRaisingEvents = true, StartInfo = psi }; _process.Exited += OnExited; _process.Start(); try { if (connection.Wait(_debuggerConnectionTimeout)) { var socket = connection.Result; if (socket != null) { _stream = new DebugAdapterProcessStream(new NetworkStream(connection.Result, ownsSocket: true)); } } else { Debug.WriteLine("Timed out waiting for debuggee to connect.", nameof(DebugAdapterProcess)); } } catch (AggregateException ex) { Debug.WriteLine("Error waiting for debuggee to connect {0}".FormatInvariant(ex.InnerException ?? ex), nameof(DebugAdapterProcess)); } if (_stream == null) { _process.Kill(); } }
private static async Task <ProcessOutputResult> RunRunScript(Redirector redirector, string interpreterPath, string templateFolderPath, string userConfigFilePath, string outputFolderPath, string contextPath) { var scriptPath = PythonToolsInstallPath.GetFile("cookiecutter_run.py"); return(await RunPythonScript(redirector, interpreterPath, scriptPath, GetRunArguments(templateFolderPath, userConfigFilePath, outputFolderPath, contextPath))); }
private void StartProcess(string launchJson) { var connection = InitializeListenerSocket(); var json = JObject.Parse(launchJson); var exe = json["exe"].Value <string>(); var scriptAndScriptArgs = json["args"].Value <string>(); var cwd = json["cwd"].Value <string>(); ParseOptions(json["options"].Value <string>()); var argsList = new List <string> { string.IsNullOrWhiteSpace(_interpreterOptions) ? "" : _interpreterOptions, PythonToolsInstallPath.GetFile("ptvsd_launcher.py"), cwd.Trim('\\'), $"{_listenerPort}", $"{_processGuid}", $"{_debugOptions}", "-g" }; var launcherArgs = string.Join(" ", argsList.Where(a => !string.IsNullOrWhiteSpace(a)).Select(ProcessOutput.QuoteSingleArgument)); var arguments = $"{launcherArgs} {scriptAndScriptArgs}"; ProcessStartInfo psi = new ProcessStartInfo { FileName = exe, Arguments = arguments, WorkingDirectory = cwd, RedirectStandardError = false, RedirectStandardInput = false, RedirectStandardOutput = false, UseShellExecute = false, CreateNoWindow = false, }; var env = json["env"].Value <JArray>(); foreach (JObject curValue in env) { var name = curValue["name"].Value <string>(); var value = curValue["value"].Value <string>(); if (!string.IsNullOrWhiteSpace(name)) { psi.EnvironmentVariables[name] = value; } } _process = new Process { EnableRaisingEvents = true, StartInfo = psi }; _process.Exited += OnExited; _process.Start(); var logger = (IPythonToolsLogger)VisualStudio.Shell.ServiceProvider.GlobalProvider.GetService(typeof(IPythonToolsLogger)); try { if (connection.Wait(_debuggerConnectionTimeout)) { var socket = connection.Result; if (socket != null) { _debuggerConnected = true; _stream = new DebugAdapterProcessStream(new NetworkStream(socket, ownsSocket: true)); _stream.Initialized += OnInitialized; _stream.LegacyDebugger += OnLegacyDebugger; if (!string.IsNullOrEmpty(_webBrowserUrl) && Uri.TryCreate(_webBrowserUrl, UriKind.RelativeOrAbsolute, out Uri uri)) { OnPortOpenedHandler.CreateHandler(uri.Port, null, null, ProcessExited, LaunchBrowserDebugger); } } } else { Debug.WriteLine("Timed out waiting for debuggee to connect.", nameof(DebugAdapterProcess)); logger?.LogEvent(PythonLogEvent.DebugAdapterConnectionTimeout, "Launch"); } } catch (AggregateException ex) { Debug.WriteLine("Error waiting for debuggee to connect {0}".FormatInvariant(ex.InnerException ?? ex), nameof(DebugAdapterProcess)); } if (_stream == null && !_process.HasExited) { _process.Kill(); } }
public static async Task <int> GenerateAsync(PythonTypeDatabaseCreationRequest request) { var fact = request.Factory; var evt = request.OnExit; if (fact == null || !Directory.Exists(fact.Configuration.LibraryPath)) { if (evt != null) { evt(NotSupportedExitCode); } return(NotSupportedExitCode); } var outPath = request.OutputPath; var analyzerPath = PythonToolsInstallPath.GetFile("Microsoft.PythonTools.Analyzer.exe"); Directory.CreateDirectory(CompletionDatabasePath); var baseDb = BaselineDatabasePath; if (request.ExtraInputDatabases.Any()) { baseDb = baseDb + ";" + string.Join(";", request.ExtraInputDatabases); } var logPath = Path.Combine(outPath, "AnalysisLog.txt"); var glogPath = Path.Combine(CompletionDatabasePath, "AnalysisLog.txt"); using (var output = ProcessOutput.RunHiddenAndCapture( analyzerPath, "/id", fact.Configuration.Id, "/version", fact.Configuration.Version.ToString(), "/python", fact.Configuration.InterpreterPath, request.DetectLibraryPath ? null : "/library", request.DetectLibraryPath ? null : fact.Configuration.LibraryPath, "/outdir", outPath, "/basedb", baseDb, (request.SkipUnchanged ? null : "/all"), // null will be filtered out; empty strings are quoted "/log", logPath, "/glog", glogPath, "/wait", (request.WaitFor != null ? AnalyzerStatusUpdater.GetIdentifier(request.WaitFor) : "") )) { output.PriorityClass = ProcessPriorityClass.BelowNormal; int exitCode = await output; if (exitCode > -10 && exitCode < 0) { try { File.AppendAllLines( glogPath, new[] { string.Format("FAIL_STDLIB: ({0}) {1}", exitCode, output.Arguments) } .Concat(output.StandardErrorLines) ); } catch (IOException) { } catch (ArgumentException) { } catch (SecurityException) { } catch (UnauthorizedAccessException) { } } if (evt != null) { evt(exitCode); } return(exitCode); } }
private string Check(string interpreterPath) { var checkScript = PythonToolsInstallPath.GetFile("cookiecutter_check.py"); return(RunPythonScript(interpreterPath, checkScript, "")); }
public override IEnumerable <string> Prepare() => new[] { PythonToolsInstallPath.GetFile("pip_downloader.py", typeof(PipPackageManager).Assembly) };
private async Task <ProcessOutputResult> RunGenerateContextScript(string interpreterPath, string templateFolderPath, string userConfigFilePath) { var scriptPath = PythonToolsInstallPath.GetFile("cookiecutter_load.py"); return(await RunPythonScript(interpreterPath, scriptPath, string.Format("\"{0}\" \"{1}\"", templateFolderPath, userConfigFilePath))); }