child_process#ChildProcessWithoutNullStreams TypeScript Examples

killBackgroundProcess = (processToKill: ChildProcessWithoutNullStreams) => {
  // We need to gracefully kill the Airnode docker otherwise it remains running on background
  //
  // The following reliably kills the Airnode process for unix, but it throws for windows.
  // See: https://azimi.me/2014/12/31/kill-child_process-node-js.html
  try {
    process.kill(-processToKill.pid!);
  } catch (e) {
    // See: https://stackoverflow.com/a/28163919
    spawn('taskkill', ['/pid', processToKill.pid!.toString(), '/f', '/t']);
  }
}

waitForExitOrError = (
  proc: ChildProcessWithoutNullStreams,
  callback: (
    err: Error | null | undefined,
    data?: { code: number | null; signal: NodeJS.Signals | null },
  ) => void,
) => {
  proc.once('error', err => {
    callback(err);
  });

  proc.once('exit', (code, signal) => {
    callback(undefined, { code, signal });
  });
}

bufferOutputs = (
  proc: ChildProcessWithoutNullStreams,
  callback: (
    err: Error | undefined,
    data?: { stderr?: Buffer; stdout?: Buffer },
  ) => void,
) => {
  blStreams(
    {
      stderr: proc.stderr,
      stdout: proc.stdout,
    },
    callback,
  );
}

/**
   * What to do when the condition is fulfilled
   * @param callback the function to execute.
   *  It receives the process that fulfilled the condition
   *  (or the process owning the stream that fulfilled the condition).
   *  in parameter
   * @returns a promise, extended with an 'until' function.
   */
  private do(callback: DoCallback = () => {}) {
    return (resolve: () => void) => {
      const eventListener = this.addTerminalListener(
        this.action.condition,
        async (process: ChildProcessWithoutNullStreams) => {
          await callback(process);
        },
        resolve
      );

      this.exitFunction = () => {
        if (eventListener) {
          this.removeListener(eventListener);
        }
        resolve();
      };
    };
  }

export function start_sapio_oracle(): ChildProcessWithoutNullStreams | null {
    if (g_emulator !== null) return g_emulator;
    const oracle = preferences.data.local_oracle;
    if (oracle !== 'Disabled' && 'Enabled' in oracle) {
        const binary = preferences.data.sapio_cli.sapio_cli;
        const seed = oracle.Enabled.file;
        const iface = oracle.Enabled.interface;
        const emulator = spawnSync(binary, ['emulator', 'server', seed, iface]);
        if (emulator) {
            let quit = '';
            emulator.stderr.on('data', (data) => {
                quit += `${data}`;
            });
            emulator.on('exit', (code) => {
                if (quit !== '') {
                    console.error('Emulator Oracle Error', quit);
                    sys.exit();
                }
            });
            emulator.stdout.on('data', (data) => {
                g_emulator_log += `${data}`;
                console.log(`stdout: ${data}`);
            });
        }
        g_emulator = emulator;
        return g_emulator;
    }
    return null;
}

/**
   * Bound the `while.do` with an exit condition.
   * If not specified (either with `until` or `once`) the hook will run till the process die.
   * **It is highly recommended to specify one to ensure proper resource cleaning**
   * @param untilCondition {Condition} a condition on which the hook chain (i.e. `where.do.until`) will unhook itself from the terminal.
   * @returns {Promise} an awaitable promise that will resolve when the `untilCondition` is satisfied.
   */
  public until(untilCondition: Condition): Promise<void> {
    let eventListener: EventListenerObject | undefined;
    return new Promise<void>((resolve) => {
      eventListener = this.addTerminalListener(
        untilCondition,
        (_process: ChildProcessWithoutNullStreams, resolve: () => void) => {
          this.exitFunction!();
          resolve();
        },
        resolve
      );
    }).then(() => {
      if (eventListener) {
        this.removeListener(eventListener);
      }
    });
  }

export function startSMServer(
  cwd: string,
  port: string,
  callback: (url: string) => void
) {
  const smServer: ChildProcessWithoutNullStreams = spawn(
    "node",
    ["../../server/src/index.js"],
    {
      cwd: __dirname,
      env: {
        ...process.env,
        CWD: cwd,
        PORT: port,
      },
    }
  );

  smServer.stdout.on("data", function (data: Buffer) {
    const lns = data.toString().split("Server running");
    if (lns.length === 2) {
      callback(lns[1].replace(/\\n/, "").trim());
    } else {
      console.log(data.toString());
    }
  });

  smServer.stderr.on("data", function (data: Buffer) {
    console.log("[slice-machine] " + data.toString());
  });
}

