Nodejs Socket连接池及TCP HTTP网络模型详解

#vi /etc/security/limits.conf
*　　soft　　nofile　　65536
*　　hard　　nofile　　65536

vi /etc/sysctl.conf

net.ipv4.tcp_syncookies = 1
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_tw_recycle = 1
net.ipv4.tcp_fin_timeout = 30

POST  HTTP/1.1
Host: 127.0.0.1:9017
Content-Type: application/json
Cache-Control: no-cache
{"a":"a"}

const net = require('net');
const server = net.createServer();
server.on('connection', (client) => {
  client.write('Hi!\n'); // 服务端向客户端输出信息，使用 write() 方法
  client.write('Bye!\n');
  //client.end(); // 服务端结束该次会话
});
server.listen(9000);

$ curl http://127.0.0.1:9000
Bye!
$telnet 127.0.0.1 9000
Trying 192.168.1.21...
Connected to 192.168.1.21.
Escape character is '^]'.
Hi!
Bye!
Connection closed by foreign host.

const client = new net.Socket();
client.connect(9000, '127.0.0.1', function () {
});
client.on('data', (chunk) => {
  console.log('data', chunk.toString())
  //data Hi!
  //Bye!
});

const net = require('net');
let clientList = [];
const heartbeat = 'HEARTBEAT'; // 定义心跳包内容确保和平时发送的数据不会冲突
const server = net.createServer();
server.on('connection', (client) => {
  console.log('客户端建立连接:', client.remoteAddress + ':' + client.remotePort);
  clientList.push(client);
  client.on('data', (chunk) => {
    let content = chunk.toString();
    if (content === heartbeat) {
      console.log('收到客户端发过来的一个心跳包');
    } else {
      console.log('收到客户端发过来的数据:', content);
      client.write('服务端的数据:' + content);
    }
  });
  client.on('end', () => {
    console.log('收到客户端end');
    clientList.splice(clientList.indexOf(client), 1);
  });
  client.on('error', () => {
    clientList.splice(clientList.indexOf(client), 1);
  })
});
server.listen(9000);
setInterval(broadcast, 10000); // 定时发送心跳包
function broadcast() {
  console.log('broadcast heartbeat', clientList.length);
  let cleanup = []
  for (let i=0;i<clientList.length;i+=1) {
    if (clientList[i].writable) { // 先检查 sockets 是否可写
      clientList[i].write(heartbeat);
    } else {
      console.log('一个无效的客户端');
      cleanup.push(clientList[i]); // 如果不可写，收集起来销毁。销毁之前要 Socket.destroy() 用 API 的方法销毁。
      clientList[i].destroy();
    }
  }
  //Remove dead Nodes out of write loop to avoid trashing loop index
  for (let i=0; i<cleanup.length; i+=1) {
    console.log('删除无效的客户端:', cleanup[i].name);
    clientList.splice(clientList.indexOf(cleanup[i]), 1);
  }
}

const net = require('net');
const heartbeat = 'HEARTBEAT'; 
const client = new net.Socket();
client.connect(9000, '127.0.0.1', () => {});
client.on('data', (chunk) => {
  let content = chunk.toString();
  if (content === heartbeat) {
    console.log('收到心跳包：', content);
  } else {
    console.log('收到数据：', content);
  }
});
// 定时发送数据
setInterval(() => {
  console.log('发送数据', new Date().toUTCString());
  client.write(new Date().toUTCString());
}, 5000);
// 定时发送心跳包
setInterval(function () {
  client.write(heartbeat);
}, 10000);

