Squashed commit of the following:

commit 91e7663
Author: Simon Ser <[email protected]>
Date:   Wed Sep 4 16:34:32 2024 +0200

    core: re-order Dockerfile ADD jar stages

    Usually when rebuilding the core container only osrd_core.jar will
    be updated. Copy it last so that previous stages can benefit from
    the docker stage cache and be skipped.

commit fe8e4b7
Author: Eloi Charpentier <[email protected]>
Date:   Thu Sep 5 14:23:10 2024 +0200

    core: pathfinding: log a little extra info about failures

commit fcd9734
Author: Egor <[email protected]>
Date:   Tue Jul 30 15:31:30 2024 +0200

    editoast: make DbConnection type opaque

    Co-authored-by: Jean SIMARD <[email protected]>
    Co-authored-by: Léo VALAIS <[email protected]>

commit d6d2ed3
Author: Simon Ser <[email protected]>
Date:   Thu Sep 5 09:42:44 2024 +0200

    github: allow digits in module names

    Module names might have digits in them, e.g. "i18n" or "modelsv2".
    Stop forbidding these.

commit 979bbdb
Author: maymanaf <[email protected]>
Date:   Tue Sep 3 12:59:14 2024 +0200

    front: add webkit browser to e2e tests

commit ef82519
Author: Florian Amsallem <[email protected]>
Date:   Thu Sep 5 14:33:58 2024 +0200

    editoast: fix signal projection cache

commit 5e3ca65
Author: Youness CHRIFI ALAOUI <[email protected]>
Date:   Fri Aug 23 00:00:25 2024 +0200

    test: adapt intagration tests

commit 799b140
Author: Youness CHRIFI ALAOUI <[email protected]>
Date:   Thu Aug 22 03:38:25 2024 +0200

    front: adapt tsv2 endpoints

commit 0a2a6bb
Author: Youness CHRIFI ALAOUI <[email protected]>
Date:   Thu Aug 22 03:31:24 2024 +0200

    editoast: rename infra pathfinding input

commit 541886e
Author: Youness CHRIFI ALAOUI <[email protected]>
Date:   Thu Aug 22 02:41:58 2024 +0200

    editoast: remove v2 suffix

commit 0551a06
Author: Youness CHRIFI ALAOUI <[email protected]>
Date:   Thu Aug 22 02:41:35 2024 +0200

    editoast: rename tables

commit 144cf22
Author: Simon Ser <[email protected]>
Date:   Mon Sep 2 15:55:51 2024 +0200

    front: turn on noUnusedLocals

    This warns when something is imported but isn't actually used.

commit 05565cb
Author: Simon Ser <[email protected]>
Date:   Thu Sep 5 13:55:26 2024 +0200

    front: drop all unused React imports

    See previous commit.

commit c94b1c9
Author: Simon Ser <[email protected]>
Date:   Thu Sep 5 13:52:53 2024 +0200

    front: disable react/react-in-jsx-scope lint

    Forcing all .tsx/.jsx files to include React is cargo culting from
    old versions of the JSX compiler which were merely performing
    string substitution. Since React version 17 this isn't required
    anymore and the unused React imports can be dropped.

commit c2b8718
Author: Eloi Charpentier <[email protected]>
Date:   Thu Sep 5 11:07:06 2024 +0200

    core: stdcm: simplify stdcm edge builder

    Turns out, starting the path with a node
    instead of an edge can make things much
    easier than before

commit 615f035
Author: maymanaf <[email protected]>
Date:   Fri Aug 30 12:06:48 2024 +0200

    front: update train count check

commit 19912ba
Author: maymanaf <[email protected]>
Date:   Tue Jul 30 15:02:34 2024 +0200

    front: add import trains e2e tests

commit 1b14ae3
Author: SarahBellaha <[email protected]>
Date:   Thu Aug 22 18:15:02 2024 +0200

    front: be able to select a via on the map even when pf failed

Author: SergeCroise

.github/scripts/check-commit-titles.sh

