Comment implémenter la fonction de réutilisation des ports dans Node.Js

Cette fois, je vais vous montrer comment implémenter la fonction de réutilisation de port dans Node.Js, et quelles sont les précautions pour implémenter la fonction de réutilisation de port dans Node.Js. Voici un cas pratique. Jetons un coup d’œil.

Origine, voir port partagé multi-processus depuis l'instance officielle

const cluster = require('cluster');
const http = require('http');
const numCPUs = require('os').cpus().length;
if (cluster.isMaster) {
 console.log(`Master ${process.pid} is running`);
 for (let i = 0; i < numCPUs; i++) {
  cluster.fork();
 }
 cluster.on(&#39;exit&#39;, (worker, code, signal) => {
  console.log(`worker ${worker.process.pid} died`);
 });
} else {
 http.createServer((req, res) => {
  res.writeHead(200);
  res.end('hello world\n');
 }).listen(8000);
 console.log(`Worker ${process.pid} started`);
}

Résultat de l'exécution :

$ node server.js
Master 3596 est en cours d'exécution
Worker 4324 démarré
Worker 4520 démarré
Worker 6056 démarré
Worker 5644 démarré

Comprendre le module http.js :

Nous avons tous pour créer Un service http doit référencer le module http. Le module http finira par appeler net.js pour implémenter le service réseau

// lib/net.js
'use strict';
 ...
Server.prototype.listen = function(...args) {
  ...
 if (options instanceof TCP) {
   this._handle = options;
   this[async_id_symbol] = this._handle.getAsyncId();
   listenInCluster(this, null, -1, -1, backlogFromArgs); // 注意这个方法调用了cluster模式下的处理办法
   return this;
  }
  ...
};
function listenInCluster(server, address, port, addressType,backlog, fd, exclusive) {
// 如果是master 进程或者没有开启cluster模式直接启动listen
if (cluster.isMaster || exclusive) {
  //_listen2,细心的人一定会发现为什么是listen2而不直接使用listen
 // _listen2 包裹了listen方法，如果是Worker进程，会调用被hack后的listen方法，从而避免出错端口被占用的错误
  server._listen2(address, port, addressType, backlog, fd);
  return;
 }
 const serverQuery = {
  address: address,
  port: port,
  addressType: addressType,
  fd: fd,
  flags: 0
 };
// 是fork 出来的进程，获取master上的handel,并且监听，
// 现在是不是很好奇_getServer方法做了什么
 cluster._getServer(server, serverQuery, listenOnMasterHandle);
}
 ...

La réponse pourra être trouvée prochainement via le cluster. Fonction _getServer

1. Serveur proxy._listen2 Cette méthode effectue des opérations dans le processus de travail

2. Envoie un message queryServer au maître et enregistre un TCP interne serveur avec le maître

// lib/internal/cluster/child.js
cluster._getServer = function(obj, options, cb) {
 // ...
 const message = util._extend({
  act: 'queryServer',  // 关键点：构建一个queryServer的消息
  index: indexes[indexesKey],
  data: null
 }, options);
 message.address = address;
// 发送queryServer消息给master进程，master 在收到这个消息后，会创建一个开始一个server，并且listen
 send(message, (reply, handle) => {
   rr(reply, indexesKey, cb);       // Round-robin.
 });
 obj.once('listening', () => {
  cluster.worker.state = 'listening';
  const address = obj.address();
  message.act = 'listening';
  message.port = address && address.port || options.port;
  send(message);
 });
};
 //...
 // Round-robin. Master distributes handles across workers.
function rr(message, indexesKey, cb) {
  if (message.errno) return cb(message.errno, null);
  var key = message.key;
  // 这里hack 了listen方法
  // 子进程调用的listen方法，就是这个，直接返回0，所以不会报端口被占用的错误
  function listen(backlog) {
    return 0;
  }
  // ...
  const handle = { close, listen, ref: noop, unref: noop };
  handles[key] = handle;
  // 这个cb 函数是net.js 中的listenOnMasterHandle 方法
  cb(0, handle);
}
// lib/net.js
/*
function listenOnMasterHandle(err, handle) {
  err = checkBindError(err, port, handle);
  server._handle = handle;
  // _listen2 函数中,调用的handle.listen方法，也就是上面被hack的listen
  server._listen2(address, port, addressType, backlog, fd);
 }
*/

Le processus maître démarre le service après réception du message queryServer

1. Si l'adresse n'a pas été surveillée, démarrez le service via la surveillance RoundRobinHandle

2. Si l'adresse a été surveillée, liez directement le handle au service qui a été surveillé et allez consommer la demande

