feat(mutants): Prevent memory leak when transpiling mutants

packages/stryker-api/package.json

@@ -34,6 +34,6 @@
 	},
 	"devDependencies": {
 		"surrial": "~0.1.1",
-		"typed-inject": "^0.2.0"
+		"typed-inject": "^0.2.1"
 	}
 }

packages/stryker-api/plugin.ts

@@ -7,3 +7,4 @@ export * from 'typed-inject/src/api/Injector';
 export * from 'typed-inject/src/api/InjectionToken';
 export * from 'typed-inject/src/api/CorrespondingType';
 export * from 'typed-inject/src/api/Scope';
+export * from 'typed-inject/src/api/Disposable';

packages/stryker-test-helpers/package.json

@@ -19,6 +19,6 @@
   "license": "ISC",
   "devDependencies": {
     "stryker-api": "^0.24.0",
-    "typed-inject": "^0.2.0"
+    "typed-inject": "^0.2.1"
   }
 }

packages/stryker-test-helpers/src/factory.ts

@@ -149,12 +149,13 @@ export function matchedMutant(numberOfTests: number, mutantId = numberOfTests.to
 
 export function injector(): sinon.SinonStubbedInstance<Injector> {
   const injectorMock: sinon.SinonStubbedInstance<Injector> = {
+    dispose: sinon.stub(),
     injectClass: sinon.stub(),
     injectFunction: sinon.stub(),
     provideClass: sinon.stub(),
     provideFactory: sinon.stub(),
     provideValue: sinon.stub(),
-    resolve: sinon.stub()
+    resolve: sinon.stub(),
   };
   injectorMock.provideClass.returnsThis();
   injectorMock.provideFactory.returnsThis();

packages/stryker/package.json

@@ -72,7 +72,7 @@
     "surrial": "^0.2.0",
     "tree-kill": "~1.2.0",
     "tslib": "~1.9.3",
-    "typed-inject": "^0.2.0",
+    "typed-inject": "^0.2.1",
     "typed-rest-client": "~1.1.2"
   },
   "devDependencies": {

packages/stryker/src/Sandbox.ts

@@ -22,13 +22,16 @@ export default class Sandbox {
   private readonly log = getLogger(Sandbox.name);
   private testRunner: Required<TestRunner>;
   private fileMap: FileMap;
-  private readonly files: File[];
   private readonly workingDirectory: string;
 
-  private constructor(private readonly options: StrykerOptions, private readonly index: number, files: ReadonlyArray<File>, private readonly testFramework: TestFramework | null, private readonly timeOverheadMS: number, private readonly loggingContext: LoggingClientContext) {
+  private constructor(
+    private readonly options: StrykerOptions,
+    private readonly index: number,
+    private readonly files: ReadonlyArray<File>,
+    private readonly testFramework: TestFramework | null,
+    private readonly timeOverheadMS: number, private readonly loggingContext: LoggingClientContext) {
     this.workingDirectory = TempFolder.instance().createRandomFolder('sandbox');
     this.log.debug('Creating a sandbox for files in %s', this.workingDirectory);
-    this.files = files.slice(); // Create a copy
   }
 
   private async initialize(): Promise<void> {

packages/stryker/src/SandboxPool.ts

@@ -1,6 +1,6 @@
 import * as os from 'os';
-import { Observable, range } from 'rxjs';
-import { flatMap } from 'rxjs/operators';
+import { range, Subject } from 'rxjs';
+import { flatMap, tap, filter } from 'rxjs/operators';
 import { File, StrykerOptions } from 'stryker-api/core';
 import { TestFramework } from 'stryker-api/test_framework';
 import Sandbox from './Sandbox';
@@ -9,23 +9,94 @@ import { tokens, commonTokens } from 'stryker-api/plugin';
 import { coreTokens } from './di';
 import { InitialTestRunResult } from './process/InitialTestExecutor';
 import { Logger } from 'stryker-api/logging';
+import TranspiledMutant from './TranspiledMutant';
+import { Task } from './utils/Task';
+import { RunResult, RunStatus } from 'stryker-api/test_runner';
+
+const MAX_CONCURRENT_INITIALIZING_SANDBOXES = 2;
 
 export class SandboxPool {
 
-  private readonly sandboxes: Promise<Sandbox>[] = [];
+  private readonly allSandboxes: Promise<Sandbox>[] = [];
   private readonly overheadTimeMS: number;
+  private readonly workerPool: Sandbox[] = [];
+  private readonly backlog: { mutant: TranspiledMutant, task: Task<RunResult> }[] = [];
+  private isDisposed = false;
+  private sandboxesStarted = false;
+  private persistentError: any = null;
 
-  public static inject = tokens(commonTokens.logger, commonTokens.options, coreTokens.testFramework, coreTokens.initialRunResult, coreTokens.loggingContext);
+  public static inject = tokens(
+    commonTokens.logger,
+    commonTokens.options,
+    coreTokens.testFramework,
+    coreTokens.initialRunResult,
+    coreTokens.transpiledFiles,
+    coreTokens.loggingContext);
   constructor(
     private readonly log: Logger,
     private readonly options: StrykerOptions,
     private readonly testFramework: TestFramework | null,
     initialRunResult: InitialTestRunResult,
+    private readonly initialFiles: ReadonlyArray<File>,
     private readonly loggingContext: LoggingClientContext) {
-      this.overheadTimeMS = initialRunResult.overheadTimeMS;
+    this.overheadTimeMS = initialRunResult.overheadTimeMS;
+  }
+
+  public run(mutant: TranspiledMutant): Promise<RunResult> {
+    this.startSandboxes();
+    const task = new Task<RunResult>();
+    this.backlog.push({ mutant, task });
+    this.doWork();
+    return task.promise;
+  }
+
+  private readonly doWork = (): void => {
+    const backlogItem = this.backlog.shift();
+    if (backlogItem) {
+      if (this.isDisposed) {
+        backlogItem.task.resolve({ status: RunStatus.Timeout, tests: [] });
+      } else if (this.persistentError) {
+        backlogItem.task.reject(this.persistentError);
+      } else {
+        const sandbox = this.workerPool.pop();
+        if (sandbox) {
+          sandbox.runMutant(backlogItem.mutant)
+            .then(backlogItem.task.resolve, backlogItem.task.reject)
+            .then(() => this.releaseSandbox(sandbox));
+        } else {
+          // False alarm
+          this.backlog.push(backlogItem);
+        }
+      }
+    }
+  }
+
+  private startSandboxes(): void {
+    if (!this.sandboxesStarted) {
+      this.sandboxesStarted = true;
+      const concurrency = this.determineConcurrency();
+
+      range(0, concurrency).pipe(
+        flatMap(n => this.registerSandbox(Sandbox.create(this.options, n, this.initialFiles, this.testFramework, this.overheadTimeMS, this.loggingContext)),
+          MAX_CONCURRENT_INITIALIZING_SANDBOXES)
+      ).subscribe({
+        error: error => {
+          this.persistentError = error;
+          this.doWork();
+        },
+        next: this.releaseSandbox
+      });
     }
+  }
 
-  public streamSandboxes(initialFiles: ReadonlyArray<File>): Observable<Sandbox> {
+  private readonly releaseSandbox = (sandbox: Sandbox) => {
+    this.workerPool.push(sandbox);
+    // Let's see if there is work to be done in the next tick
+    // (scheduling it next tick instead of immediately will prevent a stack overflow)
+    process.nextTick(this.doWork);
+  }
+
+  private determineConcurrency() {
     let numConcurrentRunners = os.cpus().length;
     if (this.options.transpilers.length) {
       // If transpilers are configured, one core is reserved for the compiler (for now)
@@ -40,18 +111,21 @@ export class SandboxPool {
       numConcurrentRunners = 1;
     }
     this.log.info(`Creating ${numConcurrentRunners} test runners (based on ${numConcurrentRunnersSource})`);
-
-    const sandboxes = range(0, numConcurrentRunners)
-      .pipe(flatMap(n => this.registerSandbox(Sandbox.create(this.options, n, initialFiles, this.testFramework, this.overheadTimeMS, this.loggingContext))));
-    return sandboxes;
+    return numConcurrentRunners;
   }
 
-  private registerSandbox(promisedSandbox: Promise<Sandbox>): Promise<Sandbox> {
-    this.sandboxes.push(promisedSandbox);
+  private readonly registerSandbox = async (promisedSandbox: Promise<Sandbox>): Promise<Sandbox> => {
+    if (this.isDisposed) {
+      await promisedSandbox.then(sandbox => sandbox.dispose());
+    } else {
+      this.allSandboxes.push(promisedSandbox);
+    }
     return promisedSandbox;
   }
 
-  public disposeAll() {
-    return Promise.all(this.sandboxes.map(promisedSandbox => promisedSandbox.then(sandbox => sandbox.dispose())));
+  public async disposeAll() {
+    this.isDisposed = true;
+    const sandboxes = await Promise.all(this.allSandboxes);
+    return Promise.all(sandboxes.map(sandbox => sandbox.dispose()));
   }
 }

packages/stryker/src/Stryker.ts

@@ -14,9 +14,10 @@ import { Injector } from 'typed-inject';
 import { TranspilerFacade } from './transpiler/TranspilerFacade';
 import { coreTokens, MainContext, PluginCreator, buildMainInjector } from './di';
 import { commonTokens, PluginKind } from 'stryker-api/plugin';
-import MutantTranspiler from './transpiler/MutantTranspiler';
+import { MutantTranspileScheduler } from './transpiler/MutantTranspileScheduler';
 import { SandboxPool } from './SandboxPool';
 import { Logger } from 'stryker-api/logging';
+import { transpilerFactory } from './transpiler';
 
 export default class Stryker {
 
@@ -65,9 +66,15 @@ export default class Stryker {
         .injectClass(InitialTestExecutor);
       const initialRunResult = await initialTestRunProcess.run();
       const mutator = inputFileInjector.injectClass(MutatorFacade);
-      const mutationTestProcessInjector = inputFileInjector
+      const transpilerProvider = inputFileInjector
         .provideValue(coreTokens.initialRunResult, initialRunResult)
-        .provideClass(coreTokens.mutantTranspiler, MutantTranspiler)
+        .provideValue(commonTokens.produceSourceMaps, false)
+        .provideFactory(coreTokens.transpiler, transpilerFactory);
+      const transpiler = transpilerProvider.resolve(coreTokens.transpiler);
+      const transpiledFiles = await transpiler.transpile(inputFiles.files);
+      const mutationTestProcessInjector = transpilerProvider
+        .provideValue(coreTokens.transpiledFiles, transpiledFiles)
+        .provideClass(coreTokens.mutantTranspileScheduler, MutantTranspileScheduler)
         .provideClass(coreTokens.sandboxPool, SandboxPool);
       const testableMutants = await mutationTestProcessInjector
         .injectClass(MutantTestMatcher)
@@ -88,20 +95,6 @@ export default class Stryker {
     return Promise.resolve([]);
   }
 
-  // private mutate(input: InputFileCollection, initialTestRunResult: InitialTestRunResult): TestableMutant[] {
-  //   const mutator = this.injector.injectClass(MutatorFacade);
-  //   const mutants = mutator.mutate(input.filesToMutate);
-  //   const mutantRunResultMatcher = new MutantTestMatcher(
-  //     mutants,
-  //     input.filesToMutate,
-  //     initialTestRunResult.runResult,
-  //     initialTestRunResult.sourceMapper,
-  //     initialTestRunResult.coverageMaps,
-  //     this.config,
-  //     this.reporter);
-  //   return mutantRunResultMatcher.matchWithMutants();
-  // }
-
   private wrapUpReporter(): Promise<void> {
     const maybePromise = this.reporter.wrapUp();
     if (isPromise(maybePromise)) {

packages/stryker/src/di/coreTokens.ts

@@ -4,12 +4,15 @@ export const configReadFromConfigFile = 'configReadFromConfigFile';
 export const configEditorApplier = 'configEditorApplier';
 export const inputFiles = 'inputFiles';
 export const initialRunResult = 'initialRunResult';
-export const mutantTranspiler = 'mutantTranspiler';
+export const transpiledFiles = 'transpiledFiles';
+export const mutantTranspileScheduler = 'mutantTranspileScheduler';
 export const sandboxPool = 'sandboxPool';
 export const testFramework = 'testFramework';
 export const timer = 'timer';
+export const timeOverheadMS = 'timeOverheadMS';
 export const loggingContext = 'loggingContext';
 export const transpiler = 'transpiler';
+export const sandboxIndex = 'sandboxIndex';
 export const reporter = 'reporter';
 export const pluginKind = 'pluginKind';
 export const pluginDescriptors = 'pluginDescriptors';