Present kernel detection progress in kernel picker/status (microsoft#166294)

* Experimental kernel detection task

* Update kernel detection progress

* no need for start/end now.

* Enforce proposed api

Author: rebornix

src/vs/workbench/api/browser/mainThreadNotebookKernels.ts

@@ -15,7 +15,7 @@ import { extHostNamedCustomer, IExtHostContext } from 'vs/workbench/services/ext
 import { INotebookEditor } from 'vs/workbench/contrib/notebook/browser/notebookBrowser';
 import { INotebookEditorService } from 'vs/workbench/contrib/notebook/browser/services/notebookEditorService';
 import { INotebookCellExecution, INotebookExecutionStateService } from 'vs/workbench/contrib/notebook/common/notebookExecutionStateService';
-import { INotebookKernel, INotebookKernelChangeEvent, INotebookKernelService } from 'vs/workbench/contrib/notebook/common/notebookKernelService';
+import { INotebookKernel, INotebookKernelChangeEvent, INotebookKernelDetectionTask, INotebookKernelService } from 'vs/workbench/contrib/notebook/common/notebookKernelService';
 import { SerializableObjectWithBuffers } from 'vs/workbench/services/extensions/common/proxyIdentifier';
 import { ExtHostContext, ExtHostNotebookKernelsShape, ICellExecuteUpdateDto, ICellExecutionCompleteDto, INotebookKernelDto2, MainContext, MainThreadNotebookKernelsShape } from '../common/extHost.protocol';
 import { INotebookService } from 'vs/workbench/contrib/notebook/common/notebookService';
@@ -101,13 +101,18 @@ abstract class MainThreadKernel implements INotebookKernel {
 	abstract cancelNotebookCellExecution(uri: URI, cellHandles: number[]): Promise<void>;
 }
 
+class MainThreadKernelDetectionTask implements INotebookKernelDetectionTask {
+	constructor(readonly notebookType: string) { }
+}
+
 @extHostNamedCustomer(MainContext.MainThreadNotebookKernels)
 export class MainThreadNotebookKernels implements MainThreadNotebookKernelsShape {
 
 	private readonly _editors = new DisposableMap<INotebookEditor>();
 	private readonly _disposables = new DisposableStore();
 
 	private readonly _kernels = new Map<number, [kernel: MainThreadKernel, registraion: IDisposable]>();
+	private readonly _kernelDetectionTasks = new Map<number, [task: MainThreadKernelDetectionTask, registraion: IDisposable]>();
 	private readonly _proxy: ExtHostNotebookKernelsShape;
 
 	private readonly _executions = new Map<number, INotebookCellExecution>();
@@ -143,6 +148,9 @@ export class MainThreadNotebookKernels implements MainThreadNotebookKernelsShape
 		for (const [, registration] of this._kernels.values()) {
 			registration.dispose();
 		}
+		for (const [, registration] of this._kernelDetectionTasks.values()) {
+			registration.dispose();
+		}
 		this._editors.dispose();
 	}
 
@@ -286,4 +294,19 @@ export class MainThreadNotebookKernels implements MainThreadNotebookKernelsShape
 			this._executions.delete(handle);
 		}
 	}
+
+	// --- notebook kernel detection task
+	async $addKernelDetectionTask(handle: number, notebookType: string): Promise<void> {
+		const kernelDetectionTask = new MainThreadKernelDetectionTask(notebookType);
+		const registration = this._notebookKernelService.registerNotebookKernelDetectionTask(kernelDetectionTask);
+		this._kernelDetectionTasks.set(handle, [kernelDetectionTask, registration]);
+	}
+
+	$removeKernelDetectionTask(handle: number): void {
+		const tuple = this._kernelDetectionTasks.get(handle);
+		if (tuple) {
+			tuple[1].dispose();
+			this._kernelDetectionTasks.delete(handle);
+		}
+	}
 }

src/vs/workbench/api/common/extHost.api.impl.ts

@@ -1148,6 +1148,10 @@ export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): I
 			createRendererMessaging(rendererId) {
 				return extHostNotebookRenderers.createRendererMessaging(extension, rendererId);
 			},
