midway-fatcms 0.0.1-beta.16 → 0.0.1-beta.18

package/dist/configuration.js

@@ -27,7 +27,6 @@ const global_middleware_1 = require("./middleware/global.middleware");
 const forbidden_middleware_1 = require("./middleware/forbidden.middleware");
 const schedule_1 = require("./schedule");
 const crypto_utils_1 = require("./libs/utils/crypto-utils");
-const scheduleNames_1 = require("./schedule/scheduleNames");
 let ContainerLifeCycle = class ContainerLifeCycle {
     async onConfigLoad() {
         const config = this.app.getConfig();
@@ -51,6 +50,10 @@ let ContainerLifeCycle = class ContainerLifeCycle {
         return newConfig;
     }
     async onReady() {
+        /**
+         * 让ANONYMOUS_CONTEXT获取app对象
+         */
+        schedule_1.ANONYMOUS_CONTEXT.setApp(this.app);
         /**
          * 启动定时任务
          */
@@ -69,13 +72,21 @@ let ContainerLifeCycle = class ContainerLifeCycle {
         if (fatcmsScheduleService === false || fatcmsScheduleService === null) {
             return;
         }
-        let scheduleServiceList = scheduleNames_1.ALL_SCHEDULE_NAMES;
-        // 启动部分定时任务
-        if (Array.isArray(fatcmsScheduleService)) {
-            scheduleServiceList = fatcmsScheduleService;
+        let scheduleIntervalCfg = schedule_1.INNER_SCHEDULE_INTERVAL;
+        if (typeof fatcmsScheduleService === "object") {
+            scheduleIntervalCfg = fatcmsScheduleService;
+        }
+        const keys = Object.keys(scheduleIntervalCfg);
+        for (let i = 0; i < keys.length; i++) {
+            const service = keys[i];
+            const interval = scheduleIntervalCfg[service];
+            if (typeof interval !== "number") {
+                throw new Error('Invalid scheduleIntervalCfg ' + service + ",  interval must be a number");
+            }
+            schedule_1.SCHEDULE_QUEUE.setScheduleTask(service, interval);
         }
-        await (0, schedule_1.startScheduleLoop)(scheduleServiceList);
-        logger.info('ContainerLifeCycle ==> onReady 启动定时任务 ： ' + JSON.stringify(scheduleServiceList));
+        await schedule_1.SCHEDULE_QUEUE.startScheduleLoop();
+        logger.info('ContainerLifeCycle ==> onReady 启动定时任务 ： ' + JSON.stringify(scheduleIntervalCfg));
     }
 };
 __decorate([

package/dist/schedule/index.d.ts

@@ -1,4 +1,4 @@
-import { startScheduleLoop, runScheduleTaskOnce } from './runSchedule';
+import { SCHEDULE_QUEUE, runScheduleTaskOnce } from './runSchedule';
 import { ANONYMOUS_CONTEXT } from './anonymousContext';
-import { ALL_SCHEDULE_NAMES, SCHEDULE_NAMES } from './scheduleNames';
-export { ALL_SCHEDULE_NAMES, SCHEDULE_NAMES, ANONYMOUS_CONTEXT, startScheduleLoop, runScheduleTaskOnce };
+import { INNER_SCHEDULE_INTERVAL } from './scheduleNames';
+export { INNER_SCHEDULE_INTERVAL, ANONYMOUS_CONTEXT, SCHEDULE_QUEUE, runScheduleTaskOnce };

package/dist/schedule/index.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runScheduleTaskOnce = exports.startScheduleLoop = exports.ANONYMOUS_CONTEXT = exports.SCHEDULE_NAMES = exports.ALL_SCHEDULE_NAMES = void 0;
+exports.runScheduleTaskOnce = exports.SCHEDULE_QUEUE = exports.ANONYMOUS_CONTEXT = exports.INNER_SCHEDULE_INTERVAL = void 0;
 const runSchedule_1 = require("./runSchedule");
-Object.defineProperty(exports, "startScheduleLoop", { enumerable: true, get: function () { return runSchedule_1.startScheduleLoop; } });
+Object.defineProperty(exports, "SCHEDULE_QUEUE", { enumerable: true, get: function () { return runSchedule_1.SCHEDULE_QUEUE; } });
 Object.defineProperty(exports, "runScheduleTaskOnce", { enumerable: true, get: function () { return runSchedule_1.runScheduleTaskOnce; } });
 const anonymousContext_1 = require("./anonymousContext");
 Object.defineProperty(exports, "ANONYMOUS_CONTEXT", { enumerable: true, get: function () { return anonymousContext_1.ANONYMOUS_CONTEXT; } });
 const scheduleNames_1 = require("./scheduleNames");
-Object.defineProperty(exports, "ALL_SCHEDULE_NAMES", { enumerable: true, get: function () { return scheduleNames_1.ALL_SCHEDULE_NAMES; } });
-Object.defineProperty(exports, "SCHEDULE_NAMES", { enumerable: true, get: function () { return scheduleNames_1.SCHEDULE_NAMES; } });
+Object.defineProperty(exports, "INNER_SCHEDULE_INTERVAL", { enumerable: true, get: function () { return scheduleNames_1.INNER_SCHEDULE_INTERVAL; } });

package/dist/schedule/runSchedule.d.ts

@@ -2,5 +2,13 @@ declare function runScheduleTaskOnce(serviceName: string): Promise<{
     result: any;
     error: any;
 }>;
-declare function startScheduleLoop(serviceList: string[]): Promise<void>;
-export { startScheduleLoop, runScheduleTaskOnce };
+declare class ScheduleQueue {
+    private scheduleIntervalMap;
+    setScheduleTask(serviceName: string, intervalTime: number): void;
+    removeScheduleTask(serviceName: string): void;
+    private isAlreadyTimeToExecute;
+    private runScheduleServiceList;
+    startScheduleLoop(): Promise<void>;
+}
+declare const SCHEDULE_QUEUE: ScheduleQueue;
+export { SCHEDULE_QUEUE, runScheduleTaskOnce };

package/dist/schedule/runSchedule.js

@@ -1,7 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runScheduleTaskOnce = exports.startScheduleLoop = void 0;
+exports.runScheduleTaskOnce = exports.SCHEDULE_QUEUE = void 0;
 const anonymousContext_1 = require("./anonymousContext");
+// 上次执行时间
+const lastExecuteTimeMap = {};
+const DEFAULT_SCHEDULE_INTERVAL = 2 * 60 * 1000;
 async function runScheduleTaskOnce(serviceName) {
     return await anonymousContext_1.ANONYMOUS_CONTEXT.runServiceAtAnonymousContext(async (ctx) => {
         const serviceObject = await ctx.requestContext.getAsync(serviceName);
@@ -14,21 +17,49 @@ async function runScheduleTaskOnce(serviceName) {
     });
 }
 exports.runScheduleTaskOnce = runScheduleTaskOnce;
-async function runScheduleServiceList(serviceList) {
-    for (let i = 0; i < serviceList.length; i++) {
-        const serviceName = serviceList[i];
-        try {
-            await runScheduleTaskOnce(serviceName);
+class ScheduleQueue {
+    constructor() {
+        this.scheduleIntervalMap = new Map();
+    }
+    setScheduleTask(serviceName, intervalTime) {
+        this.scheduleIntervalMap.set(serviceName, intervalTime);
+    }
+    removeScheduleTask(serviceName) {
+        this.scheduleIntervalMap.delete(serviceName);
+    }
+    isAlreadyTimeToExecute(serviceName) {
+        if (!lastExecuteTimeMap[serviceName]) {
+            return true; // 可以执行
         }
-        catch (e) {
-            anonymousContext_1.ANONYMOUS_CONTEXT.getApp().getCoreLogger().error(`runSchedule error , serviceName = ${serviceName}`, e);
+        const intervalTime1 = this.scheduleIntervalMap.get(serviceName);
+        const intervalTime = intervalTime1 || DEFAULT_SCHEDULE_INTERVAL; // 时间间隔
+        const lastExecuteTime = lastExecuteTimeMap[serviceName];
+        return (Date.now() - lastExecuteTime) >= intervalTime;
+    }
+    async runScheduleServiceList() {
+        const serviceListKeys = this.scheduleIntervalMap.keys();
+        const serviceList = [...serviceListKeys];
+        for (let i = 0; i < serviceList.length; i++) {
+            const serviceName = serviceList[i];
+            // 还没有到可以执行时间
+            if (!this.isAlreadyTimeToExecute(serviceName)) {
+                return;
+            }
+            lastExecuteTimeMap[serviceName] = Date.now();
+            try {
+                await runScheduleTaskOnce(serviceName);
+            }
+            catch (e) {
+                anonymousContext_1.ANONYMOUS_CONTEXT.getApp().getCoreLogger().error(`runSchedule error , serviceName = ${serviceName}`, e);
+            }
         }
     }
+    async startScheduleLoop() {
+        await this.runScheduleServiceList();
+        setInterval(() => {
+            this.runScheduleServiceList();
+        }, 1000); // 最少1秒执行一次
+    }
 }
-async function startScheduleLoop(serviceList) {
-    await runScheduleServiceList(serviceList);
-    setInterval(() => {
-        runScheduleServiceList(serviceList);
-    }, 2 * 60 * 1000);
-}
-exports.startScheduleLoop = startScheduleLoop;
+const SCHEDULE_QUEUE = new ScheduleQueue();
+exports.SCHEDULE_QUEUE = SCHEDULE_QUEUE;

package/dist/schedule/scheduleNames.d.ts

@@ -1,8 +1,13 @@
-declare const SCHEDULE_NAMES: {
+declare const INNER_SCHEDULE_INTERVAL: {
+    proxyApiLoadService: number;
+    workbenchService: number;
+    visitStatService: number;
+    asyncTaskRunnerService: number;
+};
+declare const INNER_SCHEDULE_NAMES: {
     proxyApiLoadService: string;
     workbenchService: string;
     visitStatService: string;
     asyncTaskRunnerService: string;
 };
-declare const ALL_SCHEDULE_NAMES: string[];
-export { ALL_SCHEDULE_NAMES, SCHEDULE_NAMES, };
+export { INNER_SCHEDULE_INTERVAL, INNER_SCHEDULE_NAMES };

package/dist/schedule/scheduleNames.js

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SCHEDULE_NAMES = exports.ALL_SCHEDULE_NAMES = void 0;
-const SCHEDULE_NAMES = {
+exports.INNER_SCHEDULE_NAMES = exports.INNER_SCHEDULE_INTERVAL = void 0;
+const INNER_SCHEDULE_INTERVAL = {
+    proxyApiLoadService: 2 * 60 * 1000,
+    workbenchService: 60 * 1000,
+    visitStatService: 10 * 60 * 1000,
+    asyncTaskRunnerService: 1000, // 1s可以执行
+};
+exports.INNER_SCHEDULE_INTERVAL = INNER_SCHEDULE_INTERVAL;
+const INNER_SCHEDULE_NAMES = {
     proxyApiLoadService: 'proxyApiLoadService',
     workbenchService: 'workbenchService',
-    visitStatService: 'visitStatService',
-    asyncTaskRunnerService: 'asyncTaskRunnerService',
+    visitStatService: "visitStatService",
+    asyncTaskRunnerService: "asyncTaskRunnerService",
 };
-exports.SCHEDULE_NAMES = SCHEDULE_NAMES;
-const ALL_SCHEDULE_NAMES = [
-    SCHEDULE_NAMES.proxyApiLoadService,
-    SCHEDULE_NAMES.workbenchService,
-    SCHEDULE_NAMES.visitStatService,
-    SCHEDULE_NAMES.asyncTaskRunnerService
-];
-exports.ALL_SCHEDULE_NAMES = ALL_SCHEDULE_NAMES;
+exports.INNER_SCHEDULE_NAMES = INNER_SCHEDULE_NAMES;

package/dist/service/asyncTask/AsyncTaskRunnerService.d.ts

@@ -7,7 +7,16 @@ declare class AsyncTaskRunner {
     taskHandlerMap: Map<string, ISysAsyncTaskHandler>;
     executeTaskList(taskList: SysAsyncTaskEntity[]): Promise<void>;
     private executeTask;
+    /**
+     * 更新任务状态或任务进度
+     * @param taskElement
+     * @private
+     */
     private updateTaskStatus;
+    /**
+     * 获取当前进程可以处理的任务类型。
+     */
+    getHandlerTaskTypeList(): string[];
 }
 /**
  * 业务可以扩展

package/dist/service/asyncTask/AsyncTaskRunnerService.js

@@ -59,6 +59,11 @@ class AsyncTaskRunner {
         };
         await taskHandler.execute({ task: taskElement, updateTaskStatus });
     }
+    /**
+     * 更新任务状态或任务进度
+     * @param taskElement
+     * @private
+     */
     async updateTaskStatus(taskElement) {
         return await schedule_1.ANONYMOUS_CONTEXT.runServiceAtAnonymousContext(async (ctx) => {
             const curdProService = await ctx.requestContext.getAsync("curdProService");
@@ -78,6 +83,13 @@ class AsyncTaskRunner {
             return res.getResModel().affected;
         });
     }
+    /**
+     * 获取当前进程可以处理的任务类型。
+     */
+    getHandlerTaskTypeList() {
+        const keys = this.taskHandlerMap.keys();
+        return [...keys];
+    }
 }
 /**
  * 业务可以扩展
@@ -90,9 +102,18 @@ const LOCK_KEY_ASYNC_TASK_RUNNER = "LOCK_KEY_ASYNC_TASK_RUNNER";
 let AsyncTaskRunnerService = class AsyncTaskRunnerService extends BaseService_1.BaseService {
     async fetchPendingTasks() {
         const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
+        // 只获取本进程能够处理的任务类型。
+        const taskTypeList = exports.ASYNC_TASK_RUNNER.getHandlerTaskTypeList();
+        if (taskTypeList.length === 0) {
+            return Promise.resolve();
+        }
+        // 查询等待处理的任务。
         const queryRes = await this.curdProService.executeCrudByCfg({
             condition: {
-                task_status: AsyncTaskModel_1.SysAsyncTaskStatus.PENDING
+                task_status: AsyncTaskModel_1.SysAsyncTaskStatus.PENDING,
+                task_type: {
+                    "$in": taskTypeList
+                }
             },
             orderBy: 'id+',
             limit: 10
@@ -107,6 +128,7 @@ let AsyncTaskRunnerService = class AsyncTaskRunnerService extends BaseService_1.
             return Promise.resolve();
         }
         const taskIds = taskList.map(elem => elem.id).filter(Boolean);
+        // 将状态更新为处理中。防止其它进程重复处理。
         await this.curdProService.executeCrudByCfg({
             condition: {
                 id: {
@@ -122,6 +144,7 @@ let AsyncTaskRunnerService = class AsyncTaskRunnerService extends BaseService_1.
             sqlDatabase: SystemDbName,
             sqlDbType: SystemDbType,
         });
+        // 开始执行。
         exports.ASYNC_TASK_RUNNER.executeTaskList(taskList).then(() => {
             console.log("ASYNC_TASK_RUNNER finished taskIds ==> " + JSON.stringify(taskIds));
         });

package/dist/service/asyncTask/AsyncTaskService.js

@@ -16,7 +16,7 @@ const schedule_1 = require("../../schedule");
 const scheduleNames_1 = require("../../schedule/scheduleNames");
 let AsyncTaskService = class AsyncTaskService extends BaseService_1.BaseService {
     async startTask() {
-        (0, schedule_1.runScheduleTaskOnce)(scheduleNames_1.SCHEDULE_NAMES.asyncTaskRunnerService).then(schedule => {
+        (0, schedule_1.runScheduleTaskOnce)(scheduleNames_1.INNER_SCHEDULE_NAMES.asyncTaskRunnerService).then(schedule => {
             console.log(schedule);
         });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "midway-fatcms",
-  "version": "0.0.1-beta.16",
+  "version": "0.0.1-beta.18",
   "description": "This is a midway component sample",
   "main": "dist/index.js",
   "typings": "index.d.ts",

package/src/configuration.ts

@@ -13,9 +13,8 @@ import { join } from 'path';
 // import { NotFoundFilter } from './filter/notfound.filter';
 import { GlobalMiddleware } from './middleware/global.middleware';
 import { ForbiddenMiddleware } from './middleware/forbidden.middleware';
-import { startScheduleLoop } from './schedule';
+import { SCHEDULE_QUEUE , ANONYMOUS_CONTEXT, INNER_SCHEDULE_INTERVAL } from './schedule';
 import { privateAES } from './libs/utils/crypto-utils';
-import { ALL_SCHEDULE_NAMES } from "@/schedule/scheduleNames";
 
 @Configuration({
   // namespace: 'fatcms',
@@ -65,6 +64,11 @@ export class ContainerLifeCycle {
 
   async onReady() {
 
+    /**
+     * 让ANONYMOUS_CONTEXT获取app对象
+     */
+    ANONYMOUS_CONTEXT.setApp(this.app);
+
     /**
      * 启动定时任务
      */
@@ -78,25 +82,33 @@ export class ContainerLifeCycle {
     // this.app.useFilter([NotFoundFilter, DefaultErrorFilter]);
   }
 
-  private async startScheduleOnReady(){
+  private async startScheduleOnReady() {
     const logger = this.app.getLogger();
     const config = this.app.getConfig();
-    const fatcmsScheduleService: boolean | string[] = config.fatcmsScheduleService;
+    const fatcmsScheduleService: boolean | any = config.fatcmsScheduleService;
 
     // 关闭定时任务
     if (fatcmsScheduleService === false || fatcmsScheduleService === null) {
       return;
     }
 
+    let scheduleIntervalCfg = INNER_SCHEDULE_INTERVAL;
+    if (typeof fatcmsScheduleService === "object") {
+      scheduleIntervalCfg = fatcmsScheduleService
+    }
 
-    let scheduleServiceList = ALL_SCHEDULE_NAMES
-
-    // 启动部分定时任务
-    if (Array.isArray(fatcmsScheduleService)){
-      scheduleServiceList = fatcmsScheduleService;
+    const keys = Object.keys(scheduleIntervalCfg);
+    for (let i = 0; i < keys.length; i++) {
+      const service = keys[i];
+      const interval = scheduleIntervalCfg[service];
+      if (typeof interval !== "number") {
+        throw new Error('Invalid scheduleIntervalCfg ' + service + ",  interval must be a number");
+      }
+      SCHEDULE_QUEUE.setScheduleTask(service, interval);
     }
-    await startScheduleLoop(scheduleServiceList);
-    logger.info('ContainerLifeCycle ==> onReady 启动定时任务 ： ' + JSON.stringify(scheduleServiceList) );
+
+    await SCHEDULE_QUEUE.startScheduleLoop();
+    logger.info('ContainerLifeCycle ==> onReady 启动定时任务 ： ' + JSON.stringify(scheduleIntervalCfg));
   }
 
 

package/src/schedule/index.ts

@@ -1,14 +1,12 @@
-import {startScheduleLoop, runScheduleTaskOnce} from './runSchedule'
+import {SCHEDULE_QUEUE, runScheduleTaskOnce} from './runSchedule'
 import {ANONYMOUS_CONTEXT} from './anonymousContext'
 import {
-  ALL_SCHEDULE_NAMES,
-  SCHEDULE_NAMES,
+  INNER_SCHEDULE_INTERVAL
 } from './scheduleNames'
 
 export {
-  ALL_SCHEDULE_NAMES,
-  SCHEDULE_NAMES,
+  INNER_SCHEDULE_INTERVAL,
   ANONYMOUS_CONTEXT,
-  startScheduleLoop,
+  SCHEDULE_QUEUE,
   runScheduleTaskOnce
 }

package/src/schedule/runSchedule.ts

@@ -1,10 +1,17 @@
 import * as koa from '@midwayjs/koa';
-import { IScheduleService } from '@/interface';
-import { ANONYMOUS_CONTEXT } from "./anonymousContext";
+import {IScheduleService} from '@/interface';
+import {ANONYMOUS_CONTEXT} from "./anonymousContext";
+
+
+// 上次执行时间
+const lastExecuteTimeMap = {};
+
+const DEFAULT_SCHEDULE_INTERVAL = 2 * 60 * 1000;
+
 
 
 async function runScheduleTaskOnce(serviceName: string) {
-  return await ANONYMOUS_CONTEXT.runServiceAtAnonymousContext(async (ctx: koa.IMidwayKoaContext)=>{
+  return await ANONYMOUS_CONTEXT.runServiceAtAnonymousContext(async (ctx: koa.IMidwayKoaContext) => {
     const serviceObject: IScheduleService = await ctx.requestContext.getAsync(serviceName);
     if (serviceObject && serviceObject.runBySchedule) {
       await serviceObject.runBySchedule();
@@ -14,22 +21,58 @@ async function runScheduleTaskOnce(serviceName: string) {
   });
 }
 
-async function runScheduleServiceList(serviceList: string[]) {
-  for (let i = 0; i < serviceList.length; i++) {
-    const serviceName = serviceList[i];
-    try {
-      await runScheduleTaskOnce(serviceName);
-    } catch (e) {
-      ANONYMOUS_CONTEXT.getApp().getCoreLogger().error(`runSchedule error , serviceName = ${serviceName}`, e);
+class ScheduleQueue {
+  private scheduleIntervalMap: Map<string, number> = new Map();
+  public setScheduleTask(serviceName: string, intervalTime: number){
+    this.scheduleIntervalMap.set(serviceName, intervalTime);
+  }
+  public removeScheduleTask(serviceName: string){
+    this.scheduleIntervalMap.delete(serviceName);
+  }
+
+  private isAlreadyTimeToExecute(serviceName: string): boolean {
+    if (!lastExecuteTimeMap[serviceName]) {
+      return true; // 可以执行
     }
+    const intervalTime1 = this.scheduleIntervalMap.get(serviceName);
+    const intervalTime = intervalTime1 || DEFAULT_SCHEDULE_INTERVAL; // 时间间隔
+    const lastExecuteTime = lastExecuteTimeMap[serviceName];
+    return (Date.now() - lastExecuteTime) >= intervalTime;
   }
-}
 
-async function startScheduleLoop(serviceList: string[]) {
-  await runScheduleServiceList(serviceList);
-  setInterval(() => {
-    runScheduleServiceList(serviceList);
-  }, 2 * 60 * 1000);
+
+  private async runScheduleServiceList() {
+    const serviceListKeys = this.scheduleIntervalMap.keys();
+    const serviceList = [...serviceListKeys];
+    for (let i = 0; i < serviceList.length; i++) {
+      const serviceName = serviceList[i];
+
+      // 还没有到可以执行时间
+      if (!this.isAlreadyTimeToExecute(serviceName)) {
+        return;
+      }
+      lastExecuteTimeMap[serviceName] = Date.now();
+
+      try {
+        await runScheduleTaskOnce(serviceName);
+      } catch (e) {
+        ANONYMOUS_CONTEXT.getApp().getCoreLogger().error(`runSchedule error , serviceName = ${serviceName}`, e);
+      }
+    }
+  }
+
+
+  public async startScheduleLoop() {
+    await this.runScheduleServiceList();
+    setInterval(() => {
+      this.runScheduleServiceList();
+    }, 1000); // 最少1秒执行一次
+  }
+
+
 }
 
-export { startScheduleLoop, runScheduleTaskOnce };
+
+const SCHEDULE_QUEUE = new ScheduleQueue();
+
+export {SCHEDULE_QUEUE, runScheduleTaskOnce};

package/src/schedule/scheduleNames.ts

@@ -1,20 +1,21 @@
 
+const INNER_SCHEDULE_INTERVAL = {
+  proxyApiLoadService: 2 * 60 * 1000, // 2分钟重新加载一次,
+  workbenchService: 60 * 1000, // 1分钟重新加载一次,
+  visitStatService: 10 * 60 * 1000, // 10分钟重新加载一次,
+  asyncTaskRunnerService: 1000, // 1s可以执行
+}
 
-const SCHEDULE_NAMES = {
+const INNER_SCHEDULE_NAMES = {
   proxyApiLoadService: 'proxyApiLoadService',
   workbenchService: 'workbenchService',
-  visitStatService: 'visitStatService',
-  asyncTaskRunnerService: 'asyncTaskRunnerService',
+  visitStatService: "visitStatService",
+  asyncTaskRunnerService: "asyncTaskRunnerService",
 }
 
-const ALL_SCHEDULE_NAMES = [
-  SCHEDULE_NAMES.proxyApiLoadService,
-  SCHEDULE_NAMES.workbenchService,
-  SCHEDULE_NAMES.visitStatService,
-  SCHEDULE_NAMES.asyncTaskRunnerService
-];
+
 
 export {
-  ALL_SCHEDULE_NAMES,
-  SCHEDULE_NAMES,
+  INNER_SCHEDULE_INTERVAL,
+  INNER_SCHEDULE_NAMES
 }

package/src/service/VisitStatService.ts

@@ -34,7 +34,6 @@ export class VisitStatService extends BaseService implements IScheduleService {
     return this.flushVisitStatToDB();
   }
 
-
   async flushVisitStatToDB():  Promise<any>   {
 
     const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();

package/src/service/anyapi/AnyApiService.ts

@@ -1,17 +1,17 @@
 import { Inject, Provide } from '@midwayjs/core';
 import { Context } from '@midwayjs/koa';
-import { KeysOfSimpleSQL } from '../../libs/crud-pro/models/keys';
-import { SystemTables} from '../../models/SystemTables';
+import { KeysOfSimpleSQL } from '@/libs/crud-pro/models/keys';
+import { SystemTables} from '@/models/SystemTables';
 import { LRUCache } from 'lru-cache';
-import { BizException } from '../../models/devops';
+import { BizException } from '@/models/devops';
 import { CurdMixService } from '../curd/CurdMixService';
-import { ISysAnyApiEntity } from '../../models/SystemEntities';
+import { ISysAnyApiEntity } from '@/models/SystemEntities';
 import { AnyApiSandboxService, IRunInSandboxParams } from './AnyApiSandboxService';
-import { parseJsonObject } from '../../libs/utils/functions';
+import { parseJsonObject } from '@/libs/utils/functions';
 import * as _ from 'lodash';
-import { MixinUtils } from '../../libs/crud-pro/utils/MixinUtils';
+import { MixinUtils } from '@/libs/crud-pro/utils/MixinUtils';
 import { WorkbenchService } from '../WorkbenchService';
-import { validateByCfgString } from '../../libs/crud-pro/utils/ValidateUtils';
+import { validateByCfgString } from '@/libs/crud-pro/utils/ValidateUtils';
 import { API_BASE_TYPE, ApiBaseService } from '../base/ApiBaseService';
 import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
 

package/src/service/asyncTask/AsyncTaskRunnerService.ts

@@ -57,6 +57,11 @@ class AsyncTaskRunner {
   }
 
 
+  /**
+   * 更新任务状态或任务进度
+   * @param taskElement
+   * @private
+   */
   private async updateTaskStatus(taskElement: SysAsyncTaskEntity) {
     return await ANONYMOUS_CONTEXT.runServiceAtAnonymousContext(async (ctx: IMidwayKoaContext) => {
       const curdProService: CurdProService = await ctx.requestContext.getAsync("curdProService");
@@ -78,8 +83,18 @@ class AsyncTaskRunner {
       return res.getResModel().affected;
     });
 
+  }
+
 
+  /**
+   * 获取当前进程可以处理的任务类型。
+   */
+  public getHandlerTaskTypeList(): string[] {
+    const keys = this.taskHandlerMap.keys();
+    return [...keys];
   }
+
+
 }
 
 
@@ -97,6 +112,7 @@ const LOCK_KEY_ASYNC_TASK_RUNNER = "LOCK_KEY_ASYNC_TASK_RUNNER"
 @Provide()
 export class AsyncTaskRunnerService extends BaseService implements IScheduleService {
 
+
   @Inject()
   protected ctx: Context;
 
@@ -108,9 +124,20 @@ export class AsyncTaskRunnerService extends BaseService implements IScheduleServ
 
     const {SystemDbName, SystemDbType} = GLOBAL_STATIC_CONFIG.getConfig();
 
+    // 只获取本进程能够处理的任务类型。
+    const taskTypeList = ASYNC_TASK_RUNNER.getHandlerTaskTypeList();
+    if (taskTypeList.length === 0) {
+      return Promise.resolve();
+    }
+
+
+    // 查询等待处理的任务。
     const queryRes = await this.curdProService.executeCrudByCfg({
       condition: {
-        task_status: SysAsyncTaskStatus.PENDING
+        task_status: SysAsyncTaskStatus.PENDING,
+        task_type: {
+          "$in": taskTypeList
+        }
       },
       orderBy: 'id+',
       limit: 10
@@ -127,9 +154,9 @@ export class AsyncTaskRunnerService extends BaseService implements IScheduleServ
     if (taskList.length === 0) {
       return Promise.resolve();
     }
-
     const taskIds = taskList.map(elem => elem.id).filter(Boolean)
 
+    // 将状态更新为处理中。防止其它进程重复处理。
     await this.curdProService.executeCrudByCfg({
       condition: {
         id: {
@@ -147,6 +174,7 @@ export class AsyncTaskRunnerService extends BaseService implements IScheduleServ
     });
 
 
+    // 开始执行。
     ASYNC_TASK_RUNNER.executeTaskList(taskList).then(() => {
       console.log("ASYNC_TASK_RUNNER finished taskIds ==> " + JSON.stringify(taskIds))
     })
@@ -177,5 +205,4 @@ export class AsyncTaskRunnerService extends BaseService implements IScheduleServ
     return Promise.resolve();
   }
 
-
 }

package/src/service/asyncTask/AsyncTaskService.ts

@@ -2,7 +2,7 @@ import {Inject, Provide} from '@midwayjs/core';
 import {Context} from '@midwayjs/koa';
 import {BaseService} from "@/service/base/BaseService";
 import {runScheduleTaskOnce} from "@/schedule";
-import {SCHEDULE_NAMES} from "@/schedule/scheduleNames";
+import {INNER_SCHEDULE_NAMES} from "@/schedule/scheduleNames";
 
 @Provide()
 export class AsyncTaskService extends BaseService {
@@ -10,7 +10,7 @@ export class AsyncTaskService extends BaseService {
   protected ctx: Context;
 
   async startTask() {
-    runScheduleTaskOnce(SCHEDULE_NAMES.asyncTaskRunnerService).then(schedule => {
+    runScheduleTaskOnce(INNER_SCHEDULE_NAMES.asyncTaskRunnerService).then(schedule => {
       console.log(schedule);
     })
   }

package/src/service/proxyapi/ProxyApiLoadService.ts

@@ -86,7 +86,7 @@ export class ProxyApiLoadService extends BaseService implements IScheduleService
   }
 
   private async buildUpstreamMap() {
-    
+
     const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
 
     //       biz_tag={'upstream'}
@@ -114,10 +114,10 @@ export class ProxyApiLoadService extends BaseService implements IScheduleService
   }
 
   private async loadProxyApiEntity(workbench_code: string, upstreamMap: Record<string, IUpstreamInfo>): Promise<IProxyApiEntity[]> {
-    
+
     const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
 
-    
+
     const res = await this.curdProService.executeCrudByCfg(
       {
         condition: {},
@@ -170,4 +170,5 @@ export class ProxyApiLoadService extends BaseService implements IScheduleService
       }
     }
   }
+
 }