Refactor code

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

@@ -6,11 +6,15 @@
 import * as fastDeepEqual from 'fast-deep-equal';
 import { inject, injectable } from 'inversify';
 import { Uri } from 'vscode';
+import { ICommandManager } from '../../../common/application/types';
 import { traceWarning } from '../../../common/logger';
 import { IAsyncDisposableRegistry, IConfigurationService, IDisposableRegistry } from '../../../common/types';
-import { INotebookProvider } from '../../types';
+import { IInterpreterService } from '../../../interpreter/contracts';
+import { INotebookContentProvider } from '../../notebook/types';
+import { IDataScienceErrorHandler, INotebookEditorProvider, INotebookProvider } from '../../types';
 import { Kernel } from './kernel';
-import { IKernel, KernelOptions } from './types';
+import { KernelSelector } from './kernelSelector';
+import { IKernel, IKernelSelectionUsage, KernelOptions } from './types';
 
 @injectable()
 export class KernelProvider {
@@ -19,7 +23,15 @@ export class KernelProvider {
         @inject(IAsyncDisposableRegistry) private asyncDisposables: IAsyncDisposableRegistry,
         @inject(IDisposableRegistry) private disposables: IDisposableRegistry,
         @inject(INotebookProvider) private notebookProvider: INotebookProvider,
-        @inject(IConfigurationService) private configService: IConfigurationService
+        @inject(IConfigurationService) private configService: IConfigurationService,
+        @inject(ICommandManager) private readonly commandManager: ICommandManager,
+        @inject(IInterpreterService) private readonly interpreterService: IInterpreterService,
+        @inject(IDataScienceErrorHandler) private readonly errorHandler: IDataScienceErrorHandler,
+        @inject(INotebookContentProvider) private readonly contentProvider: INotebookContentProvider,
+        @inject(INotebookEditorProvider) private readonly editorProvider: INotebookEditorProvider,
+
+        @inject(KernelProvider) private readonly kernelProvider: KernelProvider,
+        @inject(KernelSelector) private readonly kernelSelectionUsage: IKernelSelectionUsage
     ) {}
     public get(uri: Uri): IKernel | undefined {
         return this.kernelsByUri.get(uri.toString())?.kernel;
@@ -40,7 +52,14 @@ export class KernelProvider {
             this.notebookProvider,
             this.disposables,
             waitForIdleTimeout,
-            options.launchingFile
+            options.launchingFile,
+            this.commandManager,
+            this.interpreterService,
+            this.errorHandler,
+            this.contentProvider,
+            this.editorProvider,
+            this.kernelProvider,
+            this.kernelSelectionUsage
         );
         this.asyncDisposables.push(kernel);
         this.kernelsByUri.set(uri.toString(), { options, kernel });

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

@@ -6,11 +6,11 @@
 import type { KernelMessage, Session } from '@jupyterlab/services';
 import type { Observable } from 'rxjs/Observable';
 import type { CancellationToken, Event, QuickPickItem, Uri } from 'vscode';
+import { NotebookCell, NotebookDocument } from '../../../../../types/vscode-proposed';
 import type { ServerStatus } from '../../../../datascience-ui/interactive-common/mainState';
 import type { IAsyncDisposable, Resource } from '../../../common/types';
 import type { PythonInterpreter } from '../../../pythonEnvironments/info';
 import type {
-    ICell,
     IJupyterKernel,
     IJupyterKernelSpec,
     IJupyterSessionManager,
@@ -65,9 +65,10 @@ export interface IKernel extends IAsyncDisposable {
     readonly disposed: boolean;
     readonly kernelSocket: Observable<KernelSocketInformation | undefined>;
     start(): Promise<void>;
-    interrupt(timeoutInMs: number): Promise<InterruptResult>;
-    restart(timeoutInMs: number): Promise<void>;
-    executeObservable(code: string, file: string, line: number, id: string, silent: boolean): Observable<ICell[]>;
+    interrupt(): Promise<InterruptResult>;
+    restart(): Promise<void>;
+    executeCell(cell: NotebookCell): Promise<void>;
+    executeAllCells(document: NotebookDocument): Promise<void>;
     registerIOPubListener(listener: (msg: KernelMessage.IIOPubMessage, requestId: string) => void): void;
 }
 

src/client/datascience/notebook/helpers/multiCancellationToken.ts

@@ -0,0 +1,34 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+'use strict';
+
+import { CancellationToken, EventEmitter } from 'vscode';
+
+/**
+ * Cancellation token source that can be cancelled multiple times.
+ */
+export class MultiCancellationTokenSource {
+    /**
+     * The cancellation token of this source.
+     */
+    public readonly token: CancellationToken;
+    private readonly eventEmitter = new EventEmitter<void>();
+    constructor() {
+        this.token = {
+            isCancellationRequested: false,
+            onCancellationRequested: this.eventEmitter.event.bind(this.eventEmitter)
+        };
+    }
+    public cancel(): void {
+        this.token.isCancellationRequested = true;
+        this.eventEmitter.fire();
+    }
+
+    /**
+     * Dispose object and free resources.
+     */
+    public dispose(): void {
+        this.eventEmitter.dispose();
+    }
+}

src/client/datascience/notebook/kernelProvider.ts

@@ -3,8 +3,9 @@
 
 import * as fastDeepEqual from 'fast-deep-equal';
 import { inject, injectable } from 'inversify';
-import { CancellationToken, Event, EventEmitter } from 'vscode';
+import { CancellationToken, Event, EventEmitter, Uri } from 'vscode';
 import {
+    NotebookCell,
     NotebookDocument,
     NotebookKernel as VSCNotebookKernel,
     NotebookKernelProvider
@@ -20,8 +21,32 @@ import { KernelSelection } from '../jupyter/kernels/types';
 import { INotebookStorageProvider } from '../notebookStorage/notebookStorageProvider';
 import { INotebook, INotebookProvider } from '../types';
 import { getNotebookMetadata, isJupyterNotebook, updateKernelInNotebookMetadata } from './helpers/helpers';
-import { NotebookKernel } from './notebookKernel';
-import { INotebookContentProvider, INotebookExecutionService } from './types';
+import { INotebookContentProvider } from './types';
+
+class VSCodeNotebookKernelMetadata implements VSCNotebookKernel {
+    get preloads(): Uri[] {
+        return [];
+    }
+    constructor(
+        public readonly label: string,
+        public readonly description: string,
+        public readonly selection: Readonly<KernelSelection>,
+        public readonly isPreferred: boolean,
+        private readonly kernelProvider: KernelProvider
+    ) {}
+    public executeCell(_: NotebookDocument, cell: NotebookCell) {
+        this.kernelProvider.get(cell.notebook.uri)?.executeCell(cell); // NOSONAR
+    }
+    public executeAllCells(document: NotebookDocument) {
+        this.kernelProvider.get(document.uri)?.executeAllCells(document); // NOSONAR
+    }
+    public cancelCellExecution(_: NotebookDocument, cell: NotebookCell) {
+        this.kernelProvider.get(cell.notebook.uri)?.interrupt(); // NOSONAR
+    }
+    public cancelAllCellsExecution(document: NotebookDocument) {
+        this.kernelProvider.get(document.uri)?.interrupt(); // NOSONAR
+    }
+}
 
 @injectable()
 export class VSCodeKernelPickerProvider implements NotebookKernelProvider {
@@ -31,7 +56,6 @@ export class VSCodeKernelPickerProvider implements NotebookKernelProvider {
     private readonly _onDidChangeKernels = new EventEmitter<void>();
     private notebookKernelChangeHandled = new WeakSet<INotebook>();
     constructor(
-        @inject(INotebookExecutionService) private readonly execution: INotebookExecutionService,
         @inject(KernelSelectionProvider) private readonly kernelSelectionProvider: KernelSelectionProvider,
         @inject(KernelSelector) private readonly kernelSelector: KernelSelector,
         @inject(KernelProvider) private readonly kernelProvider: KernelProvider,
@@ -45,7 +69,10 @@ export class VSCodeKernelPickerProvider implements NotebookKernelProvider {
         this.kernelSelectionProvider.SelectionsChanged(() => this._onDidChangeKernels.fire(), this, disposables);
         this.notebook.onDidChangeActiveNotebookKernel(this.onDidChangeActiveNotebookKernel, this, disposables);
     }
-    public async provideKernels(document: NotebookDocument, token: CancellationToken): Promise<NotebookKernel[]> {
+    public async provideKernels(
+        document: NotebookDocument,
+        token: CancellationToken
+    ): Promise<VSCodeNotebookKernelMetadata[]> {
         const [preferredKernel, kernels] = await Promise.all([
             this.kernelSelector.getKernelForLocalConnection(
                 document.uri,
@@ -89,21 +116,20 @@ export class VSCodeKernelPickerProvider implements NotebookKernelProvider {
         }
 
         return kernels.map((kernel) => {
-            return new NotebookKernel(
+            return new VSCodeNotebookKernelMetadata(
                 kernel.label,
                 kernel.description || kernel.detail || '',
                 kernel.selection,
                 isPreferredKernel(kernel.selection),
-                this.execution,
-                this.kernelSelector
+                this.kernelProvider
             );
         });
     }
     private async onDidChangeActiveNotebookKernel(newKernelInfo: {
         document: NotebookDocument;
         kernel: VSCNotebookKernel | undefined;
     }) {
-        if (!newKernelInfo.kernel || !(newKernelInfo.kernel instanceof NotebookKernel)) {
+        if (!newKernelInfo.kernel || !(newKernelInfo.kernel instanceof VSCodeNotebookKernelMetadata)) {
             return;
         }
 

src/client/datascience/notebook/notebookEditor.ts

@@ -24,7 +24,6 @@ import {
     IStatusProvider
 } from '../types';
 import { getDefaultCodeLanguage } from './helpers/helpers';
-import { INotebookExecutionService } from './types';
 
 export class NotebookEditor implements INotebookEditor {
     public readonly type = 'native';
@@ -75,7 +74,6 @@ export class NotebookEditor implements INotebookEditor {
         public readonly model: INotebookModel,
         public readonly document: NotebookDocument,
         private readonly vscodeNotebook: IVSCodeNotebook,
-        private readonly executionService: INotebookExecutionService,
         private readonly commandManager: ICommandManager,
         private readonly notebookProvider: INotebookProvider,
         private readonly kernelProvider: KernelProvider,
@@ -142,8 +140,6 @@ export class NotebookEditor implements INotebookEditor {
         this.executedCode.fire(code);
     }
     public async interruptKernel(): Promise<void> {
-        this.executionService.cancelPendingExecutions(this.document);
-
         if (this.restartingKernel) {
             return;
         }
@@ -154,9 +150,7 @@ export class NotebookEditor implements INotebookEditor {
         const status = this.statusProvider.set(DataScience.interruptKernelStatus(), true, undefined, undefined);
 
         try {
-            const interruptTimeout = this.configurationService.getSettings(this.file).datascience
-                .jupyterInterruptTimeout;
-            const result = await kernel.interrupt(interruptTimeout);
+            const result = await kernel.interrupt();
             status.dispose();
 
             // We timed out, ask the user if they want to restart instead.
@@ -178,8 +172,6 @@ export class NotebookEditor implements INotebookEditor {
     }
 
     public async restartKernel(): Promise<void> {
-        this.executionService.cancelPendingExecutions(this.document);
-
         sendTelemetryEvent(Telemetry.RestartKernelCommand);
         if (this.restartingKernel) {
             return;
@@ -217,11 +209,10 @@ export class NotebookEditor implements INotebookEditor {
 
         // Disable running cells.
         const [cellRunnable, runnable] = [this.document.metadata.cellRunnable, this.document.metadata.runnable];
-        const restartTimeout = this.configurationService.getSettings(this.file).datascience.jupyterInterruptTimeout;
         try {
             this.document.metadata.cellRunnable = false;
             this.document.metadata.runnable = false;
-            await kernel.restart(restartTimeout);
+            await kernel.restart();
         } catch (exc) {
             // If we get a kernel promise failure, then restarting timed out. Just shutdown and restart the entire server.
             // Note, this code might not be necessary, as such an error is thrown only when interrupting a kernel times out.

src/client/datascience/notebook/notebookEditorProvider.ts

@@ -27,7 +27,6 @@ import {
 import { JupyterNotebookView } from './constants';
 import { isJupyterNotebook } from './helpers/helpers';
 import { NotebookEditor } from './notebookEditor';
-import { INotebookExecutionService } from './types';
 
 /**
  * Notebook Editor provider used by other parts of DS code.
@@ -153,12 +152,10 @@ export class NotebookEditorProvider implements INotebookEditorProvider {
         if (!editor) {
             const notebookProvider = this.serviceContainer.get<INotebookProvider>(INotebookProvider);
             const kernelProvider = this.serviceContainer.get<KernelProvider>(KernelProvider);
-            const executionService = this.serviceContainer.get<INotebookExecutionService>(INotebookExecutionService);
             editor = new NotebookEditor(
                 model,
                 doc,
                 this.vscodeNotebook,
-                executionService,
                 this.commandManager,
                 notebookProvider,
                 kernelProvider,