深入学习 Node.js Net

$ nc -U /tmp/echo.sock # -U — Use UNIX domain socket

// 创建socket服务器
const net = require("net");
let clients = 0;

const server = net.createServer(client => {
  clients++;
  let clientId = clients;
  console.log("Client connect:", clientId);

  client.on("end", () => {
    console.log("Client disconnected:", clientId);
  });

  client.write("Welcome client: " + clientId + " \r\n");
  client.pipe(client); // 把客户端的数据返回给客户端
});

server.listen(8000, () => {
  console.log("Server started on port 8000");
});

// 创建socket客户端
const net = require("net");

const client = net.connect(8000);

client.on("data", data => {
  console.log(data.toString());
});

client.on("end", () => {
  console.log("Client disconnected");
});

// 创建socket服务器
const net = require("net");
let clients = 0;

const server = net.createServer(client => {
  // 参考net基本使用相关代码
});

server.listen(8000, () => {
  console.log("Server started on port 8000");
});

function createServer(options, connectionListener) {
  return new Server(options, connectionListener);
}

function Server(options, connectionListener) {
  if (!(this instanceof Server)) // 确保以new形式调用构造函数
    return new Server(options, connectionListener);

  EventEmitter.call(this);

  if (typeof options === 'function') {
    connectionListener = options;
    options = {};
    this.on('connection', connectionListener);
  } else if (options == null || typeof options === 'object') {
    options = options || {};

    if (typeof connectionListener === 'function') {
      this.on('connection', connectionListener);
    }
  }

  this._connections = 0;
  this._handle = null;
}
util.inherits(Server, EventEmitter);

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

  // 判断是否超过最大连接数
  if (self.maxConnections && self._connections >= self.maxConnections) {
    clientHandle.close();
    return;
  }

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


  self._connections++;

  self.emit('connection', socket);
}

Server.prototype._listen2 = setupListenHandle;

server.listen(8000, () => {
  console.log("Server started on port 8000");
});

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

  var hasCallback = (cb !== null);
  if (hasCallback) {
    this.once('listening', cb);
  }

  options = options._handle || options.handle || options;
  
  var backlog; 
  // options.port：8000
  if (typeof options.port === 'number' || typeof options.port === 'string') {
    // 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;
  }
};

function listenInCluster(server, address, port, addressType,
                         backlog, fd, exclusive) {
  // 如果exclusive是false（默认），则集群的所有进程将使用相同的底层句柄，允许共享连接处理任务。
  // 如果exclusive是true，则句柄不会被共享，如果尝试端口共享将导致错误。
  exclusive = !!exclusive;

  // 引入cluster(集群)模块
  // Node.js在单个线程中运行单个实例。 用户(开发者)为了使用现在的多核系统，有时候,
  // 用户(开发者)会用一串Node.js进程去处理负载任务。
  if (cluster === null) cluster = require('cluster');

  // 当该进程是主进程时，返回true。
  if (cluster.isMaster || exclusive) {
    // Will create a new handle
    // _listen2 sets up the listened handle, it is still named like this
    // to avoid breaking code that wraps this method
    server._listen2(address, port, addressType, backlog, fd);
    return;
  }
}

// Server.prototype._listen2 = setupListenHandle; 
function setupListenHandle(address, port, addressType, backlog, fd) {
  if (this._handle) {
    debug('setupListenHandle: have a handle already');
  } else {
    debug('setupListenHandle: create a handle');
    
    var rval = null;
    if (rval === null)
      rval = createServerHandle(address, port, addressType, fd);
    this._handle = rval;
  }

  // 此处绑定onconnection函数
  this._handle.onconnection = onconnection;
}

function createServerHandle(address, port, addressType, fd) {
  var handle;

  var isTCP = false;
  // server.listen(handle[, backlog][, callback])
  // 启动一个服务器，监听已经绑定到端口、UNIX域套接字或Windows命名管道的给定句柄上的连接。
  // 句柄对象可以是服务器、套接字（任何具有底层_handle成员的东西），也可以是含有fd成员的对象，
  // 该成员是一个有效的文件描述符。
  if (typeof fd === 'number' && fd >= 0) {
    try {
      handle = createHandle(fd, true);
    } catch (e) {
      // Not a fd we can listen on.  This will trigger an error.
      debug('listen invalid fd=%d:', fd, e.message);
      return UV_EINVAL;
    }
    handle.open(fd);
    handle.readable = true;
    handle.writable = true;
  } else if (port === -1 && addressType === -1) { // 处理UNIX domain socket或Windows pipe
    handle = new Pipe(PipeConstants.SERVER);
  } else {
    handle = new TCP(TCPConstants.SERVER); // 创建TCP服务
    isTCP = true;
  }
  return handle;
}

function createHandle(fd, is_server) {
  // 基于文件描述符确认handle的类型，TTY(文本终端)
  const type = TTYWrap.guessHandleType(fd);
  if (type === 'PIPE') {
    return new Pipe(
      is_server ? PipeConstants.SERVER : PipeConstants.SOCKET
    );
  }

  if (type === 'TCP') {
    return new TCP(
      is_server ? TCPConstants.SERVER : TCPConstants.SOCKET
    );
  }
}

const { TCP, constants: TCPConstants } = process.binding('tcp_wrap');
const { Pipe, constants: PipeConstants } = process.binding('pipe_wrap');

const net = require("net");
const server = net.createServer(c => {
  c.on("end", () => {
    console.log("client disconnected");
  });
  c.write("hello\r\n");
  c.pipe(c);
});
server.on("error", err => {
  throw err;
});
// server.listen(path[, backlog][, callback]) for IPC servers
server.listen("/tmp/echo.sock", () => {
  console.log("server bound");
});

$ nc -U /tmp/echo.sock

➜  ~ nc -U /tmp/echo.sock
hello
semlinker
semlinker
i love node
i love node