@bigtyphoon/melo 1.7.6

package/lib/util/appUtil.ts

@@ -0,0 +1,313 @@
+import * as async from 'async';
+import * as log from './log';
+import * as utils from './utils';
+import * as path from 'path';
+import * as fs from 'fs';
+import * as Constants from './constants';
+import * as starter from '../master/starter';
+import * as Loader from '@bigtyphoon/melo-loader';
+import { getLogger } from '@bigtyphoon/melo-logger'; import { Application } from '../application';
+import { melo } from '../melo';
+import { ServerInfo } from './constants';
+import { IComponent, ILifeCycle } from '../index';
+let logger = getLogger('melo', path.basename(__filename));
+
+
+/**
+ * Initialize application configuration.
+ */
+export function defaultConfiguration(app: Application) {
+    let args = parseArgs(process.argv);
+    setupEnv(app, args);
+    loadMaster(app);
+    loadServers(app);
+    processArgs(app, args);
+    configLogger(app);
+    loadLifecycle(app);
+}
+
+/**
+ * Start servers by type.
+ */
+export function startByType(app: Application, cb: (err?: Error) => void) {
+    if (!!app.startId) {
+        if (app.startId === Constants.RESERVED.MASTER) {
+            utils.invokeCallback(cb);
+        } else {
+            starter.runServers(app);
+        }
+    } else {
+        if (!!app.type && app.type !== Constants.RESERVED.ALL && app.type !== Constants.RESERVED.MASTER) {
+            starter.runServers(app);
+        } else {
+            utils.invokeCallback(cb);
+        }
+    }
+}
+
+/**
+ * Load default components for application.
+ */
+export function loadDefaultComponents(app: Application) {
+    // load system default components
+    if (app.serverType === Constants.RESERVED.MASTER) {
+        app.load(melo.components.master, app.get('masterConfig'));
+    } else {
+        app.load(melo.components.proxy, app.get('proxyConfig'));
+        if (app.getCurServer().port) {
+            app.load(melo.components.remote, app.get('remoteConfig'));
+        }
+        if (app.isFrontend()) {
+            app.load(melo.components.connection, app.get('connectionConfig'));
+            app.load(melo.components.connector, app.get('connectorConfig'));
+            app.load(melo.components.session, app.get('sessionConfig'));
+            // compatible for schedulerConfig
+            if (app.get('schedulerConfig')) {
+                app.load(melo.components.pushScheduler, app.get('schedulerConfig'));
+            } else {
+                app.load(melo.components.pushScheduler, app.get('pushSchedulerConfig'));
+            }
+        }
+        app.load(melo.components.backendSession, app.get('backendSessionConfig'));
+        app.load(melo.components.channel, app.get('channelConfig'));
+        app.load(melo.components.server, app.get('serverConfig'));
+    }
+    app.load(melo.components.monitor, app.get('monitorConfig'));
+}
+
+/**
+ * Stop components.
+ *
+ * @param  {Array}  comps component list
+ * @param  {Number}   index current component index
+ * @param  {Boolean}  force whether stop component immediately
+ * @param  {Function} cb
+ */
+export function stopComps(comps: IComponent[], index: number, force: boolean, cb: () => void ) {
+    if (index >= comps.length) {
+        utils.invokeCallback(cb);
+        return;
+    }
+    let comp = comps[index];
+    if (typeof comp.stop === 'function') {
+        comp.stop(force, function () {
+            // ignore any error
+            stopComps(comps, index + 1, force, cb);
+        });
+    } else {
+        stopComps(comps, index + 1, force, cb);
+    }
+}
+
+/**
+ * Apply command to loaded components.
+ * This method would invoke the component {method} in series.
+ * Any component {method} return err, it would return err directly.
+ *
+ * @param {Array} comps loaded component list
+ * @param {String} method component lifecycle method name, such as: start, stop
+ * @param {Function} cb
+ */
+export function optComponents(comps: IComponent[], method: string, cb: (err?: Error) => void) {
+    let i = 0;
+    async.forEachSeries(comps, function (comp, done) {
+        i++;
+        if (typeof (comp as any)[method] === 'function') {
+            (comp as any)[method](done);
+        } else {
+            done();
+        }
+    }, function (err: Error) {
+        if (err) {
+            if (typeof err === 'string') {
+                logger.error('fail to operate component, method: %s, err: %j', method, err);
+            } else {
+                logger.error('fail to operate component, method: %s, err: %j', method, err.stack);
+            }
+        }
+        utils.invokeCallback(cb, err);
+    });
+}
+
+export function optLifecycles(comps: ILifeCycle[], method: string, app: Application, cb: (err?: Error) => void, arg2 ?: any) {
+    let i = 0;
+    async.forEachSeries(comps, function (comp, done) {
+        i++;
+        if (typeof (comp as any)[method] === 'function') {
+            (comp as any)[method](app , done , arg2);
+        } else {
+            done();
+        }
+    }, function (err: Error) {
+        if (err) {
+            if (typeof err === 'string') {
+                logger.error('fail to operate lifecycle, method: %s, err: %j', method, err);
+            } else {
+                logger.error('fail to operate lifecycle, method: %s, err: %j', method, err.stack);
+            }
+        }
+        utils.invokeCallback(cb, err);
+    });
+}
+
+
+/**
+ * Load server info from config/servers.json.
+ */
+let loadServers = function (app: Application) {
+    app.loadConfigBaseApp(Constants.RESERVED.SERVERS, Constants.FILEPATH.SERVER);
+    let servers = app.get(Constants.RESERVED.SERVERS);
+    let serverMap: {[serverId: string]: ServerInfo} = {}, slist, i, l, server;
+    for (let serverType in servers) {
+        slist = servers[serverType];
+        for (i = 0, l = slist.length; i < l; i++) {
+            server = slist[i];
+            server.serverType = serverType;
+            if (server[Constants.RESERVED.CLUSTER_COUNT]) {
+                utils.loadCluster(app, server, serverMap);
+                continue;
+            }
+            serverMap[server.id] = server;
+            if (server.wsPort) {
+                logger.warn('wsPort is deprecated, use clientPort in frontend server instead, server: %j', server);
+            }
+        }
+    }
+    app.set(Constants.KEYWORDS.SERVER_MAP, serverMap);
+};
+
+/**
+ * Load master info from config/master.json.
+ */
+let loadMaster = function (app: Application) {
+    app.loadConfigBaseApp(Constants.RESERVED.MASTER, Constants.FILEPATH.MASTER);
+    app.master = app.get(Constants.RESERVED.MASTER);
+};
+
+export interface ServerStartArgs extends ServerInfo {
+    mode?: Constants.RESERVED.CLUSTER | Constants.RESERVED.STAND_ALONE;
+    masterha ?: 'true' | 'false';
+    type ?: Constants.RESERVED.ALL;
+    startId ?: string;
+    main ?: string;
+}
+
+/**
+ * Process server start command
+ */
+let processArgs = function (app: Application, args: ServerStartArgs) {
+    let serverType = args.serverType || Constants.RESERVED.MASTER;
+    let serverId = args.id || app.getMaster().id;
+    let mode = args.mode || Constants.RESERVED.CLUSTER;
+    let masterha = args.masterha || 'false';
+    let type = args.type || Constants.RESERVED.ALL;
+    let startId = args.startId;
+
+    app.set(Constants.RESERVED.MAIN, args.main, true);
+    app.set(Constants.RESERVED.SERVER_TYPE, serverType, true);
+    app.set(Constants.RESERVED.SERVER_ID, serverId, true);
+    app.set(Constants.RESERVED.MODE, mode, true);
+    app.set(Constants.RESERVED.TYPE, type, true);
+    if (!!startId) {
+        app.set(Constants.RESERVED.STARTID, startId, true);
+    }
+
+    if (masterha === 'true') {
+        app.master = args;
+        app.set(Constants.RESERVED.CURRENT_SERVER, args, true);
+    } else if (serverType !== Constants.RESERVED.MASTER) {
+        app.set(Constants.RESERVED.CURRENT_SERVER, args, true);
+    } else {
+        app.set(Constants.RESERVED.CURRENT_SERVER, app.getMaster(), true);
+    }
+};
+
+/**
+ * Setup enviroment.
+ */
+let setupEnv = function (app: Application, args: {env: string}) {
+    app.set(Constants.RESERVED.ENV, args.env || process.env.NODE_ENV || Constants.RESERVED.ENV_DEV, true);
+};
+let _checkCanRequire = (path: string) => {
+    try {
+        path = require.resolve(path);
+    } catch(err) {
+        return null;
+    }
+    return path;
+};
+
+/**
+ * Configure custom logger.
+ */
+let configLogger = function (app: Application) {
+    if (process.env.POMELO_LOGGER !== 'off') {
+        let env = app.get(Constants.RESERVED.ENV);
+        let originPath = path.join(app.getBase(), Constants.FILEPATH.LOG);
+        let presentPath = path.join(app.getBase(), Constants.FILEPATH.CONFIG_DIR, env, path.basename(Constants.FILEPATH.LOG));
+
+        if (_checkCanRequire(originPath)) {
+            log.configure(app, originPath);
+        } else if (_checkCanRequire(presentPath)) {
+            log.configure(app, presentPath);
+        } else {
+            logger.error('logger file path configuration is error.');
+        }
+    }
+};
+
+/**
+ * Parse command line arguments.
+ *
+ * @param args command line arguments
+ *
+ * @return Object argsMap map of arguments
+ */
+let parseArgs = function (args: string[]) {
+    let argsMap: any = {};
+    let mainPos = 1;
+
+    while (args[mainPos].indexOf('--') > 0) {
+        mainPos++;
+    }
+    argsMap.main = args[mainPos];
+
+    for (let i = (mainPos + 1); i < args.length; i++) {
+        let arg = args[i];
+        let sep = arg.indexOf('=');
+        let key = arg.slice(0, sep);
+        let value = arg.slice(sep + 1);
+        if (!isNaN(Number(value)) && (value.indexOf('.') < 0)) {
+            value = Number(value) as any;
+        }
+        argsMap[key] = value;
+    }
+
+    return argsMap;
+};
+
+/**
+ * Load lifecycle file.
+ *
+ */
+let loadLifecycle = function (app: Application) {
+    let filePath = path.join(app.getBase(), Constants.FILEPATH.SERVER_DIR, app.serverType, Constants.FILEPATH.LIFECYCLE);
+    try {
+        filePath = require.resolve(filePath);
+    } catch(err) {
+        return;
+    }
+
+    let lifecycle = require(filePath);
+    if (!filePath) {
+        logger.error('lifecycle.js in %s is error format.', filePath);
+        return;
+    }
+    if (typeof lifecycle.default === 'function') {
+        lifecycle = lifecycle.default(app);
+    } else {
+        logger.error('lifecycle.js in %s is error format.', filePath);
+        return;
+    }
+    app.usedPlugins.push(lifecycle);
+};

