Block node build (#792)

Co-authored-by: Slimane AMAR <[email protected]>

Author: SlimaneAmar

src/main/java/org/gridsuite/study/server/controller/StudyController.java

@@ -16,15 +16,17 @@
 @Builder
 public record InvalidateNodeTreeParameters(
     InvalidationMode invalidationMode,
+    boolean withBlockedNodeBuild,
     ComputationsInvalidationMode computationsInvalidationMode // Only for the first node (root node)
 ) {
-    public static InvalidateNodeTreeParameters ALL = new InvalidateNodeTreeParameters(InvalidationMode.ALL, ComputationsInvalidationMode.ALL);
-    public static InvalidateNodeTreeParameters ONLY_CHILDREN = new InvalidateNodeTreeParameters(InvalidationMode.ONLY_CHILDREN, ComputationsInvalidationMode.ALL);
-    public static InvalidateNodeTreeParameters ONLY_CHILDREN_BUILD_STATUS = new InvalidateNodeTreeParameters(InvalidationMode.ONLY_CHILDREN_BUILD_STATUS, ComputationsInvalidationMode.ALL);
+    public static InvalidateNodeTreeParameters ALL = new InvalidateNodeTreeParameters(InvalidationMode.ALL, false, ComputationsInvalidationMode.ALL);
+    public static InvalidateNodeTreeParameters ALL_WITH_BLOCK_NODES = new InvalidateNodeTreeParameters(InvalidationMode.ALL, true, ComputationsInvalidationMode.ALL);
+    public static InvalidateNodeTreeParameters ONLY_CHILDREN = new InvalidateNodeTreeParameters(InvalidationMode.ONLY_CHILDREN, false, ComputationsInvalidationMode.ALL);
+    public static InvalidateNodeTreeParameters ONLY_CHILDREN_BUILD_STATUS = new InvalidateNodeTreeParameters(InvalidationMode.ONLY_CHILDREN_BUILD_STATUS, false, ComputationsInvalidationMode.ALL);
     public static InvalidateNodeTreeParameters DEFAULT = ALL;
 
     public enum InvalidationMode {
-        ALL, ONLY_CHILDREN, ONLY_CHILDREN_BUILD_STATUS;
+        ALL, ONLY_CHILDREN, ONLY_CHILDREN_BUILD_STATUS
     }
 
     public enum ComputationsInvalidationMode {
@@ -45,7 +47,7 @@ public boolean isOnlyChildren() {
         return invalidationMode == InvalidationMode.ONLY_CHILDREN;
     }
 
-    public boolean isOnlyChildrenBuildStatusMode() {
+    public boolean isOnlyChildrenBuildStatus() {
         return invalidationMode == InvalidationMode.ONLY_CHILDREN_BUILD_STATUS;
     }
 }

src/main/java/org/gridsuite/study/server/dto/InvalidateNodeTreeParameters.java

@@ -102,6 +102,9 @@ public class RootNetworkNodeInfoEntity {
     @Column(name = "stateEstimationResultUuid")
     private UUID stateEstimationResultUuid;
 
+    @Column(name = "blockedBuild")
+    private Boolean blockedBuild;
+
     @Embedded
     @AttributeOverrides(value = {
         @AttributeOverride(name = "localBuildStatus", column = @Column(name = "localBuildStatus", nullable = false)),

src/main/java/org/gridsuite/study/server/networkmodificationtree/entities/RootNetworkNodeInfoEntity.java

@@ -54,9 +54,12 @@ public interface RootNetworkNodeInfoRepository extends JpaRepository<RootNetwork
 
     List<RootNetworkNodeInfoEntity> findAllByRootNetworkStudyIdAndLoadFlowResultUuidNotNull(UUID studyUuid);
 
-    @Query("select count(rnni) > 0 from RootNetworkNodeInfoEntity rnni LEFT JOIN rnni.rootNetwork rn LEFT JOIN rn.study s " +
+    @Query("SELECT count(rnni) > 0 from RootNetworkNodeInfoEntity rnni LEFT JOIN rnni.rootNetwork rn LEFT JOIN rn.study s " +
         "where s.id = :studyUuid and (rnni.nodeBuildStatus.globalBuildStatus = :buildStatus or rnni.nodeBuildStatus.localBuildStatus = :buildStatus)")
     boolean existsByStudyUuidAndBuildStatus(UUID studyUuid, BuildStatus buildStatus);
 
     List<RootNetworkNodeInfoEntity> getAllByRootNetworkIdAndNodeInfoIdIn(UUID rootNetworkUuid, List<UUID> nodesUuids);
+
+    @Query(value = "SELECT count(rnni) > 0 FROM RootNetworkNodeInfoEntity rnni WHERE rnni.rootNetwork.id = :rootNetworkUuid AND rnni.nodeInfo.idNode IN :nodesUuids AND rnni.blockedBuild = true ")
+    boolean existsByNodeUuidsAndBlockedBuild(UUID rootNetworkUuid, List<UUID> nodesUuids);
 }

src/main/java/org/gridsuite/study/server/repository/rootnetwork/RootNetworkNodeInfoRepository.java

@@ -49,12 +49,12 @@ public class ConsumerService {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(ConsumerService.class);
 
-    static final String RESULT_UUID = "resultUuid";
-    static final String NETWORK_UUID = "networkUuid";
-    static final String NETWORK_ID = "networkId";
-    static final String HEADER_CASE_FORMAT = "caseFormat";
-    static final String HEADER_CASE_NAME = "caseName";
-    static final String HEADER_WITH_RATIO_TAP_CHANGERS = "withRatioTapChangers";
+    private static final String RESULT_UUID = "resultUuid";
+    private static final String NETWORK_UUID = "networkUuid";
+    private static final String NETWORK_ID = "networkId";
+    private static final String HEADER_CASE_FORMAT = "caseFormat";
+    private static final String HEADER_CASE_NAME = "caseName";
+    private static final String HEADER_WITH_RATIO_TAP_CHANGERS = "withRatioTapChangers";
 
     private final ObjectMapper objectMapper;
 
@@ -134,7 +134,7 @@ private void handleBuildResultWorkflow(UUID studyUuid, UUID nodeUuid, UUID rootN
             WorkflowType workflowType = WorkflowType.valueOf(workflowTypeStr);
             if (WorkflowType.RERUN_LOAD_FLOW.equals(workflowType)) {
                 RerunLoadFlowInfos workflowInfos = objectMapper.readValue(URLDecoder.decode(workflowInfosStr, StandardCharsets.UTF_8), RerunLoadFlowInfos.class);
-                studyService.sendLoadflowRequest(studyUuid, nodeUuid, rootNetworkUuid, workflowInfos.getLoadflowResultUuid(), workflowInfos.isWithRatioTapChangers(), workflowInfos.getUserId());
+                studyService.sendLoadflowRequest(studyUuid, nodeUuid, rootNetworkUuid, workflowInfos.getLoadflowResultUuid(), workflowInfos.isWithRatioTapChangers(), false, workflowInfos.getUserId());
             }
         }
     }
@@ -226,54 +226,59 @@ public Consumer<Message<String>> consumeCaseImportSucceeded() {
                     return;
                 }
 
-                UUID caseUuid = receiver.getCaseUuid();
-                UUID studyUuid = receiver.getStudyUuid();
-                String userId = receiver.getUserId();
-                Long startTime = receiver.getStartTime();
-                UUID importReportUuid = receiver.getReportUuid();
-                UUID rootNetworkUuid = receiver.getRootNetworkUuid();
-                CaseImportAction caseImportAction = receiver.getCaseImportAction();
-
-                CaseInfos caseInfos = new CaseInfos(caseUuid, receiver.getOriginalCaseUuid(), caseName, caseFormat);
-                NetworkInfos networkInfos = new NetworkInfos(networkUuid, networkId);
-                try {
-                    switch (caseImportAction) {
-                        case STUDY_CREATION ->
-                            insertStudy(studyUuid, userId, networkInfos, caseInfos, importParameters, importReportUuid);
-                        case ROOT_NETWORK_CREATION ->
-                            studyService.createRootNetwork(studyUuid, RootNetworkInfos.builder()
-                                .id(rootNetworkUuid)
-                                .caseInfos(caseInfos)
-                                .reportUuid(importReportUuid)
-                                .networkInfos(networkInfos)
-                                .importParameters(importParameters)
-                                .build());
-                        case NETWORK_RECREATION ->
-                            studyService.updateNetwork(studyUuid, rootNetworkUuid, networkInfos, userId);
-                        case ROOT_NETWORK_MODIFICATION ->
-                            studyService.modifyRootNetwork(studyUuid, RootNetworkInfos.builder()
-                                .id(rootNetworkUuid)
-                                .networkInfos(networkInfos)
-                                .caseInfos(caseInfos)
-                                .importParameters(importParameters)
-                                .reportUuid(importReportUuid)
-                                .build(), true);
-                    }
-                    caseService.disableCaseExpiration(caseUuid);
-                } catch (Exception e) {
-                    LOGGER.error("Error while importing case", e);
-                } finally {
-                    // if studyEntity is already existing, we don't delete anything in the end of the process
-                    if (caseImportAction == CaseImportAction.STUDY_CREATION) {
-                        studyService.deleteStudyIfNotCreationInProgress(studyUuid);
-                    }
-                    LOGGER.trace("{} for study uuid '{}' : {} seconds", caseImportAction.getLabel(), studyUuid,
-                        TimeUnit.NANOSECONDS.toSeconds(System.nanoTime() - startTime));
-                }
+                handleConsumeCaseImportSucceeded(receiver, networkUuid, networkId, caseName, caseFormat, importParameters);
             }
         };
     }
 
+    private void handleConsumeCaseImportSucceeded(CaseImportReceiver receiver, UUID networkUuid, String networkId, String caseName, String caseFormat, Map<String, String> importParameters) {
+        UUID caseUuid = receiver.getCaseUuid();
+        UUID studyUuid = receiver.getStudyUuid();
+        String userId = receiver.getUserId();
+        Long startTime = receiver.getStartTime();
+        UUID importReportUuid = receiver.getReportUuid();
+        UUID rootNetworkUuid = receiver.getRootNetworkUuid();
+        CaseImportAction caseImportAction = receiver.getCaseImportAction();
+
+        CaseInfos caseInfos = new CaseInfos(caseUuid, receiver.getOriginalCaseUuid(), caseName, caseFormat);
+        NetworkInfos networkInfos = new NetworkInfos(networkUuid, networkId);
+        try {
+            switch (caseImportAction) {
+                case STUDY_CREATION ->
+                    insertStudy(studyUuid, userId, networkInfos, caseInfos, importParameters, importReportUuid);
+                case ROOT_NETWORK_CREATION -> studyService.createRootNetwork(studyUuid, RootNetworkInfos.builder()
+                    .id(rootNetworkUuid)
+                    .caseInfos(caseInfos)
+                    .reportUuid(importReportUuid)
+                    .networkInfos(networkInfos)
+                    .importParameters(importParameters)
+                    .build());
+                case NETWORK_RECREATION -> studyService.updateNetwork(studyUuid, rootNetworkUuid, networkInfos, userId);
+                case ROOT_NETWORK_MODIFICATION -> studyService.modifyRootNetwork(studyUuid, RootNetworkInfos.builder()
+                    .id(rootNetworkUuid)
+                    .networkInfos(networkInfos)
+                    .caseInfos(caseInfos)
+                    .importParameters(importParameters)
+                    .reportUuid(importReportUuid)
+                    .build());
+            }
+            caseService.disableCaseExpiration(caseUuid);
+        } catch (Exception e) {
+            LOGGER.error("Error while importing case", e);
+        } finally {
+            // if studyEntity is already existing, we don't delete anything in the end of the process
+            if (caseImportAction == CaseImportAction.STUDY_CREATION) {
+                studyService.deleteStudyIfNotCreationInProgress(studyUuid);
+            }
+            if (caseImportAction == CaseImportAction.ROOT_NETWORK_MODIFICATION) {
+                UUID rootNodeUuid = networkModificationTreeService.getStudyRootNodeUuid(studyUuid);
+                networkModificationTreeService.invalidateBlockedBuildNodeTree(rootNetworkUuid, rootNodeUuid);
+            }
+            LOGGER.trace("{} for study uuid '{}' : {} seconds", caseImportAction.getLabel(), studyUuid,
+                TimeUnit.NANOSECONDS.toSeconds(System.nanoTime() - startTime));
+        }
+    }
+
     private void insertStudy(UUID studyUuid, String userId, NetworkInfos networkInfos, CaseInfos caseInfos,
                              Map<String, String> importParameters, UUID importReportUuid) {
         UserProfileInfos userProfileInfos = getUserProfile(userId);
@@ -521,7 +526,7 @@ public void consumeCalculationFailed(Message<String> msg, ComputationType comput
             }
         }
         if (!Strings.isBlank(receiver)) {
-            NodeReceiver receiverObj;
+            NodeReceiver receiverObj = null;
             try {
                 receiverObj = objectMapper.readValue(URLDecoder.decode(receiver, StandardCharsets.UTF_8), NodeReceiver.class);
 
@@ -530,24 +535,18 @@ public void consumeCalculationFailed(Message<String> msg, ComputationType comput
                 // delete computation results from the databases
                 // ==> will probably be removed soon because it prevents the front from recovering the resultId ; or 'null' parameter will be replaced by null like in VOLTAGE_INITIALIZATION
                 rootNetworkNodeInfoService.updateComputationResultUuid(receiverObj.getNodeUuid(), receiverObj.getRootNetworkUuid(), resultUuid, computationType);
-
-                UUID studyUuid = networkModificationTreeService.getStudyUuidForNodeId(receiverObj.getNodeUuid());
-
-                if (computationType == LOAD_FLOW) {
-                    // since running loadflow impacts the network linked to the node "nodeUuid", we need to invalidate its children nodes to prevent inconsistencies
-                    studyService.invalidateNodeTree(studyUuid, receiverObj.getNodeUuid(), receiverObj.getRootNetworkUuid(), InvalidateNodeTreeParameters.ONLY_CHILDREN);
-                }
-
-                // send notification for failed computation
-                notificationService.emitStudyError(
-                    studyUuid,
-                    receiverObj.getNodeUuid(),
-                    receiverObj.getRootNetworkUuid(),
-                    computationType.getUpdateFailedType(),
-                    errorMessage,
-                    userId);
             } catch (JsonProcessingException e) {
                 LOGGER.error(e.toString());
+            } finally {
+                if (receiverObj != null) {
+                    if (computationType == LOAD_FLOW) {
+                        networkModificationTreeService.invalidateBlockedBuildNodeTree(receiverObj.getRootNetworkUuid(), receiverObj.getNodeUuid());
+                    }
+
+                    // send notification for failed computation
+                    UUID studyUuid = networkModificationTreeService.getStudyUuidForNodeId(receiverObj.getNodeUuid());
+                    notificationService.emitStudyError(studyUuid, receiverObj.getNodeUuid(), receiverObj.getRootNetworkUuid(), computationType.getUpdateFailedType(), errorMessage, userId);
+                }
             }
         }
     }
@@ -601,22 +600,22 @@ private void consumeLoadFlowResult(Message<String> msg, boolean withRatioTapChan
         Optional.ofNullable(msg.getHeaders().get(RESULT_UUID, String.class))
             .map(UUID::fromString)
             .ifPresent(resultUuid -> getNodeReceiver(msg).ifPresent(receiverObj -> {
-                LOGGER.info("{} result '{}' available for node '{}'",
-                    LOAD_FLOW.getLabel(),
-                    resultUuid,
-                    receiverObj.getNodeUuid());
-
-                // update DB
-                rootNetworkNodeInfoService.updateLoadflowResultUuid(receiverObj.getNodeUuid(), receiverObj.getRootNetworkUuid(), resultUuid, withRatioTapChangers);
-
-                UUID studyUuid = networkModificationTreeService.getStudyUuidForNodeId(receiverObj.getNodeUuid());
+                try {
+                    LOGGER.info("{} result '{}' available for node '{}'",
+                        LOAD_FLOW.getLabel(),
+                        resultUuid,
+                        receiverObj.getNodeUuid());
 
-                // since running loadflow impacts the network linked to the node "nodeUuid", we need to invalidate its children nodes to prevent inconsistencies
-                studyService.invalidateNodeTree(studyUuid, receiverObj.getNodeUuid(), receiverObj.getRootNetworkUuid(), InvalidateNodeTreeParameters.ONLY_CHILDREN);
+                    // update DB
+                    rootNetworkNodeInfoService.updateLoadflowResultUuid(receiverObj.getNodeUuid(), receiverObj.getRootNetworkUuid(), resultUuid, withRatioTapChangers);
+                } finally {
+                    networkModificationTreeService.invalidateBlockedBuildNodeTree(receiverObj.getRootNetworkUuid(), receiverObj.getNodeUuid());
 
-                // send notifications
-                notificationService.emitStudyChanged(studyUuid, receiverObj.getNodeUuid(), receiverObj.getRootNetworkUuid(), LOAD_FLOW.getUpdateStatusType());
-                notificationService.emitStudyChanged(studyUuid, receiverObj.getNodeUuid(), receiverObj.getRootNetworkUuid(), LOAD_FLOW.getUpdateResultType());
+                    // send notifications
+                    UUID studyUuid = networkModificationTreeService.getStudyUuidForNodeId(receiverObj.getNodeUuid());
+                    notificationService.emitStudyChanged(studyUuid, receiverObj.getNodeUuid(), receiverObj.getRootNetworkUuid(), LOAD_FLOW.getUpdateStatusType());
+                    notificationService.emitStudyChanged(studyUuid, receiverObj.getNodeUuid(), receiverObj.getRootNetworkUuid(), LOAD_FLOW.getUpdateResultType());
+                }
             }));
     }