代码

Node 版本： 8.9.4

const server = new net.Server((socket) => {
  console.log(socket);
});

server.listen('1234', () => {
  console.log('server started at 1234');
});

�

Socket

服务器 socket 是用于监听连接而不是发起连接，其生命周期通常由创建，绑定，监听，连接，关闭组成的。

为了便于说明，把上面代码划分为四块：

1) new net.Server()
2) socket => console.log(socket)
3) server.listen()
4) () => console.log('server started at 1234')

服务器启动流程

运行代码, 我们可以通过 lsof 看到一个 socket 处于 LISTEN 状态, 这就是服务器 socket.

$ lsof -i tcp:1234

COMMAND   PID    USER   FD   TYPE             DEVICE SIZE/OFF NODE NAME
node    64852 i312714   14u  IPv6 0xe781f0e6b2c52e5b      0t0  TCP *:search-agent (LISTEN)

在代码块1 我们初始化了 net.Server()，具体代码在 net.js L1176, 这里为了精简文章，只贴出了关键代码，后面都会只贴出关键代码。

function Server(options, connectionListener) {
  this.on('connection', connectionListener);
  this._connections = 0;

  this[async_id_symbol] = -1;
  this._handle = null;
  this._usingWorkers = false;
  this._workers = [];
  this._unref = false;

  this.allowHalfOpen = options.allowHalfOpen || false;
  this.pauseOnConnect = !!options.pauseOnConnect;
}
util.inherits(Server, EventEmitter);

这里先是注册了 connection 的事件监听回调 connectionListener，也就是代码块2

然后初始化了 _handle, _usingWorkers, _workers, _unref 等属性

并且让 Server 继承 EventEmitter

服务器监听

按照代码运行顺序，下一步是执行代码块3，调用了server.listen，源代码代码在 net.js L1411

Server.prototype.listen = function(...args) {
  var normalized = normalizeArgs(args);
  var options = normalized[0];
  var cb = normalized[1];

  var backlog;
  if (typeof options.port === 'number' || typeof options.port === 'string') {
    if (!isLegalPort(options.port)) {
      throw new ERR_SOCKET_BAD_PORT(options.port);
    }
    backlog = options.backlog || backlogFromArgs;
    // start TCP server listening on host:port
    if (options.host) {
      lookupAndListen(this, options.port | 0, options.host, backlog,
                      options.exclusive);
    } else { // Undefined host, listens on unspecified address
      // Default addressType 4 will be used to search for master server
      listenInCluster(this, null, options.port | 0, 4,
                      backlog, undefined, options.exclusive);
    }
    return this;
  }
};

省略中间代码追述，调用了 setupListenHandle

function setupListenHandle(address, port, addressType, backlog, fd) {
  rval = createServerHandle(address, port, addressType, fd);
  this._handle = rval;
  this[async_id_symbol] = getNewAsyncId(this._handle);
  this._handle.onconnection = onconnection;
  this._handle.owner = this;

  this._handle.listen(backlog || 511);
}

关键代码第一步是 createServerHandle, 源代码如下

function createServerHandle(address, port, addressType, fd) {
  handle = new TCP(TCPConstants.SERVER);
  isTCP = true;
  err = handle.bind(address, port);
  return handle;
}

重点来了:

TCP 是从 tcp_wrap 模块中引入的，tcp_wrap 是一个C++写的Node模块, TCPWrap 的继承链是 TCPWrap < ConnectionWrap < LibuvStreamWrap < HandleWrap, StreamBase < HandleWrap

在 tcp_wrap 的 Initialize 中定义了 TCP 的 open, bind, listen 等方法

createServerHandle 中的 new TCP() 是调用 tcp_wrap TCPWrap::New, 最后会返回一个 TCPWrap 的实例, 这里主要是初始化了 libuv 中 uv_handle_t

handle.bind() 调用 TCPWrap::Bind, 这里调用了 libuv 中 uv__tcp_bind 这里给之前初始化的 handle 设置了 socket, 并且绑定了host，port等信息

这时候在js中访问 handle.fd 就会返回真实的文件描述符，应该与 lsof 中看到的 FD 一致的

回到 setupListenHandle 中

handle.onconnection = onconnection 这个稍后解释

handle.listen() 调用了 TCPWrap::Listen, 这里调用了 libuv 中的 uv_listen(uv_tcp_listen)，最终调用系统的 listen 方法, 并且注册了 uv__server_io 回调

以上完成了Socket 的创建，绑定和监听。

服务器连接

服务器接收连接之后就会触发代码块2，在代码块2中就可以拿到连接socket，从中可以读取数据或者写入数据。

在 new net.Server() 时，这个回调作为 connection 事件绑定到 server 上。

在创建服务器socket的时候，this._handle.onconnection = onconnection 这个onconnection 就会最终 emit connection 事件。

function onconnection(err, clientHandle) {
  var handle = this;
  var self = handle.owner;

  var socket = new Socket({
    handle: clientHandle,
    allowHalfOpen: self.allowHalfOpen,
    pauseOnCreate: self.pauseOnConnect
  });
  socket.readable = socket.writable = true;


  self._connections++;
  socket.server = self;
  socket._server = self;
  self.emit('connection', socket);
}

回到调用 uv_listen 的时候的代码

  int err = uv_listen(reinterpret_cast<uv_stream_t*>(&wrap->handle_),
                      backlog,
                      OnConnection);

这里的 OnConnection 其实是 ConnectionWrap<WrapType, UVType>::OnConnection 这个方法，这个方法里面会调用 js 的 onconnection 回调。

OnConnection 这个方法里面生成了新的 socket 并且赋值给了 argv 最终传递给了 onconnection

template <typename WrapType, typename UVType>
void ConnectionWrap<WrapType, UVType>::OnConnection(uv_stream_t* handle,
                                                    int status) {
  ...
  ...

  if (status == 0) {
    // Instantiate the client javascript object and handle.
    Local<Object> client_obj = WrapType::Instantiate(env,
                                                     wrap_data,
                                                     WrapType::SOCKET);

    WrapType* wrap;
    ASSIGN_OR_RETURN_UNWRAP(&wrap, client_obj);
    uv_stream_t* client_handle =
        reinterpret_cast<uv_stream_t*>(&wrap->handle_);

    if (uv_accept(handle, client_handle))
      return;

    argv[1] = client_obj;
  }
  // connection_string 就是 "onconnection"
  wrap_data->MakeCallback(env->onconnection_string(), arraysize(argv), argv); 
}

到这里基本说明了Node在连接时候的代码逻辑。后面也会继续整理一下关于socket close的代码。