package/lib/util/constants.ts

@@ -0,0 +1,154 @@
+import { RemoteServerCode } from '../index';
+
+
+export enum KEYWORDS {
+    BEFORE_FILTER= '__befores__',
+    AFTER_FILTER= '__afters__',
+    GLOBAL_BEFORE_FILTER= '__globalBefores__',
+    GLOBAL_AFTER_FILTER= '__globalAfters__',
+    ROUTE= '__routes__',
+    BEFORE_STOP_HOOK= '__beforeStopHook__',
+    MODULE= '__modules__',
+    SERVER_MAP= '__serverMap__',
+    RPC_BEFORE_FILTER= '__rpcBefores__',
+    RPC_AFTER_FILTER= '__rpcAfters__',
+    MASTER_WATCHER= '__masterwatcher__',
+    MONITOR_WATCHER= '__monitorwatcher__'
+}
+
+export enum FILEPATH  {
+    MASTER = '/config/master.json',
+    SERVER = '/config/servers.json',
+    CRON = '/config/crons.json',
+    LOG = '/config/log4js.json',
+    SERVER_PROTOS = '/config/serverProtos.json',
+    CLIENT_PROTOS = '/config/clientProtos.json',
+    MASTER_HA = '/config/masterha.json',
+    LIFECYCLE = '/lifecycle.js',
+    SERVER_DIR = '/app/servers/',
+    CONFIG_DIR = '/config'
+}
+
+export enum DIR  {
+    HANDLER = 'handler',
+    REMOTE = 'remote',
+    CRON = 'cron',
+    LOG = 'logs',
+    SCRIPT = 'scripts',
+    EVENT = 'events',
+    COMPONENT = 'components'
+}
+
+export enum RESERVED  {
+    BASE = 'base',
+    MAIN = 'main',
+    MASTER = 'master',
+    SERVERS = 'servers',
+    ENV = 'env',
+    CPU = 'cpu',
+    ENV_DEV = 'development',
+    ENV_PRO = 'production',
+    ALL = 'all',
+    SERVER_TYPE = 'serverType',
+    SERVER_ID = 'serverId',
+    CURRENT_SERVER = 'curServer',
+    MODE = 'mode',
+    TYPE = 'type',
+    CLUSTER = 'clusters',
+    STAND_ALONE = 'stand-alone',
+    BEFORE_START = 'beforeStart',
+    START = 'start',
+    AFTER_START = 'afterStart',
+    AFTER_STARTALL = 'afterStartAll',
+    CRONS = 'crons',
+    ERROR_HANDLER = 'errorHandler',
+    GLOBAL_ERROR_HANDLER = 'globalErrorHandler',
+    AUTO_RESTART = 'auto-restart',
+    RESTART_FORCE = 'restart-force',
+    CLUSTER_COUNT = 'clusterCount',
+    CLUSTER_PREFIX = 'cluster-server-',
+    CLUSTER_SIGNAL = '++',
+    RPC_ERROR_HANDLER = 'rpcErrorHandler',
+    SERVER = 'server',
+    CLIENT = 'client',
+    STARTID = 'startId',
+    STOP_SERVERS = 'stop_servers',
+    SSH_CONFIG_PARAMS = 'ssh_config_params'
+}
+
+export enum COMMAND  {
+    TASKSET = 'taskset',
+    KILL = 'kill',
+    TASKKILL = 'taskkill',
+    SSH = 'ssh'
+}
+
+export enum PLATFORM  {
+    WIN = 'win32',
+    LINUX = 'linux'
+}
+
+export enum LIFECYCLE  {
+    BEFORE_STARTUP = 'beforeStartup',
+    BEFORE_SHUTDOWN = 'beforeShutdown',
+    AFTER_STARTUP = 'afterStartup',
+    AFTER_STARTALL = 'afterStartAll'
+}
+
+export enum SIGNAL  {
+    FAIL = 0,
+    OK = 1
+}
+
+export enum TIME  {
+    TIME_WAIT_STOP = 3 * 1000,
+    TIME_WAIT_KILL = 5 * 1000,
+    TIME_WAIT_RESTART = 5 * 1000,
+    TIME_WAIT_COUNTDOWN = 10 * 1000,
+    TIME_WAIT_MASTER_KILL = 2 * 60 * 1000,
+    TIME_WAIT_MONITOR_KILL = 2 * 1000,
+    TIME_WAIT_PING = 30 * 1000,
+    TIME_WAIT_MAX_PING = 5 * 60 * 1000,
+    DEFAULT_UDP_HEARTBEAT_TIME = 20 * 1000,
+    DEFAULT_UDP_HEARTBEAT_TIMEOUT = 100 * 1000,
+    DEFAULT_MQTT_HEARTBEAT_TIMEOUT = 90 * 1000
+}
+
+export interface RouteRecord {
+    route: string;
+    serverType: string;
+    handler: string;
+    method: string;
+}
+
+export type UID = string;
+export type SID = number;
+export type FRONTENDID = string;
+
+/**
+ * ServerInfo
+ */
+export interface ServerInfo {
+    id: string;
+    serverType: string;
+    host: string;
+    port: number;
+    clientHost?: string;
+    clientPort?: number;
+    frontend ?: boolean;
+
+    args ?: string | string[];
+    cpu ?: number;
+
+    ['max-connections'] ?: number;
+    ['auto-restart'] ?: boolean;
+    ['restart-force'] ?: boolean;
+    ['clusterCount'] ?: number;
+
+    handlerPaths ?: string[];
+    remoterPaths ?: RemoteServerCode[];
+    // 进程id  number
+    pid?: any;
+    // 进程启动时的 env 参数
+    env?: string;
+}

