Node.Js中實現(xiàn)端口重用原理詳解

更新時間：2018年05月03日 14:30:44 作者：G_Doe

這篇文章主要介紹了Node.Js中實現(xiàn)端口重用原理詳解，小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧

本文介紹了Node.Js中實現(xiàn)端口重用原理詳解，分享給大家，具體如下：

起源，從官方實例中看多進程共用端口

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('exit', (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`);
}

執(zhí)行結果：

$ node server.js
Master 3596 is running
Worker 4324 started
Worker 4520 started
Worker 6056 started
Worker 5644 started

了解http.js模塊：

我們都只有要創(chuàng)建一個http服務，必須引用http模塊,http模塊最終會調用net.js實現(xiàn)網(wǎng)絡服務

// 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,細心的人一定會發(fā)現(xiàn)為什么是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,并且監(jiān)聽，
// 現(xiàn)在是不是很好奇_getServer方法做了什么
 cluster._getServer(server, serverQuery, listenOnMasterHandle);
}
 ...

答案很快就可以通過cluster._getServer 這個函數(shù)找到

代理了server._listen2 這個方法在work進程的執(zhí)行操作
向master發(fā)送queryServer消息，向master注冊一個內部TCP服務器

// 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;

// 發(fā)送queryServer消息給master進程，master 在收到這個消息后，會創(chuàng)建一個開始一個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 函數(shù)是net.js 中的listenOnMasterHandle 方法
  cb(0, handle);
}
// lib/net.js
/*
function listenOnMasterHandle(err, handle) {
  err = checkBindError(err, port, handle);
  server._handle = handle;
  // _listen2 函數(shù)中,調用的handle.listen方法，也就是上面被hack的listen
  server._listen2(address, port, addressType, backlog, fd);
 }
*/

master進程收到queryServer消息后進行啟動服務

如果地址沒被監(jiān)聽過，通過RoundRobinHandle監(jiān)聽開啟服務
如果地址已經(jīng)被監(jiān)聽，直接綁定handel到已經(jīng)監(jiān)聽到服務上，去消費請求

// 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];

  // 如果地址沒被監(jiān)聽過，通過RoundRobinHandle監(jiān)聽開啟服務
  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);
  }

  // 如果地址已經(jīng)被監(jiān)聽，直接綁定handel到已經(jīng)監(jiān)聽到服務上，去消費請求
  // 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);
  });
}

看到這一步，已經(jīng)很明顯，我們知道了多進行端口共享的實現(xiàn)原理

其實端口僅由master進程中的內部TCP服務器監(jiān)聽了一次
因為net.js 模塊中會判斷當前的進程是master還是Worker進程
如果是Worker進程調用cluster._getServer 去hack原生的listen 方法
所以在child調用的listen方法，是一個return 0 的空方法，所以不會報端口占用錯誤

那現(xiàn)在問題來了，既然Worker進程是如何獲取到master進程監(jiān)聽服務接收到的connect呢？

監(jiān)聽master進程啟動的TCP服務器的connection事件
通過輪詢挑選出一個worker
向其發(fā)送newconn內部消息，消息體中包含了客戶端句柄
有了句柄，誰都知道要怎么處理了哈哈

// 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;
    // 監(jiān)聽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進程其發(fā)送newconn內部消息和客戶端的句柄handle
  sendHelper(worker.process, message, handle, (reply) => {
  // ...
    this.handoff(worker);
  });
};

下面讓我們看看Worker進程接收到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);
}

總結