fix：执行计划

1.修改定时任务的统计逻辑，改为查询库表的数据

cctp-atu/atu-execute-plan/src/main/java/net/northking/cctp/executePlan/config/AtuPlanConfig.java

@@ -21,4 +21,37 @@ public class AtuPlanConfig {
         }
         this.waitTimeout = waitTimeout;
     }
+
+    /**
+     * 是否启用执行超时，默认启用
+     * atu.plan.batchExecuteTimeoutEnabled
+     */
+    private Boolean batchExecuteTimeoutEnabled;
+
+    /**
+     * 批次执行超时时间，默认48小时
+     *  atu.plan.batchExecuteTimeout
+     */
+    private Integer batchExecuteTimeout;
+
+
+    public boolean isBatchExecuteTimeoutEnabled() {
+        return batchExecuteTimeoutEnabled == null ? true : batchExecuteTimeoutEnabled;
+    }
+
+    public void setBatchExecuteTimeoutEnabled(boolean batchExecuteTimeoutEnabled) {
+        this.batchExecuteTimeoutEnabled = batchExecuteTimeoutEnabled;
+    }
+
+    public Integer getBatchExecuteTimeout() {
+        if (isBatchExecuteTimeoutEnabled()) {
+            // 如果是启用了批次执行超时，
+            return batchExecuteTimeout == null ? 48 : batchExecuteTimeout;
+        }
+        return 48;
+    }
+
+    public void setBatchExecuteTimeout(Integer batchExecuteTimeout) {
+        this.batchExecuteTimeout = batchExecuteTimeout;
+    }
 }

cctp-atu/atu-execute-plan/src/main/java/net/northking/cctp/executePlan/db/dao/AtuPlanTaskDao.java

@@ -4,13 +4,9 @@
 */
 package net.northking.cctp.executePlan.db.dao;
 
-import net.northking.cctp.common.http.QueryByPage;
 import net.northking.cctp.executePlan.db.entity.AtuPlanTask;
 import net.northking.cctp.executePlan.db.mapper.AtuPlanTaskMapper;
-import net.northking.cctp.executePlan.dto.planTask.AtuPlanTaskExtendDto;
+import net.northking.cctp.executePlan.dto.planTask.*;
-import net.northking.cctp.executePlan.dto.planTask.AtuPlanTaskPageDto;
-import net.northking.cctp.executePlan.dto.planTask.AtuPlanTaskQueryDto;
-import net.northking.cctp.executePlan.dto.planTask.AtuTaskSendBugDto;
 import net.northking.cctp.executePlan.pub.dto.ScriptFirstExecutionDTO;
 import org.apache.ibatis.annotations.Param;
 import org.springframework.stereotype.Repository;
@@ -132,4 +128,17 @@ public interface AtuPlanTaskDao extends AtuPlanTaskMapper
     AtuPlanTaskExtendDto queryTaskExtendById(String id);
 
     List<AtuPlanTask> queryWaitTimeoutTask(@Param("waitTimeout") Integer waitTimeout);
+
+    List<ScriptStatusStatistic> countTaskStatus(AtuPlanTask task);
+
+    /**
+     * 将批次下的所有等待中和执行中的任务改成超时
+     *
+     * @param batchId 批次id
+     * @param timeoutStatus 超时状态码
+     * @param waitStatus 等待中状态码
+     * @param startStatus 执行中状态码
+     */
+    long batchUpdateTaskStatusToTimeout(@Param(value = "batchId")String batchId, @Param(value = "timeoutStatus")String timeoutStatus,
+                                        @Param(value = "waitStatus")String waitStatus, @Param(value = "startStatus")String startStatus);
 }

cctp-atu/atu-execute-plan/src/main/java/net/northking/cctp/executePlan/db/impl/AtuPlanTaskServiceImpl.java

@@ -4,18 +4,19 @@
 */
 package net.northking.cctp.executePlan.db.impl;
 
