POC : use existing servers to run cyclic chain

monitor-commons/src/main/java/org/gridsuite/monitor/commons/CaseResultInfos.java

@@ -0,0 +1,38 @@
+/**
+ * Copyright (c) 2026, RTE (http://www.rte-france.com)
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+package org.gridsuite.monitor.commons;
+
+import lombok.Getter;
+
+import java.util.UUID;
+
+/**
+ * @author Franck Lecuyer <franck.lecuyer at rte-france.com>
+ */
+@Getter
+public class CaseResultInfos {
+    private final UUID caseResultUuid;
+
+    private final UUID executionUuid;
+
+    private final UUID reportUuid;
+
+    private final UUID resultUuid;
+
+    private final String stepType;
+
+    private final String status;
+
+    public CaseResultInfos(UUID caseResultUuid, UUID executionUuid, UUID reportUuid, UUID resultUuid, String stepType, String status) {
+        this.caseResultUuid = caseResultUuid;
+        this.executionUuid = executionUuid;
+        this.reportUuid = reportUuid;
+        this.resultUuid = resultUuid;
+        this.stepType = stepType;
+        this.status = status;
+    }
+}

monitor-commons/src/main/java/org/gridsuite/monitor/commons/ProcessExecutionStep.java

@@ -31,4 +31,5 @@ public class ProcessExecutionStep {
     private UUID reportId;
     private Instant startedAt;
     private Instant completedAt;
+    private UUID resultCaseId;
 }

monitor-server/src/main/java/org/gridsuite/monitor/server/controllers/MonitorController.java

@@ -111,5 +111,16 @@ public ResponseEntity<Void> deleteExecution(@PathVariable UUID executionId) {
             ResponseEntity.ok().build() :
             ResponseEntity.notFound().build();
     }
+
+    @PostMapping("/execute/security-analysis-using-servers")
+    @Operation(summary = "Execute a security analysis process using existing servers (network-modification-server and security-analysis-server)")
+    @ApiResponses(value = {@ApiResponse(responseCode = "200", description = "The security analysis execution has been started")})
+    public ResponseEntity<UUID> executeSecurityAnalysisUsingServers(
+            @RequestParam UUID caseUuid,
+            @RequestBody SecurityAnalysisConfig securityAnalysisConfig,
+            @RequestHeader(HEADER_USER_ID) String userId) {
+        UUID executionId = monitorService.executeProcessUsingServers(caseUuid, userId, securityAnalysisConfig);
+        return ResponseEntity.ok(executionId);
+    }
 }
 

monitor-server/src/main/java/org/gridsuite/monitor/server/entities/ProcessExecutionStepEntity.java

@@ -54,4 +54,7 @@ public class ProcessExecutionStepEntity {
 
     @Column
     private Instant completedAt;
+
+    @Column
+    private UUID resultCaseId;
 }

monitor-server/src/main/java/org/gridsuite/monitor/server/mapper/ProcessExecutionStepMapper.java

@@ -25,6 +25,7 @@ public static ProcessExecutionStep toDto(ProcessExecutionStepEntity entity) {
                 .reportId(entity.getReportId())
                 .startedAt(entity.getStartedAt())
                 .completedAt(entity.getCompletedAt())
+                .resultCaseId(entity.getResultCaseId())
                 .build();
     }
 }

monitor-server/src/main/java/org/gridsuite/monitor/server/services/ConsumerServiceUsingServers.java

