Move KSpanningTreeWriteStep to dedicated module

Author: vnickolov

applications/algorithms/path-finding/src/main/java/org/neo4j/gds/applications/algorithms/pathfinding/PathFindingAlgorithmsWriteModeBusinessFacade.java

@@ -37,6 +37,7 @@
 import org.neo4j.gds.logging.Log;
 import org.neo4j.gds.mem.MemoryEstimation;
 import org.neo4j.gds.pathfinding.BellmanFordWriteStep;
+import org.neo4j.gds.pathfinding.KSpanningTreeWriteStep;
 import org.neo4j.gds.paths.WritePathOptionsConfig;
 import org.neo4j.gds.paths.astar.config.ShortestPathAStarWriteConfig;
 import org.neo4j.gds.paths.bellmanford.AllShortestPathsBellmanFordWriteConfig;
@@ -144,10 +145,14 @@ public <RESULT> RESULT kSpanningTree(
         ResultBuilder<KSpanningTreeWriteConfig, SpanningTree, RESULT, Void> resultBuilder
     ) {
         var writeStep = new KSpanningTreeWriteStep(
-            log,
-            requestScopedDependencies,
+            configuration.writeProperty(),
             writeContext,
-            configuration
+            configuration::resolveResultStore,
+            configuration.jobId(),
+            configuration.writeConcurrency(),
+            log,
+            requestScopedDependencies.taskRegistryFactory(),
+            requestScopedDependencies.terminationFlag()
         );
 
         return runAlgorithmAndWrite(

procedures/path-finding-write-steps/build.gradle

@@ -15,6 +15,9 @@ dependencies {
     //  extract them in a separate project and bring it instead
     implementation project(':algo')
 
+    // FIXME: AlgorithmLabel 🙄
+    implementation project(':algo-common')
+
     implementation project(':algorithms-machinery')
 
     // FIXME: Massively annoying we need to bring this in because services use configs;
@@ -25,4 +28,9 @@ dependencies {
     implementation project(':core-api')
     implementation project(':logging')
     implementation project(':string-formatting')
+
+    // FIXME: These don't belong here, the write should be abstracted via service.
+    implementation project(':core-write')
+    implementation project(':progress-tracking')
+    implementation project(':termination')
 }

…panningTreeBackedNodePropertyValues.java …panningTreeBackedNodePropertyValues.javaapplications/algorithms/path-finding/src/main/java/org/neo4j/gds/applications/algorithms/pathfinding/KSpanningTreeBackedNodePropertyValues.java renamed to procedures/path-finding-write-steps/src/main/java/org/neo4j/gds/pathfinding/KSpanningTreeBackedNodePropertyValues.java applications/algorithms/path-finding/src/main/java/org/neo4j/gds/applications/algorithms/pathfinding/KSpanningTreeBackedNodePropertyValues.java renamed to procedures/path-finding-write-steps/src/main/java/org/neo4j/gds/pathfinding/KSpanningTreeBackedNodePropertyValues.java

@@ -17,16 +17,16 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-package org.neo4j.gds.applications.algorithms.pathfinding;
+package org.neo4j.gds.pathfinding;
 
 import org.neo4j.gds.api.properties.nodes.LongNodePropertyValues;
 import org.neo4j.gds.spanningtree.SpanningTree;
 
-public class KSpanningTreeBackedNodePropertyValues implements LongNodePropertyValues {
+class KSpanningTreeBackedNodePropertyValues implements LongNodePropertyValues {
     private final SpanningTree spanningTree;
     private final long nodeCount;
 
-    public KSpanningTreeBackedNodePropertyValues(
+    KSpanningTreeBackedNodePropertyValues(
         SpanningTree spanningTree,
         long nodeCount
     ) {

…/pathfinding/KSpanningTreeWriteStep.java …/pathfinding/KSpanningTreeWriteStep.javaapplications/algorithms/path-finding/src/main/java/org/neo4j/gds/applications/algorithms/pathfinding/KSpanningTreeWriteStep.java renamed to procedures/path-finding-write-steps/src/main/java/org/neo4j/gds/pathfinding/KSpanningTreeWriteStep.java applications/algorithms/path-finding/src/main/java/org/neo4j/gds/applications/algorithms/pathfinding/KSpanningTreeWriteStep.java renamed to procedures/path-finding-write-steps/src/main/java/org/neo4j/gds/pathfinding/KSpanningTreeWriteStep.java

@@ -17,40 +17,58 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-package org.neo4j.gds.applications.algorithms.pathfinding;
+package org.neo4j.gds.pathfinding;
 
 import org.neo4j.gds.api.Graph;
 import org.neo4j.gds.api.GraphStore;
 import org.neo4j.gds.api.ResultStore;
 import org.neo4j.gds.applications.algorithms.machinery.AlgorithmLabel;
-import org.neo4j.gds.applications.algorithms.machinery.RequestScopedDependencies;
 import org.neo4j.gds.applications.algorithms.machinery.WriteContext;
 import org.neo4j.gds.applications.algorithms.machinery.WriteStep;
+import org.neo4j.gds.core.concurrency.Concurrency;
 import org.neo4j.gds.core.utils.logging.LoggerForProgressTrackingAdapter;
 import org.neo4j.gds.core.utils.progress.JobId;
+import org.neo4j.gds.core.utils.progress.TaskRegistryFactory;
 import org.neo4j.gds.core.utils.progress.tasks.TaskProgressTracker;
 import org.neo4j.gds.core.write.NodePropertyExporter;
-import org.neo4j.gds.kspanningtree.KSpanningTreeWriteConfig;
 import org.neo4j.gds.logging.Log;
 import org.neo4j.gds.spanningtree.SpanningTree;
+import org.neo4j.gds.termination.TerminationFlag;
 
-class KSpanningTreeWriteStep implements WriteStep<SpanningTree, Void> {
+import java.util.Optional;
+import java.util.function.Function;
+
+// FIXME: This implementation is not what we would like it to be.
+//  We need to abstract the write operation to a write service and not create the individual exporters here.
+public class KSpanningTreeWriteStep implements WriteStep<SpanningTree, Void> {
+
+    private final String writeProperty;
     private final Log log;
-    private final RequestScopedDependencies requestScopedDependencies;
     private final WriteContext writeContext;
-    private final KSpanningTreeWriteConfig configuration;
-
+    private final Function<ResultStore, Optional<ResultStore>> resultStoreResolver;
+    private final JobId jobId;
+    private final Concurrency writeConcurrency;
+    private final TaskRegistryFactory taskRegistryFactory;
+    private final TerminationFlag terminationFlag;
 
-    KSpanningTreeWriteStep(
-        Log log,
-        RequestScopedDependencies requestScopedDependencies,
+    public KSpanningTreeWriteStep(
+        String writeProperty,
         WriteContext writeContext,
-        KSpanningTreeWriteConfig configuration
+        Function<ResultStore, Optional<ResultStore>> resultStoreResolver,
+        JobId jobId,
+        Concurrency writeConcurrency,
+        Log log,
+        TaskRegistryFactory taskRegistryFactory,
+        TerminationFlag terminationFlag
     ) {
+        this.writeProperty = writeProperty;
         this.log = log;
-        this.requestScopedDependencies = requestScopedDependencies;
         this.writeContext = writeContext;
-        this.configuration = configuration;
+        this.resultStoreResolver = resultStoreResolver;
+        this.jobId = jobId;
+        this.writeConcurrency = writeConcurrency;
+        this.taskRegistryFactory = taskRegistryFactory;
+        this.terminationFlag = terminationFlag;
     }
 
     @Override
@@ -66,20 +84,20 @@ public Void execute(
         var progressTracker = new TaskProgressTracker(
             NodePropertyExporter.baseTask(AlgorithmLabel.KSpanningTree.asString(), graph.nodeCount()),
             new LoggerForProgressTrackingAdapter(log),
-            configuration.writeConcurrency(),
-            requestScopedDependencies.taskRegistryFactory()
+            writeConcurrency,
+            taskRegistryFactory
         );
 
         var nodePropertyExporter = writeContext.nodePropertyExporterBuilder()
             .withIdMap(graph)
-            .withTerminationFlag(requestScopedDependencies.terminationFlag())
+            .withTerminationFlag(terminationFlag)
             .withProgressTracker(progressTracker)
-            .withResultStore(configuration.resolveResultStore(resultStore))
-            .withJobId(configuration.jobId())
+            .withResultStore(resultStoreResolver.apply(resultStore))
+            .withJobId(this.jobId)
             .build();
 
         // effect
-        nodePropertyExporter.write(configuration.writeProperty(), properties);
+        nodePropertyExporter.write(writeProperty, properties);
 
         // reporting
         // countsBuilder.withNodePropertiesWritten(...);

procedures/path-finding-write-steps/src/main/java/org/neo4j/gds/pathfinding/PathFindingWriteRelationshipSpecification.java

@@ -28,7 +28,7 @@
 
 import java.util.List;
 
-final class PathFindingWriteRelationshipSpecification {
+public final class PathFindingWriteRelationshipSpecification {
 
     private static final String TOTAL_COST_KEY = "totalCost";
     private static final String NODE_IDS_KEY = "nodeIds";
@@ -39,13 +39,13 @@ final class PathFindingWriteRelationshipSpecification {
     private final boolean writeNodeIds;
     private final boolean writeCosts;
 
-    PathFindingWriteRelationshipSpecification(IdMap idMap, boolean writeNodeIds, boolean writeCosts) {
+    public PathFindingWriteRelationshipSpecification(IdMap idMap, boolean writeNodeIds, boolean writeCosts) {
         this.idMap = idMap;
         this.writeNodeIds = writeNodeIds;
         this.writeCosts = writeCosts;
     }
 
-    List<String> createKeys() {
+    public List<String> createKeys() {
         if (writeNodeIds && writeCosts) {
             return List.of(
                 TOTAL_COST_KEY,
@@ -68,7 +68,7 @@ List<String> createKeys() {
         return List.of(TOTAL_COST_KEY);
     }
 
-     List<ValueType> createTypes() {
+     public List<ValueType> createTypes() {
         if (writeNodeIds && writeCosts) {
             return List.of(
                 ValueType.DOUBLE,
@@ -124,7 +124,7 @@ private long[] toOriginalIds( long[] internalIds) {
         return internalIds;
     }
 
-     ExportedRelationship createRelationship(PathResult pathResult){
+     public ExportedRelationship createRelationship(PathResult pathResult){
         return new ExportedRelationship(
             pathResult.sourceNode(),
             pathResult.targetNode(),