+import cn.hutool.core.util.StrUtil;
 import net.northking.cctp.common.db.BasicDao;
 import net.northking.cctp.common.db.PaginationService;
+import net.northking.cctp.common.exception.PlatformRuntimeException;
 import net.northking.cctp.common.http.QueryByPage;
 import net.northking.cctp.executePlan.db.dao.AtuPlanTaskDao;
 import net.northking.cctp.executePlan.db.entity.AtuPlanTask;
 import net.northking.cctp.executePlan.db.service.AtuPlanTaskService;
-import net.northking.cctp.executePlan.dto.planTask.AtuPlanTaskExtendDto;
+import net.northking.cctp.executePlan.dto.planTask.*;
-import net.northking.cctp.executePlan.dto.planTask.AtuPlanTaskPageDto;
+import net.northking.cctp.executePlan.exception.ExecPlanError;
-import net.northking.cctp.executePlan.dto.planTask.AtuPlanTaskQueryDto;
-import net.northking.cctp.executePlan.dto.planTask.AtuTaskSendBugDto;
 import net.northking.cctp.executePlan.pub.dto.ScriptFirstExecutionDTO;
 import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
@@ -183,6 +184,36 @@ private static final Logger logger = LoggerFactory.getLogger(AtuPlanTaskServiceI
         return atuPlanTaskDao.queryWaitTimeoutTask(waitTimeout);
     }
 
+  /**
+   * 统计指定批次下分组查询脚本下任务的执行状态结果
+   *
+   * @param task
+   * @return
+   */
+  @Override
+  public List<ScriptStatusStatistic> countTaskStatus(AtuPlanTask task) {
+    if (task == null || StringUtils.isBlank(task.getBatchId())) {
+      throw new PlatformRuntimeException(ExecPlanError.EMPTY_BATCH_ID);
+    }
+    return this.atuPlanTaskDao.countTaskStatus(task);
+  }
+
+  /**
+   * 将批次下的所有等待中和执行中的任务改成超时
+   *
+   * @param batchId 批次id
+   * @param timeoutStatus 超时状态码
+   * @param waitStatus 等待中状态码
+   * @param startStatus 执行中状态码
+   */
+  @Override
+  public void batchUpdateTaskStatusToTimeout(String batchId, String timeoutStatus, String waitStatus, String startStatus) {
+    if (StringUtils.isBlank(batchId)) {
+      throw new PlatformRuntimeException(ExecPlanError.EMPTY_BATCH_ID);
+    }
+    this.atuPlanTaskDao.batchUpdateTaskStatusToTimeout(batchId, timeoutStatus, waitStatus, startStatus);
+  }
+
 // ----      The End by Generator     ----//
 
 

cctp-atu/atu-execute-plan/src/main/java/net/northking/cctp/executePlan/db/service/AtuPlanTaskService.java

@@ -7,10 +7,7 @@ package net.northking.cctp.executePlan.db.service;
 import net.northking.cctp.common.db.BasicService;
 import net.northking.cctp.common.http.QueryByPage;
 import net.northking.cctp.executePlan.db.entity.AtuPlanTask;
-import net.northking.cctp.executePlan.dto.planTask.AtuPlanTaskExtendDto;
+import net.northking.cctp.executePlan.dto.planTask.*;
-import net.northking.cctp.executePlan.dto.planTask.AtuPlanTaskPageDto;
-import net.northking.cctp.executePlan.dto.planTask.AtuPlanTaskQueryDto;
-import net.northking.cctp.executePlan.dto.planTask.AtuTaskSendBugDto;
 import net.northking.cctp.executePlan.pub.dto.ScriptFirstExecutionDTO;
 
 import java.time.LocalDate;
@@ -136,4 +133,20 @@ public interface AtuPlanTaskService extends BasicService<AtuPlanTask>
     AtuPlanTaskExtendDto queryTaskExtendById(String taskId);
 
     List<AtuPlanTask> queryWaitTimeoutTask(Integer waitTimeout);