package/lib/util/countDownLatch.ts

@@ -0,0 +1,72 @@
+
+export interface CountDownLatchOptions {
+    timeout ?: number;
+}
+
+export type CountDownLatchCallback = (isTimeout ?: boolean) => void;
+
+/**
+ * Count down to zero or timeout and invoke cb finally.
+ */
+export class CountDownLatch {
+    count: number;
+    cb: CountDownLatchCallback;
+    timerId: any;
+    constructor(count: number, opts: CountDownLatchOptions, cb: CountDownLatchCallback) {
+        this.count = count;
+        this.cb = cb;
+        let self = this;
+        if (opts.timeout) {
+            this.timerId = setTimeout(function () {
+                self.cb(true);
+            }, opts.timeout);
+        }
+    }
+
+    /**
+     * Call when a task finish to count down.
+     *
+     * @api public
+     */
+    done() {
+        if (this.count <= 0) {
+            throw new Error('illegal state.');
+        }
+
+        this.count--;
+        if (this.count === 0) {
+            if (this.timerId) {
+                clearTimeout(this.timerId);
+            }
+            this.cb();
+        }
+    }
+}
+
+/**
+ * Create a count down latch
+ *
+ * @param {Integer} count
+ * @param {Object} opts, opts.timeout indicates timeout, optional param
+ * @param {Function} cb, cb(isTimeout)
+ *
+ * @api public
+ */
+export function createCountDownLatch(count: number, cb ?: CountDownLatchCallback): CountDownLatch;
+export function createCountDownLatch(count: number, opts:  CountDownLatchOptions, cb ?: CountDownLatchCallback): CountDownLatch;
+export function createCountDownLatch(count: number, opts ?: CountDownLatchCallback | CountDownLatchOptions, cb ?: CountDownLatchCallback) {
+  if(!count || count <= 0) {
+    throw new Error('count should be positive.');
+  }
+
+  if (!cb && typeof opts === 'function') {
+    cb = opts;
+    opts = {};
+  }
+
+  if(typeof cb !== 'function') {
+    throw new Error('cb should be a function.');
+  }
+
+  return new CountDownLatch(count, opts as CountDownLatchOptions, cb);
+}

