@bigtyphoon/melo 1.7.6

package/lib/components/master.ts

@@ -0,0 +1,41 @@
+/**
+ * Component for master.
+ */
+import { MasterServer, MasterServerOptions } from '../master/master';
+import { IComponent } from '../interfaces/IComponent';
+import { Application } from '../application';
+
+/**
+* Master component class
+*
+* @param {Object} app current application context
+*/
+export class MasterComponent implements IComponent {
+    name = '__master__';
+    master: MasterServer;
+    constructor(app: Application, opts: MasterServerOptions) {
+        this.master = new MasterServer(app, opts);
+    }
+
+    /**
+     * Component lifecycle function
+     *
+     * @param  {Function} cb
+     * @return {Void}
+     */
+    start(cb: (err?: Error) => void) {
+        this.master.start(cb);
+    }
+
+    /**
+     * Component lifecycle function
+     *
+     * @param  {Boolean}   force whether stop the component immediately
+     * @param  {Function}  cb
+     * @return {Void}
+     */
+    stop(force: boolean, cb: (err?: Error) => void) {
+        this.master.stop(cb);
+    }
+
+}

package/lib/components/monitor.ts

@@ -0,0 +1,30 @@
+/**
+ * Component for monitor.
+ * Load and start monitor client.
+ */
+import { Monitor, MonitorOptions } from '../monitor/monitor';
+import { IComponent } from '../interfaces/IComponent';
+import { Application } from '../application';
+import { MasterInfo } from '../index';
+
+
+
+export class MonitorComponent implements IComponent {
+    monitor: Monitor;
+    constructor(app: Application, opts ?: MonitorOptions) {
+        this.monitor = new Monitor(app, opts);
+    }
+
+    name = '__monitor__';
+    start(cb: () => void) {
+        this.monitor.start(cb);
+    }
+
+    stop(force: boolean, cb: () => void) {
+        this.monitor.stop(cb);
+    }
+
+    reconnect(masterInfo: MasterInfo) {
+        this.monitor.reconnect(masterInfo);
+    }
+}

package/lib/components/protobuf.ts

