Add manager for lab extension

This manager will be added to running sessions widget so that user can
view and terminate running server proxy apps.

Proxy app metadata will be shown when we hover over proxy app name.

Author: mahendrapaipuri

labextension/src/index.ts

@@ -5,7 +5,21 @@ import {
 } from "@jupyterlab/application";
 import { ILauncher } from "@jupyterlab/launcher";
 import { PageConfig } from "@jupyterlab/coreutils";
+import { IRunningSessionManagers, IRunningSessions } from '@jupyterlab/running';
 import { IFrame, MainAreaWidget, WidgetTracker } from "@jupyterlab/apputils";
+import { LabIcon } from '@jupyterlab/ui-components';
+import { ServerProxyManager } from './manager';
+import { IModel as IServerProxyModel } from './serverproxy';
+import serverProxyAppSvgstr from '../style/icons/proxy.svg';
+
+export const ServerProxyAppIcon = new LabIcon({
+  name: 'server-proxy:proxyAppIcon',
+  svgstr: serverProxyAppSvgstr
+});
+
+namespace CommandIDs {
+  export const open = 'running-server-proxy:open';
+}
 
 function newServerProxyWidget(
   id: string,
@@ -32,6 +46,53 @@ function newServerProxyWidget(
   return widget;
 }
 
+/**
+ * This function adds the active server proxy applications to running sessions
+ * so that user can track currently running applications via server proxy.
+ * User can shut down the applications as well to restart them in future
+ *
+ */
+ function addRunningSessionManager(
+  managers: IRunningSessionManagers,
+  app: JupyterFrontEnd,
+  manager: ServerProxyManager
+): void {
+  managers.add({
+    name: 'Server Proxy Apps',
+    running: () =>
+      Array.from(manager.running()).map(
+        model => new RunningServerProxyApp(model)
+      ),
+    shutdownAll: () => manager.shutdownAll(),
+    refreshRunning: () => manager.refreshRunning(),
+    runningChanged: manager.runningChanged,
+    shutdownAllConfirmationText: 'Are you sure you want to close all server proxy applications?'
+  });
+
+  class RunningServerProxyApp implements IRunningSessions.IRunningItem {
+    constructor(model: IServerProxyModel) {
+      this._model = model;
+    }
+    open(): void {
+      app.commands.execute(CommandIDs.open, { sp: this._model });
+    }
+    icon(): LabIcon {
+      return ServerProxyAppIcon;
+    }
+    label(): string {
+      return `${this._model.name}`;
+    }
+    labelTitle(): string {
+      return `cmd: ${this._model.cmd}\nport: ${this._model.port}\nmanaged: ${this._model.managed}`;
+    }
+    shutdown(): Promise<void> {
+      return manager.shutdown(this._model.name);
+    }
+
+    private _model: IServerProxyModel;
+  }
+}
+
 /**
  * The activate function is registered to be called on activation of the
  * jupyterlab extension.
@@ -42,10 +103,11 @@ async function activate(
   app: JupyterFrontEnd,
   launcher: ILauncher,
   restorer: ILayoutRestorer,
+  sessions: IRunningSessionManagers | null
 ): Promise<void> {
   // Fetch configured server processes from {base_url}/server-proxy/servers-info
   const response = await fetch(
-    PageConfig.getBaseUrl() + "server-proxy/servers-info",
+    PageConfig.getBaseUrl() + "api/server-proxy/servers-info",
   );
   if (!response.ok) {
     console.log(
@@ -76,6 +138,13 @@ async function activate(
   }
 
   const { commands, shell } = app;
+
+  // Add server proxy session manager to running sessions
+  if (sessions) {
+    let manager = new ServerProxyManager();
+    addRunningSessionManager(sessions, app, manager);
+  }
+
   commands.addCommand(command, {
     label: (args) => args["title"] as string,
     execute: (args) => {
@@ -105,6 +174,15 @@ async function activate(
     },
   });
 
+  commands.addCommand(CommandIDs.open, {
+    execute: args => {
+      const model = args['sp'] as IServerProxyModel;
+      const url = PageConfig.getBaseUrl() + model.url;
+      window.open(url, '_blank');
+      return;
+    }
+  });
+
   for (let server_process of data.server_processes) {
     if (!server_process.launcher_entry.enabled) {
       continue;

labextension/src/manager.ts

@@ -0,0 +1,163 @@
+import { Signal, ISignal } from '@lumino/signaling';
+import { ServerConnection } from '@jupyterlab/services';
+import { listRunning, shutdown } from './restapi';
+import * as ServerProxyApp from './serverproxy';
+
+/**
+ * A server proxy manager.
+ */
+export class ServerProxyManager implements ServerProxyApp.IManager {
+  /**
+   * Construct a new server proxy manager.
+   */
+  constructor(options: ServerProxyManager.IOptions = {}) {
+      this.serverSettings = options.serverSettings || ServerConnection.makeSettings();
+      this._refreshTimer = (setInterval as any)(() => {
+          if (typeof document !== 'undefined' && document.hidden) {
+              return;
+          }
+          this._refreshRunning();
+      }, 10000);
+  }
+
+  /**
+   * The server settings of the manager.
+   */
+  readonly serverSettings: ServerConnection.ISettings;
+
+  /**
+   * A signal emitted when the running server proxies change.
+   */
+  get runningChanged(): ISignal<this, ServerProxyApp.IModel[]> {
+      return this._runningChanged;
+  }
+
+  /**
+   * A signal emitted when there is a connection failure.
+   */
+  get connectionFailure(): ISignal<this, Error> {
+      return this._connectionFailure;
+  }
+
+  /**
+   * Test whether the delegate has been disposed.
+   */
+  get isDisposed(): boolean {
+      return this._isDisposed;
+  }
+
+  /**
+   * Dispose of the resources used by the manager.
+   */
+  dispose(): void {
+      if (this.isDisposed) {
+          return;
+      }
+      this._isDisposed = true;
+      clearInterval(this._refreshTimer);
+      Signal.clearData(this);
+  }
+
+  /**
+   * Create an iterator over the most recent running proxy apps.
+   *
+   * @returns A new iterator over the running proxy apps.
+   */
+  running(): IterableIterator<ServerProxyApp.IModel> {
+      return this._models[Symbol.iterator]();
+  }
+
+  /**
+   * Shut down a server proxy app by name.
+   */
+  async shutdown(name: string): Promise<void> {
+      await shutdown(name, this.serverSettings);
+      await this.refreshRunning();
+  }
+
+  /**
+   * Shut down all server proxy apps.
+   *
+   * @returns A promise that resolves when all of the apps are shut down.
+   */
+  async shutdownAll(): Promise<void> {
+      // Update the list of models to make sure our list is current.
+      await this.refreshRunning();
+
+      // Shut down all models.
+      await Promise.all(
+          this._names.map(name => shutdown(name, this.serverSettings))
+      );
+
+      // Update the list of models to clear out our state.
+      await this.refreshRunning();
+  }
+
+  /**
+   * Force a refresh of the running server proxy apps.
+   *
+   * @returns A promise that with the list of running proxy apps.
+   */
+  async refreshRunning(): Promise<void> {
+      return this._refreshRunning();
+  }
+
+  /**
+   * Refresh the running proxy apps.
+   */
+  private async _refreshRunning(): Promise<void> {
+      let models: ServerProxyApp.IModel[];
+      try {
+          models = await 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 ServerConnection.NetworkError ||
+              err.response?.status === 503 ||
+              err.response?.status === 424
+          ) {
+              this._connectionFailure.emit(err);
+          }
+          throw err;
+      }
+
+      if (this.isDisposed) {
+          return;
+      }
+
+      const names = models.map(({ name }) => name).sort();
+      if (names === this._names) {
+      // Identical models list, so just return
+          return;
+      }
+
+      this._names = names;
+      this._models = models;
+      this._runningChanged.emit(this._models);
+  }
+
+  private _names: string[] = [];
+  private _models: ServerProxyApp.IModel[] = [];
+
+  private _isDisposed = false;
+  private _refreshTimer = -1;
+  private _runningChanged = new Signal<this, ServerProxyApp.IModel[]>(this);
+  private _connectionFailure = new Signal<this, Error>(this);
+}
+
+/**
+ * The namespace for `BaseManager` class statics.
+ */
+export namespace ServerProxyManager {
+  /**
+   * The options used to initialize a SessionManager.
+   */
+  export interface IOptions {
+    /**
+     * The server settings for the manager.
+     */
+    serverSettings?: ServerConnection.ISettings;
+  }
+}

