Modify FSWatching Locator

Author: Kartik Raj

src/client/pythonEnvironments/base/locators/lowLevel/fsWatchingLocator.ts

@@ -1,6 +1,10 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
+import { FileChangeType } from '../../../../common/platform/fileSystemWatcher';
+import { sleep } from '../../../../common/utils/async';
+import { watchLocationForPythonBinaries } from '../../../common/pythonBinariesWatcher';
+import { PythonEnvKind } from '../../info';
 import { Locator } from '../../locator';
 
 /**
@@ -10,5 +14,71 @@ import { Locator } from '../../locator';
  * Subclasses can call `this.emitter.fire()` * to emit events.
  */
 export abstract class FSWatchingLocator extends Locator {
-    public async abstract initialize(): Promise<void>;
+    private initialized = false;
+
+    constructor(
+        /**
+         * Location(s) to watch for python binaries.
+         */
+        private readonly getRoots: () => Promise<string[]> | string,
+        /**
+         * Returns the kind of environment specific to locator given the path to exectuable.
+         */
+        private readonly getKind: (executable: string) => Promise<PythonEnvKind>,
+        private readonly opts: {
+            /**
+             * Glob which represents basename of the executable to watch.
+             */
+            executableBaseGlob?: string,
+            /**
+             * Time to wait before attempting to identify kind when detected that an environment has been created.
+             */
+            delayOnCreated?: number, // milliseconds
+        } = {},
+    ) {
+        super();
+    }
+
+    public async initialize(): Promise<void> {
+        if (this.initialized) {
+            return;
+        }
+        this.initialized = true;
+        await this.startWatchers();
+    }
+
+    public dispose(): void {
+        super.dispose();
+        this.initialized = false;
+    }
+
+    private async startWatchers(): Promise<void> {
+        let roots = await this.getRoots();
+        if (typeof roots === 'string') {
+            roots = [roots];
+        }
+        roots.map((root) => this.startWatcher(root));
+    }
+
+    private startWatcher(root: string): void {
+        this.disposables.push(
+            watchLocationForPythonBinaries(
+                root,
+                async (type: FileChangeType, executable: string) => {
+                    if (type === FileChangeType.Created) {
+                        if (this.opts.delayOnCreated !== undefined) {
+                            // Note detecting kind of env depends on the file structure around the
+                            // executable, so we need to wait before attempting to detect it. However even
+                            // if the type detected is incorrect, it doesn't do any practical harm as kinds
+                            // in the same locator can be used in the same way (same activation commands etc.)
+                            await sleep(this.opts.delayOnCreated);
+                        }
+                    }
+                    const kind = await this.getKind(executable);
+                    this.emitter.fire({ type, kind });
+                },
+                this.opts.executableBaseGlob,
+            ),
+        );
+    }
 }

src/client/pythonEnvironments/discovery/locators/services/globalVirtualEnvronmentLocator.ts

@@ -4,8 +4,7 @@
 import { uniq } from 'lodash';
 import * as path from 'path';
 import { traceVerbose } from '../../../../common/logger';
-import { FileChangeType } from '../../../../common/platform/fileSystemWatcher';
-import { chain, iterable, sleep } from '../../../../common/utils/async';
+import { chain, iterable } from '../../../../common/utils/async';
 import {
     getEnvironmentVariable, getOSType, getUserHomeDir, OSType
 } from '../../../../common/utils/platform';
@@ -15,7 +14,6 @@ import { IPythonEnvsIterator } from '../../../base/locator';
 import { FSWatchingLocator } from '../../../base/locators/lowLevel/fsWatchingLocator';
 import { findInterpretersInDir } from '../../../common/commonUtils';
 import { getFileInfo, pathExists } from '../../../common/externalDependencies';
