oak-backend-base 4.1.2 → 4.1.4

package/lib/AppLoader.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { EntityDict as BaseEntityDict } from 'oak-domain/lib/base-app-domain';
-import { AppLoader as GeneralAppLoader, Trigger, EntityDict, Watcher, OpRecord, OperationResult } from "oak-domain/lib/types";
+import { AppLoader as GeneralAppLoader, Trigger, EntityDict, Watcher, OpRecord, FreeTimer, OperationResult } from "oak-domain/lib/types";
 import { DbStore } from "./DbStore";
 import { BackendRuntimeContext } from 'oak-frontend-base/lib/context/BackendRuntimeContext';
 import { IncomingHttpHeaders, IncomingMessage } from 'http';
@@ -34,10 +34,13 @@ export declare class AppLoader<ED extends EntityDict & BaseEntityDict, Cxt exten
     initialize(): Promise<void>;
     getStore(): DbStore<ED, Cxt>;
     getEndpoints(prefix: string): [string, "post" | "get" | "put" | "delete", string, (params: Record<string, string>, headers: IncomingHttpHeaders, req: IncomingMessage, body?: any) => Promise<any>][];
-    protected operateInWatcher<T extends keyof ED>(entity: T, operation: ED[T]['Update'], context: Cxt): Promise<OperationResult<ED>>;
-    protected selectInWatcher<T extends keyof ED>(entity: T, selection: ED[T]['Selection'], context: Cxt): Promise<Partial<ED[T]["Schema"]>[]>;
+    protected operateInWatcher<T extends keyof ED>(entity: T, operation: ED[T]['Update'], context: Cxt, singleton?: true): Promise<OperationResult<ED>>;
+    protected selectInWatcher<T extends keyof ED>(entity: T, selection: ED[T]['Selection'], context: Cxt, singleton?: true): Promise<Partial<ED[T]["Schema"]>[]>;
     protected execWatcher(watcher: Watcher<ED, keyof ED, Cxt>): Promise<OperationResult<ED> | undefined>;
+    protected getCheckpointTs(): number;
+    protected checkpoint(): Promise<number>;
     startWatchers(): void;
+    protected execFreeTimer(timer: FreeTimer<ED, Cxt>, context: Cxt): Promise<OperationResult<ED>> | undefined;
     startTimers(): void;
     execStartRoutines(): Promise<void>;
     execRoutine(routine: <Cxt extends AsyncContext<ED>>(context: Cxt) => Promise<void>): Promise<void>;

package/lib/AppLoader.js

@@ -270,10 +270,10 @@ class AppLoader extends types_1.AppLoader {
         }
         return endPointRouters;
     }
