@atlaspack/core 2.13.2-canary.3657 → 2.13.2-canary.3658

package/lib/atlaspack-v3/AtlaspackV3.js

@@ -11,7 +11,7 @@ function _rust() {
   };
   return data;
 }
-var _WorkerPool = require("./WorkerPool");
+var _NapiWorkerPool = require("./NapiWorkerPool");
 function _diagnostic() {
   const data = _interopRequireDefault(require("@atlaspack/diagnostic"));
   _diagnostic = function () {
@@ -23,39 +23,26 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 class AtlaspackV3 {
   constructor({
     fs,
-    nodeWorkers,
     packageManager,
     threads,
     lmdb,
+    napiWorkerPool = new _NapiWorkerPool.NapiWorkerPool(),
     ...options
   }) {
     options.logLevel = options.logLevel || 'error';
     options.defaultTargetOptions = options.defaultTargetOptions || {};
     // $FlowFixMe "engines" are readonly
     options.defaultTargetOptions.engines = options.defaultTargetOptions.engines || {};
-    this._workerIds = [];
     this._internal = _rust().AtlaspackNapi.create({
       fs,
-      nodeWorkers,
       packageManager,
       threads,
-      options
+      options,
+      napiWorkerPool
     }, lmdb);
   }
   async buildAssetGraph() {
-    const workerIds = [];
-    let [graph, error] = await this._internal.buildAssetGraph({
-      registerWorker: tx_worker => {
-        // $FlowFixMe
-        const workerId = _WorkerPool.workerPool.registerWorker(tx_worker);
-        workerIds.push(workerId);
-      }
-    });
-
-    // In the integration tests we keep the workers alive so they don't need to
-    // be re-initialized for the next test
-
-    _WorkerPool.workerPool.shutdown();
+    let [graph, error] = await this._internal.buildAssetGraph();
     if (error !== null) {
       throw new (_diagnostic().default)({
         diagnostic: error

package/lib/atlaspack-v3/NapiWorkerPool.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NapiWorkerPool = void 0;
+function _worker_threads() {
+  const data = require("worker_threads");
+  _worker_threads = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _process() {
+  const data = _interopRequireDefault(require("process"));
+  _process = function () {
+    return data;
+  };
+  return data;
+}
+function _rust() {
+  const data = require("@atlaspack/rust");
+  _rust = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const WORKER_PATH = _path().default.join(__dirname, 'worker', 'index.js');
+const ATLASPACK_NAPI_WORKERS = _process().default.env.ATLASPACK_NAPI_WORKERS && parseInt(_process().default.env.ATLASPACK_NAPI_WORKERS, 10);
+class NapiWorkerPool {
+  #workers;
+  #napiWorkers;
+  #workerCount;
+  constructor({
+    workerCount
+  } = {
+    workerCount: undefined
+  }) {
+    this.#workerCount = workerCount ?? ATLASPACK_NAPI_WORKERS ?? (0, _rust().getAvailableThreads)();
+    if (!this.#workerCount) {
+      // TODO use main thread if workerCount is 0
+    }
+    this.#workers = [];
+    this.#napiWorkers = [];
+    for (let i = 0; i < this.#workerCount; i++) {
+      let worker = new (_worker_threads().Worker)(WORKER_PATH);
+      this.#workers.push(worker);
+      this.#napiWorkers.push(new Promise(res => worker.once('message', res)));
+    }
+  }
+  workerCount() {
+    return this.#workerCount;
+  }
+  getWorkers() {
+    return Promise.all(this.#napiWorkers);
+  }
+  shutdown() {
+    for (const worker of this.#workers) {
+      worker.terminate();
+    }
+  }
+}
+exports.NapiWorkerPool = NapiWorkerPool;

package/lib/atlaspack-v3/index.js

@@ -15,5 +15,12 @@ Object.defineProperty(exports, "FileSystemV3", {
     return _fs.FileSystemV3;
   }
 });
+Object.defineProperty(exports, "NapiWorkerPool", {
+  enumerable: true,
+  get: function () {
+    return _NapiWorkerPool.NapiWorkerPool;
+  }
+});
 var _fs = require("./fs");
-var _AtlaspackV = require("./AtlaspackV3");
+var _AtlaspackV = require("./AtlaspackV3");
+var _NapiWorkerPool = require("./NapiWorkerPool");

package/lib/atlaspack-v3/worker/worker.js

@@ -272,30 +272,9 @@ class AtlaspackWorker {
     JSON.stringify((await mutableAsset.getMap()).toVLQ()) : ''];
   });
 }
+
+// Create napi worker and send it back to main thread
 exports.AtlaspackWorker = AtlaspackWorker;
 const worker = new AtlaspackWorker();
-_worker_threads().parentPort === null || _worker_threads().parentPort === void 0 || _worker_threads().parentPort.on('message', event => {
-  if (event.type === 'registerWorker') {
-    try {
-      napi().registerWorker(event.tx_worker, worker);
-    } catch (err) {
-      // eslint-disable-next-line no-console
-      console.error('Registering worker failed... This might mean atlaspack is getting shut-down before the worker registered', err);
-      _worker_threads().parentPort === null || _worker_threads().parentPort === void 0 || _worker_threads().parentPort.postMessage({
-        type: 'workerError',
-        error: err
-      });
-    }
-    _worker_threads().parentPort === null || _worker_threads().parentPort === void 0 || _worker_threads().parentPort.postMessage({
-      type: 'workerRegistered'
-    });
-  } else if (event.type === 'probeStatus') {
-    _worker_threads().parentPort.postMessage({
-      type: 'status',
-      status: 'ok'
-    });
-  }
-});
-_worker_threads().parentPort === null || _worker_threads().parentPort === void 0 || _worker_threads().parentPort.postMessage({
-  type: 'workerLoaded'
-});
+const napiWorker = napi().newNodejsWorker(worker);
+_worker_threads().parentPort === null || _worker_threads().parentPort === void 0 || _worker_threads().parentPort.postMessage(napiWorker);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.13.2-canary.3657+93732232c",
+  "version": "2.13.2-canary.3658+4812d0f74",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -20,21 +20,21 @@
     "check-ts": "tsc --noEmit index.d.ts"
   },
   "dependencies": {
-    "@atlaspack/build-cache": "2.13.2-canary.3657+93732232c",
-    "@atlaspack/cache": "2.13.2-canary.3657+93732232c",
-    "@atlaspack/diagnostic": "2.13.2-canary.3657+93732232c",
-    "@atlaspack/events": "2.13.2-canary.3657+93732232c",
-    "@atlaspack/feature-flags": "2.13.2-canary.3657+93732232c",
-    "@atlaspack/fs": "2.13.2-canary.3657+93732232c",
-    "@atlaspack/graph": "3.3.2-canary.3657+93732232c",
-    "@atlaspack/logger": "2.13.2-canary.3657+93732232c",
-    "@atlaspack/package-manager": "2.13.2-canary.3657+93732232c",
-    "@atlaspack/plugin": "2.13.2-canary.3657+93732232c",
-    "@atlaspack/profiler": "2.13.2-canary.3657+93732232c",
-    "@atlaspack/rust": "2.13.2-canary.3657+93732232c",
-    "@atlaspack/types": "2.13.2-canary.3657+93732232c",
-    "@atlaspack/utils": "2.13.2-canary.3657+93732232c",
-    "@atlaspack/workers": "2.13.2-canary.3657+93732232c",
+    "@atlaspack/build-cache": "2.13.2-canary.3658+4812d0f74",
+    "@atlaspack/cache": "2.13.2-canary.3658+4812d0f74",
+    "@atlaspack/diagnostic": "2.13.2-canary.3658+4812d0f74",
+    "@atlaspack/events": "2.13.2-canary.3658+4812d0f74",
+    "@atlaspack/feature-flags": "2.13.2-canary.3658+4812d0f74",
+    "@atlaspack/fs": "2.13.2-canary.3658+4812d0f74",
+    "@atlaspack/graph": "3.3.2-canary.3658+4812d0f74",
+    "@atlaspack/logger": "2.13.2-canary.3658+4812d0f74",
+    "@atlaspack/package-manager": "2.13.2-canary.3658+4812d0f74",
+    "@atlaspack/plugin": "2.13.2-canary.3658+4812d0f74",
+    "@atlaspack/profiler": "2.13.2-canary.3658+4812d0f74",
+    "@atlaspack/rust": "2.13.2-canary.3658+4812d0f74",
+    "@atlaspack/types": "2.13.2-canary.3658+4812d0f74",
+    "@atlaspack/utils": "2.13.2-canary.3658+4812d0f74",
+    "@atlaspack/workers": "2.13.2-canary.3658+4812d0f74",
     "@mischnic/json-sourcemap": "^0.1.0",
     "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
@@ -66,5 +66,5 @@
   "browser": {
     "./src/serializerCore.js": "./src/serializerCore.browser.js"
   },
-  "gitHead": "93732232c38c42c9357356bdfd8325cd0bc2536d"
+  "gitHead": "4812d0f7400af0f8416f1b7175ecb87700860a68"
 }

package/src/atlaspack-v3/AtlaspackV3.js

@@ -5,13 +5,13 @@ import {
   type Lmdb,
   type AtlaspackNapiOptions,
 } from '@atlaspack/rust';
-import {workerPool} from './WorkerPool';
+import {NapiWorkerPool} from './NapiWorkerPool';
 import ThrowableDiagnostic from '@atlaspack/diagnostic';
 import type {Event} from '@parcel/watcher';
+import type {NapiWorkerPool as INapiWorkerPool} from '@atlaspack/types';
 
 export type AtlaspackV3Options = {|
   fs?: AtlaspackNapiOptions['fs'],
-  nodeWorkers?: number,
   packageManager?: AtlaspackNapiOptions['packageManager'],
   threads?: number,
   /**
@@ -19,6 +19,7 @@ export type AtlaspackV3Options = {|
    */
   lmdb: Lmdb,
   featureFlags?: {[string]: string | boolean},
+  napiWorkerPool?: INapiWorkerPool,
   ...AtlaspackNapiOptions['options'],
 |};
 
@@ -28,10 +29,10 @@ export class AtlaspackV3 {
 
   constructor({
     fs,
-    nodeWorkers,
     packageManager,
     threads,
     lmdb,
+    napiWorkerPool = new NapiWorkerPool(),
     ...options
   }: AtlaspackV3Options) {
     options.logLevel = options.logLevel || 'error';
@@ -40,37 +41,20 @@ export class AtlaspackV3 {
     options.defaultTargetOptions.engines =
       options.defaultTargetOptions.engines || {};
 
-    this._workerIds = [];
     this._internal = AtlaspackNapi.create(
       {
         fs,
-        nodeWorkers,
         packageManager,
         threads,
         options,
+        napiWorkerPool,
       },
       lmdb,
     );
   }
 
   async buildAssetGraph(): Promise<any> {
-    const workerIds = [];
-
-    let [graph, error] = await this._internal.buildAssetGraph({
-      registerWorker: (tx_worker) => {
-        // $FlowFixMe
-        const workerId = workerPool.registerWorker(tx_worker);
-        workerIds.push(workerId);
-      },
-    });
-
-    // In the integration tests we keep the workers alive so they don't need to
-    // be re-initialized for the next test
-    if (process.env.ATLASPACK_BUILD_ENV === 'test') {
-      workerPool.releaseWorkers(workerIds);
-    } else {
-      workerPool.shutdown();
-    }
+    let [graph, error] = await this._internal.buildAssetGraph();
 
     if (error !== null) {
       throw new ThrowableDiagnostic({

package/src/atlaspack-v3/NapiWorkerPool.js

@@ -0,0 +1,53 @@
+// @flow
+import type {NapiWorkerPool as INapiWorkerPool} from '@atlaspack/types';
+import {Worker} from 'worker_threads';
+import path from 'path';
+import process from 'process';
+import type {Transferable} from '@atlaspack/rust';
+import {getAvailableThreads} from '@atlaspack/rust';
+
+const WORKER_PATH = path.join(__dirname, 'worker', 'index.js');
+const ATLASPACK_NAPI_WORKERS =
+  process.env.ATLASPACK_NAPI_WORKERS &&
+  parseInt(process.env.ATLASPACK_NAPI_WORKERS, 10);
+
+export type NapiWorkerPoolOptions = {|
+  workerCount?: number,
+|};
+
+export class NapiWorkerPool implements INapiWorkerPool {
+  #workers: Worker[];
+  #napiWorkers: Array<Promise<Transferable>>;
+  #workerCount: number;
+
+  constructor({workerCount}: NapiWorkerPoolOptions = {workerCount: undefined}) {
+    this.#workerCount =
+      workerCount ?? ATLASPACK_NAPI_WORKERS ?? getAvailableThreads();
+    if (!this.#workerCount) {
+      // TODO use main thread if workerCount is 0
+    }
+
+    this.#workers = [];
+    this.#napiWorkers = [];
+
+    for (let i = 0; i < this.#workerCount; i++) {
+      let worker = new Worker(WORKER_PATH);
+      this.#workers.push(worker);
+      this.#napiWorkers.push(new Promise((res) => worker.once('message', res)));
+    }
+  }
+
+  workerCount(): number {
+    return this.#workerCount;
+  }
+
+  getWorkers(): Promise<Array<Transferable>> {
+    return Promise.all(this.#napiWorkers);
+  }
+
+  shutdown(): void {
+    for (const worker of this.#workers) {
+      worker.terminate();
+    }
+  }
+}

package/src/atlaspack-v3/index.js

@@ -2,4 +2,6 @@
 
 export {FileSystemV3} from './fs';
 export {AtlaspackV3} from './AtlaspackV3';
+export {NapiWorkerPool} from './NapiWorkerPool';
 export type * from './AtlaspackV3';
+export type * from './NapiWorkerPool';

package/src/atlaspack-v3/worker/worker.js

@@ -299,28 +299,10 @@ export class AtlaspackWorker {
   );
 }
 
+// Create napi worker and send it back to main thread
 const worker = new AtlaspackWorker();
-parentPort?.on('message', (event) => {
-  if (event.type === 'registerWorker') {
-    try {
-      napi.registerWorker(event.tx_worker, worker);
-    } catch (err) {
-      // eslint-disable-next-line no-console
-      console.error(
-        'Registering worker failed... This might mean atlaspack is getting shut-down before the worker registered',
-        err,
-      );
-      parentPort?.postMessage({type: 'workerError', error: err});
-    }
-    parentPort?.postMessage({type: 'workerRegistered'});
-  } else if (event.type === 'probeStatus') {
-    parentPort.postMessage({
-      type: 'status',
-      status: 'ok',
-    });
-  }
-});
-parentPort?.postMessage({type: 'workerLoaded'});
+const napiWorker = napi.newNodejsWorker(worker);
+parentPort?.postMessage(napiWorker);
 
 type ResolverState<T> = {|
   resolver: Resolver<T>,

package/lib/atlaspack-v3/WorkerPool.js

@@ -1,171 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.WorkerPool = void 0;
-exports.waitForMessage = waitForMessage;
-exports.workerPool = void 0;
-function _path() {
-  const data = _interopRequireDefault(require("path"));
-  _path = function () {
-    return data;
-  };
-  return data;
-}
-function _promises() {
-  const data = require("timers/promises");
-  _promises = function () {
-    return data;
-  };
-  return data;
-}
-function _worker_threads() {
-  const data = require("worker_threads");
-  _worker_threads = function () {
-    return data;
-  };
-  return data;
-}
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-/* eslint-disable no-console */
-/*!
- * Atlaspack V3 delegates work to node.js worker threads.
- *
- * Starting-up each worker is relatively expensive, in particular when atlaspack
- * is running in development mode, in which case each worker will transpile the
- * project on startup.
- *
- * This "WorkerPool" mitigates this problem by reusing worker threads across
- * builds.
- */
-// $FlowFixMe Missing types
-const WORKER_PATH = _path().default.join(__dirname, 'worker', 'index.js');
-function waitForMessage(worker, type, signal) {
-  return new Promise(resolve => {
-    const onMessage = message => {
-      if (message.type === type) {
-        resolve(message);
-        worker.off('message', onMessage);
-      }
-    };
-    worker.on('message', onMessage);
-    const onAbort = () => {
-      signal.removeEventListener('abort', onAbort);
-      worker.off('message', onMessage);
-    };
-    signal.addEventListener('abort', onAbort);
-  });
-}
-class WorkerPool {
-  #workerPool = [];
-  #usedWorkers = new Set();
-  #workerPath;
-  constructor(workerPath = WORKER_PATH) {
-    this.#workerPath = workerPath;
-
-    // $FlowFixMe
-    this[Symbol.dispose] = () => {
-      this.shutdown();
-    };
-  }
-
-  /**
-   * Find a worker thread that is free to use or create a new one.
-   *
-   * Then register the `tx_worker` channel ID with the worker thread.
-   */
-  registerWorker(tx_worker) {
-    const availableIndex = this.#workerPool.findIndex((worker, index) => !this.#usedWorkers.has(index));
-    const [workerId, worker] = availableIndex !== -1 ? [availableIndex, this.#workerPool[availableIndex]] : this.#createWorker();
-    this.#bootWorker(worker, tx_worker).catch(err => {
-      // eslint-disable-next-line no-console
-      console.error('Worker failed, retrying to create it...', err);
-      this.#workerPool[workerId] = new (_worker_threads().Worker)(this.#workerPath, {
-        workerData: {
-          attempt: 2
-        }
-      });
-      this.#bootWorker(this.#workerPool[workerId], tx_worker).catch(err => {
-        console.error('Worker failed to start, the build may hang:', err);
-      });
-    });
-    this.#usedWorkers.add(workerId);
-    return workerId;
-  }
-
-  /**
-   * Release a set of workers back into the pool for re-use
-   */
-  releaseWorkers(ids) {
-    for (let id of ids) {
-      this.#usedWorkers.delete(id);
-    }
-  }
-
-  /**
-   * Terminate all worker threads and reset state.
-   */
-  shutdown() {
-    for (let worker of this.#workerPool) {
-      worker.terminate();
-    }
-    this.#usedWorkers.clear();
-    this.#workerPool = [];
-  }
-  getStats() {
-    return {
-      totalWorkers: this.#workerPool.length,
-      workersInUse: this.#usedWorkers.size
-    };
-  }
-
-  /**
-   * Get the worker thread. Used for testing.
-   */
-  getWorker(workerId) {
-    if (!this.#workerPool[workerId]) {
-      throw new Error('Worker does not exist');
-    }
-    return this.#workerPool[workerId];
-  }
-  async #bootWorker(worker, tx_worker) {
-    const controller = new AbortController();
-    const signal = controller.signal;
-    const workerError = new Promise((_, reject) => {
-      const onError = err => {
-        reject(err);
-      };
-      worker.once('error', onError);
-      const onAbort = () => {
-        signal.removeEventListener('abort', onAbort);
-        worker.off('error', onError);
-      };
-      signal.addEventListener('abort', onAbort);
-    });
-    const workerReady = waitForMessage(worker, 'workerRegistered', signal);
-    worker.postMessage({
-      type: 'registerWorker',
-      tx_worker
-    });
-    try {
-      await Promise.race([(0, _promises().setTimeout)(5000, {
-        signal
-      }), workerError, workerReady]);
-    } finally {
-      controller.abort();
-    }
-  }
-  #createWorker() {
-    const worker = new (_worker_threads().Worker)(this.#workerPath, {
-      workerData: {
-        attempt: 1
-      }
-    });
-    const workerId = this.#workerPool.length;
-    this.#workerPool.push(worker);
-    return [workerId, worker];
-  }
-}
-exports.WorkerPool = WorkerPool;
-const workerPool = exports.workerPool = new WorkerPool();

package/src/atlaspack-v3/WorkerPool.js

@@ -1,171 +0,0 @@
-// @flow strict-local
-
-/* eslint-disable no-console */
-
-/*!
- * Atlaspack V3 delegates work to node.js worker threads.
- *
- * Starting-up each worker is relatively expensive, in particular when atlaspack
- * is running in development mode, in which case each worker will transpile the
- * project on startup.
- *
- * This "WorkerPool" mitigates this problem by reusing worker threads across
- * builds.
- */
-import path from 'path';
-// $FlowFixMe Missing types
-import {setTimeout} from 'timers/promises';
-import {Worker} from 'worker_threads';
-
-const WORKER_PATH = path.join(__dirname, 'worker', 'index.js');
-
-export function waitForMessage<T>(
-  worker: Worker,
-  type: string,
-  signal: AbortSignal,
-): Promise<T> {
-  return new Promise((resolve) => {
-    const onMessage = (message: T & {|type: string|}) => {
-      if (message.type === type) {
-        resolve(message);
-        worker.off('message', onMessage);
-      }
-    };
-
-    worker.on('message', onMessage);
-
-    const onAbort = () => {
-      signal.removeEventListener('abort', onAbort);
-      worker.off('message', onMessage);
-    };
-
-    signal.addEventListener('abort', onAbort);
-  });
-}
-
-export class WorkerPool {
-  #workerPool: Worker[] = [];
-  #usedWorkers: Set<number> = new Set();
-  #workerPath: string;
-
-  constructor(workerPath: string = WORKER_PATH) {
-    this.#workerPath = workerPath;
-
-    // $FlowFixMe
-    this[Symbol.dispose] = () => {
-      this.shutdown();
-    };
-  }
-
-  /**
-   * Find a worker thread that is free to use or create a new one.
-   *
-   * Then register the `tx_worker` channel ID with the worker thread.
-   */
-  registerWorker(tx_worker: number): number {
-    const availableIndex = this.#workerPool.findIndex(
-      (worker, index) => !this.#usedWorkers.has(index),
-    );
-
-    const [workerId, worker] =
-      availableIndex !== -1
-        ? [availableIndex, this.#workerPool[availableIndex]]
-        : this.#createWorker();
-
-    this.#bootWorker(worker, tx_worker).catch((err) => {
-      // eslint-disable-next-line no-console
-      console.error('Worker failed, retrying to create it...', err);
-      this.#workerPool[workerId] = new Worker(this.#workerPath, {
-        workerData: {attempt: 2},
-      });
-
-      this.#bootWorker(this.#workerPool[workerId], tx_worker).catch((err) => {
-        console.error('Worker failed to start, the build may hang:', err);
-      });
-    });
-
-    this.#usedWorkers.add(workerId);
-
-    return workerId;
-  }
-
-  /**
-   * Release a set of workers back into the pool for re-use
-   */
-  releaseWorkers(ids: number[]) {
-    for (let id of ids) {
-      this.#usedWorkers.delete(id);
-    }
-  }
-
-  /**
-   * Terminate all worker threads and reset state.
-   */
-  shutdown() {
-    for (let worker of this.#workerPool) {
-      worker.terminate();
-    }
-    this.#usedWorkers.clear();
-    this.#workerPool = [];
-  }
-
-  getStats(): {|totalWorkers: number, workersInUse: number|} {
-    return {
-      totalWorkers: this.#workerPool.length,
-      workersInUse: this.#usedWorkers.size,
-    };
-  }
-
-  /**
-   * Get the worker thread. Used for testing.
-   */
-  getWorker(workerId: number): Worker {
-    if (!this.#workerPool[workerId]) {
-      throw new Error('Worker does not exist');
-    }
-    return this.#workerPool[workerId];
-  }
-
-  async #bootWorker(worker: Worker, tx_worker: number): Promise<void> {
-    const controller = new AbortController();
-    const signal = controller.signal;
-
-    const workerError = new Promise((_, reject) => {
-      const onError = (err: Error) => {
-        reject(err);
-      };
-
-      worker.once('error', onError);
-
-      const onAbort = () => {
-        signal.removeEventListener('abort', onAbort);
-        worker.off('error', onError);
-      };
-
-      signal.addEventListener('abort', onAbort);
-    });
-
-    const workerReady = waitForMessage(worker, 'workerRegistered', signal);
-
-    worker.postMessage({type: 'registerWorker', tx_worker});
-
-    try {
-      await Promise.race([
-        setTimeout(5000, {signal}),
-        workerError,
-        workerReady,
-      ]);
-    } finally {
-      controller.abort();
-    }
-  }
-
-  #createWorker(): [number, Worker] {
-    const worker = new Worker(this.#workerPath, {workerData: {attempt: 1}});
-    const workerId = this.#workerPool.length;
-    this.#workerPool.push(worker);
-    return [workerId, worker];
-  }
-}
-
-export const workerPool: WorkerPool = new WorkerPool();

