Add API to get data from registry (#14297)

* Add API to get data from registry

* Address Comments

* more tweaks

Author: karthiknadig

src/client/pythonEnvironments/common/windowsUtils.ts

@@ -2,6 +2,14 @@
 // Licensed under the MIT License.
 
 import * as path from 'path';
+import {
+    Options, REG_SZ, Registry, RegistryItem,
+} from 'winreg';
+import { traceVerbose } from '../../common/logger';
+import { createDeferred } from '../../common/utils/async';
+
+// tslint:disable-next-line: no-single-line-block-comment
+/* eslint-disable global-require */
 
 /**
  * Checks if a given path ends with python*.exe
@@ -20,3 +28,99 @@ export function isWindowsPythonExe(interpreterPath:string): boolean {
 
     return windowsPythonExes.test(path.basename(interpreterPath));
 }
+
+export async function readRegistryValues(options: Options): Promise<RegistryItem[]> {
+    // tslint:disable-next-line:no-require-imports
+    const WinReg = require('winreg');
+    const regKey = new WinReg(options);
+    const deferred = createDeferred<RegistryItem[]>();
+    regKey.values((err:Error, res:RegistryItem[]) => {
+        if (err) {
+            deferred.reject(err);
+        }
+        deferred.resolve(res);
+    });
+    return deferred.promise;
+}
+
+export async function readRegistryKeys(options: Options): Promise<Registry[]> {
+    // tslint:disable-next-line:no-require-imports
+    const WinReg = require('winreg');
+    const regKey = new WinReg(options);
+    const deferred = createDeferred<Registry[]>();
+    regKey.keys((err:Error, res:Registry[]) => {
+        if (err) {
+            deferred.reject(err);
+        }
+        deferred.resolve(res);
+    });
+    return deferred.promise;
+}
+
+export interface IRegistryInterpreterData{
+    interpreterPath: string;
+    versionStr?: string;
+    sysVersionStr?:string;
+    bitnessStr?: string;
+    displayName?: string;
+    distroOrgName?: string;
+}
+
+async function getInterpreterDataFromKey(
+    { arch, hive, key }:Registry,
+    distroOrgName:string,
+): Promise<IRegistryInterpreterData | undefined> {
+    const result:IRegistryInterpreterData = {
+        interpreterPath: '',
+        distroOrgName,
+    };
+
+    const values:RegistryItem[] = await readRegistryValues({ arch, hive, key });
+    for (const value of values) {
+        switch (value.name) {
+            case 'SysArchitecture':
+                result.bitnessStr = value.value;
+                break;
+            case 'SysVersion':
+                result.sysVersionStr = value.value;
+                break;
+            case 'Version':
+                result.versionStr = value.value;
+                break;
+            case 'DisplayName':
+                result.displayName = value.value;
+                break;
+            default:
+                break;
+        }
+    }
+
+    const subKeys:Registry[] = await readRegistryKeys({ arch, hive, key });
+    const subKey = subKeys.map((s) => s.key).find((s) => s.endsWith('InstallPath'));
+    if (subKey) {
+        const subKeyValues:RegistryItem[] = await readRegistryValues({ arch, hive, key: subKey });
+        const value = subKeyValues.find((v) => v.name === 'ExecutablePath');
+        if (value) {
+            result.interpreterPath = value.value;
+            if (value.type !== REG_SZ) {
+                traceVerbose(`Registry interpreter path type [${value.type}]: ${value.value}`);
+            }
+        }
+    }
+
+    if (result.interpreterPath.length > 0) {
+        return result;
+    }
+    return undefined;
+}
+
+export async function getInterpreterDataFromRegistry(
+    arch:string,
+    hive:string,
+    key:string,
+): Promise<IRegistryInterpreterData[]> {
+    const subKeys = await readRegistryKeys({ arch, hive, key });
+    const distroOrgName = key.substr(key.lastIndexOf('\\') + 1);
+    const allData = await Promise.all(subKeys.map((subKey) => getInterpreterDataFromKey(subKey, distroOrgName)));
+    return (allData.filter((data) => data !== undefined) || []) as IRegistryInterpreterData[];
+}

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

@@ -0,0 +1,21 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { uniqBy } from 'lodash';
+import { HKCU, HKLM } from 'winreg';
+import { getInterpreterDataFromRegistry, IRegistryInterpreterData, readRegistryKeys } from '../../../common/windowsUtils';
+
+export async function getRegistryInterpreters() : Promise<IRegistryInterpreterData[]> {
+    let registryData:IRegistryInterpreterData[] = [];
+
+    for (const arch of ['x64', 'x86']) {
+        for (const hive of [HKLM, HKCU]) {
+            const keys = (await readRegistryKeys({ arch, hive, key: '\\SOFTWARE\\Python' })).map((k) => k.key);
+            for (const key of keys) {
+                registryData = registryData.concat(await getInterpreterDataFromRegistry(arch, hive, key));
+            }
+        }
+    }
+
+    return uniqBy(registryData, (r:IRegistryInterpreterData) => r.interpreterPath);
+}