service-starter/bin/RegisteredService/RegisteredService.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const RunningStatus_1 = require("../RunningStatus");
const Log_1 = require("../Log");
/**
 * 对注册了的服务进行一层封装，便于ServicesManager使用。
 * 对于注册服务的生命周期进行管理。
 *
 * @class RegisteredService
 */
class RegisteredService {
    constructor(service, manager) {
        /**
         * 绑定在服务上的错误监听器。
         *
         * @type {Function}
         */
        this._errorListener = async (err) => {
            const value = await this.service.onError(err);
            switch (value) {
                case false:
                    this._manager.onError(err, this.service);
                    break;
                case true:
                    break;
                default:
                    if (value instanceof Error)
                        this._manager.onError(value, this.service);
                    break;
            }
        };
        this._status = RunningStatus_1.RunningStatus.stopped;
        this.service = service;
        this._manager = manager;
        // 给服务绑定管理器
        this.service.servicesManager = manager;
    }
    /**
     * 服务的运行状态
     */
    get status() {
        return this._status;
    }
    /**
     * 启动服务。成功返回void，失败返回Error。
     * 如果抛出异常则一定是该程序内部逻辑错误
     * 这个方法仅供内部使用。
     *
     * @returns {Promise<Error | void>}
     */
    async _start() {
        //确保只有在stopped的情况下才能执行_start
        if (this._status !== RunningStatus_1.RunningStatus.stopped) {
            throw new Error(Log_1.log.s1.format(`服务：${this.service.name}`, '在还未完全关闭的情况下又再次被启动。', `当前的状态为：${RunningStatus_1.RunningStatus[this._status]}`));
        }
        try {
            Log_1.log.s1.l(Log_1.log.chalk.blue('服务：开始启动'), this.service.name);
            this._status = RunningStatus_1.RunningStatus.starting;
            await this.service.onStart();
            this.service.on('error', this._errorListener);
            Log_1.log.s1.l(Log_1.log.chalk.green('服务：成功启动'), this.service.name);
            this._status = RunningStatus_1.RunningStatus.running;
        }
        catch (err) {
            Log_1.log.s1.e(Log_1.log.chalk.red('服务：启动失败'), this.service.name, err);
            await this._stop();
            return err;
        }
    }
    /**
     * 停止服务。
     * 如果抛出异常则一定是该程序内部逻辑错误
     * 这个方法仅供内部使用。
     */
    async _stop() {
        //确保不会重复停止
        if (this._status === RunningStatus_1.RunningStatus.stopping || this._status === RunningStatus_1.RunningStatus.stopped) {
            throw new Error(Log_1.log.s1.format(`服务：${this.service.name}`, '在处于正在停止或已停止的状态下又再次被停止。', `当前的状态为：${RunningStatus_1.RunningStatus[this._status]}`));
        }
        try {
            Log_1.log.s1.l(Log_1.log.chalk.blue('服务：开始停止'), this.service.name);
            this._status = RunningStatus_1.RunningStatus.stopping;
            await this.service.onStop();
            Log_1.log.s1.l(Log_1.log.chalk.green('服务：成功停止'), this.service.name);
        }
        catch (err) {
            Log_1.log.s1.e(Log_1.log.chalk.red('服务：停止失败'), this.service.name, err);
        }
        finally {
            this._status = RunningStatus_1.RunningStatus.stopped;
            this.service.removeListener('error', this._errorListener);
        }
    }
    /**
     * 健康检查。
     * 如果抛出异常则一定是该程序内部逻辑错误
     * 这个方法仅供内部使用。
     *
     * @returns {(Promise<Error | void>)} 健康检查出现的错误
     */
    async _healthCheck() {
        // 确保只检查运行状况下的健康状态
        if (this._status !== RunningStatus_1.RunningStatus.running) {
            throw new Error(Log_1.log.s1.format(`服务：${this.service.name}`, '在非运行状态下进行了健康检查。', `当前的状态为：${RunningStatus_1.RunningStatus[this._status]}`));
        }
        try {
            await this.service.onHealthChecking();
        }
        catch (err) {
            Log_1.log.s1.w(`服务：${this.service.name}`, '运行状况异常：', err);
            return err;
        }
    }
}
exports.RegisteredService = RegisteredService;

