@bigtyphoon/melo 1.7.6

package/lib/monitor/monitor.ts

@@ -0,0 +1,99 @@
+/**
+ * Component for monitor.
+ * Load and start monitor client.
+ */
+import { getLogger } from '@bigtyphoon/melo-logger';
+import * as admin from '@bigtyphoon/melo-admin';
+import * as moduleUtil from '../util/moduleUtil';
+import * as utils from '../util/utils';
+import * as Constants from '../util/constants';
+import { Application } from '../application';
+import { ConsoleService, IModule } from '@bigtyphoon/melo-admin';
+import { ServerInfo } from '../util/constants';
+import { ServerStartArgs } from '../util/appUtil';
+import { MasterInfo } from '../index';
+import * as path from 'path';
+let logger = getLogger('melo', path.basename(__filename));
+
+export interface MonitorOptions {
+    closeWatcher ?: boolean;
+    monitorAgentClientFactory?: admin.IMonitorAgentClientFactory;
+}
+export class Monitor {
+    app: Application;
+    serverInfo: ServerInfo;
+    masterInfo: ServerStartArgs;
+    modules: IModule[] = [];
+    closeWatcher: any;
+    monitorConsole: ConsoleService;
+    monitorOpts: admin.MonitorConsoleServiceOpts;
+
+    constructor(app: Application, opts ?: MonitorOptions) {
+        opts = opts || {};
+        this.app = app;
+        this.serverInfo = app.getCurServer();
+        this.masterInfo = app.getMaster();
+        this.closeWatcher = opts.closeWatcher;
+
+        this.monitorOpts = {
+            id: this.serverInfo.id,
+            type: this.app.getServerType(),
+            host: this.masterInfo.host,
+            port: this.masterInfo.port,
+            info: this.serverInfo,
+            env: this.app.get(Constants.RESERVED.ENV),
+            authServer: app.get('adminAuthServerMonitor'), // auth server function
+            monitorAgentClientFactory: opts.monitorAgentClientFactory
+        };
+        this.monitorConsole = admin.createMonitorConsole(this.monitorOpts);
+    }
+
+    start(cb: (err?: Error) => void) {
+        moduleUtil.registerDefaultModules(false, this.app, this.closeWatcher);
+        this.startConsole(cb);
+    }
+
+    startConsole(cb: (err?: Error) => void) {
+        moduleUtil.loadModules(this, this.monitorConsole);
+
+        let self = this;
+        this.monitorConsole.start(function (err) {
+            if (err) {
+                utils.invokeCallback(cb, err);
+                return;
+            }
+            moduleUtil.startModules(self.modules, function (err) {
+                utils.invokeCallback(cb, err);
+                return;
+            });
+        });
+
+        this.monitorConsole.on('error', function (err) {
+            if (!!err) {
+                logger.error('monitorConsole encounters with error: %j', err.stack);
+                return;
+            }
+        });
+    }
+
+    stop(cb: () => void) {
+        this.monitorConsole.stop();
+        this.modules = [];
+        process.nextTick(function () {
+            utils.invokeCallback(cb);
+        });
+    }
+
+    // monitor reconnect to master
+    reconnect(masterInfo: MasterInfo) {
+        let self = this;
+        this.stop(function () {
+            self.monitorOpts.host = masterInfo.host;
+            self.monitorOpts.port = masterInfo.port;
+            self.monitorConsole = admin.createMonitorConsole(self.monitorOpts);
+            self.startConsole(function () {
+                logger.info('restart modules for server : %j finish.', self.app.serverId);
+            });
+        });
+    }
+}

package/lib/pushSchedulers/buffer.ts