+
+    /**
+     * 统计指定批次下分组查询脚本下任务的执行状态结果
+     * @param task
+     * @return
+     */
+    List<ScriptStatusStatistic> countTaskStatus(AtuPlanTask task);
+
+    /**
+     * 将批次下的所有等待中和执行中的任务改成超时
+     * @param batchId 批次id
+     * @param timeoutStatus 超时状态码
+     * @param waitStatus 等待中状态码
+     * @param startStatus 执行中状态码
+     */
+    void batchUpdateTaskStatusToTimeout(String batchId, String timeoutStatus, String waitStatus, String startStatus);
 }

cctp-atu/atu-execute-plan/src/main/java/net/northking/cctp/executePlan/exception/ExecPlanError.java

@@ -85,6 +85,8 @@ public enum ExecPlanError implements PlatformError {
 
     PARSE_DATE_ERROR("格式化日期出错，请检查参数"),
 
+    EMPTY_BATCH_ID("批次id不能为空"),
+
     GET_FILE_FAIL("获取文件失败"),
 
     /**

cctp-atu/atu-execute-plan/src/main/java/net/northking/cctp/executePlan/job/PlanBatchTaskDataUpdateJob.java

@@ -16,6 +16,7 @@ import net.northking.cctp.executePlan.api.service.AtuPlanInfoApiService;
 import net.northking.cctp.executePlan.api.service.AtuPlanTaskApiService;
 import net.northking.cctp.executePlan.api.service.MessageCenterService;
 import net.northking.cctp.executePlan.api.third.feilang.service.FeiLangService;
+import net.northking.cctp.executePlan.config.AtuPlanConfig;
 import net.northking.cctp.executePlan.constants.MsgConstant;
 import net.northking.cctp.executePlan.constants.PlanConstant;
 import net.northking.cctp.executePlan.constants.RabbitConstant;
@@ -24,6 +25,7 @@ import net.northking.cctp.executePlan.db.entity.*;
 import net.northking.cctp.executePlan.db.service.*;
 import net.northking.cctp.executePlan.dto.planBatch.*;
 import net.northking.cctp.executePlan.dto.planInfo.AtuPlanRunDto;
+import net.northking.cctp.executePlan.dto.planTask.ScriptStatusStatistic;
 import net.northking.cctp.executePlan.enums.MobilePlatformEnum;
 import net.northking.cctp.executePlan.feign.PublicFeignClient;
 import net.northking.cctp.executePlan.utils.MinioPathUtils;
@@ -35,14 +37,20 @@ import org.springframework.amqp.core.AmqpAdmin;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.integration.redis.util.RedisLockRegistry;
 import org.springframework.scheduling.annotation.EnableScheduling;
 import org.springframework.scheduling.annotation.Scheduled;
 
 import java.io.File;
+import java.time.Duration;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.format.DateTimeFormatter;
 import java.util.*;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.LinkedBlockingDeque;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.Lock;
 import java.util.stream.Collectors;
 
 /**
@@ -108,6 +116,14 @@ public class PlanBatchTaskDataUpdateJob {
     @Autowired
     private RedissonClient redisson;
 
+    @Autowired
+    private RedisLockRegistry redisLockRegistry;
+
+    private final static String LOCK_KEY_BATCH_SUM = "LOCK:PLAN:BATCH-SUM-DATA-UPDATE-METHOD";
+
+    @Autowired
+    private AtuPlanConfig atuPlanConfig;
+
     public static final int EXECUTOR_CORE_POOL_SIZE = 2 * 2 + 2;
     public static final int EXECUTOR_MAX_POOL_SIZE = 10;
     public static final int EXECUTOR_LINKED_BLOCKING_SIZE = 50;
@@ -120,6 +136,12 @@ public class PlanBatchTaskDataUpdateJob {
 
     @Scheduled(fixedRateString = "${atu.plan.batchCountUpdateJob:20000}")
     private void batchSumDataUpdate() {
+        // 统计加锁，多节点只需要一个节点启动
+        Lock lock = redisLockRegistry.obtain(LOCK_KEY_BATCH_SUM);
+        if (!lock.tryLock()) {  // 没有拿到锁退出方法，有别的节点获取到锁进行统计
+            return;
+        }
+        try {
             logger.debug("同步缓存中计划批次统计数据----start----");
             // 1. 获取缓存中所有的批次统计数据
             String patternKey = RedisConstant.CLUSTER_KEY_PREFIX + "*" + RedisConstant.CLUSTER_KEY_SUFFIX +
@@ -134,76 +156,88 @@ public class PlanBatchTaskDataUpdateJob {
                 Map<Object, Object> entries = redisTemplate.opsForHash().entries(key);
                 if (CollUtil.isEmpty(entries)) {
                     logger.info("缓存[" + key + "]中无统计数据");
+                    // 没有统计数据，删掉key
+                    redisTemplate.delete(key);
                     return;
                 }
                 String batchId = key.substring(key.lastIndexOf(":") + 1);
                 String clusterKeyPrefix = RedisConstant.CLUSTER_KEY_PREFIX + batchId.substring(0, 4) +
                         RedisConstant.CLUSTER_KEY_SUFFIX;
-            // 2. 遍历判断该批次是否已完成
+
-            int waitTotal = 0;
+                // 通过数据库进行统计，减少统计数据出错的原因
-            Object waitStatusObj = entries.get(clusterKeyPrefix + PlanConstant.TASK_WAIT_EXECUTE_STATUS);
+                AtuPlanTask taskQ = new AtuPlanTask();
-            if (ObjectUtil.isNotNull(waitStatusObj)) {
+                taskQ.setBatchId(batchId);
-                waitTotal = Integer.parseInt(waitStatusObj.toString());
+                List<ScriptStatusStatistic> resultList = planTaskService.countTaskStatus(taskQ);
+                List<String> batchStatusList = new ArrayList<>();
+                for (ScriptStatusStatistic result : resultList) {
+                    Set<String> statusSet = result.getStatusSet();
+                    result.setStatus(scriptStatus(statusSet));  // 根据脚本下的所有任务确定脚本的执行结果
+                    batchStatusList.add(result.getStatus());
                 }
-            int runningTotal = 0;
+                int allScriptCount = batchStatusList.size(); // 总脚本执行数
-            Object runningStatusObj = entries.get(clusterKeyPrefix + PlanConstant.TASK_START_EXECUTE_STATUS);
+                // 等待中
-            if (ObjectUtil.isNotNull(runningStatusObj)) {
+                int waitCount = Collections.frequency(batchStatusList, PlanConstant.TASK_WAIT_EXECUTE_STATUS);
-                runningTotal = Integer.parseInt(runningStatusObj.toString());
+                // 执行中
-            }
+                int ingCount = Collections.frequency(batchStatusList, PlanConstant.TASK_START_EXECUTE_STATUS);
-            // TODO: 判断有没有负数、总数是否相等
+                // 成功
-            // 失败的数据
+                int successCount = Collections.frequency(batchStatusList, PlanConstant.TASK_EXECUTE_SUCCESS_STATUS);
-            // 脚本超时的
+                // 执行失败
-            if (waitTotal != 0 || runningTotal != 0) {
+                int executeFailCount = Collections.frequency(batchStatusList, PlanConstant.TASK_EXECUTE_FAIL_STATUS);
-                // 该批次还未完成
+                // 断言失败
+                int assertFailCount = Collections.frequency(batchStatusList, PlanConstant.TASK_ASSERT_FAIL_STATUS);
+                // 取消的
+                int cancelCount = Collections.frequency(batchStatusList, PlanConstant.TASK_CANCEL_STATUS);
+                // 超时的
+                int timeoutCount = Collections.frequency(batchStatusList, PlanConstant.TASK_TIMEOUT_STATUS);
+
+                if (waitCount > 0 || ingCount > 0) {    // 批次还没有完成
+                    // 检查批次的开始时间
+                    AtuPlanBatch batch = this.planBatchService.findByPrimaryKey(batchId);
+                    if (batch != null) {
+                        Date createdTime = batch.getCreatedTime();
+                        if (createdTime != null) {  // 有创建时间，那么比较开始时间与现在的时间差
+                            LocalDateTime createDateTime = createdTime.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
+                            LocalDateTime now = LocalDateTime.now();
+                            Duration duration = Duration.between(createDateTime, now);
+                            long hours = duration.toHours();
+                            if (atuPlanConfig.isBatchExecuteTimeoutEnabled() && hours > atuPlanConfig.getBatchExecuteTimeout().longValue()) {  // 参数化
+                                logger.info("批次[{}-{}]已创建{}小时，任务没有执行完成，强制结束批次", batch.getId(), batch.getBatch(), 48);
+                                // 如果批次的创建时间离现在已经过去48小时还没完成，那么判定批次已完成，等待中|执行中 的任务全部算超时处理
+                                timeoutCount += waitCount;
+                                timeoutCount += ingCount;
+                                waitCount = 0;
+                                ingCount = 0;
+                                // 更新批次下 等待中（0）|执行中（1） 的任务全部算超时处理（6）
+                                this.planTaskService.batchUpdateTaskStatusToTimeout(batch.getId(), PlanConstant.TASK_TIMEOUT_STATUS, PlanConstant.TASK_WAIT_EXECUTE_STATUS, PlanConstant.TASK_START_EXECUTE_STATUS);
+                            } else {
+                                // 批次还没有完成，退出统计
                                 return;
                             }
-            // 2.1. 完成则更新数据库中的批次统计数据
+                        } else {
-            int total = 0;
+                            // 有批次信息，但是没有创建时间，应该是数据有问题
-            Object scriptTotalObj = entries.get(clusterKeyPrefix + PlanConstant.SCRIPT_TOTAL);
+                            logger.debug("批次[{}]没有创建时间", batch.getId());
-            if (ObjectUtil.isNotNull(scriptTotalObj)) {
+                            return;
-                total = Integer.parseInt(scriptTotalObj.toString());
                         }
-            int successTotal = 0;
+                    } else {    // 没有对应批次数据，删除缓存数据
-            Object successStatusObj = entries.get(clusterKeyPrefix + PlanConstant.TASK_EXECUTE_SUCCESS_STATUS);
+                        logger.debug("没有对应的批次信息[{}]，删除缓存数据", batchId);
-            if (ObjectUtil.isNotNull(successStatusObj)) {
+                        redisTemplate.delete(key);
-                successTotal = Integer.parseInt(successStatusObj.toString());
+                        return; // 退出这个批次统计
-            }
-            int failTotal = 0;
-            Object failStatusObj = entries.get(clusterKeyPrefix + PlanConstant.TASK_EXECUTE_FAIL_STATUS);
-            if (ObjectUtil.isNotNull(failStatusObj)) {
-                failTotal = Integer.parseInt(failStatusObj.toString());
-                if (failTotal < 0) {
-                    failTotal = 0;
                     }
                 }
-            int assertFailTotal = 0;
+                // 批次已完成
-            Object assertFailStatusObj = entries.get(clusterKeyPrefix + PlanConstant.TASK_ASSERT_FAIL_STATUS);
+
-            if (ObjectUtil.isNotNull(assertFailStatusObj)) {
-                assertFailTotal = Integer.parseInt(assertFailStatusObj.toString());
-            }
-            int timeoutTotal = 0;
-            Object timeoutStatusObj = entries.get(clusterKeyPrefix + PlanConstant.TASK_TIMEOUT_STATUS);
-            if (ObjectUtil.isNotNull(timeoutStatusObj)) {
-                timeoutTotal = Integer.parseInt(timeoutStatusObj.toString());
-            }
-            int cancelTotal = 0;
-            Object cancelStatusObj = entries.get(clusterKeyPrefix + PlanConstant.TASK_CANCEL_STATUS);
-            if (ObjectUtil.isNotNull(cancelStatusObj)) {
-                cancelTotal = Integer.parseInt(cancelStatusObj.toString());
-            }
-            // TODO: 统计库表数据进行更新，而不是通过缓存
                 // 更新批次表
                 AtuPlanBatch planBatch = new AtuPlanBatch();
                 planBatch.setId(batchId);
-            planBatch.setSuccessNum(successTotal);
+                planBatch.setSuccessNum(successCount);
-            planBatch.setExecFailNum(failTotal);
+                planBatch.setExecFailNum(executeFailCount);
-            planBatch.setAssertFailNum(assertFailTotal);
+                planBatch.setAssertFailNum(assertFailCount);
-            planBatch.setTimeoutNum(timeoutTotal);
+                planBatch.setTimeoutNum(timeoutCount);
-            planBatch.setCancelNum(cancelTotal);
+                planBatch.setCancelNum(cancelCount);
 
                 planBatch.setSuccessRate(MsgConstant.PLAN_BATCH_SUCCESS_RATE);
-            if (successTotal > 0 && total > 0) {
+                if (planBatch.getSuccessNum() > 0 && allScriptCount > 0) {
-                planBatch.setSuccessRate(NumberUtil.decimalFormat(MsgConstant.PATTERN_HASH_DOT_HASH_HASH, NumberUtil.div(successTotal, total)));
+                    planBatch.setSuccessRate(NumberUtil.decimalFormat(MsgConstant.PATTERN_HASH_DOT_HASH_HASH, NumberUtil.div(planBatch.getSuccessNum(), allScriptCount)));
                 }
                 // 查询批次最先开始执行的任务的开始时间
                 if (planBatch.getStartTime() == null) {
@@ -214,7 +248,7 @@ public class PlanBatchTaskDataUpdateJob {
                 }
                 // 任务状态判断
                 String planStatus = "";
-            if (cancelTotal > 0) {
+                if (planBatch.getCancelNum() > 0) {
                     planStatus = PlanConstant.PLAN_CANCEL_STATUS;
                     // 修改为取消状态
                     planBatch.setStatus(PlanConstant.BATCH_CANCEL_STATUS);
@@ -249,13 +283,13 @@ public class PlanBatchTaskDataUpdateJob {
                 if (ObjectUtil.isNotNull(planInfo)) {
                     // 是则更新计划表
                     planInfo.setStatus(planStatus);
-                planInfo.setWaitingNum(waitTotal);
+                    planInfo.setWaitingNum(waitCount);
-                planInfo.setRunningNum(runningTotal);
+                    planInfo.setRunningNum(ingCount);
-                planInfo.setSuccessNum(successTotal);
+                    planInfo.setSuccessNum(planBatch.getSuccessNum());
-                planInfo.setExecFailNum(failTotal);
+                    planInfo.setExecFailNum(planBatch.getExecFailNum());
-                planInfo.setAssertFailNum(assertFailTotal);
+                    planInfo.setAssertFailNum(planBatch.getAssertFailNum());
-                planInfo.setTimeoutNum(timeoutTotal);
+                    planInfo.setTimeoutNum(planBatch.getTimeoutNum());
-                planInfo.setCancelNum(cancelTotal);
+                    planInfo.setCancelNum(planBatch.getCancelNum());
                     //不用代码生成的方法
                     planInfoService.updatePlanResultById(planInfo);
                 }
@@ -276,6 +310,11 @@ public class PlanBatchTaskDataUpdateJob {
                 }
             });
             logger.debug("同步缓存中计划批次统计数据----end----");
+        } catch (Exception e) {
+            logger.error("批次统计数据执行发生异常", e);
+        } finally {
+            lock.unlock();
+        }
     }
 
     /**
@@ -710,4 +749,37 @@ public class PlanBatchTaskDataUpdateJob {
         // 绑定脚本
         planScriptLinkService.insertByBatch(scriptLinkList);
     }
+
+    /**
+     * 用于确定脚本的执行结果状态
+     * @param statusSet 脚本下的所有任务状态
+     * @return
+     */
+    private String scriptStatus(Set<String> statusSet) {
+        String status = PlanConstant.TASK_EXECUTE_SUCCESS_STATUS;   // 默认成功
+        if (statusSet == null || statusSet.isEmpty()) { // 如果状态为空，那么脚本成功
+            return status;
+        }
+        boolean flag = statusSet.remove(PlanConstant.TASK_WAIT_EXECUTE_STATUS);
+        if (flag) { // 如果存在等待（0）
+            if (statusSet.isEmpty()) {  // 全都是等待（0）
+                status = PlanConstant.TASK_WAIT_EXECUTE_STATUS;
+            } else {    // 还有其他状态
+                status = PlanConstant.TASK_START_EXECUTE_STATUS;
+            }
+        } else {    // 不存在等待（0）
+            if (statusSet.remove(PlanConstant.TASK_START_EXECUTE_STATUS)) {  // 存在执行中(1)
+                status = PlanConstant.TASK_START_EXECUTE_STATUS;
+            } else if (statusSet.remove(PlanConstant.TASK_CANCEL_STATUS)) {  // 存在取消（5）
+                status = PlanConstant.TASK_CANCEL_STATUS;
+            } else if (statusSet.remove(PlanConstant.TASK_TIMEOUT_STATUS)) { // 存在超时（6）
+                status = PlanConstant.TASK_TIMEOUT_STATUS;
+            } else if (statusSet.remove(PlanConstant.TASK_ASSERT_FAIL_STATUS)) {   // 存在断言失败（4）
+                status = PlanConstant.TASK_ASSERT_FAIL_STATUS;
+            } else if (statusSet.remove(PlanConstant.TASK_EXECUTE_FAIL_STATUS)) {    // 存在执行失败（3）
+                status = PlanConstant.TASK_EXECUTE_FAIL_STATUS;
+            }
+        }
+        return status;
+    }
 }

