@bigtyphoon/melo 1.7.6

package/lib/modules/monitorwatcher.ts

@@ -0,0 +1,151 @@
+import { getLogger } from '@bigtyphoon/melo-logger';
+import * as utils from '../util/utils';
+import { default as events } from '../util/events';
+import * as Constants from '../util/constants';
+import * as util from 'util';
+import { Application } from '../application';
+import { IModule, ConsoleService, MonitorAgent, MonitorCallback } from '@bigtyphoon/melo-admin';
+import { ServerInfo } from '../util/constants';
+import * as path from 'path';
+let logger = getLogger('melo', path.basename(__filename));
+
+
+
+export class MonitorWatcherModule implements IModule {
+    app: Application;
+    service: any;
+    id: string;
+
+    static moduleId = Constants.KEYWORDS.MONITOR_WATCHER;
+
+    constructor(opts: {app: Application}, consoleService: ConsoleService) {
+        this.app = opts.app;
+        this.service = consoleService;
+        this.id = this.app.getServerId();
+
+        this.app.event.on(events.START_SERVER, finishStart.bind(null, this));
+    }
+
+    start(cb: () => void) {
+        subscribeRequest(this, this.service.agent, this.id, cb);
+    }
+
+    monitorHandler(agent: MonitorAgent, msg: any, cb: MonitorCallback) {
+        if (!msg || !msg.action) {
+            return;
+        }
+        let func = (monitorMethods as any)[msg.action];
+        if (!func) {
+            logger.info('monitorwatcher unknown action: %j', msg.action);
+            return;
+        }
+        func(this, agent, msg, cb);
+    }
+}
+
+// ----------------- monitor start method -------------------------
+
+let subscribeRequest = function (self: MonitorWatcherModule, agent: MonitorAgent, id: string, cb: MonitorCallback) {
+    let msg = { action: 'subscribe', id: id };
+    agent.request(Constants.KEYWORDS.MASTER_WATCHER, msg, function (err: Error, servers) {
+        if (err) {
+            logger.error('subscribeRequest request to master with error: %j', err.stack);
+            utils.invokeCallback(cb, err);
+        }
+        let res = [];
+        for (let id in servers) {
+            res.push(servers[id]);
+        }
+        addServers(self, res);
+        utils.invokeCallback(cb);
+    });
+};
+
+// ----------------- monitor request methods -------------------------
+
+let addServer = function (self: MonitorWatcherModule, agent: MonitorAgent, msg: any, cb: MonitorCallback) {
+    logger.debug('[%s] receive addServer signal: %j', self.app.serverId, msg);
+    if (!msg || !msg.server) {
+        logger.warn('monitorwatcher addServer receive empty message: %j', msg);
+        utils.invokeCallback(cb, Constants.SIGNAL.FAIL);
+        return;
+    }
+    addServers(self, [msg.server]);
+    utils.invokeCallback(cb, Constants.SIGNAL.OK);
+};
+
+let removeServer = function  (self: MonitorWatcherModule, agent: MonitorAgent, msg: any, cb: MonitorCallback) {
+    logger.debug('%s receive removeServer signal: %j', self.app.serverId, msg);
+    if (!msg || !msg.id) {
+        logger.warn('monitorwatcher removeServer receive empty message: %j', msg);
+        utils.invokeCallback(cb, Constants.SIGNAL.FAIL);
+        return;
+    }
+    removeServers(self, [msg.id]);
+    utils.invokeCallback(cb, Constants.SIGNAL.OK);
+};
+
+let replaceServer = function (self: MonitorWatcherModule, agent: MonitorAgent, msg: any, cb: MonitorCallback) {
+    logger.debug('%s receive replaceServer signal: %j', self.app.serverId, msg);
+    if (!msg || !msg.servers) {
+        logger.warn('monitorwatcher replaceServer receive empty message: %j', msg);
+        utils.invokeCallback(cb, Constants.SIGNAL.FAIL);
+        return;
+    }
+    replaceServers(self, msg.servers);
+    utils.invokeCallback(cb, Constants.SIGNAL.OK);
+};
+
+let startOver = function (self: MonitorWatcherModule, agent: MonitorAgent, msg: any, cb: MonitorCallback) {
+
+    for(let component of self.app.loaded) {
+        let fun = component[Constants.RESERVED.AFTER_STARTALL];
+        if (!!fun) {
+            fun.call(component);
+        }
+    }
+
+    for(let lifecycle of self.app.usedPlugins) {
+        let fun = lifecycle[Constants.LIFECYCLE.AFTER_STARTALL];
+        if (!!fun) {
+            fun.call(lifecycle, self.app);
+        }
+    }
+
+    self.app.event.emit(events.START_ALL);
+    utils.invokeCallback(cb, Constants.SIGNAL.OK);
+};
+
+// ----------------- common methods -------------------------
+
+let addServers = function (self: MonitorWatcherModule, servers: ServerInfo[]) {
+    if (!servers || !servers.length) {
+        return;
+    }
+    self.app.addServers(servers);
+};
+
+let removeServers = function (self: MonitorWatcherModule, ids: string[]) {
+    if (!ids || !ids.length) {
+        return;
+    }
+    self.app.removeServers(ids);
+};
+
+let replaceServers = function (self: MonitorWatcherModule, servers:  {[serverId: string]: ServerInfo}) {
+    self.app.replaceServers(servers);
+};
+
+// ----------------- bind methods -------------------------
+
+let finishStart = function (self: MonitorWatcherModule, id: string) {
+    let msg = { action: 'record', id: id };
+    self.service.agent.notify(Constants.KEYWORDS.MASTER_WATCHER, msg);
+};
+
+let monitorMethods = {
+    'addServer': addServer,
+    'removeServer': removeServer,
+    'replaceServer': replaceServer,
+    'startOver': startOver
+};

