commit

api-common/src/main/java/api/common/pojo/param/scene/SceneEvaluationComputeParam.java

@@ -17,16 +17,14 @@ import java.util.List;
 @AllArgsConstructor
 public class SceneEvaluationComputeParam implements Serializable {
 
-    // 场景评价规则 Id
-    private String sceneId;
-    private List<String> copySceneId;
-    private String sceneXOSCPath;
-    private String sceneXODRPath;
-    private String sceneType;
-    private String taskId;
-    private String computeType;
-    private String evaluationPath;
+    // 场景评价规则 id
+    private String sceneEvaluationRuleId;
+    private String linuxTempPath;
+    private String bucketName;
+    private String createUserId;
     private String vehicleId;
     private String algorithmId;
-    private String createUserId;
+    private String taskId;
+    private String computeType;
+    private List<SceneEvaluationComputeSubParam> sceneEvaluationComputeSubParam;
 }

api-common/src/main/java/api/common/pojo/param/scene/SceneEvaluationComputeSubParam.java

@@ -0,0 +1,27 @@
+package api.common.pojo.param.scene;
+
+import lombok.*;
+
+import java.io.Serializable;
+import java.util.List;
+
+/**
+ * 场景评价规则
+ *
+ * @author lcy
+ */
+@EqualsAndHashCode()
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class SceneEvaluationComputeSubParam implements Serializable {
+
+    // 场景评价规则 Id
+    private String sceneId;
+    private List<String> copySceneId;
+    private String sceneXOSCPath;
+    private String sceneXODRPath;
+    private String sceneType;
+    private String evaluationPath;
+}

simulation-resource-scheduler/src/main/java/com/css/simulation/resource/scheduler/adapter/controller/SceneEvaluationController.java

@@ -0,0 +1,27 @@
+package com.css.simulation.resource.scheduler.adapter.controller;
+
+
+import api.common.pojo.common.ResponseBodyVO;
+import api.common.pojo.param.scene.SceneEvaluationComputeParam;
+import com.css.simulation.resource.scheduler.domain.service.TaskDomainService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+
+import javax.annotation.Resource;
+
+@Controller
+@Slf4j
+@RequestMapping("/")
+public class SceneEvaluationController {
+
+    @Resource
+    private TaskDomainService taskDomainService;
+
+    @GetMapping("/computeSceneEvaluation")
+    public ResponseBodyVO<String> computeSceneEvaluation(SceneEvaluationComputeParam sceneEvaluationComputeParam) {
+        taskDomainService.computeSceneEvaluation(sceneEvaluationComputeParam);
+        return new ResponseBodyVO<>(ResponseBodyVO.Response.SUCCESS);
+    }
+}

simulation-resource-scheduler/src/main/java/com/css/simulation/resource/scheduler/domain/service/TaskDomainService.java

@@ -2,7 +2,7 @@ package com.css.simulation.resource.scheduler.domain.service;
 
 import api.common.pojo.constants.DictConstants;
 import api.common.pojo.param.scene.SceneEvaluationComputeParam;
-import api.common.pojo.param.scene.SceneImportParam;
+import api.common.pojo.param.scene.SceneEvaluationComputeSubParam;
 import api.common.util.*;
 import com.alibaba.druid.util.StringUtils;
 import com.css.simulation.resource.scheduler.app.repository.TaskIndexRepository;
@@ -72,12 +72,6 @@ public class TaskDomainService {
     @Resource
     private CustomConfiguration customConfiguration;
     @Resource
-    private SceneEvaluationRuleMapper sceneEvaluationRuleMapper;
-    @Resource
-    private SceneComplexityMapper sceneComplexityMapper;
-    @Resource
-    private SceneRiskMapper sceneRiskMapper;
-    @Resource
     private SceneMapper sceneMapper;
     @Resource
     private IndexTemplateMapper indexTemplateMapper;
@@ -92,7 +86,6 @@ public class TaskDomainService {
         }
     }
 
-
     /**
      * @param projectUserId 项目创建用户的 id
      */
