@bigtyphoon/melo 1.7.6

package/lib/filters/rpc/toobusy.ts

@@ -0,0 +1,41 @@
+/**
+ * Filter for rpc log.
+ * Reject rpc request when toobusy
+ */
+import {getLogger} from '@bigtyphoon/melo-logger';
+import {IRpcFilter} from '@bigtyphoon/melo-rpc';
+
+let rpcLogger = getLogger('rpc-log', __filename);
+let toobusy: any = null;
+
+let DEFAULT_MAXLAG = 70;
+
+
+export class RpcToobusyFilter implements IRpcFilter {
+    constructor(maxLag = DEFAULT_MAXLAG) {
+        try {
+            toobusy = require('toobusy');
+        } catch (e) {
+        }
+        if (!!toobusy) {
+            toobusy.maxLag(maxLag);
+        }
+    }
+
+    name = 'toobusy';
+
+    /**
+     * Before filter for rpc
+     */
+    before(serverId: string, msg: any, opts: any, next: (target?: Error | string, message?: any, options?: any) => void) {
+        opts = opts || {};
+        if (!!toobusy && toobusy()) {
+            rpcLogger.warn('Server too busy for rpc request, serverId:' + serverId + ' msg: ' + msg);
+            let err = new Error('Backend server ' + serverId + ' is too busy now!');
+            (err as any).code = 500;
+            next(err);
+        } else {
+            next();
+        }
+    }
+}

package/lib/index.ts

@@ -0,0 +1,74 @@
+export * from './melo';
+
+export * from './application';
+export * from './common/service/backendSessionService';
+export * from './common/service/channelService';
+export * from './common/service/connectionService';
+export * from './common/service/filterService';
+export * from './common/service/handlerService';
+export * from './common/service/sessionService';
+
+export * from './connectors/hybridconnector';
+export * from './connectors/udpconnector';
+export * from './connectors/mqttconnector';
+export * from './connectors/sioconnector';
+
+
+export * from './pushSchedulers/direct';
+export * from './pushSchedulers/buffer';
+
+export * from './components/connection';
+export * from './components/connector';
+export * from './components/dictionary';
+export * from './components/master';
+export * from './components/monitor';
+export * from './components/protobuf';
+export * from './components/proxy';
+export * from './components/pushScheduler';
+export * from './components/remote';
+export * from './components/server';
+export * from './components/session';
+export * from './components/backendSession';
+export * from './components/channel';
+
+
+export {RestartNotifyModule} from './modules/restartNotifyModule';
+
+export * from './server/server';
+export * from './monitor/monitor';
+export * from './pushSchedulers/direct';
+export * from './pushSchedulers/buffer';
+export * from './pushSchedulers/multi';
+
+export * from './filters/rpc/toobusy';
+export * from './filters/rpc/rpcLog';
+export * from './filters/handler/toobusy';
+export * from './filters/handler/time';
+export * from './filters/handler/serial';
+export * from './filters/handler/timeout';
+
+export {default as events} from './util/events';
+export * from './util/constants';
+export * from './util/utils';
+export * from './util/pathUtil';
+export * from './util/remoterHelper';
+export * from './util/handlerHelper';
+
+
+export * from './interfaces/define';
+export * from './interfaces/IComponent';
+export * from './interfaces/IConnector';
+export * from './interfaces/IHandlerFilter';
+export * from './interfaces/ILifeCycle';
+export * from './interfaces/IPlugin';
+export * from './interfaces/IPushScheduler';
+export * from './interfaces/ISocket';
+export * from './interfaces/IStore';
+
+export * from '@bigtyphoon/melo-admin';
+export * from '@bigtyphoon/melo-loader';
+export * from '@bigtyphoon/melo-logger';
+export * from '@bigtyphoon/melo-protobuf';
+export * from '@bigtyphoon/melo-protocol';
+export * from '@bigtyphoon/melo-rpc';
+export * from '@bigtyphoon/melo-scheduler';

package/lib/interfaces/IComponent.ts

@@ -0,0 +1,47 @@
+
+
+export interface IComponent {
+    name: string;
+    /**
+     * Component lifecycle callback
+     *
+     * @param {Function} cb
+     * @return {Void}
+     */
+    beforeStart?: (cb: () => void) => void;
+
+    /**
+     * Component lifecycle callback
+     *
+     * @param {Function} cb
+     * @return {Void}
+     */
+    start ?: (cb: () => void) => void;
+
+    /**
+     * Component lifecycle callback
+     *
+     * @param {Function} cb
+     * @return {Void}
+     */
+    afterStart?: (cb: () => void) => void;
+
+    /**
+     * Component lifecycle callback
+     * 所有进程启动好以后的通知。单个进程重启是不会有这个通知的。
+     * 如果单独重启了master。 master内会有一个计数器。 其它进程重启到这个次数，就会发送这个通知（也就是说有可能重复通知afterStartAll）。
+     * 可以通过注册使用 RestartNotifyModule admin模块，来实现重启单个逻辑进程时通知这个事件（这个模块可以避免重复通知）。
+     *
+     * @return {Void}
+     */
+    afterStartAll ?: () => void;
+
+    /**
+     * Component lifecycle function
+     *
+     * @param {Boolean}  force whether stop the component immediately
+     * @param {Function}  cb
+     * @return {Void}
+     */
+    stop?: (force: boolean, cb: () => void) => void;
+}

