@d-es-ign/stryker-js-core 9.6.0

package/src/child-proxy/child-process-proxy.ts

@@ -0,0 +1,353 @@
+import childProcess from 'child_process';
+import os from 'os';
+import { fileURLToPath, URL } from 'url';
+
+import { FileDescriptions, StrykerOptions } from '@stryker-mutator/api/core';
+import {
+  isErrnoException,
+  Task,
+  ExpirableTask,
+  StrykerError,
+} from '@stryker-mutator/util';
+import { Disposable, InjectableClass, InjectionToken } from 'typed-inject';
+
+import { LoggingServerAddress } from '../logging/index.js';
+import { objectUtils } from '../utils/object-utils.js';
+import { StringBuilder } from '../utils/string-builder.js';
+import { deserialize, padLeft, serialize } from '../utils/string-utils.js';
+
+import { ChildProcessCrashedError } from './child-process-crashed-error.js';
+import {
+  InitMessage,
+  ParentMessage,
+  ParentMessageKind,
+  WorkerMessage,
+  WorkerMessageKind,
+} from './message-protocol.js';
+import { OutOfMemoryError } from './out-of-memory-error.js';
+import { ChildProcessContext } from './child-process-proxy-worker.js';
+import { IdGenerator } from './id-generator.js';
+import { Logger, LoggerFactoryMethod } from '@stryker-mutator/api/logging';
+
+type Func<TS extends any[], R> = (...args: TS) => R;
+
+type PromisifiedFunc<TS extends any[], R> = (...args: TS) => Promise<R>;
+
+export type Promisified<T> = {
+  [K in keyof T]: T[K] extends PromisifiedFunc<any, any>
+    ? T[K]
+    : T[K] extends Func<infer TS, infer R>
+      ? PromisifiedFunc<TS, R>
+      : () => Promise<T[K]>;
+};
+
+const BROKEN_PIPE_ERROR_CODE = 'EPIPE';
+const IPC_CHANNEL_CLOSED_ERROR_CODE = 'ERR_IPC_CHANNEL_CLOSED';
+const TIMEOUT_FOR_DISPOSE = 2000;
+
+export class ChildProcessProxy<T> implements Disposable {
+  public readonly proxy: Promisified<T>;
+
+  private readonly worker: childProcess.ChildProcess;
+  private readonly initTask: Task;
+  private disposeTask: ExpirableTask | undefined;
+  private fatalError: StrykerError | undefined;
+  private readonly workerTasks = new Map<number, Task>();
+  private workerTaskCounter = 0;
+  private readonly log;
+  private readonly stdoutBuilder = new StringBuilder();
+  private readonly stderrBuilder = new StringBuilder();
+  private isDisposed = false;
+  private readonly initMessage: InitMessage;
+
+  private constructor(
+    modulePath: string,
+    namedExport: string,
+    loggingServerAddress: LoggingServerAddress,
+    options: StrykerOptions,
+    fileDescriptions: FileDescriptions,
+    pluginModulePaths: readonly string[],
+    workingDirectory: string,
+    logger: Logger,
+    execArgv: string[],
+    idGenerator: IdGenerator,
+  ) {
+    const workerId = idGenerator.next().toString();
+    this.worker = childProcess.fork(
+      fileURLToPath(
+        new URL('./child-process-proxy-worker.js', import.meta.url),
+      ),
+      {
+        silent: true,
+        execArgv,
+        env: { STRYKER_MUTATOR_WORKER: workerId, ...process.env },
+      },
+    );
+    this.initTask = new Task();
+    this.log = logger;
+    this.log.debug(
+      'Started %s in worker process %s with pid %s %s',
+      namedExport,
+      workerId,
+      this.worker.pid,
+      execArgv.length ? ` (using args ${execArgv.join(' ')})` : '',
+    );
+    // Listen to `close`, not `exit`, see https://github.com/stryker-mutator/stryker-js/issues/1634
+    this.worker.on('close', this.handleUnexpectedExit);
+    this.worker.on('error', this.handleError);
+
+    this.initMessage = {
+      kind: WorkerMessageKind.Init,
+      loggingServerAddress,
+      options,
+      fileDescriptions,
+      pluginModulePaths,
+      namedExport: namedExport,
+      modulePath: modulePath,
+      workingDirectory,
+    };
+    this.listenForMessages();
+    this.listenToStdoutAndStderr();
+
+    this.proxy = this.initProxy();
+  }
+
+  /**
+   * @description Creates a proxy where each function of the object created using the constructorFunction arg is ran inside of a child process
+   */
+  public static create<
+    R,
+    Tokens extends Array<InjectionToken<ChildProcessContext>>,
+  >(
+    modulePath: string,
+    loggingServerAddress: LoggingServerAddress,
+    options: StrykerOptions,
+    fileDescriptions: FileDescriptions,
+    pluginModulePaths: readonly string[],
+    workingDirectory: string,
+    injectableClass: InjectableClass<ChildProcessContext, R, Tokens>,
+    execArgv: string[],
+    getLogger: LoggerFactoryMethod,
+    idGenerator: IdGenerator,
+  ): ChildProcessProxy<R> {
+    return new ChildProcessProxy(
+      modulePath,
+      injectableClass.name,
+      loggingServerAddress,
+      options,
+      fileDescriptions,
+      pluginModulePaths,
+      workingDirectory,
+      getLogger(ChildProcessProxy.name),
+      execArgv,
+      idGenerator,
+    );
+  }
+
+  private send(message: WorkerMessage) {
+    this.worker.send(serialize(message));
+  }
+
+  private initProxy(): Promisified<T> {
+    // This proxy is a genuine javascript `Proxy` class
+    // More info: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy
+    return new Proxy({} as Promisified<T>, {
+      get: (_, propertyKey) => {
+        if (typeof propertyKey === 'string') {
+          return this.forward(propertyKey);
+        } else {
+          return undefined;
+        }
+      },
+    });
+  }
+
+  private forward(methodName: string) {
+    return async (...args: any[]) => {
+      if (this.fatalError) {
+        return Promise.reject(this.fatalError);
+      } else {
+        const workerTask = new Task<void>();
+        const correlationId = this.workerTaskCounter++;
+        this.workerTasks.set(correlationId, workerTask);
+        this.initTask.promise
+          .then(() => {
+            this.send({
+              args,
+              correlationId,
+              kind: WorkerMessageKind.Call,
+              methodName,
+            });
+          })
+          .catch((error: unknown) => {
+            workerTask.reject(error);
+          });
+        return workerTask.promise;
+      }
+    };
+  }
+
+  private listenForMessages() {
+    this.worker.on('message', (serializedMessage: string) => {
+      const message = deserialize<ParentMessage>(serializedMessage);
+      switch (message.kind) {
+        case ParentMessageKind.Ready:
+          // Workaround, because of a race condition more prominent in native ESM node modules
+          // Fix has landed in v17.4.0 🎉, but we need this workaround for now.
+          // See https://github.com/nodejs/node/issues/41134
+          this.send(this.initMessage);
+          break;
+        case ParentMessageKind.Initialized:
+          this.initTask.resolve(undefined);
+          break;
+        case ParentMessageKind.CallResult:
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+          this.workerTasks.get(message.correlationId)!.resolve(message.result);
+          this.workerTasks.delete(message.correlationId);
+          break;
+        case ParentMessageKind.CallRejection:
+          this.workerTasks
+            .get(message.correlationId)!
+            .reject(new StrykerError(message.error));
+          this.workerTasks.delete(message.correlationId);
+          break;
+        case ParentMessageKind.DisposeCompleted:
+          if (this.disposeTask) {
+            this.disposeTask.resolve(undefined);
+          }
+          break;
+        case ParentMessageKind.InitError:
+          this.fatalError = new StrykerError(message.error);
+          this.reportError(this.fatalError);
+          void this.dispose();
+          break;
+        default:
+          this.logUnidentifiedMessage(message);
+          break;
+      }
+    });
+  }
+
+  private listenToStdoutAndStderr() {
+    const handleData = (builder: StringBuilder) => (data: Buffer | string) => {
+      const output = data.toString();
+      builder.append(output);
+      this.log.trace(output);
+    };
+
+    if (this.worker.stdout) {
+      this.worker.stdout.on('data', handleData(this.stdoutBuilder));
+    }
+
+    if (this.worker.stderr) {
+      this.worker.stderr.on('data', handleData(this.stderrBuilder));
+    }
+  }
+
+  public get stdout(): string {
+    return this.stdoutBuilder.toString();
+  }
+
+  public get stderr(): string {
+    return this.stderrBuilder.toString();
+  }
+
+  private reportError(error: Error) {
+    const onGoingWorkerTasks = [...this.workerTasks.values()].filter(
+      (task) => !task.isCompleted,
+    );
+    if (!this.initTask.isCompleted) {
+      onGoingWorkerTasks.push(this.initTask);
+    }
+    if (onGoingWorkerTasks.length) {
+      onGoingWorkerTasks.forEach((task) => task.reject(error));
+    }
+  }
+
+  private readonly handleUnexpectedExit = (code: number, signal: string) => {
+    this.isDisposed = true;
+    const output = StringBuilder.concat(this.stderrBuilder, this.stdoutBuilder);
+    if (processOutOfMemory()) {
+      const oom = new OutOfMemoryError(this.worker.pid, code);
+      this.fatalError = oom;
+      this.log.warn(
+        `Child process [pid ${oom.pid}] ran out of memory. Stdout and stderr are logged on debug level.`,
+      );
+      this.log.debug(stdoutAndStderr());
+    } else {
+      this.fatalError = new ChildProcessCrashedError(
+        this.worker.pid,
+        `Child process [pid ${this.worker.pid}] exited unexpectedly with exit code ${code} (${signal || 'without signal'}). ${stdoutAndStderr()}`,
+        code,
+        signal,
+      );
+      this.log.warn(this.fatalError.message, this.fatalError);
+    }
+
+    this.reportError(this.fatalError);
+
+    function processOutOfMemory() {
+      return (
+        output.includes('JavaScript heap out of memory') ||
+        output.includes('FatalProcessOutOfMemory')
+      );
+    }
+
+    function stdoutAndStderr() {
+      if (output.length) {
+        return `Last part of stdout and stderr was:${os.EOL}${padLeft(output)}`;
+      } else {
+        return 'Stdout and stderr were empty.';
+      }
+    }
+  };
+
+  private readonly handleError = (error: Error) => {
+    if (this.innerProcessIsCrashed(error)) {
+      this.log.warn(
+        `Child process [pid ${this.worker.pid}] has crashed. See other warning messages for more info.`,
+        error,
+      );
+      this.reportError(
+        new ChildProcessCrashedError(
+          this.worker.pid,
+          `Child process [pid ${this.worker.pid}] has crashed`,
+          undefined,
+          undefined,
+          error,
+        ),
+      );
+    } else {
+      this.reportError(error);
+    }
+  };
+
+  private innerProcessIsCrashed(error: Error) {
+    return (
+      isErrnoException(error) &&
+      (error.code === BROKEN_PIPE_ERROR_CODE ||
+        error.code === IPC_CHANNEL_CLOSED_ERROR_CODE)
+    );
+  }
+
+  public async dispose(): Promise<void> {
+    if (!this.isDisposed) {
+      this.worker.removeListener('close', this.handleUnexpectedExit);
+      this.isDisposed = true;
+      this.log.debug('Disposing of worker process %s', this.worker.pid);
+      this.disposeTask = new ExpirableTask(TIMEOUT_FOR_DISPOSE);
+      this.send({ kind: WorkerMessageKind.Dispose });
+      try {
+        await this.disposeTask.promise;
+      } finally {
+        this.log.debug('Kill %s', this.worker.pid);
+        await objectUtils.kill(this.worker.pid);
+      }
+    }
+  }
+
+  private logUnidentifiedMessage(message: never) {
+    // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+    this.log.error(`Received unidentified message ${message}`);
+  }
+}

