Class SessionManager

src/sessionManager.ts:123–288

}

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: ISessionLauncher<TSessionImpl>,
  ) {}

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

  /**
   * Gets whether the pending target ID exists.
   */
  public hasPendingTargetId(targetId: string) {
    return this._pendingTarget.has(targetId);
  }

  public createNewRootSession(
    debugSession: TSessionImpl,
    transport: IDapTransport | DapConnection,
  ) {
    const root = new RootSession(
      debugSession,
      transport,
      createTopLevelSessionContainer(this.globalContainer),
    );
    root.createBinder(this);
    this._sessions.set(debugSession.id, root);
    return root;
  }

  /**
   * @inheritdoc
   */
  public createNewChildSession(
    debugSession: TSessionImpl,
    pendingTargetId: string,
    transport: IDapTransport | DapConnection,
  ): Session<TSessionImpl> {
    const pending = this._pendingTarget.get(pendingTargetId);
    if (!pending) {
      throw new Error(`Cannot find target ${pendingTargetId}`);
    }