Class SessionManager

valdi/vscode_debugger/src/sessionManager.ts:108–254

}

export class SessionManager<TSessionImpl extends IDebugSessionLike>
  implements IDisposable, IBinderDelegate {
  private _disposables: IDisposable[] = [];
  private _sessions = new Map<string, Session<TSessionImpl>>();

  private _pendingTarget = new Map<string, { target: ITarget; parent: Session<TSessionImpl> }>();
  private _sessionForTarget = new Map<ITarget, Promise<Session<TSessionImpl>>>();
  private _sessionForTargetCallbacks = new Map<
    ITarget,
    { fulfill: (session: Session<TSessionImpl>) => void; reject: (error: Error) => void }
  >();

  constructor(
    private readonly globalContainer: Container,
    private readonly sessionLauncher: SessionLauncher<TSessionImpl>,
  ) {}

  public terminate(debugSession: TSessionImpl) {
    const session = this._sessions.get(debugSession.id);
    this._sessions.delete(debugSession.id);
    if (session) session.dispose();
  }

  /**
   * @inheritdoc
   */
  public createNewSession(
    debugSession: TSessionImpl,
    config: IPseudoAttachConfiguration,
    transport: IDapTransport,
  ): Session<TSessionImpl> {
    let session: Session<TSessionImpl>;

    const pendingTargetId = config.__pendingTargetId;
    if (pendingTargetId) {
      const pending = this._pendingTarget.get(pendingTargetId);
      if (!pending) {
        throw new Error(`Cannot find target ${pendingTargetId}`);
      }

      const { target, parent } = pending;
      session = new Session<TSessionImpl>(
        debugSession,
        transport,
        parent.logger,
        parent.sessionStates,
      );

      this._pendingTarget.delete(pendingTargetId);
      session.debugSession.name = target.name();
      session.listenToTarget(target);
      const callbacks = this._sessionForTargetCallbacks.get(target);
      this._sessionForTargetCallbacks.delete(target);
      callbacks?.fulfill?.(session);
    } else {
      const root = new RootSession(
        debugSession,
        transport,