@difizen/libro-kernel 0.0.2-alpha.0

package/src/server/server-connection-protocol.ts

@@ -0,0 +1,57 @@
+/**
+ * A Jupyter server settings object.
+ * Note that all of the settings are optional when passed to
+ * [[makeSettings]].  The default settings are given in [[defaultSettings]].
+ */
+export interface ISettings {
+  /**
+   * The base url of the server.
+   */
+  readonly baseUrl: string;
+
+  /**
+   * The app url of the JupyterLab application.
+   */
+  readonly appUrl: string;
+
+  /**
+   * The base ws url of the server.
+   */
+  readonly wsUrl: string;
+
+  /**
+   * The default request init options.
+   */
+  readonly init: RequestInit;
+
+  /**
+   * The authentication token for requests.  Use an empty string to disable.
+   */
+  readonly token: string;
+
+  /**
+   * Whether to append a token to a Websocket url.  The default is `false` in the browser
+   * and `true` in node or jest.
+   */
+  readonly appendToken: boolean;
+
+  /**
+   * The `fetch` method to use.
+   */
+  readonly fetch: (input: RequestInfo, init?: RequestInit) => Promise<Response>;
+
+  /**
+   * The `Request` object constructor.
+   */
+  readonly Request: typeof Request;
+
+  /**
+   * The `Headers` object constructor.
+   */
+  readonly Headers: typeof Headers;
+
+  /**
+   * The `WebSocket` object constructor.
+   */
+  readonly WebSocket: typeof WebSocket;
+}

package/src/server/server-connection.ts

@@ -0,0 +1,144 @@
+import { URL } from '@difizen/libro-common';
+import { isNative, isWeb, prop } from '@difizen/mana-app';
+import { singleton } from '@difizen/mana-app';
+
+import { PageConfig } from '../page-config.js';
+
+import { NetworkError } from './connection-error.js';
+import type { ISettings } from './server-connection-protocol.js';
+
+let FETCH: (input: RequestInfo, init?: RequestInit) => Promise<Response>;
+let HEADERS: typeof Headers;
+let REQUEST: typeof Request;
+let WEBSOCKET: typeof WebSocket;
+
+if (typeof window === 'undefined') {
+  // node environment
+} else {
+  FETCH = fetch;
+  REQUEST = Request;
+  HEADERS = Headers;
+  WEBSOCKET = WebSocket;
+}
+
+@singleton()
+export class ServerConnection {
+  @prop()
+  settings: ISettings;
+
+  constructor() {
+    this.updateSettings({
+      baseUrl: 'http://localhost:8000/',
+      wsUrl: 'ws://localhost:8888/',
+    });
+  }
+
+  updateSettings(options: Partial<ISettings> = {}): ISettings {
+    const pageBaseUrl = PageConfig.getBaseUrl();
+    const pageWsUrl = PageConfig.getWsUrl();
+    const baseUrl = URL.normalize(options.baseUrl) || pageBaseUrl;
+    let wsUrl = options.wsUrl;
+    // Prefer the default wsUrl if we are using the default baseUrl.
+    if (!wsUrl && baseUrl === pageBaseUrl) {
+      wsUrl = pageWsUrl;
+    }
+    // Otherwise convert the baseUrl to a wsUrl if possible.
+    if (!wsUrl && baseUrl.indexOf('http') === 0) {
+      wsUrl = 'ws' + baseUrl.slice(4);
+    }
+    // Otherwise fall back on the default wsUrl.
+    wsUrl = wsUrl ?? pageWsUrl;
+
+    this.settings = {
+      init: { cache: 'no-store', credentials: 'same-origin' },
+      fetch: FETCH,
+      Headers: HEADERS,
+      Request: REQUEST,
+      WebSocket: WEBSOCKET,
+      token: PageConfig.getToken(),
+      appUrl: PageConfig.getOption('appUrl'),
+      appendToken:
+        !isWeb ||
+        (isNative && process?.env?.['JEST_WORKER_ID'] !== undefined) ||
+        URL.getHostName(pageBaseUrl) !== URL.getHostName(wsUrl),
+      ...options,
+      baseUrl,
+      wsUrl,
+    };
+    PageConfig.setOption('baseUrl', baseUrl);
+    return this.settings;
+  }
+
+  /**
+   * Handle a request.
+   *
+   * @param url - The url for the request.
+   *
+   * @param init - The overrides for the request init.
+   *
+   * @param settings - The settings object for the request.
+   *
+   * #### Notes
+   * The `url` must start with `settings.baseUrl`.  The `init` settings
+   * take precedence over `settings.init`.
+   */
+  makeRequest(
+    baseUrl: string,
+    init: RequestInit,
+    settings: ISettings = this.settings,
+  ): Promise<Response> {
+    let url = baseUrl;
+    // Handle notebook server requests.
+    if (url.indexOf(settings.baseUrl) !== 0) {
+      throw new Error('Can only be used for notebook server requests');
+    }
+
+    // Use explicit cache buster when `no-store` is set since
+    // not all browsers use it properly.
+    const cache = init.cache ?? settings.init.cache;
+    if (cache === 'no-store') {
+      // https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/Using_XMLHttpRequest#Bypassing_the_cache
+      url += (/\?/.test(url) ? '&' : '?') + new Date().getTime();
+    }
+
+    const request = new settings.Request(url, { ...settings.init, ...init });
+
+    // Handle authentication. Authentication can be overdetermined by
+    // settings token and XSRF token.
+    let authenticated = false;
+    if (settings.token) {
+      authenticated = true;
+      request.headers.append('Authorization', `token ${settings.token}`);
+    }
+    if (typeof document !== 'undefined' && document?.cookie) {
+      const xsrfToken = this.getCookie('_xsrf');
+      if (xsrfToken !== undefined) {
+        authenticated = true;
+        request.headers.append('X-XSRFToken', xsrfToken);
+      }
+    }
+
+    // Set the content type if there is no given data and we are
+    // using an authenticated connection.
+    if (!request.headers.has('Content-Type') && authenticated) {
+      request.headers.set('Content-Type', 'application/json');
+    }
+
+    // Use `call` to avoid a `TypeError` in the browser.
+    return settings.fetch.call(null, request).catch((e: TypeError) => {
+      // Convert the TypeError into a more specific error.
+      throw new NetworkError(e);
+    });
+    // TODO: *this* is probably where we need a system-wide connectionFailure
+    // signal we can hook into.
+  }
+
+  /**
+   * Get a cookie from the document.
+   */
+  getCookie(name: string): string | undefined {
+    // From http://www.tornadoweb.org/en/stable/guide/security.html
+    const matches = document.cookie.match('\\b' + name + '=([^;]*)\\b');
+    return matches?.[1];
+  }
+}

