Add logs on voltage limits

lombok.config

@@ -0,0 +1 @@
+import target/configs/powsybl-build-tools.jar!powsybl-build-tools/lombok.config

pom.xml

@@ -189,21 +189,11 @@
             <artifactId>powsybl-iidm-test</artifactId>
             <scope>test</scope>
         </dependency>
-        <dependency>
-            <groupId>com.squareup.okhttp3</groupId>
-            <artifactId>okhttp</artifactId>
-            <scope>test</scope>
-        </dependency>
         <dependency>
             <groupId>com.squareup.okhttp3</groupId>
             <artifactId>mockwebserver</artifactId>
             <scope>test</scope>
         </dependency>
-        <dependency>
-            <groupId>junit</groupId>
-            <artifactId>junit</artifactId>
-            <scope>test</scope>
-        </dependency>
         <dependency>
             <groupId>org.assertj</groupId>
             <artifactId>assertj-guava</artifactId>

src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitRunContext.java

@@ -6,35 +6,32 @@
  */
 package org.gridsuite.voltageinit.server.service;
 
-import lombok.Getter;
+import com.powsybl.commons.reporter.Reporter;
+import com.powsybl.commons.reporter.ReporterModel;
+import lombok.Data;
 
+import java.util.HashMap;
 import java.util.Map;
 import java.util.Objects;
 import java.util.UUID;
 
 /**
  * @author Etienne Homer <etienne.homer at rte-france.com>
  */