@@ -0,0 +1,167 @@
+/**
+ * Copyright (c) 2026, RTE (http://www.rte-france.com)
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+package org.gridsuite.monitor.server.services;
+
+import org.gridsuite.monitor.commons.CaseResultInfos;
+import org.gridsuite.monitor.commons.ProcessConfig;
+import org.gridsuite.monitor.commons.ProcessExecutionStep;
+import org.gridsuite.monitor.commons.ProcessRunMessage;
+import org.gridsuite.monitor.commons.ProcessStatus;
+import org.gridsuite.monitor.commons.ResultType;
+import org.gridsuite.monitor.commons.SecurityAnalysisConfig;
+import org.gridsuite.monitor.commons.StepStatus;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.messaging.Message;
+
+import java.time.Instant;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Consumer;
+
+/**
+ * @author Franck Lecuyer <franck.lecuyer at rte-france.com>
+ */
+@Configuration
+public class ConsumerServiceUsingServers {
+    private static final Logger LOGGER = LoggerFactory.getLogger(ConsumerServiceUsingServers.class);
+
+    private final NetworkModificationRestService networkModificationRestService;
+    private final SecurityAnalysisRestService securityAnalysisRestService;
+    private final MonitorService monitorService;
+
+    private record ProcessExecutionContext(
+        UUID applyModificationsStepId,
+        UUID securityAnalysisStepId,
+        UUID caseUuid,
+        List<String> contingencies,
+        UUID parametersUuid
+    ) { }
+
+    private final Map<UUID, ProcessExecutionContext> processExecutionContexts = new ConcurrentHashMap<>();
+
+    @Autowired
+    ConsumerServiceUsingServers(NetworkModificationRestService networkModificationRestService,
+                                SecurityAnalysisRestService securityAnalysisRestService,
+                                MonitorService monitorService) {
+        this.networkModificationRestService = networkModificationRestService;
+        this.securityAnalysisRestService = securityAnalysisRestService;
+        this.monitorService = monitorService;
+    }
+
+    @Bean
+    public <T extends ProcessConfig> Consumer<Message<ProcessRunMessage<T>>> consumeRunUsingServers() {
+        // consume message to launch process
+        //
+        return message -> {
+            ProcessRunMessage<T> processRunMessage = message.getPayload();
+            UUID caseUuid = processRunMessage.caseUuid();
+            UUID executionId = processRunMessage.executionId();
+
+            ProcessConfig processConfig = processRunMessage.config();
+            List<UUID> modificationUuids = ((SecurityAnalysisConfig) processConfig).modificationUuids();
+
+            UUID applyModificationsStepId = UUID.randomUUID();
+            UUID securityAnalysisStepId = UUID.randomUUID();
+
+            List<String> contingencies = null;
+            UUID parametersUuid = null;
+            switch (processConfig.processType()) {
+                case SECURITY_ANALYSIS -> {
+                    contingencies = ((SecurityAnalysisConfig) processConfig).contingencies();
+                    parametersUuid = ((SecurityAnalysisConfig) processConfig).parametersUuid();
+                }
+            }
+
+            processExecutionContexts.put(executionId, new ProcessExecutionContext(
+                applyModificationsStepId,
+                securityAnalysisStepId,
+                caseUuid,
+                contingencies,
+                parametersUuid
+            ));
+
+            monitorService.updateExecutionStatus(executionId, ProcessStatus.RUNNING, null, Instant.now(), null);
+            monitorService.updateStepStatus(executionId,
+                new ProcessExecutionStep(applyModificationsStepId, "APPLY_MODIFICATIONS", 0, StepStatus.RUNNING, null, null, null, Instant.now(), null, null));
+            monitorService.updateStepStatus(executionId,
+                new ProcessExecutionStep(securityAnalysisStepId, "SECURITY_ANALYSIS", 1, StepStatus.SCHEDULED, null, null, null, null, null, null));
+
+            // call network-modification-server to apply modifications
+            networkModificationRestService.applyModifications(caseUuid, executionId, modificationUuids);
+        };
+    }
+
+    @Bean
+    public Consumer<Message<CaseResultInfos>> consumeNetworkModifications() {
+        // consume message received from network-modification-server
+        //
+        return message -> {
+            CaseResultInfos caseResultInfos = message.getPayload();
+            UUID caseResultUuid = caseResultInfos.getCaseResultUuid();
+            UUID executionId = caseResultInfos.getExecutionUuid();
+            String stepType = caseResultInfos.getStepType();
+            UUID reportUuid = caseResultInfos.getReportUuid();
+
+            StepStatus stepStatus = StepStatus.valueOf(caseResultInfos.getStatus());
+
+            ProcessExecutionContext processExecutionContext = processExecutionContexts.get(executionId);
+            if (processExecutionContext == null) {
+                LOGGER.error("Process execution context not found for executionId: {}", executionId);
+                return;
+            }
+
+            monitorService.updateStepStatus(executionId,
+                new ProcessExecutionStep(processExecutionContext.applyModificationsStepId(), stepType, 0, stepStatus, null, null, reportUuid, null, Instant.now(), caseResultUuid));
+            monitorService.updateStepStatus(executionId,
+                new ProcessExecutionStep(processExecutionContext.securityAnalysisStepId(), "SECURITY_ANALYSIS", 1,
+                    stepStatus == StepStatus.COMPLETED ? StepStatus.RUNNING : StepStatus.SKIPPED,
+                    null, null, null, Instant.now(), null, null));
+
+            if (stepStatus == StepStatus.COMPLETED) {
+                // call security-analysis-server to run security analysis
+                securityAnalysisRestService.runSecurityAnalysis(caseResultUuid, executionId, processExecutionContext.contingencies(), processExecutionContext.parametersUuid());
+            } else {
+                processExecutionContexts.remove(executionId);
+            }
+        };
+    }
+
+    @Bean
+    public Consumer<Message<CaseResultInfos>> consumeSecurityAnalysis() {
+        // consume message received from security-analysis-server
+        //
+        return message -> {
+            CaseResultInfos caseResultInfos = message.getPayload();
+            UUID executionId = caseResultInfos.getExecutionUuid();
+            String stepType = caseResultInfos.getStepType();
+            UUID reportUuid = caseResultInfos.getReportUuid();
+            UUID resultUuid = caseResultInfos.getResultUuid();
+            StepStatus stepStatus = StepStatus.valueOf(caseResultInfos.getStatus());
+            UUID caseResultUuid = caseResultInfos.getCaseResultUuid();
+
+            ProcessExecutionContext processExecutionContext = processExecutionContexts.get(executionId);
+            if (processExecutionContext == null) {
+                LOGGER.error("Process execution context not found for executionId: {}", executionId);
+                return;
+            }
+
+            monitorService.updateStepStatus(executionId,
+                new ProcessExecutionStep(processExecutionContext.securityAnalysisStepId(), stepType, 1, stepStatus, resultUuid, ResultType.SECURITY_ANALYSIS, reportUuid, null, Instant.now(), caseResultUuid));
+            monitorService.updateExecutionStatus(executionId,
+                stepStatus == StepStatus.COMPLETED ? ProcessStatus.COMPLETED : ProcessStatus.FAILED,
+                null, null, Instant.now());
+
+            processExecutionContexts.remove(executionId);
+        };
+    }
+}

