Function getKernelsApi

src/standalone/api/kernels/index.ts:57–143

(extensionId: string)

}

export function getKernelsApi(extensionId: string): Kernels {
    return {
        async getKernel(uri: Uri) {
            let accessAllowed: boolean | undefined = undefined;

            const kernelProvider = ServiceContainer.instance.get<IKernelProvider>(IKernelProvider);
            const notebook = workspace.notebookDocuments.find((item) => item.uri.toString() === uri.toString());
            const kernel = kernelProvider.get(notebook || uri);
            // We are only interested in returning kernels that have been started by the user.
            // Returning started kernels is not sufficient as we also pre-warm kernels (i.e. we start kernels even though the user may not have executed any code).
            if (!kernel || !kernel.startedAtLeastOnce || !kernel.userStartedKernel) {
                sendTelemetryEvent(Telemetry.NewJupyterKernelsApiUsage, undefined, {
                    extensionId,
                    pemUsed: 'getKernel',
                    accessAllowed
                });
                return;
            }
            if (extensionId !== JVSC_EXTENSION_ID) {
                void initializeInteractiveOrNotebookTelemetryBasedOnUserAction(
                    kernel.resourceUri,
                    kernel.kernelConnectionMetadata
                );
            }
            const { api } = getWrappedKernel(kernel, extensionId);
            return api;
        },
        get onDidStart() {
            if (
                ![JVSC_EXTENSION_ID, DATA_WRANGLER_EXTENSION_ID].includes(extensionId) &&
                !PROPOSED_API_ALLOWED_PUBLISHERS.includes(extensionId.split('.')[0])
            ) {
                throw new Error(`Proposed API is not supported for extension ${extensionId}`);
            }

            // We can cache the event emitter for subsequent calls.
            const extensionAPI = getOrCreateExtensionAPI(extensionId);
            if (!extensionAPI.onDidStart) {
                const kernelProvider = ServiceContainer.instance.get<IKernelProvider>(IKernelProvider);
                const disposableRegistry = ServiceContainer.instance.get<IDisposableRegistry>(IDisposableRegistry);
                extensionAPI.onDidStart = new EventEmitter<{
                    uri: Uri;
                    kernel: Kernel;
                    token: CancellationToken;
                    waitUntil(thenable: Thenable<unknown>): void;
                }>();

                disposableRegistry.push(
                    extensionAPI.onDidStart,
                    kernelProvider.onDidPostInitializeKernel(({ kernel, token, waitUntil }) => {
                        const { api, progress } = getWrappedKernel(kernel, extensionId);
                        extensionAPI.onDidStart?.fire({
                            uri: kernel.uri,
                            kernel: api,
                            token,
                            waitUntil: (thenable) => {
                                // Wrap around the `waitUntil` method to inject telemetry and notifications.
                                // For notifications, we reuse the kernel execution progress indicator message