labextension/src/restapi.ts

@@ -0,0 +1,58 @@
+import { URLExt } from '@jupyterlab/coreutils';
+import { ServerConnection } from '@jupyterlab/services';
+import { IModel } from './serverproxy'
+
+/**
+ * The url for the server proxy service.
+ */
+const SERVER_PROXY_SERVICE_URL = 'api/server-proxy';
+
+/**
+ * List the running server proxy apps.
+ *
+ * @param settings - The server settings to use.
+ *
+ * @returns A promise that resolves with the list of running session models.
+ */
+export async function listRunning(
+  settings: ServerConnection.ISettings = ServerConnection.makeSettings()
+): Promise<IModel[]> {
+  const url = URLExt.join(settings.baseUrl, SERVER_PROXY_SERVICE_URL);
+  const response = await ServerConnection.makeRequest(url, {}, settings);
+  if (response.status !== 200) {
+    const err = await ServerConnection.ResponseError.create(response);
+    throw err;
+  }
+  const data = await response.json();
+
+  if (!Array.isArray(data)) {
+    throw new Error('Invalid server proxy list');
+  }
+
+  return data;
+}
+
+/**
+ * Shut down a server proxy app by name.
+ *
+ * @param name - The name of the target server proxy app.
+ *
+ * @param settings - The server settings to use.
+ *
+ * @returns A promise that resolves when the app is shut down.
+ */
+export async function shutdown(
+  name: string,
+  settings: ServerConnection.ISettings = ServerConnection.makeSettings()
+): Promise<void> {
+  const url = URLExt.join(settings.baseUrl, SERVER_PROXY_SERVICE_URL, name);
+  const init = { method: 'DELETE' };
+  const response = await ServerConnection.makeRequest(url, init, settings);
+  if (response.status === 404) {
+    const msg = `Server proxy "${name}" does not exist. Are you sure "${name}" is started by jupyter-server-proxy?`;
+    console.warn(msg);
+  } else if (response.status !== 204) {
+      const err = await ServerConnection.ResponseError.create(response);
+      throw err;
+  }
+}