ee-core 2.0.3 → 2.1.0-beta.3

package/utils/get-port/index.d.ts

@@ -0,0 +1,64 @@
+/// <reference types="node"/>
+import {ListenOptions} from 'net';
+
+declare namespace getPort {
+	interface Options extends Omit<ListenOptions, 'port'> {
+		/**
+		A preferred port or an iterable of preferred ports to use.
+		*/
+		readonly port?: number | Iterable<number>;
+
+		/**
+		The host on which port resolution should be performed. Can be either an IPv4 or IPv6 address.
+		*/
+		readonly host?: string;
+	}
+}
+
+declare const getPort: {
+	/**
+	Get an available TCP port number.
+
+	@returns Port number.
+
+	@example
+	```
+	import getPort = require('get-port');
+
+	(async () => {
+		console.log(await getPort());
+		//=> 51402
+
+		// Pass in a preferred port
+		console.log(await getPort({port: 3000}));
+		// Will use 3000 if available, otherwise fall back to a random port
+
+		// Pass in an array of preferred ports
+		console.log(await getPort({port: [3000, 3001, 3002]}));
+		// Will use any element in the preferred ports array if available, otherwise fall back to a random port
+	})();
+	```
+	*/
+	(options?: getPort.Options): Promise<number>;
+
+	/**
+	Make a range of ports `from`...`to`.
+
+	@param from - First port of the range. Must be in the range `1024`...`65535`.
+	@param to - Last port of the range. Must be in the range `1024`...`65535` and must be greater than `from`.
+	@returns The ports in the range.
+
+	@example
+	```
+	import getPort = require('get-port');
+
+	(async () => {
+		console.log(await getPort({port: getPort.makeRange(3000, 3100)}));
+		// Will use any port from 3000 to 3100, otherwise fall back to a random port
+	})();
+	```
+	*/
+	makeRange(from: number, to: number): Iterable<number>;
+};
+
+export = getPort;

package/utils/get-port/index.js

@@ -0,0 +1,109 @@
+'use strict';
+const net = require('net');
+
+class Locked extends Error {
+	constructor(port) {
+		super(`${port} is locked`);
+	}
+}
+
+const lockedPorts = {
+	old: new Set(),
+	young: new Set()
+};
+
+// On this interval, the old locked ports are discarded,
+// the young locked ports are moved to old locked ports,
+// and a new young set for locked ports are created.
+const releaseOldLockedPortsIntervalMs = 1000 * 15;
+
+// Lazily create interval on first use
+let interval;
+
+const getAvailablePort = options => new Promise((resolve, reject) => {
+	const server = net.createServer();
+	server.unref();
+	server.on('error', reject);
+	server.listen(options, () => {
+		const {port} = server.address();
+		server.close(() => {
+			resolve(port);
+		});
+	});
+});
+
+const portCheckSequence = function * (ports) {
+	if (ports) {
+		yield * ports;
+	}
+
+	yield 0; // Fall back to 0 if anything else failed
+};
+
+module.exports = async options => {
+	let ports;
+
+	if (options) {
+		ports = typeof options.port === 'number' ? [options.port] : options.port;
+	}
+
+	if (interval === undefined) {
+		interval = setInterval(() => {
+			lockedPorts.old = lockedPorts.young;
+			lockedPorts.young = new Set();
+		}, releaseOldLockedPortsIntervalMs);
+
+		// Does not exist in some environments (Electron, Jest jsdom env, browser, etc).
+		if (interval.unref) {
+			interval.unref();
+		}
+	}
+
+	for (const port of portCheckSequence(ports)) {
+		try {
+			let availablePort = await getAvailablePort({...options, port}); // eslint-disable-line no-await-in-loop
+			while (lockedPorts.old.has(availablePort) || lockedPorts.young.has(availablePort)) {
+				if (port !== 0) {
+					throw new Locked(port);
+				}
+
+				availablePort = await getAvailablePort({...options, port}); // eslint-disable-line no-await-in-loop
+			}
+
+			lockedPorts.young.add(availablePort);
+			return availablePort;
+		} catch (error) {
+			if (!['EADDRINUSE', 'EACCES'].includes(error.code) && !(error instanceof Locked)) {
+				throw error;
+			}
+		}
+	}
+
+	throw new Error('No available ports found');
+};
+
+module.exports.makeRange = (from, to) => {
+	if (!Number.isInteger(from) || !Number.isInteger(to)) {
+		throw new TypeError('`from` and `to` must be integer numbers');
+	}
+
+	if (from < 1024 || from > 65535) {
+		throw new RangeError('`from` must be between 1024 and 65535');
+	}
+
+	if (to < 1024 || to > 65536) {
+		throw new RangeError('`to` must be between 1024 and 65536');
+	}
+
+	if (to < from) {
+		throw new RangeError('`to` must be greater than or equal to `from`');
+	}
+
+	const generator = function * (from, to) {
+		for (let port = from; port <= to; port++) {
+			yield port;
+		}
+	};
+
+	return generator(from, to);
+};

