node.js - español - nodejs documents

NodeJS | Cluster: ¿Cómo enviar datos del maestro a todos o a un solo hijo/trabajador?

Question

Tengo script de trabajo (stock) de node

var cluster = require(''cluster'');
var http = require(''http'');
var numReqs = 0;

if (cluster.isMaster) {
  // Fork workers.
  for (var i = 0; i < 2; i++) {
    var worker = cluster.fork();

    worker.on(''message'', function(msg) {
      if (msg.cmd && msg.cmd == ''notifyRequest'') {
        numReqs++;
      }
    });
  }

  setInterval(function() {
    console.log("numReqs =", numReqs);
  }, 1000);
} else {
  // Worker processes have a http server.
  http.Server(function(req, res) {
    res.writeHead(200);
    res.end("hello world/n");
    // Send message to master process
    process.send({ cmd: ''notifyRequest'' });
  }).listen(8000);
}

En el script anterior, puedo enviar datos del trabajador al proceso maestro con facilidad. Pero, ¿cómo enviar datos del maestro al trabajador / trabajadores? Con ejemplos, si es posible.

Answer 1

Así es como implementé una solución a un problema similar. Al enganchar en cluster.on(''fork'') , puede adjuntar manejadores de mensajes a los trabajadores cuando están bifurcados (en lugar de almacenarlos en una matriz), lo que tiene la ventaja adicional de tratar casos en los que los trabajadores mueren o se desconectan y una nueva trabajador está bifurcado.

Este fragmento enviaría un mensaje del maestro a todos los trabajadores.

