cgserver 6.0.5 → 6.0.8

package/dist/lib/Database/RedisManager.js

@@ -0,0 +1,408 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisManager = exports.GRedisMgr = void 0;
+const Log_1 = require("../Logic/Log");
+const redis = require("redis");
+exports.GRedisMgr = null;
+class RedisManager {
+    _redis = null;
+    get redis() {
+        return this._redis;
+    }
+    _resis_init_succ = false;
+    _redisCfg = null;
+    constructor() {
+    }
+    async init(redisCfg) {
+        return new Promise((resolve) => {
+            if (!redisCfg || !redisCfg.open) {
+                resolve(null);
+                return;
+            }
+            if (this._redis) {
+                resolve(null);
+                return;
+            }
+            this._redisCfg = redisCfg;
+            Log_1.GLog.info("begin conect redis=" + JSON.stringify(redisCfg), true);
+            this._redis = redis.createClient(redisCfg.port, redisCfg.host, { parser: "javascript", return_buffers: false, connect_timeout: 3000, password: redisCfg.password });
+            this._redis.on("connect", () => {
+                this.onConnect();
+                resolve(null);
+            });
+            this._redis.on("end", this.onEnd.bind(this));
+            this._redis.on("error", this.onError.bind(this));
+        });
+    }
+    onConnect() {
+        if (this._redisCfg.database) {
+            this._redis.select(this._redisCfg.database);
+        }
+        this._resis_init_succ = true;
+        Log_1.GLog.info("redis has connected!", true);
+    }
+    onEnd() {
+        this._resis_init_succ = false;
+        this._redis = null;
+        this.init(this._redisCfg); //重连
+    }
+    onError(err) {
+        Log_1.GLog.info("Error connected=" + this._redis.connected + ": " + err, true);
+    }
+    expire(key, seconds) {
+        return new Promise((resolve, reject) => {
+            if (!this._redis) {
+                resolve(null);
+                return;
+            }
+            this._redis.expire(key, seconds, (err, reply) => {
+                if (err) {
+                    Log_1.GLog.error(err);
+                }
+                resolve(reply);
+            });
+        });
+    }
+    incr(key) {
+        return new Promise((resolve, reject) => {
+            if (!this._redis) {
+                resolve(null);
+                return;
+            }
+            this._redis.incr(key, (err, reply) => {
+                if (err) {
+                    Log_1.GLog.error(err);
+                }
+                resolve(reply);
+            });
+        });
+    }
+    set(key, value) {
+        return new Promise((resolve, reject) => {
+            if (!this._redis) {
+                resolve(null);
+                return;
+            }
+            this._redis.set(key, value, (err, reply) => {
+                if (err) {
+                    Log_1.GLog.error(err);
+                }
+                resolve(reply);
+            });
+        });
+    }
+    get(key) {
+        return new Promise((resolve, reject) => {
+            if (!this._redis) {
+                resolve(null);
+                return;
+            }
+            this._redis.get(key, (err, reply) => {
+                if (err) {
+                    Log_1.GLog.error(err);
+                }
+                resolve(reply);
+            });
+        });
+    }
+    /**
+     *
+     * @param key
+     * @param cb 有表示异步
+     */
+    del(key, cb) {
+        return new Promise((resolve, reject) => {
+            if (!this._redis) {
+                resolve(null);
+                return;
+            }
+            this._redis.del(key, (err, reply) => {
+                if (err) {
+                    Log_1.GLog.error(err);
+                }
+                resolve(reply);
+            });
+        });
+    }
+    hset(h, key, value) {
+        return new Promise((resolve, reject) => {
+            if (!this._redis) {
+                resolve(null);
+                return;
+            }
+            this._redis.hset(h, key, value, (err, reply) => {
+                if (err) {
+                    Log_1.GLog.error(err);
+                }
+                resolve(reply);
+            });
+        });
+    }
+    hget(h, key) {
+        return new Promise((resolve, reject) => {
+            if (!this._redis) {
+                resolve(null);
+                return;
+            }
+            this._redis.hget(h, key, (err, reply) => {
+                if (err) {
+                    Log_1.GLog.error(err);
+                }
+                resolve(reply);
+            });
+        });
+    }
+    hdel(key, sub_key) {
+        return new Promise((resolve, reject) => {
+            if (!this._redis) {
+                resolve(null);
+                return;
+            }
+            this._redis.hdel(key, sub_key, (err, reply) => {
+                if (err) {
+                    Log_1.GLog.error(err);
+                }
+                resolve(reply);
+            });
+        });
+    }
+    /**
+     * hash值，能转换位整数的就自动转换为整数
+     * @param h key
+     */
+    hgetall(h) {
+        return new Promise((resolve, reject) => {
+            if (!this._redis) {
+                resolve(null);
+                return;
+            }
+            this._redis.hgetall(h, (err, replys) => {
+                if (err) {
+                    Log_1.GLog.error(err);
+                    resolve(replys);
+                    return;
+                }
+                let value = {};
+                for (let k in replys) {
+                    let v = replys[k];
+                    let iv = parseInt(v);
+                    if (v == "" + iv) {
+                        value[k] = iv;
+                    }
+                    else {
+                        value[k] = v;
+                    }
+                }
+                if (!replys) {
+                    value = null;
+                }
+                resolve(value);
+            });
+        });
+    }
+    /**
+     *
+     * @param h
+     * @param array
+     */
+    hmset(h, array) {
+        return new Promise((resolve, reject) => {
+            if (!this._redis) {
+                resolve(null);
+                return;
+            }
+            this._redis.hmset(h, array, (err, replys) => {
+                if (err) {
+                    Log_1.GLog.error(err);
+                }
+                resolve(replys);
+            });
+        });
+    }
+    lpush(key, array) {
+        return new Promise((resolve, reject) => {
+            if (!this._redis) {
+                resolve(null);
+                return;
+            }
+            this._redis.lpush(key, array, (err, replys) => {
+                if (err) {
+                    Log_1.GLog.error(err);
+                }
+                resolve(replys);
+            });
+        });
+    }
+    lrange(key, start, end) {
+        return new Promise((resolve, reject) => {
+            if (!this._redis) {
+                resolve(null);
+                return;
+            }
+            if (!this._redis) {
+                return null;
+            }
+            if (!start) {
+                start = 0;
+            }
+            if (!end) {
+                end = -1;
+            }
+            this._redis.lrange(key, start, end, (err, replys) => {
+                if (err) {
+                    Log_1.GLog.error(err);
+                }
+                resolve(replys);
+            });
+        });
+    }
+    ltrim(key, start, end) {
+        return new Promise((resolve, reject) => {
+            if (!this._redis) {
+                resolve(null);
+                return;
+            }
+            if (!this._redis) {
+                return null;
+            }
+            if (!start) {
+                start = 0;
+            }
+            if (!end) {
+                end = -1;
+            }
+            this._redis.ltrim(key, start, end, (err, replys) => {
+                if (err) {
+                    Log_1.GLog.error(err);
+                }
+                resolve(replys);
+            });
+        });
+    }
+    sadd(key, array) {
+        return new Promise((resolve, reject) => {
+            if (!this._redis) {
+                resolve(null);
+                return;
+            }
+            this._redis.sadd(key, array, (err, replys) => {
+                if (err) {
+                    Log_1.GLog.error(err);
+                }
+                resolve(replys);
+            });
+        });
+    }
+    smembers(key) {
+        return new Promise((resolve, reject) => {
+            if (!this._redis) {
+                resolve(null);
+                return;
+            }
+            this._redis.smembers(key, (err, replys) => {
+                if (err) {
+                    Log_1.GLog.error(err);
+                }
+                resolve(replys);
+            });
+        });
+    }
+    srem(key, array) {
+        return new Promise((resolve, reject) => {
+            if (!this._redis) {
+                resolve(null);
+                return;
+            }
+            this._redis.srem(key, array, (err, replys) => {
+                if (err) {
+                    Log_1.GLog.error(err);
+                }
+                resolve(replys);
+            });
+        });
+    }
+    keys(key) {
+        return new Promise((resolve, reject) => {
+            if (!this._redis) {
+                resolve(null);
+                return;
+            }
+            this._redis.keys(key, (err, replys) => {
+                if (err) {
+                    Log_1.GLog.error(err);
+                }
+                resolve(replys);
+            });
+        });
+    }
+    multi() {
+        if (!this._redis) {
+            return null;
+        }
+        return this._redis.multi();
+    }
+    exists(key) {
+        return new Promise((resolve, reject) => {
+            if (!this._redis) {
+                resolve(null);
+                return;
+            }
+            this._redis.exists(key, (err, replys) => {
+                if (err) {
+                    Log_1.GLog.error(err);
+                }
+                resolve(replys);
+            });
+        });
+    }
+    exec(multi) {
+        return new Promise((resolve, reject) => {
+            if (!this._redis || !multi) {
+                resolve(null);
+                return;
+            }
+            multi.exec((err, replys) => {
+                if (err) {
+                    Log_1.GLog.error(err);
+                }
+                resolve(replys);
+            });
+        });
+    }
+    publish(channel, value) {
+        return new Promise((resolve, reject) => {
+            if (!this._redis) {
+                resolve(null);
+                return;
+            }
+            this._redis.publish(channel, value, (err, num) => {
+                if (err) {
+                    Log_1.GLog.error(err);
+                }
+                resolve(num);
+            });
+        });
+    }
+    subscribe(channel) {
+        return new Promise((resolve, reject) => {
+            if (!this._redis) {
+                resolve(null);
+                return;
+            }
+            this._redis.subscribe(channel, (err, msg) => {
+                if (err) {
+                    Log_1.GLog.error(err);
+                }
+                resolve(msg);
+            });
+        });
+    }
+    on(message, cb) {
+        if (!this._redis) {
+            return;
+        }
+        this._redis.on(message, cb);
+    }
+}
+exports.RedisManager = RedisManager;
+exports.GRedisMgr = new RedisManager();