const net = require('net');
const server = net.createServer();
let clientList = [];
const heartBeat = 'HeartBeat'; // 定义心跳包内容确保和平时发送的数据不会冲突
const getHeader = (num) => {
  return 'length:' + (Array(13).join(0) + num).slice(-13);
}
server.on('connection', (client) => {
  client.name = client.remoteAddress + ':' + client.remotePort
  // client.write('Hi ' + client.name + '!\n');
  console.log('客户端建立连接', client.name);
  clientList.push(client)
  let chunks = [];
  let length = 0;
  client.on('data', (chunk) => {
    let content = chunk.toString();
    console.log("content:", content, content.length);
    if (content === heartBeat) {
      console.log('收到客户端发过来的一个心跳包');
    } else {
      if (content.indexOf('length:') === 0){
        length = parseInt(content.substring(7,20));
        console.log('length', length);
        chunks =[chunk.slice(20, chunk.length)];
      } else {
        chunks.push(chunk);
      }
      let heap = Buffer.concat(chunks);
      console.log('heap.length', heap.length)
      if (heap.length >= length) {
        try {
          console.log('收到数据', JSON.parse(heap.toString()));
          let data = '服务端的数据数据:' + heap.toString();;
          let dataBuff =  Buffer.from(JSON.stringify(data));
          let header = getHeader(dataBuff.length)
          client.write(header);
          client.write(dataBuff);
        } catch (err) {
          console.log('数据解析失败');
        }
      }
    }
  })
  client.on('end', () => {
    console.log('收到客户端end');
    clientList.splice(clientList.indexOf(client), 1);
  });
  client.on('error', () => {
    clientList.splice(clientList.indexOf(client), 1);
  })
});
server.listen(9000);
setInterval(broadcast, 10000); // 定时检查客户端 并发送心跳包
function broadcast() {
  console.log('broadcast heartbeat', clientList.length);
  let cleanup = []
  for(var i=0;i<clientList.length;i+=1) {
    if(clientList[i].writable) { // 先检查 sockets 是否可写
      // clientList[i].write(heartBeat); // 发送心跳数据
    } else {
      console.log('一个无效的客户端')
      cleanup.push(clientList[i]) // 如果不可写，收集起来销毁。销毁之前要 Socket.destroy() 用 API 的方法销毁。
      clientList[i].destroy();
    }
  }
  // 删除无效的客户端
  for(i=0; i<cleanup.length; i+=1) {
    console.log('删除无效的客户端:', cleanup[i].name);
    clientList.splice(clientList.indexOf(cleanup[i]), 1)
  }
}

const net = require('net');
const client = new net.Socket();
const heartBeat = 'HeartBeat'; // 定义心跳包内容确保和平时发送的数据不会冲突
const getHeader = (num) => {
  return 'length:' + (Array(13).join(0) + num).slice(-13);
}
client.connect(9000, '127.0.0.1', function () {});
let chunks = [];
let length = 0;
client.on('data', (chunk) => {
  let content = chunk.toString();
  console.log("content:", content, content.length);
  if (content === heartBeat) {
    console.log('收到服务端发过来的一个心跳包');
  } else {
    if (content.indexOf('length:') === 0){
      length = parseInt(content.substring(7,20));
      console.log('length', length);
      chunks =[chunk.slice(20, chunk.length)];
    } else {
      chunks.push(chunk);
    }
    let heap = Buffer.concat(chunks);
    console.log('heap.length', heap.length)
    if (heap.length >= length) {
      try {
        console.log('收到数据', JSON.parse(heap.toString()));
      } catch (err) {
        console.log('数据解析失败');
      }
    }
  }
});
// 定时发送数据
setInterval(function () {
  let data = new Date().toUTCString();
  let dataBuff =  Buffer.from(JSON.stringify(data));
  let header =getHeader(dataBuff.length);
  client.write(header);
  client.write(dataBuff);
}, 5000);
// 定时发送心跳包
setInterval(function () {
  client.write(heartBeat);
}, 10000);

