Cherry pick cypher support

hugegraph-api/pom.xml

@@ -104,7 +104,12 @@
             <version>${pdclient.version}</version>
             <scope>compile</scope>
         </dependency>
-
+        <dependency>
+            <groupId>org.opencypher.gremlin</groupId>
+            <artifactId>translation</artifactId>
+            <version>1.0.4</version>
+            <scope>compile</scope>
+        </dependency>
     </dependencies>
 
     <build>
@@ -143,7 +148,7 @@
                             </addDefaultSpecificationEntries>
                         </manifest>
                         <manifestEntries>
-                            <Implementation-Version>0.67.0.0</Implementation-Version>
+                            <Implementation-Version>0.69.0.0</Implementation-Version>
                         </manifestEntries>
                     </archive>
                 </configuration>

hugegraph-api/src/main/java/com/baidu/hugegraph/api/gremlin/CypherAPI.java

@@ -0,0 +1,97 @@
+package com.baidu.hugegraph.api.gremlin;
+
+import org.opencypher.gremlin.translation.TranslationFacade;
+import org.slf4j.Logger;
+
+import com.baidu.hugegraph.api.filter.CompressInterceptor;
+import com.baidu.hugegraph.util.E;
+import com.baidu.hugegraph.util.Log;
+import com.codahale.metrics.annotation.Timed;
+
+import javax.inject.Singleton;
+import javax.ws.rs.Consumes;
+import javax.ws.rs.GET;
+import javax.ws.rs.POST;
+import javax.ws.rs.Path;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.Produces;
+import javax.ws.rs.QueryParam;
+import javax.ws.rs.core.Context;
+import javax.ws.rs.core.HttpHeaders;
+import javax.ws.rs.core.Response;
+
+@Path("graphspaces/{graphspace}/graphs/{graph}/cypher")
+@Singleton
+public class CypherAPI extends GremlinQueryAPI {
+
+    private static final Logger LOG = Log.logger(CypherAPI.class);
+
+
+    @GET
+    @Timed
+    @CompressInterceptor.Compress(buffer = (1024 * 40))
+    @Produces(APPLICATION_JSON_WITH_CHARSET)
+    public Response query(@Context HttpHeaders headers,
+                          @PathParam("graphspace") String graphspace,
+                          @PathParam("graph") String graph,
+                          @QueryParam("cypher") String cypher) {
+
+        return this.queryByCypher(headers, graphspace, graph, cypher);
+    }
+
+    @POST
+    @Timed
+    @CompressInterceptor.Compress
+    @Consumes(APPLICATION_JSON)
+    @Produces(APPLICATION_JSON_WITH_CHARSET)
+    public Response post(@Context HttpHeaders headers,
+                         @PathParam("graphspace") String graphspace,
+                         @PathParam("graph") String graph,
+                         String cypher) {
+
+        return this.queryByCypher(headers, graphspace, graph, cypher);
+    }
+
+    private Response queryByCypher(HttpHeaders headers, String graphspace,
+                                   String graph, String cypher) {
+
+        E.checkArgument(graphspace != null && !graphspace.isEmpty(),
+                "The graphspace parameter can't be null or empty");
+        E.checkArgument(graph != null && !graph.isEmpty(),
+                "The graph parameter can't be null or empty");
+        E.checkArgument(cypher != null && !cypher.isEmpty(),
+                "The cypher parameter can't be null or empty");
+        String gremlin = this.translateCypher2Gremlin(cypher);
+        LOG.debug("translated gremlin is {}", gremlin);
+        String auth = headers.getHeaderString(HttpHeaders.AUTHORIZATION);
+        String graphInfo = graphspace + "-" + graph;
+        String gremlinQuery = "{"
+                + "\"gremlin\":\"" + gremlin + "\","
+                + "\"bindings\":{},"
+                + "\"language\":\"gremlin-groovy\","
+                + "\"aliases\":{\"graph\":" + "\"" + graphInfo + "\"" +
+                ", \"g\":\"__g_" + graphInfo + "\"" + "}}";
+        Response response = this.client().doPostRequest(auth, gremlinQuery);
+        return transformResponseIfNeeded(response);
+    }
+
+    private String translateCypher2Gremlin(String cypher) {
+        TranslationFacade translator = new TranslationFacade();
+        String gremlin = translator.toGremlinGroovy(cypher);
+        gremlin = this.buildQueryableGremlin(gremlin);
+        return gremlin;
+    }
+
+    private String buildQueryableGremlin(String gremlin) {
+        /*
+         * `CREATE (a:person { name : 'test', age: 20) return a`
+         * would be translated to:
+         * `g.addV('person').as('a').property(single, 'name', 'test') ...`,
+         * but hugegraph don't support `.property(single, k, v)`,
+         * so we replace it to `.property(k, v)` here
+         */
+        gremlin = gremlin.replace(".property(single,", ".property(");
+
+        return gremlin;
+    }
+}

