ya-rfc
Yet Another Remote Function Call library for Node js.
Ya-rpc anables to run functions on remote machines within a distributed system without worrying about network messaging or load balancing.
It provides an easy way to implement performance-critical applications by parallel execution on machines and processes.
Key Features
- multiple transports available
- websocket
- tcp
- ipc
- configurable load balancing
- blazing fast
- integrates well with ya-pubsub
- asynchronous
- embeddable
Typical execution flow
Installation
$ npm install ya-rfc
ya-rfc is tested with versions 12, 14 & 16 on of node.js on ubuntu-latest.
Quick start
const ya = require('ya-rfc');
Broker
Create a rfc broker that accepts TCP, IPC and websocket connections (only one transport required)
const namedPipe = path.join('\\\\.\\pipe', 'some-pipe');
ya.broker([
ya.transports.ipc(namedPipe),
ya.transports.tcp(8005, 'localhost'),
ya.transports.ws(8006, 'localhost')]);
Server
Define functions that remote rfc clients will request to execute
// procedures.js
module.exports = {
sum: (a, b) => {
return a + b
},
count: (until, progress) => {
const x = parseInt(until / 10)
for (let i = 0; i < until; i++) {
if (i % x === 0) {
progress(`${i}/${until}`)
}
}
return until
}
};
Create a (ideally multiple) rfc server that connects to the Broker over TCP, it can also be IPC or websocket
ya.server(ya.transports.tcp(8005, 'localhost'), 'procedures.js');
// ya.server(ya.transports.ws(8006, 'localhost'));
// const win32namedPipe = require('path').join('\\\\.\\pipe', 'some-pipe');
// ya.server(ya.transports.ipc(win32namedPipe));
Client
Create a rfc client that connects to the Broker over TCP, it can also be IPC or websocket
const client = ya.client(ya.transports.tcp(8005, 'localhost'));
// const wsClient = ya.client(ya.transports.ws(8006, 'localhost'))
// const win32namedPipe = require('path').join('\\\\.\\pipe', 'some-pipe')
// const ipcClient = ya.client(ya.transports.ipc(win32namedPipe))
Execute a function remotely
tcpClient.remote.sum(1, 2)
.then(result => {
console.log(result)
})
.catch(error => {
console.error(error)
});
/* output:
3
*/
Execute a function remotely and get notified of its progression
client.remote.count(10000, {
onProgress: (progress) => {
console.log('progress', progress)
}
})
.then(result => {
console.log('result is', result)
})
.catch(error => {
console.error(error)
});
/* output:
progress 0/10000
progress 1000/10000
progress 2000/10000
progress 3000/10000
progress 4000/10000
progress 5000/10000
progress 6000/10000
progress 7000/10000
progress 8000/10000
progress 9000/10000
result is 10000
*/
User defined load balancing
By default, each server will be assigned a maximum of 4*cpu-cores
concurrent requests distributed (round robin) on its 2*cpu-cores
workers. The broker will always route requests to the less loaded server.
You can create a server with an arbitrary number of workers
ya.server(transport, modulePath, { workers:10 })
You can define the maximum accepted load. For example, if each request has a load of 1
, a maximum of 100 concurrent requests can be defined as such:
ya.server(transport, modulePath, { maxLoad:[100] })
Alternatively you can unset (not recommended) the limit by providing -1
ya.server(transport, modulePath, { maxLoad:[-1] })
By default, all requests are assigned a load of 1
, this can be overridden like this:
rfc.remote.foo(bar, { load:[10] })
Often, the impact of a request on cpu or memory usage has to be modelled with several values, this is why maxLoad and load options are to be provided as arrays.
Versioning
Yaps-node uses Semantic Versioning for predictable versioning.
License
This library is licensed under MIT.