// lib/internal/cluster/master.js
function queryServer(worker, message) {
  const args = [
    message.address,
    message.port,
    message.addressType,
    message.fd,
    message.index
  ];
  const key = args.join(':');
  var handle = handles[key];
  // 如果地址没被监听过，通过RoundRobinHandle监听开启服务
  if (handle === undefined) {
    var constructor = RoundRobinHandle;
    if (schedulingPolicy !== SCHED_RR ||
      message.addressType === 'udp4' ||
      message.addressType === 'udp6') {
      constructor = SharedHandle;
    }
    handles[key] = handle = new constructor(key,
      address,
      message.port,
      message.addressType,
      message.fd,
      message.flags);
  }
  // 如果地址已经被监听，直接绑定handel到已经监听到服务上，去消费请求
  // Set custom server data
  handle.add(worker, (errno, reply, handle) => {
    reply = util._extend({
      errno: errno,
      key: key,
      ack: message.seq,
      data: handles[key].data
    }, reply);
    if (errno)
      delete handles[key]; // Gives other workers a chance to retry.
    send(worker, reply, handle);
  });
}

Vu cette étape, c'est déjà très simple. Evidemment, on connaît le principe de mise en œuvre du partage multi-port

1. En fait, le port est seulement écouté. une fois par le serveur TCP interne dans le processus maître

2. Parce que le module net.js déterminera si le processus actuel est un processus maître ou un processus Worker

3. Si le processus Worker appelle cluster._getServer, piratez la méthode d'écoute native

4. Donc la méthode d'écoute appelée dans l'enfant est une méthode vide qui renvoie 0, donc l'erreur d'occupation du port ne sera pas signalé

Maintenant, la question est, puisque comment se déroule le processus Worker Comment obtenir la connexion reçue par le service d'écoute du processus maître ?

1. Écoutez l'événement de connexion du serveur TCP démarré par le processus maître

2. Sélectionnez un travailleur via un sondage

3. Envoyez-lui un message interne à newconn, le corps du message contient le handle du client

4. Avec le handle, tout le monde sait quoi faire haha

// lib/internal/cluster/round_robin_handle.js
function RoundRobinHandle(key, address, port, addressType, fd) {
  this.server = net.createServer(assert.fail);
  if (fd >= 0)
    this.server.listen({ fd });
  else if (port >= 0)
    this.server.listen(port, address);
  else
    this.server.listen(address); // UNIX socket path.
  this.server.once('listening', () => {
    this.handle = this.server._handle;
    // 监听onconnection方法
    this.handle.onconnection = (err, handle) => this.distribute(err, handle);
    this.server._handle = null;
    this.server = null;
  });
}
RoundRobinHandle.prototype.add = function (worker, send) {
  // ...
};
RoundRobinHandle.prototype.remove = function (worker) {
  // ...
};
RoundRobinHandle.prototype.distribute = function (err, handle) {
  // 负载均衡地挑选出一个worker
  this.handles.push(handle);
  const worker = this.free.shift();
  if (worker) this.handoff(worker);
};
RoundRobinHandle.prototype.handoff = function (worker) {
  const handle = this.handles.shift();
  const message = { act: 'newconn', key: this.key };
  // 向work进程其发送newconn内部消息和客户端的句柄handle
  sendHelper(worker.process, message, handle, (reply) => {
  // ...
    this.handoff(worker);
  });
};

Voyons quelles opérations le processus Worker a effectuées après avoir reçu le message newconn

// lib/child.js
function onmessage(message, handle) {
  if (message.act === 'newconn')
   onconnection(message, handle);
  else if (message.act === 'disconnect')
   _disconnect.call(worker, true);
 }
// Round-robin connection.
// 接收连接，并且处理
function onconnection(message, handle) {
 const key = message.key;
 const server = handles[key];
 const accepted = server !== undefined;
 send({ ack: message.seq, accepted });
 if (accepted) server.onconnection(0, handle);
}

Résumé

1. Le module net jugera le processus, qu'il s'agisse d'un travailleur ou d'un maître. S'il s'agit d'un travailleur, piratez la méthode d'écoute de l'instance net.Server

2. La méthode d'écoute appelée par le travailleur est piratée et renvoie 0 directement, mais un événement de connexion sera enregistré auprès du maître

3. Après que le maître ait reçu l'événement de connexion client, il interrogera le travailleur Enverra le handle client depuis la connexion

4. Le travailleur reçoit le handle client envoyé par le maître, puis il peut traiter la demande du client

Je pense que vous maîtrisez la méthode après avoir lu le cas dans cet article. Pour des informations plus intéressantes, veuillez prêter attention aux autres articles connexes sur le site Web PHP chinois !

Lecture recommandée :

Analyse pratique du projet de liaison bidirectionnelle Vue.js

Comment jquery détermine que le contenu de l'élément est vide

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!