.
|————lib  ------------------------- 代码库
| |————DefaultEvictor.js ---------- 
| |————Deferred.js ---------------- 
| |————Deque.js ------------------- 
| |————DequeIterator.js ----------- 
| |————DoublyLinkedList.js -------- 
| |————DoublyLinkedListIterator.js- 
| |————factoryValidator.js -------- 
| |————Pool.js -------------------- 连接池主要代码
| |————PoolDefaults.js ------------ 
| |————PooledResource.js ---------- 
| |————Queue.js ------------------- 队列
| |————ResourceLoan.js ------------ 
| |————ResourceRequest.js --------- 
| |————utils.js ------------------- 工具
|————test ------------------------- 测试目录
|————README.md  ------------------- 项目描述文件
|————.eslintrc  ------------------- eslint静态检查配置文件
|————.eslintignore  --------------- eslint静态检查忽略的文件
|————package.json ----------------- npm包依赖配置

'use strict';
const net = require('net');
const genericPool = require('generic-pool');
function createPool(conifg) {
  let options = Object.assign({
    fifo: true,                             // 是否优先使用老的资源
    priorityRange: 1,                       // 优先级
    testOnBorrow: true,                     // 是否开启获取验证
    // acquireTimeoutMillis: 10 * 1000,     // 获取的超时时间
    autostart: true,                        // 自动初始化和释放调度启用
    min: 10,                                // 初始化连接池保持的长连接最小数量
    max: 0,                                 // 最大连接池保持的长连接数量
    evictionRunIntervalMillis: 0,           // 资源释放检验间隔检查 设置了下面几个参数才起效果
    numTestsPerEvictionRun: 3,              // 每次释放资源数量
    softIdleTimeoutMillis: -1,              // 可用的超过了最小的min 且空闲时间时间 达到释放
    idleTimeoutMillis: 30000                // 强制释放
    // maxWaitingClients: 50                // 最大等待
  }, conifg.options);
  const factory = {
    create: function () {
      return new Promise((resolve, reject) => {
        let socket = new net.Socket();
        socket.setKeepAlive(true);
        socket.connect(conifg.port, conifg.host);
        // TODO 心跳包的处理逻辑
        socket.on('connect', () => {
          console.log('socket_pool', conifg.host, conifg.port, 'connect' );
          resolve(socket);
        });
        socket.on('close', (err) => { // 先end 事件再close事件
          console.log('socket_pool', conifg.host, conifg.port, 'close', err);
        });
        socket.on('error', (err) => {
          console.log('socket_pool', conifg.host, conifg.port, 'error', err);
          reject(err);
        });
      });
    },
    //销毁连接
    destroy: function (socket) {
      return new Promise((resolve) => {
        socket.destroy(); // 不会触发end 事件 第一次会触发发close事件 如果有message会触发error事件
        resolve();
      });
    },
    validate: function (socket) { //获取资源池校验资源有效性
      return new Promise((resolve) => {
        // console.log('socket.destroyed:', socket.destroyed, 'socket.readable:', socket.readable, 'socket.writable:', socket.writable);
        if (socket.destroyed || !socket.readable || !socket.writable) {
          return resolve(false);
        } else {
          return resolve(true);
        }
      });
    }
  };
  const pool = genericPool.createPool(factory, options);
  pool.on('factoryCreateError', (err) => { // 监听新建长连接出错 让请求直接返回错误
    const clientResourceRequest = pool._waitingClientsQueue.dequeue();
    if (clientResourceRequest) {
      clientResourceRequest.reject(err);
    }
  });
  return pool;
};
let pool = createPool({
  port: 9000,
  host: '127.0.0.1',
  options: {min: 0, max: 10}
});