monitor-server/src/main/java/org/gridsuite/monitor/server/services/MonitorService.java

@@ -106,11 +106,16 @@ private void updateStep(ProcessExecutionEntity execution, ProcessExecutionStepEn
                     existingStep.setStatus(stepEntity.getStatus());
                     existingStep.setStepType(stepEntity.getStepType());
                     existingStep.setStepOrder(stepEntity.getStepOrder());
-                    existingStep.setStartedAt(stepEntity.getStartedAt());
-                    existingStep.setCompletedAt(stepEntity.getCompletedAt());
+                    if (stepEntity.getStartedAt() != null) {
+                        existingStep.setStartedAt(stepEntity.getStartedAt());
+                    }
+                    if (stepEntity.getCompletedAt() != null) {
+                        existingStep.setCompletedAt(stepEntity.getCompletedAt());
+                    }
                     existingStep.setResultId(stepEntity.getResultId());
                     existingStep.setResultType(stepEntity.getResultType());
                     existingStep.setReportId(stepEntity.getReportId());
+                    existingStep.setResultCaseId(stepEntity.getResultCaseId());
                 },
                 () -> steps.add(stepEntity));
     }
@@ -146,6 +151,7 @@ private ProcessExecutionStepEntity toStepEntity(ProcessExecutionStep processExec
                 .reportId(processExecutionStep.getReportId())
                 .startedAt(processExecutionStep.getStartedAt())
                 .completedAt(processExecutionStep.getCompletedAt())
+                .resultCaseId(processExecutionStep.getResultCaseId())
                 .build();
     }
 
