@jshaftoe/infra/dist/ThreadPool.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

var _events = _interopRequireDefault(require("events"));

var _autoBind = _interopRequireDefault(require("auto-bind"));

var _AsyncQueue = _interopRequireWildcard(require("./AsyncQueue"));

var _asyncSyncUtils = require("./asyncSyncUtils");

var _errorUtils = require("./errorUtils");

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

/**
 * A thread-pool abstraction for ES6 async operations",
 * 
 * @export
 * @class ThreadPool
 * @extends {EventEmitter}
 */
class ThreadPool extends _events.default {
  static async run(options) {
    options.errorHandler = options.errorHandler || (err => {
      throw err;
    });

    const tp = new ThreadPool(options);

    if (options.items) {
      await tp.queueItems(options.items);
    }

    return await tp.runAllQueued();
  }

  static async all(items, task, threads) {
    const tp = new ThreadPool({
      task: task,
      threads: threads,
      items: items
    });

    if (items) {
      await tp.queueItems(items);
    }

    return await tp.runAllQueued();
  }
  /**
   * Creates an instance of ThreadPool
   */


  constructor(options) {
    super();

    _defineProperty(this, "queuedCount", 0);

    _defineProperty(this, "startedCount", 0);

    _defineProperty(this, "endedCount", 0);

    _defineProperty(this, "_options", void 0);

    _defineProperty(this, "_errorHandler", void 0);

    _defineProperty(this, "_uncaughtErrors", []);

    _defineProperty(this, "_closed", false);

    _defineProperty(this, "_queuedTasks", void 0);

    _defineProperty(this, "_threadsSemaphore", void 0);

    _defineProperty(this, "_completeEvent", void 0);

    _defineProperty(this, "_allTasksCompleteOrSomeFailedEvent", void 0);

    _defineProperty(this, "_res", []);

    this._options = options;
    this._options.threads = this._options.threads || Infinity;

    this._errorHandler = this._options.errorHandler || (err => {
      throw err;
    }); // eslint-disable-line no-console


    this._queuedTasks = new _AsyncQueue.default({
      name: options.name,
      maxSize: options.queueMaxSize
    });
    this._threadsSemaphore = new _asyncSyncUtils.Semaphore(this._options.threads);
    this._completeEvent = new _asyncSyncUtils.OneTimeBroadcastEvent(false);
    this._allTasksCompleteOrSomeFailedEvent = new _asyncSyncUtils.OneTimeBroadcastEvent(false);
    (0, _autoBind.default)(this);
  }
  /**
   * Queues an itme from the ThreadPool
   */


  async queueItem(item) {
    if (this._closed) throw new Error(`Trying to queue a job to a closed ThreadPool`);
    const index = this.queuedCount++;
    await this._queuedTasks.enqueue({
      func: async () => this._res[index] = await this._options.task(item),
      index: index
    });
  }
  /**
   * Queues an itme from the ThreadPool
   */


  async queueItems(queueItem) {
    for (const item of queueItem) {
      await this.queueItem(item);
    }
  }
  /**
   * Starts executing all queued tasks
   * 
   * This function should be awaited - it will return after the ThreadPool has been closed and all it's tasks completed, or after a task threw an error.
   */


  async run() {
    try {
      while (true) {
        // wait for an available task
        // TODO: also wait for errors here?
        let task;

        try {
          task = await this._queuedTasks.dequeue();
        } catch (err) {
          if (err instanceof _AsyncQueue.QueueClosedError) break;
          throw err;
        } // wait for an available 'thread'


        await this._threadsSemaphore.enter();

        if (this._uncaughtErrors.length) {
          break;
        }

        this._allTasksCompleteOrSomeFailedEvent.reset(); // NOTE: no await


        this._runTask(task);
      } // wait for completion


      if (this.startedCount > 0) {
        await this._allTasksCompleteOrSomeFailedEvent.wait();
      }

      this._throwUncaughtErrors();
    } finally {
      this._completeEvent.signal();
    }
  }
  /**
   * Starts executing all queued tasks
   * 
   * This function should not be awaited - it will return immediatly
   */


  startRun() {
    (async () => {
      try {
        await this.run();
      } catch (err) {} // eslint-disable-line no-empty

    })();
  }
  /**
   * Closes the ThreadPool for further task queueing, the ThreadPool's completion can be awaited afte'r it's called
   */


  close() {
    this._closed = true;

    this._queuedTasks.close(); // NOTE: NO AWAIT
    // TODO: await completion

  }
  /**
   * Closes the ThreadPool, runs it's tasks and awaits their completion
   */


  async runAllQueued() {
    this.close();
    await this.run();
    return this._res;
  }
  /**
   * Awaits the closing and completion of all ThreadPool tasks
   */