export function answerPrompt(answer: string) {
  return (proc: ChildProcessWithoutNullStreams) =>
    new Promise<void>((resolve) => {
      if (!proc.stdin.write(answer)) {
        proc.stdin.once('drain', () => resolve());
      } else {
        process.nextTick(() => resolve());
      }
    });
}

public spawn(
    command: string,
    args?: ReadonlyArray<string>,
    options?: SpawnOptionsWithoutStdio
  ): ChildProcessWithoutNullStreams {
    const process = nativeSpawn(command, args, {
      detached: true,
      ...options,
    });
    process.on('exit', this.onExit(process));
    this.processes.add(process);
    return process;
  }

spawnApp = (name: string, command: string, args: string[]): RunningApp => {
  const logger = log4js.getLogger(name);
  logger.debug(`spawning app`, { name, command, args });

  let proc: ChildProcessWithoutNullStreams | undefined = undefined;
  try {
    proc = spawn(command, args);

    proc.stdout.on("data", (data) => {
      logger.debug(`stdout: ${data}`);
    });

    proc.stderr.on("data", (data) => {
      logger.error(`stderr: ${data}`);
    });

    proc.on("close", (code) => {
      logger.debug(`child process exited with code ${code}`);
    });
  } catch (e) {
    logger.error(`spawn error`, e);
  }

  return {
    send: (data: any) => {
      logger.warn(`cannot send data to a spawned app, must be forked.`);
    },
    stop: () => {
      logger.debug(`stopping..`);
      if (proc) kill(proc.pid);
    },
  };
}

private childProcess: ChildProcessWithoutNullStreams;

processes : {[key: number]: ChildProcessWithoutNullStreams} = {}

private readonly _proc: ChildProcessWithoutNullStreams;

spawnWithWorkingDirectory = (
  command: string,
  args: readonly string[],
  workingDirectory: string,
): ChildProcessWithoutNullStreams =>
  ChildProcess.spawn(command, args, {
    cwd: workingDirectory,
  })

child: ChildProcessWithoutNullStreams | null

p: { [key: string]: ChildProcessWithoutNullStreams } = {}

private readonly process: ChildProcessWithoutNullStreams;

g_emulator: null | ChildProcessWithoutNullStreams = null

private _process: ChildProcessWithoutNullStreams | undefined;

childProc: ChildProcessWithoutNullStreams;

public constructor(public process: ChildProcessWithoutNullStreams) {
    this.actions = new Array<Action>();
  }

private addTerminalListener(
    condition: Condition,
    callback: (
      process: ChildProcessWithoutNullStreams,
      resolve: () => void
    ) => void,
    resolve: () => void
  ) {
    const target: Readable | ChildProcessWithoutNullStreams = this.getTarget();

    let onParams: [string, (data: Buffer) => void] | undefined;
    if (isConditionRegExp(condition)) {
      onParams = [
        'data',
        (data: Buffer) => {
          if (condition.test(stripAnsi(data.toString()).replace(/\n/g, ''))) {
            callback(this.action.process, resolve);
          }
        },
      ];
    }

    if (isConditionString(condition)) {
      onParams = [condition, () => callback(this.action.process, resolve)];
    }

    if (isConditionPromise(condition)) {
      condition.then(() => callback(this.action.process, resolve));
      return;
    }

    if (onParams) {
      target.on(...onParams);
      return {target, event: onParams[0], listener: onParams[1]};
    }

    throw new Error(
      `Terminal Action malformed:\n${JSON.stringify(this.action)}`
    );
  }

private getTarget(): Readable | ChildProcessWithoutNullStreams {
    return this.action.target === 'process'
      ? this.action.process
      : this.action.process[this.action.target];
  }

public constructor(public process: ChildProcessWithoutNullStreams) {}

private onExit = (process: ChildProcessWithoutNullStreams) => () => {
    this.processes.delete(process);
  };

private processes: Set<ChildProcessWithoutNullStreams>;

public constructor() {
    this.processes = new Set<ChildProcessWithoutNullStreams>();
  }

#child: ChildProcessWithoutNullStreams;

#child: ChildProcessWithoutNullStreams = null;