feat(algorithm): support single source shortest path algorithm

computer-algorithm/src/main/java/org/apache/hugegraph/computer/algorithm/path/shortest/SingleSourceShortestPath.java

@@ -17,9 +17,8 @@
 
 package org.apache.hugegraph.computer.algorithm.path.shortest;
 
-import java.util.Arrays;
 import java.util.Iterator;
-import java.util.stream.Collectors;
+import java.util.List;
 
 import org.apache.commons.lang3.StringUtils;
 import org.apache.hugegraph.computer.core.common.exception.ComputerException;
@@ -32,17 +31,19 @@
 import org.apache.hugegraph.computer.core.graph.value.Value;
 import org.apache.hugegraph.computer.core.graph.vertex.Vertex;
 import org.apache.hugegraph.computer.core.util.IdUtil;
+import org.apache.hugegraph.computer.core.util.JsonUtilExt;
 import org.apache.hugegraph.computer.core.worker.Computation;
 import org.apache.hugegraph.computer.core.worker.ComputationContext;
 import org.apache.hugegraph.computer.core.worker.WorkerContext;
+import org.apache.hugegraph.rest.SerializeException;
+import org.apache.hugegraph.util.JsonUtil;
 import org.apache.hugegraph.util.Log;
 import org.slf4j.Logger;
 
 public class SingleSourceShortestPath implements Computation<SingleSourceShortestPathValue> {
 
     private static final Logger LOG = Log.logger(SingleSourceShortestPath.class);
 
-    public static final String OPTION_VERTEX_ID_TYPE = "single_source_shortest_path.vertex_id_type";
     public static final String OPTION_SOURCE_ID = "single_source_shortest_path.source_id";
     public static final String OPTION_TARGET_ID = "single_source_shortest_path.target_id";
     public static final String OPTION_WEIGHT_PROPERTY =
@@ -51,27 +52,20 @@
             "single_source_shortest_path.default_weight";
 
     /**
-     * id type of vertex.
-     * string|number|uuid
+     * source vertex id.
+     * {"id": "", "idType": ""}
      */
-    // todo improve: automatic inference
-    private String vertexIdTypeStr;
-    private IdCategory vertexIdType;
-
-    /**
-     * source vertex id
-     */
-    private String sourceIdStr;
+    // todo improve: automatic inference idType
     private Id sourceId;
 
     /**
      * target vertex id.
-     * 1. single target: one vertex id
-     * 2. multiple target: multiple vertex ids separated by comma
-     * 3. all: *
+     * 1. single target: [{"id": "", "idType": ""}]
+     * 2. multiple target: [{"id": "", "idType": ""}, {"id": "", "idType": ""}]
+     * 3. all: []
      */
-    private String targetIdStr;
-    private IdSet targetIdSet; // empty when targetIdStr == "*"
+    // todo improve: automatic inference idType
+    private IdSet targetIdSet; // empty when targetId is all
     /**
      * target quantity type
      */
@@ -93,7 +87,7 @@
     /**
      * reached targets
      */
-    private IdSet reachedTargets; // empty when targetIdStr == "*"
+    private IdSet reachedTargets; // empty when targetId is all
 
     @Override
     public String category() {
@@ -107,28 +101,35 @@
 
     @Override
     public void init(Config config) {
-        this.vertexIdTypeStr = config.getString(OPTION_VERTEX_ID_TYPE, "");
-        this.vertexIdType = IdCategory.parse(this.vertexIdTypeStr);
-
-        this.sourceIdStr = config.getString(OPTION_SOURCE_ID, "");
-        if (StringUtils.isBlank(this.sourceIdStr)) {
+        String sourceIdStr = config.getString(OPTION_SOURCE_ID, "");
+        if (StringUtils.isBlank(sourceIdStr)) {
             throw new ComputerException("The param '%s' must not be blank", OPTION_SOURCE_ID);
         }
-        this.sourceId = IdUtil.parseId(this.vertexIdType, this.sourceIdStr);
+        VertexInputJson sourceVertex;
+        try {
+            sourceVertex = JsonUtil.fromJson(sourceIdStr, VertexInputJson.class);
+        } catch (SerializeException e) {
+            throw new ComputerException("The param '%s' is unexpected format", OPTION_SOURCE_ID);
+        }
+        this.sourceId = IdUtil.parseId(IdCategory.parse(sourceVertex.getIdType()),
+                                       sourceVertex.getId());
 
-        this.targetIdStr = config.getString(OPTION_TARGET_ID, "");
-        if (StringUtils.isBlank(this.targetIdStr)) {
+        String targetIdStr = config.getString(OPTION_TARGET_ID, "");
+        if (StringUtils.isBlank(targetIdStr)) {
             throw new ComputerException("The param '%s' must not be blank", OPTION_TARGET_ID);
         }
-        // remove spaces
-        this.targetIdStr = Arrays.stream(this.targetIdStr.split(","))
-                                 .map(e -> e.trim())
-                                 .collect(Collectors.joining(","));
-        this.targetQuantityType = this.getQuantityType();
+        List<VertexInputJson> targetVertices;
+        try {
+            targetVertices = JsonUtilExt.fromJson2List(targetIdStr, VertexInputJson.class);
+        } catch (SerializeException e) {
+            throw new ComputerException("The param '%s' is unexpected format", OPTION_TARGET_ID);
+        }
+        this.targetQuantityType = this.getQuantityType(targetVertices);
         if (this.targetQuantityType != QuantityType.ALL) {
             this.targetIdSet = new IdSet();
-            for (String targetIdStr : this.targetIdStr.split(",")) {
-                targetIdSet.add(IdUtil.parseId(this.vertexIdType, targetIdStr));
+            for (VertexInputJson targetVertex : targetVertices) {
+                targetIdSet.add(IdUtil.parseId(IdCategory.parse(targetVertex.getIdType()),
+                                               targetVertex.getId()));
             }
         }
 
@@ -136,7 +137,7 @@
 
         this.defaultWeight = config.getDouble(OPTION_DEFAULT_WEIGHT, 1);
         if (this.defaultWeight <= 0) {
             throw new ComputerException("The param '%s' must be greater than 0, " +
                                         "actual got '%s'",
                                         OPTION_DEFAULT_WEIGHT, this.defaultWeight);
         }
@@ -157,19 +158,18 @@
 
         // single target && source == target
         if (this.targetQuantityType == QuantityType.SINGLE &&
-            this.sourceIdStr.equals(this.targetIdStr)) {
+            this.sourceId.equals(this.targetIdSet.value().iterator().next())) {
             LOG.debug("source vertex {} equals target vertex {}",
-                      this.sourceIdStr, this.targetIdStr);
+                      this.sourceId, this.targetIdSet.value().iterator().next());
             vertex.inactivate();
             return;
         }
 
         if (vertex.numEdges() <= 0) {
             // isolated vertex
-            LOG.debug("source vertex {} can not reach target vertex {}",
-                      this.sourceIdStr, this.targetIdStr);
+            LOG.debug("source vertex {} is isolated", this.sourceId);
             vertex.inactivate();
             return;
         }
 
         vertex.edges().forEach(edge -> {
@@ -201,8 +201,9 @@
                 continue;
             }
 
-            // reach all target or nowhere to go
-            if (this.isAllTargetsReached(vertex) || vertex.numEdges() <= 0) {
+            // target vertex finds all targets reached or nowhere to go
+            if ((this.isTarget(vertex) && this.isAllTargetsReached(vertex)) ||
+                vertex.numEdges() <= 0) {
                 continue;
             }
 
@@ -232,15 +233,15 @@
     }
 
     /**
-     * get QuantityType by this.targetId
+     * get quantityType by targetId
      */
-    private QuantityType getQuantityType() {
-        if (this.targetIdStr.equals("*")) {
+    private QuantityType getQuantityType(List<VertexInputJson> targetVertices) {
+        if (targetVertices.size() == 0) {
             return QuantityType.ALL;
-        } else if (this.targetIdStr.contains(",")) {
-            return QuantityType.MULTIPLE;
-        } else {
+        } else if (targetVertices.size() == 1) {
             return QuantityType.SINGLE;
+        } else {
+            return QuantityType.MULTIPLE;
         }
     }
 
@@ -253,16 +254,16 @@
         Value property = edge.property(this.weightProperty);
         if (property != null) {
             if (!property.isNumber()) {
                 throw new ComputerException("The value of %s must be a numeric value, " +
                                             "actual got '%s'",
                                             this.weightProperty, property.string());
             }
 
             weight = ((DoubleValue) property).doubleValue();
             if (weight <= 0) {
                 throw new ComputerException("The value of %s must be greater than 0, " +
                                             "actual got '%s'",
                                             this.weightProperty, property.string());
             }
         }
         return weight;
@@ -281,17 +282,38 @@
      */
     private boolean isAllTargetsReached(Vertex vertex) {
         if (this.targetQuantityType == QuantityType.ALL) {
             return false;
         }
 
         if (this.targetIdSet.size() == this.reachedTargets.size()) {
             for (Id targetId : this.targetIdSet.value()) {
                 if (!this.reachedTargets.contains(targetId)) {
                     return false;
                 }
             }
             return true;
         }
         return false;
     }
+
+    static class VertexInputJson {
+        private String id;
+        private String idType;
+
+        public String getId() {
+            return id;
+        }
+
+        public void setId(String id) {
+            this.id = id;
+        }
+
+        public String getIdType() {
+            return idType;
+        }
+
+        public void setIdType(String idType) {
+            this.idType = idType;
+        }
+    }
 }

computer-api/src/main/java/org/apache/hugegraph/computer/core/graph/id/IdFactory.java

@@ -90,10 +90,10 @@
                 case UUID:
                     return (Id) BYTES_ID_UUID_METHOD.invoke(null, value);
                 default:
-                    throw new ComputerException("Can't parse Id for %s", type.name());
+                    throw new ComputerException("Unexpected id type %s", type.name());
             }
         } catch (Exception e) {
-            throw new ComputerException("Failed to parse Id", e);
+            throw new ComputerException("Failed to parse %s Id: '%s'", e, type, value);
         }
     }
 

computer-api/src/main/java/org/apache/hugegraph/computer/core/util/JsonUtilExt.java

@@ -0,0 +1,46 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with this
+ * work for additional information regarding copyright ownership. The ASF
+ * licenses this file to You under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.hugegraph.computer.core.util;
+
+import java.io.IOException;
+import java.util.List;
+
+import org.apache.hugegraph.rest.SerializeException;
+
+import com.fasterxml.jackson.databind.JavaType;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+// todo move to org.apache.hugegraph.util.JsonUtil later
+public class JsonUtilExt {
+
+    private static final ObjectMapper MAPPER = new ObjectMapper();
+
+    public static <T> List<T> fromJson2List(String json, Class<T> clazz) {
+        try {
+            return MAPPER.readValue(json, getCollectionType(List.class, clazz));
+        } catch (IOException e) {
+            throw new SerializeException("Failed to deserialize json '%s'",
+                                         e, json);
+        }
+    }
+
+    private static JavaType getCollectionType(Class<?> collectionClass,
+                                              Class<?>... elementClasses) {
+        return MAPPER.getTypeFactory().constructParametricType(collectionClass, elementClasses);
+    }
+}

computer-test/src/main/java/org/apache/hugegraph/computer/algorithm/path/shortest/SingleSourceShortestPathTest.java

@@ -40,8 +40,8 @@ public class SingleSourceShortestPathTest extends AlgorithmTestBase {
     public static final String EL = "road";
     public static final String PROPERTY_KEY = "distance";
 
-    public static final String SOURCE_ID = "A";
-    public static final String TARGET_ID = "E";
+    public static final String SOURCE_ID = "{\"id\": \"A\", \"idType\": \"string\"}";
+    public static final String TARGET_ID = "[{\"id\": \"E\", \"idType\": \"string\"}]";
     public static final String SHORTEST_PATH = "[A, C, B, E]";
     public static final double TOTAL_WEIGHT = 28;
 

computer-test/src/main/java/org/apache/hugegraph/computer/core/util/IdUtilTest.java

@@ -34,5 +34,8 @@ public void testParseId() {
         Assert.assertEquals(IdType.LONG, IdUtil.parseId(IdCategory.NUMBER, "222").idType());
         Assert.assertEquals(IdType.UTF8, IdUtil.parseId(IdCategory.STRING, "aaa222").idType());
         Assert.assertEquals(IdType.UUID, IdUtil.parseId(IdCategory.UUID, uuid).idType());
+
+        Assert.assertEquals(IdType.UTF8, IdUtil.parseId(IdCategory.STRING, "222").idType());
+        Assert.assertEquals(IdType.UTF8, IdUtil.parseId(IdCategory.STRING, uuid).idType());
     }
 }