@@ -0,0 +1,117 @@
+import * as utils from '../util/utils';
+import { Application } from '../application';
+import { SID } from '../util/constants';
+import { ScheduleOptions, BroadcastOptions } from '../interfaces/IPushScheduler';
+import { Session } from '../index';
+let DEFAULT_FLUSH_INTERVAL = 20;
+
+export interface BufferPushSchedulerOptions {
+    flushInterval?: number;
+}
+
+export class BufferPushScheduler {
+    app: Application;
+    flushInterval: number;
+    sessions: { [sid: number]: Session[] } = {};   // sid -> msg queue
+    tid: NodeJS.Timeout = null;
+
+    constructor(app: Application, opts?: BufferPushSchedulerOptions) {
+
+        opts = opts || {};
+        this.app = app;
+        this.flushInterval = opts.flushInterval || DEFAULT_FLUSH_INTERVAL;
+    }
+
+    async start() {
+        this.tid = setInterval(this.flush.bind(this), this.flushInterval);
+    }
+
+    async stop() {
+        if (this.tid) {
+            clearInterval(this.tid);
+            this.tid = null;
+        }
+    }
+
+    schedule(reqId: number, route: string, msg: any, recvs: SID[], opts: ScheduleOptions, cb: () => void) {
+        opts = opts || {};
+        if (opts.type === 'broadcast') {
+            this.doBroadcast( msg, opts.userOptions);
+        } else {
+            this.doBatchPush( msg, recvs);
+        }
+
+        process.nextTick(function () {
+            utils.invokeCallback(cb);
+        });
+    }
+
+    flush() {
+        let sessionService = this.app.get('sessionService');
+        let queue, session;
+        for (let sid in this.sessions) {
+            session = sessionService.get(Number(sid));
+            if (!session) {
+                continue;
+            }
+
+            queue = this.sessions[sid];
+            if (!queue || queue.length === 0) {
+                continue;
+            }
+
+            session.sendBatch(queue);
+            this.sessions[sid] = [];
+        }
+    }
+
+
+    doBroadcast(msg: any, opts: BroadcastOptions) {
+        let channelService = this.app.get('channelService');
+        let sessionService = this.app.get('sessionService');
+
+        if (opts.binded) {
+            sessionService.forEachBindedSession( (session) => {
+                if (channelService.broadcastFilter &&
+                    !channelService.broadcastFilter(session, msg, opts.filterParam)) {
+                    return;
+                }
+
+                this.enqueue( session, msg);
+            });
+        } else {
+            sessionService.forEachSession( (session) => {
+                if (channelService.broadcastFilter &&
+                    !channelService.broadcastFilter(session, msg, opts.filterParam)) {
+                    return;
+                }
+
+                this.enqueue( session, msg);
+            });
+        }
+    }
+    doBatchPush(msg: any, recvs: SID[]) {
+        let sessionService = this.app.get('sessionService');
+        let session;
+        for (let i = 0, l = recvs.length; i < l; i++) {
+            session = sessionService.get(recvs[i]);
+            if (session) {
+                this.enqueue( session, msg);
+            }
+        }
+    }
+
+    enqueue(session: Session, msg: any) {
+        let queue = this.sessions[session.id];
+        if (!queue) {
+            queue = this.sessions[session.id] = [];
+            session.once('closed', this.onClose.bind(this));
+        }
+
+        queue.push(msg);
+    }
+
+    onClose(session: Session) {
+        delete this.sessions[session.id];
+    }
+}

package/lib/pushSchedulers/direct.ts

