Add sllpa to business facade

Author: IoannisPanagiotas

algorithms-compute-business-facade/build.gradle

@@ -10,12 +10,16 @@ dependencies {
     implementation project(':algo-common') // TODO: extract the results to a separate module and depend on it
     implementation project(':algorithms-compute-facade')
     implementation project(':collections')
+    implementation project(":community-configs") //Need for SLLPA
     implementation project(':community-params')
+    implementation project(":config-api") //Need for SLLPA
+
     implementation project(':core') // TODO: this is here because of the `GraphStoreCatalogService` --> refactor it so we can use the service without bringing the entire sub-project
     implementation project(':graph-schema-api')
     implementation project(':logging')
     implementation project(':node-embeddings-params')
     implementation project(':path-finding-params')
+    implementation project(":pregel") //Need for SLLPA
     implementation project(':progress-tracking')
     implementation project(':string-formatting')
     implementation project(':termination')

algorithms-compute-business-facade/src/main/java/org/neo4j/gds/community/CommunityComputeBusinessFacade.java

@@ -26,10 +26,12 @@
 import org.neo4j.gds.api.nodeproperties.ValueType;
 import org.neo4j.gds.approxmaxkcut.ApproxMaxKCutParameters;
 import org.neo4j.gds.approxmaxkcut.ApproxMaxKCutResult;
+import org.neo4j.gds.beta.pregel.PregelResult;
 import org.neo4j.gds.cliqueCounting.CliqueCountingResult;
 import org.neo4j.gds.cliquecounting.CliqueCountingParameters;
 import org.neo4j.gds.collections.ha.HugeLongArray;
 import org.neo4j.gds.community.validation.ApproxMaxKCutValidation;
+import org.neo4j.gds.community.validation.SpeakerListenerLPAGraphStoreValidation;
 import org.neo4j.gds.community.validation.TriangleCountGraphStoreValidation;
 import org.neo4j.gds.community.validation.UndirectedAndSeedableGraphStoreValidation;
 import org.neo4j.gds.conductance.ConductanceParameters;
@@ -62,6 +64,7 @@
 import org.neo4j.gds.result.TimedAlgorithmResult;
 import org.neo4j.gds.results.ResultTransformerBuilder;
 import org.neo4j.gds.scc.SccParameters;
+import org.neo4j.gds.sllpa.SpeakerListenerLPAConfig;
 import org.neo4j.gds.triangle.LocalClusteringCoefficientParameters;
 import org.neo4j.gds.triangle.LocalClusteringCoefficientResult;
 import org.neo4j.gds.triangle.TriangleCountParameters;
@@ -513,6 +516,35 @@ public <TR> CompletableFuture<TR> scc(
         ).thenApply(resultTransformerBuilder.build(graphResources));
     }
 
