yineng.huang
/
hz
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix：执行计划 

1.任务批量重试的逻辑添加锁进行控制。
hz_1122
李杰应 2024-12-11 19:28:32 +08:00
parent 6b3e0333be
commit 58c743a889
3 changed files with 261 additions and 239 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

493
cctp-atu/atu-execute-plan/src/main/java/net/northking/cctp/executePlan/api/service/AtuPlanTaskApiServiceImpl.java
View File

@ -74,6 +74,7 @@ import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders; import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType; import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity; import org.springframework.http.ResponseEntity;
import org.springframework.integration.redis.util.RedisLockRegistry;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional; import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils; import org.springframework.util.CollectionUtils;
@ -82,6 +83,7 @@ import org.springframework.web.client.RestTemplate;
import java.io.*; import java.io.*;
import java.time.LocalDate; import java.time.LocalDate;
import java.util.*; import java.util.*;
import java.util.concurrent.locks.Lock;
import java.util.function.Function; import java.util.function.Function;
import java.util.stream.Collectors; import java.util.stream.Collectors;
@ -148,6 +150,9 @@ public class AtuPlanTaskApiServiceImpl extends AbstractExcelService<AtuPlanTask>
@Autowired @Autowired
private AttachmentFeignClient attachmentFeignClient; private AttachmentFeignClient attachmentFeignClient;
@Autowired
private RedisLockRegistry redisLockRegistry;
@Value("${zmn.hostStr}") @Value("${zmn.hostStr}")
private String hostStr; private String hostStr;
@ -1477,264 +1482,274 @@ public class AtuPlanTaskApiServiceImpl extends AbstractExcelService<AtuPlanTask>
PlanConstant.BATCH_EXECUTING_STATUS.equals(planBatch.getStatus())) { PlanConstant.BATCH_EXECUTING_STATUS.equals(planBatch.getStatus())) {
throw new PlatformRuntimeException(ExecPlanError.BATCH_NOT_FINISH); throw new PlatformRuntimeException(ExecPlanError.BATCH_NOT_FINISH);
} }
logger.debug("根据批次编号[{}]查询计划信息", firstFailTask.getBatchId()); // 加个锁，当选择的任务量比较多的时候，需要时间进行处理
AtuPlanInfo planInfo = atuPlanInfoApiService.findByBatchId(firstFailTask.getBatchId()); Lock lock = redisLockRegistry.obtain(String.format("%s%s", RedisConstant.PLAN_BATCH_RETRY_LOCK_PRE, planBatch.getId()));
if (planInfo == null) { if (!lock.tryLock()) {
throw new PlatformRuntimeException(ExecPlanError.PLAN_IS_NULL); // 获取不到锁，正在处理重试
throw new PlatformRuntimeException(ExecPlanError.BATCH_IS_DEALING_WITH_RETRY);
} }
try {
logger.debug("根据批次编号[{}]查询计划信息", firstFailTask.getBatchId());
AtuPlanInfo planInfo = atuPlanInfoApiService.findByBatchId(firstFailTask.getBatchId());
if (planInfo == null) {
throw new PlatformRuntimeException(ExecPlanError.PLAN_IS_NULL);
}
logger.debug("更新计划和批次状态"); logger.debug("更新计划和批次状态");
String planStatus = ""; String planStatus = "";
if (planBatch.getTaskTotal() > retryDto.getTaskIdList().size()) { if (planBatch.getTaskTotal() > retryDto.getTaskIdList().size()) {
logger.debug("部分任务重试，批次状态为：{}，计划状态为：{}", PlanConstant.BATCH_EXECUTING_STATUS, logger.debug("部分任务重试，批次状态为：{}，计划状态为：{}", PlanConstant.BATCH_EXECUTING_STATUS,
PlanConstant.PLAN_EXECUTING_STATUS); PlanConstant.PLAN_EXECUTING_STATUS);
planBatch.setStatus(PlanConstant.BATCH_EXECUTING_STATUS); planBatch.setStatus(PlanConstant.BATCH_EXECUTING_STATUS);
planStatus = PlanConstant.PLAN_EXECUTING_STATUS; planStatus = PlanConstant.PLAN_EXECUTING_STATUS;
} else { } else {
logger.debug("全部任务重试，批次状态为：{}，计划状态为：{}", PlanConstant.BATCH_WAITING_STATUS, logger.debug("全部任务重试，批次状态为：{}，计划状态为：{}", PlanConstant.BATCH_WAITING_STATUS,
PlanConstant.PLAN_WAITING_STATUS); PlanConstant.PLAN_WAITING_STATUS);
planBatch.setStatus(PlanConstant.BATCH_WAITING_STATUS); planBatch.setStatus(PlanConstant.BATCH_WAITING_STATUS);
planStatus = PlanConstant.PLAN_WAITING_STATUS; planStatus = PlanConstant.PLAN_WAITING_STATUS;
}
List<String> deletedFilePath = new ArrayList<>();
List<String> taskIds = new ArrayList<>();
planTaskList.forEach(task -> {
logger.info("普通脚本任务id：{}，执行结果文件：{}", task.getId(), task.getExecResultFile());
taskIds.add(task.getId());
String execResultFile = task.getExecResultFile();
if (StringUtils.isNotBlank(execResultFile)){
deletedFilePath.add(execResultFile);
getActualImagePath(deletedFilePath, execResultFile);
} }
String perDataPath = task.getPerDataPath(); List<String> deletedFilePath = new ArrayList<>();
if (StringUtils.isNotBlank(perDataPath)) { List<String> taskIds = new ArrayList<>();
deletedFilePath.add("/" + MinioPathUtils.idToPath(perDataPath)[1]); planTaskList.forEach(task -> {
} logger.info("普通脚本任务id：{}，执行结果文件：{}", task.getId(), task.getExecResultFile());
String videoUrl = task.getVideoUrl(); taskIds.add(task.getId());
if (StringUtils.isNotBlank(videoUrl)) { String execResultFile = task.getExecResultFile();
deletedFilePath.add("/" + MinioPathUtils.idToPath(videoUrl)[1]); if (StringUtils.isNotBlank(execResultFile)){
}
// 场景用例脚本json是单独的需要删除
if (task.getCaseType().equals("5")) {
deletedFilePath.add("/" + MinioPathUtils.idToPath(task.getScriptJson())[1]);
}
});
if (!CollectionUtils.isEmpty(taskIds)) {
List<AtuPlanSceneCaseTask> atuPlanSceneCaseTaskList = atuPlanSceneCaseTaskService.querySceneCaseTasksByTaskIds(taskIds);
atuPlanSceneCaseTaskList.forEach(atuPlanSceneCaseTask -> {
logger.info("场景任务id：{}，节点任务id：{}，执行结果文件：{}", atuPlanSceneCaseTask.getTaskId(),atuPlanSceneCaseTask.getId(), atuPlanSceneCaseTask.getExecResultFile());
String videoUrl = atuPlanSceneCaseTask.getVideoUrl();
if (StringUtils.isNotBlank(videoUrl)) {
deletedFilePath.add("/" + MinioPathUtils.idToPath(videoUrl)[1]);
}
String perDataPath = atuPlanSceneCaseTask.getPerDataPath();
if (StringUtils.isNotBlank(perDataPath)) {
deletedFilePath.add("/" + MinioPathUtils.idToPath(perDataPath)[1]);
}
String execResultFile = atuPlanSceneCaseTask.getExecResultFile();
if (StringUtils.isNotBlank(execResultFile)) {
deletedFilePath.add(execResultFile); deletedFilePath.add(execResultFile);
getActualImagePath(deletedFilePath, execResultFile); getActualImagePath(deletedFilePath, execResultFile);
} }
String perDataPath = task.getPerDataPath();
if (StringUtils.isNotBlank(perDataPath)) {
deletedFilePath.add("/" + MinioPathUtils.idToPath(perDataPath)[1]);
}
String videoUrl = task.getVideoUrl();
if (StringUtils.isNotBlank(videoUrl)) {
deletedFilePath.add("/" + MinioPathUtils.idToPath(videoUrl)[1]);
}
// 场景用例脚本json是单独的需要删除
if (task.getCaseType().equals("5")) {
deletedFilePath.add("/" + MinioPathUtils.idToPath(task.getScriptJson())[1]);
}
}); });
} if (!CollectionUtils.isEmpty(taskIds)) {
if (!CollectionUtils.isEmpty(deletedFilePath)) { List<AtuPlanSceneCaseTask> atuPlanSceneCaseTaskList = atuPlanSceneCaseTaskService.querySceneCaseTasksByTaskIds(taskIds);
AssociatedFilesDto associatedFilesDto = new AssociatedFilesDto(); atuPlanSceneCaseTaskList.forEach(atuPlanSceneCaseTask -> {
associatedFilesDto.setObjId("-1"); logger.info("场景任务id：{}，节点任务id：{}，执行结果文件：{}", atuPlanSceneCaseTask.getTaskId(),atuPlanSceneCaseTask.getId(), atuPlanSceneCaseTask.getExecResultFile());
associatedFilesDto.setFileIds(deletedFilePath); String videoUrl = atuPlanSceneCaseTask.getVideoUrl();
attachmentFeignClient.associatedFiles(associatedFilesDto); if (StringUtils.isNotBlank(videoUrl)) {
} deletedFilePath.add("/" + MinioPathUtils.idToPath(videoUrl)[1]);
planBatchApiService.updateByEntity(planBatch);
atuPlanInfoApiService.updateStatusByLastBatchId(planBatch.getId(), planStatus);
logger.info("查询计划数据集中未被选择的意图数据");
Set<String> scriptIdSet = new HashSet<>();
Map<String, List<String>> envScriptMap = new HashMap<>();
Map<String, List<AtuPlanTask>> envScriptTaskMap = new HashMap<>();
List<String> taskIdList = new ArrayList<>();
for (AtuPlanTask planTask : planTaskList) {
taskIdList.add(planTask.getId());
scriptIdSet.add(planTask.getScriptId());
List<String> scriptIdList = new ArrayList<>();
if (envScriptMap.containsKey(planTask.getEnvId())) {
scriptIdList = envScriptMap.get(planTask.getEnvId());
}
scriptIdList.add(planTask.getScriptId());
envScriptMap.put(planTask.getEnvId(), scriptIdList);
String key = planTask.getEnvId() + "-" + planTask.getScriptId();
List<AtuPlanTask> envScriptTaskList = new ArrayList<>();
if (envScriptTaskMap.containsKey(key)) {
envScriptTaskList = envScriptTaskMap.get(key);
}
envScriptTaskList.add(planTask);
envScriptTaskMap.put(key, envScriptTaskList);
}
logger.debug("获取最新的输入项数据");
Map<String, String> taskParamsMap = getRetryTaskInputInfo(envScriptTaskMap, envScriptMap);
logger.debug("最新输入项数据大小：{}", taskParamsMap.size());
logger.debug("start 初始化批次缓存数据");
taskRetryInitCache(taskIdList, planBatch);
logger.debug("end 初始化批次缓存数据");
logger.debug("查询脚本最新数据");
logger.debug("脚本数量：{}", scriptIdSet.size());
Map<String, AtuScriptDetailDto> scriptMap = queryScriptDetailMap(scriptIdSet);
logger.debug("脚本最新信息数量：{}", scriptMap.size());
Map<String, Object> caseTypeMap = new HashMap<>();
caseTypeMap.put("hasPc", false);
caseTypeMap.put("hasMob", false);
caseTypeMap.put("hasInterface", false);
for (AtuPlanTask planTask : planTaskList) {
String status = planTask.getStatus();
logger.debug("原任务状态为： {}", status);
// 判断任务是否开始执行
if (PlanConstant.TASK_WAIT_EXECUTE_STATUS.equals(planTask.getStatus()) ||
PlanConstant.TASK_START_EXECUTE_STATUS.equals(planTask.getStatus())) {
throw new PlatformRuntimeException(ExecPlanError.TASK_NOT_FINISH);
}
logger.debug("修改任务脚本为最新脚本信息");
if (scriptMap.containsKey(planTask.getScriptId())) {
AtuScriptDetailDto atuScriptDetailDto = scriptMap.get(planTask.getScriptId());
planTask.setVersionId(atuScriptDetailDto.getVersionId());
planTask.setVersionName(atuScriptDetailDto.getVersionName());
planTask.setScriptName(atuScriptDetailDto.getScriptName());
planTask.setScriptJson(atuScriptDetailDto.getScriptPath());
planTask.setAppId(queryAppId(planInfo.getId(),atuScriptDetailDto.getPlatformType(),
atuScriptDetailDto.getAppPackage(),atuScriptDetailDto.getScriptType()));
}
logger.debug("生成任务执行信息");
AtuTaskExecDto taskExecDto = new AtuTaskExecDto();
BeanUtil.copyProperties(planInfo, taskExecDto);
taskExecDto.setPlanId(planInfo.getId());
taskExecDto.setFailRetryNum(planInfo.getFailRetryCount());
taskExecDto.setBatchId(planTask.getBatchId());
taskExecDto.setTaskId(planTask.getId());
taskExecDto.setCaseId(planTask.getCaseId());
taskExecDto.setEnvId(planTask.getEnvId());
String type = planTask.getCaseType();
taskExecDto.setCaseType(type);
String scriptPath = planTask.getScriptJson();
Map<String, Object> caseParams = new HashMap<>();
if (taskParamsMap.containsKey(planTask.getId())) {
logger.debug("重试使用新数据");
caseParams = JSONUtil.toBean(taskParamsMap.get(planTask.getId()), Map.class);
} else {
if (StrUtil.isNotBlank(planTask.getCaseParam())) {
logger.debug("使用旧数据重试");
caseParams = JSONUtil.toBean(planTask.getCaseParam(), Map.class);
}
}
// 更新静态数据与模糊数据为最新值
caseParams = this.handleQuoteData(caseParams, planTask.getEnvId(), planInfo.getProjectId());
planTask.setCaseParam(JSONUtil.toJsonStr(caseParams));
String appId = planTask.getAppId();
AtuSceneNodeExecDto sceneNodeExecDto = null;
//判断是否场景任务
if (PlanConstant.SCRIPT_TYPE_SCENE.equals(planTask.getCaseType())) {
// 调用脚本服务获取场景首节点信息，通知脚本服务场景重新发起
logger.debug("查询场景脚本的首节点信息");
SceneFirstNodeDto firstNodeDto = new SceneFirstNodeDto();
firstNodeDto.setTaskId(planTask.getId());
firstNodeDto.setCaseId(planTask.getCaseId());
String scriptId = planTask.getScriptId();
firstNodeDto.setScriptId(scriptId);
firstNodeDto.setParamMap(caseParams);
logger.debug("查询参数 => {}", JSONUtil.toJsonStr(firstNodeDto));
AtuSceneNodeInfoDto nodeInfo;
try {
ResultWrapper<AtuSceneNodeExecDto> firstNodeResult = publicFeignClient.getFirstNode(firstNodeDto);
if (firstNodeResult.isSuccess() && firstNodeResult.getData() != null) {
logger.debug("首节点信息为 => " + JSONUtil.toJsonStr(firstNodeResult));
sceneNodeExecDto = firstNodeResult.getData();
nodeInfo = sceneNodeExecDto.getNodeInfo();
} else {
throw new RuntimeException("获取场景脚本[ " + scriptId + "]首节点信息异常，" + firstNodeResult.getMessage());
} }
} catch (Exception e) { String perDataPath = atuPlanSceneCaseTask.getPerDataPath();
logger.error("获取场景首节点信息异常", e); if (StringUtils.isNotBlank(perDataPath)) {
throw new PlatformRuntimeException(ExecPlanError.GET_SCENE_FIRST_NODE_FAIL); deletedFilePath.add("/" + MinioPathUtils.idToPath(perDataPath)[1]);
}
String execResultFile = atuPlanSceneCaseTask.getExecResultFile();
if (StringUtils.isNotBlank(execResultFile)) {
deletedFilePath.add(execResultFile);
getActualImagePath(deletedFilePath, execResultFile);
}
});
}
if (!CollectionUtils.isEmpty(deletedFilePath)) {
AssociatedFilesDto associatedFilesDto = new AssociatedFilesDto();
associatedFilesDto.setObjId("-1");
associatedFilesDto.setFileIds(deletedFilePath);
attachmentFeignClient.associatedFiles(associatedFilesDto);
}
planBatchApiService.updateByEntity(planBatch);
atuPlanInfoApiService.updateStatusByLastBatchId(planBatch.getId(), planStatus);
logger.info("查询计划数据集中未被选择的意图数据");
Set<String> scriptIdSet = new HashSet<>();
Map<String, List<String>> envScriptMap = new HashMap<>();
Map<String, List<AtuPlanTask>> envScriptTaskMap = new HashMap<>();
List<String> taskIdList = new ArrayList<>();
for (AtuPlanTask planTask : planTaskList) {
taskIdList.add(planTask.getId());
scriptIdSet.add(planTask.getScriptId());
List<String> scriptIdList = new ArrayList<>();
if (envScriptMap.containsKey(planTask.getEnvId())) {
scriptIdList = envScriptMap.get(planTask.getEnvId());
} }
if (ObjectUtil.isNull(nodeInfo)) { scriptIdList.add(planTask.getScriptId());
throw new PlatformRuntimeException(ExecPlanError.SCENE_FIRST_NODE_INFO_IS_NULL); envScriptMap.put(planTask.getEnvId(), scriptIdList);
String key = planTask.getEnvId() + "-" + planTask.getScriptId();
List<AtuPlanTask> envScriptTaskList = new ArrayList<>();
if (envScriptTaskMap.containsKey(key)) {
envScriptTaskList = envScriptTaskMap.get(key);
}
envScriptTaskList.add(planTask);
envScriptTaskMap.put(key, envScriptTaskList);
}
logger.debug("获取最新的输入项数据");
Map<String, String> taskParamsMap = getRetryTaskInputInfo(envScriptTaskMap, envScriptMap);
logger.debug("最新输入项数据大小：{}", taskParamsMap.size());
logger.debug("start 初始化批次缓存数据");
taskRetryInitCache(taskIdList, planBatch);
logger.debug("end 初始化批次缓存数据");
logger.debug("查询脚本最新数据");
logger.debug("脚本数量：{}", scriptIdSet.size());
Map<String, AtuScriptDetailDto> scriptMap = queryScriptDetailMap(scriptIdSet);
logger.debug("脚本最新信息数量：{}", scriptMap.size());
Map<String, Object> caseTypeMap = new HashMap<>();
caseTypeMap.put("hasPc", false);
caseTypeMap.put("hasMob", false);
caseTypeMap.put("hasInterface", false);
for (AtuPlanTask planTask : planTaskList) {
String status = planTask.getStatus();
logger.debug("原任务状态为： {}", status);
// 判断任务是否开始执行
if (PlanConstant.TASK_WAIT_EXECUTE_STATUS.equals(planTask.getStatus()) ||
PlanConstant.TASK_START_EXECUTE_STATUS.equals(planTask.getStatus())) {
throw new PlatformRuntimeException(ExecPlanError.TASK_NOT_FINISH);
}
logger.debug("修改任务脚本为最新脚本信息");
if (scriptMap.containsKey(planTask.getScriptId())) {
AtuScriptDetailDto atuScriptDetailDto = scriptMap.get(planTask.getScriptId());
planTask.setVersionId(atuScriptDetailDto.getVersionId());
planTask.setVersionName(atuScriptDetailDto.getVersionName());
planTask.setScriptName(atuScriptDetailDto.getScriptName());
planTask.setScriptJson(atuScriptDetailDto.getScriptPath());
planTask.setAppId(queryAppId(planInfo.getId(),atuScriptDetailDto.getPlatformType(),
atuScriptDetailDto.getAppPackage(),atuScriptDetailDto.getScriptType()));
} }
String sceneTaskId = IdUtil.simpleUUID(); logger.debug("生成任务执行信息");
taskExecDto.setTaskId(sceneTaskId); AtuTaskExecDto taskExecDto = new AtuTaskExecDto();
scriptPath = nodeInfo.getScriptPath(); BeanUtil.copyProperties(planInfo, taskExecDto);
caseParams = nodeInfo.getCaseParam(); taskExecDto.setPlanId(planInfo.getId());
appId = queryAppId(taskExecDto.getPlanId(), nodeInfo.getPlatformType(), taskExecDto.setFailRetryNum(planInfo.getFailRetryCount());
nodeInfo.getAppPackage(), nodeInfo.getNodeType()); taskExecDto.setBatchId(planTask.getBatchId());
type = nodeInfo.getNodeType(); taskExecDto.setTaskId(planTask.getId());
taskExecDto.setCaseId(planTask.getCaseId());
taskExecDto.setEnvId(planTask.getEnvId());
String type = planTask.getCaseType();
taskExecDto.setCaseType(type);
String scriptPath = planTask.getScriptJson();
logger.debug("清理原节点任务"); Map<String, Object> caseParams = new HashMap<>();
AtuPlanSceneCaseTask deleteParams = new AtuPlanSceneCaseTask(); if (taskParamsMap.containsKey(planTask.getId())) {
deleteParams.setTaskId(planTask.getId()); logger.debug("重试使用新数据");
int rows = atuPlanSceneCaseTaskService.deleteByExample(deleteParams); caseParams = JSONUtil.toBean(taskParamsMap.get(planTask.getId()), Map.class);
} else {
if (StrUtil.isNotBlank(planTask.getCaseParam())) {
logger.debug("使用旧数据重试");
caseParams = JSONUtil.toBean(planTask.getCaseParam(), Map.class);
}
}
// 更新静态数据与模糊数据为最新值
caseParams = this.handleQuoteData(caseParams, planTask.getEnvId(), planInfo.getProjectId());
planTask.setCaseParam(JSONUtil.toJsonStr(caseParams));
String appId = planTask.getAppId();
AtuSceneNodeExecDto sceneNodeExecDto = null;
//判断是否场景任务
if (PlanConstant.SCRIPT_TYPE_SCENE.equals(planTask.getCaseType())) {
// 调用脚本服务获取场景首节点信息，通知脚本服务场景重新发起
logger.debug("查询场景脚本的首节点信息");
SceneFirstNodeDto firstNodeDto = new SceneFirstNodeDto();
firstNodeDto.setTaskId(planTask.getId());
firstNodeDto.setCaseId(planTask.getCaseId());
String scriptId = planTask.getScriptId();
firstNodeDto.setScriptId(scriptId);
firstNodeDto.setParamMap(caseParams);
logger.debug("查询参数 => {}", JSONUtil.toJsonStr(firstNodeDto));
AtuSceneNodeInfoDto nodeInfo;
try {
ResultWrapper<AtuSceneNodeExecDto> firstNodeResult = publicFeignClient.getFirstNode(firstNodeDto);
if (firstNodeResult.isSuccess() && firstNodeResult.getData() != null) {
logger.debug("首节点信息为 => " + JSONUtil.toJsonStr(firstNodeResult));
sceneNodeExecDto = firstNodeResult.getData();
nodeInfo = sceneNodeExecDto.getNodeInfo();
} else {
throw new RuntimeException("获取场景脚本[ " + scriptId + "]首节点信息异常，" + firstNodeResult.getMessage());
}
} catch (Exception e) {
logger.error("获取场景首节点信息异常", e);
throw new PlatformRuntimeException(ExecPlanError.GET_SCENE_FIRST_NODE_FAIL);
}
if (ObjectUtil.isNull(nodeInfo)) {
throw new PlatformRuntimeException(ExecPlanError.SCENE_FIRST_NODE_INFO_IS_NULL);
}
String sceneTaskId = IdUtil.simpleUUID();
taskExecDto.setTaskId(sceneTaskId);
scriptPath = nodeInfo.getScriptPath();
caseParams = nodeInfo.getCaseParam();
appId = queryAppId(taskExecDto.getPlanId(), nodeInfo.getPlatformType(),
nodeInfo.getAppPackage(), nodeInfo.getNodeType());
type = nodeInfo.getNodeType();
logger.debug("清理原节点任务");
AtuPlanSceneCaseTask deleteParams = new AtuPlanSceneCaseTask();
deleteParams.setTaskId(planTask.getId());
int rows = atuPlanSceneCaseTaskService.deleteByExample(deleteParams);
if (rows <= 0) {
logger.error("清理原场景节点任务失败");
throw new PlatformRuntimeException(ExecPlanError.CLEAR_SCENE_NODE_TASK_FAIL);
}
logger.debug("插入新节点任务");
AtuPlanSceneCaseTask planSceneCaseTask = new AtuPlanSceneCaseTask();
planSceneCaseTask.setId(sceneTaskId);
planSceneCaseTask.setTaskId(planTask.getId());
planSceneCaseTask.setScriptId(nodeInfo.getScriptId());
planSceneCaseTask.setVersionId(nodeInfo.getVersionId());
planSceneCaseTask.setVersionName(nodeInfo.getVersionName());
planSceneCaseTask.setScriptName(nodeInfo.getScriptName());
planSceneCaseTask.setScriptJson(nodeInfo.getScriptPath());
planSceneCaseTask.setNodeId(nodeInfo.getNodeId());
planSceneCaseTask.setNodeType(nodeInfo.getNodeType());
if (CollUtil.isNotEmpty(nodeInfo.getCaseParam())) {
planSceneCaseTask.setNodeParams(JSONUtil.toJsonStr(nodeInfo.getCaseParam()));
}
planSceneCaseTask.setCreatedTime(new Date());
planSceneCaseTask.setStatus(PlanConstant.TASK_WAIT_EXECUTE_STATUS);
planSceneCaseTask.setScriptJson(nodeInfo.getScriptPath());
atuPlanSceneCaseTaskService.insert(planSceneCaseTask);
}
taskExecDto.setScriptPath(scriptPath);
taskExecDto.setCaseParams(caseParams);
taskExecDto.setAppId(appId);
logger.debug("修改原任务状态");
planTask.setEngineId("");
planTask.setDeviceId("");
planTask.setAppId("");
planTask.setStatus(PlanConstant.TASK_WAIT_EXECUTE_STATUS);
planTask.setStartTime(null);
planTask.setEndTime(null);
planTask.setErrorMsg("");
planTask.setVideoUrl("");
planTask.setExecResultFile("");
planTask.setBugId("");
if (sceneNodeExecDto != null && sceneNodeExecDto.getSceneScriptUrl() != null) {
planTask.setScriptJson(sceneNodeExecDto.getSceneScriptUrl());
}else {
logger.info("首节点返回sceneScriptUrl为空" + sceneNodeExecDto);
}
int rows = atuPlanTaskService.updateByPrimaryKey(planTask);
if (rows <= 0) { if (rows <= 0) {
logger.error("清理原场景节点任务失败"); throw new PlatformRuntimeException(ExecPlanError.INIT_TASK_INFO_FAIL);
throw new PlatformRuntimeException(ExecPlanError.CLEAR_SCENE_NODE_TASK_FAIL);
} }
logger.debug("插入新节点任务");
AtuPlanSceneCaseTask planSceneCaseTask = new AtuPlanSceneCaseTask();
planSceneCaseTask.setId(sceneTaskId);
planSceneCaseTask.setTaskId(planTask.getId());
planSceneCaseTask.setScriptId(nodeInfo.getScriptId());
planSceneCaseTask.setVersionId(nodeInfo.getVersionId());
planSceneCaseTask.setVersionName(nodeInfo.getVersionName());
planSceneCaseTask.setScriptName(nodeInfo.getScriptName());
planSceneCaseTask.setScriptJson(nodeInfo.getScriptPath());
planSceneCaseTask.setNodeId(nodeInfo.getNodeId());
planSceneCaseTask.setNodeType(nodeInfo.getNodeType());
if (CollUtil.isNotEmpty(nodeInfo.getCaseParam())) {
planSceneCaseTask.setNodeParams(JSONUtil.toJsonStr(nodeInfo.getCaseParam()));
}
planSceneCaseTask.setCreatedTime(new Date());
planSceneCaseTask.setStatus(PlanConstant.TASK_WAIT_EXECUTE_STATUS);
planSceneCaseTask.setScriptJson(nodeInfo.getScriptPath());
atuPlanSceneCaseTaskService.insert(planSceneCaseTask);
} logger.debug("发送任务执行信息至消息队列");
taskExecDto.setScriptPath(scriptPath); sendToQueue(taskExecDto.getBatchId(), taskExecDto, type);
taskExecDto.setCaseParams(caseParams);
taskExecDto.setAppId(appId);
logger.debug("修改原任务状态"); atuPlanInfoApiService.handleAutoType(PlanConstant.SCRIPT_TYPE_SCENE, caseTypeMap);
planTask.setEngineId("");
planTask.setDeviceId("");
planTask.setAppId("");
planTask.setStatus(PlanConstant.TASK_WAIT_EXECUTE_STATUS);
planTask.setStartTime(null);
planTask.setEndTime(null);
planTask.setErrorMsg("");
planTask.setVideoUrl("");
planTask.setExecResultFile("");
planTask.setBugId("");
if (sceneNodeExecDto != null && sceneNodeExecDto.getSceneScriptUrl() != null) {
planTask.setScriptJson(sceneNodeExecDto.getSceneScriptUrl());
}else {
logger.info("首节点返回sceneScriptUrl为空" + sceneNodeExecDto);
}
int rows = atuPlanTaskService.updateByPrimaryKey(planTask);
if (rows <= 0) {
throw new PlatformRuntimeException(ExecPlanError.INIT_TASK_INFO_FAIL);
} }
logger.debug("发送任务执行信息至消息队列"); logger.debug("计划批次重新发起委托");
sendToQueue(taskExecDto.getBatchId(), taskExecDto, type); atuPlanInfoApiService.handlePlanDevice(planInfo.getId(), planInfo.getPriority(), planBatch.getId(),
retryDto.getHasOfflineDevice(), caseTypeMap, true);
atuPlanInfoApiService.handleAutoType(PlanConstant.SCRIPT_TYPE_SCENE, caseTypeMap); return true;
} finally {
lock.unlock();
} }
logger.debug("计划批次重新发起委托");
atuPlanInfoApiService.handlePlanDevice(planInfo.getId(), planInfo.getPriority(), planBatch.getId(),
retryDto.getHasOfflineDevice(), caseTypeMap, true);
return true;
} }
@Override @Override

5
cctp-atu/atu-execute-plan/src/main/java/net/northking/cctp/executePlan/constants/RedisConstant.java
View File

@ -59,4 +59,9 @@ public class RedisConstant {
*/ */
public static final String BATCH_MESSAGE_LOCK_PRE = "BATCH_MESSAGE_LOCK_PRE"; public static final String BATCH_MESSAGE_LOCK_PRE = "BATCH_MESSAGE_LOCK_PRE";
/**
*
*/
public static final String PLAN_BATCH_RETRY_LOCK_PRE = "LOCK:PLAN:PLAN-BATCH-RETRY-LOCK-PRE:";
} }

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

@ -89,6 +89,8 @@ public enum ExecPlanError implements PlatformError {
GET_FILE_FAIL("获取文件失败"), GET_FILE_FAIL("获取文件失败"),
BATCH_IS_DEALING_WITH_RETRY("批次的任务重试正在处理中..."),
/** /**
* 错误码结束值 * 错误码结束值
*/ */