Use separate class to manage kernel dependencies (#11472)

Use a single class that manages dependencies in kernels.
I.e. move both of the following into its own class.

* Is ipykernel installed
* Install ipykernel if required

Author: DonJayamanne

package.nls.json

@@ -488,5 +488,5 @@
     "DataScience.unhandledMessage": "Unhandled kernel message from a widget: {0} : {1}",
     "DataScience.qgridWidgetScriptVersionCompatibilityWarning": "Unable to load a compatible version of the widget 'qgrid'. Consider downgrading to version 1.1.1.",
     "DataScience.kernelStarted": "Started kernel {0}",
-    "DataScience.ipykernelNotInstalled": "Ipykernel is not installed."
+    "DataScience.libraryRequiredToLaunchJupyterKernelNotInstalledInterpreter": "Data Science library {1} is not installed in interpreter {0}. Install?"
 }

src/client/common/process/baseDaemon.ts

@@ -21,8 +21,8 @@ import {
     StdErrError
 } from './types';
 
-type ErrorResponse = { error?: string };
-
+export type ErrorResponse = { error?: string };
+export type ExecResponse = ErrorResponse & { stdout: string; stderr?: string };
 export class ConnectionClosedError extends Error {
     constructor(public readonly message: string) {
         super();
@@ -181,7 +181,6 @@ export abstract class BasePythonDaemon {
     ): ObservableExecutionResult<string> {
         const subject = new Subject<Output<string>>();
         const start = async () => {
-            type ExecResponse = ErrorResponse & { stdout: string; stderr?: string };
             let response: ExecResponse;
             if ('fileName' in moduleOrFile) {
                 const request = new RequestType<
@@ -282,7 +281,6 @@ export abstract class BasePythonDaemon {
         args: string[],
         options: SpawnOptions
     ): Promise<ExecutionResult<string>> {
-        type ExecResponse = ErrorResponse & { stdout: string; stderr?: string };
         const request = new RequestType<
             // tslint:disable-next-line: no-any
             { file_name: string; args: string[]; cwd?: string; env?: any },
@@ -304,7 +302,6 @@ export abstract class BasePythonDaemon {
         args: string[],
         options: SpawnOptions
     ): Promise<ExecutionResult<string>> {
-        type ExecResponse = ErrorResponse & { stdout: string; stderr?: string };
         const request = new RequestType<
             // tslint:disable-next-line: no-any
             { module_name: string; args: string[]; cwd?: string; env?: any },

src/client/common/utils/localize.ts

@@ -350,6 +350,10 @@ export namespace DataScience {
         'DataScience.libraryRequiredToLaunchJupyterNotInstalledInterpreter',
         'Data Science library {1} is not installed in interpreter {0}.'
     );
+    export const libraryRequiredToLaunchJupyterKernelNotInstalledInterpreter = localize(
+        'DataScience.libraryRequiredToLaunchJupyterKernelNotInstalledInterpreter',
+        'Data Science library {1} is not installed in interpreter {0}. Install?'
+    );
     export const librariesRequiredToLaunchJupyterNotInstalledInterpreter = localize(
         'DataScience.librariesRequiredToLaunchJupyterNotInstalledInterpreter',
         'Data Science libraries {1} are not installed in interpreter {0}.'
@@ -920,7 +924,6 @@ export namespace DataScience {
     );
 
     export const kernelStarted = localize('DataScience.kernelStarted', 'Started kernel {0}.');
-    export const ipykernelNotInstalled = localize('DataScience.ipykernelNotInstalled', 'Ipykernel is not installed.');
 }
 
 export namespace DebugConfigStrings {

src/client/datascience/jupyter/kernels/kernelDependencyService.ts

@@ -0,0 +1,76 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+'use strict';
+
+import { inject, injectable } from 'inversify';
+import { CancellationToken } from 'vscode';
+import { IApplicationShell } from '../../../common/application/types';
+import { createPromiseFromCancellation, wrapCancellationTokens } from '../../../common/cancellation';
+import { ProductNames } from '../../../common/installer/productNames';
+import { IInstaller, InstallerResponse, Product } from '../../../common/types';
+import { Common, DataScience } from '../../../common/utils/localize';
+import { PythonInterpreter } from '../../../interpreter/contracts';
+import { IKernelDependencyService, KernelInterpreterDependencyResponse } from '../../types';
+
+/**
+ * Responsible for managing dependencies of a Python interpreter required to run as a Jupyter Kernel.
+ * If required modules aren't installed, will prompt user to install them.
+ */
+@injectable()
+export class KernelDependencyService implements IKernelDependencyService {
+    constructor(
+        @inject(IApplicationShell) private readonly appShell: IApplicationShell,
+        @inject(IInstaller) private readonly installer: IInstaller
+    ) {}
+    /**
+     * Configures the python interpreter to ensure it can run a Jupyter Kernel by installing any missing dependencies.
+     * If user opts not to install they can opt to select another interpreter.
+     */
+    public async installMissingDependencies(
+        interpreter: PythonInterpreter,
+        token?: CancellationToken
+    ): Promise<KernelInterpreterDependencyResponse> {
+        if (await this.areDependenciesInstalled(interpreter, token)) {
+            return KernelInterpreterDependencyResponse.ok;
+        }
+
+        const promptCancellationPromise = createPromiseFromCancellation({
+            cancelAction: 'resolve',
+            defaultValue: undefined,
+            token
+        });
+        const message = DataScience.libraryRequiredToLaunchJupyterKernelNotInstalledInterpreter().format(
+            interpreter.displayName || interpreter.envName || interpreter.path,
+            ProductNames.get(Product.ipykernel)!
+        );
+        const installerToken = wrapCancellationTokens(token);
+        const selection = await Promise.race([
+            this.appShell.showErrorMessage(message, Common.ok(), Common.cancel()),
+            promptCancellationPromise
+        ]);
+        if (installerToken.isCancellationRequested) {
+            return KernelInterpreterDependencyResponse.cancel;
+        }
+
+        if (selection === Common.ok()) {
+            const cancellatonPromise = createPromiseFromCancellation({
+                cancelAction: 'resolve',
+                defaultValue: InstallerResponse.Ignore,
+                token
+            });
+            // Always pass a cancellation token to `install`, to ensure it waits until the module is installed.
+            const response = await Promise.race([
+                this.installer.install(Product.ipykernel, interpreter, installerToken),
+                cancellatonPromise
+            ]);
+            if (response === InstallerResponse.Installed) {
+                return KernelInterpreterDependencyResponse.ok;
+            }
+        }
+        return KernelInterpreterDependencyResponse.cancel;
+    }
+    public areDependenciesInstalled(interpreter: PythonInterpreter, _token?: CancellationToken): Promise<boolean> {
+        return this.installer.isInstalled(Product.ipykernel, interpreter).then((installed) => installed === true);
+    }
+}

src/client/datascience/jupyter/kernels/kernelSelector.ts

@@ -9,7 +9,7 @@ import { CancellationToken } from 'vscode-jsonrpc';
 
 import { IApplicationShell } from '../../../common/application/types';
 import { traceError, traceInfo, traceVerbose } from '../../../common/logger';
-import { IInstaller, Product, Resource } from '../../../common/types';
+import { Resource } from '../../../common/types';
 import * as localize from '../../../common/utils/localize';
 import { noop } from '../../../common/utils/misc';
 import { StopWatch } from '../../../common/utils/stopWatch';
@@ -18,7 +18,7 @@ import { IEventNamePropertyMapping, sendTelemetryEvent } from '../../../telemetr
 import { KnownNotebookLanguages, Telemetry } from '../../constants';
 import { reportAction } from '../../progress/decorator';
 import { ReportableAction } from '../../progress/types';
-import { IJupyterKernelSpec, IJupyterSessionManager } from '../../types';
+import { IJupyterKernelSpec, IJupyterSessionManager, IKernelDependencyService } from '../../types';
 import { KernelSelectionProvider } from './kernelSelections';
 import { KernelService } from './kernelService';
 import { IKernelSpecQuickPickItem, LiveKernelModel } from './types';
@@ -57,7 +57,7 @@ export class KernelSelector {
         @inject(IApplicationShell) private readonly applicationShell: IApplicationShell,
         @inject(KernelService) private readonly kernelService: KernelService,
         @inject(IInterpreterService) private readonly interpreterService: IInterpreterService,
-        @inject(IInstaller) private readonly installer: IInstaller
+        @inject(IKernelDependencyService) private readonly kernelDepdencyService: IKernelDependencyService
     ) {}
 
     /**
@@ -378,7 +378,7 @@ export class KernelSelector {
     ): Promise<KernelSpecInterpreter> {
         let kernelSpec: IJupyterKernelSpec | undefined;
 
-        if (await this.installer.isInstalled(Product.ipykernel, interpreter)) {
+        if (await this.kernelDepdencyService.areDependenciesInstalled(interpreter, cancelToken)) {
             // Find the kernel associated with this interpter.
             kernelSpec = await this.kernelService.findMatchingKernelSpec(interpreter, session, cancelToken);
 

src/client/datascience/jupyter/kernels/kernelService.ts

@@ -15,7 +15,7 @@ import '../../../common/extensions';
 import { traceDecorators, traceError, traceInfo, traceVerbose, traceWarning } from '../../../common/logger';
 import { IFileSystem } from '../../../common/platform/types';
 import { IPythonExecutionFactory } from '../../../common/process/types';
-import { IInstaller, InstallerResponse, Product, ReadWrite } from '../../../common/types';
+import { ReadWrite } from '../../../common/types';
 import { sleep } from '../../../common/utils/async';
 import { noop } from '../../../common/utils/misc';
 import { IEnvironmentActivationService } from '../../../interpreter/activation/types';
@@ -24,7 +24,13 @@ import { captureTelemetry, sendTelemetryEvent } from '../../../telemetry';
 import { Telemetry } from '../../constants';
 import { reportAction } from '../../progress/decorator';
 import { ReportableAction } from '../../progress/types';
-import { IJupyterKernelSpec, IJupyterSessionManager, IJupyterSubCommandExecutionService } from '../../types';
+import {
+    IJupyterKernelSpec,
+    IJupyterSessionManager,
+    IJupyterSubCommandExecutionService,
+    IKernelDependencyService,
+    KernelInterpreterDependencyResponse
+} from '../../types';
 import { JupyterKernelSpec } from './jupyterKernelSpec';
 import { LiveKernelModel } from './types';
 
@@ -61,7 +67,7 @@ export class KernelService {
         private readonly jupyterInterpreterExecService: IJupyterSubCommandExecutionService,
         @inject(IPythonExecutionFactory) private readonly execFactory: IPythonExecutionFactory,
         @inject(IInterpreterService) private readonly interpreterService: IInterpreterService,
-        @inject(IInstaller) private readonly installer: IInstaller,
+        @inject(IKernelDependencyService) private readonly kernelDependencyService: IKernelDependencyService,
         @inject(IFileSystem) private readonly fileSystem: IFileSystem,
         @inject(IEnvironmentActivationService) private readonly activationHelper: IEnvironmentActivationService
     ) {}
@@ -305,15 +311,14 @@ export class KernelService {
         execServicePromise.ignoreErrors();
         const name = this.generateKernelNameForIntepreter(interpreter);
         // If ipykernel is not installed, prompt to install it.
-        if (!(await this.installer.isInstalled(Product.ipykernel, interpreter)) && !disableUI) {
+        if (!(await this.kernelDependencyService.areDependenciesInstalled(interpreter, cancelToken)) && !disableUI) {
             // If we wish to wait for installation to complete, we must provide a cancel token.
             const token = new CancellationTokenSource();
-            const response = await this.installer.promptToInstall(
-                Product.ipykernel,
+            const response = await this.kernelDependencyService.installMissingDependencies(
                 interpreter,
                 wrapCancellationTokens(cancelToken, token.token)
             );
-            if (response !== InstallerResponse.Installed) {
+            if (response !== KernelInterpreterDependencyResponse.ok) {
                 traceWarning(
                     `Prompted to install ipykernel, however ipykernel not installed in the interpreter ${interpreter.path}. Response ${response}`
                 );

src/client/datascience/jupyter/kernels/kernelSwitcher.ts

@@ -4,16 +4,21 @@
 'use strict';
 
 import { inject, injectable } from 'inversify';
-import { CancellationTokenSource, ProgressLocation, ProgressOptions } from 'vscode';
+import { ProgressLocation, ProgressOptions } from 'vscode';
 import { IApplicationShell } from '../../../common/application/types';
-import { traceVerbose } from '../../../common/logger';
-import { IConfigurationService, IInstaller, InstallerResponse, Product, Resource } from '../../../common/types';
+import { IConfigurationService, Resource } from '../../../common/types';
 import { Common, DataScience } from '../../../common/utils/localize';
 import { StopWatch } from '../../../common/utils/stopWatch';
 import { JupyterSessionStartError } from '../../baseJupyterSession';
-// import * as localize from '../../common/utils/localize';
 import { Commands, Settings } from '../../constants';
-import { IJupyterConnection, IJupyterKernelSpec, IJupyterSessionManagerFactory, INotebook } from '../../types';
+import {
+    IJupyterConnection,
+    IJupyterKernelSpec,
+    IJupyterSessionManagerFactory,
+    IKernelDependencyService,
+    INotebook,
+    KernelInterpreterDependencyResponse
+} from '../../types';
 import { JupyterInvalidKernelError } from '../jupyterInvalidKernelError';
 import { KernelSelector, KernelSpecInterpreter } from './kernelSelector';
 import { LiveKernelModel } from './types';
@@ -25,7 +30,7 @@ export class KernelSwitcher {
         @inject(IJupyterSessionManagerFactory) private jupyterSessionManagerFactory: IJupyterSessionManagerFactory,
         @inject(KernelSelector) private kernelSelector: KernelSelector,
         @inject(IApplicationShell) private appShell: IApplicationShell,
-        @inject(IInstaller) private readonly installer: IInstaller
+        @inject(IKernelDependencyService) private readonly kernelDependencyService: IKernelDependencyService
     ) {}
 
     public async switchKernel(notebook: INotebook): Promise<KernelSpecInterpreter | undefined> {
@@ -126,17 +131,9 @@ export class KernelSwitcher {
         }
     }
     private async switchToKernel(notebook: INotebook, kernel: KernelSpecInterpreter): Promise<void> {
-        if (
-            notebook.connection?.type === 'raw' &&
-            !(await this.installer.isInstalled(Product.ipykernel, kernel.interpreter))
-        ) {
-            const token = new CancellationTokenSource();
-            const response = await this.installer.promptToInstall(Product.ipykernel, kernel.interpreter, token.token);
-            if (response === InstallerResponse.Installed) {
-                traceVerbose(`ipykernel installed in ${kernel.interpreter!.path}.`);
-            } else {
-                this.appShell.showErrorMessage(DataScience.ipykernelNotInstalled());
-                traceVerbose(`ipykernel is not installed in ${kernel.interpreter!.path}.`);
+        if (notebook.connection?.type === 'raw' && kernel.interpreter) {
+            const response = await this.kernelDependencyService.installMissingDependencies(kernel.interpreter);
+            if (response === KernelInterpreterDependencyResponse.cancel) {
                 return;
             }
         }

src/client/datascience/serviceRegistry.ts

@@ -65,6 +65,7 @@ import { JupyterPasswordConnect } from './jupyter/jupyterPasswordConnect';
 import { JupyterServerWrapper } from './jupyter/jupyterServerWrapper';
 import { JupyterSessionManagerFactory } from './jupyter/jupyterSessionManagerFactory';
 import { JupyterVariables } from './jupyter/jupyterVariables';
+import { KernelDependencyService } from './jupyter/kernels/kernelDependencyService';
 import { KernelSelectionProvider } from './jupyter/kernels/kernelSelections';
 import { KernelSelector } from './jupyter/kernels/kernelSelector';
 import { KernelService } from './jupyter/kernels/kernelService';
@@ -112,6 +113,7 @@ import {
     IJupyterSessionManagerFactory,
     IJupyterSubCommandExecutionService,
     IJupyterVariables,
+    IKernelDependencyService,
     INotebookEditor,
     INotebookEditorProvider,
     INotebookExecutionLogger,
@@ -209,6 +211,7 @@ export function registerTypes(serviceManager: IServiceManager) {
     serviceManager.addSingleton<IPyWidgetMessageDispatcherFactory>(IPyWidgetMessageDispatcherFactory, IPyWidgetMessageDispatcherFactory);
     serviceManager.addSingleton<IJupyterInterpreterDependencyManager>(IJupyterInterpreterDependencyManager, JupyterInterpreterSubCommandExecutionService);
     serviceManager.addSingleton<IJupyterSubCommandExecutionService>(IJupyterSubCommandExecutionService, JupyterInterpreterSubCommandExecutionService);
+    serviceManager.addSingleton<IKernelDependencyService>(IKernelDependencyService, KernelDependencyService);
 
     registerGatherTypes(serviceManager);
 }

src/client/datascience/types.ts

@@ -1137,3 +1137,17 @@ export interface IJMPConnection extends IDisposable {
     // tslint:disable-next-line: no-any
     subscribe(handlerFunc: (message: KernelMessage.IMessage) => void, errorHandler?: (exc: any) => void): void;
 }
+
+export enum KernelInterpreterDependencyResponse {
+    ok,
+    cancel
+}
+
+export const IKernelDependencyService = Symbol('IKernelDependencyService');
+export interface IKernelDependencyService {
+    installMissingDependencies(
+        interpreter: PythonInterpreter,
+        token?: CancellationToken
+    ): Promise<KernelInterpreterDependencyResponse>;
+    areDependenciesInstalled(interpreter: PythonInterpreter, _token?: CancellationToken): Promise<boolean>;
+}

src/test/datascience/dataScienceIocContainer.ts

@@ -214,6 +214,7 @@ import { JupyterPasswordConnect } from '../../client/datascience/jupyter/jupyter
 import { JupyterServerWrapper } from '../../client/datascience/jupyter/jupyterServerWrapper';
 import { JupyterSessionManagerFactory } from '../../client/datascience/jupyter/jupyterSessionManagerFactory';
 import { JupyterVariables } from '../../client/datascience/jupyter/jupyterVariables';
+import { KernelDependencyService } from '../../client/datascience/jupyter/kernels/kernelDependencyService';
 import { KernelSelectionProvider } from '../../client/datascience/jupyter/kernels/kernelSelections';
 import { KernelSelector } from '../../client/datascience/jupyter/kernels/kernelSelector';
 import { KernelService } from '../../client/datascience/jupyter/kernels/kernelService';
@@ -260,6 +261,7 @@ import {
     IJupyterSessionManagerFactory,
     IJupyterSubCommandExecutionService,
     IJupyterVariables,
+    IKernelDependencyService,
     INotebookEditor,
     INotebookEditorProvider,
     INotebookExecutionLogger,
@@ -751,6 +753,7 @@ export class DataScienceIocContainer extends UnitTestIocContainer {
         this.serviceManager.addSingleton<KernelSelector>(KernelSelector, KernelSelector);
         this.serviceManager.addSingleton<KernelSelectionProvider>(KernelSelectionProvider, KernelSelectionProvider);
         this.serviceManager.addSingleton<KernelSwitcher>(KernelSwitcher, KernelSwitcher);
+        this.serviceManager.addSingleton<IKernelDependencyService>(IKernelDependencyService, KernelDependencyService);
         this.serviceManager.addSingleton<IProductService>(IProductService, ProductService);
         this.serviceManager.addSingleton<IProductPathService>(
             IProductPathService,