package/dist/lib/Logic/CacheTool.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GCacheTool = void 0;
+const _ = require("underscore");
+exports.GCacheTool = null;
+class CacheItem {
+    key = "";
+    value = null;
+    milliseconds = 0;
+    expire_time = -1;
+}
+class CacheTool {
+    _items = new Map();
+    constructor() {
+        //一个小时清除一次过期缓存
+        setInterval(this._refresh.bind(this), 60 * 60 * 1000);
+    }
+    /**
+     * 定时清除缓存
+     */
+    _refresh() {
+        let time = new Date().getTime();
+        let keys = _.clone(this._items.keys);
+        for (let i in keys) {
+            let key = keys[i];
+            let item = this._items[key];
+            if (!item) {
+                delete this._items[key];
+                continue;
+            }
+            if (time > item.expire_time) {
+                this.remove(key);
+            }
+        }
+    }
+    get(key, refresh) {
+        let item = this._items[key];
+        if (!item) {
+            return;
+        }
+        let time = new Date().getTime();
+        if (time > item.expire_time) {
+            this.remove(key);
+            return;
+        }
+        if (refresh) {
+            item.expire_time = time + item.milliseconds;
+        }
+        return item.value;
+    }
+    /**
+     *
+     * @param key
+     * @param value
+     * @param time 缓存的毫秒数
+     */
+    add(key, value, milliseconds) {
+        let item = this._items[key];
+        if (!item) {
+            item = new CacheItem();
+            item.key = key;
+            this._items[key] = item;
+        }
+        item.value = value;
+        item.milliseconds = milliseconds;
+        item.expire_time = new Date().getTime() + milliseconds;
+    }
+    remove(key) {
+        this._items[key] = null;
+        delete this._items[key];
+    }
+}
+exports.GCacheTool = new CacheTool();