package/lib/util/events.ts

@@ -0,0 +1,15 @@
+export enum AppEvents {
+    ADD_SERVERS= 'add_servers',
+    REMOVE_SERVERS= 'remove_servers',
+    REPLACE_SERVERS= 'replace_servers',
+    BIND_SESSION= 'bind_session',
+    UNBIND_SESSION= 'unbind_session',
+    CLOSE_SESSION= 'close_session',
+    ADD_CRONS= 'add_crons',
+    REMOVE_CRONS= 'remove_crons',
+    START_SERVER= 'start_server',
+    START_ALL= 'start_all',
+    // ProtobufComponent 组件，当协议文件热更新时 通知  参数： type(server|client)
+    PROTO_CHANGED= 'proto_changed',
+}
+export default AppEvents;

package/lib/util/handlerHelper.ts

@@ -0,0 +1,5 @@
+import { FrontendOrBackendSession } from '../server/server';
+
+export function bindHandlerMethod<T, MSG, R, F>(method: ((msg: MSG, session: FrontendOrBackendSession) => Promise<R>), thisArg: T): (msg: MSG) => Promise<R> {
+    return method.bind(thisArg) as any;
+}

package/lib/util/log.ts

@@ -0,0 +1,11 @@
+import * as logger from '@bigtyphoon/melo-logger';
+import { Application } from '../application';
+
+/**
+ * Configure melo logger
+ */
+export function configure(app: Application, filename: string) {
+  let serverId = app.getServerId();
+  let base = app.getBase();
+  logger.configure(filename, {serverId: serverId, base: base});
+}

