server-libs/src/CacheMoudle.js

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const Util_1 = require("./Util");
const fs_1 = require("fs");
const path_1 = require("path");
const exec_pools_1 = require("./exec_pools");
const cluster_1 = __importDefault(require("cluster"));
// 先提供一个同步版本的获取信息
class CacheMoudle {
    constructor(name, ttl, keep) {
        this.valueCache = {};
        this.getfresh = false;
        this.ttl = 0;
        this.name = '';
        this.change = false;
        this.name = name || '';
        this.ttl = ttl || this.ttl;
        keep = keep || { type: "unknow" };
        switch (keep.type) {
            case 'mongo':
                this.loader = new Keep_Mongo(this.name, keep);
                break;
            case 'file': {
                this.loader = new Keep_File(this.name, keep);
                break;
            }
            default: {
                this.loader = new Keep_base(this.name, keep);
                break;
            }
        }
    }
    /**5s 检查一次 */
    static init() {
        if (this.handle) {
            this.handle.stop();
        }
        this.handle = Util_1.Util.setInterval(CacheMoudle.update.bind(CacheMoudle), 5 * 1000);
        return Promise.resolve();
    }
    /**
     * 创建cache
     * @param name 模块名字 如果没有名字将不支持自动update功能
     * @param ttl 数据有效期 等于0的时候不更新 小于0的时候不计算ttl
     */
    static createCache(name, ttl, keep) {
        if (name == undefined) {
            return new CacheMoudle(name, ttl, keep);
        }
        else {
            if (!this.cacheMap.hasOwnProperty(name)) {
                this.cacheMap[name] = new CacheMoudle(name, ttl, keep);
            }
            this.thread = Math.ceil(Math.sqrt(Object.keys(this.cacheMap).length));
            return this.cacheMap[name];
        }
    }
    // 移除cache
    static removeCache(name) {
        delete this.cacheMap[name];
    }
    static update() {
        return __awaiter(this, void 0, void 0, function* () {
            let curr = Date.now();
            let list = [];
            for (let key in CacheMoudle.cacheMap) {
                let unit = CacheMoudle.cacheMap[key];
                list.push(unit._update.bind(unit));
            }
            yield exec_pools_1.execPools(list, this.thread, curr);
            return Promise.resolve();
        });
    }
    init() {
        return __awaiter(this, void 0, void 0, function* () {
            if (!this.loader)
                return true;
            this.valueCache = yield this.loader.load();
            return true;
        });
    }
    /**
     *
     * @param key
     * @param value 内容
     * @param time 当  ttl 大于等于0时设置的当前时间或者不设置，ttl小于0时设置过期的时间
     */
    set(key, value, time) {
        return __awaiter(this, void 0, void 0, function* () {
            let change = false;
            if (!this.valueCache.hasOwnProperty(key)) {
                this.valueCache[key] = { value: value, time: time || Date.now() };
                change = true;
            }
            else {
                if (time && this.valueCache[key].time != time) {
                    this.valueCache[key].time = time;
                    change = true;
                }
                if (this.valueCache[key].value != value || JSON.stringify(this.valueCache[key].value) != JSON.stringify(value)) {
                    this.valueCache[key].value = value;
                    change = true;
                }
            }
            if (change)
                yield this.loader.set(key, this.valueCache[key].value, this.valueCache[key].time);
            return true;
        });
    }
    has(key) {
        return this.hasOwnProperty(key);
    }
    hasOwnProperty(key) {
        return this.valueCache.hasOwnProperty(key);
    }
    get(key) {
        if (this.valueCache.hasOwnProperty(key)) {
            if (this.getfresh && this.ttl > 0) {
                this.valueCache[key].time = Date.now();
            }
            return this.valueCache[key].value;
        }
        else
            return undefined;
    }
    del(key) {
        return __awaiter(this, void 0, void 0, function* () {
            if (!this.valueCache.hasOwnProperty(key))
                return;
            delete this.valueCache[key];
            return yield this.loader.del(key);
        });
    }
    /**
     * 遍历内容
     * @param cb 当方法返回 true时 结束遍历(break)
     */
    forEach(cb) {
        for (let key in this.valueCache) {
            if (cb(this.valueCache[key].value, key)) {
                return this.valueCache[key].value;
            }
        }
        return undefined;
    }
    clear() {
        this.valueCache = {};
        this.change = true;
    }
    _update(curr) {
        return __awaiter(this, void 0, void 0, function* () {
            // 增加淘汰算法空间
            if (this.ttl == 0) {
                yield this.loader.save();
                return;
            }
            let ttl = this.ttl;
            if (ttl < 0)
                ttl = 0;
            for (let key in this.valueCache) {
                let unit = this.valueCache[key];
                if (unit.time + ttl < curr) {
                    yield this.del(key);
                }
            }
            yield this.loader.save();
            return;
        });
    }
}
exports.CacheMoudle = CacheMoudle;
CacheMoudle.thread = 1;
CacheMoudle.cacheMap = {};
class Keep_base {
    constructor(name, keep) {
    }
    set(key, value) {
        return __awaiter(this, void 0, void 0, function* () {
            return true;
        });
    }
    load() {
        return __awaiter(this, void 0, void 0, function* () {
            return {};
        });
    }
    save() {
        return __awaiter(this, void 0, void 0, function* () {
            return true;
        });
    }
    del(key) {
        return __awaiter(this, void 0, void 0, function* () {
            return true;
        });
    }
}
class Keep_Mongo {
    constructor(name, keep) {
        this._data = {};
        this.keep = keep;
        this.name = name;
    }
    load() {
        return __awaiter(this, void 0, void 0, function* () {
            let list = yield this.keep.path.get_list(this.name, {}).load();
            for (let i = 0; i < list.length; i++) {
                let unit = list.get_at(i);
                if (!unit)
                    continue;
                this._data[unit._id] = { value: unit.value, time: unit.time };
            }
            return this._data;
        });
    }
    set(key, value, time) {
        return __awaiter(this, void 0, void 0, function* () {
            this._data[key] = { value: value, time: time };
            this.keep.path.update(this.name, { _id: key }, { value: value, time: time }, true);
        });
    }
    save() {
        return __awaiter(this, void 0, void 0, function* () {
            return;
        });
    }
    del(key) {
        return __awaiter(this, void 0, void 0, function* () {
            if (!this._data.hasOwnProperty(key)) {
                return;
            }
            delete this._data[key];
            yield this.keep.path.del(this.name, { _id: key });
            return true;
        });
    }
}
class Keep_File {
    constructor(name, keep) {
        this._data = {};
        this._change = false;
        this.keep = keep;
        this.name = name;
    }
    load() {
        return __awaiter(this, void 0, void 0, function* () {
            if (!this.keep.path || typeof this.keep.path != 'string') {
                return this._data;
            }
            let preID = cluster_1.default.isWorker ? cluster_1.default.worker.id.toString() : '';
            try {
                this._data = JSON.parse(fs_1.readFileSync(path_1.join(this.keep.path, this.name + '|' + preID + '.json')).toString() || "{}");
            }
            catch (e) {
            }
            return this._data;
        });
    }
    save() {
        return __awaiter(this, void 0, void 0, function* () {
            if (!this._change)
                return;
            if (!fs_1.existsSync(this.keep.path))
                fs_1.mkdirSync(this.keep.path, { recursive: true });
            fs_1.writeFileSync(path_1.join(this.keep.path, this.name + '.json'), JSON.stringify(this._data, null, 4), { flag: 'w+' });
            return;
        });
    }
    set(key, value, time) {
        return __awaiter(this, void 0, void 0, function* () {
            this._data[key] = { value, time };
            this._change = true;
        });
    }
    del(key) {
        return __awaiter(this, void 0, void 0, function* () {
            if (!this._data.hasOwnProperty(key)) {
                return;
            }
            this._change = true;
            delete this._data[key];
            return true;
        });
    }
}