service-starter/bin/common/BaseServiceModule.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Emitter = require("component-emitter");
/**
 * 所有服务模块的父类
 */
class BaseServiceModule extends Emitter {
    constructor() {
        super(...arguments);
        /**
         * 简化对其他注册服务的获取
         */
        this.services = new Proxy({}, {
            get: (_, property) => {
                if (this._servicesManager !== undefined) {
                    const rs = this._servicesManager.services.get(property);
                    if (rs !== undefined)
                        return rs.service;
                }
            }
        });
    }
    /**
     * 获取当前服务的名称（默认是类名）
     */
    get name() {
        return this.constructor.name;
    }
    /**
     * 当前模块的运行状态
     */
    get runningStatus() {
        return this._runningStatus;
    }
    set runningStatus(v) {
        this._runningStatus = v;
    }
    /**
     * 对于服务管理器的引用。
     * 当服务注册之后，服务管理器会自动对该属性进行绑定
     */
    get servicesManager() {
        return this._servicesManager;
    }
    set servicesManager(v) {
        //确保只能被设置一次
        if (this._servicesManager === undefined)
            this._servicesManager = v;
        else
            throw new Error(`模块：${this.name}：不允许重复设置ServicesManager`);
    }
    /**
     * 停止服务
     * 注意：停止过程中出现的错误直接通过Promise.reject()来处理。停止过程中不要出现未捕获异常
     *
     * @returns {Promise<void>}
     */
    onStop() {
        return Promise.resolve();
    }
    /**
     * 当服务发生异常时，这个方法会在全局错误处理方法(BaseServicesManager的onError)之前被调用。
     * 注意：该方法只有当服务在运行过程中发生错误时（通过this.emit('error')触发的错误），该方法才会被调用。
     *
     * 返回false、undefined或null                     ：错误将继续交由全局错误处理方法处理
     * 返回true                                       ：错误不再交由全局错误处理方法处理
     * 返回{errName: string | undefined, err: Error}  ：替换错误的内容，将新的Error交由全局错误处理方法继续处理
     *
     * @param errName 错误消息的名称
     * @param err 错误消息
     */
    onError(errName, err) {
        return Promise.resolve();
    }
    /**
     * 检查当前服务运行是否正常。
     * 如果正常直接Promise.resolve()，如果出现问题直接Promise.reject(new Error())
     *
     * @returns {Promise<void>}
     */
    onHealthCheck() {
        return Promise.resolve();
    }
    on(event, listener) {
        super.on(event, listener);
        return this;
    }
    once(event, listener) {
        super.once(event, listener);
        return this;
    }
    emit(event, ...args) {
        if (event === 'error') {
            let errName, err;
            if (args[0] instanceof Error) {
                err = args[0];
            }
            else {
                errName = args[0];
                err = args[1];
            }
            return super.emit(event, errName, err);
        }
        else {
            return super.emit(event, ...args);
        }
    }
}
exports.BaseServiceModule = BaseServiceModule;

