Working but super slow

Author: rchiodo

package.nls.json

@@ -136,6 +136,7 @@
  "DataScience.startingJupyter": "Starting Jupyter server",
  "DataScience.connectingToJupyter": "Connecting to Jupyter server",
  "DataScience.connectingToIPyKernel": "Connecting to IPython kernel",
+ "DataScience.connectedToIPyKernel": "Connected.",
  "Experiments.inGroup": "User belongs to experiment group '{0}'",
  "Interpreters.RefreshingInterpreters": "Refreshing Python Interpreters",
  "Interpreters.entireWorkspace": "Entire workspace",

src/client/common/utils/localize.ts

@@ -377,6 +377,7 @@ export namespace DataScience {
  export const importingFormat = localize('DataScience.importingFormat', 'Importing {0}');
  export const startingJupyter = localize('DataScience.startingJupyter', 'Starting Jupyter server');
  export const connectingIPyKernel = localize('DataScience.connectingToIPyKernel', 'Connecting to IPython kernel');
+ export const connectedToIPyKernel = localize('DataScience.connectedToIPyKernel', 'Connected.');
  export const connectingToJupyter = localize('DataScience.connectingToJupyter', 'Connecting to Jupyter server');
  export const exportingFormat = localize('DataScience.exportingFormat', 'Exporting {0}');
  export const runAllCellsLensCommandTitle = localize(

src/client/datascience/baseJupyterSession.ts

@@ -40,28 +40,6 @@ export abstract class BaseJupyterSession implements IJupyterSession {
  protected get session(): ISessionWithSocket | undefined {
  return this._session;
  }
- protected set session(session: ISessionWithSocket | undefined) {
- const oldSession = this._session;
- this._session = session;
-
- // If we have a new session, then emit the new kernel connection information.
- if (session && oldSession !== session) {
- if (!session.kernelSocketInformation) {
- traceError(`Unable to find WebSocket connetion assocated with kerne ${session.kernel.id}`);
- this._kernelSocket.next(undefined);
- } else {
- this._kernelSocket.next({
- options: {
- clientId: session.kernel.clientId,
- id: session.kernel.id,
- model: { ...session.kernel.model },
- userName: session.kernel.username
- },
- socket: session.kernelSocketInformation.socket
- });
- }
- }
- }
  protected kernelSpec: IJupyterKernelSpec | LiveKernelModel | undefined;
  public get kernelSocket(): Observable<KernelSocketInformation | undefined> {
  return this._kernelSocket;
@@ -119,7 +97,7 @@ export abstract class BaseJupyterSession implements IJupyterSession {
  } catch {
  noop();
  }
- this.session = undefined;
+ this.setSession(undefined);
  this.restartSessionPromise = undefined;
  }
  if (this.onStatusChangedEvent) {
@@ -160,13 +138,13 @@ export abstract class BaseJupyterSession implements IJupyterSession {
  this.kernelSpec = kernel;
 
  // Save the new session
- this.session = newSession;
+ this.setSession(newSession);
 
  // Listen for session status changes
  this.session?.statusChanged.connect(this.statusHandler); // NOSONAR
 
  // Start the restart session promise too.
- this.restartSessionPromise = this.createRestartSession(kernel, this.session);
+ this.restartSessionPromise = this.createRestartSession(kernel, newSession);
  }
 
  public async restart(_timeout: number): Promise<void> {
@@ -189,7 +167,7 @@ export abstract class BaseJupyterSession implements IJupyterSession {
  const oldStatusHandler = this.statusHandler;
 
  // Just switch to the other session. It should already be ready
- this.session = await this.restartSessionPromise;
+ this.setSession(await this.restartSessionPromise);
  if (!this.session) {
  throw new Error(localize.DataScience.sessionDisposed());
  }
@@ -329,6 +307,29 @@ export abstract class BaseJupyterSession implements IJupyterSession {
  timeoutMS: number
  ): Promise<ISessionWithSocket>;
 
+ // Changes the current session.
+ protected setSession(session: ISessionWithSocket | undefined) {
+ const oldSession = this._session;
+ this._session = session;
+
+ // If we have a new session, then emit the new kernel connection information.
+ if (session && oldSession !== session) {
+ if (!session.kernelSocketInformation) {
+ traceError(`Unable to find WebSocket connection assocated with kerne ${session.kernel.id}`);
+ this._kernelSocket.next(undefined);
+ } else {
+ this._kernelSocket.next({
+ options: {
+ clientId: session.kernel.clientId,
+ id: session.kernel.id,
+ model: { ...session.kernel.model },
+ userName: session.kernel.username
+ },
+ socket: session.kernelSocketInformation.socket
+ });
+ }
+ }
+ }
  protected async shutdownSession(
  session: ISessionWithSocket | undefined,
  statusHandler: Slot<ISessionWithSocket, Kernel.Status> | undefined

src/client/datascience/jupyter/jupyterSession.ts

@@ -90,11 +90,8 @@ export class JupyterSession extends BaseJupyterSession {
  }
 
  // Start a new session
- this.session = await this.createSession(
- this.serverSettings,
- this.kernelSpec,
- this.contentsManager,
- cancelToken
+ this.setSession(
+ await this.createSession(this.serverSettings, this.kernelSpec, this.contentsManager, cancelToken)
  );
 
  // Listen for session status changes

src/client/datascience/kernel-launcher/kernelLauncher.ts

@@ -3,7 +3,7 @@
 'use strict';
 
 import { ChildProcess } from 'child_process';
-import { inject, injectable } from 'inversify';
+import { inject, injectable, named } from 'inversify';
 import * as portfinder from 'portfinder';
 import { promisify } from 'util';
 import * as uuid from 'uuid/v4';
@@ -12,10 +12,12 @@ import { InterpreterUri } from '../../common/installer/types';
 import { traceInfo, traceWarning } from '../../common/logger';
 import { IFileSystem, TemporaryFile } from '../../common/platform/types';
 import { IPythonExecutionFactory } from '../../common/process/types';
+import { IOutputChannel } from '../../common/types';
 import { createDeferred, Deferred } from '../../common/utils/async';
 import * as localize from '../../common/utils/localize';
 import { noop } from '../../common/utils/misc';
 import { IInterpreterService } from '../../interpreter/contracts';
+import { JUPYTER_OUTPUT_CHANNEL } from '../constants';
 import { IJupyterKernelSpec } from '../types';
 import { findIndexOfConnectionFile } from './kernelFinder';
 import { IKernelConnection, IKernelFinder, IKernelLauncher, IKernelProcess } from './types';
@@ -49,6 +51,7 @@ class KernelProcess implements IKernelProcess {
  private executionFactory: IPythonExecutionFactory,
  private interpreterService: IInterpreterService,
  private file: IFileSystem,
+ private outputChannel: IOutputChannel,
  private _connection: IKernelConnection,
  private _kernelSpec: IJupyterKernelSpec
  ) {
@@ -82,11 +85,15 @@ class KernelProcess implements IKernelProcess {
  interpreter: matchingInterpreter
  });
 
+ this.outputChannel.appendLine(localize.DataScience.connectingIPyKernel());
+
  // Then launch that process, also merging in the environment in the kernelspec
  const exeObs = executionService.execObservable(args, { extraVariables: this._kernelSpec.env });
 
  if (exeObs.proc) {
  exeObs.proc!.on('exit', (exitCode) => {
+ // tslint:disable-next-line: messages-must-be-localized
+ this.outputChannel.appendLine(`Kernel died with exit code: ${exitCode}`);
  traceInfo('KernelProcess Exit', `Exit - ${exitCode}`);
  if (!this.readyPromise.completed) {
  this.readyPromise.reject(new Error(localize.DataScience.rawKernelProcessExitBeforeConnect()));
@@ -100,13 +107,18 @@ class KernelProcess implements IKernelProcess {
  exeObs.out.subscribe((output) => {
  if (output.source === 'stderr') {
  traceWarning(`StdErr from Kernel Process ${output.out}`);
+ this.outputChannel.appendLine(output.out);
  } else {
  // Search for --existing this is the message that will indicate that our kernel is actually
  // up and started from stdout
  // To connect another client to this kernel, use:
  // --existing /var/folders/q7/cn8fg6s94fgdcl0h7rbxldf00000gn/T/tmp-16231TOL2dgBoWET1.json
+ // Is this going to work with non-python?
  if (!this.readyPromise.completed && output.out.includes('--existing')) {
  this.readyPromise.resolve();
+ this.outputChannel.appendLine(localize.DataScience.connectedToIPyKernel());
+ } else if (this.readyPromise.resolved) {
+ this.outputChannel.appendLine(output.out);
  }
  traceInfo(output.out);
  }
@@ -133,7 +145,8 @@ export class KernelLauncher implements IKernelLauncher {
  @inject(IKernelFinder) private kernelFinder: IKernelFinder,
  @inject(IPythonExecutionFactory) private executionFactory: IPythonExecutionFactory,
  @inject(IInterpreterService) private interpreterService: IInterpreterService,
- @inject(IFileSystem) private file: IFileSystem
+ @inject(IFileSystem) private file: IFileSystem,
+ @inject(IOutputChannel) @named(JUPYTER_OUTPUT_CHANNEL) private jupyterOutput: IOutputChannel
  ) {}
 
  public async launch(
@@ -154,6 +167,7 @@ export class KernelLauncher implements IKernelLauncher {
  this.executionFactory,
  this.interpreterService,
  this.file,
+ this.jupyterOutput,
  connection,
  kernelSpec
  );

src/client/datascience/raw-kernel/enchannel-zmq-backend-6/index.ts

@@ -150,7 +150,9 @@ class SocketEventEmitter extends Events.EventEmitter {
  this.emit('message', b);
  setTimeout(this.waitForReceive.bind(this, socket), 0);
  })
- .ignoreErrors();
+ .catch((exc) => {
+ traceError('Exception communicating with kernel:', exc);
+ });
  }
  }
 }

src/client/datascience/raw-kernel/enchannelJMPConnection.ts

@@ -1,6 +1,7 @@
 import type { KernelMessage } from '@jupyterlab/services';
 import type { Channels } from '@nteract/messaging';
 import { injectable } from 'inversify';
+import { noop } from '../../common/utils/misc';
 import { IJMPConnection, IJMPConnectionInfo } from '../types';
 
 @injectable()
@@ -24,10 +25,11 @@ export class EnchannelJMPConnection implements IJMPConnection {
  this.mainChannel.next(message as any);
  }
  }
- public subscribe(handlerFunc: (message: KernelMessage.IMessage) => void) {
+ // tslint:disable-next-line: no-any
+ public subscribe(handlerFunc: (message: KernelMessage.IMessage) => void, errorHandler?: (exc: any) => void) {
  if (this.mainChannel) {
  // tslint:disable-next-line:no-any
- this.mainChannel.subscribe(handlerFunc as any);
+ this.mainChannel.subscribe(handlerFunc as any, errorHandler ? errorHandler : noop);
  }
  }
 

src/client/datascience/raw-kernel/rawJupyterSession.ts

@@ -57,10 +57,11 @@ export class RawJupyterSession extends BaseJupyterSession {
  ): Promise<IJupyterKernelSpec | undefined> {
  // Save the resource that we connect with
  this.resource = resource;
+ let newSession: RawSession | null | CancellationError = null;
  try {
  // Try to start up our raw session, allow for cancellation or timeout
  // Notebook Provider level will handle the thrown error
- const newSession = await waitForPromise(
+ newSession = await waitForPromise(
  Promise.race([
  this.startRawSession(resource, kernelName),
  createPromiseFromCancellation({
@@ -81,7 +82,7 @@ export class RawJupyterSession extends BaseJupyterSession {
  throw new Error(localize.DataScience.sessionDisposed());
  } else {
  traceInfo('Raw session started and connected');
- this.session = newSession;
+ this.setSession(newSession);
  this.kernelSpec = newSession.kernelProcess?.kernelSpec;
  }
  } catch (error) {
@@ -94,7 +95,7 @@ export class RawJupyterSession extends BaseJupyterSession {
  this.startRestartSession();
 
  this.connected = true;
- return (this.session as RawSession).kernelProcess.kernelSpec;
+ return (newSession as RawSession).kernelProcess.kernelSpec;
  }
 
  public async createNewKernelSession(
@@ -109,8 +110,8 @@ export class RawJupyterSession extends BaseJupyterSession {
  return this.startRawSession(this.resource, kernel);
  }
 
- protected set session(session: ISessionWithSocket | undefined) {
- super.session = session;
+ protected setSession(session: ISessionWithSocket | undefined) {
+ super.setSession(session);
 
  // When setting the session clear our current exit handler and hook up to the
  // new session process

src/client/datascience/raw-kernel/rawKernel.ts

@@ -2,7 +2,7 @@
 // Licensed under the MIT License.
 import type { Kernel, KernelMessage, ServerConnection } from '@jupyterlab/services';
 import * as uuid from 'uuid/v4';
-import { KernelSocketWrapper } from '../kernelSocketWrapper';
+import { IWebSocketLike, KernelSocketWrapper } from '../kernelSocketWrapper';
 import { IJMPConnection, IKernelSocket } from '../types';
 import { RawSocket } from './rawSocket';
 
@@ -65,41 +65,13 @@ export class RawKernel implements Kernel.IKernel {
  public get isDisposed(): boolean {
  return this.realKernel.isDisposed;
  }
- private realKernel: Kernel.IKernel;
- constructor(connection: IJMPConnection, name: string, clientId: string) {
- // Dummy websocket we give to the underlying real kernel
- let socketInstance: any;
- class RawSocketWrapper extends KernelSocketWrapper(RawSocket) {
- constructor() {
- super(connection, clientId);
- socketInstance = this;
- }
- }
-
- // Remap the server settings for the real kernel to use our dummy websocket
- // tslint:disable-next-line: no-require-imports
- const jupyterLab = require('@jupyterlab/services') as typeof import('@jupyterlab/services');
- const settings = jupyterLab.ServerConnection.makeSettings({
- WebSocket: RawSocketWrapper as any,
- wsUrl: 'BOGUS_PVSC'
- });
-
- // Then create the real kernel
- // tslint:disable-next-line: no-require-imports
- const defaultImport = require('@jupyterlab/services/lib/kernel/default') as typeof import('@jupyterlab/services/lib/kernel/default');
- this.realKernel = new defaultImport.DefaultKernel(
- {
- name,
- serverSettings: settings,
- clientId,
- handleComms: true
- },
- uuid()
- );
-
+ constructor(private realKernel: Kernel.IKernel, socket: IKernelSocket & IWebSocketLike) {
  // Save this raw socket as our kernel socket. It will be
  // used to watch and respond to kernel messages.
- this.socket = socketInstance;
+ this.socket = socket;
+
+ // Pretend like an open occurred. This will prime the real kernel to be connected
+ socket.emit('open');
  }
 
  public shutdown(): Promise<void> {
@@ -222,3 +194,38 @@ export class RawKernel implements Kernel.IKernel {
  this.realKernel.removeMessageHook(msgId, hook);
  }
 }
+
+export function createRawKernel(connection: IJMPConnection, name: string, clientId: string): RawKernel {
+ // Dummy websocket we give to the underlying real kernel
+ let socketInstance: any;
+ class RawSocketWrapper extends KernelSocketWrapper(RawSocket) {
+ constructor() {
+ super(connection, clientId);
+ socketInstance = this;
+ }
+ }
+
+ // Remap the server settings for the real kernel to use our dummy websocket
+ // tslint:disable-next-line: no-require-imports
+ const jupyterLab = require('@jupyterlab/services') as typeof import('@jupyterlab/services');
+ const settings = jupyterLab.ServerConnection.makeSettings({
+ WebSocket: RawSocketWrapper as any,
+ wsUrl: 'BOGUS_PVSC'
+ });
+
+ // Then create the real kernel
+ // tslint:disable-next-line: no-require-imports
+ const defaultImport = require('@jupyterlab/services/lib/kernel/default') as typeof import('@jupyterlab/services/lib/kernel/default');
+ const realKernel = new defaultImport.DefaultKernel(
+ {
+ name,
+ serverSettings: settings,
+ clientId,
+ handleComms: true
+ },
+ uuid()
+ );
+
+ // Use this real kernel in result.
+ return new RawKernel(realKernel, socketInstance);
+}