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/types/messaging/ProcessExecutionStep.java

@@ -33,4 +33,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

@@ -12,6 +12,7 @@
 import io.swagger.v3.oas.annotations.responses.ApiResponses;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import org.gridsuite.monitor.commons.types.messaging.ProcessExecutionStep;
+import org.gridsuite.monitor.commons.types.processconfig.SecurityAnalysisConfig;
 import org.gridsuite.monitor.commons.types.processexecution.ProcessType;
 import org.gridsuite.monitor.server.dto.processexecution.ProcessExecution;
 import org.gridsuite.monitor.server.dto.report.ReportPage;
@@ -112,5 +113,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 = processExecutionService.executeProcessUsingServers(caseUuid, userId, securityAnalysisConfig);
+        return ResponseEntity.ok(executionId);
+    }
 }
 

monitor-server/src/main/java/org/gridsuite/monitor/server/entities/processexecution/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/messaging/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);
     }

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

@@ -0,0 +1,168 @@
+/**
+ * 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.types.messaging.ProcessExecutionStep;
+import org.gridsuite.monitor.commons.types.messaging.ProcessRunMessage;
+import org.gridsuite.monitor.commons.types.processconfig.ProcessConfig;
+import org.gridsuite.monitor.commons.types.processconfig.SecurityAnalysisConfig;
+import org.gridsuite.monitor.commons.types.processexecution.ProcessStatus;
+import org.gridsuite.monitor.commons.types.processexecution.StepStatus;
+import org.gridsuite.monitor.commons.types.result.ResultType;
+import org.gridsuite.monitor.server.services.processexecution.ProcessExecutionService;
+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 ProcessExecutionService processExecutionService;
+
+    private record ProcessExecutionContext(
+        UUID applyModificationsStepId,
+        UUID securityAnalysisStepId,
+        UUID caseUuid,
+        UUID securityAnalysisParametersUuid,
+        UUID loadflowParametersUuid
+    ) { }
+
+    private final Map<UUID, ProcessExecutionContext> processExecutionContexts = new ConcurrentHashMap<>();
+
+    @Autowired
+    ConsumerServiceUsingServers(NetworkModificationRestService networkModificationRestService,
+                                SecurityAnalysisRestService securityAnalysisRestService,
+                                ProcessExecutionService processExecutionService) {
+        this.networkModificationRestService = networkModificationRestService;
+        this.securityAnalysisRestService = securityAnalysisRestService;
+        this.processExecutionService = processExecutionService;
+    }
+
+    @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 = processConfig.modificationUuids();
+
+            UUID applyModificationsStepId = UUID.randomUUID();
+            UUID securityAnalysisStepId = UUID.randomUUID();
+
+            UUID securityAnalysisParametersUuid = null;
+            UUID loadflowParametersUuid = null;
+            switch (processConfig.processType()) {
+                case SECURITY_ANALYSIS -> {
+                    securityAnalysisParametersUuid = ((SecurityAnalysisConfig) processConfig).securityAnalysisParametersUuid();
+                    loadflowParametersUuid = ((SecurityAnalysisConfig) processConfig).loadflowParametersUuid();
+                }
+            }
+
+            processExecutionContexts.put(executionId, new ProcessExecutionContext(
+                applyModificationsStepId,
+                securityAnalysisStepId,
+                caseUuid,
+                securityAnalysisParametersUuid,
+                loadflowParametersUuid
+            ));
+
+            processExecutionService.updateExecutionStatus(executionId, ProcessStatus.RUNNING, null, Instant.now(), null);
+            processExecutionService.updateStepStatus(executionId,
+                new ProcessExecutionStep(applyModificationsStepId, "APPLY_MODIFICATIONS", 0, StepStatus.RUNNING, null, null, null, Instant.now(), null, null));
+            processExecutionService.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;
+            }
+
+            processExecutionService.updateStepStatus(executionId,
+                new ProcessExecutionStep(processExecutionContext.applyModificationsStepId(), stepType, 0, stepStatus, null, null, reportUuid, null, Instant.now(), caseResultUuid));
+            processExecutionService.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.securityAnalysisParametersUuid(), processExecutionContext.loadflowParametersUuid);
+            } 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;
+            }
+
+            processExecutionService.updateStepStatus(executionId,
+                new ProcessExecutionStep(processExecutionContext.securityAnalysisStepId(), stepType, 1, stepStatus, resultUuid, ResultType.SECURITY_ANALYSIS, reportUuid, null, Instant.now(), caseResultUuid));
+            processExecutionService.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/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/SecurityAnalysisRestService.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.UUID;
+
+/**
+ * @author Franck Lecuyer <franck.lecuyer at rte-france.com>
+ */
+@Service
+public class SecurityAnalysisRestService {
+    private static final String SECURITY_ANALYSIS_SERVER_API_VERSION = "v1";
+    private static final String DELIMITER = "/";
+
+    private final RestTemplate securityAnalysisServerRest;
+    private final String securityAnalysisServerBaseUri;
+
+    public SecurityAnalysisRestService(@Value("${gridsuite.services.security-analysis-server.base-uri:http://security-analysis-server/}") String securityAnalysisServerBaseUri,
+                                       RestTemplateBuilder restTemplateBuilder) {
+        this.securityAnalysisServerRest = restTemplateBuilder.build();
+        this.securityAnalysisServerBaseUri = securityAnalysisServerBaseUri;
+    }
+
+    public void runSecurityAnalysis(UUID caseUuid, UUID executionId, UUID securityAnalysisParametersUuid, UUID loadflowParametersUuid) {
+        var uriComponentsBuilder = UriComponentsBuilder.fromPath(DELIMITER + SECURITY_ANALYSIS_SERVER_API_VERSION + DELIMITER + "/cases/{caseUuid}/run-and-save");
+        var path = uriComponentsBuilder
+            .queryParam("executionUuid", executionId)
+            .queryParam("parametersUuid", securityAnalysisParametersUuid)
+            .queryParam("loadFlowParametersUuid", loadflowParametersUuid)
+            .buildAndExpand(caseUuid)
+            .toUriString();
+
+        HttpHeaders headers = new HttpHeaders();
+        headers.setContentType(MediaType.APPLICATION_JSON);
+        HttpEntity httpEntity = new HttpEntity<>(null, headers);
+
+        securityAnalysisServerRest.exchange(securityAnalysisServerBaseUri + path, HttpMethod.POST, httpEntity, Void.class);
+    }
+}