2018 year 11 month 19 Japan

Multi process model

Master：

Under this model ,Master The process undertakes the work of process management （ similar pm2）, Don't run any business code , We just need to run a Master Process, it will help us deal with all Worker、Agent The initialization and restart of the process .

Master The stability of the process is extremely high , When running online, we just need to pass egg-scripts Background operation passed egg.startCluster Starting up Master The process is OK , No need to use pm2 Wait for the process daemons .

Agent：

In most cases , When we write business code, we don't have to consider Agent The existence of processes , But when we come across some scenes , When you just want the code to run on a process ,Agent It's time for the process to work .

because Agent only one , And will be responsible for a lot of dirty work to maintain the connection , So it can't hang up and restart easily , therefore Agent The process will not exit when it listens for uncapped exceptions , But it will print out the error log , We need to be alert to uncapped exceptions in the log .

Worker：

Worker The process is responsible for handling real user requests and Timing task To deal with . and Egg The timed task also provides only one Worker The ability of a process to run , Therefore, the problems that can be solved through scheduled tasks should not be put into Agent On the implementation .

Worker Running business code , Relative ratio Agent and Master The code running on the process is more complex , The stability is also a little lower , When Worker When the process exits abnormally ,Master The process will restart a Worker process .

'use strict';
const cluster = require('cluster');

if (cluster.isMaster) {
    
  const worker = cluster.fork();
  worker.send('hi there');
  worker.on('message', msg => {
    
    console.log(`msg: ${
      msg} from worker#${
      worker.id}`);
  });
} else if (cluster.isWorker) {
    
  process.on('message', (msg) => {
    
    process.send(msg);
  });
}

• app.messenger.broadcast(action, data)： Send it to all agent / app process （ Including myself ）
• app.messenger.sendToApp(action, data): Send it to all app process
  • stay app Calling this method will send it to yourself and others app process
  • stay agent Calling this method will be sent to all app process
• app.messenger.sendToAgent(action, data) : Send to agent process
  • stay app Calling this method will send to agent process
  • stay agent Calling this method will send to agent own
• agent.messenger.sendRandom(action, data):
  • app There is no such method on （ Now? Egg The implementation of is equivalent to sentToAgent）
  • agent Will send a random message to app process （ from master To control who to send ）
• app.messenger.sendTo(pid, action, data): Send to the specified process

// app.js
module.exports = app => {
    
  //  Be careful , Only in  egg-ready  The message cannot be sent until the event is received 
  app.messenger.once('egg-ready', () => {
    
    app.messenger.sendToAgent('agent-event', {
     foo: 'bar' });
    app.messenger.sendToApp('app-event', {
     foo: 'bar' });
  });
}

egg-ready：

The above example mentioned , Need to wait egg-ready The message cannot be sent until the message is sent . Only in Master Make sure all the Agent The process and Worker All processes have started successfully （ and ready） after , Will pass messenger send out egg-ready News to all Agent and Worker, Tell me everything is ready ,IPC The channel is ready to use .

Accept ：

stay message Listen for the corresponding action event , You can accept the information sent by other processes .

app.messenger.on(action, data => {
    
  // process data
});
app.messenger.once(action, data => {
    
  // process data
});