oak-backend-base 4.1.23 → 4.1.25

package/lib/AppLoader.d.ts

@@ -7,6 +7,7 @@ import { Namespace } from 'socket.io';
 import DataSubscriber from './cluster/DataSubscriber';
 import Synchronizer from './Synchronizer';
 import { AsyncContext } from 'oak-domain/lib/store/AsyncRowStore';
+import { InternalErrorHandler } from './types';
 export declare class AppLoader<ED extends EntityDict & BaseEntityDict, Cxt extends BackendRuntimeContext<ED>> extends GeneralAppLoader<ED, Cxt> {
     protected dbStore: DbStore<ED, Cxt>;
     private aspectDict;
@@ -17,6 +18,17 @@ export declare class AppLoader<ED extends EntityDict & BaseEntityDict, Cxt exten
     private nsSocket?;
     private watcherTimerId?;
     private scheduledJobs;
+    private internalErrorHandlers;
+    regAllExceptionHandler(): void;
+    /**
+     * 注册一个内部错误处理器
+     * @param handler 内部错误处理器
+     */
+    registerInternalErrorHandler(handler: InternalErrorHandler<ED, Cxt>): void;
+    /**
+     * 发布内部错误事件给注册的处理器
+     */
+    private publishInternalError;
     private requireSth;
     protected makeContext(cxtStr?: string, headers?: IncomingHttpHeaders): Promise<Cxt>;
     /**
@@ -50,5 +62,6 @@ export declare class AppLoader<ED extends EntityDict & BaseEntityDict, Cxt exten
     protected execFreeTimer(timer: FreeTimer<ED, Cxt>, context: Cxt): Promise<OperationResult<ED>> | undefined;
     startTimers(): void;
     execStartRoutines(): Promise<void>;
+    execStopRoutines(): Promise<void>;
     execRoutine(routine: <Cxt extends AsyncContext<ED>>(context: Cxt) => Promise<void>): Promise<void>;
 }

package/lib/AppLoader.js

@@ -28,6 +28,53 @@ class AppLoader extends types_1.AppLoader {
     nsSocket;
     watcherTimerId;
     scheduledJobs = {};
+    internalErrorHandlers = new Array();
+    regAllExceptionHandler() {
+        const handlers = this.requireSth('lib/configuration/exception');
+        if (Array.isArray(handlers)) {
+            handlers.forEach((handler) => {
+                console.log(`注册内部错误处理器: ${handler.name}`);
+                this.registerInternalErrorHandler(handler);
+            });
+        }
+        else {
+            console.warn('lib/configuration/exception必须默认导出一个处理器数组，当前导出类型不正确，将忽略此配置');
+        }
+    }
+    /**
+     * 注册一个内部错误处理器
+     * @param handler 内部错误处理器
+     */
+    registerInternalErrorHandler(handler) {
+        // 检查有没有名称重复
+        if (this.internalErrorHandlers.find(h => h.name === handler.name)) {
+            throw new Error(`内部错误处理器名称重复: ${handler.name}`);
+        }
+        this.internalErrorHandlers.push(handler);
+    }
+    /**
+     * 发布内部错误事件给注册的处理器
+     */
+    async publishInternalError(type, message, err) {
+        const errorToPublish = (0, lodash_1.cloneDeep)(err);
+        await Promise.all(this.internalErrorHandlers.map((handler) => {
+            return new Promise(async (resolve) => {
+                const ctx = await this.makeContext();
+                try {
+                    console.log(`调用internalErrorHandler【${handler.name}】处理内部错误事件`);
+                    await handler.handle(ctx, type, message, errorToPublish);
+                    await ctx.commit();
+                }
+                catch (e) {
+                    console.error('执行internalErrorHandler时出错', e);
+                    await ctx.rollback();
+                }
+                finally {
+                    resolve();
+                }
+            });
+        }));
+    }
     requireSth(filePath) {
         return (0, requirePrj_1.default)(this.path, filePath, this.externalDependencies);
     }
@@ -172,7 +219,9 @@ class AppLoader extends types_1.AppLoader {
             };
         }
         catch (err) {
+            console.error(`执行aspect「${name}」出错`, err);
             await context.rollback();
+            this.publishInternalError(`aspect`, `执行aspect「${name}」出错`, err);
             if (err instanceof types_1.OakException) {
                 throw err;
             }
@@ -357,6 +406,7 @@ class AppLoader extends types_1.AppLoader {
             else {
                 await context.rollback();
             }
+            // 不能在这里publish，因为这个方法可能是在timer中调用，也可能是在routine中调用
             throw err;
         }
     }
