Method execute

src/kernels/execution/codeExecution.ts:159–218

(code: string, session: IKernelSession)

    }

    private async execute(code: string, session: IKernelSession) {
        if (!session.kernel) {
            const error = new Error('No kernel available to execute code');
            this._done.resolve();
            throw error;
        }
        traceExecMessage(this.extensionId, this.executionId, 'Send code for execution');

        const kernelConnection = session.kernel;
        try {
            this.started = true;
            this._onRequestSent.fire();
            traceExecMessage(this.extensionId, this.executionId, `Execution Request Sent to Kernel`);
            // For Jupyter requests, silent === don't output, while store_history === don't update execution count
            // https://jupyter-client.readthedocs.io/en/stable/api/client.html#jupyter_client.KernelClient.execute
            this.request = executeSilentlyAndEmitOutput(
                kernelConnection,
                code,
                () => this._onRequestAcknowledge.fire(),
                (output) => this._onDidEmitOutput.fire(output)
            );
            // Don't want dangling promises.
            this.request.done.then(noop, noop);
        } catch (ex) {
            logger.error(`Code execution failed without request, for exec ${this.executionId}`, ex);
            this._completed = true;
            this._done.reject(ex);
            return;
        }

        // WARNING: Do not dispose `request`.
        // Even after request.done & execute_reply is sent we could have more messages coming from iopub.
        // E.g. background threads.

        try {
            // When the request finishes we are done
            // request.done resolves even before all iopub messages have been sent through.
            // Solution is to wait for all messages to get processed.
            const response = await this.request!.done;
            this._completed = true;
            if (response.content.status === 'error') {
                traceExecMessage(this.extensionId, this.executionId, 'Executed with errors');
                this._done.reject(new KernelError(response.content));
            } else {
                traceExecMessage(this.extensionId, this.executionId, 'Executed successfully');
                this._done.resolve();
            }
        } catch (ex) {
            this._completed = true;
            if (this.cancelHandled) {
                return;
            }
            if (!this.disposed && !this.cancelRequested) {
                // @jupyterlab/services throws a `Canceled` error when the kernel is interrupted.
                // Or even when the kernel dies when running a cell with the code `os.kill(os.getpid(), 9)`
                logger.error(`Error in waiting for code ${this.executionId} to complete`, ex);
            }
            this._done.reject(ex);