package/lib/interfaces/IConnector.ts

@@ -0,0 +1,20 @@
+import { ISocket } from './ISocket';
+
+export type IEncoder = (reqId: number, route: string, msg: any) =>
+{
+    id: number,
+    body: any
+} | any;
+
+export type IDecoder = (msg: any) => { id: number, route: string, body: any };
+
+export interface IConnector {
+    start(cb: () => void): void;
+    stop(force: boolean, cb: () => void): void;
+    encode ?: IEncoder;
+
+    decode ?: IDecoder;
+
+    on(evt: 'connection' , listener: (cb: (socket: ISocket) => boolean, socket: ISocket) => void): void;
+
+}

package/lib/interfaces/IHandlerFilter.ts

@@ -0,0 +1,15 @@
+import { RouteRecord } from '../util/constants';
+import { HandlerCallback } from '../common/service/handlerService';
+import { FrontendOrBackendSession } from '../server/server';
+
+
+export type BeforeHandlerFilterFunction = (routeRecord: RouteRecord , msg: any, session: FrontendOrBackendSession, cb: HandlerCallback) => void;
+export type AfterHandlerFilterFunction = (err: Error, routeRecord: RouteRecord , msg: any, session: FrontendOrBackendSession, resp: any, cb: HandlerCallback) => void;
+
+export interface IHandlerFilter {
+    before ?: BeforeHandlerFilterFunction;
+    after ?: AfterHandlerFilterFunction;
+}
+
+export type BeforeHandlerFilter = BeforeHandlerFilterFunction | IHandlerFilter;
+export type AfterHandlerFilter = AfterHandlerFilterFunction | IHandlerFilter;

package/lib/interfaces/ILifeCycle.ts

@@ -0,0 +1,16 @@
+import { Application } from '../application';
+import { IComponent } from './IComponent';
+
+/**
+ * 服务器生命周期
+ */
+export interface ILifeCycle {
+    beforeStartup ?: (app: Application , cb: () => void) => void;
+    afterStartup ?: (app: Application , cb: () => void) => void;
+    // 所有进程启动好以后的通知。单个进程重启是不会有这个通知的。
+    // 如果单独重启了master。 master内会有一个计数器。 其它进程重启到这个次数，就会发送这个通知（也就是说有可能重复通知afterStartAll）。
+    // 可以通过注册使用 RestartNotifyModule admin模块，来实现重启单个逻辑进程时通知这个事件（这个模块可以避免重复通知）。
+    afterStartAll ?: (app: Application) => void;
+
+    beforeShutdown ?: (app: Application , shutDown: () => void , cancelShutDownTimer: () => void) => void;
+}

package/lib/interfaces/IPlugin.ts

@@ -0,0 +1,65 @@
+
+import {default as AppEvents} from '../util/events';
+import { ServerInfo } from '../util/constants';
+import { ObjectType } from './define';
+import { ILifeCycle } from './ILifeCycle';
+import { IComponent } from './IComponent';
+import { Cron } from '../server/server';
+import { Session } from '../index';
+import { Application } from '../application';
+
+export interface ComponentContructor {
+    new(app: Application, opts ?: any): IComponent;
+}
+
+export interface IApplicationEvent {
+    add_servers ?: (servers: ServerInfo[]) => void;
+    remove_servers ?: (servers: ServerInfo[]) => void;
+    replace_servers ?: (servers: ServerInfo[]) => void;
+    bind_session ?: (session: Session) => void;
+    unbind_session ?: (session: Session) => void;
+    close_session ?: (session: Session) => void;
+    add_crons ?: (crons: Cron[]) => void;
+    remove_crons ?: (crons: Cron[]) => void;
+    start_server ?: (serverId: string) => void;
+    start_all ?: () => void;
+}
+
+export interface ApplicationEventContructor {
+    new(opts ?: any): IApplicationEvent;
+}
+
+/**
+ * 一个melo插件
+ */
+export interface IPlugin extends ILifeCycle {
+    /**
+     * 插件的名称
+     */
+    name: string;
+
+    /**
+     * 启动插件时需要自动加载的组件
+     */
+    components ?: ComponentContructor[];
+
+    /**
+     * 启动插件时需要侦听的应用程序事件
+     */
+    events ?: ApplicationEventContructor[];
+
+    /**
+     * 插件暴漏的handler所在的路径
+     */
+    handlerPath ?: string;
+
+    /**
+     * 插件暴漏的remoters所在的路径
+     */
+    remoterPath?: string;
+
+    /**
+     * 插件暴漏的crons所在的路径
+     */
+    cronPath ?: string;
+}