@@ -0,0 +1,65 @@
+import * as utils from '../util/utils';
+import { Application } from '../application';
+import { IPushScheduler, ScheduleOptions, BroadcastOptions } from '../interfaces/IPushScheduler';
+import { SID } from '../util/constants';
+
+export class DirectPushScheduler implements IPushScheduler {
+    async start() {
+    }
+    async stop() {
+    }
+    app: Application;
+    constructor(app: Application, opts ?: {}) {
+        opts = opts || {};
+        this.app = app;
+    }
+
+
+    schedule(reqId: number, route: string, msg: any, recvs: SID[], opts: ScheduleOptions, cb: (err?: Error) => void) {
+        opts = opts || {};
+        if (opts.type === 'broadcast') {
+            this.doBroadcast(msg, opts.userOptions);
+        } else {
+            this.doBatchPush(msg, recvs);
+        }
+
+        if (cb) {
+            process.nextTick(function () {
+                utils.invokeCallback(cb);
+            });
+        }
+    }
+
+    doBroadcast(msg: any, opts: BroadcastOptions) {
+        let channelService = this.app.get('channelService');
+        let sessionService = this.app.get('sessionService');
+
+        if (opts.binded) {
+            sessionService.forEachBindedSession(function (session) {
+                if (channelService.broadcastFilter &&
+                    !channelService.broadcastFilter(session, msg, opts.filterParam)) {
+                    return;
+                }
+
+                sessionService.sendMessageByUid(session.uid, msg);
+            });
+        } else {
+            sessionService.forEachSession(function (session) {
+                if (channelService.broadcastFilter &&
+                    !channelService.broadcastFilter(session, msg, opts.filterParam)) {
+                    return;
+                }
+
+                sessionService.sendMessage(session.id, msg);
+            });
+        }
+    }
+
+    doBatchPush(msg: any, recvs: SID[]) {
+        let sessionService = this.app.get('sessionService');
+        for (let i = 0, l = recvs.length; i < l; i++) {
+            sessionService.sendMessage(recvs[i], msg);
+        }
+    }
+
+}

package/lib/pushSchedulers/multi.ts

@@ -0,0 +1,94 @@
+import { IPushScheduler, ScheduleOptions, IPushSchedulerOrCtor, MultiPushSchedulerOptions, IPushSelector } from '../interfaces/IPushScheduler';
+import { Application } from '../application';
+import { getLogger } from '@bigtyphoon/melo-logger';
+import { SID } from '../util/constants';
+import * as path from 'path';
+let logger = getLogger('melo', path.basename(__filename));
+
+
+
+export class MultiPushScheduler implements IPushScheduler {
+    app: Application;
+
+    selector: IPushSelector;
+
+    scheduler: {[id: number]: IPushScheduler};
+
+    constructor(app: Application, opts: MultiPushSchedulerOptions) {
+        opts = opts || {};
+        let scheduler = opts.scheduler;
+        if (Array.isArray(scheduler)) {
+            this.scheduler = {};
+            for(let sch of scheduler) {
+                if (typeof sch.scheduler === 'function') {
+                    this.scheduler[sch.id] = new sch.scheduler(app, sch.options);
+                } else {
+                    this.scheduler[sch.id] = sch.scheduler;
+                }
+            }
+
+            if(typeof opts.selector === 'function') {
+                throw new Error('MultiPushScheduler必须提供selector参数');
+            }
+
+            this.selector = opts.selector;
+        }
+        else {
+            throw new Error('MultiPushScheduler必须提供scheduler参数');
+        }
+
+        this.app = app;
+    }
+
+
+
+    /**
+     * Component lifecycle callback
+     *
+     * @param {Function} cb
+     * @return {Void}
+     */
+    async start() {
+        for (let k in this.scheduler) {
+            let sch = this.scheduler[k];
+            if (typeof sch.start === 'function') {
+                await sch.start();
+            }
+        }
+    }
+
+    /**
+     * Component lifecycle callback
+     *
+     * @param {Function} cb
+     * @return {Void}
+     */
+    async stop() {
+        for (let k in this.scheduler) {
+            let sch = this.scheduler[k];
+            if (typeof sch.stop === 'function') {
+                await sch.stop();
+            }
+        }
+    }
+
+    /**
+     * Schedule how the message to send.
+     *
+     * @param  {Number}   reqId request id
+     * @param  {String}   route route string of the message
+     * @param  {Object}   msg   message content after encoded
+     * @param  {Array}    recvs array of receiver's session id
+     * @param  {Object}   opts  options
+     */
+    schedule(reqId: number, route: string, msg: any, recvs: SID[], opts: ScheduleOptions, cb: (err?: Error) => void) {
+        let self = this;
+        let id = self.selector(reqId, route, msg, recvs, opts);
+
+        if (self.scheduler[id]) {
+            self.scheduler[id].schedule(reqId, route, msg, recvs, opts, cb);
+        } else {
+            logger.error('invalid pushScheduler id, id: %j', id);
+        }
+    }
+}