Skip to content

High performance self-hosted photo and video management solution.

3.4 KB
Raw Blame
import { Injectable } from '@nestjs/common';
import { SpawnOptionsWithoutStdio, fork, spawn } from 'node:child_process';
import { constants } from 'node:fs';
import { access } from 'node:fs/promises';
import { availableParallelism } from 'node:os';
import path from 'node:path';
import { Duplex } from 'node:stream';

@Injectable()
export class ProcessRepository {
  spawn = spawn;
  availableParallelism = availableParallelism;

  async isCommandAvailable(command: string): Promise<boolean> {
    const directories = (process.env.PATH ?? '').split(path.delimiter).filter(Boolean);
    const found = await Promise.all(
      directories.map((directory) =>
        access(path.join(directory, command), constants.X_OK)
          .then(() => true)
          .catch(() => false),
      ),
    );
    return found.includes(true);
  }

  spawnDuplexStream(command: string, args?: readonly string[], options?: SpawnOptionsWithoutStdio): Duplex {
    let isStdinClosed = false;
    let drainCallback: undefined | (() => void);

    const process = this.spawn(command, args, options);
    const duplex = new Duplex({
      // duplex -> stdin
      write(chunk, encoding, callback) {
        // drain the input if process dies
        if (isStdinClosed) {
          return callback();
        }

        // handle stream backpressure
        if (process.stdin.write(chunk, encoding)) {
          callback();
        } else {
          drainCallback = callback;
          process.stdin.once('drain', () => {
            drainCallback = undefined;
            callback();
          });
        }
      },

      read() {
        // no-op
      },

      final(callback) {
        if (isStdinClosed) {
          callback();
        } else {
          process.stdin.end(callback);
        }
      },

      destroy(error, callback) {
        if (process.exitCode === null && process.signalCode === null) {
          process.kill();
        }
        callback(error);
      },
    });

    // stdout -> duplex
    process.stdout.on('data', (chunk) => {
      // handle stream backpressure
      if (!duplex.push(chunk)) {
        process.stdout.pause();
      }
    });

    duplex.on('resume', () => process.stdout.resume());

    // end handling
    let isStdoutClosed = false;
    function close(error?: Error) {
      isStdinClosed = true;

      if (error) {
        duplex.destroy(error);
      } else if (isStdoutClosed && typeof process.exitCode === 'number') {
        duplex.push(null);
      }
    }

    process.stdout.on('close', () => {
      isStdoutClosed = true;
      close();
    });

    // error handling
    process.on('error', close);
    process.stdout.on('error', close);
    process.stdin.on('error', (error) => {
      if ((error as { code?: 'EPIPE' })?.code === 'EPIPE') {
        try {
          drainCallback!();
        } catch (error) {
          close(error as Error);
        }
      } else {
        close(error);
      }
    });

    let stderr = '';
    process.stderr.on('data', (chunk) => (stderr += chunk));

    process.on('exit', (code) => {
      console.info(`${command} exited (${code})`);

      if (code === 0) {
        close();
      } else {
        close(new Error(`${command} non-zero exit code (${code})\n${stderr}`));
      }
    });

    return Object.assign(duplex, { _process: process });
  }

  fork(...args: Parameters<typeof fork>): ReturnType<typeof fork> {
    return fork(...args);
  }
}