//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["common/BaseServiceModule.ts"],"names":[],"mappings":";;AAEA,6CAA6C;AAE7C;;GAEG;AACH,uBAAwC,SAAQ,OAAO;IAAvD;;QAoCI;;WAEG;QACM,aAAQ,GAAQ,IAAI,KAAK,CAAC,EAAE,EAAE;YACnC,GAAG,EAAE,CAAC,CAAC,EAAE,QAAgB;gBACrB,EAAE,CAAC,CAAC,IAAI,CAAC,gBAAgB,KAAK,SAAS,CAAC,CAAC,CAAC;oBACtC,MAAM,EAAE,GAAG,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;oBACxD,EAAE,CAAC,CAAC,EAAE,KAAK,SAAS,CAAC;wBACjB,MAAM,CAAC,EAAE,CAAC,OAAO,CAAC;gBAC1B,CAAC;YACL,CAAC;SACJ,CAAC,CAAC;IAgGP,CAAC;IA7IG;;OAEG;IACH,IAAI,IAAI;QACJ,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;IACjC,CAAC;IAED;;OAEG;IACH,IAAI,aAAa;QACb,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC;IAC/B,CAAC;IACD,IAAI,aAAa,CAAC,CAAgB;QAC9B,IAAI,CAAC,cAAc,GAAG,CAAC,CAAC;IAC5B,CAAC;IAGD;;;OAGG;IACH,IAAI,eAAe;QACf,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC;IACjC,CAAC;IACD,IAAI,eAAe,CAAC,CAAsB;QACtC,WAAW;QACX,EAAE,CAAC,CAAC,IAAI,CAAC,gBAAgB,KAAK,SAAS,CAAC;YACpC,IAAI,CAAC,gBAAgB,GAAG,CAAC,CAAC;QAC9B,IAAI;YACA,MAAM,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC,IAAI,yBAAyB,CAAC,CAAC;IAClE,CAAC;IA2BD;;;;;OAKG;IACH,MAAM;QACF,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;IAC7B,CAAC;IAED;;;;;;;;;;OAUG;IACH,OAAO,CAAC,OAA2B,EAAE,GAAU;QAC3C,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;IAC7B,CAAC;IAED;;;;;OAKG;IACH,aAAa;QACT,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;IAC7B,CAAC;IAMD,EAAE,CAAC,KAAa,EAAE,QAAkB;QAChC,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;QAC1B,MAAM,CAAC,IAAI,CAAC;IAChB,CAAC;IAGD,IAAI,CAAC,KAAa,EAAE,QAAkB;QAClC,KAAK,CAAC,IAAI,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;QAC5B,MAAM,CAAC,IAAI,CAAC;IAChB,CAAC;IAqBD,IAAI,CAAC,KAAa,EAAE,GAAG,IAAW;QAC9B,EAAE,CAAC,CAAC,KAAK,KAAK,OAAO,CAAC,CAAC,CAAC;YACpB,IAAI,OAAO,EAAE,GAAG,CAAC;YACjB,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,YAAY,KAAK,CAAC,CAAC,CAAC;gBAC3B,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;YAClB,CAAC;YAAC,IAAI,CAAC,CAAC;gBACJ,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;gBAClB,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;YAClB,CAAC;YACD,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,CAAC,CAAC;QAC3C,CAAC;QAAC,IAAI,CAAC,CAAC;YACJ,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,EAAE,GAAG,IAAI,CAAC,CAAC;QACtC,CAAC;IACL,CAAC;CACJ;AA/ID,8CA+IC","file":"common/BaseServiceModule.js","sourcesContent":["import { BaseServicesManager } from \"./BaseServicesManager\";\r\nimport { RunningStatus } from './RunningStatus';\r\nimport * as Emitter from 'component-emitter';\r\n\r\n/**\r\n * 所有服务模块的父类    \r\n */\r\nexport abstract class BaseServiceModule extends Emitter {\r\n\r\n    /**\r\n     * 获取当前服务的名称（默认是类名）\r\n     */\r\n    get name(): string {\r\n        return this.constructor.name;\r\n    }\r\n\r\n    /**\r\n     * 当前模块的运行状态\r\n     */\r\n    get runningStatus(): RunningStatus {\r\n        return this._runningStatus;\r\n    }\r\n    set runningStatus(v: RunningStatus) {\r\n        this._runningStatus = v;\r\n    }\r\n    private _runningStatus: RunningStatus;\r\n\r\n    /**\r\n     * 对于服务管理器的引用。    \r\n     * 当服务注册之后，服务管理器会自动对该属性进行绑定\r\n     */\r\n    get servicesManager(): BaseServicesManager {\r\n        return this._servicesManager;\r\n    }\r\n    set servicesManager(v: BaseServicesManager) {\r\n        //确保只能被设置一次\r\n        if (this._servicesManager === undefined)\r\n            this._servicesManager = v;\r\n        else\r\n            throw new Error(`模块：${this.name}：不允许重复设置ServicesManager`);\r\n    }\r\n    private _servicesManager: BaseServicesManager;\r\n\r\n    /**\r\n     * 简化对其他注册服务的获取\r\n     */\r\n    readonly services: any = new Proxy({}, {\r\n        get: (_, property: string) => {\r\n            if (this._servicesManager !== undefined) {\r\n                const rs = this._servicesManager.services.get(property);\r\n                if (rs !== undefined)\r\n                    return rs.service;\r\n            }\r\n        }\r\n    });\r\n\r\n    /**\r\n     * 启动服务     \r\n     * 注意：启动过程中出现的错误直接通过Promise.reject()来处理。\r\n     * 启动之后(运行过程中)出现的错误，通过this.emit('error')来处理。\r\n     * 尽可能多地捕捉异常，然后在onError中处理，未捕捉的异常根据平台的不同可能会导致程序直接被关闭。\r\n     * \r\n     * @abstract\r\n     * @returns {Promise<void>} \r\n     */\r\n    abstract onStart(): Promise<void>;\r\n\r\n    /**\r\n     * 停止服务     \r\n     * 注意：停止过程中出现的错误直接通过Promise.reject()来处理。停止过程中不要出现未捕获异常\r\n     * \r\n     * @returns {Promise<void>} \r\n     */\r\n    onStop(): Promise<void> {\r\n        return Promise.resolve();\r\n    }\r\n\r\n    /**\r\n     * 当服务发生异常时，这个方法会在全局错误处理方法(BaseServicesManager的onError)之前被调用。      \r\n     * 注意：该方法只有当服务在运行过程中发生错误时（通过this.emit('error')触发的错误），该方法才会被调用。    \r\n     * \r\n     * 返回false、undefined或null                     ：错误将继续交由全局错误处理方法处理   \r\n     * 返回true                                       ：错误不再交由全局错误处理方法处理   \r\n     * 返回{errName: string | undefined, err: Error}  ：替换错误的内容，将新的Error交由全局错误处理方法继续处理   \r\n     * \r\n     * @param errName 错误消息的名称\r\n     * @param err 错误消息\r\n     */\r\n    onError(errName: string | undefined, err: Error): Promise<{ errName: string | undefined, err: Error } | boolean | void> {\r\n        return Promise.resolve();\r\n    }\r\n\r\n    /**\r\n     * 检查当前服务运行是否正常。   \r\n     * 如果正常直接Promise.resolve()，如果出现问题直接Promise.reject(new Error())\r\n     * \r\n     * @returns {Promise<void>} \r\n     */\r\n    onHealthCheck(): Promise<void> {\r\n        return Promise.resolve();\r\n    }\r\n\r\n    /**\r\n     * 模块运行过程中发生的从错误\r\n     */\r\n    on(event: 'error', listener: (errName: string | undefined, err: Error) => any): this;\r\n    on(event: string, listener: Function): this {\r\n        super.on(event, listener);\r\n        return this;\r\n    }\r\n\r\n    once(event: 'error', listener: (errName: string | undefined, err: Error) => any): this;\r\n    once(event: string, listener: Function): this {\r\n        super.once(event, listener);\r\n        return this;\r\n    }\r\n\r\n    /**\r\n     * 触发错误事件。并设置错误事件的errName为undefined\r\n     * \r\n     * @param {'error'} event \r\n     * @param {Error} err 错误消息\r\n     * @returns {boolean} \r\n     * @memberof BaseServiceModule\r\n     */\r\n    emit(event: 'error', err: Error): boolean;\r\n    /**\r\n     * 触发错误事件。\r\n     * \r\n     * @param {'error'} event \r\n     * @param {string} errName 错误消息的名称\r\n     * @param {Error} err 错误消息\r\n     * @returns {boolean} \r\n     * @memberof BaseServiceModule\r\n     */\r\n    emit(event: 'error', errName: string, err: Error): boolean;\r\n    emit(event: string, ...args: any[]): boolean {\r\n        if (event === 'error') {\r\n            let errName, err;\r\n            if (args[0] instanceof Error) {\r\n                err = args[0];\r\n            } else {\r\n                errName = args[0];\r\n                err = args[1];\r\n            }\r\n            return super.emit(event, errName, err);\r\n        } else {\r\n            return super.emit(event, ...args);\r\n        }\r\n    }\r\n}"]}