package/lib/interfaces/IPushScheduler.ts

@@ -0,0 +1,52 @@
+import { SID } from '../util/constants';
+import { Application } from '../application';
+
+
+export interface BroadcastOptions {
+    binded: boolean ;
+    filterParam: any;
+}
+export interface ScheduleOptions {
+    type ?: 'broadcast' | 'response';
+    userOptions ?: BroadcastOptions;
+}
+
+export type IPushSelector = (reqId: number, route: string, msg: any, recvs: number[], opts: any) => number;
+
+export type IPushSchedulerOrCtor = { new(app: Application, opts?: any): IPushScheduler } | IPushScheduler;
+
+export interface SinglePushScheduler {
+    scheduler ?: IPushSchedulerOrCtor;
+}
+
+export interface MultiPushSchedulerOptions {
+    scheduler ?: {id: number , scheduler: IPushSchedulerOrCtor , options: IPushSchedulerOptions}[];
+    selector ?: IPushSelector;
+}
+
+export type IPushSchedulerOptions = SinglePushScheduler | MultiPushSchedulerOptions;
+
+export interface IPushScheduler {
+
+    /**
+     * Component lifecycle callback
+     *
+     * @param {Function} cb
+     * @return {Void}
+     */
+    start(): Promise<void>;
+
+    /**
+     * Component lifecycle function
+     *
+     * @param {Boolean}  force whether stop the component immediately
+     * @param {Function}  cb
+     * @return {Void}
+     */
+    stop(): Promise<void>;
+
+    /**
+     * 调度发生时调用
+     */
+    schedule(reqId: number, route: string, msg: any, recvs: SID[], opts: ScheduleOptions, cb: (err?: Error) => void): void;
+}

package/lib/interfaces/ISocket.ts

@@ -0,0 +1,26 @@
+
+export interface ISocket {
+    once(evt: 'disconnect', listener: () => void): void;
+    once(evt: 'error', listener: () => void): void;
+    on(evt: 'disconnect', listener: (reason: string) => void): void;
+    on(evt: 'error', listener: (reason: string) => void): void;
+    on(evt: 'message', listener: (msg: any) => void): void;
+    send(msg: any): void;
+    sendRaw(msg: any): void;
+    disconnect(): void;
+    sendBatch(msgs: any[]): void;
+
+    emit(evt: 'heartbeat'): void;
+    emit(evt: 'message' , pkg: any): void;
+    emit(evt: 'closing' , reason: string): void;
+    emit(evt: 'handshake' , pkg: any): void;
+
+    state: number;
+
+    id ?: number;
+
+    handshakeResponse ?: (response: any) => void;
+    sendForce ?: (response: any) => void;
+
+    remoteAddress ?: {ip: string , port ?: number};
+}

package/lib/interfaces/IStore.ts

@@ -0,0 +1,10 @@
+
+/**
+* 存储虚接口
+*/
+export interface IStore {
+    add(key: string, value: string, done: (err?: Error) => void): void;
+    remove(key: string, value: string, done: (err?: Error) => void): void;
+    load(key: string, done: (err?: Error , list ?: Array<string>) => void): void;
+    removeAll(key: string, done: (err?: Error) => void): void;
+}

package/lib/interfaces/define.ts

@@ -0,0 +1,15 @@
+/**
+ * master server info
+ */
+export interface MasterInfo {
+    id: string;
+    host: string;
+    port: number;
+}
+
+/**
+ * Represents some Type of the Object.
+ */
+export type ObjectType<T> = {
+    new (): T;
+};

package/lib/master/master.ts