@@ -239,4 +245,25 @@ public boolean deleteExecution(UUID executionId) {
         }
         return false;
     }
+
+    @Transactional
+    public UUID executeProcessUsingServers(UUID caseUuid, String userId, ProcessConfig processConfig) {
+        ProcessExecutionEntity execution = ProcessExecutionEntity.builder()
+            .type(processConfig.processType().name())
+            .caseUuid(caseUuid)
+            .status(ProcessStatus.SCHEDULED)
+            .scheduledAt(Instant.now())
+            .userId(userId)
+            .executionEnvName("using-servers-env")
+            .build();
+        executionRepository.save(execution);
+
+        String bindingName = switch (processConfig.processType()) {
+            case SECURITY_ANALYSIS -> "publishRunSecurityAnalysisUsingServers-out-0";
+        };
+        notificationService.sendProcessRunMessage(caseUuid, processConfig, execution.getId(), null, bindingName);
+
+        return execution.getId();
+    }
+
 }

monitor-server/src/main/java/org/gridsuite/monitor/server/services/NetworkModificationRestService.java

@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) 2026, RTE (http://www.rte-france.com)
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+package org.gridsuite.monitor.server.services;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.web.client.RestTemplateBuilder;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.MediaType;
+import org.springframework.stereotype.Service;
+import org.springframework.web.client.RestTemplate;
+import org.springframework.web.util.UriComponentsBuilder;
+
+import java.util.List;
+import java.util.UUID;
+
+/**
+ * @author Franck Lecuyer <franck.lecuyer at rte-france.com>
+ */
+@Service
+public class NetworkModificationRestService {
+    private static final String NETWORK_MODIFICATION_SERVER_API_VERSION = "v1";
+    private static final String DELIMITER = "/";
+
+    private final RestTemplate networkModificationServerRest;
+    private final String networkModificationServerBaseUri;
+
+    public NetworkModificationRestService(@Value("${gridsuite.services.network-modification-server.base-uri:http://network-modification-server/}") String networkModificationServerBaseUri,
+                                          RestTemplateBuilder restTemplateBuilder) {
+        this.networkModificationServerRest = restTemplateBuilder.build();
+        this.networkModificationServerBaseUri = networkModificationServerBaseUri;
+    }
+
+    public void applyModifications(UUID caseUuid, UUID executionId, List<UUID> modificationUuids) {
+        var uriComponentsBuilder = UriComponentsBuilder.fromPath(DELIMITER + NETWORK_MODIFICATION_SERVER_API_VERSION + DELIMITER + "cases/{caseUuid}/network-composite-modifications");
+        var path = uriComponentsBuilder
+            .queryParam("executionUuid", executionId)
+            .queryParam("uuids", modificationUuids)
+            .buildAndExpand(caseUuid)
+            .toUriString();
+
+        HttpHeaders headers = new HttpHeaders();
+        headers.setContentType(MediaType.APPLICATION_JSON);
+        HttpEntity httpEntity = new HttpEntity<>(null, headers);
+
+        networkModificationServerRest.exchange(networkModificationServerBaseUri + path, HttpMethod.POST, httpEntity, Void.class);
+    }
+}

monitor-server/src/main/java/org/gridsuite/monitor/server/services/NotificationService.java

@@ -27,6 +27,10 @@ public void sendProcessRunMessage(UUID caseUuid, ProcessConfig processConfig, UU
         String bindingName = switch (processConfig.processType()) {
             case SECURITY_ANALYSIS -> "publishRunSecurityAnalysis-out-0";
         };
+        sendProcessRunMessage(caseUuid, processConfig, executionId, bindingName, debugFileLocation);
+    }
+
+    public void sendProcessRunMessage(UUID caseUuid, ProcessConfig processConfig, UUID executionId, String bindingName, String debugFileLocation) {
         ProcessRunMessage<?> message = new ProcessRunMessage<>(executionId, caseUuid, processConfig, debugFileLocation);
         publisher.send(bindingName, message);
     }