詳解 Node.Js 中實現埠重用原理

西門吹牛發表於2019-02-16
Node.js

起源，從官方例項中看多程式共用埠

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
`);
  }).listen(8000);

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

執行結果：

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

瞭解http.js模組：

  • 我們都只有要建立一個http服務，必須引用http模組,http模組最終會呼叫net.js實現網路服務
// 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);
}
 ...

答案很快就可以通過cluster._getServer 這個函式找到

  • 代理了server._listen2 這個方法在work程式的執行操作
  • 向master傳送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;

// 傳送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);
  }
*/

master程式收到queryServer訊息後進行啟動服務

  • 如果地址沒被監聽過，通過RoundRobinHandle監聽開啟服務
  • 如果地址已經被監聽，直接繫結handel到已經監聽到服務上，去消費請求
// 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);
    });
}

看到這一步，已經很明顯，我們知道了多進行埠共享的實現原理

  • 其實埠僅由master程式中的內部TCP伺服器監聽了一次
  • 因為net.js 模組中會判斷當前的程式是master還是Worker程式
  • 如果是Worker程式呼叫cluster._getServer 去hack原生的listen 方法
  • 所以在child呼叫的listen方法，是一個return 0 的空方法，所以不會報埠占用錯誤

那現在問題來了，既然Worker程式是如何獲取到master程式監聽服務接收到的connect呢？

  • 監聽master程式啟動的TCP伺服器的connection事件
  • 通過輪詢挑選出一個worker
  • 向其傳送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;
        // 監聽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);
    });
};

下面讓我們看看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);
}

總結

  • net模組會對程式進行判斷，是worker 還是master, 是worker的話進行hack net.Server例項的listen方法
  • worker 呼叫的listen 方法是hack掉的，直接return 0,不過會向master註冊一個connection接手的事件
  • master 收到客戶端connection事件後，會輪詢向worker傳送connection上來的客戶端控制程式碼
  • worker收到master傳送過來客戶端的控制程式碼，這時候就可以處理客戶端請求了

分享出於共享學習的目的，如有錯誤，歡迎大家留言指導，不喜勿噴。

相關文章