package/lib/util/moduleUtil.ts

@@ -0,0 +1,110 @@
+import * as os from 'os';
+import * as admin from '@bigtyphoon/melo-admin';
+import * as utils from './utils';
+import * as Constants from './constants';
+import * as pathUtil from './pathUtil';
+import * as starter from '../master/starter';
+import { getLogger } from '@bigtyphoon/melo-logger'; import { Application } from '../application';
+import { ConsoleService, IModule, IModuleFactory } from '@bigtyphoon/melo-admin';
+import { MasterWatcherModule } from '../modules/masterwatcher';
+import { MonitorWatcherModule } from '../modules/monitorwatcher';
+import { WatchServerModule } from '../modules/watchServer';
+import { OnlineUserModule } from '../modules/onlineUser';
+import { ConsoleModule } from '../modules/console';
+import * as path from 'path';
+let logger = getLogger('melo', path.basename(__filename));
+
+
+export interface ModuleRecord {
+    module: IModuleFactory | IModule;
+    moduleId: string;
+    opts: any;
+}
+/**
+ * Load admin modules
+ */
+export function loadModules(self: {app: Application , modules: Array<IModule>}, consoleService: ConsoleService) {
+    // load app register modules
+    let _modules = self.app.get(Constants.KEYWORDS.MODULE);
+
+    if (!_modules) {
+        return;
+    }
+
+    let modules = [];
+    for (let m in _modules) {
+        modules.push(_modules[m]);
+    }
+
+    let record, moduleId, module;
+    for (let i = 0, l = modules.length; i < l; i++) {
+        record = modules[i];
+        if (typeof record.module === 'function') {
+            module = new record.module(record.opts, consoleService);
+        } else {
+            module = record.module;
+        }
+
+        moduleId = record.moduleId || module.moduleId;
+
+        if (!moduleId) {
+            logger.warn('ignore an unknown module.');
+            continue;
+        }
+
+        consoleService.register(moduleId, module);
+        self.modules.push(module);
+    }
+}
+
+export function startModules(modules: IModule[], cb: (err?: Error) => void) {
+    // invoke the start lifecycle method of modules
+
+    if (!modules) {
+        return;
+    }
+    startModule(null, modules, 0, cb);
+}
+
+/**
+ * Append the default system admin modules
+ */
+export function registerDefaultModules(isMaster: boolean, app: Application, closeWatcher: boolean) {
+    if (!closeWatcher) {
+        if (isMaster) {
+            app.registerAdmin(MasterWatcherModule, { app: app });
+        } else {
+            app.registerAdmin(MonitorWatcherModule, { app: app });
+        }
+    }
+    app.registerAdmin(WatchServerModule, { app: app });
+    app.registerAdmin(ConsoleModule, { app: app, starter: starter });
+    if (app.enabled('systemMonitor')) {
+        if (os.platform() !== Constants.PLATFORM.WIN) {
+            app.registerAdmin(admin.modules.systemInfo);
+            app.registerAdmin(admin.modules.nodeInfo);
+        }
+        app.registerAdmin(OnlineUserModule);
+        app.registerAdmin(admin.modules.monitorLog, { path: pathUtil.getLogPath(app.getBase()) });
+        app.registerAdmin(admin.modules.scripts, { app: app, path: pathUtil.getScriptPath(app.getBase()) });
+        if (os.platform() !== Constants.PLATFORM.WIN) {
+            app.registerAdmin(admin.modules.profiler);
+        }
+    }
+}
+
+let startModule = function (err: Error, modules: IModule[], index: number, cb: (err?: Error) => void) {
+    if (err || index >= modules.length) {
+        utils.invokeCallback(cb, err);
+        return;
+    }
+
+    let module = modules[index];
+    if (module && typeof module.start === 'function') {
+        module.start((err) => {
+            startModule(err, modules, index + 1, cb);
+        });
+    } else {
+        startModule(err, modules, index + 1, cb);
+    }
+};