Move bandwidthSaveMode to JupyterLab.IInfo of `@jupyterlab/applic…

…ation`

packages/application/src/lab.ts

@@ -7,6 +7,8 @@ import { Base64ModelFactory } from '@jupyterlab/docregistry';
 
 import { IRenderMime } from '@jupyterlab/rendermime-interfaces';
 
+import { ServiceManager } from '@jupyterlab/services';
+
 import { Token } from '@lumino/coreutils';
 
 import { JupyterFrontEnd, JupyterFrontEndPlugin } from './frontend';
@@ -25,7 +27,17 @@ export class JupyterLab extends JupyterFrontEnd<ILabShell> {
    * Construct a new JupyterLab object.
    */
   constructor(options: JupyterLab.IOptions = { shell: new LabShell() }) {
-    super({ ...options, shell: options.shell || new LabShell() });
+    super({
+      ...options,
+      shell: options.shell || new LabShell(),
+      serviceManager:
+        options.serviceManager ||
+        new ServiceManager({
+          standby: () => {
+            return this._info.bandwidthSaveMode || 'when-hidden';
+          }
+        })
+    });
     this.restored = this.shell.restored
       .then(() => undefined)
       .catch(() => undefined);
@@ -164,7 +176,7 @@ export class JupyterLab extends JupyterFrontEnd<ILabShell> {
     });
   }
 
-  private _info: JupyterLab.IInfo;
+  private _info: JupyterLab.IInfo = JupyterLab.defaultInfo;
   private _paths: JupyterFrontEnd.IPaths;
 }
 