let pool = createPool({
  port: 9000,
  host: '127.0.0.1',
  options: {min: 0, max: 10}
});
const getHeader = (num) => {
  return 'length:' + (Array(13).join(0) + num).slice(-13);
}
const request = async (requestDataBuff) => {
  let client;
  try {
    client = await pool.acquire();
  } catch (e) {
    console.log('acquire socket client failed: ', e);
    throw e;
  }
  let timeout = 10000;
  return new Promise((resolve, reject) => {
    let chunks = [];
    let length = 0;
    client.setTimeout(timeout);
    client.removeAllListeners('error');
    client.on('error', (err) => {
      client.removeAllListeners('error');
      client.removeAllListeners('data');
      client.removeAllListeners('timeout');
      pool.destroyed(client);
      reject(err);
    });
    client.on('timeout', () => {
      client.removeAllListeners('error');
      client.removeAllListeners('data');
      client.removeAllListeners('timeout');
      // 应该销毁以防下一个req的data事件监听才返回数据
      pool.destroy(client);
      // pool.release(client);
      reject(`socket connect timeout set ${timeout}`);
    });
    let header = getHeader(requestDataBuff.length);
    client.write(header);
    client.write(requestDataBuff);
    client.on('data', (chunk) => {
      let content = chunk.toString();
      console.log('content', content, content.length);
      // TODO 过滤心跳包
      if (content.indexOf('length:') === 0){
        length = parseInt(content.substring(7,20));
        console.log('length', length);
        chunks =[chunk.slice(20, chunk.length)];
      } else {
        chunks.push(chunk);
      }
      let heap = Buffer.concat(chunks);
      console.log('heap.length', heap.length);
      if (heap.length >= length) {
        pool.release(client);
        client.removeAllListeners('error');
        client.removeAllListeners('data');
        client.removeAllListeners('timeout');
        try {
          // console.log('收到数据', JSON.parse(heap.toString()));
          resolve(JSON.parse(heap.toString()));
        } catch (err) {
          reject(err);
          console.log('数据解析失败');
        }
      }
    });
  });
}
request(Buffer.from(JSON.stringify({a: 'a'})))
  .then((data) => {
    console.log('收到服务的数据',data)
  }).catch(err => {
    console.log(err);
  });
request(Buffer.from(JSON.stringify({b: 'b'})))
  .then((data) => {
    console.log('收到服务的数据',data)
  }).catch(err => {
    console.log(err);
  });
setTimeout(function () { //查看是否会复用Socket 有没有建立新的连接
  request(Buffer.from(JSON.stringify({c: 'c'})))
    .then((data) => {
      console.log('收到服务的数据',data)
    }).catch(err => {
    console.log(err);
  });
  request(Buffer.from(JSON.stringify({d: 'd'})))
    .then((data) => {
      console.log('收到服务的数据',data)
    }).catch(err => {
    console.log(err);
  });
}, 1000)

/**
   * Generate an Object pool with a specified `factory` and `config`.
   *
   * @param {typeof DefaultEvictor} Evictor
   * @param {typeof Deque} Deque
   * @param {typeof PriorityQueue} PriorityQueue
   * @param {Object} factory
   *   Factory to be used for generating and destroying the items.
   * @param {Function} factory.create
   *   Should create the item to be acquired,
   *   and call it's first callback argument with the generated item as it's argument.
   * @param {Function} factory.destroy
   *   Should gently close any resources that the item is using.
   *   Called before the items is destroyed.
   * @param {Function} factory.validate
   *   Test if a resource is still valid .Should return a promise that resolves to a boolean, true if resource is still valid and false
   *   If it should be removed from pool.
   * @param {Object} options
   */
  constructor(Evictor, Deque, PriorityQueue, factory, options) {
    super();
    factoryValidator(factory); // 检验我们定义的factory的有效性包含create destroy validate
    this._config = new PoolOptions(options); // 连接池配置
    // TODO: fix up this ugly glue-ing
    this._Promise = this._config.Promise;
    this._factory = factory;
    this._draining = false;
    this._started = false;
    /**
     * Holds waiting clients
     * @type {PriorityQueue}
     */
    this._waitingClientsQueue = new PriorityQueue(this._config.priorityRange); // 请求的对象管管理队列queue 初始化queue的size 1 { _size: 1, _slots: [ Queue { _list: [Object] } ] }
    /**
     * Collection of promises for resource creation calls made by the pool to factory.create
     * @type {Set}
     */
    this._factoryCreateOperations = new Set(); // 正在创建的长连接
    /**
     * Collection of promises for resource destruction calls made by the pool to factory.destroy
     * @type {Set}
     */
    this._factoryDestroyOperations = new Set(); // 正在销毁的长连接
    /**
     * A queue/stack of pooledResources awaiting acquisition
     * TODO: replace with LinkedList backed array
     * @type {Deque}
     */
    this._availableObjects = new Deque(); // 空闲的资源长连接
    /**
     * Collection of references for any resource that are undergoing validation before being acquired
     * @type {Set}
     */
    this._testOnBorrowResources = new Set(); // 正在检验有效性的资源
    /**
     * Collection of references for any resource that are undergoing validation before being returned
     * @type {Set}
     */
    this._testOnReturnResources = new Set();
    /**
     * Collection of promises for any validations currently in process
     * @type {Set}
     */
    this._validationOperations = new Set();// 正在校验的中间temp
    /**
     * All objects associated with this pool in any state (except destroyed)
     * @type {Set}
     */
    this._allObjects = new Set(); // 所有的链接资源 是一个 PooledResource对象
    /**
     * Loans keyed by the borrowed resource
     * @type {Map}
     */
    this._resourceLoans = new Map(); // 被借用的对象的map release的时候用到
    /**
     * Infinitely looping iterator over available object
     * @type {DequeIterator}
     */
    this._evictionIterator = this._availableObjects.iterator(); // 一个迭代器
    this._evictor = new Evictor();
    /**
     * handle for setTimeout for next eviction run
     * @type {(number|null)}
     */
    this._scheduledEviction = null;
    // create initial resources (if factory.min > 0)
    if (this._config.autostart === true) { // 初始化最小的连接数量
      this.start();
    }
  }