@@ -382,6 +432,7 @@ class AppLoader extends types_1.AppLoader {
             }
             catch (err) {
                 console.error(`执行watcher【${watcher.name}】失败，耗时【${Date.now() - start}】，结果是：`, err);
+                await this.publishInternalError(`watcher`, `执行watcher【${watcher.name}】失败`, err);
             }
         };
         const doWatchers = async () => {
@@ -400,6 +451,7 @@ class AppLoader extends types_1.AppLoader {
             }
             catch (err) {
                 console.error(`执行了checkpoint，发生错误：`, err);
+                await this.publishInternalError(`checkpoint`, `执行checkpoint发生错误`, err);
             }
             this.watcherTimerId = setTimeout(() => doWatchers(), 120000);
         };
@@ -424,6 +476,7 @@ class AppLoader extends types_1.AppLoader {
                         }
                         catch (err) {
                             console.error(`定时器【${name}】执行失败，耗时${Date.now() - start}毫秒】，错误是`, err);
+                            this.publishInternalError(`timer`, `定时器【${name}】执行失败`, err);
                         }
                     }
                     else {
@@ -443,6 +496,7 @@ class AppLoader extends types_1.AppLoader {
                             else {
                                 await context.rollback();
                             }
+                            this.publishInternalError(`timer`, `定时器【${name}】执行失败`, err);
                         }
                     }
                 });
@@ -461,6 +515,42 @@ class AppLoader extends types_1.AppLoader {
     async execStartRoutines() {
         const routines = this.requireSth('lib/routines/start') || [];
         for (const routine of routines) {
+            console.log(`执行启动例程【${routine.name}】...`);
+            if (routine.hasOwnProperty('entity')) {
+                const start = Date.now();
+                try {
+                    const result = await this.execWatcher(routine);
+                    console.log(`例程【${routine.name}】执行成功，耗时${Date.now() - start}毫秒，结果是`, result);
+                }
+                catch (err) {
+                    console.error(`例程【${routine.name}】执行失败，耗时${Date.now() - start}毫秒，错误是`, err);
+                    throw err;
+                }
+            }
+            else {
+                const { name, routine: routineFn } = routine;
+                const context = await this.makeContext();
+                const start = Date.now();
+                try {
+                    const result = await routineFn(context, {
+                        socket: this.nsSocket,
+                        contextBuilder: () => this.makeContext(),
+                    });
+                    console.log(`例程【${name}】执行成功，耗时${Date.now() - start}毫秒，结果是【${result}】`);
+                    await context.commit();
+                }
+                catch (err) {
+                    console.error(`例程【${name}】执行失败，耗时${Date.now() - start}毫秒，错误是`, err);
+                    await context.rollback();
+                    throw err;
+                }
+            }
+        }
+    }
+    async execStopRoutines() {
+        const routines = this.requireSth('lib/routines/stop') || [];
+        for (const routine of routines) {
+            console.log(`执行停止例程【${routine.name}】...`);
             if (routine.hasOwnProperty('entity')) {
                 const start = Date.now();
                 try {
@@ -479,6 +569,7 @@ class AppLoader extends types_1.AppLoader {
                 try {
                     const result = await routineFn(context, {
                         socket: this.nsSocket,
+                        contextBuilder: () => this.makeContext(),
                     });
                     console.log(`例程【${name}】执行成功，耗时${Date.now() - start}毫秒，结果是【${result}】`);
                     await context.commit();

package/lib/types/index.d.ts

@@ -0,0 +1,9 @@
+import { BaseEntityDict } from "oak-domain";
+import { AsyncContext } from "oak-domain/lib/store/AsyncRowStore";
+import { EntityDict } from "oak-domain/lib/types";
+export type InternalErrorType = 'aspect' | 'trigger' | 'watcher' | 'timer' | 'checkpoint';
+export type InternalErrorHandler<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>> = {
+    name: string;
+    handle: (ctx: Cxt, type: InternalErrorType, message: string, err: Error) => Promise<void>;
+};
+export type ExceptionPublisher = (type: string, message: string, err: any) => Promise<void>;

package/lib/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "oak-backend-base",
-    "version": "4.1.23",
+    "version": "4.1.25",
     "description": "oak-backend-base",
     "main": "lib/index",
     "author": {
@@ -23,8 +23,8 @@
         "node-schedule": "^2.1.0",
         "oak-common-aspect": "^3.0.5",
         "oak-db": "^3.3.11",
-        "oak-domain": "^5.1.28",
-        "oak-frontend-base": "^5.3.38",
+        "oak-domain": "^5.1.31",
+        "oak-frontend-base": "^5.3.43",
         "socket.io": "^4.8.1",
         "socket.io-client": "^4.7.2",
         "uuid": "^8.3.2"