Implement async SteinerTree

Author: vnickolov

algorithms-compute-facade/src/main/java/org/neo4j/gds/pathfinding/PathFindingComputeFacade.java

@@ -77,6 +77,9 @@
 import org.neo4j.gds.spanningtree.Prim;
 import org.neo4j.gds.spanningtree.SpanningTree;
 import org.neo4j.gds.spanningtree.SpanningTreeParameters;
+import org.neo4j.gds.steiner.ShortestPathsSteinerAlgorithm;
+import org.neo4j.gds.steiner.SteinerTreeParameters;
+import org.neo4j.gds.steiner.SteinerTreeProgressTask;
 import org.neo4j.gds.steiner.SteinerTreeResult;
 import org.neo4j.gds.termination.TerminationFlag;
 import org.neo4j.gds.traversal.RandomWalk;
@@ -781,13 +784,57 @@ CompletableFuture<SpanningTree> spanningTree(
         );
     }
 
-    CompletableFuture<SteinerTreeResult> steinerTree() {
+    CompletableFuture<SteinerTreeResult> steinerTree(
+        GraphName graphName,
+        GraphParameters graphParameters,
+        Optional<String> relationshipProperty,
+        SteinerTreeParameters parameters,
+        JobId jobId,
+        boolean logProgress
+    ) {
         // Fetch the Graph the algorithm will operate on
+        var graph = graphStoreCatalogService.fetchGraphResources(
+            graphName,
+            graphParameters,
+            relationshipProperty,
+            new SourceNodeTargetNodesGraphStoreValidation(parameters.sourceNode(), parameters.targetNodes()),
+            Optional.empty(),
+            user,
+            databaseId
+        ).graph();
+
         // Create ProgressTracker
+        var progressTracker = progressTrackerFactory.create(
+            SteinerTreeProgressTask.create(parameters, graph.nodeCount()),
+            jobId,
+            parameters.concurrency(),
+            logProgress
+        );
+
         // Create the algorithm
-        // Submit the algorithm for async computation
+        var mappedSourceNodeId = graph.toMappedNodeId(parameters.sourceNode());
+        var mappedTargetNodeIds = parameters.targetNodes()
+            .stream()
+            .map(graph::safeToMappedNodeId)
+            .toList();
 
-        return CompletableFuture.failedFuture(new RuntimeException("Not yet implemented"));
+        var steinerTree = new ShortestPathsSteinerAlgorithm(
+            graph,
+            mappedSourceNodeId,
+            mappedTargetNodeIds,
+            parameters.delta(),
+            parameters.concurrency(),
+            parameters.applyRerouting(),
+            executorService,
+            progressTracker,
+            terminationFlag
+        );
+
+        // Submit the algorithm for async computation
+        return algorithmCaller.run(
+            steinerTree::compute,
+            jobId
+        );
     }
 
     CompletableFuture<TopologicalSortResult> topologicalSort() {

algorithms-compute-facade/src/test/java/org/neo4j/gds/pathfinding/PathFindingComputeFacadeTest.java

@@ -59,6 +59,7 @@
 import org.neo4j.gds.pcst.PCSTParameters;
 import org.neo4j.gds.spanningtree.PrimOperators;
 import org.neo4j.gds.spanningtree.SpanningTreeParameters;
+import org.neo4j.gds.steiner.SteinerTreeParameters;
 import org.neo4j.gds.termination.TerminationFlag;
 import org.neo4j.gds.traversal.RandomWalkParameters;
 import org.neo4j.gds.traversal.TraversalParameters;
@@ -472,4 +473,28 @@ void spanningTree() {
         assertThat(future.join()).isNotNull();
     }
 
+    @Test
+    void steinerTree() {
+        var future = facade.steinerTree(
+            new GraphName("foo"),
+            new GraphParameters(
+                List.of(NodeLabel.of("Node")),
+                List.of(RelationshipType.of("REL")),
+                true,
+                Optional.empty()
+            ),
+            Optional.empty(),
+            new SteinerTreeParameters(
+                new Concurrency(4),
+                idFunction.of("a"),
+                List.of(idFunction.of("c")),
+                2.0,
+                false
+            ),
+            jobIdMock,
+            true
+        );
+        assertThat(future.join()).isNotNull();
+    }
+
 }