Block unbuild when computation (#847)

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

Author: SlimaneAmar

src/main/java/org/gridsuite/study/server/service/ConsumerService.java

@@ -533,9 +533,7 @@ public void consumeCalculationFailed(Message<String> msg, ComputationType comput
                 LOGGER.error(e.toString());
             } finally {
                 if (receiverObj != null) {
-                    if (computationType == LOAD_FLOW) {
-                        networkModificationTreeService.unblockNodeTree(receiverObj.getRootNetworkUuid(), receiverObj.getNodeUuid());
-                    }
+                    handleUnblockNode(receiverObj, computationType);
 
                     // send notification for failed computation
                     UUID studyUuid = networkModificationTreeService.getStudyUuidForNodeId(receiverObj.getNodeUuid());
@@ -548,7 +546,7 @@ public void consumeCalculationFailed(Message<String> msg, ComputationType comput
     public void consumeCalculationStopped(Message<String> msg, ComputationType computationType) {
         String receiver = msg.getHeaders().get(HEADER_RECEIVER, String.class);
         if (!Strings.isBlank(receiver)) {
-            NodeReceiver receiverObj;
+            NodeReceiver receiverObj = null;
             try {
                 receiverObj = objectMapper.readValue(URLDecoder.decode(receiver, StandardCharsets.UTF_8), NodeReceiver.class);
 
@@ -561,6 +559,10 @@ public void consumeCalculationStopped(Message<String> msg, ComputationType compu
                 LOGGER.info("{} stopped for node '{}'", computationType.getLabel(), receiverObj.getNodeUuid());
             } catch (JsonProcessingException e) {
                 LOGGER.error(e.toString());
+            } finally {
+                if (receiverObj != null) {
+                    handleUnblockNode(receiverObj, computationType);
+                }
             }
         }
     }
@@ -590,27 +592,12 @@ public void consumeCalculationCancelFailed(Message<String> msg, ComputationType
         }
     }
 
-    private void consumeLoadFlowResult(Message<String> msg, boolean withRatioTapChangers) {
-        Optional.ofNullable(msg.getHeaders().get(RESULT_UUID, String.class))
-            .map(UUID::fromString)
-            .ifPresent(resultUuid -> getNodeReceiver(msg).ifPresent(receiverObj -> {
-                try {
-                    LOGGER.info("{} result '{}' available for node '{}'",
-                        LOAD_FLOW.getLabel(),
-                        resultUuid,
-                        receiverObj.getNodeUuid());
-
-                    // update DB
-                    rootNetworkNodeInfoService.updateLoadflowResultUuid(receiverObj.getNodeUuid(), receiverObj.getRootNetworkUuid(), resultUuid, withRatioTapChangers);
-                } finally {
-                    networkModificationTreeService.unblockNodeTree(receiverObj.getRootNetworkUuid(), receiverObj.getNodeUuid());
-
-                    // 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());
-                }
-            }));
+    private void handleUnblockNode(NodeReceiver receiverObj, ComputationType computationType) {
+        if (computationType == ComputationType.LOAD_FLOW && networkModificationTreeService.isSecurityNode(receiverObj.getNodeUuid())) {
+            networkModificationTreeService.unblockNodeTree(receiverObj.getRootNetworkUuid(), receiverObj.getNodeUuid());
+        } else {
+            networkModificationTreeService.unblockNode(receiverObj.getRootNetworkUuid(), receiverObj.getNodeUuid());
+        }
     }
 
     public void consumeCalculationDebug(Message<String> msg, ComputationType computationType) {
@@ -635,11 +622,18 @@ public void consumeCalculationResult(Message<String> msg, ComputationType comput
                     receiverObj.getNodeUuid());
 
                 // update DB
-                rootNetworkNodeInfoService.updateComputationResultUuid(receiverObj.getNodeUuid(), receiverObj.getRootNetworkUuid(), resultUuid, computationType);
+                if (computationType == ComputationType.LOAD_FLOW) {
+                    Boolean withRatioTapChangers = msg.getHeaders().get(HEADER_WITH_RATIO_TAP_CHANGERS, Boolean.class);
+                    rootNetworkNodeInfoService.updateLoadflowResultUuid(receiverObj.getNodeUuid(), receiverObj.getRootNetworkUuid(), resultUuid, withRatioTapChangers);
+                } else {
+                    rootNetworkNodeInfoService.updateComputationResultUuid(receiverObj.getNodeUuid(), receiverObj.getRootNetworkUuid(), resultUuid, computationType);
+                }
 
-                UUID studyUuid = networkModificationTreeService.getStudyUuidForNodeId(receiverObj.getNodeUuid());
+                // unblock node
+                handleUnblockNode(receiverObj, computationType);
 
                 // send notifications
+                UUID studyUuid = networkModificationTreeService.getStudyUuidForNodeId(receiverObj.getNodeUuid());
                 notificationService.emitStudyChanged(studyUuid, receiverObj.getNodeUuid(), receiverObj.getRootNetworkUuid(), computationType.getUpdateStatusType());
                 notificationService.emitStudyChanged(studyUuid, receiverObj.getNodeUuid(), receiverObj.getRootNetworkUuid(), computationType.getUpdateResultType());
             }));
@@ -750,10 +744,7 @@ public Consumer<Message<String>> consumeSensitivityAnalysisFailed() {
 
     @Bean
     public Consumer<Message<String>> consumeLoadFlowResult() {
-        return message -> {
-            Boolean withRatioTapChangers = message.getHeaders().get(HEADER_WITH_RATIO_TAP_CHANGERS, Boolean.class);
-            consumeLoadFlowResult(message, Boolean.TRUE.equals(withRatioTapChangers));
-        };
+        return message -> consumeCalculationResult(message, LOAD_FLOW);
     }
 
     @Bean

src/main/java/org/gridsuite/study/server/service/NetworkModificationTreeService.java

@@ -948,6 +948,16 @@ public void unblockNodeTree(UUID rootNetworkUuid, UUID nodeUuid) {
         rootNetworkNodeInfoService.unblockNodes(rootNetworkUuid, getNodeTreeUuids(nodeUuid));
     }
 
+    @Transactional
+    public void unblockNode(UUID rootNetworkUuid, UUID nodeUuid) {
+        rootNetworkNodeInfoService.unblockNodes(rootNetworkUuid, List.of(nodeUuid));
+    }
+
+    @Transactional
+    public void blockNode(UUID rootNetworkUuid, UUID nodeUuid) {
+        rootNetworkNodeInfoService.blockNodes(rootNetworkUuid, List.of(nodeUuid));
+    }
+
     /**
      * Recursively iterate through *nodeUuid* parents until one of them match one of the following conditions :<br>
      * - it is of type ROOT<br>

src/main/java/org/gridsuite/study/server/service/RootNetworkNodeInfoService.java

@@ -406,8 +406,12 @@ public void assertNoBlockedNode(UUID rootNetworkUuid, List<UUID> nodesUuids) {
         }
     }
 
+    public void blockNodes(UUID rootNetworkUuid, List<UUID> nodesUuids) {
+        getRootNetworkNodes(rootNetworkUuid, nodesUuids).forEach(rnn -> rnn.setBlockedNode(true));
+    }
+
     public void unblockNodes(UUID rootNetworkUuid, List<UUID> nodesUuids) {
-        getRootNetworkNodes(rootNetworkUuid, nodesUuids).stream().forEach(rnn -> rnn.setBlockedNode(false));
+        getRootNetworkNodes(rootNetworkUuid, nodesUuids).forEach(rnn -> rnn.setBlockedNode(false));
     }
 
     private void addLink(NetworkModificationNodeInfoEntity nodeInfoEntity, RootNetworkEntity rootNetworkEntity, RootNetworkNodeInfoEntity rootNetworkNodeInfoEntity) {