package/lib/modules/onlineUser.ts

@@ -0,0 +1,78 @@
+/*!
+ * Pomelo -- consoleModule onlineUser
+ * Copyright(c) 2012 fantasyni <fantasyni@163.com>
+ * MIT Licensed
+ */
+import { getLogger } from '@bigtyphoon/melo-logger';
+import * as utils from '../util/utils';
+import { IModule, MonitorCallback, MasterCallback, ModuleType ,  MonitorAgent, MasterAgent } from '@bigtyphoon/melo-admin';
+import { Application } from '../application';
+import { melo } from '../melo';
+import * as path from 'path';
+let logger = getLogger('melo', path.basename(__filename));
+
+
+export class OnlineUserModule implements IModule {
+
+    static moduleId = 'onlineUser';
+
+    app: Application;
+    type: ModuleType;
+    interval: number;
+
+    constructor(opts?: { type?: ModuleType, interval?: number }) {
+        opts = opts || {};
+        this.app = melo.app;
+        this.type = opts.type || ModuleType.pull;
+        this.interval = opts.interval || 5;
+    }
+
+    /**
+    * collect monitor data from monitor
+    *
+    * @param {Object} agent monitorAgent object
+    * @param {Object} msg client message
+    * @param {Function} cb callback function
+    * @api public
+    */
+    monitorHandler(agent: MonitorAgent, msg: any, cb: MonitorCallback) {
+        let connectionService = this.app.components.__connection__;
+        if (!connectionService) {
+            logger.error('not support connection: %j', agent.id);
+            return;
+        }
+        agent.notify(OnlineUserModule.moduleId, connectionService.getStatisticsInfo());
+    }
+
+    masterHandler(agent: MasterAgent, msg: any) {
+        if (!msg) {
+            // pull interval callback
+            let list = agent.typeMap['connector'];
+            if (!list || list.length === 0) {
+                return;
+            }
+            agent.notifyByType('connector', OnlineUserModule.moduleId, msg);
+            return;
+        }
+
+        let data = agent.get(OnlineUserModule.moduleId);
+        if (!data) {
+            data = {};
+            agent.set(OnlineUserModule.moduleId, data);
+        }
+
+        data[msg.serverId] = msg;
+    }
+    /**
+     * Handle client request
+     *
+     * @param {Object} agent masterAgent object
+     * @param {Object} msg client message
+     * @param {Function} cb callback function
+     * @api public
+     */
+    clientHandler(agent: MasterAgent, msg: any, cb: MasterCallback) {
+        utils.invokeCallback(cb, null, agent.get(OnlineUserModule.moduleId));
+    }
+
+}

package/lib/modules/restartNotifyModule.ts