//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["RegisteredService/RegisteredService.ts"],"names":[],"mappings":"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","file":"RegisteredService/RegisteredService.js","sourcesContent":["import { ServiceModule } from \"../ServiceModule/ServiceModule\";\nimport { ServicesManager } from \"../ServicesManager/ServicesManager\";\nimport { RunningStatus } from \"../RunningStatus\";\nimport { log } from \"../Log\";\n\n/**\n * 对注册了的服务进行一层封装，便于ServicesManager使用。\n * 对于注册服务的生命周期进行管理。\n * \n * @class RegisteredService\n */\nexport class RegisteredService {\n\n    /**\n     * 保存对服务管理器的引用\n     */\n    private readonly _manager: ServicesManager;\n\n    /**\n     * 绑定在服务上的错误监听器。\n     * \n     * @type {Function}\n     */\n    private readonly _errorListener = async (err: Error) => {\n        const value = await this.service.onError(err);\n\n        switch (value) {\n            case false:\n                this._manager.onError(err, this.service);\n                break;\n            case true:\n                break;\n            default:\n                if (value instanceof Error)\n                    this._manager.onError(value, this.service);\n                break;\n        }\n    };\n\n    /**\n     * 服务实例\n     * \n     * @type {ServiceModule}\n     */\n    readonly service: ServiceModule;\n\n    /**\n     * 服务的运行状态\n     */\n    public get status() {\n        return this._status;\n    }\n    private _status: RunningStatus = RunningStatus.stopped;\n\n    constructor(service: ServiceModule, manager: ServicesManager) {\n        this.service = service;\n        this._manager = manager;\n\n        // 给服务绑定管理器\n        this.service.servicesManager = manager;\n    }\n\n    /**\n     * 启动服务。成功返回void，失败返回Error。    \n     * 如果抛出异常则一定是该程序内部逻辑错误      \n     * 这个方法仅供内部使用。\n     * \n     * @returns {Promise<Error | void>} \n     */\n    async _start(): Promise<Error | void> {\n        //确保只有在stopped的情况下才能执行_start\n        if (this._status !== RunningStatus.stopped) {\n            throw new Error(\n                log.s1.format(\n                    `服务：${this.service.name}`,\n                    '在还未完全关闭的情况下又再次被启动。',\n                    `当前的状态为：${RunningStatus[this._status]}`\n                )\n            );\n        }\n\n        try {\n            log.s1.l(log.chalk.blue('服务：开始启动'), this.service.name);\n            this._status = RunningStatus.starting;\n\n            await this.service.onStart();\n            this.service.on('error', this._errorListener);\n\n            log.s1.l(log.chalk.green('服务：成功启动'), this.service.name);\n            this._status = RunningStatus.running;\n        } catch (err) {\n            log.s1.e(log.chalk.red('服务：启动失败'), this.service.name, err);\n            await this._stop();\n\n            return err;\n        }\n    }\n\n    /**\n     * 停止服务。    \n     * 如果抛出异常则一定是该程序内部逻辑错误      \n     * 这个方法仅供内部使用。\n     */\n    async _stop() {\n        //确保不会重复停止\n        if (this._status === RunningStatus.stopping || this._status === RunningStatus.stopped) {\n            throw new Error(\n                log.s1.format(\n                    `服务：${this.service.name}`,\n                    '在处于正在停止或已停止的状态下又再次被停止。',\n                    `当前的状态为：${RunningStatus[this._status]}`\n                )\n            );\n        }\n\n        try {\n            log.s1.l(log.chalk.blue('服务：开始停止'), this.service.name);\n            this._status = RunningStatus.stopping;\n\n            await this.service.onStop();\n\n            log.s1.l(log.chalk.green('服务：成功停止'), this.service.name);\n        } catch (err) {\n            log.s1.e(log.chalk.red('服务：停止失败'), this.service.name, err);\n        } finally {\n            this._status = RunningStatus.stopped;\n            this.service.removeListener('error', this._errorListener);\n        }\n    }\n\n    /**\n     * 健康检查。\n     * 如果抛出异常则一定是该程序内部逻辑错误      \n     * 这个方法仅供内部使用。\n     * \n     * @returns {(Promise<Error | void>)} 健康检查出现的错误\n     */\n    async _healthCheck(): Promise<Error | void> {\n        // 确保只检查运行状况下的健康状态\n        if (this._status !== RunningStatus.running) {\n            throw new Error(\n                log.s1.format(\n                    `服务：${this.service.name}`,\n                    '在非运行状态下进行了健康检查。',\n                    `当前的状态为：${RunningStatus[this._status]}`\n                )\n            );\n        }\n\n        try {\n            await this.service.onHealthChecking();\n        } catch (err) {\n            log.s1.w(`服务：${this.service.name}`, '运行状况异常：', err);\n            return err;\n        }\n    }\n}"]}