A high-performance and easy-to-use RPC microservices framework for Node.js, load a directory as a RPC server, call a remote function or method of a remote object like s1.say.hi(), as same as do it at local. Booms can passes not only data, but also callback functions to the server, that's awesome.
Booms is based on Node.js native TCP socket. It does not require you to write proto files, which is more easier to use.
Booms is used for modules which are on different machines. If you want to load modules which is on same machine, you should use Zooms.
Booms uses Redis to store the remote functions definition data. If you haven't installed it, please perform the following steps to install it in docker.
1. Install Docker (Docker CE recommended)
2. Install Redis in Docker
1) Install: docker pull redis
2) Start: docker run --restart=always --name redis -d -p 6379:6379 -it redis redis-server
npm install booms --savegit clone https://github.com/hiowenluke/booms.git
cd booms
npm installOpen 4 new tabs in your terminal, then:
1st tab, run `node examples/server1`
2nd tab, run `node examples/server2`
3rd tab, run `node examples/client`
4th tab, run `node examples/client-message-style`The results in clients will be like below:
Server #1
Server #2
{ msg: 'Hi, I am owen, 100 years old.' }
I am obj.do()
hi, 3Create a demo directory first.
mkdir ./booms-demo && cd ./booms-demo0) Initialize this server
mkdir ./server && cd ./server
npm init -y
npm install booms --save1) Run mkdir -p src/say to create directories, then create file "./src/say/hi.js"
module.exports = async function (name, age) {
return {msg: `Hi, I am ${name}, ${age} years old.`};
};2) Create file "index.js". (See options)
// Create a server named "s1"
require('booms').server.init('s1');3) Run
node index.js
Server s1 listening on localhost:50051Open a new tab in your terminal first.
0) Initialize this client
cd .. && mkdir ./client && cd ./client
npm init -y
npm install booms --save1) Create file "index.js"
const {s1} = require('booms/services');
const main = async function () {
const result = await s1.say.hi('owen', 100);
console.log(result);
};
main();2) Run
node index.js
{ msg: 'Hi, I am owen, 100 years old.' }The client loads the remote functions definition like below:
const {s1} = require('booms/services');Click above "booms/services.js" in your editor (such as VS Code or WebStorm) to view it:
const apis = {
s1: {
about: async function(){},
callback: async function(hi, cb){},
obj: {
do: async function(){}
},
say: {
hi: async function(name, age){}
}
},
s2: {
about: async function(){}
}
};
...It will be compact like below while options.isCompactFunctionsList is true. (See options)
// The list of remote functions with parameters.
// You should use the "await" keyword to call them.
const apis = {
s1: {
about(){},
callback(hi, cb){},
obj: {
do(){}
},
say: {
hi(name, age){}
}
},
s2: {
about(){}
}
};
...See examples to learn more.
In addition to calling a remote function, you can also call a method of a remote object.
// obj.js
module.exports = {
async do() {
return `I am obj.do()`;
}
};const {s1} = require('booms/services');
const main = async function () {
const result = await s1.obj.do();
console.log(result); // "I am obj.do()"
};
main();Booms can passes not only data, but also callback functions to the server.
// callback.js
module.exports = async function(hi, cb) {
// The cb is the callback comes from the client.
// The cb has wrapped as an asynchronous function by Booms automatically.
// You should use keyword await when invoke it.
// The cbResult is the result returned after the cb is executed.
const cbResult = await cb(2);
return hi + ', ' + cbResult;
};const {s1} = require('booms/services');
const main = async function () {
const x = 1;
// 1. The client passes a function to the server via Booms.
// 2. The server calls it to get a result, and handles with it.
// 3. The server returns the final result to the client.
const result = await s1.callback('hi', function (y) {
// The argument y is passed from the server, its value is 2
return x + y;
});
console.log(result); // "hi, 3"
};
main();In addition to Object-Style calling like s1.say.hi(), Booms also supports Message-Style calling like call('s1:/say/hi').
It can be omitted if it is the default value as below.
const booms = require('booms');
const options = {
name: 's1',
dir: './src',
host: 'localhost',
redis: {
host: 'localhost',
}
};
booms.server.init(options);Create file boomsConfig.js under your project root path if needed. It can be omitted if it is the default value as below.
module.exports = {
redis: {
host: 'localhost',
},
// The server names which will be fetched
servers: 'all',
// For file "booms/services.js"
functionList: {
// If it is true, the function list will be compact like below right.
// You should to always use "await" keyword to call these functions.
// s1: { s1: {
// hi: async function(name, age) {} => hi(name, age) {}
// } }
isCompact: false,
// The useArrowFunction is true only takes effect when isCompact is false
useArrowFunction: true,
},
};Download this repo first (see TRY IT) if not yet, then:
npm testBooms is based on Node.js native TCP socket, much faster than other RPC frameworks based on gRPC or MQ. (See RPC Frameworks Performance PK)
With Booms, you can require the remote services and call the remote functions as same as you do it at local. That is, you can easily disassemble a project, move any sub module directory to any other location and load it as a microservices any time without adjust any code in parent module.
- Why Enterprises Are Embracing Microservices and Node.js
- Microservices With Node.js: Scalable, Superior, and Secure Apps
Copyright (c) 2019, Owen Luke