package/src/child-proxy/id-generator.ts

@@ -0,0 +1,6 @@
+export class IdGenerator {
+  private id = 0;
+  public next(): number {
+    return this.id++;
+  }
+}

package/src/child-proxy/message-protocol.ts

@@ -0,0 +1,87 @@
+import { FileDescriptions, StrykerOptions } from '@stryker-mutator/api/core';
+
+import type { LoggingServerAddress } from '../logging/index.js';
+
+export enum WorkerMessageKind {
+  Init,
+  Call,
+  Dispose,
+}
+
+export enum ParentMessageKind {
+  /**
+   * Indicates that the child process is spawned and ready to receive messages
+   */
+  Ready,
+  /**
+   * Indicates that initialization is done
+   */
+  Initialized,
+  /**
+   * Indicates an error happened during initialization
+   */
+  InitError,
+  /**
+   * Indicates that a 'Call' was successful
+   */
+  CallResult,
+  /**
+   * Indicates that a 'Call' was rejected
+   */
+  CallRejection,
+  /**
+   * Indicates that a 'Dispose' was completed
+   */
+  DisposeCompleted,
+}
+
+export type WorkerMessage = CallMessage | DisposeMessage | InitMessage;
+export type ParentMessage =
+  | InitRejectionResult
+  | RejectionResult
+  | WorkResult
+  | {
+      kind:
+        | ParentMessageKind.DisposeCompleted
+        | ParentMessageKind.Initialized
+        | ParentMessageKind.Ready;
+    };
+
+export interface InitMessage {
+  kind: WorkerMessageKind.Init;
+  loggingServerAddress: LoggingServerAddress;
+  options: StrykerOptions;
+  fileDescriptions: FileDescriptions;
+  pluginModulePaths: readonly string[];
+  workingDirectory: string;
+  namedExport: string;
+  modulePath: string;
+}
+
+export interface DisposeMessage {
+  kind: WorkerMessageKind.Dispose;
+}
+
+export interface WorkResult {
+  kind: ParentMessageKind.CallResult;
+  correlationId: number;
+  result: any;
+}
+
+export interface RejectionResult {
+  kind: ParentMessageKind.CallRejection;
+  correlationId: number;
+  error: string;
+}
+
+export interface InitRejectionResult {
+  kind: ParentMessageKind.InitError;
+  error: string;
+}
+
+export interface CallMessage {
+  correlationId: number;
+  kind: WorkerMessageKind.Call;
+  args: any[];
+  methodName: string;
+}

