Implement async TopologicalSort

Author: vnickolov

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

@@ -41,6 +41,9 @@
 import org.neo4j.gds.dag.longestPath.DagLongestPath;
 import org.neo4j.gds.dag.longestPath.DagLongestPathParameters;
 import org.neo4j.gds.dag.longestPath.LongestPathTask;
+import org.neo4j.gds.dag.topologicalsort.TopSortTask;
+import org.neo4j.gds.dag.topologicalsort.TopologicalSort;
+import org.neo4j.gds.dag.topologicalsort.TopologicalSortParameters;
 import org.neo4j.gds.dag.topologicalsort.TopologicalSortResult;
 import org.neo4j.gds.kspanningtree.KSpanningTree;
 import org.neo4j.gds.kspanningtree.KSpanningTreeParameters;
@@ -837,13 +840,47 @@ CompletableFuture<SteinerTreeResult> steinerTree(
         );
     }
 
-    CompletableFuture<TopologicalSortResult> topologicalSort() {
+    CompletableFuture<TopologicalSortResult> topologicalSort(
+        GraphName graphName,
+        GraphParameters graphParameters,
+        Optional<String> relationshipProperty,
+        TopologicalSortParameters parameters,
+        JobId jobId,
+        boolean logProgress
+    ) {
         // Fetch the Graph the algorithm will operate on
+        var graph = graphStoreCatalogService.fetchGraphResources(
+            graphName,
+            graphParameters,
+            relationshipProperty,
+            new NoAlgorithmValidation(),
+            Optional.empty(),
+            user,
+            databaseId
+        ).graph();
+
         // Create ProgressTracker
+        var progressTracker = progressTrackerFactory.create(
+            TopSortTask.create(graph),
+            jobId,
+            parameters.concurrency(),
+            logProgress
+        );
+
         // Create the algorithm
-        // Submit the algorithm for async computation
+        var topologicalSort = new TopologicalSort(
+            graph,
+            progressTracker,
+            parameters.concurrency(),
+            parameters.computeMaxDistanceFromSource(),
+            terminationFlag
+        );
 
-        return CompletableFuture.failedFuture(new RuntimeException("Not yet implemented"));
+        // Submit the algorithm for async computation
+        return algorithmCaller.run(
+            topologicalSort::compute,
+            jobId
+        );
     }
 
 }

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

@@ -43,6 +43,7 @@
 import org.neo4j.gds.core.utils.progress.tasks.IterativeTask;
 import org.neo4j.gds.core.utils.progress.tasks.ProgressTracker;
 import org.neo4j.gds.dag.longestPath.DagLongestPathParameters;
+import org.neo4j.gds.dag.topologicalsort.TopologicalSortParameters;
 import org.neo4j.gds.extension.GdlExtension;
 import org.neo4j.gds.extension.GdlGraph;
 import org.neo4j.gds.extension.IdFunction;
@@ -497,4 +498,25 @@ void steinerTree() {
         assertThat(future.join()).isNotNull();
     }
 
+    @Test
+    void topologicalSort() {
+        var future = facade.topologicalSort(
+            new GraphName("foo"),
+            new GraphParameters(
+                List.of(NodeLabel.of("Node")),
+                List.of(RelationshipType.of("REL")),
+                true,
+                Optional.empty()
+            ),
+            Optional.empty(),
+            new TopologicalSortParameters(
+                false,
+                new Concurrency(4)
+            ),
+            jobIdMock,
+            true
+        );
+        assertThat(future.join()).isNotNull();
+    }
+
 }