@@ -0,0 +1,128 @@
+import * as path from 'path';
+import { getLogger } from '@bigtyphoon/melo-logger';
+import { ConsoleService, IModule, MasterAgent, MonitorAgent, MonitorCallback } from '@bigtyphoon/melo-admin';
+import { Application } from '../application';
+import { KEYWORDS, ServerInfo } from '../util/constants';
+import { events } from '../index';
+import { MasterWatcherModule } from './masterwatcher';
+
+let logger = getLogger('melo', path.basename(__filename));
+
+// 单个进程重启通知 afterStartAll 生命周期事件。
+export class RestartNotifyModule implements IModule {
+    app: Application;
+    service: any;
+    id: string;
+
+    static moduleId = 'RestartNotifyModule';
+    private readonly removedServers: { [key: string]: boolean } = {};
+
+    private _addEvent = this.onAddServers.bind(this);
+    private _removeEvent = this.onRemoveServers.bind(this);
+    private _masterWatcherModule: MasterWatcherModule;
+
+    constructor(opts: { app: Application }, consoleService: ConsoleService) {
+        this.app = opts.app;
+        this.service = consoleService;
+
+    }
+
+
+    // ----------------- bind methods -------------------------
+
+    private onAddServers(servers: ServerInfo[]) {
+        if (!servers || !servers.length) {
+            return;
+        }
+        servers.forEach(val => this.onServerAdd(val));
+    }
+
+    private onRemoveServers(ids: string[]) {
+        if (ids && ids.length) {
+            // 避免有重复通知的问题。
+            this._masterWatcherModule.watchdog.isStarted = true;
+            this._masterWatcherModule.watchdog.count = -1;
+            ids.forEach(val => this.onServerLeave(val));
+        }
+
+    }
+
+    private onServerAdd(record: ServerInfo) {
+        if (this.removedServers[record.id]) {
+            this.removedServers[record.id] = false;
+            // TOxDO notify afterStartAll
+            const masterAgent = this.service.agent as MasterAgent;
+            logger.warn('notify afterStartAll ', record.id);
+            process.nextTick(() => {
+                masterAgent.request(record.id, 'RestartNotifyModule', { action: 'afterStartCallback' }, (err, body) => {
+                    logger.warn('RestartNotifyModule notify RestartNotifyModule afterStart:', record.id, err, body);
+                    // 通知startOver
+                    masterAgent.request(record.id, KEYWORDS.MONITOR_WATCHER, { action: 'startOver' }, (err, body) => {
+                        logger.warn('RestartNotifyModule notify MONITOR_WATCHER start over:', record.id, err, body);
+                    });
+                });
+            });
+        }
+    }
+
+
+    private onServerLeave(id: string) {
+        logger.debug('RestartNotifyModule onServerLeave: %s', id);
+        if (!id) {
+            logger.warn('onServerLeave receive server id is empty.');
+            return;
+        }
+        this.removedServers[id] = true;
+    }
+
+    private afterStartCallBack: any = null;
+    private afterStartCalled = false;
+
+    afterStart() {
+        logger.debug('~~ RestartNotifyModule afterStart', this.id);
+        this.afterStartCalled = true;
+        if (this.afterStartCallBack) {
+            this.afterStartCallBack(1);
+            this.afterStartCallBack = null;
+        }
+    }
+
+    // ----------------- module methods -------------------------
+
+    start(cb: () => void) {
+        //    subscribeRequest(this, this.service.agent, this.id, cb);
+        this.id = this.app.getServerId();
+        if (this.app.getServerType() === 'master') {
+            if (this.service.master) {
+                this.app.event.on(events.ADD_SERVERS, this._addEvent);
+                this.app.event.on(events.REMOVE_SERVERS, this._removeEvent);
+                this._masterWatcherModule = this.service.modules[KEYWORDS.MASTER_WATCHER].module;
+            }
+        } else {
+            this.app.event.on(events.START_SERVER, this.afterStart.bind(this));
+        }
+        cb();
+    }
+
+
+    monitorHandler(agent: MonitorAgent, msg: any, cb: MonitorCallback) {
+        if (!msg || !msg.action) {
+            return;
+        }
+        switch (msg.action) {
+            case 'afterStartCallback': {
+                logger.warn('RestartNotifyModule afterStart notify ', this.id, msg);
+                if (this.afterStartCalled) {
+                    cb(1 as any);
+                    break;
+                }
+                this.afterStartCallBack = cb;
+                break;
+            }
+            default: {
+                logger.error('RestartNotifyModule unknown action: %j', msg.action);
+                return;
+            }
+        }
+    }
+}