package/utils/helper.js

@@ -2,7 +2,7 @@ const fs = require('fs');
 const mkdirp = require('mkdirp');
 const convert = require('koa-convert');
 const is = require('is-type-of');
-const co = require('co');
+const co = require('./co');
 
 /**
  * fnDebounce
@@ -114,3 +114,27 @@ exports.callFn = async function (fn, args, ctx) {
 exports.middleware = function (fn) {
   return is.generatorFunction(fn) ? convert(fn) : fn;
 }
+
+/**
+ * 序列化对象
+ */
+exports.stringify = function(obj, ignore = []) {
+  const result = {};
+  Object.keys(obj).forEach(key => {
+      if (!ignore.includes(key)) {
+      result[key] = obj[key];
+      }
+  });
+  return JSON.stringify(result);
+}
+
+/**
+ * 是否有效值
+ */
+exports.validValue = function(value) {
+  return (
+    value !== undefined &&
+    value !== null &&
+    value !== ''
+  );
+}

package/utils/index.js

@@ -1,3 +1,6 @@
+"use strict";
+
+const os = require("os");
 const path = require('path');
 const Ps = require('../ps');
 const UtilsJson = require('./json');
@@ -11,5 +14,48 @@ exports.getPackage = function() {
   return json;
 };
 
+/**
+ * Get the first proper MAC address
+ * @param iface If provided, restrict MAC address fetching to this interface
+ */
+exports.getMAC = function(iface) {
+  const zeroRegex = /(?:[0]{1,2}[:-]){5}[0]{1,2}/;
+  const list = os.networkInterfaces();
+  if (iface) {
+      const parts = list[iface];
+      if (!parts) {
+          throw new Error(`interface ${iface} was not found`);
+      }
+      for (const part of parts) {
+          if (zeroRegex.test(part.mac) === false) {
+              return part.mac;
+          }
+      }
+      throw new Error(`interface ${iface} had no valid mac addresses`);
+  }
+  else {
+      for (const [key, parts] of Object.entries(list)) {
+          // for some reason beyond me, this is needed to satisfy typescript
+          // fix https://github.com/bevry/getmac/issues/100
+          if (!parts)
+              continue;
+          for (const part of parts) {
+              if (zeroRegex.test(part.mac) === false) {
+                  return part.mac;
+              }
+          }
+      }
+  }
+  throw new Error('failed to get the MAC address');
+}
+
+/**
+ * Check if the input is a valid MAC address
+ */
+exports.isMAC = function(macAddress) {
+  const macRegex = /(?:[a-z0-9]{1,2}[:-]){5}[a-z0-9]{1,2}/i;
+  return macRegex.test(macAddress);
+}
+
 
 

package/utils/ip.js