-import { watchLocationForPythonBinaries } from '../../../common/pythonBinariesWatcher';
 import { isPipenvEnvironment } from './pipEnvHelper';
 import {
     isVenvEnvironment,
@@ -89,12 +87,14 @@ export class GlobalVirtualEnvironmentLocator extends FSWatchingLocator {
         PythonEnvKind.Pipenv,
     ];
 
-    public constructor(private readonly searchDepth?: number) {
-        super();
-    }
-
-    public async initialize(): Promise<void> {
-        await this.startWatchers();
+    constructor(private readonly searchDepth?: number) {
+        super(getGlobalVirtualEnvDirs, getVirtualEnvKind, {
+            // Note detecting kind of virtual env depends on the file structure around the
+            // executable, so we need to wait before attempting to detect it. However even
+            // if the type detected is incorrect, it doesn't do any practical harm as kinds
+            // in this locator are used in the same way (same activation commands etc.)
+            delayOnCreated: 1000,
+        });
     }
 
     public iterEnvs(): IPythonEnvsIterator {
@@ -171,21 +171,4 @@ export class GlobalVirtualEnvironmentLocator extends FSWatchingLocator {
         }
         return undefined;
     }
-
-    private async startWatchers(): Promise<void> {
-        const dirs = await getGlobalVirtualEnvDirs();
-        dirs.forEach(
-            (d) => this.disposables.push(
-                watchLocationForPythonBinaries(d, async (type: FileChangeType, executablePath: string) => {
-                    // Note detecting kind of virtual env depends on the file structure around the
-                    // executable, so we need to wait before attempting to detect it. However even
-                    // if the type detected is incorrect, it doesn't do any practical harm as kinds
-                    // in this locator are used in the same way (same activation commands etc.)
-                    await sleep(1000);
-                    const kind = await getVirtualEnvKind(executablePath);
-                    this.emitter.fire({ type, kind });
-                }),
-            ),
-        );
-    }
 }

src/client/pythonEnvironments/discovery/locators/services/windowsStoreLocator.ts

@@ -5,15 +5,13 @@ import * as fsapi from 'fs-extra';
 import * as minimatch from 'minimatch';
 import * as path from 'path';
 import { traceWarning } from '../../../../common/logger';
-import { FileChangeType } from '../../../../common/platform/fileSystemWatcher';
 import { Architecture, getEnvironmentVariable } from '../../../../common/utils/platform';
 import { PythonEnvInfo, PythonEnvKind } from '../../../base/info';
 import { buildEnvInfo } from '../../../base/info/env';
 import { getPythonVersionFromPath } from '../../../base/info/pythonVersion';
 import { IPythonEnvsIterator } from '../../../base/locator';
 import { FSWatchingLocator } from '../../../base/locators/lowLevel/fsWatchingLocator';
 import { getFileInfo } from '../../../common/externalDependencies';
-import { watchLocationForPythonBinaries } from '../../../common/pythonBinariesWatcher';
 
 /**
  * Gets path to the Windows Apps directory.
@@ -143,8 +141,12 @@ export async function getWindowsStorePythonExes(): Promise<string[]> {
 export class WindowsStoreLocator extends FSWatchingLocator {
     private readonly kind: PythonEnvKind = PythonEnvKind.WindowsStore;
 
-    public async initialize(): Promise<void> {
-        this.startWatcher();
+    constructor() {
+        super(
+            getWindowsStoreAppsRoot,
+            async () => this.kind,
+            { executableBaseGlob: pythonExeGlob },
+        );
     }
 
     public iterEnvs(): IPythonEnvsIterator {
@@ -176,17 +178,4 @@ export class WindowsStoreLocator extends FSWatchingLocator {
         }
         return undefined;
     }
-
-    private startWatcher(): void {
-        const windowsAppsRoot = getWindowsStoreAppsRoot();
-        this.disposables.push(
-            watchLocationForPythonBinaries(
-                windowsAppsRoot,
-                (type: FileChangeType) => {
-                    this.emitter.fire({ type, kind: this.kind });
-                },
-                pythonExeGlob,
-            ),
-        );
-    }
 }