@bigtyphoon/melo 1.7.6

package/dist/lib/application.js

@@ -0,0 +1,888 @@
+"use strict";
+/*!
+ * Melo -- proto
+ * Copyright(c) 2012 xiechengchao <xiecc@163.com>
+ * MIT Licensed
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Application = void 0;
+/**
+ * Module dependencies.
+ */
+const utils = require("./util/utils");
+const melo_logger_1 = require("@bigtyphoon/melo-logger");
+const events_1 = require("events");
+const events_2 = require("./util/events");
+const appUtil = require("./util/appUtil");
+const Constants = require("./util/constants");
+const appManager = require("./common/manager/appManager");
+const fs = require("fs");
+const path = require("path");
+let logger = (0, melo_logger_1.getLogger)('melo', path.basename(__filename));
+/**
+ * Application states
+ */
+let STATE_INITED = 1; // app has inited
+let STATE_BEFORE_START = 2; // app before start
+let STATE_START = 3; // app start
+let STATE_STARTED = 4; // app has started
+let STATE_STOPED = 5; // app has stoped
+class Application {
+    constructor() {
+        this.loaded = []; // loaded component list
+        this.components = {}; // name -> component map
+        this.settings = {}; // collection keep set/get
+        this.event = new events_1.EventEmitter(); // event object to sub/pub events
+        // global server infos
+        this.master = null; // master server info
+        this.servers = {}; // current global server info maps, id -> info
+        this.serverTypeMaps = {}; // current global type maps, type -> [info]
+        this.serverTypes = []; // current global server type list
+        this.usedPlugins = []; // current server custom lifecycle callbacks
+        this.clusterSeq = {}; // cluster id seqence
+        this.astart = utils.promisify(this.start);
+        this.aconfigure = utils.promisify(this.configure);
+    }
+    /**
+     * Initialize the server.
+     *
+     *   - setup default configuration
+     */
+    init(opts) {
+        opts = opts || {};
+        let base = opts.base || path.dirname(require.main.filename);
+        this.set(Constants.RESERVED.BASE, base);
+        this.base = base;
+        appUtil.defaultConfiguration(this);
+        this.state = STATE_INITED;
+        logger.info('application inited: %j', this.getServerId());
+    }
+    /**
+     * Get application base path
+     *
+     *  // cwd: /home/game/
+     *  melo start
+     *  // app.getBase() -> /home/game
+     *
+     * @return {String} application base path
+     *
+     * @memberOf Application
+     */
+    getBase() {
+        return this.get(Constants.RESERVED.BASE);
+    }
+    /**
+     * Override require method in application
+     *
+     * @param {String} relative path of file
+     *
+     * @memberOf Application
+     */
+    require(ph) {
+        return require(path.join(this.getBase(), ph));
+    }
+    /**
+     * Configure logger with {$base}/config/log4js.json
+     *
+     * @param {Object} logger melo-logger instance without configuration
+     *
+     * @memberOf Application
+     */
+    configureLogger(logger) {
+        if (process.env.POMELO_LOGGER !== 'off') {
+            let serverId = this.getServerId();
+            let base = this.getBase();
+            let env = this.get(Constants.RESERVED.ENV);
+            let originPath = path.join(base, Constants.FILEPATH.LOG);
+            let presentPath = path.join(base, Constants.FILEPATH.CONFIG_DIR, env, path.basename(Constants.FILEPATH.LOG));
+            if (this._checkCanRequire(originPath)) {
+                logger.configure(originPath, { serverId: serverId, base: base });
+            }
+            else if (this._checkCanRequire(presentPath)) {
+                logger.configure(presentPath, { serverId: serverId, base: base });
+            }
+            else {
+                console.error('logger file path configuration is error.');
+            }
+        }
+    }
+    /**
+     * add a filter to before and after filter
+     *
+     * @param {Object} filter provide before and after filter method.
+     *                        A filter should have two methods: before and after.
+     * @memberOf Application
+     */
+    filter(filter) {
+        this.before(filter);
+        this.after(filter);
+    }
+    /**
+     * Add before filter.
+     *
+     * @param {Object|Function} bf before fileter, bf(msg, session, next)
+     * @memberOf Application
+     */
+    before(bf) {
+        addFilter(this, Constants.KEYWORDS.BEFORE_FILTER, bf);
+    }
+    /**
+     * Add after filter.
+     *
+     * @param {Object|Function} af after filter, `af(err, msg, session, resp, next)`
+     * @memberOf Application
+     */
+    after(af) {
+        addFilter(this, Constants.KEYWORDS.AFTER_FILTER, af);
+    }
+    /**
+     * add a global filter to before and after global filter
+     *
+     * @param {Object} filter provide before and after filter method.
+     *                        A filter should have two methods: before and after.
+     * @memberOf Application
+     */
+    globalFilter(filter) {
+        this.globalBefore(filter);
+        this.globalAfter(filter);
+    }
+    /**
+     * Add global before filter.
+     *
+     * @param {Object|Function} bf before fileter, bf(msg, session, next)
+     * @memberOf Application
+     */
+    globalBefore(bf) {
+        addFilter(this, Constants.KEYWORDS.GLOBAL_BEFORE_FILTER, bf);
+    }
+    /**
+     * Add global after filter.
+     *
+     * @param {Object|Function} af after filter, `af(err, msg, session, resp, next)`
+     * @memberOf Application
+     */
+    globalAfter(af) {
+        addFilter(this, Constants.KEYWORDS.GLOBAL_AFTER_FILTER, af);
+    }
+    /**
+     * Add rpc before filter.
+     *
+     * @param {Object|Function} bf before fileter, bf(serverId, msg, opts, next)
+     * @memberOf Application
+     */
+    rpcBefore(bf) {
+        addFilter(this, Constants.KEYWORDS.RPC_BEFORE_FILTER, bf);
+    }
+    /**
+     * Add rpc after filter.
+     *
+     * @param {Object|Function} af after filter, `af(serverId, msg, opts, next)`
+     * @memberOf Application
+     */
+    rpcAfter(af) {
+        addFilter(this, Constants.KEYWORDS.RPC_AFTER_FILTER, af);
+    }
+    /**
+     * add a rpc filter to before and after rpc filter
+     *
+     * @param {Object} filter provide before and after filter method.
+     *                        A filter should have two methods: before and after.
+     * @memberOf Application
+     */
+    rpcFilter(filter) {
+        this.rpcBefore(filter);
+        this.rpcAfter(filter);
+    }
+    load(name, component, opts) {
+        if (typeof name !== 'string') {
+            opts = component;
+            component = name;
+            name = null;
+        }
+        if (typeof component === 'function') {
+            component = new component(this, opts);
+        }
+        if (!name && typeof component.name === 'string') {
+            name = component.name;
+        }
+        if (name && this.components[name]) {
+            // ignore duplicat component
+            logger.warn('ignore duplicate component: %j', name);
+            return;
+        }
+        this.loaded.push(component);
+        if (name) {
+            // components with a name would get by name throught app.components later.
+            this.components[name] = component;
+        }
+        return component;
+    }
+    _checkCanRequire(path) {
+        try {
+            path = require.resolve(path);
+        }
+        catch (err) {
+            return null;
+        }
+        return path;
+    }
+    /**
+     * Load Configure json file to settings.(support different enviroment directory & compatible for old path)
+     *
+     * @param {String} key environment key
+     * @param {String} val environment value
+     * @param {Boolean} reload whether reload after change default false
+     * @return {Server|Mixed} for chaining, or the setting value
+     * @memberOf Application
+     */
+    loadConfigBaseApp(key, val, reload = false) {
+        let self = this;
+        let env = this.get(Constants.RESERVED.ENV);
+        let originPath = path.join(this.getBase(), val);
+        let presentPath = path.join(this.getBase(), Constants.FILEPATH.CONFIG_DIR, env, path.basename(val));
+        let realPath;
+        let tmp;
+        if (self._checkCanRequire(originPath)) {
+            realPath = require.resolve(originPath);
+            let file = require(originPath);
+            if (file[env]) {
+                file = file[env];
+            }
+            this.set(key, file);
+        }
+        else if (self._checkCanRequire(presentPath)) {
+            realPath = require.resolve(presentPath);
+            let pfile = require(presentPath);
+            this.set(key, pfile);
+        }
+        else {
+            logger.error('invalid configuration with file path: %s', key);
+        }
+        if (!!realPath && !!reload) {
+            const watcher = fs.watch(realPath, function (event, filename) {
+                if (event === 'change') {
+                    self.clearRequireCache(require.resolve(realPath));
+                    watcher.close();
+                    self.loadConfigBaseApp(key, val, reload);
+                }
+            });
+        }
+    }
+    clearRequireCache(path) {
+        const moduleObj = require.cache[path];
+        if (!moduleObj) {
+            logger.warn('can not find module of truepath', path);
+            return;
+        }
+        if (moduleObj.parent) {
+            //    console.log('has parent ',moduleObj.parent);
+            moduleObj.parent.children.splice(moduleObj.parent.children.indexOf(moduleObj), 1);
+        }
+        delete require.cache[path];
+    }
+    /**
+     * Load Configure json file to settings.
+     *
+     * @param {String} key environment key
+     * @param {String} val environment value
+     * @return {Server|Mixed} for chaining, or the setting value
+     * @memberOf Application
+     */
+    loadConfig(key, val) {
+        let env = this.get(Constants.RESERVED.ENV);
+        let cfg = require(val);
+        if (cfg[env]) {
+            cfg = cfg[env];
+        }
+        this.set(key, cfg);
+    }
+    /**
+     * Set the route function for the specified server type.
+     *
+     * Examples:
+     *
+     *  app.route('area', routeFunc);
+     *
+     *  let routeFunc = function(session, msg, app, cb) {
+     *    // all request to area would be route to the first area server
+     *    let areas = app.getServersByType('area');
+     *    cb(null, areas[0].id);
+     *  };
+     *
+     * @param  {String} serverType server type string
+     * @param  {Function} routeFunc  route function. routeFunc(session, msg, app, cb)
+     * @return {Object}     current application instance for chain invoking
+     * @memberOf Application
+     */
+    route(serverType, routeFunc) {
+        let routes = this.get(Constants.KEYWORDS.ROUTE);
+        if (!routes) {
+            routes = {};
+            this.set(Constants.KEYWORDS.ROUTE, routes);
+        }
+        routes[serverType] = routeFunc;
+        return this;
+    }
+    /**
+     * Set before stop function. It would perform before servers stop.
+     *
+     * @param  {Function} fun before close function
+     * @return {Void}
+     * @memberOf Application
+     */
+    beforeStopHook(fun) {
+        logger.warn('this method was deprecated in melo 0.8');
+        if (!!fun && typeof fun === 'function') {
+            this.set(Constants.KEYWORDS.BEFORE_STOP_HOOK, fun);
+        }
+    }
+    /**
+     * Start application. It would load the default components and start all the loaded components.
+     *
+     * @param  {Function} cb callback function
+     * @memberOf Application
+     */
+    start(cb) {
+        this.startTime = Date.now();
+        if (this.state > STATE_INITED) {
+            utils.invokeCallback(cb, new Error('application has already start.'));
+            return;
+        }
+        let self = this;
+        appUtil.startByType(self, function () {
+            appUtil.loadDefaultComponents(self);
+            let startUp = function () {
+                self.state = STATE_BEFORE_START;
+                logger.info('%j enter before start...', self.getServerId());
+                appUtil.optComponents(self.loaded, Constants.RESERVED.BEFORE_START, function (err) {
+                    if (err) {
+                        utils.invokeCallback(cb, err);
+                    }
+                    else {
+                        logger.info('%j enter start...', self.getServerId());
+                        appUtil.optComponents(self.loaded, Constants.RESERVED.START, function (err) {
+                            self.state = STATE_START;
+                            if (err) {
+                                utils.invokeCallback(cb, err);
+                            }
+                            else {
+                                logger.info('%j enter after start...', self.getServerId());
+                                self.afterStart(cb);
+                            }
+                        });
+                    }
+                });
+            };
+            appUtil.optLifecycles(self.usedPlugins, Constants.LIFECYCLE.BEFORE_STARTUP, self, function (err) {
+                if (err) {
+                    utils.invokeCallback(cb, err);
+                }
+                else {
+                    startUp();
+                }
+            });
+        });
+    }
+    /**
+     * Lifecycle callback for after start.
+     *
+     * @param  {Function} cb callback function
+     * @return {Void}
+     */
+    afterStart(cb) {
+        if (this.state !== STATE_START) {
+            utils.invokeCallback(cb, new Error('application is not running now.'));
+            return;
+        }
+        let self = this;
+        appUtil.optComponents(this.loaded, Constants.RESERVED.AFTER_START, function (err) {
+            self.state = STATE_STARTED;
+            let id = self.getServerId();
+            if (!err) {
+                logger.info('%j finish start', id);
+            }
+            appUtil.optLifecycles(self.usedPlugins, Constants.LIFECYCLE.AFTER_STARTUP, self, function (err) {
+                let usedTime = Date.now() - self.startTime;
+                logger.info('%j startup in %s ms', id, usedTime);
+                self.event.emit(events_2.default.START_SERVER, id);
+                cb && cb(err);
+            });
+        });
+    }
+    /**
+     * Stop components.
+     *
+     * @param  {Boolean} force whether stop the app immediately
+     */
+    stop(force) {
+        if (this.state > STATE_STARTED) {
+            logger.warn('[melo application] application is not running now.');
+            return;
+        }
+        this.state = STATE_STOPED;
+        let self = this;
+        this.stopTimer = setTimeout(function () {
+            process.exit(0);
+        }, Constants.TIME.TIME_WAIT_STOP);
+        let cancelShutDownTimer = function () {
+            if (!!self.stopTimer) {
+                clearTimeout(self.stopTimer);
+            }
+        };
+        let shutDown = function () {
+            appUtil.stopComps(self.loaded, 0, force, function () {
+                cancelShutDownTimer();
+                if (force) {
+                    process.exit(0);
+                }
+            });
+        };
+        let fun = this.get(Constants.KEYWORDS.BEFORE_STOP_HOOK);
+        appUtil.optLifecycles(self.usedPlugins, Constants.LIFECYCLE.BEFORE_SHUTDOWN, self, function (err) {
+            if (err) {
+                console.error(`throw err when beforeShutdown `, err.stack);
+            }
+            else {
+                if (!!fun) {
+                    utils.invokeCallback(fun, self, shutDown, cancelShutDownTimer);
+                }
+                else {
+                    shutDown();
+                }
+            }
+        }, cancelShutDownTimer);
+    }
+    set(setting, val, attach) {
+        this.settings[setting] = val;
+        if (attach) {
+            this[setting] = val;
+        }
+        return this;
+    }
+    get(setting) {
+        return this.settings[setting];
+    }
+    /**
+     * Check if `setting` is enabled.
+     *
+     * @param {String} setting application setting
+     * @return {Boolean}
+     * @memberOf Application
+     */
+    enabled(setting) {
+        return !!this.get(setting);
+    }
+    /**
+     * Check if `setting` is disabled.
+     *
+     * @param {String} setting application setting
+     * @return {Boolean}
+     * @memberOf Application
+     */
+    disabled(setting) {
+        return !this.get(setting);
+    }
+    /**
+     * Enable `setting`.
+     *
+     * @param {String} setting application setting
+     * @return {app} for chaining
+     * @memberOf Application
+     */
+    enable(setting) {
+        return this.set(setting, true);
+    }
+    /**
+     * Disable `setting`.
+     *
+     * @param {String} setting application setting
+     * @return {app} for chaining
+     * @memberOf Application
+     */
+    disable(setting) {
+        return this.set(setting, false);
+    }
+    configure(env, type, fn) {
+        let args = [].slice.call(arguments);
+        fn = args.pop();
+        env = type = Constants.RESERVED.ALL;
+        if (args.length > 0) {
+            env = args[0];
+        }
+        if (args.length > 1) {
+            type = args[1];
+        }
+        if (env === Constants.RESERVED.ALL || contains(this.settings.env, env)) {
+            if (type === Constants.RESERVED.ALL || contains(this.settings.serverType, type)) {
+                fn.call(this);
+            }
+        }
+        return this;
+    }
+    registerAdmin(moduleId, module, opts) {
+        let modules = this.get(Constants.KEYWORDS.MODULE);
+        if (!modules) {
+            modules = {};
+            this.set(Constants.KEYWORDS.MODULE, modules);
+        }
+        if (typeof moduleId !== 'string') {
+            opts = module;
+            module = moduleId;
+            if (module) {
+                moduleId = (module.moduleId);
+                if (!moduleId)
+                    moduleId = module.constructor.name;
+            }
+        }
+        if (!moduleId) {
+            return;
+        }
+        modules[moduleId] = {
+            moduleId: moduleId,
+            module: module,
+            opts: opts
+        };
+    }
+    /**
+     * Use plugin.
+     *
+     * @param  {Object} plugin plugin instance
+     * @param  {[type]} opts    (optional) construct parameters for the factory function
+     * @memberOf Application
+     */
+    use(plugin, opts) {
+        opts = opts || {};
+        if (!plugin) {
+            throw new Error(`pluin is null!]`);
+        }
+        if (this.usedPlugins.indexOf(plugin) >= 0) {
+            throw new Error(`pluin[${plugin.name} was used already!]`);
+        }
+        if (plugin.components) {
+            for (let componentCtor of plugin.components) {
+                this.load(componentCtor, opts);
+            }
+        }
+        if (plugin.events) {
+            for (let eventCtor of plugin.events) {
+                this.loadEvent(eventCtor, opts);
+            }
+        }
+        this.usedPlugins.push(plugin);
+        console.warn(`used Plugin : ${plugin.name}`);
+    }
+    /**
+     * Application transaction. Transcation includes conditions and handlers, if conditions are satisfied, handlers would be executed.
+     * And you can set retry times to execute handlers. The transaction log is in file logs/transaction.log.
+     *
+     * @param {String} name transaction name
+     * @param {Object} conditions functions which are called before transaction
+     * @param {Object} handlers functions which are called during transaction
+     * @param {Number} retry retry times to execute handlers if conditions are successfully executed
+     * @memberOf Application
+     */
+    transaction(name, conditions, handlers, retry) {
+        appManager.transaction(name, conditions, handlers, retry);
+    }
+    /**
+     * Get master server info.
+     *
+     * @return {Object} master server info, {id, host, port}
+     * @memberOf Application
+     */
+    getMaster() {
+        return this.master;
+    }
+    /**
+     * Get current server info.
+     *
+     * @return {Object} current server info, {id, serverType, host, port}
+     * @memberOf Application
+     */
+    getCurServer() {
+        return this.curServer;
+    }
+    /**
+     * Get current server id.
+     *
+     * @return {String|Number} current server id from servers.json
+     * @memberOf Application
+     */
+    getServerId() {
+        return this.serverId;
+    }
+    /**
+     * Get current server
+     * @returns ServerInfo
+     */
+    getCurrentServer() {
+        return this.curServer;
+    }
+    /**
+     * Get current server type.
+     *
+     * @return {String|Number} current server type from servers.json
+     * @memberOf Application
+     */
+    getServerType() {
+        return this.serverType;
+    }
+    /**
+     * Get all the current server infos.
+     *
+     * @return {Object} server info map, key: server id, value: server info
+     * @memberOf Application
+     */
+    getServers() {
+        return this.servers;
+    }
+    /**
+     * Get all server infos from servers.json.
+     *
+     * @return {Object} server info map, key: server id, value: server info
+     * @memberOf Application
+     */
+    getServersFromConfig() {
+        return this.get(Constants.KEYWORDS.SERVER_MAP);
+    }
+    /**
+     * Get all the server type.
+     *
+     * @return {Array} server type list
+     * @memberOf Application
+     */
+    getServerTypes() {
+        return this.serverTypes;
+    }
+    /**
+     * Get server info by server id from current server cluster.
+     *
+     * @param  {String} serverId server id
+     * @return {Object} server info or undefined
+     * @memberOf Application
+     */
+    getServerById(serverId) {
+        return this.servers[serverId];
+    }
+    /**
+     * Get server info by server id from servers.json.
+     *
+     * @param  {String} serverId server id
+     * @return {Object} server info or undefined
+     * @memberOf Application
+     */
+    getServerFromConfig(serverId) {
+        return this.get(Constants.KEYWORDS.SERVER_MAP)[serverId];
+    }
+    /**
+     * Get server infos by server type.
+     *
+     * @param  {String} serverType server type
+     * @return {Array}      server info list
+     * @memberOf Application
+     */
+    getServersByType(serverType) {
+        return this.serverTypeMaps[serverType];
+    }
+    /**
+     * Check the server whether is a frontend server
+     *
+     * @param  {server}  server server info. it would check current server
+     *            if server not specified
+     * @return {Boolean}
+     *
+     * @memberOf Application
+     */
+    isFrontend(server) {
+        server = server || this.getCurServer();
+        return !!server && server.frontend === 'true';
+    }
+    /**
+     * Check the server whether is a backend server
+     *
+     * @param  {server}  server server info. it would check current server
+     *            if server not specified
+     * @return {Boolean}
+     * @memberOf Application
+     */
+    isBackend(server) {
+        server = server || this.getCurServer();
+        return !!server && !server.frontend;
+    }
+    /**
+     * Check whether current server is a master server
+     *
+     * @return {Boolean}
+     * @memberOf Application
+     */
+    isMaster() {
+        return this.serverType === Constants.RESERVED.MASTER;
+    }
+    /**
+     * Add new server info to current application in runtime.
+     *
+     * @param {Array} servers new server info list
+     * @memberOf Application
+     */
+    addServers(servers) {
+        if (!servers || !servers.length) {
+            return;
+        }
+        let item, slist;
+        for (let i = 0, l = servers.length; i < l; i++) {
+            item = servers[i];
+            // update global server map
+            this.servers[item.id] = item;
+            // update global server type map
+            slist = this.serverTypeMaps[item.serverType];
+            if (!slist) {
+                this.serverTypeMaps[item.serverType] = slist = [];
+            }
+            replaceServer(slist, item);
+            // update global server type list
+            if (this.serverTypes.indexOf(item.serverType) < 0) {
+                this.serverTypes.push(item.serverType);
+            }
+        }
+        this.event.emit(events_2.default.ADD_SERVERS, servers);
+    }
+    /**
+     * Remove server info from current application at runtime.
+     *
+     * @param  {Array} ids server id list
+     * @memberOf Application
+     */
+    removeServers(ids) {
+        if (!ids || !ids.length) {
+            return;
+        }
+        let id, item, slist;
+        for (let i = 0, l = ids.length; i < l; i++) {
+            id = ids[i];
+            item = this.servers[id];
+            if (!item) {
+                continue;
+            }
+            // clean global server map
+            delete this.servers[id];
+            // clean global server type map
+            slist = this.serverTypeMaps[item.serverType];
+            removeServer(slist, id);
+            // TODO: should remove the server type if the slist is empty?
+        }
+        this.event.emit(events_2.default.REMOVE_SERVERS, ids);
+    }
+    /**
+     * Replace server info from current application at runtime.
+     *
+     * @param  {Object} server id map
+     * @memberOf Application
+     */
+    replaceServers(servers) {
+        if (!servers) {
+            return;
+        }
+        this.servers = servers;
+        this.serverTypeMaps = {};
+        this.serverTypes = [];
+        let serverArray = [];
+        for (let id in servers) {
+            let server = servers[id];
+            let serverType = server[Constants.RESERVED.SERVER_TYPE];
+            let slist = this.serverTypeMaps[serverType];
+            if (!slist) {
+                this.serverTypeMaps[serverType] = slist = [];
+            }
+            this.serverTypeMaps[serverType].push(server);
+            // update global server type list
+            if (this.serverTypes.indexOf(serverType) < 0) {
+                this.serverTypes.push(serverType);
+            }
+            serverArray.push(server);
+        }
+        this.event.emit(events_2.default.REPLACE_SERVERS, serverArray);
+    }
+    /**
+     * Add crons from current application at runtime.
+     *
+     * @param  {Array} crons new crons would be added in application
+     * @memberOf Application
+     */
+    addCrons(crons) {
+        if (!crons || !crons.length) {
+            logger.warn('crons is not defined.');
+            return;
+        }
+        this.event.emit(events_2.default.ADD_CRONS, crons);
+    }
+    /**
+     * Remove crons from current application at runtime.
+     *
+     * @param  {Array} crons old crons would be removed in application
+     * @memberOf Application
+     */
+    removeCrons(crons) {
+        if (!crons || !crons.length) {
+            logger.warn('ids is not defined.');
+            return;
+        }
+        this.event.emit(events_2.default.REMOVE_CRONS, crons);
+    }
+    /**
+     * 加载一个事件侦听
+     * @param Event
+     * @param opts
+     */
+    loadEvent(Event, opts) {
+        let eventInstance = new Event(opts);
+        for (let evt in events_2.AppEvents) {
+            let name = events_2.AppEvents[evt];
+            let method = eventInstance[name];
+            if (method) {
+                this.event.on(name, method.bind(eventInstance));
+            }
+        }
+    }
+}
+exports.Application = Application;
+let replaceServer = function (slist, serverInfo) {
+    for (let i = 0, l = slist.length; i < l; i++) {
+        if (slist[i].id === serverInfo.id) {
+            slist[i] = serverInfo;
+            return;
+        }
+    }
+    slist.push(serverInfo);
+};
+let removeServer = function (slist, id) {
+    if (!slist || !slist.length) {
+        return;
+    }
+    for (let i = 0, l = slist.length; i < l; i++) {
+        if (slist[i].id === id) {
+            slist.splice(i, 1);
+            return;
+        }
+    }
+};
+let contains = function (str, settings) {
+    if (!settings) {
+        return false;
+    }
+    let ts = settings.split('|');
+    for (let i = 0, l = ts.length; i < l; i++) {
+        if (str === ts[i]) {
+            return true;
+        }
+    }
+    return false;
+};
+let addFilter = function (app, type, filter) {
+    let filters = app.get(type);
+    if (!filters) {
+        filters = [];
+        app.set(type, filters);
+    }
+    filters.push(filter);
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"application.js","sourceRoot":"","sources":["../../lib/application.ts"],"names":[],"mappings":"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"}