@@ -0,0 +1,261 @@
+const { promisify } = require('util');
+const dgram = require('dgram');
+const { isIPv6, isIPv4 } = require('net');
+const dns = require('dns-socket');
+const HttpClient = require('../httpclient');
+
+const emptyIP = '';
+const defaults = {
+	timeout: 3000,
+	type: 'http', // 'http' | 'dns' | 'all'
+};
+
+const dnsServers = [
+	{
+		v4: {
+			servers: [
+				'208.67.222.222',
+				'208.67.220.220',
+				'208.67.222.220',
+				'208.67.220.222',
+			],
+			name: 'myip.opendns.com',
+			type: 'A',
+		},
+		v6: {
+			servers: [
+				'2620:0:ccc::2',
+				'2620:0:ccd::2',
+			],
+			name: 'myip.opendns.com',
+			type: 'AAAA',
+		},
+	},
+];
+
+const type = {
+	v4: {
+		dnsServers: dnsServers.map(({v4: {servers, ...question}}) => ({
+			servers, question,
+		})),
+		httpsUrls: [
+			'https://icanhazip.com/',
+			'https://api.ipify.org/',
+		],
+	},
+	v6: {
+		dnsServers: dnsServers.map(({v6: {servers, ...question}}) => ({
+			servers, question,
+		})),
+		httpsUrls: [
+			'https://icanhazip.com/',
+			'https://api6.ipify.org/',
+		],
+	},
+};
+
+const queryDns = (version, options) => {
+	const data = type[version];
+	const socket = dns({
+		retries: 0,
+		maxQueries: 1,
+		socket: dgram.createSocket(version === 'v6' ? 'udp6' : 'udp4'),
+		timeout: options.timeout,
+	});
+
+	const socketQuery = promisify(socket.query.bind(socket));
+	const promise = (async () => {
+		for (const dnsServerInfo of data.dnsServers) {
+			const {servers, question} = dnsServerInfo;
+			for (const server of servers) {
+				if (socket.destroyed) {
+					return emptyIP;
+				}
+
+				try {
+					const {name, type, transform} = question;
+					const dnsResponse = await socketQuery({questions: [{name, type}]}, 53, server);
+
+					const {
+						answers: {
+							0: {
+								data,
+							},
+						},
+					} = dnsResponse;
+					const response = (typeof data === 'string' ? data : data.toString()).trim();
+          const ip = (transform && version === 'v6') ? transform(response) : response;
+					const method = version === 'v6' ? isIPv6 : isIPv4;
+
+					if (ip && method(ip)) {
+						socket.destroy();
+						return ip;
+					}
+				} catch (error) {
+					// Log.coreLogger.error('[ee-core] [utils/ip] queryDns error:', error);
+				}
+			}
+		}
+
+		socket.destroy();
+		return emptyIP;
+	})();
+
+	promise.cancel = () => {
+		socket.destroy();
+	};
+
+	return promise;
+};
+
+const queryHttps = (version, options) => {
+	let cancel;
+  const hc = new HttpClient();
+
+	const promise = (async () => {
+		const requestOptions = {
+			method: 'GET',
+			timeout: options.timeout,
+			dataType: 'text',
+		};
+
+		const urls = [
+			...type[version].httpsUrls,
+			...(options.fallbackUrls ?? []),
+		];
+
+		for (const url of urls) {
+			try {
+				const gotPromise = hc.request(url, requestOptions);
+				gotPromise.cancel = () => {
+					// todo
+				}
+				cancel = gotPromise.cancel;
+
+				const response = await gotPromise;
+				let result = response.status == 200 ? response.data : '';
+				const ip = result.trim();
+
+				const method = version === 'v6' ? isIPv6 : isIPv4;
+
+				if (ip && method(ip)) {
+					return ip;
+				}
+			} catch (error) {
+				//Log.coreLogger.error('[ee-core] [utils/ip] queryHttps error:', error);
+			}
+		}
+
+		return emptyIP;
+	})();
+
+	promise.cancel = function () {
+		return cancel.apply(this);
+	};
+
+	return promise;
+};
+
+const queryAll = (version, options) => {
+	let cancel;
+	const promise = (async () => {
+		let response;
+		const dnsPromise = queryDns(version, options);
+		cancel = dnsPromise.cancel;
+		try {
+			response = await dnsPromise;
+		} catch {
+			const httpsPromise = queryHttps(version, options);
+			cancel = httpsPromise.cancel;
+			response = await httpsPromise;
+		}
+
+		return response;
+	})();
+
+	promise.cancel = cancel;
+
+	return promise;
+};
+
+/**
+ * 查询 public ipv4
+ */  
+function publicIpv4(options) {
+  options = {
+    ...defaults,
+    ...options,
+  };
+
+  if (options.type == 'http') {
+    return queryHttps('v4', options);
+  }	
+	
+  if (options.type == 'dns') {
+    return queryDns('v4', options);
+  }
+
+  return queryAll('v4', options);
+}
+
+/**
+ * 查询public ipv6
+ */  
+function publicIpv6(options) {
+  options = {
+    ...defaults,
+    ...options,
+  };
+
+  if (options.type == 'http') {
+    return queryHttps('v6', options);
+  }	
+	
+  if (options.type == 'dns') {
+    return queryDns('v6', options);
+  }
+
+  return queryAll('v6', options);
+}
+
+/**
+ * todo 未来趋势是ipv6优先，以后再放开
+ */  
+const publicIp = createPublicIp(publicIpv4, publicIpv6);
+function createPublicIp(publicIpv4, publicIpv6) {
+	return function publicIp(options) {
+		const ipv4Promise = publicIpv4(options);
+		const ipv6Promise = publicIpv6(options);
+
+		const promise = (async () => {
+			try {
+				const ipv6 = await ipv6Promise;
+				ipv4Promise.cancel();
+				return ipv6;
+			} catch (ipv6Error) {
+				//Log.coreLogger.error('[ee-core] [utils/ip] publicIp ipv6Error:', ipv6Error);
+				try {
+					return await ipv4Promise;
+				} catch (ipv4Error) {
+					//Log.coreLogger.error('[ee-core] [utils/ip] publicIp ipv4Error:', ipv4Error);
+				}
+			}
+		})();
+
+		promise.cancel = () => {
+			ipv4Promise.cancel();
+			ipv6Promise.cancel();
+		};
+
+		return promise;
+	};
+}
+
+const IP = {
+  //publicIp,
+  publicIpv4,
+  publicIpv6
+}
+
+module.exports = IP;
+

