Function initializeAfterStart

src/kernels/kernel.ts:777–897

(session: IKernelSession | undefined)

    }

    private async initializeAfterStart(session: IKernelSession | undefined) {
        const nb = workspace.notebookDocuments.find((nb) => nb.uri.toString() === this.uri.toString());
        const tracker = getNotebookTelemetryTracker(nb);
        const postInitialization = nb ? tracker?.postKernelStartup() : undefined;
        try {
            await Promise.all(
                Array.from(this.hooks.get('didStart') || new Set<Hook>()).map((h) =>
                    h(session, this.startCancellation.token).catch(noop)
                )
            );
            logger.trace(`Started running kernel initialization for ${getDisplayPath(this.uri)}`);
            if (!session) {
                logger.trace('Not running kernel initialization');
                return;
            }
            if (!this.hookedSessionForEvents.has(session)) {
                this.hookedSessionForEvents.add(session);
                session.onDidKernelSocketChange((e) => this._onDidKernelSocketChange.fire(e));
                session.onDidDispose(() => {
                    logger.ci(
                        `Kernel got disposed as a result of session.onDisposed (1) ${getDisplayPath(
                            this.resourceUri || this.uri
                        )}`
                    );
                    // Ignore when session is disposed as a result of failed restarts.
                    if (!this._ignoreJupyterSessionDisposedErrors) {
                        logger.info(
                            `Kernel got disposed as a result of session.onDisposed ${getDisplayPath(
                                this.resourceUri || this.uri
                            )} & _ignoreJupyterSessionDisposedErrors = false.`
                        );
                        const isActiveSessionDead = this._session === session;
                        this._jupyterSessionPromise = undefined;
                        this._postInitializedOnStartPromise = undefined;
                        this._session = undefined;

                        // If the active session died, then kernel is dead.
                        if (isActiveSessionDead) {
                            this.isKernelDead = true;
                            this._onStatusChanged.fire('dead');
                        }
                    }
                });
                const statusChangeHandler = (_: unknown, status: KernelMessage.Status) =>
                    this._onStatusChanged.fire(status);
                session.statusChanged.connect(statusChangeHandler);
                this.disposables.push(
                    new Disposable(() => swallowExceptions(() => session.statusChanged.disconnect(statusChangeHandler)))
                );
            }

            // So that we don't have problems with ipywidgets, always register the default ipywidgets comm target.
            // Restart sessions and retries might make this hard to do correctly otherwise.
            session.kernel?.registerCommTarget(Identifiers.DefaultCommTarget, noop);

            if (this.kernelConnectionMetadata.kind === 'connectToLiveRemoteKernel') {
                // As users can have IPyWidgets at any point in time, we need to determine the version of ipywidgets
                // This must happen early on as the state of the kernel needs to be synced with the Kernel in the webview (renderer)