@@ -34,7 +34,7 @@ check_forbidden_chars() {
 }
 
 check_structure() {
-    if grep -q -E -v '^([-_.a-z]+[,:] )*[-_.a-z]+: [a-z](:[^ ]|[^:])*$'; then
+    if grep -q -E -v '^([-_.a-z0-9]+[,:] )*[-_.a-z0-9]+: [a-z](:[^ ]|[^:])*$'; then
         echo 'Invalid commit title structure'
     fi
 }

core/Dockerfile

@@ -15,9 +15,9 @@ RUN --mount=type=cache,target=/home/gradle/.gradle \
 #### Running stage
 FROM eclipse-temurin:21 AS running_env
 
-COPY --from=build_env /osrd-all.jar /app/osrd_core.jar
 ADD 'https://dtdg.co/latest-java-tracer' /app/dd-java-agent.jar
 ADD 'https://github.com/open-telemetry/opentelemetry-java-instrumentation/releases/latest/download/opentelemetry-javaagent.jar' /app/opentelemetry-javaagent.jar
+COPY --from=build_env /osrd-all.jar /app/osrd_core.jar
 
 ARG OSRD_GIT_DESCRIBE
 ENV OSRD_GIT_DESCRIBE=${OSRD_GIT_DESCRIBE}

core/kt-osrd-sim-infra/src/main/kotlin/fr/sncf/osrd/sim_infra/utils/InfraUtils.kt

@@ -118,9 +118,7 @@ private fun findRoute(
             return routeId
         }
     }
-    val error = OSRDError(ErrorType.ScheduleMetadataExtractionFailed)
-    error.context["reason"] = "Couldn't find a route matching the given chunk list"
-    throw error
+    throw OSRDError(ErrorType.MissingRouteFromChunkPath)
 }
 
 /** Returns false if the route differs from the path */

core/osrd-reporting/src/main/java/fr/sncf/osrd/reporting/exceptions/ErrorType.java

@@ -162,7 +162,12 @@ public enum ErrorType {
     InvalidSTDCMStepWithTimingData(
             "invalid_stdcm_step_with_timing_data",
             "An STDCM step with planned timing data must be a stop",
-            ErrorCause.USER);
+            ErrorCause.USER),
+    MissingRouteFromChunkPath(
+            "missing_route_from_chunk_path",
+            "couldn't find a route matching the given chunk list",
+            ErrorCause.INTERNAL),
+    ;
 
     public final String type;
     public final String message;

core/src/main/kotlin/fr/sncf/osrd/api/api_v2/pathfinding/PathfindingBlocksEndpointV2.kt

@@ -23,6 +23,8 @@ import fr.sncf.osrd.utils.units.meters
 import java.time.Duration
 import java.time.Instant
 import java.util.*
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
 import org.takes.Request
 import org.takes.Response
 import org.takes.Take
@@ -39,7 +41,10 @@ import org.takes.rs.RsWithStatus
  */
 class NoPathFoundException(val response: PathfindingBlockResponse) : Exception()
 