cctp-atu/atu-execute-plan/src/main/resources/mybatis/ext/AtuPlanTask.Dao.xml

@@ -366,4 +366,35 @@
   <select id="queryAllFailIdList" resultType="java.lang.String">
     select id from <include refid="Table_Name"/> where batch_id = #{batchId} and status in ("3", "4", "6")
   </select>
+
+  <resultMap id="taskStatusMap" type="net.northking.cctp.executePlan.dto.planTask.ScriptStatusStatistic">
+    <!-- 脚本id -->
+    <result column="script_id" jdbcType="VARCHAR" property="scriptId"/>
+    <!-- 状态字符串 -->
+    <result column="task_status" jdbcType="VARCHAR" property="statusString"/>
+    <!-- 任务数量   -->
+    <result column="total" jdbcType="INTEGER" property="total" />
+  </resultMap>
+
+  <select id="countTaskStatus" parameterType="net.northking.cctp.executePlan.db.entity.AtuPlanTask" resultMap="taskStatusMap">
+    SELECT
+    script_id,
+    group_concat(status) as task_status,
+    count(*) as total
+    FROM <include refid="Table_Name" />
+    WHERE
+    batch_id = #{task.batchId,jdbcType=VARCHAR}
+    GROUP BY script_id
+  </select>
+
+  <update id="batchUpdateTaskStatusToTimeout" >
+    UPDATE
+    <include refid="Table_Name" />
+    SET
+    `status` = #{timeoutStatus,jdbcType=VARCHAR}
+    WHERE
+    batch_id = #{batchId,jdbcType=VARCHAR}
+    AND
+    (`status` = #{waitStatus, jdbcType=VARCHAR} or `status` = #{timeoutStatus, jdbcType=VARCHAR})
+  </update>
 </mapper>