Use worker threads for fetching conda environments

Author: Kartik Raj

src/client/common/process/worker/plainExecWorker.ts

@@ -1,7 +1,13 @@
 import { parentPort, workerData } from 'worker_threads';
-import { workerPlainExec } from './workerRawProcessApis';
+import { _workerPlainExecImpl } from './workerRawProcessApis';
 
-workerPlainExec(workerData.file, workerData.args, workerData.options, workerData.defaultEnv, workerData.disposables)
+_workerPlainExecImpl(
+    workerData.file,
+    workerData.args,
+    workerData.options,
+    workerData.defaultEnv,
+    workerData.disposables,
+)
     .then((res) => {
         if (!parentPort) {
             throw new Error('Not in a worker thread');

src/client/common/process/worker/rawProcessApiWrapper.ts

@@ -6,30 +6,27 @@ import * as path from 'path';
 import { WorkspaceService } from '../../application/workspace';
 import { ProcessLogger } from '../logger';
 import { executeWorkerFile } from './main';
-import { EnvironmentVariables, ExecutionResult, IDisposable, ShellOptions } from './types';
+import { EnvironmentVariables, ExecutionResult, ShellOptions } from './types';
 
-export function shellExec(
+export function workerShellExec(
     command: string,
     options: ShellOptions,
     defaultEnv?: EnvironmentVariables,
-    disposables?: Set<IDisposable>,
 ): Promise<ExecutionResult<string>> {
     const processLogger = new ProcessLogger(new WorkspaceService());
     processLogger.logProcess(command, undefined, options);
     return executeWorkerFile(path.join(__dirname, 'shellExecWorker.js'), {
         command,
         options,
         defaultEnv,
-        disposables,
     });
 }
 
-export function plainExec(
+export function workerPlainExec(
     file: string,
     args: string[],
     options: SpawnOptions & { doNotLog?: boolean } = {},
     defaultEnv?: EnvironmentVariables,
-    disposables?: Set<IDisposable>,
 ): Promise<ExecutionResult<string>> {
     const processLogger = new ProcessLogger(new WorkspaceService());
     processLogger.logProcess(file, args, options);
@@ -38,6 +35,5 @@ export function plainExec(
         args,
         options,
         defaultEnv,
-        disposables,
     });
 }

src/client/common/process/worker/shellExecWorker.ts

@@ -1,16 +1,16 @@
 import { parentPort, workerData } from 'worker_threads';
-import { workerShellExec } from './workerRawProcessApis';
+import { _workerShellExecImpl } from './workerRawProcessApis';
 
-workerShellExec(workerData.command, workerData.options, workerData.defaultEnv, workerData.disposables)
+_workerShellExecImpl(workerData.command, workerData.options, workerData.defaultEnv, workerData.disposables)
     .then((res) => {
         if (!parentPort) {
             throw new Error('Not in a worker thread');
         }
-        parentPort.postMessage(res);
+        parentPort.postMessage({ res });
     })
     .catch((ex) => {
         if (!parentPort) {
             throw new Error('Not in a worker thread');
         }
-        parentPort.postMessage(ex);
+        parentPort.postMessage({ ex });
     });

src/client/common/process/worker/workerRawProcessApis.ts

@@ -52,7 +52,7 @@ function getDefaultOptions<T extends ShellOptions | SpawnOptions>(options: T, de
     return defaultOptions;
 }
 
-export function workerShellExec(
+export function _workerShellExecImpl(
     command: string,
     options: ShellOptions,
     defaultEnv?: EnvironmentVariables,
@@ -102,7 +102,7 @@ export function workerShellExec(
     });
 }
 
-export function workerPlainExec(
+export function _workerPlainExecImpl(
     file: string,
     args: string[],
     options: SpawnOptions & { doNotLog?: boolean } = {},

src/client/pythonEnvironments/common/externalDependencies.ts

@@ -12,7 +12,7 @@ import { getOSType, OSType } from '../../common/utils/platform';
 import { IServiceContainer } from '../../ioc/types';
 import { traceError, traceVerbose } from '../../logging';
 import { DiscoveryUsingWorkers } from '../../common/experiments/groups';
-import { plainExec, shellExec } from '../../common/process/worker/rawProcessApiWrapper';
+import { workerPlainExec, workerShellExec } from '../../common/process/worker/rawProcessApiWrapper';
 import { IEnvironmentVariablesProvider } from '../../common/variables/types';
 
 let internalServiceContainer: IServiceContainer;
@@ -23,25 +23,25 @@ export function initializeExternalDependencies(serviceContainer: IServiceContain
 // processes
 
 export async function shellExecute(command: string, options: ShellOptions = {}): Promise<ExecutionResult<string>> {
-    if (inExperiment(DiscoveryUsingWorkers.experiment)) {
+    if (!inExperiment(DiscoveryUsingWorkers.experiment)) {
         const service = await internalServiceContainer.get<IProcessServiceFactory>(IProcessServiceFactory).create();
         return service.shellExec(command, options);
     }
     const envVarsService = internalServiceContainer.get<IEnvironmentVariablesProvider>(IEnvironmentVariablesProvider);
     const envs = await envVarsService.getEnvironmentVariables();
     options.env = { ...options.env, ...envs };
-    return shellExec(command, options);
+    return workerShellExec(command, options);
 }
 
 export async function exec(file: string, args: string[], options: SpawnOptions = {}): Promise<ExecutionResult<string>> {
-    if (inExperiment(DiscoveryUsingWorkers.experiment)) {
+    if (!inExperiment(DiscoveryUsingWorkers.experiment)) {
         const service = await internalServiceContainer.get<IProcessServiceFactory>(IProcessServiceFactory).create();
         return service.exec(file, args, options);
     }
     const envVarsService = internalServiceContainer.get<IEnvironmentVariablesProvider>(IEnvironmentVariablesProvider);
     const envs = await envVarsService.getEnvironmentVariables();
     options.env = { ...options.env, ...envs };
-    return plainExec(file, args, options);
+    return workerPlainExec(file, args, options);
 }
 
 export function inExperiment(experimentName: string): boolean {