package/src/server/server-manager.ts

@@ -0,0 +1,76 @@
+import { prop } from '@difizen/mana-app';
+import { inject, singleton } from '@difizen/mana-app';
+import { timeout, Deferred } from '@difizen/mana-app';
+
+import type { ISpecModels } from '../kernelspec/restapi.js';
+import { KernelSpecRestAPI } from '../kernelspec/restapi.js';
+
+@singleton()
+export class ServerManager {
+  /**
+   * 加载中
+   */
+  @prop()
+  launching?: boolean = true;
+
+  /**
+   * 加载成功
+   */
+  @prop()
+  loaded?: boolean = false;
+
+  @prop()
+  kernelspec?: ISpecModels;
+
+  protected defer: Deferred<ISpecModels> = new Deferred<ISpecModels>();
+
+  get ready() {
+    return this.defer.promise;
+  }
+
+  protected kernelSpecRestAPI: KernelSpecRestAPI;
+
+  constructor(@inject(KernelSpecRestAPI) kernelSpecRestAPI: KernelSpecRestAPI) {
+    this.kernelSpecRestAPI = kernelSpecRestAPI;
+  }
+
+  async launch() {
+    this.doLaunch()
+      .then((r) => {
+        this.defer.resolve(r);
+        return;
+      })
+      .catch(() => {
+        //
+      });
+
+    return this.defer.promise;
+  }
+
+  protected async doLaunch(): Promise<ISpecModels> {
+    const kernelspec = await this.doGetServerStatus();
+    this.launching = true;
+    this.loaded = false;
+    if (!kernelspec) {
+      await timeout(1000);
+      return await this.doLaunch();
+    }
+    this.launching = false;
+    this.loaded = true;
+    this.kernelspec = kernelspec;
+    return kernelspec;
+  }
+
+  protected async doGetServerStatus(): Promise<ISpecModels | undefined> {
+    try {
+      const r = await this.kernelSpecRestAPI.getSpecs();
+      if (r && r.kernelspecs && Object.keys(r.kernelspecs).length !== 0) {
+        return r;
+      }
+      return;
+    } catch (error) {
+      console.error(error);
+      return;
+    }
+  }
+}