  async waitComplete() {
    await this._completeEvent.wait();

    this._throwUncaughtErrors();

    return this._res;
  }
  /**
   * Closes the ThreadPool and awaits the running and completion of all ThreadPool tasks
   */


  async closeAndWaitComplete() {
    this.close();
    return await this.waitComplete();
  }
  /****************** privates ******************/


  _throwUncaughtErrors() {
    if (this._uncaughtErrors.length > 0) {
      throw new _errorUtils.ExtendedError(`Errors were thrown during execution of ThreadPool`, {
        threadPoolName: this._options.name,
        errorCount: this._uncaughtErrors.length,
        errorMessages: this._uncaughtErrors.map(e => e.message),
        uncaughtErrors: this._uncaughtErrors
      });
    }
  }

  async _runTask(task) {
    try {
      this.startedCount++;
      await task.func();
    } catch (err) {
      try {
        this._errorHandler(err);
      } catch (err2) {
        this._uncaughtErrors.push(err2);

        await this._allTasksCompleteOrSomeFailedEvent.signal();
      }
    } finally {
      this.endedCount++; // fire 'progress' event

      this.emit('progress', {
        endedCount: this.endedCount
      });

      this._threadsSemaphore.exit();

      if (this._threadsSemaphore.takenCount === 0) {
        this._allTasksCompleteOrSomeFailedEvent.signal();
      }
    }
  }

}

