node-worker-threads-pool-ts/src/dynamic-pool.js

Simple worker threads pool using Node's worker_threads module. Compatible with ES6+ Promise, Typescript, Async/Await.

"use strict";
/**
 * @typedef {import("./pool-worker").TaskConfig} TaskConfig
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.DynamicPool = void 0;
const pool_1 = require("./pool");
const pool_worker_1 = require("./pool-worker");
const task_executor_1 = require("./task-executor");
const create_code_1 = require("./create-code");
const worker_threads_1 = require("worker_threads");
const script = `
  const vm = require('vm');
  const { parentPort } = require('worker_threads');

  process.once("unhandledRejection", (err) => {
    throw err;
  });

  parentPort.on('message', async ({ code, workerData, param }) => {
    this.workerData = workerData;
    const task = vm.runInThisContext(code);
    const container = { task, workerData, require };
    const result = await container.task(param);
    parentPort.postMessage(result);
  });
`;
/**
 * Threads pool that can run different function
 * each call.
 */
class DynamicPool extends pool_1.Pool {
    /**
     * @param size Number of workers.
     * @param opt Some advanced settings.
     *
     */
    constructor(size, opt = {}) {
        super(size);
        const workerOpt = {
            eval: true,
        };
        /* istanbul ignore next */
        if (opt.shareEnv) {
            workerOpt.env = worker_threads_1.SHARE_ENV;
        }
        /* istanbul ignore next */
        if (typeof opt.resourceLimits === "object") {
            workerOpt.resourceLimits = opt.resourceLimits;
        }
        this.fill(() => new pool_worker_1.PoolWorker(script, workerOpt, opt.isDone));
    }
    /**
     * Choose a idle worker to execute the function
     * with context provided.
     */
    exec(options) {
        const { task, param, workerData, timeout = 0 } = options;
        if (typeof task !== "function") {
            throw new TypeError('task "fn" must be a function!');
        }
        const code = create_code_1.createCode(task);
        const workerParam = {
            code,
            param,
            workerData,
        };
        return this.runTask(workerParam, { timeout });
    }
    /**
     * Create a task executor of this pool.
     * This is used to apply some advanced settings to a task.
     */
    createExecutor(task) {
        return new task_executor_1.DynamicTaskExecutor(this, task);
    }
}
exports.DynamicPool = DynamicPool;
//# sourceMappingURL=dynamic-pool.js.map