Ensure conda info command isn't run multiple times during startup when large number of conda interpreters are present (#18808)

Author: Kartik Raj

news/2 Fixes/18200.md

@@ -0,0 +1 @@
+Ensure `conda info` command isn't run multiple times during startup when large number of conda interpreters are present.

src/client/pythonEnvironments/base/locators/composite/envsResolver.ts

@@ -78,7 +78,7 @@ export class PythonEnvsResolver implements IResolvingLocator {
                     );
                 } else if (seen[event.index] !== undefined) {
                     const old = seen[event.index];
-                    seen[event.index] = await resolveBasicEnv(event.update);
+                    seen[event.index] = await resolveBasicEnv(event.update, true);
                     didUpdate.fire({ old, index: event.index, update: seen[event.index] });
                     this.resolveInBackground(event.index, state, didUpdate, seen).ignoreErrors();
                 } else {
@@ -92,7 +92,8 @@ export class PythonEnvsResolver implements IResolvingLocator {
 
         let result = await iterator.next();
         while (!result.done) {
-            const currEnv = await resolveBasicEnv(result.value);
+            // Use cache from the current refresh where possible.
+            const currEnv = await resolveBasicEnv(result.value, true);
             seen.push(currEnv);
             yield currEnv;
             this.resolveInBackground(seen.indexOf(currEnv), state, didUpdate, seen).ignoreErrors();

src/client/pythonEnvironments/base/locators/composite/resolverUtils.ts

@@ -27,8 +27,8 @@ import { BasicEnvInfo } from '../../locator';
 import { parseVersionFromExecutable } from '../../info/executable';
 import { traceError, traceWarn } from '../../../../logging';
 
-function getResolvers(): Map<PythonEnvKind, (env: BasicEnvInfo) => Promise<PythonEnvInfo>> {
-    const resolvers = new Map<PythonEnvKind, (_: BasicEnvInfo) => Promise<PythonEnvInfo>>();
+function getResolvers(): Map<PythonEnvKind, (env: BasicEnvInfo, useCache?: boolean) => Promise<PythonEnvInfo>> {
+    const resolvers = new Map<PythonEnvKind, (_: BasicEnvInfo, useCache?: boolean) => Promise<PythonEnvInfo>>();
     Object.values(PythonEnvKind).forEach((k) => {
         resolvers.set(k, resolveGloballyInstalledEnv);
     });
@@ -46,11 +46,11 @@ function getResolvers(): Map<PythonEnvKind, (env: BasicEnvInfo) => Promise<Pytho
  * executable and returns it. Notice `undefined` is never returned, so environment
  * returned could still be invalid.
  */
-export async function resolveBasicEnv(env: BasicEnvInfo): Promise<PythonEnvInfo> {
+export async function resolveBasicEnv(env: BasicEnvInfo, useCache = false): Promise<PythonEnvInfo> {
     const { kind, source } = env;
     const resolvers = getResolvers();
     const resolverForKind = resolvers.get(kind)!;
-    const resolvedEnv = await resolverForKind(env);
+    const resolvedEnv = await resolverForKind(env, useCache);
     resolvedEnv.searchLocation = getSearchLocation(resolvedEnv);
     resolvedEnv.source = uniq(resolvedEnv.source.concat(source ?? []));
     if (getOSType() === OSType.Windows && resolvedEnv.source?.includes(PythonEnvSource.WindowsRegistry)) {
@@ -137,13 +137,13 @@ async function resolveSimpleEnv(env: BasicEnvInfo): Promise<PythonEnvInfo> {
     return envInfo;
 }
 
-async function resolveCondaEnv(env: BasicEnvInfo): Promise<PythonEnvInfo> {
+async function resolveCondaEnv(env: BasicEnvInfo, useCache?: boolean): Promise<PythonEnvInfo> {
     const { executablePath } = env;
     const conda = await Conda.getConda();
     if (conda === undefined) {
         traceWarn(`${executablePath} identified as Conda environment even though Conda is not installed`);
     }
-    const envs = (await conda?.getEnvList()) ?? [];
+    const envs = (await conda?.getEnvList(useCache)) ?? [];
     for (const { name, prefix } of envs) {
         let executable = await getInterpreterPathFromDir(prefix);
         const currEnv: BasicEnvInfo = { executablePath: executable ?? '', kind: PythonEnvKind.Conda, envPath: prefix };

src/client/pythonEnvironments/common/environmentManagers/conda.ts

@@ -241,6 +241,8 @@ export class Conda {
      */
     private static condaPromise: Promise<Conda | undefined> | undefined;
 
+    private condaInfoCached: Promise<CondaInfo> | undefined;
+
     /**
      * Creates a Conda service corresponding to the corresponding "conda" command.
      *
@@ -402,16 +404,19 @@ export class Conda {
      * Retrieves global information about this conda.
      * Corresponds to "conda info --json".
      */
-    public async getInfo(): Promise<CondaInfo> {
-        return this.getInfoCached(this.command);
+    public async getInfo(useCache?: boolean): Promise<CondaInfo> {
+        if (!useCache || !this.condaInfoCached) {
+            this.condaInfoCached = this.getInfoImpl(this.command);
+        }
+        return this.condaInfoCached;
     }
 
     /**
-     * Cache result for this particular command.
+     * Temporarily cache result for this particular command.
      */
-    @cache(30_000, true, 10_000)
+    // @cache(30_000, true, 10_000)
     // eslint-disable-next-line class-methods-use-this
-    private async getInfoCached(command: string): Promise<CondaInfo> {
+    private async getInfoImpl(command: string): Promise<CondaInfo> {
         const quoted = [command.toCommandArgument(), 'info', '--json'].join(' ');
         // Execute in a shell as `conda` on windows refers to `conda.bat`, which requires a shell to work.
         const result = await shellExecute(quoted, { timeout: CONDA_GENERAL_TIMEOUT });
@@ -423,9 +428,9 @@ export class Conda {
      * Retrieves list of Python environments known to this conda.
      * Corresponds to "conda env list --json", but also computes environment names.
      */
-    @cache(30_000, true, 10_000)
-    public async getEnvList(): Promise<CondaEnvInfo[]> {
-        const info = await this.getInfo();
+    // @cache(30_000, true, 10_000)
+    public async getEnvList(useCache?: boolean): Promise<CondaEnvInfo[]> {
+        const info = await this.getInfo(useCache);
         const { envs } = info;
         if (envs === undefined) {
             return [];
@@ -510,7 +515,7 @@ export class Conda {
      */
     @cache(-1, true)
     public async getCondaVersion(): Promise<SemVer | undefined> {
-        const info = await this.getInfo().catch<CondaInfo | undefined>(() => undefined);
+        const info = await this.getInfo(true).catch<CondaInfo | undefined>(() => undefined);
         let versionString: string | undefined;
         if (info && info.conda_version) {
             versionString = info.conda_version;