+    public <TR> CompletableFuture<TR> sllpa(
+        GraphName graphName,
+        GraphParameters graphParameters,
+        Optional<String> relationshipProperty,
+        SpeakerListenerLPAConfig config,
+        JobId jobId,
+        boolean logProgress,
+        ResultTransformerBuilder<TimedAlgorithmResult<PregelResult>, TR> resultTransformerBuilder
+    ) {
+        // Fetch the Graph the algorithm will operate on
+        var graphResources = graphStoreCatalogService.fetchGraphResources(
+            graphName,
+            graphParameters,
+            relationshipProperty,
+            new SpeakerListenerLPAGraphStoreValidation(config.writeProperty()),
+            Optional.empty(),
+            user,
+            databaseId
+        );
+        var graph = graphResources.graph();
+
+        return computeFacade.sllpa(
+            graph,
+            config,
+            jobId,
+            logProgress
+        ).thenApply(resultTransformerBuilder.build(graphResources));
+    }
+
     public <TR> CompletableFuture<TR> triangleCount(
         GraphName graphName,
         GraphParameters graphParameters,

algorithms-compute-business-facade/src/main/java/org/neo4j/gds/community/validation/SpeakerListenerLPAGraphStoreValidation.java

@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Neo4j is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * 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.community.validation;
+
+import org.neo4j.gds.NodeLabel;
+import org.neo4j.gds.RelationshipType;
+import org.neo4j.gds.api.GraphStore;
+import org.neo4j.gds.core.loading.validation.GraphStoreValidation;
+
+import java.util.Collection;
+
+public class SpeakerListenerLPAGraphStoreValidation  extends GraphStoreValidation {
+
+    private final String writeProperty;
+
+    public SpeakerListenerLPAGraphStoreValidation(String writeProperty) {
+        this.writeProperty = writeProperty;
+    }
+
+    @Override
+    protected void validateAlgorithmRequirements(
+        GraphStore graphStore,
+        Collection<NodeLabel> selectedLabels,
+        Collection<RelationshipType> selectedRelationshipTypes
+    ) {
+        validateCanWrite(graphStore);
+    }
+
+    private void validateCanWrite(GraphStore graphStore){
+        // See PregelProcedureConfig for exaplanation of this
+        if (writeProperty.isBlank()) {
+            return;
+        }
+
+        if (!graphStore.capabilities().canWriteToLocalDatabase() && !graphStore.capabilities()
+            .canWriteToRemoteDatabase()) { //skip result store  ¯\\_(ツ)_/¯
+            throw new IllegalArgumentException("The provided graph does not support `write` execution mode.");
+        }
+    }
+}

algorithms-compute-facade/src/main/java/org/neo4j/gds/community/CommunityComputeFacade.java

@@ -565,6 +565,39 @@ CompletableFuture<TimedAlgorithmResult<HugeLongArray>> scc(
         );
     }
 
+    CompletableFuture<TimedAlgorithmResult<PregelResult>> sllpa(
+        Graph graph,
+        SpeakerListenerLPAConfig configuration,
+        JobId jobId,
+        boolean logProgress
+    ) {
+
+        if (graph.isEmpty()) {
+            var empty = NodeValue.of(new PregelSchema.Builder().build(),0,new Concurrency(1));
+            return CompletableFuture.completedFuture(TimedAlgorithmResult.empty(ImmutablePregelResult.of(empty, 0, false)));
+        }
+
+        var progressTracker = progressTrackerFactory.create(
+            tasks.speakerListenerLPA(graph,configuration),
+            jobId,
+            configuration.concurrency(),
+            logProgress
+        );
+
+        var algorithm = new SpeakerListenerLPA(
+            graph,
+            configuration,
+            DefaultPool.INSTANCE,
+            progressTracker,
+            Optional.empty()
+        );
+
+        return algorithmCaller.run(
+            algorithm::compute,
+            jobId
+        );
+    }
+
     CompletableFuture<TimedAlgorithmResult<TriangleCountResult>> triangleCount(
         Graph graph,
         TriangleCountParameters parameters,
@@ -655,37 +688,4 @@ CompletableFuture<TimedAlgorithmResult<DisjointSetStruct>> wcc(
         );
     }
 
-    CompletableFuture<TimedAlgorithmResult<PregelResult>> sllpa(
-        Graph graph,
-        SpeakerListenerLPAConfig configuration,
-        JobId jobId,
-        boolean logProgress
-    ) {
-
-        if (graph.isEmpty()) {
-            var empty = NodeValue.of(new PregelSchema.Builder().build(),0,new Concurrency(1));
-            return CompletableFuture.completedFuture(TimedAlgorithmResult.empty(ImmutablePregelResult.of(empty, 0, false)));
-        }
-
-        var progressTracker = progressTrackerFactory.create(
-            tasks.speakerListenerLPA(graph,configuration),
-            jobId,
-            configuration.concurrency(),
-            logProgress
-        );
-
-        var algorithm = new SpeakerListenerLPA(
-            graph,
-            configuration,
-            DefaultPool.INSTANCE,
-            progressTracker,
-            Optional.empty()
-        );
-
-        return algorithmCaller.run(
-            algorithm::compute,
-            jobId
-        );
-    }
-
 }