Matte
Matte is an implementation a thread pool pattern for node.js
As we know Node.js is asynchronous but some features stay synchronous. The matte solution can help you to avoid blocking your main thread and compute sync things in another Event loop.
Features
- Easy to use
- Task timeouts
- Cancellable tasks
- Autorestart worker when they fall
- Can be filled by your inline functions
- All your handlers are covered by VM context
- You can parallel tasks in one worker or workers group
- Leverage all CPU cores
- Async workers
- Very small package
- ts-results compatible
- rxjs compatible
Built with
- Node.js - Platform
- Typescript - typed superset of JavaScript that compiles to plain JavaScript
Prerequisites
- Node.js 12.x+
- Typescript knowledge
Installation
npm install @datapain/matte
Usage
First of all, let's look at a basic example where we want to execute some Math operation:
Basic math operation
import assert from 'assert';
import { WorkerPool } from '@datapain/matte';
type PowPool = { x: number; y: number };
const pow = ({ x, y }: PowPool) => {
return Math.pow(x, y);
};
const pool = new WorkerPool();
pool
.init({ workers: { timeout: 200 } })
.catch(console.error)
.then(() => {
const taskId = pool.process<PowPool, number>({
handler: pow,
data: { x: 2, y: 2 },
callback: (result) => {
assert.strictEqual(result.val, 4);
console.log('Always works');
pool.terminate();
},
});
});
Task abortion
The next example will describe how we able to abort some tasks:
import assert from 'assert';
import { WorkerPool } from '@datapain/matte';
import type { AbortSignal } from 'abort-controller';
const reallyLongTask = async (_, signal: AbortSignal) =>
new Promise((res, rej) => {
const timeoutId = setTimeout(() => {
res('BOOM!');
}, 200);
signal.addEventListener('abort', () => {
clearTimeout(timeoutId);
rej(new Error('Task was aborted'));
});
});
const pool = new WorkerPool();
pool
.init({ workers: { timeout: 100 } })
.catch(console.error)
.then(() => {
pool
.process<undefined, unknown>({
handler: reallyLongTask,
callback: (result) => {
result
.map(() => {
throw new Error('BOOM');
})
.mapErr((err) => {
assert.strictEqual(err.message, 'Task was aborted');
console.log('Always works!');
});
pool.terminate();
},
})
.andThen((id) => pool.abort(id));
});
Predefined context functions
import assert from 'assert';
import { WorkerPool } from '@datapain/matte';
const pool = new WorkerPool();
pool
.init({
workers: { timeout: 100 },
fn: {
context: () => {
// @ts-ignore
this.pow = ({ x, y }) => {
return Math.pow(x, y);
};
},
},
})
.catch(console.error)
.then(() => {
pool
.process<undefined, number>({
handler: () => {
// @ts-ignore
return pow({ x: 2, y: 2 });
},
callback: (result) => {
result.map((res) => assert.strictEqual(res, 4));
pool.terminate();
},
})
.andThen((id) => pool.abort(id));
});
Versioning
We use SemVer for versioning.