Fix interrupt_request to use control channel instead of shell

When interrupt_mode is 'message', send interrupt_request on the control
channel as specified by Jupyter protocol. This prevents the interrupt
from being queued behind pending shell messages.

Author: mntss

src/kernels/raw/session/rawKernelConnection.node.ts

@@ -357,16 +357,16 @@ export class RawKernelConnection implements Kernel.IKernelConnection {
         if (this.kernelProcess?.canInterrupt) {
             return this.kernelProcess?.interrupt();
         } else if (this.kernelConnectionMetadata.kernelSpec.interrupt_mode === 'message') {
-            logger.info(`Interrupting kernel with a shell message`);
+            logger.info(`Interrupting kernel with a control message`);
             const jupyterLab = require('@jupyterlab/services') as typeof import('@jupyterlab/services');
             const msg = jupyterLab.KernelMessage.createMessage({
                 msgType: 'interrupt_request' as any,
-                channel: 'shell',
+                channel: 'control',
                 username: this.realKernel!.username,
                 session: this.realKernel!.clientId,
                 content: {}
-            }) as any as KernelMessage.IShellMessage<'inspect_request'>;
-            await this.realKernel!.sendShellMessage<'interrupt_request'>(msg as any, true, true).done.catch((ex) =>
+            }) as any as KernelMessage.IControlMessage<'interrupt_request'>;
+            await this.realKernel!.sendControlMessage<'interrupt_request'>(msg as any, true, true).done.catch((ex) =>
                 logger.error('Failed to interrupt via a message', ex)
             );
         } else {

src/kernels/raw/session/rawSessionConnection.node.unit.test.ts

@@ -505,16 +505,16 @@ suite('Raw Session & Raw Kernel Connection', () => {
         test('Send and interrupt message', async () => {
             (kernelConnectionMetadata.kernelSpec as ReadWrite<IJupyterKernelSpec>).interrupt_mode = 'message';
             when(kernelProcess.canInterrupt).thenReturn(false);
-            let request: KernelMessage.IShellMessage<KernelMessage.ShellMessageType> | undefined;
-            when(kernel.sendShellMessage(anything(), anything(), anything())).thenCall((msg) => {
+            let request: KernelMessage.IControlMessage<KernelMessage.ControlMessageType> | undefined;
+            when(kernel.sendControlMessage(anything(), anything(), anything())).thenCall((msg) => {
                 request = msg;
                 return { done: Promise.resolve() } as any;
             });
 
             await session.kernel?.interrupt();
 
             verify(kernelProcess.interrupt()).never();
-            verify(kernel.sendShellMessage(anything(), anything(), anything())).once();
+            verify(kernel.sendControlMessage(anything(), anything(), anything())).once();
             assert.strictEqual(request?.header.msg_type, 'interrupt_request');
         });
     });