Function interruptExecution

src/kernels/kernel.ts:560–652

(
        session: IKernelSession,
        pendingExecutions: Promise<unknown>
    )

    }

    private async interruptExecution(
        session: IKernelSession,
        pendingExecutions: Promise<unknown>
    ): Promise<InterruptResult> {
        const restarted = createDeferred<boolean>();
        const stopWatch = new StopWatch();
        const disposables: IDisposable[] = [];
        // Listen to status change events so we can tell if we're restarting
        const restartHandler = (e: KernelMessage.Status) => {
            if (e === 'restarting' || e === 'autorestarting') {
                // We restarted the kernel.
                logger.warn('Kernel restarting during interrupt');

                // Indicate we restarted the race below
                restarted.resolve(true);
            }
        };
        const statusChangedHandler = (_: unknown, e: KernelMessage.Status) => restartHandler(e);
        session.statusChanged.connect(statusChangedHandler);
        disposables.push(
            new Disposable(() => swallowExceptions(() => session.statusChanged.disconnect(statusChangedHandler)))
        );

        if (session && session.kernel) {
            logger.info(`Interrupting kernel: ${session.kernel.name}`);

            // Start our interrupt. If it fails, indicate a restart
            await raceTimeoutError(
                this.kernelSettings.interruptTimeout,
                new KernelInterruptTimeoutError(this.kernelConnectionMetadata),
                session.kernel.interrupt()
            ).catch((exc) => {
                logger.warn(`Error during interrupt: ${exc}`);
                restarted.resolve(true);
            });
        }

        const promise = (async () => {
            // Sometimes kernels can die during interrupt, so wait for the session to die (if not already dead and only when busy)
            // I.e. we do not want to handle cases where kernel dies when not busy.
            const timedOutPromiseDueToDeadKernel = createDeferred<InterruptResult>();
            if (this.status === 'busy') {
                this.onDisposed(() => timedOutPromiseDueToDeadKernel.resolve(InterruptResult.Dead), this, disposables);
                this.onStatusChanged(
                    () =>
                        this.status === 'dead'
                            ? timedOutPromiseDueToDeadKernel.resolve(InterruptResult.Dead)
                            : undefined,
                    this,
                    disposables
                );
            }
            try {
                // Wait for all of the pending cells to finish or the timeout to fire
                return await raceTimeout(
                    this.kernelSettings.interruptTimeout,
                    InterruptResult.TimedOut,
                    pendingExecutions.then(() => InterruptResult.Success),