TypeScript Session.listRunning方法代码示例

  activate: (
    app: JupyterLab,
    manager: ITooltipManager,
    editorTracker: IEditorTracker,
    rendermime: IRenderMimeRegistry
  ): void => {
    // Keep a list of active ISessions so that we can
    // clean them up when they are no longer needed.
    const activeSessions: {
      [id: string]: Session.ISession;
    } = {};

    const sessions = app.serviceManager.sessions;
    // When the list of running sessions changes,
    // check to see if there are any kernels with a
    // matching path for the file editors.
    const onRunningChanged = (
      sender: Session.IManager,
      models: Session.IModel[]
    ) => {
      editorTracker.forEach(file => {
        const model = find(models, m => file.context.path === m.path);
        if (model) {
          const oldSession = activeSessions[file.id];
          // If there is a matching path, but it is the same
          // session as we previously had, do nothing.
          if (oldSession && oldSession.id === model.id) {
            return;
          }
          // Otherwise, dispose of the old session and reset to
          // a new CompletionConnector.
          if (oldSession) {
            delete activeSessions[file.id];
            oldSession.dispose();
          }
          const session = sessions.connectTo(model);
          activeSessions[file.id] = session;
        } else {
          const session = activeSessions[file.id];
          if (session) {
            session.dispose();
            delete activeSessions[file.id];
          }
        }
      });
    };
    Session.listRunning().then(models => {
      onRunningChanged(sessions, models);
    });
    sessions.runningChanged.connect(onRunningChanged);

    // Clean up after a widget when it is disposed
    editorTracker.widgetAdded.connect((sender, widget) => {
      widget.disposed.connect(w => {
        const session = activeSessions[w.id];
        if (session) {
          session.dispose();
          delete activeSessions[w.id];
        }
      });
    });

    // Add tooltip launch command.
    app.commands.addCommand(CommandIDs.launchFile, {
      execute: async () => {
        const parent = editorTracker.currentWidget;
        const kernel =
          parent &&
          activeSessions[parent.id] &&
          activeSessions[parent.id].kernel;
        if (!kernel) {
          return;
        }
        const anchor = parent.content;
        const editor = anchor.editor;

        // If all components necessary for rendering exist, create a tooltip.
        if (!!editor && !!kernel && !!rendermime) {
          return manager.invoke({ anchor, editor, kernel, rendermime });
        }
      }
    });
  }

    editorTracker.widgetAdded.connect((sender, widget) => {
      const sessions = app.serviceManager.sessions;
      const editor = widget.content.editor;
      const contextConnector = new ContextConnector({ editor });

      // When the list of running sessions changes,
      // check to see if there are any kernels with a
      // matching path for this file editor.
      const onRunningChanged = (
        sender: Session.IManager,
        models: Session.IModel[]
      ) => {
        const oldSession = activeSessions[widget.id];
        // Search for a matching path.
        const model = find(models, m => m.path === widget.context.path);
        if (model) {
          // If there is a matching path, but it is the same
          // session as we previously had, do nothing.
          if (oldSession && oldSession.id === model.id) {
            return;
          }
          // Otherwise, dispose of the old session and reset to
          // a new CompletionConnector.
          if (oldSession) {
            delete activeSessions[widget.id];
            oldSession.dispose();
          }
          const session = sessions.connectTo(model);
          handler.connector = new CompletionConnector({ session, editor });
          activeSessions[widget.id] = session;
        } else {
          // If we didn't find a match, make sure
          // the connector is the contextConnector and
          // dispose of any previous connection.
          handler.connector = contextConnector;
          if (oldSession) {
            delete activeSessions[widget.id];
            oldSession.dispose();
          }
        }
      };
      Session.listRunning().then(models => {
        onRunningChanged(sessions, models);
      });
      sessions.runningChanged.connect(onRunningChanged);

      // Initially create the handler with the contextConnector.
      // If a kernel session is found matching this file editor,
      // it will be replaced in onRunningChanged().
      const handler = manager.register({
        connector: contextConnector,
        editor,
        parent: widget
      });

      // When the widget is disposed, do some cleanup.
      widget.disposed.connect(() => {
        sessions.runningChanged.disconnect(onRunningChanged);
        const session = activeSessions[widget.id];
        if (session) {
          delete activeSessions[widget.id];
          session.dispose();
        }
      });
    });

 it('should fail for error response status', async () => {
   const serverSettings = getRequestHandler(500, {});
   const list = Session.listRunning(serverSettings);
   await expectFailure(list, '');
 });