if (cluster.isMaster) {
    for (var i = 0; i < require(''os'').cpus.length; i++) {
        cluster.fork();
    }

    cluster.on(''disconnect'', function(worker) {
        cluster.fork();
    }

    // When a new worker process is forked, attach the handler
    // This handles cases where new worker processes are forked
    // on disconnect/exit, as above.
    cluster.on(''fork'', function(worker) {
        worker.on(''message'', messageRelay);
    }

    var messageRelay = function(msg) {
        Object.keys(cluster.workers).forEach(function(id) {
            cluster.workers[id].send(msg);
        });
    };
}
else {
    process.on(''message'', messageHandler);

    var messageHandler = function messageHandler(msg) {
        // Worker received message--do something
    };
}

Answer 2

Debería poder enviar un mensaje del maestro al trabajador así:

worker.send({message:''hello''})

porque "cluster.fork se implementa encima de child_process.fork" (cluster.fork se implementa encima de child_process.fork)

Answer 3

Debido a que cluster.fork se implementa sobre child_process.fork , puede enviar mensajes de un maestro al trabajador utilizando worker.send({ msg: ''test'' }) , y de un trabajador a un maestro por process.send({ msg: ''test'' }); . Recibe los mensajes así: worker.on(''message'', callback) (de worker a master) y process.on(''message'', callback); (de maestro a trabajador).

Aquí está mi ejemplo completo, puede probarlo navegando en http://localhost:8000/ Luego el trabajador enviará un mensaje al maestro y el maestro responderá:

var cluster = require(''cluster'');
var http = require(''http'');
var numReqs = 0;
var worker;

if (cluster.isMaster) {
  // Fork workers.
  for (var i = 0; i < 2; i++) {
    worker = cluster.fork();

    worker.on(''message'', function(msg) {
      // we only want to intercept messages that have a chat property
      if (msg.chat) {
        console.log(''Worker to master: '', msg.chat);
        worker.send({ chat: ''Ok worker, Master got the message! Over and out!'' });
      }
    });

  }
} else {
  process.on(''message'', function(msg) {
    // we only want to intercept messages that have a chat property
    if (msg.chat) {
      console.log(''Master to worker: '', msg.chat);
    }
  });
  // Worker processes have a http server.
  http.Server(function(req, res) {
    res.writeHead(200);
    res.end("hello world/n");
    // Send message to master process
    process.send({ chat: ''Hey master, I got a new request!'' });
  }).listen(8000);
}

Answer 4

Encontré este hilo mientras buscaba una forma de enviar un mensaje a todos los procesos secundarios y, afortunadamente, pude resolverlo gracias a los comentarios sobre los arreglos. Solo quería ilustrar una solución potencial para enviar un mensaje a todos los procesos secundarios que utilizan este enfoque.

var cluster = require(''cluster'');
var http = require(''http'');
var numReqs = 0;
var workers = [];

if (cluster.isMaster) {
  // Broadcast a message to all workers
  var broadcast = function() {
    for (var i in workers) {
      var worker = workers[i];
      worker.send({ cmd: ''broadcast'', numReqs: numReqs });
    }
  }

  // Fork workers.
  for (var i = 0; i < 2; i++) {
    var worker = cluster.fork();

    worker.on(''message'', function(msg) {
      if (msg.cmd) {
        switch (msg.cmd) {
          case ''notifyRequest'':
            numReqs++;
          break;
          case ''broadcast'':
            broadcast();
          break;
        }
    });

    // Add the worker to an array of known workers
    workers.push(worker);
  }

  setInterval(function() {
    console.log("numReqs =", numReqs);
  }, 1000);
} else {
  // React to messages received from master
  process.on(''message'', function(msg) {
    switch(msg.cmd) {
      case ''broadcast'':
        if (msg.numReqs) console.log(''Number of requests: '' + msg.numReqs);
      break;
    }
  });

  // Worker processes have a http server.
  http.Server(function(req, res) {
    res.writeHead(200);
    res.end("hello world/n");
    // Send message to master process
    process.send({ cmd: ''notifyRequest'' });
    process.send({ cmd: ''broadcast'' });
  }).listen(8000);
}

Answer 5

Entiendo su propósito de transmitir a todos los procesos de trabajo de nodo en un clúster, aunque no puede enviar el componente de socket como tal, pero hay una solución alternativa para el propósito que se debe atender. Voy a intentar una explicación con un ejemplo:

Paso 1: Cuando una acción del cliente requiere una transmisión:

Child.js (Process that has been forked) :

socket.on("BROADCAST_TO_ALL_WORKERS", function (data) 
{
    process.send({cmd : ''BROADCAST_TO_ALL_WORKERS'', message :data.message});
}) 

Paso 2: en el lado de la creación del cluster

Server.js (Place where cluster forking happens):

if (cluster.isMaster) {

  for (var i = 0; i < numCPUs; i++) {

    var worker = cluster.fork();

    worker.on(''message'', function (data) {
     if (data.cmd === "BROADCAST_TO_ALL_WORKERS") {
       console.log(server_debug_prefix() + "Server Broadcast To All, Message : " + data.message + " , Reload : " + data.reload + " Player Id : " + data.player_id);
        Object.keys(cluster.workers).forEach(function(id) {
            cluster.workers[id].send({cmd : "BROADCAST_TO_WORKER", message : data.message});
        });
      }
    });
  }

  cluster.on(''exit'', function (worker, code, signal) {
    var newWorker = cluster.fork();
    newWorker.on(''message'', function (data) {
      console.log(data);
      if (data.cmd === "BROADCAST_TO_ALL_WORKERS") {
        console.log(data.cmd,data);
        Object.keys(cluster.workers).forEach(function(id) {
            cluster.workers[id].send({cmd : "BROADCAST_TO_WORKER", message : data.message});
        });
      }
    });
  });
} 
else {
  //Node Js App Entry
  require("./Child.js");
}

Paso 3: Transmitir en el proceso hijo -

-> Ponga esto antes de io.on ("connection") en Child.js

process.on("message", function(data){
    if(data.cmd === "BROADCAST_TO_WORKER"){
        io.sockets.emit("SERVER_MESSAGE", { message: data.message, reload: data.reload, player_id : data.player_id });
    }
});

Espero que esto ayude. Por favor, hágamelo saber si se requiere más aclaración.