@@ -0,0 +1,208 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { Protobuf } from '@bigtyphoon/melo-protobuf';
+import * as Constants from '../util/constants';
+import * as crypto from 'crypto';
+import { getLogger } from '@bigtyphoon/melo-logger';
+import { Application } from '../application';
+import { IComponent } from '../interfaces/IComponent';
+import AppEvents from '../util/events';
+
+let logger = getLogger('melo', path.basename(__filename));
+
+export interface ProtobufComponentOptions {
+    serverProtos?: string;
+    clientProtos?: string;
+    /**
+     指定 melo-protobuf encode使用 buffer缓存大小
+     使用方法  在 connector配置参数
+     app.set('protobufConfig', {
+        // protobuf Encoder 使用 5m 的缓存 需要保证每个消息不会超过指定的缓存大小，超过了就会抛出异常
+        encoderCacheSize: 5 * 1024 * 1024
+     });
+     如果缓存大小不够就会有错误日志
+     缓存大小不够 日志示例
+     [2020-03-27T10:44:48.752] [ERROR] melo - [chat-server-1 channelService.js] [pushMessage] fail to dispatch msg to serverId: connector-server-1, err:RangeError [ERR_OUT_OF_RANGE]: The value of "offset" is out of range. It must be >= 0 and <= 0. Received 1
+     at boundsError (internal/buffer.js:53:9)
+     at writeU_Int8 (internal/buffer.js:562:5)
+     at Buffer.writeUInt8 (internal/buffer.js:569:10)
+     at Encoder.writeBytes (F:\develop\gong4-server\logicServer\melo\packages\melo-protobuf\lib\encoder.ts:195:20)
+     */
+    encoderCacheSize?: number;
+    // decode 客户端请求消息时校验消息
+    decodeCheckMsg?: boolean;
+}
+
+
+export class ProtobufComponent implements IComponent {
+    app: Application;
+
+    watchers: { [key: string]: fs.FSWatcher } = {};
+    serverProtos: {
+        [key: string]: any;
+    } = {};
+    clientProtos: {
+        [key: string]: any;
+    } = {};
+    version = '';
+    serverProtosPath: string;
+    clientProtosPath: string;
+
+    protobuf: Protobuf;
+    name = '__protobuf__';
+
+    _canRequire(path: string): boolean {
+        try {
+            require.resolve(path);
+        } catch (err) {
+            return false;
+        }
+        return true;
+    }
+
+    constructor(app: Application, opts ?: ProtobufComponentOptions) {
+        this.app = app;
+        opts = opts || {};
+        logger.debug('ProtobufComponent options:', opts)
+        let env = app.get(Constants.RESERVED.ENV);
+        let originServerPath = path.join(app.getBase(), Constants.FILEPATH.SERVER_PROTOS);
+        let presentServerPath = path.join(Constants.FILEPATH.CONFIG_DIR, env, path.basename(Constants.FILEPATH.SERVER_PROTOS));
+        let originClientPath = path.join(app.getBase(), Constants.FILEPATH.CLIENT_PROTOS);
+        let presentClientPath = path.join(Constants.FILEPATH.CONFIG_DIR, env, path.basename(Constants.FILEPATH.CLIENT_PROTOS));
+
+        this.serverProtosPath = opts.serverProtos || (this._canRequire(originServerPath) ? Constants.FILEPATH.SERVER_PROTOS : presentServerPath);
+        this.clientProtosPath = opts.clientProtos || (this._canRequire(originClientPath) ? Constants.FILEPATH.CLIENT_PROTOS : presentClientPath);
+
+        this.setProtos(Constants.RESERVED.SERVER, path.join(app.getBase(), this.serverProtosPath));
+        this.setProtos(Constants.RESERVED.CLIENT, path.join(app.getBase(), this.clientProtosPath));
+
+        this.protobuf = new Protobuf({
+            encoderProtos: this.serverProtos,
+            decoderProtos: this.clientProtos,
+            encoderCacheSize: opts.encoderCacheSize,
+            decodeCheckMsg: opts.decodeCheckMsg,
+        });
+    }
+
+
+    encode(key: string, msg: any) {
+        return this.protobuf.encode(key, msg);
+    }
+
+    encode2Bytes(key: string, msg: any) {
+        return this.protobuf.encode2Bytes(key, msg);
+    }
+
+    decode(key: string, msg: any) {
+        return this.protobuf.decode(key, msg);
+    }
+
+    getProtos() {
+        return {
+            server: this.serverProtos,
+            client: this.clientProtos,
+            version: this.version
+        };
+    }
+
+    getVersion() {
+        return this.version;
+    }
+
+    // 手动重新加载协议文件。
+    public manualReloadProtos() {
+        let truePath = path.join(this.app.getBase(), this.serverProtosPath);
+        truePath = require.resolve(truePath);
+        this.onUpdate(Constants.RESERVED.SERVER, truePath, 'change');
+        truePath = path.join(this.app.getBase(), this.clientProtosPath);
+        truePath = require.resolve(truePath);
+        this.onUpdate(Constants.RESERVED.CLIENT, truePath, 'change');
+    }
+
+    setProtos(type: string, path: string) {
+        if (!this._canRequire(path)) {
+            return;
+        }
+        if (type === Constants.RESERVED.SERVER) {
+            this.serverProtos = Protobuf.parse(require(path));
+        }
+
+        if (type === Constants.RESERVED.CLIENT) {
+            this.clientProtos = Protobuf.parse(require(path));
+        }
+
+        let protoStr = JSON.stringify(this.clientProtos) + JSON.stringify(this.serverProtos);
+        this.version = crypto.createHash('md5').update(protoStr).digest('base64');
+
+        // Watch file
+        const truePath = require.resolve(path);
+        let watcher = fs.watch(truePath, this.onUpdate.bind(this, type, truePath));
+        if (this.watchers[type]) {
+            this.watchers[type].close();
+        }
+        this.watchers[type] = watcher;
+    }
+
+    clearRequireCache(path: string) {
+        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];
+    }
+
+    onUpdate(type: string, path: string, event: string, filename?: string, errTry?: boolean) {
+        if (event !== 'change') {
+            return;
+        }
+
+        let self = this;
+        this.clearRequireCache(path);
+        try {
+            let protos = Protobuf.parse(require(path));
+            // 预防 git checkout这样的操作导致获得的数据为空的情况
+            if (!protos || !Object.keys(protos).length) {
+                // retry.
+                throw new Error('protos error');
+            }
+            if (type === Constants.RESERVED.SERVER) {
+                this.protobuf.setEncoderProtos(protos);
+                self.serverProtos = protos;
+            } else {
+                this.protobuf.setDecoderProtos(protos);
+                self.clientProtos = protos;
+            }
+
+            let protoStr = JSON.stringify(self.clientProtos) + JSON.stringify(self.serverProtos);
+            self.version = crypto.createHash('md5').update(protoStr).digest('base64');
+            logger.info('change proto file , type : %j, path : %j, version : %j', type, path, self.version);
+            // 抛出 proto 变化事件。
+            self.app.event.emit(AppEvents.PROTO_CHANGED, type);
+        } catch (e) {
+            logger.error('change proto file error! path : %j', path, filename, errTry, e);
+            if (!errTry) {
+                logger.warn('setTimeout,try update proto');
+                setTimeout(() => {
+                    logger.warn('try update proto again');
+                    this.onUpdate(type, path, event, filename, true);
+                }, 3000);
+            }
+
+        }
+        this.watchers[type].close();
+        this.watchers[type] = fs.watch(path, this.onUpdate.bind(this, type, path));
+    }
+
+    stop(force: boolean, cb: () => void) {
+        for (let type in this.watchers) {
+            this.watchers[type].close();
+        }
+        this.watchers = {};
+        process.nextTick(cb);
+    }
+}