/**
   * Request a new resource. The callback will be called,
   * when a new resource is available, passing the resource to the callback.
   * TODO: should we add a seperate "acquireWithPriority" function
   *
   * @param {Number} [priority=0]
   *   Optional.  Integer between 0 and (priorityRange - 1).  Specifies the priority
   *   of the caller if there are no available resources.  Lower numbers mean higher
   *   priority.
   *
   * @returns {Promise}
   */
  acquire(priority) { // 空闲资源队列资源是有优先等级的 
    if (this._started === false && this._config.autostart === false) {
      this.start(); // 会在this._allObjects 添加min的连接对象数
    }
    if (this._draining) { // 如果是在资源释放阶段就不能再请求资源了
      return this._Promise.reject(
        new Error("pool is draining and cannot accept work")
      );
    }
    // 如果要设置了等待队列的长度且要等待 如果超过了就返回资源不可获取
    // TODO: should we defer this check till after this event loop incase "the situation" changes in the meantime
    if (
      this._config.maxWaitingClients !== undefined &&
      this._waitingClientsQueue.length >= this._config.maxWaitingClients
    ) {
      return this._Promise.reject(
        new Error("max waitingClients count exceeded")
      );
    }
    const resourceRequest = new ResourceRequest(
      this._config.acquireTimeoutMillis, // 对象里面的超时配置 表示等待时间 会启动一个定时 超时了就触发resourceRequest.promise 的reject触发
      this._Promise
    );
    // console.log(resourceRequest)
    this._waitingClientsQueue.enqueue(resourceRequest, priority); // 请求进入等待请求队列
    this._dispense(); // 进行资源分发 最终会触发resourceRequest.promise的resolve(client) 
    return resourceRequest.promise; // 返回的是一个promise对象resolve却是在其他地方触发
  }