+val pathfindingLogger: Logger = LoggerFactory.getLogger("Pathfinding")
+
 class PathfindingBlocksEndpointV2(private val infraManager: InfraManager) : Take {
+
     override fun act(req: Request): Response {
         val recorder = DiagnosticRecorderImpl(false)
         return try {
@@ -50,13 +55,16 @@ class PathfindingBlocksEndpointV2(private val infraManager: InfraManager) : Take
             // Load infra
             val infra = infraManager.getInfra(request.infra, request.expectedVersion, recorder)
             val res = runPathfinding(infra, request)
+            pathfindingLogger.info("success")
             RsJson(RsWithBody(pathfindingResponseAdapter.toJson(res)))
         } catch (error: NoPathFoundException) {
+            pathfindingLogger.info("no path found")
             RsJson(RsWithBody(pathfindingResponseAdapter.toJson(error.response)))
         } catch (error: OSRDError) {
             if (!error.osrdErrorType.isCacheable) {
                 ExceptionHandler.handle(error)
             } else {
+                pathfindingLogger.info("pathfinding failed: ${error.message}")
                 val response = PathfindingFailed(error)
                 RsJson(RsWithBody(pathfindingResponseAdapter.toJson(response)))
             }
@@ -154,8 +162,10 @@ private fun computePaths(
             .addBlockedRangeOnEdges(constraints)
             .runPathfinding(waypoints)
     if (pathFound != null) {
+        pathfindingLogger.info("path found in block graph, start postprocessing")
         return pathFound
     }
+    pathfindingLogger.info("no path found, identifying issues")
 
     // Handling errors
     // Check if pathfinding failed due to incompatible constraints

core/src/main/kotlin/fr/sncf/osrd/graph/Pathfinding.kt

@@ -1,6 +1,7 @@
 package fr.sncf.osrd.graph
 
 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings
+import fr.sncf.osrd.api.api_v2.pathfinding.pathfindingLogger
 import fr.sncf.osrd.api.pathfinding.constraints.ConstraintCombiner
 import fr.sncf.osrd.reporting.exceptions.ErrorType
 import fr.sncf.osrd.reporting.exceptions.OSRDError
@@ -11,6 +12,7 @@ import java.time.Duration
 import java.time.Instant
 import java.util.*
 import java.util.stream.Collectors
+import kotlin.math.max
 
 @SuppressFBWarnings(
     value = ["FE_FLOATING_POINT_EQUALITY"],
@@ -184,15 +186,23 @@ class Pathfinding<NodeT : Any, EdgeT : Any, OffsetType>(
             val startRange = EdgeRange(location.edge, location.offset, location.offset)
             registerStep(startRange, null, 0.0, 0, listOf(location))
         }
+        var maxReachedTarget = 0
         val start = Instant.now()
         while (true) {
             if (Duration.between(start, Instant.now()).toSeconds() >= timeout)
                 throw OSRDError(ErrorType.PathfindingTimeoutError)
-            val step = queue.poll() ?: return null
+            val step = queue.poll()
+            if (step == null) {
+                pathfindingLogger.info(
+                    "pathfinding failed, # reached waypoints = $maxReachedTarget/${targetsOnEdges.size}"
+                )
+                return null
+            }
             val endNode = graph.getEdgeEnd(step.range.edge)
             if (seen.getOrDefault(step.range, -1) >= step.nReachedTargets) {
                 continue
             }
+            maxReachedTarget = max(step.nReachedTargets, maxReachedTarget)
             seen[step.range] = step.nReachedTargets
             if (hasReachedEnd(targetsOnEdges.size, step)) return buildResult(step)
             // Check if the next target is reached in this step, only if the step doesn't already

core/src/main/kotlin/fr/sncf/osrd/stdcm/graph/BacktrackingManager.kt

@@ -39,7 +39,6 @@ class BacktrackingManager(private val graph: STDCMGraph) {
         // Create the new edge
         val newNode = newPreviousEdge.getEdgeEnd(graph)
         return STDCMEdgeBuilder.fromNode(graph, newNode, edge.infraExplorer)
-            .setStartOffset(edge.envelopeStartOffset)
             .setEnvelope(envelope)
             .findEdgeSameNextOccupancy(edge.timeNextOccupancy)
     }
@@ -78,13 +77,8 @@ class BacktrackingManager(private val graph: STDCMGraph) {
                 graph
             )
         val prevNode = old.previousNode
-        return STDCMEdgeBuilder(old.infraExplorer, graph, prevNode)
-            .setStartTime(old.timeStart - old.addedDelay)
-            .setStartOffset(old.envelopeStartOffset)
-            .setPrevMaximumAddedDelay(old.maximumAddedDelayAfter + old.addedDelay)
-            .setPrevAddedDelay(old.totalDepartureTimeShift - old.addedDelay)
+        return STDCMEdgeBuilder.fromNode(graph, prevNode, old.infraExplorer)
             .setEnvelope(newEnvelope)
-            .setWaypointIndex(old.waypointIndex)
             .findEdgeSameNextOccupancy(old.timeNextOccupancy)
     }
 }

core/src/main/kotlin/fr/sncf/osrd/stdcm/graph/STDCMEdgeBuilder.kt

@@ -15,6 +15,7 @@ import fr.sncf.osrd.utils.units.meters
 import kotlin.math.min
 
 /** This class handles the creation of new edges, handling the many optional parameters. */
+@ConsistentCopyVisibility
 data class STDCMEdgeBuilder
 internal constructor(
     /** Instance used to explore the infra, contains the underlying edge */
@@ -23,26 +24,8 @@ internal constructor(
     private val graph: STDCMGraph,
     /** Previous node, used to compute the final path */
     private var prevNode: STDCMNode,
-    /** Start time of the edge */
-    private var startTime: Double = 0.0,
-
-    /** Start speed, ignored if envelope is specified */
-    private var startSpeed: Double = 0.0,
-
     /** Start offset on the given block */
     private var startOffset: Offset<Block> = Offset(0.meters),
-
-    /**
-     * Maximum delay we can add on any of the previous edges by shifting the departure time, without
-     * causing a conflict
-     */
-    private var prevMaximumAddedDelay: Double = 0.0,
-
-    /**
-     * Sum of all the delay that has been added in the previous edges by shifting the departure time
-     */
-    private var prevAddedDelay: Double = 0.0,
-
     /** Envelope to use on the edge, if unspecified we try to go at maximum allowed speed */
     private var envelope: Envelope? = null,
 
@@ -51,46 +34,7 @@ internal constructor(
      * for the resource generator caches. This is the instance that must be used for next edges
      */
     private var explorerWithNewEnvelope: InfraExplorerWithEnvelope? = null,
-
-    /** Index of the last waypoint passed by the train */
-    private var waypointIndex: Int = 0
 ) {
-    // region SETTERS
-    /** Sets the start time of the edge */
-    fun setStartTime(startTime: Double): STDCMEdgeBuilder {
-        this.startTime = startTime
-        return this
-    }
-
-    /** Sets the start speed, ignored if the envelope has been specified */
-    fun setStartSpeed(startSpeed: Double): STDCMEdgeBuilder {
-        this.startSpeed = startSpeed
-        return this
-    }
-
-    /** Start offset on the given block */
-    fun setStartOffset(startOffset: Offset<Block>): STDCMEdgeBuilder {
-        this.startOffset = startOffset
-        return this
-    }
-
-    /**
-     * Sets the maximum delay we can add on any of the previous edges by shifting the departure time
-     */
-    fun setPrevMaximumAddedDelay(prevMaximumAddedDelay: Double): STDCMEdgeBuilder {
-        this.prevMaximumAddedDelay = prevMaximumAddedDelay
-        return this
-    }
-
-    /**
-     * Sets the sum of all the delay that has been added in the previous edges by shifting the
-     * departure time
-     */
-    fun setPrevAddedDelay(prevAddedDelay: Double): STDCMEdgeBuilder {
-        this.prevAddedDelay = prevAddedDelay
-        return this
-    }
-
     /**
      * Sets the envelope to use on the edge, if unspecified we try to go at maximum allowed speed
      */
@@ -99,16 +43,6 @@ internal constructor(
         return this
     }
 
-    /**
-     * Sets the waypoint index on the new edge (i.e. the index of the last waypoint passed by the
-     * train)
-     */
-    fun setWaypointIndex(waypointIndex: Int): STDCMEdgeBuilder {
-        this.waypointIndex = waypointIndex
-        return this
-    }
-    // endregion SETTERS
-    // region BUILDERS
     /**
      * Creates all edges that can be accessed on the given block, using all the parameters
      * specified.
@@ -143,12 +77,10 @@ internal constructor(
         val delay =
             getDelaysPerOpening()
                 .stream()
-                .filter { x: Double -> startTime + x <= timeNextOccupancy }
+                .filter { x: Double -> prevNode.time + x <= timeNextOccupancy }
                 .max { obj: Double, anotherDouble: Double? -> obj.compareTo(anotherDouble!!) }
         return delay.map { delayNeeded: Double -> makeSingleEdge(delayNeeded) }.orElse(null)
     }
-    // endregion BUILDERS
-    // region UTILITIES
     /** Returns the envelope to be used for the new edges */
     private fun getEnvelope(): Envelope? {
         if (envelope == null)
@@ -162,13 +94,13 @@ internal constructor(
                     infraExplorer,
                     BlockSimulationParameters(
                         infraExplorer.getCurrentBlock(),
-                        startSpeed,
+                        prevNode.speed,
                         startOffset,
                         getStopOnBlock(
                             graph,
                             infraExplorer.getCurrentBlock(),
                             startOffset,
-                            waypointIndex
+                            prevNode.waypointIndex
                         )
                     )
                 )
@@ -213,7 +145,7 @@ internal constructor(
     private fun getDelaysPerOpening(): Set<Double> {
         return graph.delayManager.minimumDelaysPerOpening(
             getExplorerWithNewEnvelope()!!,
-            startTime,
+            prevNode.time,
             envelope!!,
             startOffset,
         )
@@ -222,33 +154,37 @@ internal constructor(
     /** Returns the stop duration at the end of the edge being built, or null if there's no stop */
     private fun getEndStopDuration(): Double? {
         val endAtStop =
-            getStopOnBlock(graph, infraExplorer.getCurrentBlock(), startOffset, waypointIndex) !=
-                null
+            getStopOnBlock(
+                graph,
+                infraExplorer.getCurrentBlock(),
+                startOffset,
+                prevNode.waypointIndex
+            ) != null
         if (!endAtStop) return null
-        return graph.getFirstStopAfterIndex(waypointIndex)!!.duration!!
+        return graph.getFirstStopAfterIndex(prevNode.waypointIndex)!!.duration!!
     }
 
     /** Creates a single STDCM edge, adding the given amount of delay */
     private fun makeSingleEdge(delayNeeded: Double): STDCMEdge? {
         if (java.lang.Double.isInfinite(delayNeeded)) return null
-        val actualStartTime = startTime + delayNeeded
+        val actualStartTime = prevNode.time + delayNeeded
 
         var maximumDelay = 0.0
         var departureTimeShift = delayNeeded
-        if (delayNeeded > prevMaximumAddedDelay) {
+        if (delayNeeded > prevNode.maximumAddedDelay) {
             // We can't just shift the departure time, we need an engineering allowance
             // It's not computed yet, we just check that it's possible
             if (!graph.allowanceManager.checkEngineeringAllowance(prevNode, actualStartTime))
                 return null
             // We still need to adapt the delay values
-            departureTimeShift = prevMaximumAddedDelay
+            departureTimeShift = prevNode.maximumAddedDelay
         } else {
             maximumDelay =
                 min(
-                    prevMaximumAddedDelay - delayNeeded,
+                    prevNode.maximumAddedDelay - delayNeeded,
                     graph.delayManager.findMaximumAddedDelay(
                         getExplorerWithNewEnvelope()!!,
-                        startTime + delayNeeded,
+                        prevNode.time + delayNeeded,
                         startOffset,
                         envelope!!,
                     )
@@ -266,14 +202,14 @@ internal constructor(
                 departureTimeShift,
                 graph.delayManager.findNextOccupancy(
                     getExplorerWithNewEnvelope()!!,
-                    startTime + delayNeeded,
+                    prevNode.time + delayNeeded,
                     startOffset,
                     envelope!!,
                 ),
-                prevAddedDelay + departureTimeShift,
+                prevNode.totalPrevAddedDelay + departureTimeShift,
                 prevNode,
                 startOffset,
-                waypointIndex,
+                prevNode.waypointIndex,
                 endAtStop,
                 envelope!!.beginSpeed,
                 envelope!!.endSpeed,
@@ -293,7 +229,7 @@ internal constructor(
                 return true
             node = prevEdge.previousNode
         }
-    } // endregion UTILITIES
+    }
 
     companion object {
         fun fromNode(
@@ -305,12 +241,7 @@ internal constructor(
             if (node.locationOnEdge != null) {
                 builder.startOffset = node.locationOnEdge
             }
-            builder.startTime = node.time
-            builder.startSpeed = node.speed
-            builder.prevMaximumAddedDelay = node.maximumAddedDelay
-            builder.prevAddedDelay = node.totalPrevAddedDelay
             builder.prevNode = node
-            builder.waypointIndex = node.waypointIndex
             return builder
         }
     }