package/test/atlaspack-v3/WorkerPool.test.js

@@ -1,147 +0,0 @@
-// @flow strict-local
-
-import path from 'path';
-import {Worker} from 'worker_threads';
-import {WorkerPool, waitForMessage} from '../../src/atlaspack-v3/WorkerPool';
-import assert from 'assert';
-
-function probeStatus(worker: Worker) {
-  const response = waitForMessage(
-    worker,
-    'status',
-    new AbortController().signal,
-  );
-  worker.postMessage({type: 'probeStatus'});
-  return response;
-}
-
-const flushPromises = () => new Promise((resolve) => setImmediate(resolve));
-
-describe('WorkerPool', () => {
-  it('can create workers and will send them the tx_worker value', async () => {
-    const workerPool = new WorkerPool(path.join(__dirname, 'worker.js'));
-    const workerId = workerPool.registerWorker(0);
-    const worker = workerPool.getWorker(workerId);
-    const status = await probeStatus(worker);
-
-    assert.deepEqual(status, {
-      type: 'status',
-      status: 'test-status-ok',
-      receivedMessages: [
-        {
-          type: 'registerWorker',
-          tx_worker: 0,
-        },
-      ],
-    });
-  });
-
-  it('recreates a failing worker', async () => {
-    const workerPool = new WorkerPool(path.join(__dirname, 'worker-error.js'));
-    const workerId = workerPool.registerWorker(0);
-    const failingWorker = workerPool.getWorker(workerId);
-
-    await new Promise((resolve) => {
-      failingWorker.on('error', resolve);
-    });
-
-    await flushPromises();
-
-    const worker = workerPool.getWorker(workerId);
-    const status = await probeStatus(worker);
-
-    assert.deepEqual(status, {
-      type: 'status',
-      status: 'ok',
-    });
-  });
-
-  it('when a worker is created, it is tracked', () => {
-    const workerPool = new WorkerPool(path.join(__dirname, 'worker.js'));
-    const w1 = workerPool.registerWorker(0);
-    const w2 = workerPool.registerWorker(0);
-    const w3 = workerPool.registerWorker(0);
-    assert.notEqual(w1, w2);
-    assert.notEqual(w2, w3);
-    assert.notEqual(w1, w3);
-
-    assert.deepEqual(workerPool.getStats(), {
-      totalWorkers: 3,
-      workersInUse: 3,
-    });
-  });
-
-  it('workers can be released and will then be reused', async () => {
-    const workerPool = new WorkerPool(path.join(__dirname, 'worker.js'));
-    const worker1 = workerPool.registerWorker(0);
-    workerPool.registerWorker(5);
-    assert.deepEqual(workerPool.getStats(), {
-      totalWorkers: 2,
-      workersInUse: 2,
-    });
-
-    // Release the worker
-    workerPool.releaseWorkers([worker1]);
-    assert.deepEqual(workerPool.getStats(), {
-      totalWorkers: 2,
-      workersInUse: 1,
-    });
-
-    const worker3 = workerPool.registerWorker(33);
-    assert.equal(worker1, worker3);
-
-    const worker = workerPool.getWorker(worker3);
-    const status = await probeStatus(worker);
-    assert.deepEqual(status, {
-      type: 'status',
-      status: 'test-status-ok',
-      receivedMessages: [
-        {
-          type: 'registerWorker',
-          tx_worker: 0,
-        },
-        {
-          type: 'registerWorker',
-          tx_worker: 33,
-        },
-      ],
-    });
-  });
-
-  describe('shutdown', () => {
-    it('terminates all workers', async () => {
-      const workerPool = new WorkerPool(path.join(__dirname, 'worker.js'));
-      const worker1Id = workerPool.registerWorker(0);
-      const worker2Id = workerPool.registerWorker(0);
-      const worker1 = workerPool.getWorker(worker1Id);
-      const worker2 = workerPool.getWorker(worker2Id);
-
-      const worker1Exit = new Promise((resolve) => {
-        worker1.on('exit', () => {
-          resolve(null);
-        });
-      });
-      const worker2Exit = new Promise((resolve) => {
-        worker2.on('exit', () => {
-          resolve(null);
-        });
-      });
-
-      workerPool.shutdown();
-      assert.throws(() => {
-        workerPool.getWorker(worker1Id);
-      });
-      assert.throws(() => {
-        workerPool.getWorker(worker2Id);
-      });
-
-      await worker1Exit;
-      await worker2Exit;
-
-      assert.deepEqual(workerPool.getStats(), {
-        totalWorkers: 0,
-        workersInUse: 0,
-      });
-    });
-  });
-});