/**
   * Attempt to resolve an outstanding resource request using an available resource from
   * the pool, or creating new ones
   *
   * @private
   */
  _dispense() {
    /**
     * Local variables for ease of reading/writing
     * these don't (shouldn't) change across the execution of this fn
     */
    const numWaitingClients = this._waitingClientsQueue.length; // 正在等待的请求的队列长度 各个优先级的总和
    console.log('numWaitingClients', numWaitingClients)  // 1
    // If there aren't any waiting requests then there is nothing to do
    // so lets short-circuit
    if (numWaitingClients < 1) {
      return;
    }
    //  max: 10, min: 4
    console.log('_potentiallyAllocableResourceCount', this._potentiallyAllocableResourceCount) // 目前潜在空闲可用的连接数量
    const resourceShortfall =
      numWaitingClients - this._potentiallyAllocableResourceCount; // 还差几个可用的 小于零表示不需要 大于0表示需要新建长连接的数量
    console.log('spareResourceCapacity', this.spareResourceCapacity) // 距离max数量的还有几个没有创建
    const actualNumberOfResourcesToCreate = Math.min(
      this.spareResourceCapacity, // -6
      resourceShortfall // 这个是 -3
    ); // 如果resourceShortfall>0 表示需要新建但是这新建的数量不能超过spareResourceCapacity最多可创建的
    console.log('actualNumberOfResourcesToCreate', actualNumberOfResourcesToCreate) // 如果actualNumberOfResourcesToCreate >0 表示需要创建连接
    for (let i = 0; actualNumberOfResourcesToCreate > i; i++) {
      this._createResource(); // 新增新的长连接
    }
    // If we are doing test-on-borrow see how many more resources need to be moved into test
    // to help satisfy waitingClients
    if (this._config.testOnBorrow === true) { // 如果开启了使用前校验资源的有效性
      // how many available resources do we need to shift into test
      const desiredNumberOfResourcesToMoveIntoTest =
        numWaitingClients - this._testOnBorrowResources.size;// 1
      const actualNumberOfResourcesToMoveIntoTest = Math.min(
        this._availableObjects.length, // 3
        desiredNumberOfResourcesToMoveIntoTest // 1
      );
      for (let i = 0; actualNumberOfResourcesToMoveIntoTest > i; i++) { // 需要有效性校验的数量 至少满足最小的waiting clinet
        this._testOnBorrow(); // 资源有效校验后再分发
      }
    }
    // if we aren't testing-on-borrow then lets try to allocate what we can
    if (this._config.testOnBorrow === false) { // 如果没有开启有效性校验 就开启有效资源的分发
      const actualNumberOfResourcesToDispatch = Math.min(
        this._availableObjects.length,
        numWaitingClients
      );
      for (let i = 0; actualNumberOfResourcesToDispatch > i; i++) { // 开始分发资源
        this._dispatchResource();
      }
    }
  }

/**
   * Attempt to move an available resource to a waiting client
   * @return {Boolean} [description]
   */
  _dispatchResource() {
    if (this._availableObjects.length < 1) {
      return false;
    }
    const pooledResource = this._availableObjects.shift(); // 从可以资源池里面取出一个
    this._dispatchPooledResourceToNextWaitingClient(pooledResource); // 分发
    return false;
  }
  /**
   * Dispatches a pooledResource to the next waiting client (if any) else
   * puts the PooledResource back on the available list
   * @param  {PooledResource} pooledResource [description]
   * @return {Boolean}                [description]
   */
  _dispatchPooledResourceToNextWaitingClient(pooledResource) {
    const clientResourceRequest = this._waitingClientsQueue.dequeue(); // 可能是undefined 取出一个等待的quene
    console.log('clientResourceRequest.state', clientResourceRequest.state);
    if (clientResourceRequest === undefined ||
      clientResourceRequest.state !== Deferred.PENDING) {
      console.log('没有等待的')
      // While we were away either all the waiting clients timed out
      // or were somehow fulfilled. put our pooledResource back.
      this._addPooledResourceToAvailableObjects(pooledResource); // 在可用的资源里面添加一个
      // TODO: do need to trigger anything before we leave?
      return false;
    }
    // TODO clientResourceRequest 的state是否需要判断 如果已经是resolve的状态 已经超时回去了 这个是否有问题
    const loan = new ResourceLoan(pooledResource, this._Promise); 
    this._resourceLoans.set(pooledResource.obj, loan); // _resourceLoans 是个map k=>value  pooledResource.obj 就是socket本身
    pooledResource.allocate(); // 标识资源的状态是正在被使用
    clientResourceRequest.resolve(pooledResource.obj); //  acquire方法返回的promise对象的resolve在这里执行的
    return true;
  }