detect-port

检查端口号是否被占用，被占用自动加1，最大加10

/**
 * 1. require('detect-port')({hostname: '0.0.0.0', port: 3000}).then(res => res)
 * 2. 判断传递进来的参数是否有回调。没有回调就使用promise，回调第一个参数是报错信息第二个是可以使用的端口，promise返回的直接就是一个可以使用的端口。
      把端口和ip赋值给变量。弄一个最大端口号变量maxPort = port+10，maxPort最大为65535，port - maxPort都被占用了就直接报错
 * 3. 调用tryListen方法，校验端口是否会报错，有ip就使用，没有就给null，走null没有报错就走主机的ip，在检查端口的时候报错就走handleError方法
 * 4. handleError方法用来端口号+1继续调用tryListen来校验
 */

/**
 * 1.  hostname: ip
 * 2. port: 端口
 * 3. net.Server(): 创建一个服务器
 * 4. server.on: 服务器状态监听
 * 5. server.listen: 开启服务器
 * 6. server.close(): 关闭服务器
 * 7. server.address(): 获取服务器地址
 */

// 严格模式
'use strict';

// 网络模块
const net = require('net');

// 用来获取ip,ipv6, mac
const address = require('address');

// 用来调试
const debug = require('debug')('detect-port');

module.exports = (port, callback) => {
  let hostname = '';

  // 根据类型赋值
  if (typeof port === 'object' && port) {
    hostname = port.hostname;
    callback = port.callback;
    port = port.port;
  } else {
    if (typeof port === 'function') {
      callback = port;
      port = null;
    }
  }

  port = parseInt(port) || 0;

  let maxPort = port + 10;
  if (maxPort > 65535) {
    maxPort = 65535;
  }

  // 建立一个debug实例，并且打印 检测之间的空闲端口 [3000, 3010)
  debug('检测之间的空闲端口 [%s, %s)', port, maxPort);

  // 如果是回调
  if (typeof callback === 'function') {
    return tryListen(port, maxPort, hostname, callback);
  }

  // promise
  return new Promise(resolve => {
    tryListen(port, maxPort, hostname, (_, realPort) => {
      resolve(realPort);
    });
  });
};

function tryListen(port, maxPort, hostname, callback) {
  // 处理报错,端口号添加一位
  function handleError() {
    port++;
    if (port >= maxPort) {
      debug('port: %s >= maxPort: %s, 放弃使用随机端口', port, maxPort);
      port = 0;
      maxPort = 0;
    }

    // 再走一遍检查，找到合适的port
    tryListen(port, maxPort, hostname, callback);
  }

  // 有ip
  if (hostname) {
    listen(port, hostname, (err, realPort) => {
      // 启动服务器报错
      if (err) {
        if (err.code === 'EADDRNOTAVAIL') {
          return callback(new Error('在机器上不是未知的IP'));
        }

        return handleError();
      }

      callback(null, realPort);
    });
  } else {
    // 1. 没有ip
    listen(port, null, (err, realPort) => {
      // 忽略随机听
      if (port === 0) {
        return callback(err, realPort);
      }

      if (err) {
        return handleError(err);
      }

      // 2. check 0.0.0.0
      listen(port, '0.0.0.0', err => {
        if (err) {
          return handleError(err);
        }

        // 3. 检查主机
        listen(port, 'localhost', err => {
          //  如果localhost在机器上引用的ip不是未知的，您将看到错误EADDRNOTAVAIL
          // https://stackoverflow.com/questions/10809740/listen-eaddrnotavail-error-in-node-js
          if (err && err.code !== 'EADDRNOTAVAIL') {
            return handleError(err);
          }

          // 4. 检查当前ip
          listen(port, address.ip(), (err, realPort) => {
            if (err) {
              return handleError(err);
            }

            callback(null, realPort);
          });
        });
      });
    });
  }
}

function listen(port, hostname, callback) {
  const server = new net.Server();

  // 监听server的报错事件
  server.on('error', err => {
    debug('监听 %s:%s 报错: %s', hostname, port, err);

    // 服务器停止接收新的连接
    server.close();

    if (err.code === 'ENOTFOUND') {
      debug('忽略dns ENOTFOUND错误, 免除 %s:%s', hostname, port);
      return callback(null, port);
    }
    return callback(err);
  });

  // 启动监听连接的服务器
  server.listen(port, hostname, () => {
    // 操作系统返回绑定的地址，协议族名和服务器端口。
    port = server.address().port;

    // 服务器停止接收新的连接
    server.close();

    debug('免除 %s:%s', hostname, port);

    return callback(null, port);
  });
}