package/dist/lib/Logic/HttpTool.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GHttpTool = void 0;
+const request = require("request");
+const qs = require("querystring");
+const Log_1 = require("./Log");
+exports.GHttpTool = null;
+class HttpTool {
+    httpRequest(url, noParse) {
+        return new Promise((resolve, reject) => {
+            request.get(url, {
+                strictSSL: false,
+                rejectUnauthorized: false
+            }, (error, response, body) => {
+                if (!noParse) {
+                    try {
+                        if (body) {
+                            body = JSON.parse(body);
+                        }
+                    }
+                    catch (e) {
+                        try {
+                            body = qs.parse(body);
+                        }
+                        catch (e) { }
+                    }
+                }
+                resolve({ error, response, body });
+            });
+        });
+    }
+    httpPost(url, form) {
+        return new Promise((resolve, reject) => {
+            request.post({ url: url, form: form }, (error, response, body) => {
+                let bd = body;
+                if (error) {
+                    Log_1.GLog.error("post:" + url);
+                    Log_1.GLog.error(error);
+                }
+                try {
+                    if (body) {
+                        body = JSON.parse(body);
+                    }
+                }
+                catch (e) {
+                    try {
+                        body = qs.parse(body);
+                    }
+                    catch (e) {
+                        body = bd;
+                    }
+                }
+                resolve({ error, response, body });
+            });
+        });
+    }
+}
+exports.GHttpTool = new HttpTool();