package/lib/components/proxy.ts

@@ -0,0 +1,282 @@
+/**
+ * Component for proxy.
+ * Generate proxies for rpc client.
+ */
+import * as crc from 'crc';
+import * as utils from '../util/utils';
+import { default as events } from '../util/events';
+import { RpcClient, createClient } from '@bigtyphoon/melo-rpc';
+import * as pathUtil from '../util/pathUtil';
+import * as Constants from '../util/constants';
+import { getLogger } from '@bigtyphoon/melo-logger';
+import { Application } from '../application';
+import { IComponent } from '../interfaces/IComponent';
+import { RpcClientOpts } from '@bigtyphoon/melo-rpc';
+import { ServerInfo } from '../util/constants';
+import { Session } from '../index';
+import * as path from 'path';
+
+let logger = getLogger('melo', path.basename(__filename));
+
+export interface ProxyComponentOptions extends RpcClientOpts {
+    rpcClient?: {
+        create: (opts: RpcClientOpts) => RpcClient;
+    };
+    bufferMsg?: boolean;
+    cacheMsg?: boolean;
+    interval?: number;
+
+    enableRpcLog?: boolean;
+}
+
+/**
+ * Proxy component class
+ *
+ * @param {Object} app  current application context
+ * @param {Object} opts construct parameters
+ */
+export class ProxyComponent implements IComponent {
+    app: Application;
+    opts: ProxyComponentOptions;
+    client: RpcClient;
+
+    constructor(app: Application, opts: ProxyComponentOptions) {
+        opts = opts || {};
+        // proxy default config
+        // cacheMsg is deprecated, just for compatibility here.
+        opts.bufferMsg = opts.bufferMsg || opts.cacheMsg || false;
+        opts.interval = opts.interval || 30;
+        opts.router = genRouteFun();
+        opts.context = opts.context ?? app;
+        opts.routeContext = opts.routeContext ?? app;
+        if (app.enabled('rpcDebugLog')) {
+            opts.rpcDebugLog = true;
+            opts.rpcLogger = getLogger('rpc-debug', path.basename(__filename));
+        }
+
+        this.app = app;
+        this.opts = opts;
+        this.client = genRpcClient(this.app, opts);
+        this.app.event.on(events.ADD_SERVERS, this.addServers.bind(this));
+        this.app.event.on(events.REMOVE_SERVERS, this.removeServers.bind(this));
+        this.app.event.on(events.REPLACE_SERVERS, this.replaceServers.bind(this));
+    }
+
+    name = '__proxy__';
+
+    /**
+     * Proxy component lifecycle function
+     *
+     * @param {Function} cb
+     * @return {Void}
+     */
+    start(cb: (err?: Error) => void) {
+        if (this.opts.enableRpcLog) {
+            logger.warn('enableRpcLog is deprecated in 0.8.0, please use app.rpcFilter(melo.rpcFilters.rpcLog())');
+        }
+        let rpcBefores = this.app.get(Constants.KEYWORDS.RPC_BEFORE_FILTER);
+        let rpcAfters = this.app.get(Constants.KEYWORDS.RPC_AFTER_FILTER);
+        let rpcErrorHandler = this.app.get(Constants.RESERVED.RPC_ERROR_HANDLER);
+
+        if (!!rpcBefores) {
+            this.client.before(rpcBefores);
+        }
+        if (!!rpcAfters) {
+            this.client.after(rpcAfters);
+        }
+        if (!!rpcErrorHandler) {
+            this.client.setErrorHandler(rpcErrorHandler);
+        }
+        process.nextTick(cb);
+    }
+
+    /**
+     * Component lifecycle callback
+     *
+     * @param {Function} cb
+     * @return {Void}
+     */
+    afterStart(cb: (err?: Error) => void) {
+        let self = this;
+
+        Object.defineProperty(this.app, 'rpc', {
+            get: function () {
+                return self.client.proxies.user;
+            }
+        });
+
+        Object.defineProperty(this.app, 'sysrpc', {
+            get: function () {
+                return self.client.proxies.sys;
+            }
+        });
+        this.app.rpcInvoke = this.client.rpcInvoke.bind(this.client);
+
+        this.client.start(cb);
+    }
+
+    /**
+     * Add remote server to the rpc client.
+     *
+     * @param {Array} servers server info list, {id, serverType, host, port}
+     */
+    addServers(servers: ServerInfo[]) {
+        if (!servers || !servers.length) {
+            return;
+        }
+
+        genProxies(this.client, this.app, servers);
+        this.client.addServers(servers);
+    }
+
+    manualReloadProxies() {
+        let servers = [];
+        for (let k in this.client._station.servers) {
+            servers.push(this.client._station.servers[k])
+        }
+        logger.warn('manualReloadProxies servers:', servers);
+        genProxies(this.client, this.app, servers);
+    }
+
+    /**
+     * Remove remote server from the rpc client.
+     *
+     * @param  {Array} ids server id list
+     */
+    removeServers(ids: string[]) {
+        this.client.removeServers(ids);
+    }
+
+    /**
+     * Replace remote servers from the rpc client.
+     *
+     * @param  {Array} ids server id list
+     */
+    replaceServers(servers: ServerInfo[]) {
+        if (!servers || !servers.length) {
+            return;
+        }
+
+        // update proxies
+        this.client.proxies = {};
+        genProxies(this.client, this.app, servers);
+
+        this.client.replaceServers(servers);
+    }
+
+    /**
+     * Proxy for rpc client rpcInvoke.
+     *
+     * @param {String}   serverId remote server id
+     * @param {Object}   msg      rpc message: {serverType: serverType, service: serviceName, method: methodName, args: arguments}
+     * @param {Function} cb      callback function
+     */
+    rpcInvoke(serverId: string, msg: any, cb: (err: Error, ...args: any[]) => void) {
+        this.client.rpcInvoke(serverId, msg, cb);
+    }
+}
+
+export function manualReloadProxies(app: Application) {
+    if (!app.components.__proxy__) {
+        return;
+    }
+    if (app.components.__proxy__.manualReloadProxies) {
+        app.components.__proxy__.manualReloadProxies();
+    } else {
+        logger.warn('manualReloadProxies not method');
+    }
+
+}
+
+/**
+ * Generate rpc client
+ *
+ * @param {Object} app current application context
+ * @param {Object} opts contructor parameters for rpc client
+ * @return {Object} rpc client
+ */
+let genRpcClient = function (app: Application, opts: RpcClientOpts & { rpcClient?: { create: (opts: RpcClientOpts) => RpcClient; } }) {
+    opts.context = opts.context ?? app;
+    opts.routeContext = opts.routeContext ?? app;
+    if (!!opts.rpcClient) {
+        return opts.rpcClient.create(opts);
+    } else {
+        return createClient(opts);
+    }
+};
+
+/**
+ * Generate proxy for the server infos.
+ *
+ * @param  {Object} client rpc client instance
+ * @param  {Object} app    application context
+ * @param  {Array} sinfos server info list
+ */
+let genProxies = function (client: RpcClient, app: Application, sinfos: ServerInfo[]) {
+    let item;
+    for (let i = 0, l = sinfos.length; i < l; i++) {
+        item = sinfos[i];
+        client.addProxies(getProxyRecords(app, item));
+    }
+};
+
+/**
+ * Check a server whether has generated proxy before
+ *
+ * @param  {Object}  client rpc client instance
+ * @param  {Object}  sinfo  server info
+ * @return {Boolean}        true or false
+ */
+let hasProxy = function (client: RpcClient, sinfo: ServerInfo) {
+    let proxy = client.proxies;
+    return !!proxy.sys && !!proxy.sys[sinfo.serverType];
+};
+
+/**
+ * Get proxy path for rpc client.
+ * Iterate all the remote service path and create remote path record.
+ *
+ * @param {Object} app current application context
+ * @param {Object} sinfo server info, format: {id, serverType, host, port}
+ * @return {Array}     remote path record array
+ */
+let getProxyRecords = function (app: Application, sinfo: ServerInfo) {
+    return sinfo.remoterPaths;
+};
+
+let genRouteFun = function () {
+    return function (session: Session, msg: any, app: Application, cb: RouteCallback) {
+        let routes = app.get(Constants.KEYWORDS.ROUTE);
+
+        if (!routes) {
+            defaultRoute(session, msg, app, cb);
+            return;
+        }
+
+        let type = msg.serverType,
+            route = routes[type] || routes['default'];
+
+        if (route) {
+            route(session, msg, app, cb);
+        } else {
+            defaultRoute(session, msg, app, cb);
+        }
+    };
+};
+
+export type RouteCallback = (err: Error, routeToServerId ?: string) => void;
+
+let defaultRoute = function (session: Session, msg: any, app: Application, cb: RouteCallback) {
+    let list = app.getServersByType(msg.serverType);
+    if (!list || !list.length) {
+        cb(new Error('can not find server info for type:' + msg.serverType));
+        return;
+    }
+
+    let uid = session ? (session.uid || '') : '';
+    let index = Math.abs(crc.crc32(uid.toString())) % list.length;
+    utils.invokeCallback(cb, null, list[index].id);
+};
+
+export type RouteFunction = (routeFrom: any, msg: any, app: Application, cb: RouteCallback) => void;
+export type RouteMaps = { [key: string]: RouteFunction };