-    operateInWatcher(entity, operation, context) {
+    operateInWatcher(entity, operation, context, singleton) {
         return this.dbStore.operate(entity, operation, context, {});
     }
-    selectInWatcher(entity, selection, context) {
+    selectInWatcher(entity, selection, context, singleton) {
         return this.dbStore.select(entity, selection, context, {
             blockTrigger: true,
             forUpdate: true,
@@ -284,24 +284,24 @@ class AppLoader extends types_1.AppLoader {
         let result;
         try {
             if (watcher.hasOwnProperty('actionData')) {
-                const { entity, action, filter, actionData } = watcher;
+                const { entity, action, filter, actionData, singleton } = watcher;
                 const filter2 = typeof filter === 'function' ? await filter() : (0, lodash_1.cloneDeep)(filter);
                 const data = typeof actionData === 'function' ? await (actionData)() : (0, lodash_1.cloneDeep)(actionData);
                 result = await this.operateInWatcher(entity, {
                     id: await (0, uuid_1.generateNewIdAsync)(),
                     action: action,
                     data,
-                    filter: filter2
-                }, context);
+                    filter: filter2,
+                }, context, singleton);
             }
             else {
-                const { entity, projection, fn, filter } = watcher;
+                const { entity, projection, fn, filter, singleton } = watcher;
                 const filter2 = typeof filter === 'function' ? await filter() : (0, lodash_1.cloneDeep)(filter);
                 const projection2 = typeof projection === 'function' ? await projection() : (0, lodash_1.cloneDeep)(projection);
                 const rows = await this.selectInWatcher(entity, {
                     data: projection2,
                     filter: filter2,
-                }, context);
+                }, context, singleton);
                 if (rows.length > 0) {
                     result = await fn(context, rows);
                 }
@@ -310,10 +310,22 @@ class AppLoader extends types_1.AppLoader {
             return result;
         }
         catch (err) {
-            await context.rollback();
+            if (err instanceof types_1.OakPartialSuccess) {
+                await context.commit();
+            }
+            else {
+                await context.rollback();
+            }
             throw err;
         }
     }
+    getCheckpointTs() {
+        const now = Date.now();
+        return process.env.NODE_ENV === 'development' ? now - 30 * 1000 : now - 120 * 1000;
+    }
+    checkpoint() {
+        return this.dbStore.checkpoint(this.getCheckpointTs());
+    }
     startWatchers() {
         const watchers = this.requireSth('lib/watchers/index');
         const { ActionDefDict } = require(`${this.path}/lib/oak-app-domain/ActionDefDict`);
@@ -323,7 +335,9 @@ class AppLoader extends types_1.AppLoader {
         const execOne = async (watcher, start) => {
             try {
                 const result = await this.execWatcher(watcher);
-                console.log(`执行watcher【${watcher.name}】成功，耗时【${Date.now() - start}】，结果是：`, result);
+                if (result) {
+                    console.log(`执行watcher【${watcher.name}】成功，耗时【${Date.now() - start}】，结果是：`, result);
+                }
             }
             catch (err) {
                 console.error(`执行watcher【${watcher.name}】失败，耗时【${Date.now() - start}】，结果是：`, err);
@@ -337,9 +351,8 @@ class AppLoader extends types_1.AppLoader {
             }
             const duration = Date.now() - start;
             console.log(`第${count}次执行watchers，共执行${watchers.length}个，耗时${duration}毫秒`);
-            const now = Date.now();
             try {
-                await this.dbStore.checkpoint(process.env.NODE_ENV === 'development' ? now - 30 * 1000 : now - 120 * 1000);
+                await this.checkpoint();
             }
             catch (err) {
                 console.error(`执行了checkpoint，发生错误：`, err);
@@ -348,6 +361,10 @@ class AppLoader extends types_1.AppLoader {
         };
         doWatchers();
     }
+    execFreeTimer(timer, context) {
+        const { timer: timerFn } = timer;
+        return timerFn(context);
+    }
     startTimers() {
         const timers = this.requireSth('lib/timers/index');
         if (timers) {
@@ -368,14 +385,20 @@ class AppLoader extends types_1.AppLoader {
                     else {
                         const context = await this.makeContext();
                         try {
-                            const { timer: timerFn } = timer;
-                            const result = await timerFn(context);
-                            console.log(`定时器【${name}】执行成功，耗时${Date.now() - start}毫秒，结果是【${result}】`);
+                            const result = await this.execFreeTimer(timer, context);
+                            if (result) {
+                                console.log(`定时器【${name}】执行成功，耗时${Date.now() - start}毫秒，结果是【${result}】`);
+                            }
                             await context.commit();
                         }
                         catch (err) {
                             console.warn(`定时器【${name}】执行失败，耗时${Date.now() - start}毫秒，错误是`, err);
-                            await context.rollback();
+                            if (err instanceof types_1.OakPartialSuccess) {
+                                await context.commit();
+                            }
+                            else {
+                                await context.rollback();
+                            }
                         }
                     }
                 });
@@ -384,10 +407,6 @@ class AppLoader extends types_1.AppLoader {
     }
     async execStartRoutines() {
         const routines = this.requireSth('lib/routines/start') || [];
-        if (this.synchronizer) {
-            const routine = this.synchronizer.getSyncRoutine();
-            routines.push(routine);
-        }
         for (const routine of routines) {
             if (routine.hasOwnProperty('entity')) {
                 const start = Date.now();

package/lib/ClusterAppLoader.d.ts

@@ -1,16 +1,20 @@
 import { EntityDict as BaseEntityDict } from 'oak-domain/lib/base-app-domain';
-import { EntityDict, OperationResult, Trigger } from 'oak-domain/lib/types';
+import { EntityDict, OperationResult, Trigger, Watcher, FreeTimer } from 'oak-domain/lib/types';
 import { BackendRuntimeContext } from 'oak-frontend-base/lib/context/BackendRuntimeContext';
 import { AppLoader } from './AppLoader';
 import { Namespace } from 'socket.io';
 import { Socket } from 'socket.io-client';
 export declare class ClusterAppLoader<ED extends EntityDict & BaseEntityDict, Cxt extends BackendRuntimeContext<ED>> extends AppLoader<ED, Cxt> {
-    protected socket: Socket;
     private csTriggers;
-    private connect;
+    static VolatileTriggerEvent: string;
+    protected socket: Socket;
+    private connectServerSocket;
     private sub;
     constructor(path: string, nsDs: Namespace, nsServer: Namespace, socketPath: string);
     protected registerTrigger(trigger: Trigger<ED, keyof ED, Cxt>): void;
-    protected operateInWatcher<T extends keyof ED>(entity: T, operation: ED[T]['Update'], context: Cxt): Promise<OperationResult<ED>>;
-    protected selectInWatcher<T extends keyof ED>(entity: T, selection: ED[T]['Selection'], context: Cxt): Promise<Partial<ED[T]['Schema']>[]>;
+    protected operateInWatcher<T extends keyof ED>(entity: T, operation: ED[T]['Update'], context: Cxt, singleton?: true): Promise<OperationResult<ED>>;
+    protected selectInWatcher<T extends keyof ED>(entity: T, selection: ED[T]['Selection'], context: Cxt, singleton?: true): Promise<Partial<ED[T]['Schema']>[]>;
+    protected execWatcher(watcher: Watcher<ED, keyof ED, Cxt>): Promise<OperationResult<ED> | undefined>;
+    protected execFreeTimer(timer: FreeTimer<ED, Cxt>, context: Cxt): Promise<OperationResult<ED>> | undefined;
+    protected checkpoint(): Promise<number>;
 }

package/lib/ClusterAppLoader.js

@@ -10,9 +10,10 @@ const AppLoader_1 = require("./AppLoader");
 const assert_1 = tslib_1.__importDefault(require("assert"));
 const socket_io_client_1 = require("socket.io-client");
 class ClusterAppLoader extends AppLoader_1.AppLoader {
-    socket;
     csTriggers;
-    connect() {
+    static VolatileTriggerEvent = 'vtEvent';
+    socket;
+    connectServerSocket() {
         const { instanceId } = (0, env_1.getClusterInfo)();
         this.socket.on('connect', () => {
             const csTriggerNames = Object.keys(this.csTriggers).map(ele => `${ele}-${instanceId}`);
@@ -20,14 +21,11 @@ class ClusterAppLoader extends AppLoader_1.AppLoader {
                 this.socket.emit('sub', csTriggerNames);
             }
         });
-        this.socket.on('disconnect', () => {
-            const csTriggerNames = Object.keys(this.csTriggers).map(ele => `${ele}-${instanceId}`);
-            if (csTriggerNames.length > 0) {
-                this.socket.connect();
-            }
-        });
-        this.socket.on('data', async (entity, name, ids, cxtStr, option) => {
+        this.socket.on(ClusterAppLoader.VolatileTriggerEvent, async (entity, name, ids, cxtStr, option) => {
             const context = await this.makeContext(cxtStr);
+            if (process.env.NODE_ENV === 'development') {
+                console.log(`「${(0, env_1.getClusterInfo)().instanceId}」号实例接收到来自其它进程的volatileTrigger请求， name是「${name}」， ids是「${ids.join(',')}」`);
+            }
             // await context.begin();
             try {
                 await this.dbStore.execVolatileTrigger(entity, name, ids, context, option);
@@ -38,12 +36,11 @@ class ClusterAppLoader extends AppLoader_1.AppLoader {
                 console.error('在集群环境下，处理来自其它实例的trigger数据，execVolatileTrigger异常', entity, name, ids, option, err);
             }
         });
-        this.socket.connect();
     }
-    sub(name) {
+    sub(name, clusterSensative) {
         const { instanceId } = (0, env_1.getClusterInfo)();
         (0, assert_1.default)(!this.csTriggers[name], `命名为${name}的trigger出现了多次，请检查`);
-        this.csTriggers[name] = 1;
+        this.csTriggers[name] = !!clusterSensative;
         if (this.socket.connected) {
             this.socket.emit('sub', [`${name}-${instanceId}`]);
         }
@@ -62,8 +59,12 @@ class ClusterAppLoader extends AppLoader_1.AppLoader {
                     await context.commit();
                 }
                 catch (err) {
-                    await context.rollback();
-                    if (!(err instanceof types_1.OakMakeSureByMySelfException)) {
+                    if (err instanceof types_1.OakPartialSuccess) {
+                        await context.commit();
+                        console.error('execVolatileTrigger异常', entity, trigger.name, ids2, option, err);
+                    }
+                    else {
+                        await context.rollback();
                         console.error('execVolatileTrigger异常', entity, trigger.name, ids2, option, err);
                     }
                 }
@@ -89,35 +90,52 @@ class ClusterAppLoader extends AppLoader_1.AppLoader {
                         await execLocal(ids2);
                     }
                     else {
-                        this.dataSubscriber.publishVolatileTrigger(entity, trigger.name, seqMod, ids2, cxtStr, option);
+                        if (process.env.NODE_ENV === 'development') {
+                            console.log(`在trigger「${trigger.name}」上，因为cs原因，数据「${ids2.join(',')}」将被推送到「${seqMod}」号进程操作（当前进程号是「${instanceId}」）。`);
+                        }
+                        this.dataSubscriber.publishServerEvent(`${trigger.name}-${seqMod}`, ClusterAppLoader.VolatileTriggerEvent, entity, trigger.name, ids2, cxtStr, option);
+                    }
+                }
+            }
+            else if (trigger.singleton) {
+                if ((0, env_1.getClusterInfo)().instanceId === 0) {
+                    await execLocal(ids);
+                }
+                else {
+                    if (process.env.NODE_ENV === 'development') {
+                        console.log(`在trigger「${trigger.name}」上，因为singleton原因，数据「${ids.join(',')}」将被推送到「0」号进程操作（当前进程号是「${(0, env_1.getClusterInfo)().instanceId}」）`);
                     }
+                    this.dataSubscriber.publishServerEvent(`${trigger.name}-0`, ClusterAppLoader.VolatileTriggerEvent, entity, trigger.name, ids, cxtStr, option);
                 }
             }
             else {
                 await execLocal(ids);
             }
         });
+        this.csTriggers = {};
         const { name } = nsServer;
         const socketUrl = `http://localhost:${process.env.PM2_PORT || 8080}${name}`;
         this.socket = (0, socket_io_client_1.io)(socketUrl, {
             path: socketPath,
         });
-        this.connect();
-        this.csTriggers = {};
+        this.connectServerSocket();
     }
     registerTrigger(trigger) {
         // 如果是cluster sensative的trigger，注册到socket事件上
-        if (trigger.when === 'commit' && trigger.cs) {
+        // 如果是singletone的trigger，只有0号实例注册
+        const { when, cs, singleton } = trigger;
+        (0, assert_1.default)(!(cs && singleton));
+        if (when === 'commit' && (cs || singleton && (0, env_1.getClusterInfo)().instanceId === 0)) {
             const { name } = trigger;
-            this.sub(name);
+            this.sub(name, cs);
         }
         this.dbStore.registerTrigger(trigger);
     }
-    operateInWatcher(entity, operation, context) {
+    operateInWatcher(entity, operation, context, singleton) {
         const { instanceCount, instanceId } = (0, env_1.getClusterInfo)();
         (0, assert_1.default)(instanceCount && typeof instanceId === 'number');
         const { filter } = operation;
-        const filter2 = (0, filter_1.combineFilters)(entity, this.dbStore.getSchema(), [filter, {
+        const filter2 = singleton ? filter : (0, filter_1.combineFilters)(entity, this.dbStore.getSchema(), [filter, {
                 $$seq$$: {
                     $mod: [instanceCount, instanceId]
                 }
@@ -127,11 +145,11 @@ class ClusterAppLoader extends AppLoader_1.AppLoader {
             filter: filter2,
         }, context);
     }
-    selectInWatcher(entity, selection, context) {
+    selectInWatcher(entity, selection, context, singleton) {
         const { instanceCount, instanceId } = (0, env_1.getClusterInfo)();
         (0, assert_1.default)(instanceCount && typeof instanceId === 'number');
         const { filter } = selection;
-        const filter2 = (0, filter_1.combineFilters)(entity, this.dbStore.getSchema(), [filter, {
+        const filter2 = singleton ? filter : (0, filter_1.combineFilters)(entity, this.dbStore.getSchema(), [filter, {
                 $$seq$$: {
                     $mod: [instanceCount, instanceId]
                 }
@@ -141,5 +159,30 @@ class ClusterAppLoader extends AppLoader_1.AppLoader {
             filter: filter2,
         }, context);
     }
+    async execWatcher(watcher) {
+        if (watcher.singleton && (0, env_1.getClusterInfo)().instanceId !== 0) {
+            return;
+        }
+        return super.execWatcher(watcher);
+    }
+    execFreeTimer(timer, context) {
+        if (timer.singleton && (0, env_1.getClusterInfo)().instanceId !== 0) {
+            return;
+        }
+        return super.execFreeTimer(timer, context);
+    }
+    async checkpoint() {
+        const { instanceCount, instanceId } = (0, env_1.getClusterInfo)();
+        let count = 0;
+        for (const name in this.csTriggers) {
+            if (this.csTriggers[name]) {
+                count += await this.dbStore.independentCheckPoint(name, this.getCheckpointTs(), instanceCount, instanceId);
+            }
+            else {
+                count += await this.dbStore.independentCheckPoint(name, this.getCheckpointTs());
+            }
+        }
+        return count;
+    }
 }
 exports.ClusterAppLoader = ClusterAppLoader;

package/lib/DbStore.d.ts

@@ -17,4 +17,5 @@ export declare class DbStore<ED extends EntityDict & BaseEntityDict, Cxt extends
     setOnVolatileTrigger(onVolatileTrigger: <T extends keyof ED>(entity: T, trigger: VolatileTrigger<ED, T, Cxt>, ids: string[], cxtStr: string, option: OperateOption) => Promise<void>): void;
     execVolatileTrigger<T extends keyof ED>(entity: T, name: string, ids: string[], context: Cxt, option: OperateOption): Promise<void>;
     checkpoint(ts: number): Promise<number>;
+    independentCheckPoint(name: string, ts: number, instanceCount?: number, instanceId?: number): Promise<number>;
 }

package/lib/DbStore.js

@@ -118,5 +118,8 @@ class DbStore extends oak_db_1.MysqlStore {
     checkpoint(ts) {
         return this.executor.checkpoint(ts);
     }
+    independentCheckPoint(name, ts, instanceCount, instanceId) {
+        return this.executor.independentCheckPoint(name, ts, instanceCount, instanceId);
+    }
 }
 exports.DbStore = DbStore;

package/lib/Synchronizer.d.ts

@@ -1,4 +1,4 @@
-import { EntityDict, StorageSchema, EndpointItem, SyncConfig, FreeRoutine } from 'oak-domain/lib/types';
+import { EntityDict, StorageSchema, EndpointItem, SyncConfig } from 'oak-domain/lib/types';
 import { VolatileTrigger } from 'oak-domain/lib/types/Trigger';
 import { EntityDict as BaseEntityDict } from 'oak-domain/lib/base-app-domain';
 import { BackendRuntimeContext } from 'oak-frontend-base/lib/context/BackendRuntimeContext';
@@ -9,12 +9,8 @@ export default class Synchronizer<ED extends EntityDict & BaseEntityDict, Cxt ex
     private channelDict;
     private contextBuilder;
     private pushAccessMap;
-    /**
-     * 向某一个远端对象push opers。根据幂等性，这里如果失败了必须反复推送
-     * @param channel
-     * @param retry
-     */
-    private startChannel;
+    private startChannel2;
+    /**开始同步这些channel上的oper。注意，这时候即使某个channel上失败了，也不应影响本事务提交（其它的channel成功了） */
     private startAllChannel;
     private pushOperToChannel;
     private refineOperData;
@@ -32,6 +28,6 @@ export default class Synchronizer<ED extends EntityDict & BaseEntityDict, Cxt ex
      * @returns
      */
     getSyncTriggers(): VolatileTrigger<ED, keyof ED, Cxt>[];
-    getSyncRoutine(): FreeRoutine<ED, Cxt>;
     getSelfEndpoint(): EndpointItem<ED, Cxt>;
+    tryCreateSyncProcess(): void;
 }

package/lib/Synchronizer.js

@@ -18,135 +18,85 @@ class Synchronizer {
     channelDict = {};
     contextBuilder;
     pushAccessMap = {};
-    /**
-     * 向某一个远端对象push opers。根据幂等性，这里如果失败了必须反复推送
-     * @param channel
-     * @param retry
-     */
-    async startChannel(context, channel, retry) {
+    async startChannel2(context, channel) {
         const { queue, api, selfEncryptInfo, entity, entityId } = channel;
-        let json;
-        try {
-            // todo 加密
-            const queue = channel.queue;
-            const opers = queue.map(ele => ele.oper);
-            if (process.env.NODE_ENV === 'development') {
-                console.log('向远端结点sync oper', JSON.stringify(opers.map(ele => ({
-                    id: ele.id,
-                    seq: ele.$$seq$$,
-                }))), 'txnId:', context.getCurrentTxnId());
-            }
-            const finalApi = (0, path_1.join)(api, selfEncryptInfo.id);
-            const res = await fetch(finalApi, {
-                method: 'post',
-                headers: {
-                    'Content-Type': 'application/json',
-                    [OAK_SYNC_HEADER_ENTITY]: entity,
-                    [OAK_SYNC_HEADER_ENTITYID]: entityId,
-                },
-                body: JSON.stringify(opers),
-            });
-            if (res.status !== 200) {
-                throw new Error(`sync数据时，访问api「${finalApi}」的结果不是200。「${res.status}」`);
-            }
-            json = await res.json();
-        }
-        catch (err) {
-            // 最大延迟redo时间512秒
-            const retryDelay = Math.pow(2, Math.min(9, retry)) * 1000;
-            console.error('sync push时出现error', err);
-            console.error(`将于${retryDelay}毫秒后重试`);
-            return new Promise((resolve) => {
-                setTimeout(async () => {
-                    await this.startChannel(context, channel, retry + 1);
-                    resolve(undefined);
-                }, retryDelay);
-            });
-        }
-        /**
-         * 返回结构见this.getSelfEndpoint
-         */
+        // todo 加密
+        const opers = queue.map(ele => ele.oper);
         if (process.env.NODE_ENV === 'development') {
-            console.log('同步oper返回结果', JSON.stringify(json), 'txnId:', context.getCurrentTxnId());
+            console.log('向远端结点sync oper', JSON.stringify(opers.map(ele => ({
+                id: ele.id,
+                seq: ele.$$seq$$,
+            }))), 'txnId:', context.getCurrentTxnId());
         }
-        const { successIds, failed, redundantIds } = json;
-        if (failed) {
-            const { id, error } = failed;
-            console.error('同步过程中发生异常', id, error, retry);
+        const finalApi = (0, path_1.join)(api, selfEncryptInfo.id);
+        channel.queue = [];
+        const res = await fetch(finalApi, {
+            method: 'post',
+            headers: {
+                'Content-Type': 'application/json',
+                [OAK_SYNC_HEADER_ENTITY]: entity,
+                [OAK_SYNC_HEADER_ENTITYID]: entityId,
+            },
+            body: JSON.stringify(opers),
+        });
+        if (res.status !== 200) {
+            throw new Error(`sync数据时，访问api「${finalApi}」的结果不是200。「${res.status}」`);
         }
-        const unsuccessfulOpers = queue.filter(ele => !successIds.includes(ele.oper.id) && !redundantIds.includes(ele.oper.id));
-        // 重新开始前，可以将已经完成的oper的triggerData位清零。要注意，在多个remote配置下，有可能一个oper要推给多个channel
-        // 这里可能设计过度了，代码也没经过测试
-        channel.queue = unsuccessfulOpers;
-        const aliveOperIds = [];
-        for (const k in this.channelDict) {
-            if (this.channelDict[k].queue.length > 0) {
-                aliveOperIds.push(...this.channelDict[k].queue.map(ele => ele.oper.id));
+        // 如果是200，则已经成功
+        for (const ele of queue) {
+            const { oper, onSynchronized } = ele;
+            if (onSynchronized) {
+                const operEntityArr = await context.select('operEntity', {
+                    data: {
+                        id: 1,
+                        entity: 1,
+                        entityId: 1
+                    },
+                    filter: {
+                        operId: oper.id,
+                    }
+                }, {});
+                const entityIds = operEntityArr.map(ele => ele.entityId);
+                return onSynchronized && onSynchronized({
+                    action: oper.action,
+                    data: oper.data,
+                    // rowIds: getRelevantIds(oper.filter!),
+                    rowIds: entityIds
+                }, context);
             }
         }
-        const overIds = (0, lodash_1.difference)(successIds.concat(redundantIds), aliveOperIds);
-        if (overIds.length > 0) {
-            await context.operate('oper', {
-                id: await (0, uuid_1.generateNewIdAsync)(),
-                action: 'update',
-                data: {
-                    [types_1.TriggerDataAttribute]: null,
-                    [types_1.TriggerUuidAttribute]: null,
-                },
-                filter: {
-                    id: {
-                        $in: overIds,
-                    }
+        /**
+         * 自主将triggerData属性清零
+         */
+        const operIds = queue.map(ele => ele.oper.id);
+        await context.operate('oper', {
+            id: await (0, uuid_1.generateNewIdAsync)(),
+            action: 'update',
+            data: {
+                [types_1.TriggerDataAttribute]: null,
+                [types_1.TriggerUuidAttribute]: null,
+            },
+            filter: {
+                id: {
+                    $in: operIds,
                 }
-            }, {});
-        }
-        if (successIds.length > 0) {
-            try {
-                await Promise.all(successIds.map(async (id) => {
-                    const { onSynchronized, oper } = queue.find(ele => ele.oper.id === id);
-                    const operEntityArr = await context.select('operEntity', {
-                        data: {
-                            id: 1,
-                            entity: 1,
-                            entityId: 1
-                        },
-                        filter: {
-                            operId: oper.id,
-                        }
-                    }, {});
-                    const entityIds = operEntityArr.map(ele => ele.entityId);
-                    return onSynchronized && onSynchronized({
-                        action: oper.action,
-                        data: oper.data,
-                        // rowIds: getRelevantIds(oper.filter!),
-                        rowIds: entityIds
-                    }, context);
-                }));
-            }
-            catch (err) {
-                // 这时候无法处理？
-                console.error('onSynchronzied时出错', err);
-                (0, assert_1.default)(false);
             }
-        }
-        if (channel.queue.length > 0) {
-            // 最大延迟redo时间512秒
-            const retryDelay = Math.pow(2, Math.min(9, retry)) * 1000;
-            console.error(`有${channel.queue.length}个oper同步失败，id是「${channel.queue.map(ele => ele.oper.id).join(',')}」，将于${retryDelay}毫秒后重试`);
-            return new Promise((resolve) => {
-                setTimeout(async () => {
-                    await this.startChannel(context, channel, retry + 1);
-                    resolve(undefined);
-                }, retryDelay);
-            });
-        }
+        }, {});
     }
+    /**开始同步这些channel上的oper。注意，这时候即使某个channel上失败了，也不应影响本事务提交（其它的channel成功了） */
     async startAllChannel(context) {
-        await Promise.all(Object.keys(this.channelDict).map(async (k) => {
+        return await Promise.all(Object.keys(this.channelDict).map(async (k) => {
             const channel = this.channelDict[k];
             if (channel.queue.length > 0) {
                 channel.queue.sort((o1, o2) => o1.oper.$$seq$$ - o2.oper.$$seq$$);
-                return this.startChannel(context, channel, 0);
+                try {
+                    return this.startChannel2(context, channel);
+                }
+                catch (err) {
+                    const msg = `startChannel推送数据出错，channel是「${k}」，异常是「${err.message}」`;
+                    console.error(err);
+                    return new types_1.OakPartialSuccess(msg);
+                }
             }
         }));
     }
@@ -258,94 +208,91 @@ class Synchronizer {
      * 每个进程都保证把当前所有的oper顺序处理掉，就不会有乱序的问题，大家通过database上的锁来完成同步
      * @param context
      */
-    async trySynchronizeOpers() {
-        const context = this.contextBuilder();
-        await context.begin();
+    async trySynchronizeOpers(context) {
+        let result = undefined;
         // 暂时全用root身份去执行（未来不一定对)
         await context.initialize();
         context.openRootMode();
-        try {
-            let dirtyOpers = await context.select('oper', {
+        let dirtyOpers = await context.select('oper', {
+            data: {
+                id: 1,
+            },
+            filter: {
+                [types_1.TriggerDataAttribute]: {
+                    $exists: true,
+                },
+            }
+        }, { dontCollect: true });
+        if (dirtyOpers.length > 0) {
+            // 这一步是加锁，保证只有一个进程完成推送，推送者提交前会将$$triggerData$$清零
+            const ids = dirtyOpers.map(ele => ele.id);
+            dirtyOpers = await context.select('oper', {
                 data: {
                     id: 1,
+                    action: 1,
+                    data: 1,
+                    targetEntity: 1,
+                    operatorId: 1,
+                    [types_1.TriggerDataAttribute]: 1,
+                    bornAt: 1,
+                    $$createAt$$: 1,
+                    $$seq$$: 1,
+                    filter: 1,
+                    operEntity$oper: {
+                        $entity: 'operEntity',
+                        data: {
+                            entityId: 1,
+                            operId: 1,
+                            entity: 1,
+                            id: 1,
+                        }
+                    }
                 },
                 filter: {
-                    [types_1.TriggerDataAttribute]: {
-                        $exists: true,
-                    },
-                }
-            }, { dontCollect: true });
+                    id: { $in: ids },
+                },
+            }, { dontCollect: true, forUpdate: true });
+            dirtyOpers = dirtyOpers.filter(ele => !!ele[types_1.TriggerDataAttribute]);
             if (dirtyOpers.length > 0) {
-                // 这一步是加锁，保证只有一个进程完成推送，推送者提交前会将$$triggerData$$清零
-                const ids = dirtyOpers.map(ele => ele.id);
-                dirtyOpers = await context.select('oper', {
-                    data: {
-                        id: 1,
-                        action: 1,
-                        data: 1,
-                        targetEntity: 1,
-                        operatorId: 1,
-                        [types_1.TriggerDataAttribute]: 1,
-                        bornAt: 1,
-                        $$createAt$$: 1,
-                        $$seq$$: 1,
-                        filter: 1,
-                        operEntity$oper: {
-                            $entity: 'operEntity',
-                            data: {
-                                entityId: 1,
-                                operId: 1,
-                                entity: 1,
-                                id: 1,
-                            }
-                        }
-                    },
-                    filter: {
-                        id: { $in: ids },
-                    },
-                }, { dontCollect: true, forUpdate: true });
-                dirtyOpers = dirtyOpers.filter(ele => !!ele[types_1.TriggerDataAttribute]);
-                if (dirtyOpers.length > 0) {
-                    for (const c in this.channelDict) {
-                        (0, assert_1.default)(this.channelDict[c].queue.length === 0);
-                    }
-                    const pushedIds = [];
-                    const unpushedIds = [];
-                    await Promise.all(dirtyOpers.map(async (oper) => {
-                        const result = await this.dispatchOperToChannels(oper, context);
-                        if (result) {
-                            pushedIds.push(oper.id);
-                        }
-                        else {
-                            unpushedIds.push(oper.id);
-                        }
-                    }));
-                    if (unpushedIds.length > 0) {
-                        await context.operate('oper', {
-                            id: await (0, uuid_1.generateNewIdAsync)(),
-                            action: 'update',
-                            data: {
-                                [types_1.TriggerDataAttribute]: null,
-                                [types_1.TriggerUuidAttribute]: null,
-                            },
-                            filter: {
-                                id: {
-                                    $in: unpushedIds,
-                                }
-                            }
-                        }, {});
+                for (const c in this.channelDict) {
+                    (0, assert_1.default)(this.channelDict[c].queue.length === 0);
+                }
+                const pushedIds = [];
+                const unpushedIds = [];
+                await Promise.all(dirtyOpers.map(async (oper) => {
+                    const result = await this.dispatchOperToChannels(oper, context);
+                    if (result) {
+                        pushedIds.push(oper.id);
                     }
-                    if (pushedIds.length > 0) {
-                        await this.startAllChannel(context);
+                    else {
+                        unpushedIds.push(oper.id);
                     }
+                }));
+                if (unpushedIds.length > 0) {
+                    await context.operate('oper', {
+                        id: await (0, uuid_1.generateNewIdAsync)(),
+                        action: 'update',
+                        data: {
+                            [types_1.TriggerDataAttribute]: null,
+                            [types_1.TriggerUuidAttribute]: null,
+                        },
+                        filter: {
+                            id: {
+                                $in: unpushedIds,
+                            }
+                        }
+                    }, {});
+                }
+                if (pushedIds.length > 0) {
+                    result = await this.startAllChannel(context);
                 }
             }
-            await context.commit();
         }
-        catch (err) {
-            await context.rollback();
-            console.error(err);
-            throw err;
+        if (result) {
+            const exception = result.find(ele => ele instanceof Error);
+            if (exception) {
+                throw exception;
+            }
         }
     }
     makeCreateOperTrigger() {
@@ -445,17 +392,16 @@ class Synchronizer {
             action: 'create',
             when: 'commit',
             strict: 'makeSure',
+            singleton: true,
+            grouped: true,
             check: (operation) => {
                 const { data } = operation;
                 const { targetEntity, action } = data;
                 return pushEntities.includes(data.targetEntity)
                     && !!this.pushAccessMap[targetEntity].find(({ actions }) => !actions || actions.includes(action));
             },
-            fn: async ({ ids }) => {
-                (0, assert_1.default)(ids.length === 1);
-                this.trySynchronizeOpers();
-                // 内部自主处理triggerData，因此不需要让triggerExecutor处理
-                throw new types_1.OakMakeSureByMySelfException();
+            fn: async ({ ids }, context) => {
+                return this.trySynchronizeOpers(context);
             }
         };
         return createOperTrigger;
@@ -472,15 +418,6 @@ class Synchronizer {
     getSyncTriggers() {
         return [this.makeCreateOperTrigger()];
     }
-    getSyncRoutine() {
-        return {
-            name: 'checkpoint routine for sync',
-            routine: async () => {
-                this.trySynchronizeOpers();
-                return {};
-            },
-        };
-    }
     getSelfEndpoint() {
         return {
             name: this.config.self.endpoint || 'sync',
@@ -493,9 +430,6 @@ class Synchronizer {
                 if (process.env.NODE_ENV === 'development') {
                     console.log('接收到来自远端的sync数据', entity, JSON.stringify(body));
                 }
-                const successIds = [];
-                const redundantIds = [];
-                let failed;
                 // todo 这里先缓存，不考虑本身同步相关信息的更新
                 if (!this.remotePullInfoMap[entity]) {
                     this.remotePullInfoMap[entity] = {};
@@ -544,75 +478,58 @@ class Synchronizer {
                         (0, assert_1.default)(oper.$$seq$$ > maxStaleSeq, '发现了seq没有按序进行同步');
                     }
                 }
-                await Promise.all([
-                    // 无法严格保证推送按bornAt，所以一旦还有outdatedOpers，检查其已经被apply
-                    (async () => {
-                        const ids = staleOpers.map(ele => ele.id);
-                        if (ids.length > 0) {
-                            const opersExisted = await context.select('oper', {
-                                data: {
-                                    id: 1,
-                                },
-                                filter: {
-                                    id: {
-                                        $in: ids,
-                                    }
-                                }
-                            }, { dontCollect: true });
-                            if (opersExisted.length < ids.length) {
-                                const missed = (0, lodash_1.difference)(ids, opersExisted.map(ele => ele.id));
-                                // todo 这里如果远端业务逻辑严格，发生乱序应是无关的oper，直接执行就好 by Xc
-                                throw new Error(`在sync过程中发现有丢失的oper数据「${missed}」`);
+                // 检查已经应用过的opers是否完整
+                const staleIds = staleOpers.map(ele => ele.id);
+                if (staleIds.length > 0) {
+                    const opersExisted = await context.select('oper', {
+                        data: {
+                            id: 1,
+                        },
+                        filter: {
+                            id: {
+                                $in: staleIds,
                             }
-                            redundantIds.push(...ids);
                         }
-                    })(),
-                    (async () => {
-                        for (const freshOper of freshOpers) {
-                            // freshOpers是按$$seq$$序产生的
-                            const { id, targetEntity, action, data, $$seq$$, filter } = freshOper;
-                            const ids = (0, filter_1.getRelevantIds)(filter);
-                            (0, assert_1.default)(ids.length > 0);
-                            try {
-                                if (pullEntityDict && pullEntityDict[targetEntity]) {
-                                    const { process } = pullEntityDict[targetEntity];
-                                    if (process) {
-                                        await process(action, data, context);
-                                    }
-                                }
-                                const operation = {
-                                    id,
-                                    data,
-                                    action,
-                                    filter: {
-                                        id: ids.length === 1 ? ids[0] : {
-                                            $in: ids,
-                                        },
-                                    },
-                                    bornAt: $$seq$$,
-                                };
-                                await context.operate(targetEntity, operation, {});
-                                successIds.push(id);
-                            }
-                            catch (err) {
-                                console.error(err);
-                                console.error('sync时出错', entity, JSON.stringify(freshOper));
-                                failed = {
-                                    id,
-                                    error: err.toString(),
-                                };
-                                break;
-                            }
+                    }, { dontCollect: true });
+                    if (opersExisted.length < staleIds.length) {
+                        const missed = (0, lodash_1.difference)(staleIds, opersExisted.map(ele => ele.id));
+                        // todo 这里如果远端业务逻辑严格，发生乱序应是无关的oper，直接执行就好 by Xc
+                        throw new Error(`在sync过程中发现有丢失的oper数据「${missed}」`);
+                    }
+                }
+                // 应用所有的freshOpers，失败则报错
+                for (const freshOper of freshOpers) {
+                    // freshOpers是按$$seq$$序产生的
+                    const { id, targetEntity, action, data, $$seq$$, filter } = freshOper;
+                    const ids = (0, filter_1.getRelevantIds)(filter);
+                    (0, assert_1.default)(ids.length > 0);
+                    if (pullEntityDict && pullEntityDict[targetEntity]) {
+                        const { process } = pullEntityDict[targetEntity];
+                        if (process) {
+                            await process(action, data, context);
                         }
-                    })()
-                ]);
-                return {
-                    successIds,
-                    failed,
-                    redundantIds,
-                };
+                    }
+                    const operation = {
+                        id,
+                        data,
+                        action,
+                        filter: {
+                            id: ids.length === 1 ? ids[0] : {
+                                $in: ids,
+                            },
+                        },
+                        bornAt: $$seq$$,
+                    };
+                    await context.operate(targetEntity, operation, {});
+                }
+                if (process.env.NODE_ENV === 'development') {
+                    console.log(`同步成功，其中重复的oper ${staleIds.length}个，新的oper ${freshOpers.length}个。`);
+                }
+                return {};
             }
         };
     }
+    tryCreateSyncProcess() {
+    }
 }
 exports.default = Synchronizer;

package/lib/cluster/DataSubscriber.d.ts

@@ -1,4 +1,4 @@
-import { EntityDict, OperateOption, OpRecord } from 'oak-domain/lib/types';
+import { EntityDict, OpRecord } from 'oak-domain/lib/types';
 import { EntityDict as BaseEntityDict } from 'oak-domain/lib/base-app-domain';
 import { BackendRuntimeContext } from 'oak-frontend-base/lib/context/BackendRuntimeContext';
 import { Namespace } from 'socket.io';
@@ -18,5 +18,5 @@ export default class DataSubscriber<ED extends EntityDict & BaseEntityDict, Cont
      */
     private startup;
     publishEvent(event: string, records: OpRecord<ED>[], sid?: string): void;
-    publishVolatileTrigger(entity: keyof ED, name: string, instanceNumber: string, ids: string[], cxtStr: string, option: OperateOption): void;
+    publishServerEvent(identifier: string, event: string, ...rest: any[]): void;
 }

package/lib/cluster/DataSubscriber.js

@@ -71,11 +71,9 @@ class DataSubscriber {
             this.ns.to(event).emit('data', records, event);
         }
     }
-    publishVolatileTrigger(entity, name, instanceNumber, ids, cxtStr, option) {
-        const { instanceId } = (0, env_1.getClusterInfo)();
-        // console.log('publishVolatileTrigger', instanceId, instanceNumber);
+    publishServerEvent(identifier, event, ...rest) {
         (0, console_1.assert)(this.nsServer);
-        this.nsServer.to(`${name}-${instanceNumber}`).emit('data', entity, name, ids, cxtStr, option);
+        this.nsServer.to(identifier).emit(event, ...rest);
     }
 }
 exports.default = DataSubscriber;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "oak-backend-base",
-    "version": "4.1.2",
+    "version": "4.1.4",
     "description": "oak-backend-base",
     "main": "lib/index",
     "author": {
@@ -20,10 +20,10 @@
         "mysql": "^2.18.1",
         "mysql2": "^2.3.3",
         "node-schedule": "^2.1.0",
-        "oak-common-aspect": "~3.0.0",
-        "oak-db": "~3.3.0",
-        "oak-domain": "~5.0.16",
-        "oak-frontend-base": "~5.3.0",
+        "oak-common-aspect": "^3.0.1",
+        "oak-db": "^3.3.0",
+        "oak-domain": "^5.1.0",
+        "oak-frontend-base": "^5.3.6",
         "socket.io": "^4.7.2",
         "socket.io-client": "^4.7.2",
         "uuid": "^8.3.2"