-@Getter
+@Data
 public class VoltageInitRunContext {
+    private static final String VOLTAGE_INIT_TYPE_REPORT = "VoltageInit";
 
     private final UUID networkUuid;
-
     private final String variantId;
-
     private final String receiver;
-
     private final UUID reportUuid;
-
     private final String reporterId;
-
     private final String reportType;
-
     private final String userId;
-
     private final UUID parametersUuid;
-
     private final Map<String, Double> voltageLevelsIdsRestricted;
+    private final Reporter rootReporter;
 
     public VoltageInitRunContext(UUID networkUuid, String variantId, String receiver, UUID reportUuid, String reporterId, String reportType, String userId, UUID parametersUuid, Map<String, Double> voltageLevelsIdsRestricted) {
         this.networkUuid = Objects.requireNonNull(networkUuid);
@@ -46,5 +43,15 @@ public VoltageInitRunContext(UUID networkUuid, String variantId, String receiver
         this.userId = userId;
         this.parametersUuid = parametersUuid;
         this.voltageLevelsIdsRestricted = voltageLevelsIdsRestricted;
+        if (this.reportUuid == null) {
+            this.rootReporter = Reporter.NO_OP;
+        } else {
+            final String rootReporterId = reporterId == null ? VOLTAGE_INIT_TYPE_REPORT : reporterId + "@" + reportType;
+            this.rootReporter = new ReporterModel(rootReporterId, rootReporterId);
+        }
+    }
+
+    public VoltageInitRunContext(UUID networkUuid, String variantId, String receiver, UUID reportUuid, String reporterId, String reportType, String userId, UUID parametersUuid) {
+        this(networkUuid, variantId, receiver, reportUuid, reporterId, reportType, userId, parametersUuid, new HashMap<>());
     }
 }

src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitWorkerService.java

@@ -8,10 +8,6 @@
 
 import com.google.common.collect.Sets;
 import com.powsybl.commons.PowsyblException;
-import com.powsybl.commons.reporter.Report;
-import com.powsybl.commons.reporter.Reporter;
-import com.powsybl.commons.reporter.ReporterModel;
-import com.powsybl.commons.reporter.TypedValue;
 import com.powsybl.iidm.network.Network;
 import com.powsybl.iidm.network.VariantManagerConstants;
 import com.powsybl.network.store.client.NetworkStoreService;
@@ -35,12 +31,14 @@
 import org.springframework.web.server.ResponseStatusException;
 
 import java.util.*;
-import java.util.concurrent.*;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;
 import java.util.function.Consumer;
-import java.util.stream.Collectors;
 
 import static org.gridsuite.voltageinit.server.service.NotificationService.CANCEL_MESSAGE;
 import static org.gridsuite.voltageinit.server.service.NotificationService.FAIL_MESSAGE;
@@ -50,14 +48,11 @@
  */
 @Service
 public class VoltageInitWorkerService {
-
     private static final Logger LOGGER = LoggerFactory.getLogger(VoltageInitWorkerService.class);
 
     private static final String ERROR = "error";
     private static final String ERROR_DURING_VOLTAGE_PROFILE_INITIALISATION = "Error during voltage profile initialization";
 
-    private static final String VOLTAGE_INIT_TYPE_REPORT = "VoltageInit";
-
     private final NetworkStoreService networkStoreService;
 
     private final NetworkModificationService networkModificationService;
@@ -111,43 +106,22 @@ private Network getNetwork(UUID networkUuid, String variantId) {
         return network;
     }
 
-    public static void addRestrictedVoltageLevelReport(Map<String, Double> voltageLevelsIdsRestricted, Reporter reporter) {
-        if (!voltageLevelsIdsRestricted.isEmpty()) {
-            String joinedVoltageLevelsIds = voltageLevelsIdsRestricted.entrySet()
-                    .stream()
-                    .map(entry -> entry.getKey() + " : " + entry.getValue())
-                    .collect(Collectors.joining(", "));
-
-            reporter.report(Report.builder()
-                    .withKey("restrictedVoltageLevels")
-                    .withDefaultMessage(String.format("The modifications to the low limits for certain voltage levels have been restricted to avoid negative voltage limits: %s", joinedVoltageLevelsIds))
-                    .withSeverity(TypedValue.WARN_SEVERITY)
-                    .build());
-        }
-    }
-
     private Pair<Network, OpenReacResult> run(VoltageInitRunContext context, UUID resultUuid) throws Exception {
         Objects.requireNonNull(context);
 
         LOGGER.info("Run voltage init...");
         Network network = voltageInitObserver.observe("network.load", () ->
                 getNetwork(context.getNetworkUuid(), context.getVariantId()));
 
-        AtomicReference<Reporter> rootReporter = new AtomicReference<>(Reporter.NO_OP);
-        Reporter reporter = Reporter.NO_OP;
         if (context.getReportUuid() != null) {
-            String rootReporterId = context.getReporterId() == null ? VOLTAGE_INIT_TYPE_REPORT : context.getReporterId() + "@" + context.getReportType();
-            rootReporter.set(new ReporterModel(rootReporterId, rootReporterId));
-            reporter = rootReporter.get().createSubReporter(context.getReportType(), VOLTAGE_INIT_TYPE_REPORT, VOLTAGE_INIT_TYPE_REPORT, context.getReportUuid().toString());
             // Delete any previous VoltageInit computation logs
             voltageInitObserver.observe("report.delete", () ->
                     reportService.deleteReport(context.getReportUuid(), context.getReportType()));
         }
         CompletableFuture<OpenReacResult> future = runVoltageInitAsync(context, network, resultUuid);
         if (context.getReportUuid() != null) {
-            addRestrictedVoltageLevelReport(context.getVoltageLevelsIdsRestricted(), reporter);
             voltageInitObserver.observe("report.send", () ->
-                    reportService.sendReport(context.getReportUuid(), rootReporter.get()));
+                    reportService.sendReport(context.getReportUuid(), context.getRootReporter()));
         }
 
         return future == null ? Pair.of(network, null) : Pair.of(network, voltageInitObserver.observeRun("run", future::get));
@@ -159,7 +133,6 @@ public CompletableFuture<OpenReacResult> runVoltageInitAsync(VoltageInitRunConte
             if (resultUuid != null && cancelComputationRequests.get(resultUuid) != null) {
                 return null;
             }
-
             OpenReacParameters parameters = voltageInitParametersService.buildOpenReacParameters(context, network);
             OpenReacConfig config = OpenReacConfig.load();
             CompletableFuture<OpenReacResult> future = OpenReacRunner.runAsync(network, network.getVariantManager().getWorkingVariantId(), parameters, config, voltageInitExecutionService.getComputationManager());