exports.default = ThreadPool;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/ThreadPool.js"],"names":["ThreadPool","EventEmitter","run","options","errorHandler","err","tp","items","queueItems","runAllQueued","all","task","threads","constructor","_options","Infinity","_errorHandler","_queuedTasks","AsyncQueue","name","maxSize","queueMaxSize","_threadsSemaphore","Semaphore","_completeEvent","OneTimeBroadcastEvent","_allTasksCompleteOrSomeFailedEvent","queueItem","item","_closed","Error","index","queuedCount","enqueue","func","_res","dequeue","QueueClosedError","enter","_uncaughtErrors","length","reset","_runTask","startedCount","wait","_throwUncaughtErrors","signal","startRun","close","waitComplete","closeAndWaitComplete","ExtendedError","threadPoolName","errorCount","errorMessages","map","e","message","uncaughtErrors","err2","push","endedCount","emit","exit","takenCount"],"mappings":"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","sourcesContent":["// @flow\n\nimport EventEmitter from 'events'\nimport autoBind from 'auto-bind'\n\nimport AsyncQueue, { QueueClosedError } from './AsyncQueue'\nimport { OneTimeBroadcastEvent, Semaphore } from './asyncSyncUtils'\nimport { ExtendedError } from './errorUtils'\n\n\ntype ThreadPoolOptions<T, R> = {\n  name?: ?string,\n  threads?: ?number,\n  items?: ?Array<T>,\n  task: (item: T) => Promise<R>,\n  errorHandler?: ?(err: Error) => void, \n  queueMaxSize?: ?number,\n}\n\ntype Task<R> = { \n  func: () => Promise<R>, \n  index: number,\n}\n\n/**\n * A thread-pool abstraction for ES6 async operations\",\n * \n * @export\n * @class ThreadPool\n * @extends {EventEmitter}\n */\nexport default class ThreadPool<T, R> extends EventEmitter {\n  \n  queuedCount: number = 0\n  startedCount: number = 0\n  endedCount: number = 0\n\n  _options: ThreadPoolOptions<T, R>\n  _errorHandler: (err: Error) => void\n  _uncaughtErrors: Array<Error> = []\n  _closed: boolean = false\n  _queuedTasks: AsyncQueue<{ func: () => Promise<R>, index: number }>\n  _threadsSemaphore: Semaphore\n  _completeEvent: OneTimeBroadcastEvent\n  _allTasksCompleteOrSomeFailedEvent: OneTimeBroadcastEvent\n  _res: Array<R> = []\n\n\n  static async run(options: ThreadPoolOptions<T, R>): Promise<Array<R>> {\n    options.errorHandler = options.errorHandler || ((err) => { throw err })\n    const tp = new ThreadPool(options)\n    if (options.items) {\n      await tp.queueItems(options.items)\n    }\n    return await tp.runAllQueued()\n  }\n\n  static async all(items: Array<T>, task: (item: T) => Promise<R>, threads: ?number): Promise<Array<R>> {\n    const tp = new ThreadPool({\n      task: task,\n      threads: threads,\n      items: items,\n    })\n    if (items) {\n      await tp.queueItems(items)\n    }\n    return await tp.runAllQueued()\n  }\n\n\n  /**\n   * Creates an instance of ThreadPool\n   */\n  constructor(options: ThreadPoolOptions<T, R>) {\n    super()\n\n    this._options = options\n    this._options.threads = this._options.threads || Infinity\n\n    this._errorHandler = this._options.errorHandler || ((err) => { throw err }) // eslint-disable-line no-console\n\n    this._queuedTasks = new AsyncQueue({ \n      name: options.name,\n      maxSize: options.queueMaxSize,\n    })\n    this._threadsSemaphore = new Semaphore(this._options.threads)\n    this._completeEvent = new OneTimeBroadcastEvent(false)\n    this._allTasksCompleteOrSomeFailedEvent = new OneTimeBroadcastEvent(false)\n\n    autoBind(this)\n  }\n\n  /**\n   * Queues an itme from the ThreadPool\n   */\n  async queueItem(item: T): Promise<void> {\n    if (this._closed)\n      throw new Error(`Trying to queue a job to a closed ThreadPool`)\n\n    const index = this.queuedCount++   \n    await this._queuedTasks.enqueue({ \n      func: async () => this._res[index] = await this._options.task(item), \n      index: index,\n    })\n  }\n\n  /**\n   * Queues an itme from the ThreadPool\n   */\n  async queueItems(queueItem: Array<T>): Promise<void> {\n    for (const item of queueItem) {\n      await this.queueItem(item)\n    }\n  }\n  \n  /**\n   * Starts executing all queued tasks\n   * \n   * This function should be awaited - it will return after the ThreadPool has been closed and all it's tasks completed, or after a task threw an error.\n   */\n  async run() {\n    try {\n      while (true) {\n\n        // wait for an available task\n        // TODO: also wait for errors here?\n        let task\n        try {\n          task = await this._queuedTasks.dequeue()\n        } catch (err) {\n          if (err instanceof QueueClosedError)\n            break\n          throw err\n        }\n  \n        // wait for an available 'thread'\n        await this._threadsSemaphore.enter()\n        if (this._uncaughtErrors.length) {\n          break\n        }\n  \n        this._allTasksCompleteOrSomeFailedEvent.reset()\n        \n        // NOTE: no await\n        this._runTask(task)\n      }\n  \n      // wait for completion\n      if (this.startedCount > 0) {\n        await this._allTasksCompleteOrSomeFailedEvent.wait()\n      }\n  \n      this._throwUncaughtErrors()\n    } finally {\n      this._completeEvent.signal()\n    }\n  }\n\n  /**\n   * Starts executing all queued tasks\n   * \n   * This function should not be awaited - it will return immediatly\n   */\n  startRun() {\n    (async () => {\n      try {\n        await this.run()\n      } catch (err) {} // eslint-disable-line no-empty\n    })()\n  }\n\n  /**\n   * Closes the ThreadPool for further task queueing, the ThreadPool's completion can be awaited afte'r it's called\n   */\n  close() {\n    this._closed = true\n    this._queuedTasks.close() // NOTE: NO AWAIT\n    // TODO: await completion\n  }\n\n  /**\n   * Closes the ThreadPool, runs it's tasks and awaits their completion\n   */\n  async runAllQueued(): Promise<Array<R>> {\n    this.close()\n    await this.run()\n    return this._res\n  }\n\n  /**\n   * Awaits the closing and completion of all ThreadPool tasks\n   */\n  async waitComplete(): Promise<Array<R>> {\n    await this._completeEvent.wait()\n    this._throwUncaughtErrors()\n    return this._res\n  }\n\n  /**\n   * Closes the ThreadPool and awaits the running and completion of all ThreadPool tasks\n   */\n  async closeAndWaitComplete(): Promise<Array<R>> {\n    this.close()\n    return await this.waitComplete()\n  }\n\n  /****************** privates ******************/\n\n  _throwUncaughtErrors() {   \n    if (this._uncaughtErrors.length > 0) {\n      throw new ExtendedError(`Errors were thrown during execution of ThreadPool`, {\n        threadPoolName: this._options.name,\n        errorCount: this._uncaughtErrors.length,\n        errorMessages: this._uncaughtErrors.map(e => e.message),\n        uncaughtErrors: this._uncaughtErrors,\n      })\n    }\n  }\n\n  async _runTask(task: Task<R>) {\n    try {\n      this.startedCount++\n      await task.func()\n    } catch (err) {\n      try {\n        this._errorHandler(err)\n      } catch (err2) {\n        this._uncaughtErrors.push(err2)\n        await this._allTasksCompleteOrSomeFailedEvent.signal()\n      }\n    } finally {\n      this.endedCount++          \n      // fire 'progress' event\n      this.emit('progress', { endedCount: this.endedCount })\n      this._threadsSemaphore.exit()\n      if (this._threadsSemaphore.takenCount === 0) {\n        this._allTasksCompleteOrSomeFailedEvent.signal()\n      }\n    }\n  }\n}\n"]}