Added Windows store file system watcher

src/client/pythonEnvironments/common/pythonBinariesWatcher.ts

@@ -3,19 +3,23 @@
 
 'use strict';
 
+import * as minimatch from 'minimatch';
+import * as path from 'path';
 import { FileChangeType, watchLocationForPattern } from '../../common/platform/fileSystemWatcher';
 import { getOSType, OSType } from '../../common/utils/platform';
 
 const [executable, binName] = getOSType() === OSType.Windows ? ['python.exe', 'Scripts'] : ['python', 'bin'];
-const patterns = [executable, `*/${executable}`, `*/${binName}/${executable}`];
 
 export function watchLocationForPythonBinaries(
     baseDir: string,
     callback: (type: FileChangeType, absPath: string) => void,
+    executableGlob: string = executable,
 ): void {
+    const patterns = [executableGlob, `*/${executableGlob}`, `*/${binName}/${executableGlob}`];
     for (const pattern of patterns) {
         watchLocationForPattern(baseDir, pattern, (type: FileChangeType, e: string) => {
-            if (!e.endsWith(executable)) {
+            const isMatch = minimatch(e, path.join('**', executableGlob), { nocase: getOSType() === OSType.Windows });
+            if (!isMatch) {
                 // When deleting the file for some reason path to all directories leading up to python are reported
                 // Skip those events
                 return;

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

@@ -2,16 +2,17 @@
 // Licensed under the MIT License.
 
 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 { PythonEnvInfo, PythonEnvKind } from '../../../base/info';
 import { buildEnvInfo } from '../../../base/info/env';
 import { getPythonVersionFromPath } from '../../../base/info/pythonVersion';
 import { IPythonEnvsIterator, Locator } from '../../../base/locator';
 import { getFileInfo } from '../../../common/externalDependencies';
+import { watchLocationForPythonBinaries } from '../../../common/pythonBinariesWatcher';
 
 /**
  * Gets path to the Windows Apps directory.
@@ -29,7 +30,7 @@ export function getWindowsStoreAppsRoot(): string {
  * @returns {boolean} : Returns true if `interpreterPath` is under
  * `%ProgramFiles%/WindowsApps`.
  */
-export function isForbiddenStorePath(interpreterPath:string):boolean {
+export function isForbiddenStorePath(interpreterPath: string): boolean {
     const programFilesStorePath = path
         .join(getEnvironmentVariable('ProgramFiles') || 'Program Files', 'WindowsApps')
         .normalize()
@@ -87,26 +88,27 @@ export async function isWindowsStoreEnvironment(interpreterPath: string): Promis
     return false;
 }
 
+/**
+ * This is a glob pattern which matches following file names:
+ * python3.8.exe
+ * python3.9.exe
+ * This pattern does not match:
+ * python.exe
+ * python2.7.exe
+ * python3.exe
+ * python38.exe
+ * 'python.exe', 'python3.exe', and 'python3.8.exe' can point to the same executable, hence only capture python3.*.exes.
+ */
+const pythonExeGlob = 'python3\.[0-9]*\.exe';
+
 /**
  * Checks if a given path ends with python3.*.exe. Not all python executables are matched as
  * we do not want to return duplicate executables.
  * @param {string} interpreterPath : Path to python interpreter.
  * @returns {boolean} : Returns true if the path matches pattern for windows python executable.
  */
-export function isWindowsStorePythonExe(interpreterPath:string): boolean {
-    /**
-     * This Reg-ex matches following file names:
-     * python3.8.exe
-     * python3.9.exe
-     * This Reg-ex does not match:
-     * python.exe
-     * python2.7.exe
-     * python3.exe
-     * python38.exe
-     */
-    const windowsPythonExes = /^python(3(.\d+))\.exe$/;
-
-    return windowsPythonExes.test(path.basename(interpreterPath));
+export function isWindowsStorePythonExe(interpreterPath: string): boolean {
+    return minimatch(path.basename(interpreterPath), pythonExeGlob, { nocase: true });
 }
 
 /**
@@ -131,17 +133,21 @@ export async function getWindowsStorePythonExes(): Promise<string[]> {
     // Collect python*.exe directly under %LOCALAPPDATA%/Microsoft/WindowsApps
     const files = await fsapi.readdir(windowsAppsRoot);
     return files
-        .map((filename:string) => path.join(windowsAppsRoot, filename))
+        .map((filename: string) => path.join(windowsAppsRoot, filename))
         .filter(isWindowsStorePythonExe);
 }
 
 export class WindowsStoreLocator extends Locator {
-    private readonly kind:PythonEnvKind = PythonEnvKind.WindowsStore;
+    private readonly kind: PythonEnvKind = PythonEnvKind.WindowsStore;
+
+    public initialize(): void {
+        this.startWatcher();
+    }
 
     public iterEnvs(): IPythonEnvsIterator {
         const iterator = async function* (kind: PythonEnvKind) {
             const exes = await getWindowsStorePythonExes();
-            yield* exes.map(async (executable:string) => buildEnvInfo({
+            yield* exes.map(async (executable: string) => buildEnvInfo({
                 kind,
                 executable,
                 version: getPythonVersionFromPath(executable),
@@ -167,4 +173,15 @@ export class WindowsStoreLocator extends Locator {
         }
         return undefined;
     }
+
+    private startWatcher(): void {
+        const windowsAppsRoot = getWindowsStoreAppsRoot();
+        watchLocationForPythonBinaries(
+            windowsAppsRoot,
+            (type: FileChangeType) => {
+                this.emitter.fire({ type, kind: this.kind });
+            },
+            pythonExeGlob,
+        );
+    }
 }

src/test/pythonEnvironments/discovery/locators/windowsStoreLocator.test.ts

@@ -0,0 +1,162 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { assert } from 'chai';
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import { traceWarning } from '../../../../client/common/logger';
+import { FileChangeType } from '../../../../client/common/platform/fileSystemWatcher';
+import { createDeferred, Deferred, sleep } from '../../../../client/common/utils/async';
+import { PythonEnvKind } from '../../../../client/pythonEnvironments/base/info';
+import { getEnvs } from '../../../../client/pythonEnvironments/base/locatorUtils';
+import { PythonEnvsChangedEvent } from '../../../../client/pythonEnvironments/base/watcher';
+import { arePathsSame } from '../../../../client/pythonEnvironments/common/externalDependencies';
+import { WindowsStoreLocator } from '../../../../client/pythonEnvironments/discovery/locators/services/windowsStoreLocator';
+import { TEST_TIMEOUT } from '../../../constants';
+import { TEST_LAYOUT_ROOT } from '../../common/commonTestConstants';
+
+class WindowsStoreEnvs {
+    private executables: string[] = [];
+
+    constructor(private readonly storeAppRoot: string) {}
+
+    public async create(basename: string): Promise<string> {
+        const filename = path.join(this.storeAppRoot, basename);
+        try {
+            await fs.createFile(filename);
+        } catch (err) {
+            throw new Error(`Failed to create Windows Apps executable ${filename}, Error: ${err}`);
+        }
+        this.executables.push(filename);
+        return filename;
+    }
+
+    public async update(basename: string): Promise<void> {
+        const filename = path.join(this.storeAppRoot, basename);
+        try {
+            await fs.writeFile(filename, 'Environment has been updated');
+        } catch (err) {
+            throw new Error(`Failed to update Windows Apps executable ${filename}, Error: ${err}`);
+        }
+    }
+
+    public async cleanUp() {
+        await Promise.all(
+            this.executables.map(async (filename: string) => {
+                try {
+                    await fs.remove(filename);
+                } catch (err) {
+                    traceWarning(`Failed to clean up ${filename}`);
+                }
+            }),
+        );
+    }
+}
+
+suite('Windows Store Locator', async () => {
+    const testLocalAppData = path.join(TEST_LAYOUT_ROOT, 'storeApps');
+    const testStoreAppRoot = path.join(testLocalAppData, 'Microsoft', 'WindowsApps');
+    const windowsStoreEnvs = new WindowsStoreEnvs(testStoreAppRoot);
+    let locator: WindowsStoreLocator;
+    const localAppDataOldValue = process.env.LOCALAPPDATA;
+
+    async function waitForChangeToBeDetected(deferred: Deferred<void>) {
+        const timeout = setTimeout(
+            () => {
+                clearTimeout(timeout);
+                deferred.reject(new Error('Environment not detected'));
+            },
+            TEST_TIMEOUT,
+        );
+        await deferred.promise;
+    }
+
+    async function isLocated(executable: string): Promise<boolean> {
+        const items = await getEnvs(locator.iterEnvs());
+        return items.some((item) => arePathsSame(item.executable.filename, executable));
+    }
+
+    suiteSetup(async () => {
+        process.env.LOCALAPPDATA = testLocalAppData;
+        await windowsStoreEnvs.cleanUp();
+    });
+
+    async function setupLocator(onChanged: (e: PythonEnvsChangedEvent) => Promise<void>) {
+        locator = new WindowsStoreLocator();
+        locator.initialize();
+        // Wait for watchers to get ready
+        await sleep(1000);
+        locator.onChanged(onChanged);
+    }
+
+    teardown(() => windowsStoreEnvs.cleanUp());
+    suiteTeardown(async () => {
+        process.env.LOCALAPPDATA = localAppDataOldValue;
+    });
+
+    test('Detect a new environment', async () => {
+        let actualEvent: PythonEnvsChangedEvent;
+        const deferred = createDeferred<void>();
+        const expectedEvent = {
+            kind: PythonEnvKind.WindowsStore,
+            type: FileChangeType.Created,
+        };
+        await setupLocator(async (e) => {
+            actualEvent = e;
+            deferred.resolve();
+        });
+
+        const executable = await windowsStoreEnvs.create('python3.4.exe');
+        await waitForChangeToBeDetected(deferred);
+        const isFound = await isLocated(executable);
+
+        assert.ok(isFound);
+        assert.deepEqual(actualEvent!, expectedEvent, 'Wrong event emitted');
+    });
+
+    test('Detect when an environment has been deleted', async () => {
+        let actualEvent: PythonEnvsChangedEvent;
+        const deferred = createDeferred<void>();
+        const expectedEvent = {
+            kind: PythonEnvKind.WindowsStore,
+            type: FileChangeType.Deleted,
+        };
+        const executable = await windowsStoreEnvs.create('python3.4.exe');
+        // Wait before the change event has been sent. If both operations occur almost simultaneously no event is sent.
+        await sleep(100);
+        await setupLocator(async (e) => {
+            actualEvent = e;
+            deferred.resolve();
+        });
+
+        await windowsStoreEnvs.cleanUp();
+        await waitForChangeToBeDetected(deferred);
+        const isFound = await isLocated(executable);
+
+        assert.notOk(isFound);
+        assert.deepEqual(actualEvent!, expectedEvent, 'Wrong event emitted');
+    });
+
+    test('Detect when an environment has been updated', async () => {
+        let actualEvent: PythonEnvsChangedEvent;
+        const deferred = createDeferred<void>();
+        const expectedEvent = {
+            kind: PythonEnvKind.WindowsStore,
+            type: FileChangeType.Changed,
+        };
+        const executable = await windowsStoreEnvs.create('python3.4.exe');
+        // Wait before the change event has been sent. If both operations occur almost simultaneously no event is sent.
+        await sleep(100);
+        await setupLocator(async (e) => {
+            actualEvent = e;
+            deferred.resolve();
+        });
+
+        await windowsStoreEnvs.update('python3.4.exe');
+        await waitForChangeToBeDetected(deferred);
+        const isFound = await isLocated(executable);
+
+        assert.ok(isFound);
+        assert.deepEqual(actualEvent!, expectedEvent, 'Wrong event emitted');
+    });
+});