package/src/child-proxy/out-of-memory-error.ts

@@ -0,0 +1,11 @@
+import { ChildProcessCrashedError } from './child-process-crashed-error.js';
+
+export class OutOfMemoryError extends ChildProcessCrashedError {
+  constructor(pid: number | undefined, exitCode: number) {
+    super(pid, `Process ${pid} ran out of memory`, exitCode);
+    this.message = 'Process ';
+    Error.captureStackTrace(this, OutOfMemoryError);
+    // TS recommendation: https://github.com/Microsoft/TypeScript/wiki/Breaking-Changes#extending-built-ins-like-error-array-and-map-may-no-longer-work
+    Object.setPrototypeOf(this, OutOfMemoryError.prototype);
+  }
+}

package/src/concurrent/concurrency-token-provider.ts

@@ -0,0 +1,106 @@
+import os from 'os';
+
+import { StrykerOptions } from '@stryker-mutator/api/core';
+import { ReplaySubject, Observable, range } from 'rxjs';
+import { Disposable, tokens } from 'typed-inject';
+import { commonTokens } from '@stryker-mutator/api/plugin';
+import { Logger } from '@stryker-mutator/api/logging';
+
+export class ConcurrencyTokenProvider implements Disposable {
+  private readonly concurrencyCheckers: number;
+  private readonly concurrencyTestRunners: number;
+  private readonly testRunnerTokenSubject = new ReplaySubject<number>();
+
+  public get testRunnerToken$(): Observable<number> {
+    return this.testRunnerTokenSubject;
+  }
+  public readonly checkerToken$: Observable<number>;
+  public static readonly inject = tokens(
+    commonTokens.options,
+    commonTokens.logger,
+  );
+
+  constructor(
+    options: Pick<StrykerOptions, 'checkers' | 'concurrency'>,
+    private readonly log: Logger,
+  ) {
+    const availableParallelism = os.availableParallelism();
+    const concurrency = this.computeConcurrency(
+      options.concurrency,
+      availableParallelism,
+    );
+    if (options.checkers.length > 0) {
+      this.concurrencyCheckers = Math.max(Math.ceil(concurrency / 2), 1);
+      this.checkerToken$ = range(this.concurrencyCheckers);
+      this.concurrencyTestRunners = Math.max(Math.floor(concurrency / 2), 1);
+      log.info(
+        'Creating %s checker process(es) and %s test runner process(es).',
+        this.concurrencyCheckers,
+        this.concurrencyTestRunners,
+      );
+    } else {
+      this.concurrencyCheckers = 0;
+      this.checkerToken$ = range(1); // at least one checker, the `CheckerFacade` will not create worker process.
+      this.concurrencyTestRunners = concurrency;
+      log.info(
+        'Creating %s test runner process(es).',
+        this.concurrencyTestRunners,
+      );
+    }
+    Array.from({ length: this.concurrencyTestRunners }).forEach(() =>
+      this.testRunnerTokenSubject.next(this.tick()),
+    );
+  }
+
+  private computeConcurrency(
+    concurrencyOption: number | string | undefined,
+    availableParallelism: number,
+  ): number {
+    if (typeof concurrencyOption === 'string') {
+      const percentageMatch = concurrencyOption.match(/^(100|[1-9]?[0-9])%$/);
+      if (percentageMatch) {
+        const percentage = parseInt(percentageMatch[1], 10);
+        const computed = Math.max(
+          1,
+          Math.round((availableParallelism * percentage) / 100),
+        );
+        this.log.debug(
+          'Computed concurrency %s from "%s" based on %s available parallelism.',
+          computed,
+          concurrencyOption,
+          availableParallelism,
+        );
+        return computed;
+      }
+    }
+    if (typeof concurrencyOption === 'number') {
+      return concurrencyOption;
+    }
+    // Default: n-1 for n > 4, else n
+    return availableParallelism > 4
+      ? availableParallelism - 1
+      : availableParallelism;
+  }
+
+  public freeCheckers(): void {
+    if (this.concurrencyCheckers > 0) {
+      this.log.debug(
+        'Checking done, creating %s additional test runner process(es)',
+        this.concurrencyCheckers,
+      );
+      for (let i = 0; i < this.concurrencyCheckers; i++) {
+        this.testRunnerTokenSubject.next(this.tick());
+      }
+      this.testRunnerTokenSubject.complete();
+    }
+  }
+
+  private count = 0;
+  private tick() {
+    return this.count++;
+  }
+
+  public dispose(): void {
+    this.testRunnerTokenSubject.complete();
+  }
+}

package/src/concurrent/index.ts

@@ -0,0 +1,3 @@
+export * from './pool.js';
+export * from './concurrency-token-provider.js';
+export * from './resource-decorator.js';