package/utils/is.js

@@ -139,7 +139,8 @@ const IS = {
   _osxRelease () {
     const actual = release().split('.')
     return `10.${actual[0] - 4}.${actual[1]}`
-  }
+  },
+  
 }
 
 module.exports = IS;

package/utils/time/index.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const util = require('util');
+const ms = require('./ms');
+
+function humanizeToMs (t) {
+  if (typeof t === 'number') return t;
+  var r = ms(t);
+  if (r === undefined) {
+    var err = new Error(util.format('humanize-ms(%j) result undefined', t));
+    console.warn(err.stack);
+  }
+  return r;
+}
+
+const TIME = {
+  humanizeToMs,
+  ms
+}
+module.exports = TIME;

package/utils/time/ms.js

@@ -0,0 +1,162 @@
+/**
+ * Helpers.
+ */
+
+var s = 1000;
+var m = s * 60;
+var h = m * 60;
+var d = h * 24;
+var w = d * 7;
+var y = d * 365.25;
+
+/**
+ * Parse or format the given `val`.
+ *
+ * Options:
+ *
+ *  - `long` verbose formatting [false]
+ *
+ * @param {String|Number} val
+ * @param {Object} [options]
+ * @throws {Error} throw an error if val is not a non-empty string or a number
+ * @return {String|Number}
+ * @api public
+ */
+
+module.exports = function(val, options) {
+  options = options || {};
+  var type = typeof val;
+  if (type === 'string' && val.length > 0) {
+    return parse(val);
+  } else if (type === 'number' && isFinite(val)) {
+    return options.long ? fmtLong(val) : fmtShort(val);
+  }
+  throw new Error(
+    'val is not a non-empty string or a valid number. val=' +
+      JSON.stringify(val)
+  );
+};
+
+/**
+ * Parse the given `str` and return milliseconds.
+ *
+ * @param {String} str
+ * @return {Number}
+ * @api private
+ */
+
+function parse(str) {
+  str = String(str);
+  if (str.length > 100) {
+    return;
+  }
+  var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+    str
+  );
+  if (!match) {
+    return;
+  }
+  var n = parseFloat(match[1]);
+  var type = (match[2] || 'ms').toLowerCase();
+  switch (type) {
+    case 'years':
+    case 'year':
+    case 'yrs':
+    case 'yr':
+    case 'y':
+      return n * y;
+    case 'weeks':
+    case 'week':
+    case 'w':
+      return n * w;
+    case 'days':
+    case 'day':
+    case 'd':
+      return n * d;
+    case 'hours':
+    case 'hour':
+    case 'hrs':
+    case 'hr':
+    case 'h':
+      return n * h;
+    case 'minutes':
+    case 'minute':
+    case 'mins':
+    case 'min':
+    case 'm':
+      return n * m;
+    case 'seconds':
+    case 'second':
+    case 'secs':
+    case 'sec':
+    case 's':
+      return n * s;
+    case 'milliseconds':
+    case 'millisecond':
+    case 'msecs':
+    case 'msec':
+    case 'ms':
+      return n;
+    default:
+      return undefined;
+  }
+}
+
+/**
+ * Short format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */
+
+function fmtShort(ms) {
+  var msAbs = Math.abs(ms);
+  if (msAbs >= d) {
+    return Math.round(ms / d) + 'd';
+  }
+  if (msAbs >= h) {
+    return Math.round(ms / h) + 'h';
+  }
+  if (msAbs >= m) {
+    return Math.round(ms / m) + 'm';
+  }
+  if (msAbs >= s) {
+    return Math.round(ms / s) + 's';
+  }
+  return ms + 'ms';
+}
+
+/**
+ * Long format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */
+
+function fmtLong(ms) {
+  var msAbs = Math.abs(ms);
+  if (msAbs >= d) {
+    return plural(ms, msAbs, d, 'day');
+  }
+  if (msAbs >= h) {
+    return plural(ms, msAbs, h, 'hour');
+  }
+  if (msAbs >= m) {
+    return plural(ms, msAbs, m, 'minute');
+  }
+  if (msAbs >= s) {
+    return plural(ms, msAbs, s, 'second');
+  }
+  return ms + ' ms';
+}
+
+/**
+ * Pluralization helper.
+ */
+
+function plural(ms, msAbs, n, name) {
+  var isPlural = msAbs >= n * 1.5;
+  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
+}