## Why Poolifier?
-Poolifier is used to perform CPU intensive and I/O intensive tasks on nodejs servers, it implements worker pools using [worker-threads](https://nodejs.org/api/worker_threads.html#worker_threads_worker_threads) and cluster pools using [Node.js cluster](https://nodejs.org/api/cluster.html) modules.
+Poolifier is used to perform CPU intensive and I/O intensive tasks on nodejs servers, it implements worker pools using [worker-threads](https://nodejs.org/api/worker_threads.html#worker_threads_worker_threads) and cluster pools using [cluster](https://nodejs.org/api/cluster.html) Node.js modules.
With poolifier you can improve your **performance** and resolve problems related to the event loop.
Moreover you can execute your tasks using an API designed to improve the **developer experience**.
Please consult our [general guidelines](#general-guidance).
Node pool contains two [worker-threads](https://nodejs.org/api/worker_threads.html#worker_threads_worker_threads)/[cluster worker](https://nodejs.org/api/cluster.html#cluster_class_worker) pool implementations, you don't have to deal with worker-threads/cluster worker complexity.
The first implementation is a static worker pool, with a defined number of workers that are started at creation time and will be reused.
The second implementation is a dynamic worker pool with a number of worker started at creation time (these workers will be always active and reused) and other workers created when the load will increase (with an upper limit, these workers will be reused when active), the new created workers will be stopped after a configurable period of inactivity.
-You have to implement your worker extending the ThreadWorker or ClusterWorker class.
+You have to implement your worker by extending the ThreadWorker or ClusterWorker class.
## Installation
```js
'use strict'
-const { DynamicThreadPool, FixedThreadPool, PoolEvents } = require('poolifier')
+const { DynamicThreadPool, FixedThreadPool, PoolEvents, availableParallelism } = require('poolifier')
// a fixed worker-threads pool
-const pool = new FixedThreadPool(15, './yourWorker.js', { errorHandler: e => console.error(e), onlineHandler: () => console.log('worker is online') })
+const pool = new FixedThreadPool(availableParallelism(), './yourWorker.js', {
+ errorHandler: e => console.error(e),
+ onlineHandler: () => console.info('worker is online')
+})
-pool.emitter.on(PoolEvents.busy, () => console.log('Pool is busy'))
+pool.emitter.on(PoolEvents.ready, () => console.info('Pool is ready'))
+pool.emitter.on(PoolEvents.busy, () => console.info('Pool is busy'))
// or a dynamic worker-threads pool
-const pool = new DynamicThreadPool(10, 100, './yourWorker.js', { errorHandler: e => console.error(e), onlineHandler: () => console.log('worker is online') })
+const pool = new DynamicThreadPool(Math.floor(availableParallelism() / 2), availableParallelism(), './yourWorker.js', {
+ errorHandler: e => console.error(e),
+ onlineHandler: () => console.info('worker is online')
+})
-pool.emitter.on(PoolEvents.full, () => console.log('Pool is full'))
-pool.emitter.on(PoolEvents.busy, () => console.log('Pool is busy'))
+pool.emitter.on(PoolEvents.full, () => console.info('Pool is full'))
+pool.emitter.on(PoolEvents.ready, () => console.info('Pool is ready'))
+pool.emitter.on(PoolEvents.busy, () => console.info('Pool is busy'))
// the execute method signature is the same for both implementations,
// so you can easy switch from one to another
### `pool.execute(data, name)`
`data` (optional) An object that you want to pass to your worker implementation
-`name` (optional) A string with the task function name that you want to execute on the worker. Default: `'default'`
-This method is available on both pool implementations and returns a promise.
+`name` (optional) A string with the task function name that you want to execute on the worker. Default: `'default'`
+
+This method is available on both pool implementations and returns a promise with the task function execution response.
### `pool.destroy()`
-Destroy method is available on both pool implementations.
-This method will call the terminate method on each worker.
+This method is available on both pool implementations and will call the terminate method on each worker.
### `class YourWorker extends ThreadWorker/ClusterWorker`
-`taskFunctions` (mandatory) The task function or task functions object that you want to execute on the worker
+`taskFunctions` (mandatory) The task function or task functions object `{ name_1: fn_1, ..., name_n: fn_n }` that you want to execute on the worker
`opts` (optional) An object with these properties:
- `maxInactiveTime` (optional) - Max time to wait tasks to work on in milliseconds, after this period the new worker will die.
The last active time of your worker unit will be updated when a task is submitted to a worker or when a worker terminate a task.
- If `killBehavior` is set to `KillBehaviors.HARD` this value represents also the timeout for the tasks that you submit to the pool, when this timeout expires your tasks is interrupted and the worker is killed if is not part of the minimum size of the pool.
+ If `killBehavior` is set to `KillBehaviors.HARD` this value represents also the timeout for the tasks that you submit to the pool, when this timeout expires your tasks is interrupted before completion and removed. The worker is killed if is not part of the minimum size of the pool.
If `killBehavior` is set to `KillBehaviors.SOFT` your tasks have no timeout and your workers will not be terminated until your task is completed.
Default: `60000`
This option only apply to the newly created workers.
Default: `KillBehaviors.SOFT`
+#### `YourWorker.hasTaskFunction(name)`
+
+`name` (mandatory) The task function name
+
+This method is available on both worker implementations and returns a boolean.
+
+#### `YourWorker.addTaskFunction(name, fn)`
+
+`name` (mandatory) The task function name
+`fn` (mandatory) The task function
+
+This method is available on both worker implementations and returns a boolean.
+
+#### `YourWorker.removeTaskFunction(name)`
+
+`name` (mandatory) The task function name
+
+This method is available on both worker implementations and returns a boolean.
+
+#### `YourWorker.setDefaultTaskFunction(name)`
+
+`name` (mandatory) The task function name
+
+This method is available on both worker implementations and returns a boolean.
+
## General guidance
Performance is one of the main target of these worker pool implementations, we want to have a strong focus on this.
repositories / poolifier.git / blobdiff