crabatool 1.0.367 → 1.0.369

package/index.js

@@ -20,6 +20,9 @@ exports.run = function(options) {
 }
 exports.utils = require('./lib/utils.js');
 exports.server = require('./lib/server.js');
+exports.stringBuilder = require('./lib/stringBuilder.js');
+exports.stringUtils = require('./lib/stringUtils.js');
+exports.pager = require('./lib/pager.js');
 
 function checkFast(args) {
   // 1. 服务端构建环境，自动化，根据命令行参数，直接调用脚手架功能
@@ -41,16 +44,16 @@ function checkFast(args) {
   config.progress = 0; // 通过命令行启动，默认不显示进度条
 
   if (args.includes('-checkjs')) {
-    start.bindConfigByArgv('-ignoreFiles','array');
-    start.bindConfigByArgv('-cssFiles','array');
+    start.bindConfigByArgv('-ignoreFiles', 'array');
+    start.bindConfigByArgv('-cssFiles', 'array');
 
     start.checkAllJs();
     return false;
   }
 
   if (args.includes('-checkiconfont')) {
-    start.bindConfigByArgv('-ignoreFiles','array');
-    start.bindConfigByArgv('-cssFiles','array');
+    start.bindConfigByArgv('-ignoreFiles', 'array');
+    start.bindConfigByArgv('-cssFiles', 'array');
 
     start.checkIconfont();
     return false;

package/lib/cuid.js

@@ -0,0 +1,130 @@
+/*!
+ * apracjs
+ * Copyright(c) 2017 by wssf
+ * 2017-04-26
+ */
+
+'use strict'
+var os = require('os');
+var utils = require('./utils.js');
+var hiGetter = null;
+var inited = false;
+var lastLo = null;
+var loInc = 1;
+var _hi = 0;
+var _hi2 = null;
+var TimestampBase = (new Date()).getTime();
+var MinDateTime = (new Date("2017-06-26 00:00:00")).getTime();
+var TickBase = TimestampBase - MinDateTime;
+
+/* 返回数字的cuid */
+exports.newCuid = function cuid$newCuid() {
+    var lo;
+    try {
+        if (!inited) {
+            init();
+        }
+
+        lo = getLo();
+        if (lo == lastLo || lo < lastLo + loInc) {
+            lo = lastLo + loInc;
+            loInc++;
+        } else {
+            lastLo = lo;
+            loInc = 1;
+        }
+    } catch (ex) {
+
+    } finally {
+
+    }
+
+    var hi = _hi << 48; // 左移6个字节
+    return hi + lo;
+};
+
+/* 返回字符串的cuid */
+exports.newCuidString = function cuid$newCuidString() {
+    var lo;
+    try {
+        if (!inited) {
+            init();
+        }
+
+        lo = getLo();
+        if (lo == lastLo || lo < lastLo + loInc) {
+            lo = lastLo + loInc;
+            loInc++;
+        } else {
+            lastLo = lo;
+            loInc = 1;
+        }
+    } catch (ex) {
+
+    } finally {
+
+    }
+
+    return _hi2 + utils.padLeft(lo.toString(), 12, "0");
+};
+
+/* 注册cuid的自定义hi接口 */
+exports.registerHiGetter = async function(getter) {
+    if (hiGetter || !getter || inited) return; // 只初始化一次
+
+    hiGetter = getter;
+
+    console.log('开始初始化cuid的hi');
+    if (typeof getter.getHi != 'function') {
+        console.log('注册的接口没有实现getHi方法');
+        return;
+    }
+
+    var siteId = getSiteId();
+    var hi = await getter.getHi(siteId);
+    if (hi <= 0) {
+        console.log('cuid自定义接口生成的hi失败，使用内部生成hi');
+        return; // 标记为失败，使用内部自动生成hi，使用newCuidString的情况重复概率也不大；存储空间为2的12次方
+    }
+
+    console.log('cuid自定义接口生成的hi为:' + hi);
+    makeHi(hi);
+    inited = true;
+}
+
+function init() {
+    inited = true;
+
+    lastLo = getLo();
+
+    makeHashHi();
+}
+
+function getLo() {
+    var ticks = (new Date()).getTime() - TimestampBase;
+    return TickBase + ticks;
+}
+
+function makeHashHi() {
+    var siteId = getSiteId();
+    var hashId = parseInt(utils.getHashCode(siteId));
+    makeHi(hashId);
+}
+
+function makeHi(hc) {
+    _hi = hc & 32; // JavaScript最大整数精度2*53位，时间戳48位，hi剩余5位
+    _hi2 = utils.padLeft(hc.toString(), 12, "0");
+}
+
+function getSiteId() {
+    var siteId = utils.format("{0}_{1}", os.hostname(), process.cwd()); // 机器名称+网站路径
+    return siteId;
+}
+
+function LoToDateTime(lo) {
+    return MinDateTime + lo;
+}
+
+function LoToLocalDateTime(lo) {
+    return new Date(LoToDateTime(lo));
+}

package/lib/db/baseLib.js

@@ -0,0 +1,480 @@
+var StringBuilder = require('../stringBuilder.js');
+var Url = require('url');
+var DebugDBHelper = require('debug')('aprac:DBHelper');
+var SqlString = require('sqlstring');
+var StringUtils = require("../stringUtils.js");
+var Cuid = require('../cuid.js');
+
+class BaseLib {
+    constructor(connectionSetting) {
+        this.connectionSetting = connectionSetting;
+        this.connectionStatusEnum = new Object();
+        this.connectionStatusEnum.Open = 1;
+        this.connectionStatusEnum.Close = 0;
+        this._initConnectionSetting();
+        //BaseLib._startKillLockConnectionService();
+    }
+
+    _initConnectionSetting() {
+        let uriInfo = Url.parse(this.connectionSetting, true);
+        if (uriInfo.query.useConnectionPooling) {
+            this.isPool = true;
+            this.useConnectionPooling = uriInfo.query.useConnectionPooling;
+        } else {
+            this.isPool = false;
+        }
+
+        this.hostname = uriInfo.hostname;
+        this.port = uriInfo.port;
+        this.user = uriInfo.auth.split(':')[0];
+        this.password = uriInfo.auth.split(':')[1];
+        this.database = uriInfo.pathname.indexOf('/') == 0 ? uriInfo.pathname.substr(1) : uriInfo.pathname;
+        this.connectionlimit = uriInfo.query && uriInfo.query.connectionLimit ? parseInt(uriInfo.query.connectionLimit) : 10;
+        if (isNaN(this.connectionlimit)) {
+            this.connectionlimit = 10;
+        }
+        this.connection = null;
+        this.sqlInterceptor = null;
+        this.connectionStatus = this.connectionStatusEnum.Close; //0：未连接 1：已连接
+        this.hasTransaction = false;
+    }
+
+    get connectionlimit() {
+        return this._connectionlimit;
+    }
+
+    set connectionlimit(value) {
+        this._connectionlimit = value;
+    }
+
+    get hostname() {
+        return this._hostname;
+    }
+
+    set hostname(value) {
+        this._hostname = value;
+    }
+
+    get port() {
+        return this._port;
+    }
+
+    set port(value) {
+        this._port = value;
+    }
+
+    get user() {
+        return this._user;
+    }
+
+    set user(value) {
+        this._user = value;
+    }
+
+    get password() {
+        return this._password;
+    }
+
+    set password(value) {
+        this._password = value;
+    }
+
+    get database() {
+        return this._database;
+    }
+
+    set database(value) {
+        this._database = value;
+    }
+
+    get isPool() {
+        return this._isPool;
+    }
+
+    set isPool(value) {
+        this._isPool = value;
+    }
+
+    get connectionSetting() {
+        return this._connectionSetting;
+    }
+
+    set connectionSetting(value) {
+        this._connectionSetting = value;
+    }
+
+    get sqlInterceptor() {
+        return this._sqlInterceptor;
+    }
+
+    set sqlInterceptor(value) {
+        this._sqlInterceptor = value;
+    }
+
+    get connectionStatus() {
+        return this._connectionStatus;
+    }
+
+    set connectionStatus(value) {
+        this._connectionStatus = value;
+    }
+
+    get hasTransaction() {
+        return this._hasTransaction;
+    }
+
+    set hasTransaction(value) {
+        this._hasTransaction = value;
+    }
+
+    get errorStack() {
+        return this._errorStack;
+    }
+
+    set errorStack(value) {
+        this._errorStack = value;
+    }
+
+    get connection() {
+        return this._connection;
+    }
+
+    set connection(value) {
+        this._connection = value;
+    }
+
+    get useConnectionPooling() {
+        return this._useConnectionPooling;
+    }
+
+    set useConnectionPooling(value) {
+        this._useConnectionPooling = value;
+        BaseLib.setPoolName(this.poolName);
+    }
+
+    get poolName() {
+        return "_dataBasePool_" + (this.useConnectionPooling ? this.useConnectionPooling : "NoPool");
+    }
+
+    static setPoolName(poolName) {
+        if (BaseLib.poolNameList.indexOf(poolName) === -1) {
+            BaseLib.poolNameList.push(poolName);
+        }
+    }
+
+    static get poolNameList() {
+        if (BaseLib._poolNameList == null) {
+            BaseLib._poolNameList = new Array();
+        }
+
+        return BaseLib._poolNameList;
+    }
+
+    getConnectionFunction() { }
+
+    createPool() { }
+
+    createPoolConnection() {
+        var _this = this;
+        this.errorStack = new Error();
+        return new Promise(function(resolver, reject) {
+            _this.createPool();
+            _this.getConnectionFunction()(function(err, connection) {
+                _this.connection = connection;
+                _this._addError();
+                _this._connectionConnect(resolver, reject, err);
+            });
+        });
+    }
+
+    createSingleConnection() {
+        var _this = this;
+        this.errorStack = new Error();
+        this.connection = this.getConnectionFunction()(this.connectionSetting);
+        return new Promise(function(resolver, reject) {
+            _this._addError();
+            _this.connection.connect(function(err) {
+                _this._connectionConnect(resolver, reject, err);
+            });
+        });
+    }
+
+    getTableStruct(tablename) { }
+
+    beginTransaction() { }
+
+    commitTransaction() { }
+
+    rollbackTransaction() { }
+
+    close(callback, poolConnectionIsDestroy) {
+        if (this.connection == null) {
+            return;
+        }
+
+        this.connectionStatus = this.connectionStatusEnum.Close;
+        BaseLib.removeConnectionRecord(this.poolName);
+        BaseLib.removeConnectionObject(this.connection);
+    }
+
+    create() {
+        if (this.connection != null) {
+            return new Promise(function(resolver, reject) {
+                global.setTimeout(resolver);
+            });
+        } else {
+            return this.isPool ? this.createPoolConnection() : this.createSingleConnection();
+        }
+    }
+
+    query(sql, params) { }
+
+    _connectionEnd(err) {
+        if (err) {
+            DebugDBHelper("连接结束出错：" + err);
+        }
+    }
+
+    _handleDataBaseConnectionError(qerr, resolver, reject, sql, params) {
+        if (qerr) {
+            //附加日志，方便排查可能存在的泄漏问题
+            let fullErrorMsg = " __rawSQL:【" + JSON.stringify(sql) + "】 __stack:【" + (this._errorStack ? this._errorStack.stack : "") + "】";
+
+            if (typeof qerr === "string")
+                qerr += fullErrorMsg;
+            else if (typeof qerr === "object") {
+                qerr.__fullErrorMsg = fullErrorMsg;
+
+                if (qerr.message && typeof qerr.message === "string")
+                    qerr.message += fullErrorMsg;
+
+                if (qerr.stack && typeof qerr.stack === "string")
+                    qerr.stack += fullErrorMsg;
+            }
+
+            //统一处理错误
+            let errmsg = null;
+            this.close(null, true);
+            switch (qerr.code) {
+                case "PROTOCOL_CONNECTION_LOST":
+                case "PROTOCOL_ENQUEUE_AFTER_FATAL_ERROR":
+                case "PROTOCOL_ENQUEUE_AFTER_QUIT":
+                    let _this = this;
+                    global.setTimeout(function() {
+                        _this.query(sql, params).then(function(tempValue) {
+                            resolver(tempValue);
+                        },
+                            function(tempErr) {
+                                reject(tempErr);
+                            });
+                    });
+                    break;
+                case "ECONNREFUSED":
+                    errmsg = "数据库连接失败，请联系管理员";
+                    global.setTimeout(function() {
+                        reject(errmsg);
+                    });
+                    break;
+                default:
+                    global.setTimeout(function() {
+                        reject(qerr);
+                    });
+                    break;
+            }
+        }
+    }
+
+    limit(start, count) { }
+
+    toNumber(value) { }
+
+    IF(condition, truedata, falsedata) { }
+
+    IFNULL(expression, altValue) { }
+
+    SUBSTRING_INDEX(field, split, index) { }
+
+    Like(value) {
+        if (StringUtils.isNullOrEmpty(value)) return "";
+        var str = this.sqlEscape(value, null, null, false);
+        var buffer = new StringBuilder();
+        var arr = str.split('');
+        for (var i = 0, count = arr.length; i < count; i++) {
+            var ch = arr[i];
+            if (ch == '%' || ch == '\\' || ch == '_') {
+                buffer.append('\\').append(ch);
+            } else {
+                buffer.append(ch);
+            }
+        }
+        return buffer.toString();
+    }
+
+    sqlEscape(value, stringifyObjects, timeZone, isAddMake) {
+        isAddMake = isAddMake == null ? true : isAddMake;
+        let result = SqlString.escape(value, stringifyObjects, timeZone);
+        if (isAddMake)
+            return result;
+        else {
+            if (result.startsWith('\'') && result.endsWith('\'')) {
+                return result.substr(1, result.length - 2);
+            }
+
+            return result;
+        }
+    }
+
+    _addError() {
+        if (this.connection && !this.connection.__addErrorListener) {
+            let fun = this.isPool ? this._onPoolConnectError.bind(this) : this._onSingleConnectError.bind(this);
+            this.connection.on('error', fun);
+            this.connection.__addErrorListener = true;
+        }
+    }
+
+    _onPoolConnectError(error) {
+        DebugDBHelper("数据库连接池连接错误：" + error);
+    }
+
+    _onSingleConnectError(error) {
+        DebugDBHelper("单个数据库连接错误：" + error);
+    }
+
+    _connectionConnect(resolver, reject, err) {
+        if (this.connection) {
+            this.connection._stack = this.errorStack.stack;
+            this.connection._startDate = new Date();
+            this.connection._cuid = Cuid.newCuidString();
+            this.connection._isPool = this.isPool;
+
+            BaseLib.addConnectionRecord(this.poolName);
+            BaseLib.addConnectionObject(this.connection);
+        }
+
+        if (err) {
+            this.close(null, true);
+        } else {
+            this.connectionStatus = this.connectionStatusEnum.Open;
+        }
+
+        if (err == null)
+            resolver();
+        else
+            reject(err);
+    }
+
+    _queryFormat(query, values) {
+        if (!values) {
+            if (this.sqlInterceptor) this.sqlInterceptor(this, { sql: query, values: null });
+            return query;
+        }
+
+        let _this = this;
+        let encodeSql = query.replace(/\:(\w+)/g, function(txt, key) {
+            if (values.hasOwnProperty(key)) return _this.sqlEscape(values[key], false);
+            else return txt;
+        }.bind(this));
+
+        if (this.sqlInterceptor) this.sqlInterceptor(this, { sql: encodeSql, values: values });
+        return encodeSql;
+    }
+
+    static addConnectionRecord(poolName) {
+        let value = BaseLib.getConnectionRecord(poolName);
+        value += 1;
+        BaseLib.getPoolConnectionRecordMap().set(poolName, value);
+    }
+
+    static removeConnectionRecord(poolName) {
+        let value = BaseLib.getConnectionRecord(poolName);
+        value -= 1;
+        BaseLib.getPoolConnectionRecordMap().set(poolName, value);
+    }
+
+    static getPoolInfoList() {
+        let poolNameList = BaseLib.poolNameList;
+        let poolInfoList = new Array();
+        for (let i = 0; i < poolNameList.length; i++) {
+            let poolName = poolNameList[i];
+            let nowConnectionCount = BaseLib.getConnectionRecord(poolName);
+            let poolInfo = {
+                name: poolName,
+                nowConnectionCount: nowConnectionCount
+            };
+            poolInfoList.push(poolInfo);
+        }
+        return poolInfoList;
+    }
+
+    static getPoolConnectionRecordMap() {
+        if (BaseLib._poolConnectionRecordMap == null)
+            BaseLib._poolConnectionRecordMap = new Map();
+        return BaseLib._poolConnectionRecordMap;
+    }
+
+    static getConnectionRecord(poolName) {
+        let value = BaseLib.getPoolConnectionRecordMap().get(poolName);
+        if (value == null)
+            value = 0;
+        return value;
+    }
+
+    static addConnectionObject(connection) {
+        if (!connection) {
+            return;
+        }
+
+        let map = BaseLib.getConnectionObjectMap();
+        if (map.has(connection._cuid)) {
+            console.log("连接ID重复：" + connection._cuid + " 堆栈：" + connection._stack);
+        } else {
+            map.set(connection._cuid, connection);
+        }
+    }
+
+    static removeConnectionObject(connection) {
+        if (!connection) {
+            return;
+        }
+
+        let map = BaseLib.getConnectionObjectMap();
+        if (map.has(connection._cuid)) {
+            map.delete(connection._cuid);
+        } else {
+            console.log("连接ID不存在：" + connection._cuid + " 堆栈：" + connection._stack);
+        }
+
+        BaseLib._printfTimeoutConnectionObject();
+    }
+
+    static getConnectionObjectMap() {
+        if (BaseLib._connectionObjectMap == null)
+            BaseLib._connectionObjectMap = new Map();
+        return BaseLib._connectionObjectMap;
+    }
+
+    static _printfTimeoutConnectionObject() {
+        let map = BaseLib.getConnectionObjectMap();
+        let nowDateTicks = new Date().getTime();
+        let dbConnectOccupyTimeout = 600000;
+        map.forEach(function(value, key, map) {
+            if (value._printfTimeoutConnectionObject == null && value._isPool && value._startDate.getTime() + dbConnectOccupyTimeout < nowDateTicks) {
+                console.log("连接池连接ID超时：" + value._cuid + " 堆栈：" + value._stack);
+                value._printfTimeoutConnectionObject = true;
+            }
+        });
+    }
+
+    static _startKillLockConnectionService() {
+        if (BaseLib._startKillLockConnection) return;
+
+        BaseLib._startKillLockConnection = true;
+        BaseLib._killLockConnectionService();
+    }
+
+    static _killLockConnectionService() {
+        //连接池死锁检测需求保留
+    }
+}
+
+module.exports = BaseLib;