Class WatchDog

src/targets/node/watchdogSpawn.ts:78–230

}

export class WatchDog implements IDisposable {
  private readonly onEndEmitter = new EventEmitter<IStopMetadata>();
  private readonly cts = new CancellationTokenSource();
  private target?: WebSocketTransport;
  private gracefulExit = false;
  private targetAlive = false;
  private readonly targetInfo: WatchdogTarget = {
    targetId: this.info.ownId ?? createTargetId(),
    processId: Number(this.info.pid) || 0,
    type: this.info.waitForDebugger ? 'waitingForDebugger' : '',
    title: this.info.scriptName,
    url: 'file://' + this.info.scriptName,
    openerId: this.info.openerId,
    attached: true,
    canAccessOpener: false,
    processInspectorPort: Number(new URL(this.info.inspectorURL).port),
  };

  /**
   * Gets whether the attached process is still running.
   */
  public get isTargetAlive() {
    return this.targetAlive;
  }

  /**
   * Event that fires when the watchdog stops.
   */
  public readonly onEnd = this.onEndEmitter.event;

  /**
   * Creates a watchdog and returns a promise that resolves once it's attached
   * to the server.
   */
  public static async attach(info: IWatchdogInfo) {
    const pipe: net.Socket = await new Promise((resolve, reject) => {
      const cnx: net.Socket = net.createConnection(info.ipcAddress, () => resolve(cnx));
      cnx.on('error', reject);
    });

    const server = new RawPipeTransport(Logger.null, pipe);
    return new WatchDog(info, server);
  }

  constructor(private readonly info: IWatchdogInfo, private readonly server: ITransport) {
    this.listenToServer();
  }

  /**
   * Attaches listeners to server messages to start passing them to the target.
   * Should be called once when the watchdog is created.
   */
  private listenToServer() {
    const { server, targetInfo } = this;
    server.send(JSON.stringify({ method: 'Target.targetCreated', params: { targetInfo } }));
    server.onMessage(async ([data]) => {
      // Fast-path to check if we might need to parse it:
      if (