@@ -0,0 +1,148 @@
+import * as starter from './starter';
+import { getLogger } from '@bigtyphoon/melo-logger';
+import * as path from 'path';
+
+let logger = getLogger('melo', path.basename(__filename));
+let crashLogger = getLogger('crash-log', path.basename(__filename));
+let adminLogger = getLogger('admin-log', path.basename(__filename));
+import * as admin from '@bigtyphoon/melo-admin';
+import * as util from 'util';
+import * as utils from '../util/utils';
+import * as moduleUtil from '../util/moduleUtil';
+import * as Constants from '../util/constants';
+import { Application } from '../application';
+import { ConsoleService, ConsoleServiceOpts } from '@bigtyphoon/melo-admin';
+import { IModule } from '../index';
+
+
+export type MasterServerOptions =
+    {
+        port?: number;
+        env?: string;
+        closeWatcher?: boolean;
+    } & Partial<ConsoleServiceOpts>;
+
+export class MasterServer {
+    app: Application;
+    masterInfo: any;
+    registered = {};
+    modules: IModule[] = [];
+    closeWatcher: boolean;
+    masterConsole: ConsoleService;
+
+    constructor(app: Application, opts?: MasterServerOptions) {
+        this.app = app;
+        this.masterInfo = app.getMaster();
+        opts = opts || {};
+
+        opts.port = this.masterInfo.port;
+        opts.env = this.app.get(Constants.RESERVED.ENV);
+        this.closeWatcher = opts.closeWatcher || false;
+        this.masterConsole = admin.createMasterConsole(opts);
+    }
+
+
+    start(cb: (err?: Error) => void) {
+        moduleUtil.registerDefaultModules(true, this.app, this.closeWatcher);
+        moduleUtil.loadModules(this, this.masterConsole);
+
+        let self = this;
+        // start master console
+        this.masterConsole.start(function (err) {
+            if (err) {
+                process.exit(0);
+            }
+            moduleUtil.startModules(self.modules, function (err: Error) {
+                if (err) {
+                    utils.invokeCallback(cb, err);
+                    return;
+                }
+
+                if (self.app.get(Constants.RESERVED.MODE) !== Constants.RESERVED.STAND_ALONE) {
+                    starter.runServers(self.app);
+                }
+                utils.invokeCallback(cb);
+            });
+        });
+
+        this.masterConsole.on('error', function (err) {
+            if (!!err) {
+                logger.error('masterConsole encounters with error: ' + err.stack);
+                return;
+            }
+        });
+
+        this.masterConsole.on('reconnect', function (info) {
+            self.app.addServers([info]);
+        });
+
+        // monitor servers disconnect event
+        this.masterConsole.on('disconnect', function (id, type, info, reason) {
+            crashLogger.info(util.format('[%s],[%s],[%s],[%s]', type, id, Date.now(), reason || 'disconnect'));
+            let count = 0;
+            let time = 0;
+            let pingTimer: NodeJS.Timeout = null;
+            let server = self.app.getServerById(id);
+            let stopFlags = self.app.get(Constants.RESERVED.STOP_SERVERS) || [];
+            let autoRestart: any = server && server[Constants.RESERVED.AUTO_RESTART] || '';
+            let restartForce: any = server && server[Constants.RESERVED.RESTART_FORCE] || '';
+            if ((autoRestart.toString() === 'true' || restartForce.toString() === 'true') && stopFlags.indexOf(id) < 0) {
+                let handle = function () {
+                    clearTimeout(pingTimer);
+                    utils.checkPort(self.app, server, function (status) {
+                        if (status === 'error') {
+                            utils.invokeCallback(cb, new Error('Check port command executed with error.'));
+                            return;
+                        } else if (status === 'busy') {
+                            if (!!server[Constants.RESERVED.RESTART_FORCE]) {
+                                starter.kill(self.app, [info.pid], [server]);
+                            } else {
+                                utils.invokeCallback(cb, new Error('Port occupied already, check your server to add.'));
+                                return;
+                            }
+                        }
+                        setTimeout(function () {
+                            starter.run(self.app, server, null);
+                        }, Constants.TIME.TIME_WAIT_STOP);
+                    });
+                };
+                let setTimer = function (time: number) {
+                    pingTimer = setTimeout(function () {
+                        utils.ping(server.host, function (flag) {
+                            if (flag) {
+                                handle();
+                            } else {
+                                count++;
+                                if (count > 3) {
+                                    time = Constants.TIME.TIME_WAIT_MAX_PING;
+                                } else {
+                                    time = Constants.TIME.TIME_WAIT_PING * count;
+                                }
+                                setTimer(time);
+                            }
+                        });
+                    }, time);
+                };
+                setTimer(time);
+            }
+        });
+
+        // monitor servers register event
+        this.masterConsole.on('register', function (record) {
+            starter.bindCpu(self.app, record.id, record.pid, record.host);
+        });
+
+        this.masterConsole.on('admin-log', function (log, error) {
+            if (error) {
+                adminLogger.error(JSON.stringify(log));
+            } else {
+                adminLogger.info(JSON.stringify(log));
+            }
+        });
+    }
+
+    stop(cb: () => void) {
+        this.masterConsole.stop();
+        process.nextTick(cb);
+    }
+}