+			createNotebookControllerDetectionTask(notebookType: string) {
+				checkProposedApiEnabled(extension, 'notebookKernelSource');
+				return extHostNotebookKernels.createNotebookControllerDetectionTask(extension, notebookType);
+			},
 			onDidChangeNotebookCellExecutionState(listener, thisArgs?, disposables?) {
 				checkProposedApiEnabled(extension, 'notebookCellExecutionState');
 				return extHostNotebookKernels.onDidChangeNotebookCellExecutionState(listener, thisArgs, disposables);

src/vs/workbench/api/common/extHost.protocol.ts

@@ -1042,6 +1042,9 @@ export interface MainThreadNotebookKernelsShape extends IDisposable {
 	$createExecution(handle: number, controllerId: string, uri: UriComponents, cellHandle: number): void;
 	$updateExecution(handle: number, data: SerializableObjectWithBuffers<ICellExecuteUpdateDto[]>): void;
 	$completeExecution(handle: number, data: SerializableObjectWithBuffers<ICellExecutionCompleteDto>): void;
+
+	$addKernelDetectionTask(handle: number, notebookType: string): Promise<void>;
+	$removeKernelDetectionTask(handle: number): void;
 }
 
 export interface MainThreadNotebookRenderersShape extends IDisposable {

src/vs/workbench/api/common/extHostNotebookKernels.ts

@@ -44,6 +44,9 @@ export class ExtHostNotebookKernels implements ExtHostNotebookKernelsShape {
 	private readonly _proxy: MainThreadNotebookKernelsShape;
 	private readonly _activeExecutions = new ResourceMap<NotebookCellExecutionTask>();
 
+	private _kernelDetectionTask = new Map<number, vscode.NotebookControllerDetectionTask>();
+	private _kernelDetectionTaskHandlePool: number = 0;
+
 	private readonly _kernelData = new Map<number, IKernelData>();
 	private _handlePool: number = 0;
 
@@ -271,6 +274,24 @@ export class ExtHostNotebookKernels implements ExtHostNotebookKernelsShape {
 		return null;
 	}
 
+	createNotebookControllerDetectionTask(extension: IExtensionDescription, viewType: string): vscode.NotebookControllerDetectionTask {
+		const handle = this._kernelDetectionTaskHandlePool++;
+		const that = this;
+
+		this._logService.trace(`NotebookControllerDetectionTask[${handle}], CREATED by ${extension.identifier.value}`);
+		this._proxy.$addKernelDetectionTask(handle, viewType);
+
+		const detectionTask: vscode.NotebookControllerDetectionTask = {
+			dispose: () => {
+				this._kernelDetectionTask.delete(handle);
+				that._proxy.$removeKernelDetectionTask(handle);
+			}
+		};
+
+		this._kernelDetectionTask.set(handle, detectionTask);
+		return detectionTask;
+	}
+
 	$acceptNotebookAssociation(handle: number, uri: UriComponents, value: boolean): void {
 		const obj = this._kernelData.get(handle);
 		if (obj) {

src/vs/workbench/contrib/notebook/browser/contrib/editorStatusBar/editorStatusBar.ts

@@ -192,6 +192,12 @@ registerAction2(class extends Action2 {
 			? nls.localize('prompt.placeholder.change', "Change kernel for '{0}'", labelService.getUriLabel(notebook.uri, { relative: true }))
 			: nls.localize('prompt.placeholder.select', "Select kernel for '{0}'", labelService.getUriLabel(notebook.uri, { relative: true }));
 
+		quickPick.busy = notebookKernelService.getKernelDetectionTasks(notebook).length > 0;
+
+		const kernelDetectionTaskListener = notebookKernelService.onDidChangeKernelDetectionTasks(() => {
+			quickPick.busy = notebookKernelService.getKernelDetectionTasks(notebook).length > 0;
+		});
+
 		// run extension recommendataion task if quickPickItems is empty
 		const extensionRecommendataionPromise = quickPickItems.length === 0
 			? createCancelablePromise(token => this._showInstallKernelExtensionRecommendation(notebook, quickPick, extensionWorkbenchService, token))
@@ -250,6 +256,7 @@ registerAction2(class extends Action2 {
 			});
 
 			quickPick.onDidHide(() => () => {
+				kernelDetectionTaskListener.dispose();
 				kernelChangeEventListener.dispose();
 				quickPick.dispose();
 				reject();

src/vs/workbench/contrib/notebook/browser/services/notebookKernelServiceImpl.ts

@@ -6,7 +6,7 @@
 import { Event, Emitter } from 'vs/base/common/event';
 import { Disposable, IDisposable, toDisposable } from 'vs/base/common/lifecycle';
 import { INotebookTextModel } from 'vs/workbench/contrib/notebook/common/notebookCommon';
-import { INotebookKernel, ISelectedNotebooksChangeEvent, INotebookKernelMatchResult, INotebookKernelService, INotebookTextModelLike, ISourceAction, INotebookSourceActionChangeEvent } from 'vs/workbench/contrib/notebook/common/notebookKernelService';
+import { INotebookKernel, ISelectedNotebooksChangeEvent, INotebookKernelMatchResult, INotebookKernelService, INotebookTextModelLike, ISourceAction, INotebookSourceActionChangeEvent, INotebookKernelDetectionTask } from 'vs/workbench/contrib/notebook/common/notebookKernelService';
 import { LRUCache, ResourceMap } from 'vs/base/common/map';
 import { IStorageService, StorageScope, StorageTarget } from 'vs/platform/storage/common/storage';
 import { URI } from 'vs/base/common/uri';
@@ -105,12 +105,15 @@ export class NotebookKernelService extends Disposable implements INotebookKernel
 	private readonly _onDidChangeNotebookAffinity = this._register(new Emitter<void>());
 	private readonly _onDidChangeSourceActions = this._register(new Emitter<INotebookSourceActionChangeEvent>());
 	private readonly _kernelSources = new Map<string, IKernelInfoCache>();
+	private readonly _kernelDetectionTasks = new Map<string, INotebookKernelDetectionTask[]>();
+	private readonly _onDidChangeKernelDetectionTasks = this._register(new Emitter<string>());
 
 	readonly onDidChangeSelectedNotebooks: Event<ISelectedNotebooksChangeEvent> = this._onDidChangeNotebookKernelBinding.event;
 	readonly onDidAddKernel: Event<INotebookKernel> = this._onDidAddKernel.event;
 	readonly onDidRemoveKernel: Event<INotebookKernel> = this._onDidRemoveKernel.event;
 	readonly onDidChangeNotebookAffinity: Event<void> = this._onDidChangeNotebookAffinity.event;
 	readonly onDidChangeSourceActions: Event<INotebookSourceActionChangeEvent> = this._onDidChangeSourceActions.event;
+	readonly onDidChangeKernelDetectionTasks: Event<string> = this._onDidChangeKernelDetectionTasks.event;
 
 	private static _storageNotebookBinding = 'notebook.controller2NotebookBindings';
 
@@ -342,4 +345,25 @@ export class NotebookKernelService extends Disposable implements INotebookKernel
 
 		return info.actions.map(a => a[0]);
 	}
+
+	registerNotebookKernelDetectionTask(task: INotebookKernelDetectionTask): IDisposable {
+		const notebookType = task.notebookType;
+		const all = this._kernelDetectionTasks.get(notebookType) ?? [];
+		all.push(task);
+		this._kernelDetectionTasks.set(notebookType, all);
+		this._onDidChangeKernelDetectionTasks.fire(notebookType);
+		return toDisposable(() => {
+			const all = this._kernelDetectionTasks.get(notebookType) ?? [];
+			const idx = all.indexOf(task);
+			if (idx >= 0) {
+				all.splice(idx, 1);
+				this._kernelDetectionTasks.set(notebookType, all);
+				this._onDidChangeKernelDetectionTasks.fire(notebookType);
+			}
+		});
+	}
+
+	getKernelDetectionTasks(notebook: INotebookTextModelLike): INotebookKernelDetectionTask[] {
+		return this._kernelDetectionTasks.get(notebook.viewType) ?? [];
+	}
 }

src/vs/workbench/contrib/notebook/browser/viewParts/notebookKernelActionViewItem.ts

@@ -33,6 +33,7 @@ export class NotebooKernelActionViewItem extends ActionViewItem {
 		this._register(_notebookKernelService.onDidChangeNotebookAffinity(this._update, this));
 		this._register(_notebookKernelService.onDidChangeSelectedNotebooks(this._update, this));
 		this._register(_notebookKernelService.onDidChangeSourceActions(this._update, this));
+		this._register(_notebookKernelService.onDidChangeKernelDetectionTasks(this._update, this));
 	}
 
 	override render(container: HTMLElement): void {
@@ -60,6 +61,11 @@ export class NotebooKernelActionViewItem extends ActionViewItem {
 			return;
 		}
 
+		const detectionTasks = this._notebookKernelService.getKernelDetectionTasks(notebook);
+		if (detectionTasks.length) {
+			return this._updateActionFromDetectionTask();
+		}
+
 		const runningActions = this._notebookKernelService.getRunningSourceActions(notebook);
 		if (runningActions.length) {
 			return this._updateActionFromSourceAction(runningActions[0] /** TODO handle multiple actions state */, true);
@@ -73,6 +79,12 @@ export class NotebooKernelActionViewItem extends ActionViewItem {
 		this._updateActionFromKernelInfo(info);
 	}
 
+	private _updateActionFromDetectionTask() {
+		this._action.enabled = true;
+		this._action.label = localize('kernels.detecting', "Detecting Kernels");
+		this._action.class = ThemeIcon.asClassName(ThemeIcon.modify(executingStateIcon, 'spin'));
+	}
+
 	private _updateActionFromSourceAction(sourceAction: ISourceAction, running: boolean) {
 		const action = sourceAction.action;
 		this.action.class = running ? ThemeIcon.asClassName(ThemeIcon.modify(executingStateIcon, 'spin')) : ThemeIcon.asClassName(selectKernelIcon);

src/vs/workbench/contrib/notebook/common/notebookKernelService.ts

@@ -67,6 +67,10 @@ export interface INotebookProxyKernelChangeEvent extends INotebookKernelChangeEv
 	connectionState?: true;
 }
 
+export interface INotebookKernelDetectionTask {
+	readonly notebookType: string;
+}
+
 export interface ISourceAction {
 	readonly action: IAction;
 	readonly onDidChangeState: Event<void>;
@@ -115,6 +119,12 @@ export interface INotebookKernelService {
 	 */
 	updateKernelNotebookAffinity(kernel: INotebookKernel, notebook: URI, preference: number | undefined): void;
 
+	//#region Kernel detection tasks
+	readonly onDidChangeKernelDetectionTasks: Event<string>;
+	registerNotebookKernelDetectionTask(task: INotebookKernelDetectionTask): IDisposable;
+	getKernelDetectionTasks(notebook: INotebookTextModelLike): INotebookKernelDetectionTask[];
+	//#endregion
+
 	//#region Kernel source actions
 	readonly onDidChangeSourceActions: Event<INotebookSourceActionChangeEvent>;
 	getSourceActions(notebook: INotebookTextModelLike, contextKeyService: IContextKeyService | undefined): ISourceAction[];

src/vscode-dts/vscode.proposed.notebookKernelSource.d.ts

@@ -4,4 +4,17 @@
  *--------------------------------------------------------------------------------------------*/
 
 declare module 'vscode' {
+	export interface NotebookControllerDetectionTask {
+		/**
+		 * Dispose and remove the detection task.
+		 */
+		dispose(): void;
+	}
+
+	export namespace notebooks {
+		/**
+		 * Create notebook controller detection task
+		 */
+		export function createNotebookControllerDetectionTask(notebookType: string): NotebookControllerDetectionTask;
+	}
 }