package/src/server/server-module.ts

@@ -0,0 +1,9 @@
+import { ManaModule } from '@difizen/mana-app';
+
+import { ServerConnection } from './server-connection.js';
+import { ServerManager } from './server-manager.js';
+
+export const LibroServerModule = ManaModule.create().register(
+  ServerConnection,
+  ServerManager,
+);

package/src/session/index.ts

@@ -0,0 +1,4 @@
+export * from './libro-session-manager.js';
+export * from './libro-session-protocol.js';
+export * from './session-module.js';
+export * from './restapi.js';

package/src/session/libro-session-manager.ts

@@ -0,0 +1,377 @@
+import { Poll } from '@difizen/libro-common';
+import type { Event } from '@difizen/mana-app';
+import { inject, singleton } from '@difizen/mana-app';
+import { prop, getOrigin } from '@difizen/mana-app';
+import { Emitter } from '@difizen/mana-app';
+import { StorageService } from '@difizen/mana-app';
+
+import type { IContentsModel } from '../contents/index.js';
+import { LibroKernelManager } from '../kernel/libro-kernel-manager.js';
+import { LibroKernelFactory } from '../kernel/libro-kernel-protocol.js';
+import type {
+  KernelConnectionOptions,
+  IKernelModel,
+  IKernelConnection,
+} from '../kernel/libro-kernel-protocol.js';
+import type { ISettings } from '../server/index.js';
+import { NetworkError } from '../server/index.js';
+import { ServerManager } from '../server/server-manager.js';
+
+import { LibroSessionFactory } from './libro-session-protocol.js';
+import type {
+  SessionMeta,
+  ISessionOptions,
+  SessionIModel,
+} from './libro-session-protocol.js';
+import type { DeepPartial } from './restapi.js';
+import { SessionRestAPI } from './restapi.js';
+
+interface PersistSessionMessage {
+  sessionId: string;
+  options: {
+    model: {
+      id: string; // kernel.id,
+      name: string; //  kernel.name,
+    };
+  };
+}
+
+@singleton()
+export class LibroSessionManager {
+  protected sessionFactory: LibroSessionFactory;
+  protected kernelFactory: LibroKernelFactory;
+  @inject(SessionRestAPI) sessionRestAPI: SessionRestAPI;
+
+  @prop()
+  sessionIdMap = new Map<string, string>();
+
+  readonly serverSettings: ISettings;
+  protected kernelManager: LibroKernelManager;
+  protected serverManager: ServerManager;
+  protected _pollModels: Poll;
+  protected _ready: Promise<void>;
+  protected _isReady = false;
+  protected storageService: StorageService;
+  protected _models: Map<string, SessionIModel>;
+  protected _sessionConnections: Map<string, IKernelConnection>; // sessionId -> kernelConnection
+
+  constructor(
+    @inject(LibroKernelManager) kernelManager: LibroKernelManager,
+    @inject(ServerManager) serverManager: ServerManager,
+    @inject(LibroSessionFactory) sessionFactory: LibroSessionFactory,
+    @inject(LibroKernelFactory) kernelFactory: LibroKernelFactory,
+    @inject(StorageService) storageService: StorageService,
+  ) {
+    this.kernelManager = kernelManager;
+    this.serverManager = serverManager;
+    this.sessionFactory = sessionFactory;
+    this.kernelFactory = kernelFactory;
+    this.storageService = storageService;
+    this._models = new Map();
+    this._sessionConnections = new Map();
+
+    // Start model polling with exponential backoff.
+    this._pollModels = new Poll({
+      auto: false,
+      factory: () => this.requestRunning(),
+      frequency: {
+        interval: 10 * 1000,
+        backoff: true,
+        max: 300 * 1000,
+      },
+      name: `@jupyterlab/services:SessionManager#models`,
+      // standby: options.standby ?? 'when-hidden',
+      standby: 'when-hidden',
+    });
+
+    // Initialize internal data.
+    this._ready = (async () => {
+      await getOrigin(this._pollModels).start();
+      await getOrigin(this._pollModels).tick;
+      // if (this._kernelManager.isActive) {
+      //   await this._kernelManager.ready;
+      // }
+      this._isReady = true;
+    })();
+  }
+
+  /**
+   * Execute a request to the server to poll running kernels and update state.
+   */
+  protected async requestRunning(): Promise<void> {
+    let models: SessionMeta[];
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      models = await this.sessionRestAPI.listRunning(this.serverSettings);
+    } catch (err: any) {
+      // Handle network errors, as well as cases where we are on a
+      // JupyterHub and the server is not running. JupyterHub returns a
+      // 503 (<2.0) or 424 (>2.0) in that case.
+      if (
+        err instanceof NetworkError ||
+        err.response?.status === 503 ||
+        err.response?.status === 424
+      ) {
+        this._connectionFailure.fire(err);
+      }
+      throw err;
+    }
+
+    this._models = new Map(models.map((x) => [x.id, x]));
+
+    for (const [sessionId, kc] of this._sessionConnections) {
+      if (!this._models.has(sessionId)) {
+        let filePersistKey = '';
+        this.sessionIdMap.forEach((id, pk) => {
+          if (id === sessionId) {
+            filePersistKey = pk;
+            return;
+          }
+        });
+
+        await this.storageService.setData(filePersistKey, undefined);
+        kc.dispose();
+        this.sessionIdMap.delete(filePersistKey);
+      }
+    }
+  }
+
+  protected _connectionFailure = new Emitter<Error>();
+
+  /**
+   * A signal emitted when there is a connection failure.
+   */
+  get connectionFailure(): Event<Error> {
+    return this._connectionFailure.event;
+  }
+
+  @prop()
+  kernelConnection?: IKernelConnection;
+
+  protected persistKey(fileInfo: IContentsModel): string {
+    return `${fileInfo.path}/${fileInfo.name}`;
+  }
+
+  async shutdownKC(fileInfo: IContentsModel, kc: IKernelConnection) {
+    // 删除缓存
+    await this.storageService.setData(this.persistKey(fileInfo), undefined);
+    await kc.shutdown();
+    this.sessionIdMap.delete(this.persistKey(fileInfo));
+  }
+
+  async connectToKernel(
+    fileInfo: IContentsModel,
+    reuseKernelInfo?: { id: string; name: string },
+  ): Promise<IKernelConnection | undefined> {
+    // 轮询获取的kernelspec，选取第一个kernelspec作为默认kernel
+    let firstKernelSpecName = undefined;
+    if (
+      this.serverManager.kernelspec &&
+      this.serverManager.kernelspec.kernelspecs &&
+      Object.keys(this.serverManager.kernelspec?.kernelspecs).length !== 0
+    ) {
+      const kernelspec = Object.keys(this.serverManager.kernelspec.kernelspecs)[0];
+      firstKernelSpecName =
+        this.serverManager.kernelspec?.kernelspecs[kernelspec]?.name;
+    }
+
+    const newSession = await this.sessionRestAPI.startSession(
+      {
+        name: fileInfo.name,
+        kernel: {
+          kernelName: reuseKernelInfo
+            ? reuseKernelInfo.name
+            : fileInfo.content.metadata.kernelspec?.name || firstKernelSpecName, // 使用ipynb文件原本的kernel name，或者使用kernel spec轮询得到的第一个kernel name
+        },
+        path: fileInfo.path,
+        type: fileInfo.type,
+      } as ISessionOptions,
+      this.serverSettings,
+    );
+    await this.refreshRunning();
+
+    if (!newSession || !newSession.kernel) {
+      return undefined;
+    }
+
+    // // 根据session中的信息，新建kernel
+    // newSession.kernel = this.kernelFactory(newSession.kernel);
+    // newSession.kernel.sessionIds.add(newSession.id);
+
+    // 建立Kernel连接
+    const options = {
+      model: {
+        id: reuseKernelInfo ? reuseKernelInfo.id : newSession.kernel.id,
+        name: reuseKernelInfo ? reuseKernelInfo.name : newSession.kernel.name,
+      },
+    } as KernelConnectionOptions;
+
+    await this.storageService.setData(
+      this.persistKey(fileInfo),
+      JSON.stringify({
+        sessionId: newSession.id,
+        options: options,
+      } as PersistSessionMessage),
+    );
+
+    this.sessionIdMap.set(this.persistKey(fileInfo), newSession.id);
+
+    const kernelConnection = await this.kernelManager.connectToKernel({
+      ...options,
+      serverSettings: this.serverSettings,
+    });
+
+    this._sessionConnections.set(newSession.id, kernelConnection);
+
+    return kernelConnection;
+    // newSession.kernel.kernelConnection = kernelConnection;
+
+    // // 新建session
+    // const currLibroSession = this.sessionFactory(newSession as SessionMeta);
+    // // 保存session
+    // this.sessionMap.set(newSession.id, currLibroSession);
+    // // 保存kernel
+    // this.kernelManager.kernelMap.set(newSession.kernel.id, newSession.kernel);
+  }
+
+  async startNew(fileInfo: IContentsModel) {
+    // const fileContent = await sessionApi.queryFile(params.fileName, params.type);
+
+    // const { name, content, type, path } = fileInfo;
+
+    // await this.queryAndUpdateSessions();
+
+    const tryGetPersistSession: string | undefined = await this.storageService.getData(
+      this.persistKey(fileInfo),
+    );
+
+    let kernelConnection = undefined;
+
+    if (!tryGetPersistSession) {
+      kernelConnection = await this.connectToKernel(fileInfo);
+    } else {
+      const { options, sessionId } = JSON.parse(
+        tryGetPersistSession,
+      ) as PersistSessionMessage;
+
+      const kernelId = options.model.id;
+      const isAlive = await this.kernelManager.isKernelAlive(kernelId);
+
+      if (isAlive) {
+        // 尝试复用缓存中的kernel
+        kernelConnection = await this.kernelManager.connectToKernel({
+          ...options,
+          serverSettings: this.serverSettings,
+        });
+        if (kernelConnection) {
+          this._sessionConnections.set(sessionId, kernelConnection);
+        }
+      } else {
+        // TODO: 如果缓存中的kernel不能重用，则使用fileInfo建立新的kernel连接
+        await this.storageService.setData(this.persistKey(fileInfo), undefined);
+        kernelConnection = await this.connectToKernel(fileInfo);
+      }
+    }
+
+    this.kernelConnection = kernelConnection;
+    return kernelConnection;
+  }
+
+  /**
+   * Force a refresh of the running sessions.
+   *
+   * @returns A promise that with the list of running sessions.
+   *
+   * #### Notes
+   * This is not typically meant to be called by the user, since the
+   * manager maintains its own internal state.
+   */
+  async refreshRunning(): Promise<void> {
+    await getOrigin(this._pollModels).refresh();
+    await getOrigin(this._pollModels).tick;
+  }
+
+  /**
+   * Send a PATCH to the server, updating the session path or the kernel.
+   */
+  private async _patch(
+    body: DeepPartial<SessionIModel>,
+    sessionId?: string,
+  ): Promise<SessionIModel> {
+    // TODO: 复用session
+    const model = await this.sessionRestAPI.updateSession(
+      { ...body, id: sessionId ?? '' },
+      this.serverSettings,
+    );
+    // this.update(model);
+    return model;
+  }
+
+  /**
+   * Change the kernel.
+   *
+   * @param options - The name or id of the new kernel.
+   *
+   * #### Notes
+   * This shuts down the existing kernel and creates a new kernel,
+   * keeping the existing session ID and session path.
+   */
+  async changeKernel(
+    fileInfo: IContentsModel,
+    options: Partial<IKernelModel>,
+  ): Promise<IKernelConnection | null> {
+    let reuseSessionId = this.sessionIdMap.get(this.persistKey(fileInfo));
+
+    // shutdown 过后
+    if (!reuseSessionId) {
+      const newSession = await this.sessionRestAPI.startSession(
+        {
+          name: fileInfo.name,
+          kernel: {
+            kernelName: options.name || fileInfo.content.metadata.kernelspec.name,
+          },
+          path: fileInfo.path,
+          type: fileInfo.type,
+        } as ISessionOptions,
+        this.serverSettings,
+      );
+      await this.refreshRunning();
+
+      if (!newSession || !newSession.kernel) {
+        return null;
+      }
+      reuseSessionId = newSession.id;
+      this.sessionIdMap.set(this.persistKey(fileInfo), reuseSessionId!);
+    }
+
+    const model = await this._patch({ kernel: options } as any, reuseSessionId);
+
+    if (!model || !model.kernel) {
+      return null;
+    }
+
+    const optionsForConnectKernel = {
+      model: {
+        id: model.kernel.id,
+        name: model.kernel.name,
+      },
+    } as KernelConnectionOptions;
+
+    await this.storageService.setData(
+      this.persistKey(fileInfo),
+      JSON.stringify({
+        sessionId: reuseSessionId,
+        options: optionsForConnectKernel,
+      } as PersistSessionMessage),
+    );
+
+    const kernelConnection = await this.kernelManager.connectToKernel({
+      ...optionsForConnectKernel,
+      serverSettings: this.serverSettings,
+    });
+
+    this._sessionConnections.set(reuseSessionId!, kernelConnection);
+
+    return kernelConnection;
+  }
+}