package/dist/lib/Logic/Log.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GLog = void 0;
+const Core_1 = require("../Core/Core");
+const colors = require("colors");
+const log4js = require("log4js");
+/**
+ * 输出颜色
+ */
+colors.setTheme({
+    silly: 'rainbow',
+    input: 'grey',
+    verbose: 'cyan',
+    prompt: 'red',
+    info: 'green',
+    data: 'blue',
+    help: 'cyan',
+    warn: 'yellow',
+    debug: 'magenta',
+    error: 'red'
+});
+exports.GLog = null;
+class Log {
+    //default log
+    _logger = null;
+    //the log from client
+    _client_logger = null;
+    //error and warn
+    _errorLogger = null;
+    _inited = false;
+    init(cfg) {
+        if (this._inited) {
+            return;
+        }
+        this._inited = true;
+        colors.enable();
+        log4js.configure(cfg);
+        this._logger = log4js.getLogger(cfg.categories.default.appenders[0] || "log_date");
+        this._client_logger = log4js.getLogger(cfg.categories.default.appenders[1] || "client_log_date");
+        this._errorLogger = log4js.getLogger(cfg.categories.default.appenders[2] || "error_log_file");
+    }
+    error(message, ...optionalParams) {
+        if (Core_1.core.isObject(message)) {
+            message = JSON.stringify(message);
+        }
+        this._errorLogger.error(message);
+        var time = new Date();
+        var time_str = Core_1.core.format(time, "[YYYY-MM-DD HH:mm:SS.");
+        time_str += time.getMilliseconds() + "]";
+        console.error(time_str + " " + message);
+    }
+    info(message, to_console) {
+        if (Core_1.core.isObject(message)) {
+            message = JSON.stringify(message);
+        }
+        this._logger.info(message);
+        if (to_console) {
+            var time = new Date();
+            var time_str = Core_1.core.format(time, "[YYYY-MM-DD HH:mm:SS.");
+            time_str += time.getMilliseconds() + "]";
+            console.log(time_str + " " + message);
+        }
+    }
+    warn(message, ...optionalParams) {
+        if (Core_1.core.isObject(message)) {
+            message = JSON.stringify(message);
+        }
+        this._errorLogger.warn(message);
+    }
+    record(message, ...optionalParams) {
+        this.info(message, optionalParams);
+    }
+    clientLog(message, ...optionalParams) {
+        this._client_logger.error(message);
+    }
+}
+exports.GLog = new Log();