@@ -214,6 +226,18 @@ export namespace JupyterLab {
      * Whether files are cached on the server.
      */
     readonly filesCached: boolean;
+
+    /**
+     * Every periodic network polling should be paused while this is set
+     * to `true`. Extensions should use this value to decide whether to proceed
+     * with the polling.
+     * The extensions may also set this value to `true` if there is no need to
+     * fetch anything from the server backend basing on some conditions
+     * (e.g. when an error message dialog is displayed).
+     * At the same time, the extensions are responsible for setting this value
+     * back to `false`.
+     */
+    bandwidthSaveMode: boolean;
   }
 
   /**
@@ -224,7 +248,8 @@ export namespace JupyterLab {
     deferred: { patterns: [], matches: [] },
     disabled: { patterns: [], matches: [] },
     mimeExtensions: [],
-    filesCached: PageConfig.getOption('cacheFiles').toLowerCase() === 'true'
+    filesCached: PageConfig.getOption('cacheFiles').toLowerCase() === 'true',
+    bandwidthSaveMode: false
   };
 
   /**

packages/docmanager-extension/src/index.ts

@@ -9,7 +9,8 @@ import {
   ILabShell,
   ILabStatus,
   JupyterFrontEnd,
-  JupyterFrontEndPlugin
+  JupyterFrontEndPlugin,
+  JupyterLab
 } from '@jupyterlab/application';
 
 import {
@@ -99,7 +100,8 @@ const docManagerPlugin: JupyterFrontEndPlugin<IDocumentManager> = {
     ICommandPalette,
     ILabShell,
     IMainMenu,
-    ISessionContextDialogs
+    ISessionContextDialogs,
+    JupyterLab.IInfo
   ],
   activate: (
     app: JupyterFrontEnd,
@@ -109,7 +111,8 @@ const docManagerPlugin: JupyterFrontEndPlugin<IDocumentManager> = {
     palette: ICommandPalette | null,
     labShell: ILabShell | null,
     mainMenu: IMainMenu | null,
-    sessionDialogs: ISessionContextDialogs | null
+    sessionDialogs: ISessionContextDialogs | null,
+    info: JupyterLab.IInfo | null
   ): IDocumentManager => {
     const trans = translator.load('jupyterlab');
     const manager = app.serviceManager;
@@ -147,7 +150,10 @@ const docManagerPlugin: JupyterFrontEndPlugin<IDocumentManager> = {
       when,
       setBusy: (status && (() => status.setBusy())) ?? undefined,
       sessionDialogs: sessionDialogs || undefined,
-      translator
+      translator,
+      bandwidthSaveModeCallback: () => {
+        return info?.bandwidthSaveMode || false;
+      }
     });
 
     // Register the file operations commands.

packages/docmanager/src/manager.ts

@@ -49,6 +49,8 @@ export class DocumentManager implements IDocumentManager {
    */
   constructor(options: DocumentManager.IOptions) {
     this.translator = options.translator || nullTranslator;
+    this._bandwidthSaveModeCallback =
+      options.bandwidthSaveModeCallback || (() => false);
     this.registry = options.registry;
     this.services = options.manager;
     this._dialogs = options.sessionDialogs || sessionContextDialogs;
@@ -485,8 +487,8 @@ export class DocumentManager implements IDocumentManager {
     });
     const handler = new SaveHandler({
       context,
-      saveInterval: this.autosaveInterval,
-      services: this.services
+      bandwidthSaveModeCallback: this._bandwidthSaveModeCallback,
+      saveInterval: this.autosaveInterval
     });
     Private.saveHandlerProperty.set(context, handler);
     void context.ready.then(() => {
@@ -609,6 +611,7 @@ export class DocumentManager implements IDocumentManager {
   private _when: Promise<void>;
   private _setBusy: (() => IDisposable) | undefined;
   private _dialogs: ISessionContext.IDialogs;
+  private _bandwidthSaveModeCallback: () => boolean;
 }
 
 /**
@@ -653,6 +656,12 @@ export namespace DocumentManager {
      * The applicaton language translator.
      */
     translator?: ITranslator;
+
+    /**
+     * Autosaving should be paused while this callback function returns `true`.
+     * By default, it always returns `false`.
+     */
+    bandwidthSaveModeCallback?: () => boolean;
   }
 
   /**

packages/docmanager/src/savehandler.ts

@@ -5,8 +5,6 @@ import { IDisposable } from '@lumino/disposable';
 
 import { Signal } from '@lumino/signaling';
 
-import { ServiceManager } from '@jupyterlab/services';
-
 import { DocumentRegistry } from '@jupyterlab/docregistry';
 
 /**
@@ -21,7 +19,8 @@ export class SaveHandler implements IDisposable {
    */
   constructor(options: SaveHandler.IOptions) {
     this._context = options.context;
-    this._services = options.services;
+    this._bandwidthSaveModeCallback =
+      options.bandwidthSaveModeCallback || (() => false);
     const interval = options.saveInterval || 120;
     this._minInterval = interval * 1000;
     this._interval = this._minInterval;
@@ -94,7 +93,7 @@ export class SaveHandler implements IDisposable {
       return;
     }
     this._autosaveTimer = window.setTimeout(() => {
-      if (!this._services.bandwidthSaveMode) {
+      if (!this._bandwidthSaveModeCallback()) {
         this._save();
       }
     }, this._interval);
@@ -151,7 +150,7 @@ export class SaveHandler implements IDisposable {
   private _minInterval = -1;
   private _interval = -1;
   private _context: DocumentRegistry.Context;
-  private _services: ServiceManager.IManager;
+  private _bandwidthSaveModeCallback: () => boolean;
   private _isActive = false;
   private _inDialog = false;
   private _isDisposed = false;
@@ -172,13 +171,14 @@ export namespace SaveHandler {
     context: DocumentRegistry.Context;
 
     /**
-     * The minimum save interval in seconds (default is two minutes).
+     * Autosaving should be paused while this callback function returns `true`.
+     * By default, it always returns `false`.
      */
-    saveInterval?: number;
+    bandwidthSaveModeCallback?: () => boolean;
 
     /**
-     * A service manager instance.
+     * The minimum save interval in seconds (default is two minutes).
      */
-    services: ServiceManager.IManager;
+    saveInterval?: number;
   }
 }

packages/docmanager/test/savehandler.spec.ts

@@ -38,7 +38,7 @@ describe('docregistry/savehandler', () => {
       factory,
       path: UUID.uuid4() + '.txt'
     });
-    handler = new SaveHandler({ context, services: manager });
+    handler = new SaveHandler({ context });
     return context.initialize(true);
   });
 

packages/filebrowser-extension/src/index.ts

@@ -11,7 +11,8 @@ import {
   ITreePathUpdater,
   IRouter,
   JupyterFrontEnd,
-  JupyterFrontEndPlugin
+  JupyterFrontEndPlugin,
+  JupyterLab
 } from '@jupyterlab/application';
 
 import {
@@ -253,14 +254,20 @@ const factory: JupyterFrontEndPlugin<IFileBrowserFactory> = {
   id: '@jupyterlab/filebrowser-extension:factory',
   provides: IFileBrowserFactory,
   requires: [IDocumentManager, ITranslator],
-  optional: [IStateDB, IRouter, JupyterFrontEnd.ITreeResolver],
+  optional: [
+    IStateDB,
+    IRouter,
+    JupyterFrontEnd.ITreeResolver,
+    JupyterLab.IInfo
+  ],
   activate: async (
     app: JupyterFrontEnd,
     docManager: IDocumentManager,
     translator: ITranslator,
     state: IStateDB | null,
     router: IRouter | null,
-    tree: JupyterFrontEnd.ITreeResolver | null
+    tree: JupyterFrontEnd.ITreeResolver | null,
+    info: JupyterLab.IInfo | null
   ): Promise<IFileBrowserFactory> => {
     const { commands } = app;
     const tracker = new WidgetTracker<FileBrowser>({ namespace });
@@ -274,6 +281,9 @@ const factory: JupyterFrontEndPlugin<IFileBrowserFactory> = {
         manager: docManager,
         driveName: options.driveName || '',
         refreshInterval: options.refreshInterval,
+        refreshStandby: () => {
+          return info?.bandwidthSaveMode || 'when-hidden';
+        },
         state:
           options.state === null
             ? undefined

packages/filebrowser/src/model.ts

@@ -113,9 +113,7 @@ export class FileBrowserModel implements IDisposable {
         backoff: true,
         max: 300 * 1000
       },
-      standby: () => {
-        return services.bandwidthSaveMode || 'when-hidden';
-      }
+      standby: options.refreshStandby || 'when-hidden'
     });
   }
 
@@ -700,6 +698,11 @@ export namespace FileBrowserModel {
      */
     refreshInterval?: number;
 
+    /**
+     * When the model stops polling the API. Defaults to `when-hidden`.
+     */
+    refreshStandby?: Poll.Standby | (() => boolean | Poll.Standby);
+
     /**
      * An optional state database. If provided, the model will restore which
      * folder was last opened when it is restored.

packages/hub-extension/src/index.ts

@@ -13,7 +13,8 @@ import {
   ConnectionLost,
   IConnectionLost,
   JupyterFrontEnd,
-  JupyterFrontEndPlugin
+  JupyterFrontEndPlugin,
+  JupyterLab
 } from '@jupyterlab/application';
 
 import { URLExt } from '@jupyterlab/coreutils';
@@ -128,10 +129,12 @@ const hubExtension: JupyterFrontEndPlugin<void> = {
 const connectionlost: JupyterFrontEndPlugin<IConnectionLost> = {
   id: '@jupyterlab/apputils-extension:connectionlost',
   requires: [JupyterFrontEnd.IPaths, ITranslator],
+  optional: [JupyterLab.IInfo],
   activate: (
     app: JupyterFrontEnd,
     paths: JupyterFrontEnd.IPaths,
-    translator: ITranslator
+    translator: ITranslator,
+    info: JupyterLab.IInfo | null
   ): IConnectionLost => {
     const trans = translator.load('jupyterlab');
     const hubPrefix = paths.urls.hubPrefix || '';
@@ -152,8 +155,12 @@ const connectionlost: JupyterFrontEndPlugin<IConnectionLost> = {
       if (showingError) {
         return;
       }
+
       showingError = true;
-      manager.bandwidthSaveMode = true;
+      if (info) {
+        info.bandwidthSaveMode = true;
+      }
+
       const result = await showDialog({
         title: trans.__('Server unavailable or unreachable'),
         body: trans.__(
@@ -165,8 +172,12 @@ const connectionlost: JupyterFrontEndPlugin<IConnectionLost> = {
           Dialog.cancelButton({ label: trans.__('Dismiss') })
         ]
       });
-      manager.bandwidthSaveMode = false;
+
+      if (info) {
+        info.bandwidthSaveMode = false;
+      }
       showingError = false;
+
       if (result.button.accept) {
         await app.commands.execute(CommandIDs.restart);
       }