@@ -131,8 +124,10 @@ public class TaskDomainService {
         List<SceneEntity> sceneEntityList = getSceneList(projectId, packageId);
         Map<String, SceneEntity> sceneEntityMap = sceneEntityList.stream().collect(Collectors.toMap(SceneEntity::getId, Function.identity()));
         List<LeafIndexEntity> leafIndexList = new ArrayList<>();
-        List<SceneEvaluationComputeParam> sceneComplexityEvaluationComputeParamList = new ArrayList<>();
-        List<SceneEvaluationComputeParam> sceneRiskEvaluationComputeParamList = new ArrayList<>();
+        SceneEvaluationComputeParam sceneComplexityEvaluationComputeParam = new SceneEvaluationComputeParam();
+        sceneComplexityEvaluationComputeParam.setSceneEvaluationComputeSubParam(new ArrayList<>());
+        SceneEvaluationComputeParam sceneRiskEvaluationComputeParam = new SceneEvaluationComputeParam();
+        sceneRiskEvaluationComputeParam.setSceneEvaluationComputeSubParam(new ArrayList<>());
         for (int i = 0; i < leafIndexTemplateList.size(); i++) {
             String scoreExplain = null; // 每个叶子指标下的任务的得分说明一样和叶子指标一致
             IndexTemplateEntity leafIndexTemplate = leafIndexTemplateList.get(i);
@@ -173,14 +168,12 @@ public class TaskDomainService {
                 TaskEntity taskEntity = simulationManualProjectTaskMapper.selectById(task2Id);
                 String sceneId = taskEntity.getSceneId();
                 if (!StringUtils.isEmpty(projectEntity.getComplexityEvaluationRuleId())) {
-                    SceneEvaluationComputeParam sceneEvaluationComputeParam = new SceneEvaluationComputeParam();
-                    sceneEvaluationComputeParam.setSceneId(sceneId);
-                    sceneEvaluationComputeParam.setSceneXOSCPath(sceneEntityMap.get(sceneId).getScenarioOsc());
-                    sceneEvaluationComputeParam.setSceneXODRPath(sceneEntityMap.get(sceneId).getScenarioOdr());
-                    sceneEvaluationComputeParam.setSceneType(sceneEntityMap.get(sceneId).getType());
-                    sceneEvaluationComputeParam.setTaskId(projectId);
-                    sceneEvaluationComputeParam.setComputeType(DictConstants.COMPLEXITY);
-                    sceneComplexityEvaluationComputeParamList.add(sceneEvaluationComputeParam);
+                    SceneEvaluationComputeSubParam sceneEvaluationComputeSubParam = new SceneEvaluationComputeSubParam();
+                    sceneEvaluationComputeSubParam.setSceneId(sceneId);
+                    sceneEvaluationComputeSubParam.setSceneXOSCPath(sceneEntityMap.get(sceneId).getScenarioOsc());
+                    sceneEvaluationComputeSubParam.setSceneXODRPath(sceneEntityMap.get(sceneId).getScenarioOdr());
+                    sceneEvaluationComputeSubParam.setSceneType(sceneEntityMap.get(sceneId).getType());
+                    sceneComplexityEvaluationComputeParam.getSceneEvaluationComputeSubParam().add(sceneEvaluationComputeSubParam);
                 }
                 String runState = taskOfLeaf.getRunState();
                 log.debug("任务 " + task2Id + " 的运行状态为：" + runState);
@@ -191,15 +184,11 @@ public class TaskDomainService {
 
                     // 计算复杂度和危险度
                     if (!StringUtils.isEmpty(projectEntity.getRiskEvaluationRuleId())) {
-                        SceneEvaluationComputeParam sceneEvaluationComputeParam = new SceneEvaluationComputeParam();
-                        sceneEvaluationComputeParam.setSceneId(sceneId);
-                        sceneEvaluationComputeParam.setEvaluationPath(runResultFilePath);
-                        sceneEvaluationComputeParam.setSceneType(sceneEntityMap.get(sceneId).getType());
-                        sceneEvaluationComputeParam.setTaskId(projectId);
-                        sceneEvaluationComputeParam.setComputeType(DictConstants.RISK);
-                        sceneEvaluationComputeParam.setAlgorithmId(projectEntity.getAlgorithm());
-                        sceneEvaluationComputeParam.setVehicleId(projectEntity.getVehicle());
-                        sceneRiskEvaluationComputeParamList.add(sceneEvaluationComputeParam);
+                        SceneEvaluationComputeSubParam sceneEvaluationComputeSubParam = new SceneEvaluationComputeSubParam();
+                        sceneEvaluationComputeSubParam.setSceneId(sceneId);
+                        sceneEvaluationComputeSubParam.setEvaluationPath(runResultFilePath);
+                        sceneEvaluationComputeSubParam.setSceneType(sceneEntityMap.get(sceneId).getType());
+                        sceneRiskEvaluationComputeParam.getSceneEvaluationComputeSubParam().add(sceneEvaluationComputeSubParam);
                     }
                     final ArrayList<String> csvResultFilePaths = CollectionUtil.createArrayList(
                             runResultFilePath + "/Ego.csv",
@@ -317,23 +306,21 @@ public class TaskDomainService {
 
             leafIndexList.add(leafIndex);
         }
-        if (CollectionUtil.isNotEmpty(sceneComplexityEvaluationComputeParamList)) {
-            try {
-                SceneImportParam sceneImportParam = new SceneImportParam();
-                sceneImportParam.setSceneEvaluationRuleId(projectEntity.getComplexityEvaluationRuleId());
-                ThreadPool.sceneEvaluationComputePool.execute(new SceneEvaluationComputeRunnable(sceneImportParam, sceneComplexityEvaluationComputeParamList, linuxTempPath, bucketName));
-            } catch (Exception e) {
-                log.error("计算复杂度失败", e);
-            }
+        if (CollectionUtil.isNotEmpty(sceneComplexityEvaluationComputeParam.getSceneEvaluationComputeSubParam())) {
+            sceneComplexityEvaluationComputeParam.setSceneEvaluationRuleId(projectEntity.getComplexityEvaluationRuleId());
+            sceneComplexityEvaluationComputeParam.setCreateUserId(null);
+            sceneComplexityEvaluationComputeParam.setTaskId(projectId);
+            sceneComplexityEvaluationComputeParam.setComputeType(DictConstants.COMPLEXITY);
+            computeSceneEvaluation(sceneComplexityEvaluationComputeParam);
         }
-        if (CollectionUtil.isNotEmpty(sceneRiskEvaluationComputeParamList)) {
-            try {
-                SceneImportParam sceneImportParam = new SceneImportParam();
-                sceneImportParam.setSceneEvaluationRuleId(projectEntity.getRiskEvaluationRuleId());
-                ThreadPool.sceneEvaluationComputePool.execute(new SceneEvaluationComputeRunnable(sceneImportParam, sceneRiskEvaluationComputeParamList, linuxTempPath, bucketName));
-            } catch (Exception e) {
-                log.error("计算危险度失败", e);
-            }
+        if (CollectionUtil.isNotEmpty(sceneRiskEvaluationComputeParam.getSceneEvaluationComputeSubParam())) {
+            sceneRiskEvaluationComputeParam.setSceneEvaluationRuleId(projectEntity.getComplexityEvaluationRuleId());
+            sceneRiskEvaluationComputeParam.setCreateUserId(null);
+            sceneRiskEvaluationComputeParam.setTaskId(projectId);
+            sceneRiskEvaluationComputeParam.setComputeType(DictConstants.RISK);
+            sceneRiskEvaluationComputeParam.setVehicleId(projectEntity.getVehicle());
+            sceneRiskEvaluationComputeParam.setAlgorithmId(projectEntity.getAlgorithm());
+            computeSceneEvaluation(sceneRiskEvaluationComputeParam);
         }
         // 保存叶子指标得分
         taskIndexRepository.batchInsertLeafIndex(leafIndexList);
@@ -343,6 +330,12 @@ public class TaskDomainService {
         log.info("项目 " + projectId + " 打分完成！");
     }
 
+    public void computeSceneEvaluation(SceneEvaluationComputeParam sceneEvaluationComputeParam) {
+        sceneEvaluationComputeParam.setLinuxTempPath(linuxTempPath);
+        sceneEvaluationComputeParam.setBucketName(bucketName);
+        ThreadPool.sceneEvaluationComputePool.execute(new SceneEvaluationComputeRunnable(sceneEvaluationComputeParam));
+    }
+
     public void computeFirst(List<LeafIndexEntity> leafIndexList, List<IndexTemplateEntity> allIndexTemplateList, String projectId, int maxLevel) {
         log.debug("计算父指标得分：" + leafIndexList);
         Iterator<LeafIndexEntity> leafTaskIndexIterator = leafIndexList.iterator();
@@ -423,7 +416,7 @@ public class TaskDomainService {
     /**
      * 多模式仿真任务刷新心跳的时间redisKey
      */
-    public String getMultiTaskTickPodRedisKey(String taskId, String projectId){
+    public String getMultiTaskTickPodRedisKey(String taskId, String projectId) {
         return "multi_project:" + projectId + ":taskId:" + taskId + ":taskTickPod";
     }
 

simulation-resource-scheduler/src/main/java/com/css/simulation/resource/scheduler/infra/runnable/SceneEvaluationComputeRunnable.java

@@ -2,7 +2,7 @@ package com.css.simulation.resource.scheduler.infra.runnable;
 
 import api.common.pojo.constants.DictConstants;
 import api.common.pojo.param.scene.SceneEvaluationComputeParam;
-import api.common.pojo.param.scene.SceneImportParam;
+import api.common.pojo.param.scene.SceneEvaluationComputeSubParam;
 import api.common.pojo.po.scene.SceneComplexityPO;
 import api.common.pojo.po.scene.SceneEvaluationRulePO;
 import api.common.pojo.po.scene.SceneRiskPO;
@@ -26,7 +26,6 @@ import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.nio.file.attribute.PosixFilePermission;
 import java.util.HashSet;
-import java.util.List;
 import java.util.Set;
 
 import static api.common.pojo.enums.SceneEvaluationEnum.matchLevelEnumByLevel;
@@ -38,22 +37,17 @@ import static api.common.pojo.enums.SceneEvaluationEnum.matchLevelEnumByLevel;
 @Slf4j
 public class SceneEvaluationComputeRunnable implements Runnable {
 
-    private final String linuxTempPath;
-    private final SceneImportParam param;
-    private final String bucketName;
-    private final List<SceneEvaluationComputeParam> sceneEvaluationComputeParams;
+    private final SceneEvaluationComputeParam sceneEvaluationComputeParam;
 
-    public SceneEvaluationComputeRunnable(SceneImportParam param, List<SceneEvaluationComputeParam> sceneEvaluationComputeParams, String linuxTempPath, String bucketName) {
-        this.param = param;
-        this.sceneEvaluationComputeParams = sceneEvaluationComputeParams;
-        this.linuxTempPath = linuxTempPath;
-        this.bucketName = bucketName;
+    public SceneEvaluationComputeRunnable(SceneEvaluationComputeParam sceneEvaluationComputeParam) {
+        this.sceneEvaluationComputeParam = sceneEvaluationComputeParam;
     }
 
     @Override
     public void run() {
-        String ruleId = param.getSceneEvaluationRuleId();
+        String ruleId = sceneEvaluationComputeParam.getSceneEvaluationRuleId();
         log.info("开始执行线程：" + ruleId);
+        String bucketName = sceneEvaluationComputeParam.getBucketName();
         SceneEvaluationRuleMapper sceneEvaluationRuleMapper = ApplicationContextAwareImpl.getApplicationContext().getBean(SceneEvaluationRuleMapper.class);
         SceneComplexityMapper sceneComplexityMapper = ApplicationContextAwareImpl.getApplicationContext().getBean(SceneComplexityMapper.class);
         SceneRiskMapper sceneRiskMapper = ApplicationContextAwareImpl.getApplicationContext().getBean(SceneRiskMapper.class);
@@ -66,7 +60,7 @@ public class SceneEvaluationComputeRunnable implements Runnable {
         }
         log.info("场景评价规则为：" + sceneEvaluationRulePO);
         // 1 判断有没有用户目录，没有则复制
-        String evaluationDirectoryOfUser = linuxTempPath + "scene/evaluation/" + sceneEvaluationComputeParams.get(0).getTaskId() + "/";
+        String evaluationDirectoryOfUser = sceneEvaluationComputeParam.getLinuxTempPath() + "scene/evaluation/" + sceneEvaluationComputeParam.getTaskId() + "/";
         String scriptsPath = evaluationDirectoryOfUser + "scripts";
         if (!new File(evaluationDirectoryOfUser).exists()) {
             // 1 将场景评价规则脚本保存到 script 目录
@@ -99,9 +93,9 @@ public class SceneEvaluationComputeRunnable implements Runnable {
             }
         }
         String scenePathFather = evaluationDirectoryOfUser + "scene/";
-        for (SceneEvaluationComputeParam sceneEvaluationComputeParam : sceneEvaluationComputeParams) {
+        for (SceneEvaluationComputeSubParam sceneEvaluationComputeSubParam : sceneEvaluationComputeParam.getSceneEvaluationComputeSubParam()) {
             // 创建场景路径
-            String scenePath = scenePathFather + sceneEvaluationComputeParam.getSceneId();
+            String scenePath = scenePathFather + sceneEvaluationComputeSubParam.getSceneId();
             if (!new File(scenePath).exists()) {
                 FileUtil.createDirectory(scenePath);
             } else {
@@ -110,27 +104,27 @@ public class SceneEvaluationComputeRunnable implements Runnable {
             }
             try {
                 if (StringUtils.equals(sceneEvaluationComputeParam.getComputeType(), DictConstants.COMPLEXITY)) {
-                    if (StringUtil.isEmpty(sceneEvaluationComputeParam.getSceneXODRPath())
-                            || StringUtil.isEmpty(sceneEvaluationComputeParam.getSceneXOSCPath())) {
+                    if (StringUtil.isEmpty(sceneEvaluationComputeSubParam.getSceneXODRPath())
+                            || StringUtil.isEmpty(sceneEvaluationComputeSubParam.getSceneXOSCPath())) {
                         continue;
                     }
                     // 计算复杂度，根据场景 id 获取场景信息，下载 osc odr
-                    String scenarioOsc = sceneEvaluationComputeParam.getSceneXOSCPath();
+                    String scenarioOsc = sceneEvaluationComputeSubParam.getSceneXOSCPath();
                     String[] splitXosc = scenarioOsc.split("/");
                     String xoscName = splitXosc[splitXosc.length - 1];
-                    MinioUtil.downloadToFile(minioClient, bucketName, sceneEvaluationComputeParam.getSceneXOSCPath(), scenePath + "/" + xoscName);
+                    MinioUtil.downloadToFile(minioClient, bucketName, sceneEvaluationComputeSubParam.getSceneXOSCPath(), scenePath + "/" + xoscName);
 
-                    String scenarioOdr = sceneEvaluationComputeParam.getSceneXODRPath();
+                    String scenarioOdr = sceneEvaluationComputeSubParam.getSceneXODRPath();
                     String[] splitXodr = scenarioOdr.split("/");
                     String xodrName = splitXodr[splitXodr.length - 1];
-                    MinioUtil.downloadToFile(minioClient, bucketName, sceneEvaluationComputeParam.getSceneXODRPath(), scenePath + "/" + xodrName);
+                    MinioUtil.downloadToFile(minioClient, bucketName, sceneEvaluationComputeSubParam.getSceneXODRPath(), scenePath + "/" + xodrName);
                 } else if (StringUtils.equals(sceneEvaluationComputeParam.getComputeType(), DictConstants.RISK)) {
-                    if (StringUtil.isEmpty(sceneEvaluationComputeParam.getEvaluationPath())) {
+                    if (StringUtil.isEmpty(sceneEvaluationComputeSubParam.getEvaluationPath())) {
                         continue;
                     }
                     // 计算危险度 从 minio path 下载 csv （ego 和 sensors）
-                    MinioUtil.downloadToFile(minioClient, bucketName, sceneEvaluationComputeParam.getEvaluationPath() + "/Ego.csv", scenePath + "/Ego.csv");
-                    MinioUtil.downloadToFile(minioClient, bucketName, sceneEvaluationComputeParam.getEvaluationPath() + "/evaluation.csv", scenePath + "/evaluation.csv");
+                    MinioUtil.downloadToFile(minioClient, bucketName, sceneEvaluationComputeSubParam.getEvaluationPath() + "/Ego.csv", scenePath + "/Ego.csv");
+                    MinioUtil.downloadToFile(minioClient, bucketName, sceneEvaluationComputeSubParam.getEvaluationPath() + "/evaluation.csv", scenePath + "/evaluation.csv");
                 } else {
                     return;
                 }
@@ -140,7 +134,7 @@ public class SceneEvaluationComputeRunnable implements Runnable {
             }
         }
         String sceneEvaluationCommand;
-        if (StringUtils.equals(sceneEvaluationComputeParams.get(0).getComputeType(), DictConstants.COMPLEXITY)) {
+        if (StringUtils.equals(sceneEvaluationComputeParam.getComputeType(), DictConstants.COMPLEXITY)) {
             sceneEvaluationCommand = pyMainPath + " " + scenePathFather + " complexity";
         } else {
             sceneEvaluationCommand = pyMainPath + " " + scenePathFather + " criticality";
@@ -170,11 +164,11 @@ public class SceneEvaluationComputeRunnable implements Runnable {
         }
         sceneEvaluationResult = sb.toString();
         log.info("场景评价结束，结果为：" + sceneEvaluationResult);
-        for (SceneEvaluationComputeParam sceneEvaluationComputeParam : sceneEvaluationComputeParams) {
+        for (SceneEvaluationComputeSubParam sceneEvaluationComputeSubParam : sceneEvaluationComputeParam.getSceneEvaluationComputeSubParam()) {
             // 读文件
             StringBuilder result = new StringBuilder();
             try {
-                FileInputStream fileInputStream = new FileInputStream(scenePathFather + sceneEvaluationComputeParam.getSceneId() + "/scenario_evaluation.json");
+                FileInputStream fileInputStream = new FileInputStream(scenePathFather + sceneEvaluationComputeSubParam.getSceneId() + "/scenario_evaluation.json");
                 BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(fileInputStream));
 
                 String line;
@@ -198,9 +192,9 @@ public class SceneEvaluationComputeRunnable implements Runnable {
                     String complexity = rootNode.path("复杂度").asText();
                     String complexityLevel = rootNode.path("复杂度等级").asText();
                     SceneComplexityPO sceneComplexityPO = new SceneComplexityPO();
-                    sceneComplexityPO.setSceneId(sceneEvaluationComputeParam.getSceneId());
+                    sceneComplexityPO.setSceneId(sceneEvaluationComputeSubParam.getSceneId());
                     sceneComplexityPO.setComplexityId(StringUtil.getRandomUUID());
-                    sceneComplexityPO.setSceneType(sceneEvaluationComputeParam.getSceneType());
+                    sceneComplexityPO.setSceneType(sceneEvaluationComputeSubParam.getSceneType());
                     sceneComplexityPO.setRuleId(ruleId);
                     sceneComplexityPO.setTaskId(sceneEvaluationComputeParam.getTaskId());
                     sceneComplexityPO.setComplexity(complexity);
@@ -213,9 +207,9 @@ public class SceneEvaluationComputeRunnable implements Runnable {
                     String risk = rootNode.path("危险度").asText();
                     String riskLevel = rootNode.path("危险度等级").asText();
                     SceneRiskPO sceneRiskPO = new SceneRiskPO();
-                    sceneRiskPO.setSceneId(sceneEvaluationComputeParam.getSceneId());
+                    sceneRiskPO.setSceneId(sceneEvaluationComputeSubParam.getSceneId());
                     sceneRiskPO.setRuleId(StringUtil.getRandomUUID());
-                    sceneRiskPO.setSceneType(sceneEvaluationComputeParam.getSceneType());
+                    sceneRiskPO.setSceneType(sceneEvaluationComputeSubParam.getSceneType());
                     sceneRiskPO.setRuleId(ruleId);
                     sceneRiskPO.setTaskId(sceneEvaluationComputeParam.getTaskId());
                     sceneRiskPO.setRisk(risk);
@@ -226,7 +220,7 @@ public class SceneEvaluationComputeRunnable implements Runnable {
                     sceneRiskMapper.saveSceneRisk(sceneRiskPO);
                 }
             } catch (Exception e) {
-                log.error("场景" + sceneEvaluationComputeParam.getSceneId() + " 的场景评价失败：", e);
+                log.error("场景" + sceneEvaluationComputeSubParam.getSceneId() + " 的场景评价失败：", e);
             }
         }
         // 删除临时文件

simulation-resource-server/src/main/java/com/css/simulation/resource/server/app/service/SceneAccidentService.java

@@ -771,7 +771,8 @@ public class SceneAccidentService {
                     List<String> listScene = fileDownService.listDeepOne(MI).getInfo();
                     log.info("共需要上传 " + listScene.size() + " 个交通事故场景");
                     String taskId = api.common.util.StringUtil.getRandomUUID();
-                    List<SceneEvaluationComputeParam> paramList = new ArrayList<>();
+                    SceneEvaluationComputeParam sceneComplexityEvaluationComputeParam = new SceneEvaluationComputeParam();
+                    sceneComplexityEvaluationComputeParam.setSceneEvaluationComputeSubParam(new ArrayList<>());
                     for (String scenePath : listScene) {
                         try {
                             MI.setObjectName(scenePath);
@@ -872,19 +873,16 @@ public class SceneAccidentService {
 
                             // 计算复杂度
                             if (!StringUtils.isEmpty(params.getSceneEvaluationRuleId())) {
-                                SceneEvaluationComputeParam sceneEvaluationComputeParam = new SceneEvaluationComputeParam();
-                                sceneEvaluationComputeParam.setSceneId(isupdate.equals("0") ? sceneAccidentPO.getAccidentId() : scenes.get(0).getAccidentId());
-                                sceneEvaluationComputeParam.setSceneXOSCPath(sceneAccidentPO.getXmlAddress());
-                                sceneEvaluationComputeParam.setSceneXODRPath(sceneAccidentPO.getXodrAddress());
-                                sceneEvaluationComputeParam.setSceneType(DictConstants.SCENE_ACCIDENT);
-                                sceneEvaluationComputeParam.setTaskId(taskId);
-                                sceneEvaluationComputeParam.setComputeType(DictConstants.COMPLEXITY);
-                                sceneEvaluationComputeParam.setCreateUserId(AuthUtil.getCurrentUserId());
+                                SceneEvaluationComputeSubParam sceneEvaluationComputeSubParam = new SceneEvaluationComputeSubParam();
+                                sceneEvaluationComputeSubParam.setSceneId(isupdate.equals("0") ? sceneAccidentPO.getAccidentId() : scenes.get(0).getAccidentId());
+                                sceneEvaluationComputeSubParam.setSceneXOSCPath(sceneAccidentPO.getXmlAddress());
+                                sceneEvaluationComputeSubParam.setSceneXODRPath(sceneAccidentPO.getXodrAddress());
+                                sceneEvaluationComputeSubParam.setSceneType(DictConstants.SCENE_ACCIDENT);
                                 if (isupdate.equals("1")) {
                                     String tempSceneId = scenes.get(0).getAccidentId();
-                                    sceneEvaluationComputeParam.setCopySceneId(scenes.stream().map(SceneAccidentPO::getAccidentId).filter(sceneId -> !StringUtils.equals(tempSceneId, sceneId)).collect(Collectors.toList()));
+                                    sceneEvaluationComputeSubParam.setCopySceneId(scenes.stream().map(SceneAccidentPO::getAccidentId).filter(sceneId -> !StringUtils.equals(tempSceneId, sceneId)).collect(Collectors.toList()));
                                 }
-                                paramList.add(sceneEvaluationComputeParam);
+                                sceneComplexityEvaluationComputeParam.getSceneEvaluationComputeSubParam().add(sceneEvaluationComputeSubParam);
                             }
                         } catch (Exception e) {
                             errorMessage = e.getMessage();
@@ -893,8 +891,12 @@ public class SceneAccidentService {
                         }
                     }
                     try {
-                        if (CollectionUtil.isNotEmpty(paramList)) {
-                            sceneEvaluationRuleService.computeSceneReference(params, paramList);
+                        if (CollectionUtil.isNotEmpty(sceneComplexityEvaluationComputeParam.getSceneEvaluationComputeSubParam())) {
+                            sceneComplexityEvaluationComputeParam.setTaskId(taskId);
+                            sceneComplexityEvaluationComputeParam.setSceneEvaluationRuleId(params.getSceneEvaluationRuleId());
+                            sceneComplexityEvaluationComputeParam.setComputeType(DictConstants.COMPLEXITY);
+                            sceneComplexityEvaluationComputeParam.setCreateUserId(AuthUtil.getCurrentUserId());
+                            sceneEvaluationRuleService.computeSceneEvaluation(sceneComplexityEvaluationComputeParam);
                         }
                     } catch (Exception e) {
                         log.error("计算复杂度失败", e);

simulation-resource-server/src/main/java/com/css/simulation/resource/server/app/service/SceneEvaluationRuleService.java

@@ -9,7 +9,10 @@ import api.common.pojo.po.scene.SceneEvaluationOperatePO;
 import api.common.pojo.po.scene.SceneEvaluationRulePO;
 import api.common.pojo.po.scene.SceneRiskPO;
 import api.common.pojo.po.system.SceneEvaluationRuleScriptPO;
-import api.common.util.*;
+import api.common.util.LogUtil;
+import api.common.util.ObjectUtil;
+import api.common.util.StringUtil;
+import api.common.util.TimeUtil;
 import com.alibaba.druid.util.StringUtils;
 import com.css.simulation.resource.server.infra.db.mysql.mapper.SceneComplexityMapper;
 import com.css.simulation.resource.server.infra.db.mysql.mapper.SceneEvaluationRuleMapper;
@@ -17,12 +20,10 @@ import com.css.simulation.resource.server.infra.db.mysql.mapper.ScenePackageMapp
 import com.css.simulation.resource.server.infra.db.mysql.mapper.SceneRiskMapper;
 import com.css.simulation.resource.server.infra.feign.service.FileDownService;
 import com.css.simulation.resource.server.infra.feign.service.SceneService;
-import com.css.simulation.resource.server.infra.runnable.SceneEvaluationComputeRunnable;
-import com.css.simulation.resource.server.infra.threadpool.ThreadPool;
+import com.css.simulation.resource.server.infra.feign.service.SchedulerService;
 import com.css.simulation.resource.server.infra.util.AuthUtil;
 import lombok.SneakyThrows;
 import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
 import org.springframework.web.multipart.MultipartFile;
 
@@ -40,10 +41,6 @@ import static api.common.pojo.constants.DictConstants.SCENE_IMPORT_STATUS_2;
 @Service
 public class SceneEvaluationRuleService {
 
-
-    @Value("${server.linux-path.temp}")
-    private String linuxTempPath;
-
     @Resource
     private ScenePackageMapper scenePackageMapper;
 
@@ -62,6 +59,9 @@ public class SceneEvaluationRuleService {
     @Resource
     private SceneService sceneService;
 
+    @Resource
+    private SchedulerService schedulerService;
+
     @SneakyThrows
     public int querySceneEvaluationRuleOnly(String ruleName, String ruleId) {
         return sceneEvaluationRuleMapper.querySceneEvaluationRuleOnly(ruleName, ruleId);
@@ -262,7 +262,7 @@ public class SceneEvaluationRuleService {
     }
 
 
-    public void computeSceneReference(SceneImportParam param, List<SceneEvaluationComputeParam> sceneEvaluationComputeParams) {
-        ThreadPool.sceneEvaluationComputePool.execute(new SceneEvaluationComputeRunnable(param, sceneEvaluationComputeParams, linuxTempPath));
+    public void computeSceneEvaluation(SceneEvaluationComputeParam sceneEvaluationComputeParam) {
+        schedulerService.computeSceneEvaluation(sceneEvaluationComputeParam);
     }
 }

simulation-resource-server/src/main/java/com/css/simulation/resource/server/app/service/SceneNaturalService.java

@@ -555,7 +555,8 @@ public class SceneNaturalService {
                     List<String> listScene = fileDownService.listDeepOne(MI).getInfo();
                     log.info("共需要上传 " + listScene.size() + " 个自然驾驶场景");
                     String taskId = api.common.util.StringUtil.getRandomUUID();
-                    List<SceneEvaluationComputeParam> paramList = new ArrayList<>();
+                    SceneEvaluationComputeParam sceneComplexityEvaluationComputeParam = new SceneEvaluationComputeParam();
+                    sceneComplexityEvaluationComputeParam.setSceneEvaluationComputeSubParam(new ArrayList<>());
                     HashSet<String> strings = new HashSet<>(listScene);
                     log.info("去重之后还剩 " + strings.size() + " 个自然驾驶场景");
                     int addNumber = 0;
@@ -705,20 +706,17 @@ public class SceneNaturalService {
 
                             // 计算复杂度
                             if (!StringUtils.isEmpty(parms.getSceneEvaluationRuleId())) {
-                                SceneEvaluationComputeParam sceneEvaluationComputeParam = new SceneEvaluationComputeParam();
-                                sceneEvaluationComputeParam.setSceneId(update ? scenes.get(0).getNaturalId() : sceneNaturalPO.getNaturalId());
-                                sceneEvaluationComputeParam.setSceneXOSCPath(sceneNaturalPO.getXoscAddress());
-                                sceneEvaluationComputeParam.setSceneXODRPath(sceneNaturalPO.getXodrAddress());
-                                sceneEvaluationComputeParam.setSceneType(DictConstants.SCENE_NATURAL);
-                                sceneEvaluationComputeParam.setTaskId(taskId);
-                                sceneEvaluationComputeParam.setComputeType(DictConstants.COMPLEXITY);
-                                sceneEvaluationComputeParam.setCreateUserId(AuthUtil.getCurrentUserId());
+                                SceneEvaluationComputeSubParam sceneEvaluationComputeSubParam = new SceneEvaluationComputeSubParam();
+                                sceneEvaluationComputeSubParam.setSceneId(update ? scenes.get(0).getNaturalId() : sceneNaturalPO.getNaturalId());
+                                sceneEvaluationComputeSubParam.setSceneXOSCPath(sceneNaturalPO.getXoscAddress());
+                                sceneEvaluationComputeSubParam.setSceneXODRPath(sceneNaturalPO.getXodrAddress());
+                                sceneEvaluationComputeSubParam.setSceneType(DictConstants.SCENE_NATURAL);
                                 if (update) {
                                     String tempSceneId = scenes.get(0).getNaturalId();
-                                    sceneEvaluationComputeParam.setCopySceneId(scenes.stream().map(SceneNaturalPO::getNaturalId).filter(sceneId -> !StringUtils.equals(tempSceneId, sceneId)).collect(Collectors.toList()));
+                                    sceneEvaluationComputeSubParam.setCopySceneId(scenes.stream().map(SceneNaturalPO::getNaturalId).filter(sceneId -> !StringUtils.equals(tempSceneId, sceneId)).collect(Collectors.toList()));
                                 }
-                                paramList.add(sceneEvaluationComputeParam);
-                                log.info("添加计算复杂度数据：" + sceneEvaluationComputeParam);
+                                sceneComplexityEvaluationComputeParam.getSceneEvaluationComputeSubParam().add(sceneEvaluationComputeSubParam);
+                                log.info("添加计算复杂度数据：" + sceneEvaluationComputeSubParam);
                             }
                         } catch (Exception e) {
                             errorMessage = e.getMessage();
@@ -728,8 +726,12 @@ public class SceneNaturalService {
                     }
                     log.info("共新增 " + addNumber + " 个自然驾驶场景，修改 " + updateNumber + "个场景。");
                     try {
-                        if (CollectionUtil.isNotEmpty(paramList)) {
-                            sceneEvaluationRuleService.computeSceneReference(parms, paramList);
+                        if (CollectionUtil.isNotEmpty(sceneComplexityEvaluationComputeParam.getSceneEvaluationComputeSubParam())) {
+                            sceneComplexityEvaluationComputeParam.setTaskId(taskId);
+                            sceneComplexityEvaluationComputeParam.setSceneEvaluationRuleId(parms.getSceneEvaluationRuleId());
+                            sceneComplexityEvaluationComputeParam.setComputeType(DictConstants.COMPLEXITY);
+                            sceneComplexityEvaluationComputeParam.setCreateUserId(AuthUtil.getCurrentUserId());
+                            sceneEvaluationRuleService.computeSceneEvaluation(sceneComplexityEvaluationComputeParam);
                         }
                     } catch (Exception e) {
                         log.error("计算复杂度失败", e);

simulation-resource-server/src/main/java/com/css/simulation/resource/server/app/service/SceneReferenceLibService.java

@@ -17,7 +17,6 @@ import feign.Response;
 import lombok.SneakyThrows;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.BeanUtils;
-import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -218,7 +217,8 @@ public class SceneReferenceLibService {
                     List<String> listScene = fileDownService.listDeepOne(MI).getInfo();
                     log.info("importMinio() 共需要上传 " + listScene.size() + " 个基准场景");
                     String taskId = StringUtil.getRandomUUID();
-                    List<SceneEvaluationComputeParam> paramList = new ArrayList<>();
+                    SceneEvaluationComputeParam sceneComplexityEvaluationComputeParam = new SceneEvaluationComputeParam();
+                    sceneComplexityEvaluationComputeParam.setSceneEvaluationComputeSubParam(new ArrayList<>());
                     for (String scenePath : listScene) {
                         try {
                             MI.setObjectName(scenePath);
@@ -337,19 +337,17 @@ public class SceneReferenceLibService {
                             }
                             successNum += 1;
                             if (!StringUtils.isEmpty(params.getSceneEvaluationRuleId())) {
-                                SceneEvaluationComputeParam sceneEvaluationComputeParam = new SceneEvaluationComputeParam();
-                                sceneEvaluationComputeParam.setSceneId(isUpdate ? scenes.get(0).getSceneId() : sceneReferenceLibPO.getSceneId());
-                                sceneEvaluationComputeParam.setSceneXOSCPath(sceneReferenceLibPO.getXmlAddress());
-                                sceneEvaluationComputeParam.setSceneXODRPath(sceneReferenceLibPO.getXodrAddress());
-                                sceneEvaluationComputeParam.setSceneType(DictConstants.SCENE_REFERENCE_LIB);
-                                sceneEvaluationComputeParam.setTaskId(taskId);
-                                sceneEvaluationComputeParam.setComputeType(DictConstants.COMPLEXITY);
-                                sceneEvaluationComputeParam.setCreateUserId(AuthUtil.getCurrentUserId());
+                                SceneEvaluationComputeSubParam sceneEvaluationComputeSubParam = new SceneEvaluationComputeSubParam();
+                                sceneEvaluationComputeSubParam.setSceneId(isUpdate ? scenes.get(0).getSceneId() : sceneReferenceLibPO.getSceneId());
+                                sceneEvaluationComputeSubParam.setSceneXOSCPath(sceneReferenceLibPO.getXmlAddress());
+                                sceneEvaluationComputeSubParam.setSceneXODRPath(sceneReferenceLibPO.getXodrAddress());
+                                sceneEvaluationComputeSubParam.setSceneType(DictConstants.SCENE_REFERENCE_LIB);
                                 if (isUpdate) {
                                     String tempSceneId = scenes.get(0).getSceneId();
-                                    sceneEvaluationComputeParam.setCopySceneId(scenes.stream().map(SceneReferenceLibPO::getSceneId).filter(sceneId -> !StringUtils.equals(tempSceneId, sceneId)).collect(Collectors.toList()));
+                                    sceneEvaluationComputeSubParam.setCopySceneId(scenes.stream().map(SceneReferenceLibPO::getSceneId).filter(sceneId -> !StringUtils.equals(tempSceneId, sceneId)).collect(Collectors.toList()));
                                 }
-                                paramList.add(sceneEvaluationComputeParam);
+                                sceneComplexityEvaluationComputeParam.getSceneEvaluationComputeSubParam().add(sceneEvaluationComputeSubParam);
+                                log.info("添加计算复杂度数据：" + sceneEvaluationComputeSubParam);
                             }
                         } catch (Exception e) {
                             errorMessage = e.getMessage();
@@ -358,9 +356,13 @@ public class SceneReferenceLibService {
                         }
                     }
                     // 计算复杂度
-                    if (CollectionUtil.isNotEmpty(paramList)) {
+                    if (CollectionUtil.isNotEmpty(sceneComplexityEvaluationComputeParam.getSceneEvaluationComputeSubParam())) {
                         try {
-                            sceneEvaluationRuleService.computeSceneReference(params, paramList);
+                            sceneComplexityEvaluationComputeParam.setTaskId(taskId);
+                            sceneComplexityEvaluationComputeParam.setSceneEvaluationRuleId(params.getSceneEvaluationRuleId());
+                            sceneComplexityEvaluationComputeParam.setComputeType(DictConstants.COMPLEXITY);
+                            sceneComplexityEvaluationComputeParam.setCreateUserId(AuthUtil.getCurrentUserId());
+                            sceneEvaluationRuleService.computeSceneEvaluation(sceneComplexityEvaluationComputeParam);
                         } catch (Exception e) {
                             log.error("计算复杂度失败", e);
                         }

simulation-resource-server/src/main/java/com/css/simulation/resource/server/app/service/SceneStandardsService.java

@@ -331,7 +331,8 @@ public class SceneStandardsService {
                     List<String> listScene = fileDownService.listDeepOne(MI).getInfo();
                     log.info("importMinio() 共需要上传 " + listScene.size() + " 个标准法规场景");
                     String taskId = api.common.util.StringUtil.getRandomUUID();
-                    List<SceneEvaluationComputeParam> paramList = new ArrayList<>();
+                    SceneEvaluationComputeParam sceneComplexityEvaluationComputeParam = new SceneEvaluationComputeParam();
+                    sceneComplexityEvaluationComputeParam.setSceneEvaluationComputeSubParam(new ArrayList<>());
                     for (String scenePath : listScene) {
                         try {
                             MI.setObjectName(scenePath);
@@ -421,20 +422,17 @@ public class SceneStandardsService {
 
                             // 计算复杂度
                             if (!StringUtils.isEmpty(parms.getSceneEvaluationRuleId())) {
-                                SceneEvaluationComputeParam sceneEvaluationComputeParam = new SceneEvaluationComputeParam();
-                                sceneEvaluationComputeParam.setSceneId(isupdate.equals("0") ? standardsRegulationsPO.getRegulationsId() : scenes.get(0).getRegulationsId());
-                                sceneEvaluationComputeParam.setSceneXOSCPath(standardsRegulationsPO.getXmlAddress());
-                                sceneEvaluationComputeParam.setSceneXODRPath(standardsRegulationsPO.getXodrAddress());
-                                sceneEvaluationComputeParam.setSceneType(DictConstants.SCENE_STANDARD);
-                                sceneEvaluationComputeParam.setTaskId(taskId);
-                                sceneEvaluationComputeParam.setComputeType(DictConstants.COMPLEXITY);
-                                sceneEvaluationComputeParam.setCreateUserId(AuthUtil.getCurrentUserId());
+                                SceneEvaluationComputeSubParam sceneEvaluationComputeSubParam = new SceneEvaluationComputeSubParam();
+                                sceneEvaluationComputeSubParam.setSceneId(isupdate.equals("0") ? standardsRegulationsPO.getRegulationsId() : scenes.get(0).getRegulationsId());
+                                sceneEvaluationComputeSubParam.setSceneXOSCPath(standardsRegulationsPO.getXmlAddress());
+                                sceneEvaluationComputeSubParam.setSceneXODRPath(standardsRegulationsPO.getXodrAddress());
+                                sceneEvaluationComputeSubParam.setSceneType(DictConstants.SCENE_STANDARD);
                                 if (isupdate.equals("1")) {
                                     String tempSceneId = scenes.get(0).getRegulationsId();
-                                    sceneEvaluationComputeParam.setCopySceneId(scenes.stream().map(StandardsRegulationsPO::getRegulationsId).filter(sceneId -> !StringUtils.equals(tempSceneId, sceneId)).collect(Collectors.toList()));
+                                    sceneEvaluationComputeSubParam.setCopySceneId(scenes.stream().map(StandardsRegulationsPO::getRegulationsId).filter(sceneId -> !StringUtils.equals(tempSceneId, sceneId)).collect(Collectors.toList()));
                                 }
-                                log.info("添加计算复杂度数据：" + sceneEvaluationComputeParam);
-                                paramList.add(sceneEvaluationComputeParam);
+                                sceneComplexityEvaluationComputeParam.getSceneEvaluationComputeSubParam().add(sceneEvaluationComputeSubParam);
+                                log.info("添加计算复杂度数据：" + sceneEvaluationComputeSubParam);
                             }
                         } catch (Exception e) {
                             errorMessage = e.getMessage();
@@ -443,8 +441,12 @@ public class SceneStandardsService {
                         }
                     }
                     try {
-                        if (!StringUtils.isEmpty(parms.getSceneEvaluationRuleId())) {
-                            sceneEvaluationRuleService.computeSceneReference(parms, paramList);
+                        if (CollectionUtil.isNotEmpty(sceneComplexityEvaluationComputeParam.getSceneEvaluationComputeSubParam())) {
+                            sceneComplexityEvaluationComputeParam.setTaskId(taskId);
+                            sceneComplexityEvaluationComputeParam.setSceneEvaluationRuleId(parms.getSceneEvaluationRuleId());
+                            sceneComplexityEvaluationComputeParam.setComputeType(DictConstants.COMPLEXITY);
+                            sceneComplexityEvaluationComputeParam.setCreateUserId(AuthUtil.getCurrentUserId());
+                            sceneEvaluationRuleService.computeSceneEvaluation(sceneComplexityEvaluationComputeParam);
                         }
                     } catch (Exception e) {
                         log.error("计算复杂度失败", e);

simulation-resource-server/src/main/java/com/css/simulation/resource/server/infra/feign/service/SchedulerService.java

@@ -1,10 +1,13 @@
 package com.css.simulation.resource.server.infra.feign.service;
 
 import api.common.pojo.common.ResponseBodyVO;
+import api.common.pojo.param.scene.SceneEvaluationComputeParam;
 import com.css.simulation.resource.server.infra.feign.config.FeignConfiguration;
 import com.css.simulation.resource.server.infra.feign.fallback.SchedulerServiceFallback;
 import org.springframework.cloud.openfeign.FeignClient;
+import org.springframework.scheduling.annotation.Async;
 import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestParam;
 
 //@FeignClient(name = "scheduler", url = "http://47.94.105.148", path = "/simulation/resource/scheduler", fallback = SchedulerServiceFallback.class, configuration = FeignConfiguration.class)
@@ -20,4 +23,8 @@ public interface SchedulerService {
     @PostMapping(value = "/algorithm/check")
     ResponseBodyVO<String> check(@RequestParam("minioPath") String minioPath);
 
+    @Async
+    @PostMapping(value = "/sceneEvaluation/computeSceneEvaluation")
+    ResponseBodyVO<String> computeSceneEvaluation(@RequestBody SceneEvaluationComputeParam sceneEvaluationComputeParam);
+
 }