Function restart

src/kernels/kernel.ts:367–451

()

        await this.disposingPromise;
    }
    public async restart(): Promise<void> {
        try {
            const resourceType = getResourceType(this.resourceUri);
            logger.info(`Restart requested ${getDisplayPath(this.uri)}`);
            await Promise.all(
                Array.from(this.hooks.get('willRestart') || new Set<Hook>()).map((h) => h(this._jupyterSessionPromise))
            );
            this.startCancellation.cancel(); // Cancel any pending starts.
            this.startCancellation.dispose();
            const stopWatch = new StopWatch();
            try {
                // Check if the session was started already.
                // Note, it could be empty if we were starting this and it got cancelled due to us
                // cancelling the token earlier.
                const session = this._jupyterSessionPromise
                    ? await this._jupyterSessionPromise.catch(() => undefined)
                    : undefined;

                if (session) {
                    // We already have a session, now try to restart that session instead of starting a whole new one.
                    // Just use the internal session. Pending cells should have been canceled by the caller
                    // Try to restart the current session if possible.
                    if (!this._restartPromise) {
                        // Just use the internal session. Pending cells should have been canceled by the caller
                        this._restartPromise = session.restart();
                        this._restartPromise
                            // Done restarting, clear restart promise
                            .finally(() => (this._restartPromise = undefined))
                            .catch(noop);
                    }
                    await this._restartPromise;

                    // Re-create the cancel token as we cancelled this earlier in this method.
                    this.startCancellation = new CancellationTokenSource();
                } else {
                    // If the session died, then start a new session.
                    // Or possible the previously pending start was cancelled above.
                    await this.start(new DisplayOptions(false));
                }
                sendKernelTelemetryEvent(
                    this.resourceUri,
                    Telemetry.NotebookRestart,
                    { duration: stopWatch.elapsedTime },
                    { resourceType }
                );
            } catch (ex) {
                logger.error(`Restart failed ${getDisplayPath(this.uri)}`, ex);
                this._ignoreJupyterSessionDisposedErrors = true;
                // If restart fails, kill the associated session.
                const session = this._session;
                this._session = undefined;
                this._jupyterSessionPromise = undefined;
                this._postInitializedOnStartPromise = undefined;
                // 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.
                sendKernelTelemetryEvent(
                    this.resourceUri,
                    Telemetry.NotebookRestart,