package/lib/components/pushScheduler.ts

@@ -0,0 +1,70 @@
+/**
+ * Scheduler component to schedule message sending.
+ */
+
+import {DirectPushScheduler as DefaultScheduler} from '../pushSchedulers/direct';
+import { getLogger } from '@bigtyphoon/melo-logger';
+import { Application } from '../application';
+import { IComponent } from '../interfaces/IComponent';
+import { IPushScheduler, ScheduleOptions, IPushSchedulerOrCtor, IPushSchedulerOptions, MultiPushSchedulerOptions } from '../interfaces/IPushScheduler';
+import { MultiPushScheduler } from '../pushSchedulers/multi';
+import { SID } from '../util/constants';
+import * as path from 'path';
+let logger = getLogger('melo', path.basename(__filename));
+
+
+export class PushSchedulerComponent implements IComponent {
+    scheduler: IPushScheduler;
+    constructor(private app: Application, opts ?: IPushSchedulerOptions) {
+        opts = opts || {};
+        this.scheduler = getScheduler(this, app, opts);
+    }
+
+    name = '__pushScheduler__';
+
+    /**
+     * Component lifecycle callback
+     *
+     * @param {Function} cb
+     * @return {Void}
+     */
+    afterStart(cb: () => void) {
+        this.scheduler.start().then(cb);
+    }
+
+    /**
+     * Component lifecycle callback
+     *
+     * @param {Function} cb
+     * @return {Void}
+     */
+    stop(force: boolean, cb: () => void) {
+        this.scheduler.stop().then(cb);
+    }
+
+    /**
+     * 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
+     * @param  {Function} cb
+     */
+    schedule(reqId: number, route: string, msg: any, recvs: SID[], opts: ScheduleOptions, cb: (err?: Error) => void) {
+        this.scheduler.schedule(reqId, route, msg, recvs, opts, cb);
+    }
+}
+let getScheduler = function (pushSchedulerComp: PushSchedulerComponent, app: Application, opts: IPushSchedulerOptions): IPushScheduler {
+    let scheduler = opts.scheduler || DefaultScheduler;
+    if (typeof scheduler === 'function') {
+        return new scheduler(app, opts);
+    }
+
+    if (Array.isArray(scheduler)) {
+        return new MultiPushScheduler(app , opts as MultiPushSchedulerOptions);
+    }
+
+    return scheduler as IPushScheduler;
+};