Explication détaillée du principe de réutilisation des ports dans Node.Js

Cet article présente principalement l'explication détaillée du principe de réutilisation des ports dans Node.Js. Il a une certaine valeur de référence. Maintenant, je le partage avec vous. Les amis dans le besoin peuvent s'y référer

Cet article présente. Node.Js Une explication détaillée du principe de réutilisation des ports est partagée avec tout le monde. Les détails sont les suivants :

Origine, voir les ports partagés multi-processus à partir d'exemples officiels

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(&#39;hello world\n&#39;);
 }).listen(8000);

 console.log(`Worker ${process.pid} started`);
}

Résultat de l'exécution :

$ node server.js
Le maître 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 seulement besoin de créer un service http et de référencer le module http. Le module http finira par appeler net.js pour implémenter les services 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 peut être trouvée rapidement grâce à la fonction cluster._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 serveur TCP interne auprès du 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 avoir reçu le 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 surveillé et consommez 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);
  });
}

Au vu de cette étape, il est évident que l'on connaît le principe de mise en œuvre du partage multi-port

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

2. Car le module net.js déterminera si le processus actuel est un maître ou un Processus de travail

3. S'il s'agit d'un processus de travail, appelez cluster._getServer pour pirater la méthode d'écoute native

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

Maintenant la question se pose, puisque comment le processus Worker obtient-il 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. net .La méthode d'écoute de l'instance du serveur

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

3. Une fois que le maître a reçu l'événement de connexion client, il interrogera et enverra le handle client de la connexion au travailleur

4. Le travailleur reçoit le handle client envoyé par master À ce stade, les demandes des clients peuvent être traitées

Recommandations associées :

Le nœud implémente un serveur de ressources statiques

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!