@bigtyphoon/melo 1.7.6

package/dist/lib/server/server.js

@@ -0,0 +1,500 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.manualReloadCrons = exports.Server = exports.create = void 0;
+/**
+ * Implementation of server component.
+ * Init and start server instance.
+ */
+const melo_logger_1 = require("@bigtyphoon/melo-logger");
+const path = require("path");
+const pathUtil = require("../util/pathUtil");
+const Loader = require("@bigtyphoon/melo-loader");
+const melo_loader_1 = require("@bigtyphoon/melo-loader");
+const utils = require("../util/utils");
+const schedule = require("@bigtyphoon/melo-scheduler");
+const events_1 = require("../util/events");
+const Constants = require("../util/constants");
+const filterService_1 = require("../common/service/filterService");
+const handlerService_1 = require("../common/service/handlerService");
+const events_2 = require("events");
+let logger = (0, melo_logger_1.getLogger)('melo', path.basename(__filename));
+let ST_INITED = 0; // server inited
+let ST_STARTED = 1; // server started
+let ST_STOPED = 2; // server stoped
+/**
+ * Server factory function.
+ *
+ * @param {Object} app  current application context
+ * @return {Object} erver instance
+ */
+function create(app, opts) {
+    return new Server(app, opts);
+}
+exports.create = create;
+class Server extends events_2.EventEmitter {
+    constructor(app, opts) {
+        super();
+        this.globalFilterService = null;
+        this.filterService = null;
+        this.handlerService = null;
+        this.cronHandlers = null;
+        this.crons = [];
+        this.jobs = {};
+        this.state = ST_INITED;
+        this.opts = opts || {};
+        this.app = app;
+        app.event.on(events_1.default.ADD_CRONS, this.addCrons.bind(this));
+        app.event.on(events_1.default.REMOVE_CRONS, this.removeCrons.bind(this));
+    }
+    /**
+     * Server lifecycle callback
+     */
+    start() {
+        if (this.state > ST_INITED) {
+            return;
+        }
+        this.globalFilterService = initFilter(true, this.app);
+        this.filterService = initFilter(false, this.app);
+        this.handlerService = initHandler(this.app, this.opts);
+        this.loadCrons();
+        this.state = ST_STARTED;
+    }
+    loadCrons(manualReload = false, clear = false) {
+        if (manualReload) {
+            logger.info('loadCrons remove crons', this.crons);
+            this.removeCrons(this.crons);
+            if (clear) {
+                this.crons = [];
+            }
+        }
+        this.cronHandlers = loadCronHandlers(this.app, manualReload);
+        loadCrons(this, this.app, manualReload);
+        if (manualReload) {
+            scheduleCrons(this, this.crons);
+        }
+    }
+    afterStart() {
+        scheduleCrons(this, this.crons);
+    }
+    /**
+     * Stop server
+     */
+    stop() {
+        this.state = ST_STOPED;
+    }
+    /**
+     * Global handler.
+     *
+     * @param  {Object} msg request message
+     * @param  {Object} session session object
+     * @param  {Callback} callback function
+     */
+    globalHandle(msg, session, cb) {
+        if (this.state !== ST_STARTED) {
+            utils.invokeCallback(cb, new Error('server not started'));
+            return;
+        }
+        let routeRecord = parseRoute(msg.route);
+        if (!routeRecord) {
+            utils.invokeCallback(cb, new Error(`meet unknown route message ${msg.route}`));
+            return;
+        }
+        if (routeRecord.method === 'constructor') {
+            logger.warn('attack session:', session, msg);
+            this.app.sessionService.kickBySessionId(session.id, 'attack');
+            return;
+        }
+        let self = this;
+        let dispatch = function (err, resp) {
+            if (err) {
+                handleError(true, self, err, msg, session, resp, function (err, resp) {
+                    response(true, self, err, routeRecord, msg, session, resp, cb);
+                });
+                return;
+            }
+            if (self.app.getServerType() !== routeRecord.serverType) {
+                doForward(self.app, msg, session, routeRecord, function (err, resp) {
+                    response(true, self, err, routeRecord, msg, session, resp, cb);
+                });
+            }
+            else {
+                doHandle(self, msg, session, routeRecord, function (err, resp) {
+                    response(true, self, err, routeRecord, msg, session, resp, cb);
+                });
+            }
+        };
+        beforeFilter(true, self, routeRecord, msg, session, dispatch);
+    }
+    /**
+     * Handle request
+     */
+    handle(msg, session, cb) {
+        if (this.state !== ST_STARTED) {
+            cb(new Error('server not started'));
+            return;
+        }
+        let routeRecord = parseRoute(msg.route);
+        doHandle(this, msg, session, routeRecord, cb);
+    }
+    /**
+     * Add crons at runtime.
+     *
+     * @param {Array} crons would be added in application
+     */
+    addCrons(crons) {
+        this.cronHandlers = loadCronHandlers(this.app);
+        for (let i = 0, l = crons.length; i < l; i++) {
+            let cron = crons[i];
+            checkAndAdd(cron, this.crons, this);
+        }
+        scheduleCrons(this, crons);
+    }
+    /**
+     * Remove crons at runtime.
+     *
+     * @param {Array} crons would be removed in application
+     */
+    removeCrons(crons) {
+        for (let i = 0, l = crons.length; i < l; i++) {
+            let cron = crons[i];
+            let id = cron.id;
+            if (!!this.jobs[id]) {
+                schedule.cancelJob(this.jobs[id]);
+                delete this.jobs[id];
+            }
+            else {
+                logger.warn('cron is not in application: %j', cron);
+            }
+        }
+    }
+}
+exports.Server = Server;
+// 重置 crons 缓存，  手动添加的crons只会取消任务重新加载任务。
+// clear 控制重新加载之前是否先清除原有的.
+// 有的 cron 是通过运行时动态添加进来的. 所以不能直接清除, 所以只能添加选项自己来控制
+function manualReloadCrons(app, clear = false) {
+    if (!app.components.__server__) {
+        return;
+    }
+    logger.info('manualReloadCrons start');
+    app.components.__server__.server.loadCrons(true, clear);
+    logger.info('manualReloadCrons finish');
+}
+exports.manualReloadCrons = manualReloadCrons;
+let initFilter = function (isGlobal, app) {
+    let service = new filterService_1.FilterService();
+    let befores, afters;
+    if (isGlobal) {
+        befores = app.get(Constants.KEYWORDS.GLOBAL_BEFORE_FILTER);
+        afters = app.get(Constants.KEYWORDS.GLOBAL_AFTER_FILTER);
+    }
+    else {
+        befores = app.get(Constants.KEYWORDS.BEFORE_FILTER);
+        afters = app.get(Constants.KEYWORDS.AFTER_FILTER);
+    }
+    let i, l;
+    if (befores) {
+        for (i = 0, l = befores.length; i < l; i++) {
+            service.before(befores[i]);
+        }
+    }
+    if (afters) {
+        for (i = 0, l = afters.length; i < l; i++) {
+            service.after(afters[i]);
+        }
+    }
+    return service;
+};
+let initHandler = function (app, opts) {
+    return new handlerService_1.HandlerService(app, opts);
+};
+/**
+ * Load cron handlers from current application
+ */
+let loadCronHandlers = function (app, manualReload = false) {
+    let all = {};
+    let p = pathUtil.getCronPath(app.getBase(), app.getServerType());
+    if (p) {
+        let crons = Loader.load(p, app, manualReload, true, melo_loader_1.LoaderPathType.PINUS_CRONNER);
+        for (let name in crons) {
+            all[name] = crons[name];
+        }
+    }
+    for (let plugin of app.usedPlugins) {
+        if (plugin.cronPath) {
+            if (!_checkCanRequire(plugin.cronPath)) {
+                logger.error(`插件[${plugin.name}的cronPath[${plugin.cronPath}不存在。]]`);
+                continue;
+            }
+            let crons = Loader.load(plugin.cronPath, app, manualReload, true, melo_loader_1.LoaderPathType.PINUS_CRONNER);
+            for (let name in crons) {
+                all[name] = crons[name];
+            }
+        }
+    }
+    return all;
+};
+const clearRequireCache = function (path) {
+    const moduleObj = require.cache[path];
+    if (!moduleObj) {
+        return;
+    }
+    if (moduleObj.parent) {
+        moduleObj.parent.children.splice(moduleObj.parent.children.indexOf(moduleObj), 1);
+    }
+    delete require.cache[path];
+};
+function _checkCanRequire(path, manualReload = false) {
+    try {
+        path = require.resolve(path);
+        if (manualReload) {
+            clearRequireCache(path);
+        }
+    }
+    catch (err) {
+        return null;
+    }
+    return path;
+}
+/**
+ * Load crons from configure file
+ */
+let loadCrons = function (server, app, manualReload = false) {
+    let env = app.get(Constants.RESERVED.ENV);
+    let p = path.join(app.getBase(), Constants.FILEPATH.CRON);
+    if (!_checkCanRequire(p, manualReload)) {
+        p = path.join(app.getBase(), Constants.FILEPATH.CONFIG_DIR, env, path.basename(Constants.FILEPATH.CRON));
+        if (!_checkCanRequire(p, manualReload)) {
+            return;
+        }
+    }
+    app.loadConfigBaseApp(Constants.RESERVED.CRONS, Constants.FILEPATH.CRON);
+    let crons = app.get(Constants.RESERVED.CRONS);
+    for (let serverType in crons) {
+        if (app.serverType === serverType) {
+            let list = crons[serverType];
+            for (let i = 0; i < list.length; i++) {
+                if (!list[i].serverId) {
+                    checkAndAdd(list[i], server.crons, server, manualReload);
+                }
+                else {
+                    if (app.serverId === list[i].serverId) {
+                        checkAndAdd(list[i], server.crons, server, manualReload);
+                    }
+                }
+            }
+        }
+    }
+};
+/**
+ * Fire before filter chain if any
+ */
+let beforeFilter = function (isGlobal, server, routeRecord, msg, session, cb) {
+    let fm;
+    if (isGlobal) {
+        fm = server.globalFilterService;
+    }
+    else {
+        fm = server.filterService;
+    }
+    if (fm) {
+        fm.beforeFilter(routeRecord, msg, session, cb);
+    }
+    else {
+        utils.invokeCallback(cb);
+    }
+};
+/**
+ * Fire after filter chain if have
+ */
+let afterFilter = function (isGlobal, server, err, routeRecord, msg, session, resp, cb) {
+    let fm;
+    if (isGlobal) {
+        fm = server.globalFilterService;
+    }
+    else {
+        fm = server.filterService;
+    }
+    if (fm) {
+        if (isGlobal) {
+            fm.afterFilter(err, routeRecord, msg, session, resp, function () {
+                // do nothing
+            });
+        }
+        else {
+            fm.afterFilter(err, routeRecord, msg, session, resp, function (err) {
+                cb(err, resp);
+            });
+        }
+    }
+};
+/**
+ * pass err to the global error handler if specified
+ */
+let handleError = function (isGlobal, server, err, msg, session, resp, cb) {
+    let handler;
+    if (isGlobal) {
+        handler = server.app.get(Constants.RESERVED.GLOBAL_ERROR_HANDLER);
+    }
+    else {
+        handler = server.app.get(Constants.RESERVED.ERROR_HANDLER);
+    }
+    if (!handler) {
+        logger.error(`${server.app.serverId} no default error handler msg[${JSON.stringify(msg)}] to resolve unknown exception: sessionId:${JSON.stringify(session.export())} , error stack: ${err.stack}`);
+        utils.invokeCallback(cb, err, resp);
+    }
+    else {
+        if (handler.length === 5) {
+            handler(err, msg, resp, session, cb);
+        }
+        else {
+            handler(err, msg, resp, session, cb);
+        }
+    }
+};
+/**
+ * Send response to client and fire after filter chain if any.
+ */
+let response = function (isGlobal, server, err, routeRecord, msg, session, resp, cb) {
+    if (isGlobal) {
+        cb(err, resp);
+        // after filter should not interfere response
+        afterFilter(isGlobal, server, err, routeRecord, msg, session, resp, cb);
+    }
+    else {
+        afterFilter(isGlobal, server, err, routeRecord, msg, session, resp, cb);
+    }
+};
+/**
+ * Parse route string.
+ *
+ * @param  {String} route route string, such as: serverName.handlerName.methodName
+ * @return {Object}       parse result object or null for illeagle route string
+ */
+let parseRoute = function (route) {
+    if (!route) {
+        return null;
+    }
+    let ts = route.split('.');
+    if (ts.length !== 3) {
+        return null;
+    }
+    return {
+        route: route,
+        serverType: ts[0],
+        handler: ts[1],
+        method: ts[2]
+    };
+};
+let doForward = function (app, msg, session, routeRecord, cb) {
+    let finished = false;
+    // should route to other servers
+    try {
+        app.sysrpc[routeRecord.serverType].msgRemote.forwardMessage(
+        // app.sysrpc[routeRecord.serverType].msgRemote.forwardMessage2(
+        session, msg, 
+        // msg.oldRoute || msg.route,
+        // msg.body,
+        // msg.aesPassword,
+        // msg.compressGzip,
+        session.export()).then(function (resp) {
+            finished = true;
+            utils.invokeCallback(cb, null, resp);
+        }).catch(function (err) {
+            logger.error(app.serverId + ' fail to process remote message:' + err.stack);
+            utils.invokeCallback(cb, err);
+        });
+    }
+    catch (err) {
+        if (!finished) {
+            logger.error(app.serverId + ' fail to forward message:' + err.stack);
+            utils.invokeCallback(cb, err);
+        }
+    }
+};
+let doHandle = function (server, msg, session, routeRecord, cb) {
+    msg = msg.body || {};
+    let self = server;
+    let handle = function (err, resp) {
+        if (err) {
+            // error from before filter
+            handleError(false, self, err, msg, session, resp, function (err, resp) {
+                response(false, self, err, routeRecord, msg, session, resp, cb);
+            });
+            return;
+        }
+        self.handlerService.handle(routeRecord, msg, session, function (err, resp) {
+            if (err) {
+                // error from handler
+                handleError(false, self, err, msg, session, resp, function (err, resp) {
+                    response(false, self, err, routeRecord, msg, session, resp, cb);
+                });
+                return;
+            }
+            response(false, self, err, routeRecord, msg, session, resp, cb);
+        });
+    }; // end of handle
+    beforeFilter(false, server, routeRecord, msg, session, handle);
+};
+/**
+ * Schedule crons
+ */
+let scheduleCrons = function (server, crons) {
+    let handlers = server.cronHandlers;
+    for (let i = 0; i < crons.length; i++) {
+        let cronInfo = crons[i];
+        let time = cronInfo.time;
+        let action = cronInfo.action;
+        let jobId = cronInfo.id;
+        if (!time || !action || !jobId) {
+            logger.error(server.app.serverId + ' cron miss necessary parameters: %j', cronInfo);
+            continue;
+        }
+        if (action.indexOf('.') < 0) {
+            logger.error(server.app.serverId + ' cron action is error format: %j', cronInfo);
+            continue;
+        }
+        let cron = action.split('.')[0];
+        let job = action.split('.')[1];
+        let handler = handlers[cron];
+        if (!handler) {
+            logger.error('could not find cron: %j', cronInfo);
+            continue;
+        }
+        if (typeof handler[job] !== 'function') {
+            logger.error('could not find cron job: %j, %s', cronInfo, job);
+            continue;
+        }
+        let id = schedule.scheduleJob(time, handler[job].bind(handler));
+        server.jobs[jobId] = id;
+    }
+};
+/**
+ * If cron is not in crons then put it in the array.
+ */
+let checkAndAdd = function (cron, crons, server, replace = false) {
+    const orgCron = containCron(cron.id, crons);
+    if (!orgCron) {
+        server.crons.push(cron);
+    }
+    else {
+        logger.warn('cron is duplicated: %j', cron);
+        if (replace) {
+            logger.warn('replace time and action org:%j, new:%j', orgCron, cron);
+            orgCron.time = cron.time;
+            orgCron.action = cron.action;
+        }
+    }
+};
+/**
+ * Check if cron is in crons.
+ */
+let containCron = function (id, crons) {
+    for (let i = 0, l = crons.length; i < l; i++) {
+        if (id === crons[i].id) {
+            return crons[i];
+        }
+    }
+    return null;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server.js","sourceRoot":"","sources":["../../../lib/server/server.ts"],"names":[],"mappings":"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"}