hugegraph-api/src/main/java/com/baidu/hugegraph/api/gremlin/GremlinAPI.java

@@ -45,13 +45,12 @@
 
 @Path("gremlin")
 @Singleton
-public class GremlinAPI extends API {
+public class GremlinAPI extends GremlinQueryAPI {
 
     private static final Histogram gremlinInputHistogram =
             MetricsUtil.registerHistogram(GremlinAPI.class, "gremlin-input");
     private static final Histogram gremlinOutputHistogram =
             MetricsUtil.registerHistogram(GremlinAPI.class, "gremlin-output");
-
     private static final Set<String> FORBIDDEN_REQUEST_EXCEPTIONS =
             ImmutableSet.of("java.lang.SecurityException",
                             "javax.ws.rs.ForbiddenException");
@@ -100,46 +99,4 @@ public Response post(@Context HugeConfig conf,
         gremlinOutputHistogram.update(response.getLength());
         return transformResponseIfNeeded(response);
     }
-
-    private static Response transformResponseIfNeeded(Response response) {
-        MediaType mediaType = response.getMediaType();
-        if (mediaType != null) {
-            // Append charset
-            assert MediaType.APPLICATION_JSON_TYPE.equals(mediaType);
-            response.getHeaders().putSingle(HttpHeaders.CONTENT_TYPE,
-                                            mediaType.withCharset(CHARSET));
-        }
-
-        Response.StatusType status = response.getStatusInfo();
-        if (status.getStatusCode() < 400) {
-            // No need to transform if normal response without error
-            return response;
-        }
-
-        if (mediaType == null || !JSON.equals(mediaType.getSubtype())) {
-            String message = response.readEntity(String.class);
-            throw new HugeGremlinException(status.getStatusCode(),
-                                           ImmutableMap.of("message", message));
-        }
-
-        @SuppressWarnings("unchecked")
-        Map<String, Object> map = response.readEntity(Map.class);
-        String exClassName = (String) map.get("Exception-Class");
-        if (FORBIDDEN_REQUEST_EXCEPTIONS.contains(exClassName)) {
-            status = Response.Status.FORBIDDEN;
-        } else if (matchBadRequestException(exClassName)) {
-            status = Response.Status.BAD_REQUEST;
-        }
-        throw new HugeGremlinException(status.getStatusCode(), map);
-    }
-
-    private static boolean matchBadRequestException(String exClass) {
-        if (exClass == null) {
-            return false;
-        }
-        if (BAD_REQUEST_EXCEPTIONS.contains(exClass)) {
-            return true;
-        }
-        return BAD_REQUEST_EXCEPTIONS.stream().anyMatch(exClass::startsWith);
-    }
 }

hugegraph-api/src/main/java/com/baidu/hugegraph/api/gremlin/GremlinQueryAPI.java

@@ -0,0 +1,90 @@
+package com.baidu.hugegraph.api.gremlin;
+
+import java.util.Map;
+import java.util.Set;
+
+import com.baidu.hugegraph.api.API;
+import com.baidu.hugegraph.config.HugeConfig;
+import com.baidu.hugegraph.config.ServerOptions;
+import com.baidu.hugegraph.exception.HugeGremlinException;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+
+import javax.inject.Provider;
+import javax.ws.rs.core.Context;
+import javax.ws.rs.core.HttpHeaders;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+
+public class GremlinQueryAPI extends API {
+
+    private static final Set<String> FORBIDDEN_REQUEST_EXCEPTIONS =
+            ImmutableSet.of("java.lang.SecurityException",
+                            "jakarta.ws.rs.ForbiddenException");
+    private static final Set<String> BAD_REQUEST_EXCEPTIONS = ImmutableSet.of(
+            "java.lang.IllegalArgumentException",
+            "java.util.concurrent.TimeoutException",
+            "groovy.lang.",
+            "org.codehaus.",
+            "com.baidu.hugegraph."
+    );
+
+    @Context
+    private Provider<HugeConfig> configProvider;
+
+    private GremlinClient client;
+
+    public GremlinClient client() {
+        if (this.client != null) {
+            return this.client;
+        }
+        HugeConfig config = this.configProvider.get();
+        String url = config.get(ServerOptions.GREMLIN_SERVER_URL);
+        int timeout = config.get(ServerOptions.GREMLIN_SERVER_TIMEOUT) * 1000;
+        int maxRoutes = config.get(ServerOptions.GREMLIN_SERVER_MAX_ROUTE);
+        this.client = new GremlinClient(url, timeout, maxRoutes, maxRoutes);
+        return this.client;
+    }
+
+    protected static Response transformResponseIfNeeded(Response response) {
+        MediaType mediaType = response.getMediaType();
+        if (mediaType != null) {
+            // Append charset
+            assert MediaType.APPLICATION_JSON_TYPE.equals(mediaType);
+            response.getHeaders().putSingle(HttpHeaders.CONTENT_TYPE,
+                                            mediaType.withCharset(CHARSET));
+        }
+
+        Response.StatusType status = response.getStatusInfo();
+        if (status.getStatusCode() < 400) {
+            // No need to transform if normal response without error
+            return response;
+        }
+
+        if (mediaType == null || !JSON.equals(mediaType.getSubtype())) {
+            String message = response.readEntity(String.class);
+            throw new HugeGremlinException(status.getStatusCode(),
+                                           ImmutableMap.of("message", message));
+        }
+
+        @SuppressWarnings("unchecked")
+        Map<String, Object> map = response.readEntity(Map.class);
+        String exClassName = (String) map.get("Exception-Class");
+        if (FORBIDDEN_REQUEST_EXCEPTIONS.contains(exClassName)) {
+            status = Response.Status.FORBIDDEN;
+        } else if (matchBadRequestException(exClassName)) {
+            status = Response.Status.BAD_REQUEST;
+        }
+        throw new HugeGremlinException(status.getStatusCode(), map);
+    }
+
+    private static boolean matchBadRequestException(String exClass) {
+        if (exClass == null) {
+            return false;
+        }
+        if (BAD_REQUEST_EXCEPTIONS.contains(exClass)) {
+            return true;
+        }
+        return BAD_REQUEST_EXCEPTIONS.stream().anyMatch(exClass::startsWith);
+    }
+}

hugegraph-api/src/main/java/com/baidu/hugegraph/version/ApiVersion.java

@@ -118,14 +118,15 @@ public final class ApiVersion {
      * [0.66] Issue-1567: Support get schema RESTful API
      * [0.67] Issue-1065: Support dynamically add/remove graph
      * [0.67] Issue-10: Support adamic-adar & resource-allocation API
-     *
      * version 0.13:
      * [0.67] Issue-11: hugegraph with etcd/pd,
      *        add graphspace, remove auth server
+     * [0.68] Issue-1763: Support adamic-adar & resource-allocation API
+     * [0.69] Issue-1748: Support Cypher query RESTful API
      */
 
     // The second parameter of Version.of() is for IDE running without JAR
-    public static final Version VERSION = Version.of(ApiVersion.class, "0.68");
+    public static final Version VERSION = Version.of(ApiVersion.class, "0.69");
 
     public static final void check() {
         // Check version of hugegraph-core. Firstly do check from version 0.3

hugegraph-test/src/main/java/com/baidu/hugegraph/api/ApiTestSuite.java

@@ -40,7 +40,8 @@
     MetricsApiTest.class,
     UserApiTest.class,
     LoginApiTest.class,
-    TraversersApiTestSuite.class
+    TraversersApiTestSuite.class,
+    CypherApiTest.class
 })
 public class ApiTestSuite {
 

hugegraph-test/src/main/java/com/baidu/hugegraph/api/BaseApiTest.java

@@ -60,7 +60,7 @@ public class BaseApiTest {
     private static final String USERNAME = "admin";
     private static final String PASSWORD = "admin";
 
-    private static final String URL_PREFIX = "graphs/" + GRAPH;
+    protected static final String URL_PREFIX = "graphs/" + GRAPH;
     private static final String SCHEMA_PKS = "/schema/propertykeys";
     private static final String SCHEMA_VLS = "/schema/vertexlabels";
     private static final String SCHEMA_ELS = "/schema/edgelabels";

hugegraph-test/src/main/java/com/baidu/hugegraph/api/CypherApiTest.java

@@ -0,0 +1,86 @@
+/*
+ * Copyright 2017 HugeGraph Authors
+ *
+ * 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 com.baidu.hugegraph.api;
+
+import static com.baidu.hugegraph.testutil.Assert.assertContains;
+
+import java.util.Map;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import com.google.common.collect.ImmutableMap;
+
+import javax.ws.rs.core.Response;
+
+public class CypherApiTest extends BaseApiTest {
+
+    private static final String PATH = URL_PREFIX + "/cypher";
+    private static final String QUERY = "MATCH (n:person) where n.city ='Beijing' return n";
+    private static final String QUERY_RESULT = "Beijing";
+
+    @Before
+    public void prepareSchema() {
+        BaseApiTest.initPropertyKey();
+        BaseApiTest.initVertexLabel();
+        BaseApiTest.initEdgeLabel();
+        BaseApiTest.initIndexLabel();
+        BaseApiTest.initVertex();
+        BaseApiTest.initEdge();
+    }
+
+    @Test
+    public void testGet() {
+        Map<String, Object> params = ImmutableMap.of("cypher", QUERY);
+        Response r =  client().get(PATH, params);
+
+        this.validStatusAndTextContains(QUERY_RESULT, r);
+    }
+
+    @Test
+    public void testPost() {
+        this.testCypherQueryAndContains(QUERY, QUERY_RESULT);
+    }
+
+    @Test
+    public void testCreate() {
+        this.testCypherQueryAndContains("CREATE (n:person { name : 'test', " +
+                                        "age: 20, city: 'Hefei' }) return n",
+                                        "Hefei");
+    }
+
+    @Test
+    public void testRelationQuery() {
+        String cypher = "MATCH (n:person)-[r:knows]->(friend:person)\n" +
+                        "WHERE n.name = 'marko'\n" +
+                        "RETURN n, friend.name AS friend";
+        this.testCypherQueryAndContains(cypher, "friend");
+    }
+
+    private void testCypherQueryAndContains(String cypher, String containsText) {
+        Response r = client().post(PATH, cypher);
+        this.validStatusAndTextContains(containsText, r);
+    }
+
+    private void validStatusAndTextContains(String value, Response r) {
+        String content = assertResponseStatus(200, r);
+        assertContains(value, content);
+    }
+}