You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tinkerpop.apache.org by va...@apache.org on 2023/11/16 00:49:18 UTC
(tinkerpop) 01/01: merge bytecode over HTTP PR
This is an automated email from the ASF dual-hosted git repository.
valentyn pushed a commit to branch 3.7-dev
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git
commit 0abb82d87f155191750f42e5f2a4ffc9f037eaf9
Merge: ed4dac94af 8365421f25
Author: Valentyn Kahamlyk <Va...@improving.com>
AuthorDate: Wed Nov 15 16:48:44 2023 -0800
merge bytecode over HTTP PR
.../driver/handler/HttpGremlinRequestEncoder.java | 48 +++---
.../driver/handler/HttpGremlinResponseDecoder.java | 8 +-
.../gremlin/groovy/engine/GremlinExecutor.java | 86 +++++++++--
.../gremlin_python/driver/aiohttp/transport.py | 4 +-
.../main/python/gremlin_python/driver/protocol.py | 32 +---
.../driver/test_driver_remote_connection_http.py | 19 +--
.../conf/gremlin-server-rest-modern.yaml | 5 +-
.../server/handler/HttpGremlinEndpointHandler.java | 82 +++++-----
.../gremlin/server/handler/HttpHandlerUtil.java | 63 +++++++-
.../server/util/TextPlainMessageSerializer.java | 7 +-
.../server/GremlinServerHttpIntegrateTest.java | 20 ++-
.../gremlin/server/HttpDriverIntegrateTest.java | 30 +++-
.../server/handler/HttpHandlerUtilTest.java | 165 +++++++++++++++++++++
.../util/ser/GraphSONMessageSerializerV3Test.java | 48 +++++-
.../binary/GraphBinaryMessageSerializerV1Test.java | 25 +++-
15 files changed, 483 insertions(+), 159 deletions(-)
diff --cc gremlin-driver/src/main/java/org/apache/tinkerpop/gremlin/driver/handler/HttpGremlinRequestEncoder.java
index 1c15f6162c,bdf0f544af..c29dd1ddaa
--- a/gremlin-driver/src/main/java/org/apache/tinkerpop/gremlin/driver/handler/HttpGremlinRequestEncoder.java
+++ b/gremlin-driver/src/main/java/org/apache/tinkerpop/gremlin/driver/handler/HttpGremlinRequestEncoder.java
@@@ -27,16 -27,13 +27,13 @@@ import io.netty.handler.codec.http.Full
import io.netty.handler.codec.http.HttpHeaderNames;
import io.netty.handler.codec.http.HttpMethod;
import io.netty.handler.codec.http.HttpVersion;
- import org.apache.tinkerpop.gremlin.util.MessageSerializer;
- import org.apache.tinkerpop.gremlin.util.Tokens;
-import org.apache.tinkerpop.gremlin.driver.MessageSerializer;
import org.apache.tinkerpop.gremlin.driver.exception.ResponseException;
-import org.apache.tinkerpop.gremlin.driver.message.RequestMessage;
-import org.apache.tinkerpop.gremlin.driver.message.ResponseStatusCode;
-import org.apache.tinkerpop.gremlin.driver.ser.SerTokens;
+ import org.apache.tinkerpop.gremlin.process.traversal.Bytecode;
++import org.apache.tinkerpop.gremlin.util.MessageSerializer;
+import org.apache.tinkerpop.gremlin.util.message.RequestMessage;
+import org.apache.tinkerpop.gremlin.util.message.ResponseStatusCode;
- import org.apache.tinkerpop.gremlin.process.traversal.Bytecode;
- import org.apache.tinkerpop.gremlin.process.traversal.translator.GroovyTranslator;
- import org.apache.tinkerpop.shaded.jackson.databind.ObjectMapper;
++import org.apache.tinkerpop.gremlin.util.ser.SerTokens;
- import java.util.HashMap;
import java.util.List;
import java.util.function.UnaryOperator;
@@@ -58,29 -53,22 +53,22 @@@ public final class HttpGremlinRequestEn
@Override
protected void encode(final ChannelHandlerContext channelHandlerContext, final RequestMessage requestMessage, final List<Object> objects) throws Exception {
- try {
- final String gremlin;
- final Object gremlinStringOrBytecode = requestMessage.getArg(Tokens.ARGS_GREMLIN);
+ final String mimeType = serializer.mimeTypesSupported()[0];
+ // only GraphSON3 and GraphBinary recommended for serialization of Bytecode requests
+ if (requestMessage.getArg("gremlin") instanceof Bytecode &&
- !mimeType.equals(SerTokens.MIME_GRAPHSON_V3D0) &&
- !mimeType.equals(SerTokens.MIME_GRAPHBINARY_V1D0)) {
++ !mimeType.equals(SerTokens.MIME_GRAPHSON_V3) &&
++ !mimeType.equals(SerTokens.MIME_GRAPHBINARY_V1)) {
+ throw new ResponseException(ResponseStatusCode.REQUEST_ERROR_SERIALIZATION, String.format(
+ "An error occurred during serialization of this request [%s] - it could not be sent to the server - Reason: only GraphSON3 and GraphBinary recommended for serialization of Bytecode requests, but used %s",
+ requestMessage, serializer.getClass().getName()));
+ }
- // the gremlin key can contain a Gremlin script or bytecode. if it's bytecode we can't submit it over
- // http as such. it has to be converted to a script and we can do that with the Groovy translator.
- final boolean usesBytecode = gremlinStringOrBytecode instanceof Bytecode;
- if (usesBytecode) {
- gremlin = GroovyTranslator.of("g").translate((Bytecode) gremlinStringOrBytecode).getScript();
- } else {
- gremlin = gremlinStringOrBytecode.toString();
- }
- final byte[] payload = mapper.writeValueAsBytes(new HashMap<String,Object>() {{
- put(Tokens.ARGS_GREMLIN, gremlin);
- put(Tokens.REQUEST_ID, requestMessage.getRequestId());
- if (usesBytecode) put("op", Tokens.OPS_BYTECODE);
- }});
- final ByteBuf bb = channelHandlerContext.alloc().buffer(payload.length);
- bb.writeBytes(payload);
- final FullHttpRequest request = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.POST, "/", bb);
- request.headers().add(HttpHeaderNames.CONTENT_TYPE, "application/json");
- request.headers().add(HttpHeaderNames.CONTENT_LENGTH, payload.length);
- request.headers().add(HttpHeaderNames.ACCEPT, serializer.mimeTypesSupported()[0]);
+ try {
+ final ByteBuf buffer = serializer.serializeRequestAsBinary(requestMessage, channelHandlerContext.alloc());
+ final FullHttpRequest request = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.POST, "/", buffer);
+ request.headers().add(HttpHeaderNames.CONTENT_TYPE, mimeType);
+ request.headers().add(HttpHeaderNames.CONTENT_LENGTH, buffer.readableBytes());
+ request.headers().add(HttpHeaderNames.ACCEPT, mimeType);
objects.add(interceptor.apply(request));
} catch (Exception ex) {
diff --cc gremlin-server/conf/gremlin-server-rest-modern.yaml
index a0d82bd9b4,66928acba0..5da2f36cc9
--- a/gremlin-server/conf/gremlin-server-rest-modern.yaml
+++ b/gremlin-server/conf/gremlin-server-rest-modern.yaml
@@@ -28,7 -28,10 +28,10 @@@ scriptEngines:
org.apache.tinkerpop.gremlin.jsr223.ImportGremlinPlugin: {classImports: [java.lang.Math], methodImports: [java.lang.Math#*]},
org.apache.tinkerpop.gremlin.jsr223.ScriptFileGremlinPlugin: {files: [scripts/generate-modern.groovy]}}}}
serializers:
- - { className: org.apache.tinkerpop.gremlin.util.ser.GraphSONMessageSerializerV3, config: { ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV3] }} # application/json
- - { className: org.apache.tinkerpop.gremlin.driver.ser.GraphSONMessageSerializerV3d0, config: { ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV3d0] }} # application/vnd.gremlin-v3.0+json
- - { className: org.apache.tinkerpop.gremlin.driver.ser.GraphBinaryMessageSerializerV1 } # application/vnd.graphbinary-v1.0
- - { className: org.apache.tinkerpop.gremlin.driver.ser.GraphBinaryMessageSerializerV1, config: { serializeResultToString: true }} # application/vnd.graphbinary-v1.0-stringd
-
++ - { className: org.apache.tinkerpop.gremlin.util.ser.GraphSONUntypedMessageSerializerV3, config: { ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV3] }} # application/vnd.gremlin-v3.0+json;types=false
++ - { className: org.apache.tinkerpop.gremlin.util.ser.GraphSONMessageSerializerV3, config: { ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV3] }} # application/vnd.gremlin-v3.0+json
++ - { className: org.apache.tinkerpop.gremlin.util.ser.GraphBinaryMessageSerializerV1 } # application/vnd.graphbinary-v1.0
++ - { className: org.apache.tinkerpop.gremlin.util.ser.GraphBinaryMessageSerializerV1, config: { serializeResultToString: true }} # application/vnd.graphbinary-v1.0-stringd
metrics: {
slf4jReporter: {enabled: true, interval: 180000}}
strictTransactionManagement: false
diff --cc gremlin-server/src/main/java/org/apache/tinkerpop/gremlin/server/handler/HttpGremlinEndpointHandler.java
index d1ac15a01c,59b179c84a..ec19b28e6d
--- a/gremlin-server/src/main/java/org/apache/tinkerpop/gremlin/server/handler/HttpGremlinEndpointHandler.java
+++ b/gremlin-server/src/main/java/org/apache/tinkerpop/gremlin/server/handler/HttpGremlinEndpointHandler.java
@@@ -19,47 -19,43 +19,47 @@@
package org.apache.tinkerpop.gremlin.server.handler;
import com.codahale.metrics.Timer;
+ import io.netty.buffer.ByteBuf;
+ import io.netty.buffer.Unpooled;
+ import io.netty.channel.ChannelHandler;
+ import io.netty.channel.ChannelHandlerContext;
+ import io.netty.channel.ChannelInboundHandlerAdapter;
+ import io.netty.channel.ChannelPromise;
+ import io.netty.handler.codec.TooLongFrameException;
import io.netty.handler.codec.http.DefaultFullHttpResponse;
- import io.netty.handler.codec.http.FullHttpResponse;
import io.netty.handler.codec.http.FullHttpRequest;
- import io.netty.handler.codec.http.HttpUtil;
+ import io.netty.handler.codec.http.FullHttpResponse;
import io.netty.handler.codec.http.HttpHeaderNames;
import io.netty.handler.codec.http.HttpResponseStatus;
- import org.apache.tinkerpop.gremlin.process.remote.traversal.DefaultRemoteTraverser;
- import org.apache.tinkerpop.gremlin.util.message.RequestMessage;
- import org.apache.tinkerpop.gremlin.jsr223.GremlinScriptChecker;
- import org.apache.tinkerpop.gremlin.process.traversal.traverser.util.AbstractTraverser;
- import org.apache.tinkerpop.gremlin.structure.Element;
- import org.apache.tinkerpop.gremlin.structure.util.reference.ReferenceFactory;
- import org.apache.tinkerpop.gremlin.util.Tokens;
- import org.apache.tinkerpop.gremlin.util.ser.SerializationException;
- import org.apache.tinkerpop.gremlin.server.util.TextPlainMessageSerializer;
- import org.javatuples.Pair;
- import org.slf4j.Logger;
- import org.slf4j.LoggerFactory;
- import org.apache.tinkerpop.gremlin.util.ExceptionHelper;
- import org.apache.tinkerpop.gremlin.util.MessageSerializer;
- import org.apache.tinkerpop.gremlin.util.message.ResponseMessage;
- import org.apache.tinkerpop.gremlin.util.message.ResponseStatusCode;
- import org.apache.tinkerpop.gremlin.util.ser.MessageTextSerializer;
+ import io.netty.handler.codec.http.HttpUtil;
+ import io.netty.util.ReferenceCountUtil;
import org.apache.tinkerpop.gremlin.groovy.engine.GremlinExecutor;
++import org.apache.tinkerpop.gremlin.jsr223.GremlinScriptChecker;
+ import org.apache.tinkerpop.gremlin.process.remote.traversal.DefaultRemoteTraverser;
import org.apache.tinkerpop.gremlin.process.traversal.TraversalSource;
++import org.apache.tinkerpop.gremlin.process.traversal.traverser.util.AbstractTraverser;
import org.apache.tinkerpop.gremlin.server.GraphManager;
import org.apache.tinkerpop.gremlin.server.GremlinServer;
import org.apache.tinkerpop.gremlin.server.Settings;
import org.apache.tinkerpop.gremlin.server.auth.AuthenticatedUser;
import org.apache.tinkerpop.gremlin.server.util.MetricManager;
+ import org.apache.tinkerpop.gremlin.server.util.TextPlainMessageSerializer;
++import org.apache.tinkerpop.gremlin.structure.Element;
import org.apache.tinkerpop.gremlin.structure.Graph;
++import org.apache.tinkerpop.gremlin.structure.util.reference.ReferenceFactory;
+ import org.apache.tinkerpop.gremlin.util.ExceptionHelper;
-import org.apache.tinkerpop.gremlin.driver.MessageSerializer;
-import org.apache.tinkerpop.gremlin.driver.Tokens;
++import org.apache.tinkerpop.gremlin.util.MessageSerializer;
++import org.apache.tinkerpop.gremlin.util.Tokens;
import org.apache.tinkerpop.gremlin.util.function.FunctionUtils;
import org.apache.tinkerpop.gremlin.util.iterator.IteratorUtils;
- import io.netty.buffer.ByteBuf;
- import io.netty.buffer.Unpooled;
- import io.netty.channel.ChannelHandler;
- import io.netty.channel.ChannelHandlerContext;
- import io.netty.channel.ChannelInboundHandlerAdapter;
- import io.netty.channel.ChannelPromise;
- import io.netty.handler.codec.TooLongFrameException;
- import io.netty.util.ReferenceCountUtil;
-import org.apache.tinkerpop.gremlin.driver.message.RequestMessage;
-import org.apache.tinkerpop.gremlin.driver.message.ResponseMessage;
-import org.apache.tinkerpop.gremlin.driver.message.ResponseStatusCode;
-import org.apache.tinkerpop.gremlin.driver.ser.MessageTextSerializer;
-import org.apache.tinkerpop.gremlin.driver.ser.SerializationException;
++import org.apache.tinkerpop.gremlin.util.message.RequestMessage;
++import org.apache.tinkerpop.gremlin.util.message.ResponseMessage;
++import org.apache.tinkerpop.gremlin.util.message.ResponseStatusCode;
++import org.apache.tinkerpop.gremlin.util.ser.MessageTextSerializer;
++import org.apache.tinkerpop.gremlin.util.ser.SerializationException;
+ import org.javatuples.Pair;
+ import org.slf4j.Logger;
+ import org.slf4j.LoggerFactory;
import javax.script.Bindings;
import javax.script.SimpleBindings;
@@@ -93,7 -93,7 +97,6 @@@ import static io.netty.handler.codec.ht
public class HttpGremlinEndpointHandler extends ChannelInboundHandlerAdapter {
private static final Logger logger = LoggerFactory.getLogger(HttpGremlinEndpointHandler.class);
private static final Logger auditLogger = LoggerFactory.getLogger(GremlinServer.AUDIT_LOGGER_NAME);
-- private static final Charset UTF8 = StandardCharsets.UTF_8;
private static final Timer evalOpTimer = MetricManager.INSTANCE.getTimer(name(GremlinServer.class, "op", "eval"));
@@@ -229,28 -230,13 +233,30 @@@
requestMessage.getArg(Tokens.ARGS_GREMLIN),
requestMessage.getArg(Tokens.ARGS_BINDINGS), o, Thread.currentThread().getName());
- final Optional<String> mp = GremlinScriptChecker.parse(requestMessage.getArg(Tokens.ARGS_GREMLIN)).getMaterializeProperties();
++ final Optional<String> mp = requestMessage.getArg(Tokens.ARGS_GREMLIN) instanceof String
++ ? GremlinScriptChecker.parse(requestMessage.getArg(Tokens.ARGS_GREMLIN)).getMaterializeProperties()
++ : Optional.empty();
+
// need to replicate what TraversalOpProcessor does with the bytecode op. it converts
// results to Traverser so that GLVs can handle the results. don't quite get the same
// benefit here because the bulk has to be 1 since we've already resolved the result,
// but at least http is compatible
- final List<Object> results = requestMessage.getProcessor().equals(Tokens.OPS_BYTECODE) ?
+ final List<Object> results = requestMessage.getOp().equals(Tokens.OPS_BYTECODE) ?
(List<Object>) IteratorUtils.asList(o).stream().map(r -> new DefaultRemoteTraverser<Object>(r, 1)).collect(Collectors.toList()) :
IteratorUtils.asList(o);
+
+ if (mp.isPresent() && mp.get().equals(Tokens.MATERIALIZE_PROPERTIES_TOKENS)) {
+ final Object firstElement = results.get(0);
+
+ if (firstElement instanceof Element) {
+ for (int i = 0; i < results.size(); i++)
+ results.set(i, ReferenceFactory.detach((Element) results.get(i)));
+ } else if (firstElement instanceof AbstractTraverser) {
+ for (final Object item : results)
+ ((AbstractTraverser) item).detach();
+ }
+ }
+
final ResponseMessage responseMessage = ResponseMessage.build(requestMessage.getRequestId())
.code(ResponseStatusCode.SUCCESS)
.result(results).create();
diff --cc gremlin-server/src/main/java/org/apache/tinkerpop/gremlin/server/handler/HttpHandlerUtil.java
index b8232981d8,748d9d39ae..e3f92540e8
--- a/gremlin-server/src/main/java/org/apache/tinkerpop/gremlin/server/handler/HttpHandlerUtil.java
+++ b/gremlin-server/src/main/java/org/apache/tinkerpop/gremlin/server/handler/HttpHandlerUtil.java
@@@ -23,14 -24,16 +24,22 @@@ import io.netty.buffer.Unpooled
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
--import io.netty.handler.codec.http.*;
++import io.netty.handler.codec.http.DefaultFullHttpResponse;
++import io.netty.handler.codec.http.FullHttpRequest;
++import io.netty.handler.codec.http.FullHttpResponse;
++import io.netty.handler.codec.http.HttpHeaderNames;
++import io.netty.handler.codec.http.HttpResponseStatus;
++import io.netty.handler.codec.http.HttpUtil;
++import io.netty.handler.codec.http.QueryStringDecoder;
import io.netty.util.CharsetUtil;
import org.apache.commons.lang3.exception.ExceptionUtils;
-import org.apache.tinkerpop.gremlin.driver.MessageSerializer;
-import org.apache.tinkerpop.gremlin.driver.Tokens;
-import org.apache.tinkerpop.gremlin.driver.message.RequestMessage;
++import org.apache.tinkerpop.gremlin.util.MessageSerializer;
+import org.apache.tinkerpop.gremlin.util.Tokens;
+import org.apache.tinkerpop.gremlin.util.message.RequestMessage;
import org.apache.tinkerpop.gremlin.server.GremlinServer;
import org.apache.tinkerpop.gremlin.server.op.standard.StandardOpProcessor;
import org.apache.tinkerpop.gremlin.server.util.MetricManager;
-import org.apache.tinkerpop.gremlin.driver.ser.SerializationException;
++import org.apache.tinkerpop.gremlin.util.ser.SerializationException;
import org.apache.tinkerpop.shaded.jackson.databind.JsonNode;
import org.apache.tinkerpop.shaded.jackson.databind.ObjectMapper;
import org.apache.tinkerpop.shaded.jackson.databind.node.ArrayNode;
diff --cc gremlin-server/src/main/java/org/apache/tinkerpop/gremlin/server/util/TextPlainMessageSerializer.java
index fe6cdbf7d9,ea0332de48..002058e09f
--- a/gremlin-server/src/main/java/org/apache/tinkerpop/gremlin/server/util/TextPlainMessageSerializer.java
+++ b/gremlin-server/src/main/java/org/apache/tinkerpop/gremlin/server/util/TextPlainMessageSerializer.java
@@@ -20,10 -20,11 +20,11 @@@ package org.apache.tinkerpop.gremlin.se
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufAllocator;
+ import io.netty.util.CharsetUtil;
-import org.apache.tinkerpop.gremlin.driver.message.RequestMessage;
-import org.apache.tinkerpop.gremlin.driver.message.ResponseMessage;
-import org.apache.tinkerpop.gremlin.driver.ser.MessageTextSerializer;
-import org.apache.tinkerpop.gremlin.driver.ser.SerializationException;
+import org.apache.tinkerpop.gremlin.util.message.RequestMessage;
+import org.apache.tinkerpop.gremlin.util.message.ResponseMessage;
+import org.apache.tinkerpop.gremlin.util.ser.MessageTextSerializer;
+import org.apache.tinkerpop.gremlin.util.ser.SerializationException;
import java.util.List;
import java.util.Objects;
diff --cc gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/server/GremlinServerHttpIntegrateTest.java
index 3a0970d60f,6d01dd45e6..40de5c0563
--- a/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/server/GremlinServerHttpIntegrateTest.java
+++ b/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/server/GremlinServerHttpIntegrateTest.java
@@@ -18,18 -18,20 +18,21 @@@
*/
package org.apache.tinkerpop.gremlin.server;
+ import io.netty.buffer.ByteBuf;
+ import io.netty.buffer.Unpooled;
import org.apache.commons.lang3.RandomStringUtils;
+ import org.apache.http.HttpEntity;
import org.apache.http.HttpHeaders;
-import org.apache.tinkerpop.gremlin.driver.message.ResponseMessage;
-import org.apache.tinkerpop.gremlin.driver.ser.GraphBinaryMessageSerializerV1;
-import org.apache.tinkerpop.gremlin.driver.ser.GraphSONMessageSerializerGremlinV1d0;
-import org.apache.tinkerpop.gremlin.driver.Tokens;
-import org.apache.tinkerpop.gremlin.driver.ser.GraphSONMessageSerializerV2d0;
-import org.apache.tinkerpop.gremlin.driver.ser.GraphSONMessageSerializerV3d0;
-import org.apache.tinkerpop.gremlin.driver.ser.GraphSONUntypedMessageSerializerV1d0;
-import org.apache.tinkerpop.gremlin.driver.ser.GraphSONUntypedMessageSerializerV2d0;
-import org.apache.tinkerpop.gremlin.driver.ser.SerTokens;
+import org.apache.tinkerpop.gremlin.util.message.ResponseMessage;
+import org.apache.tinkerpop.gremlin.util.ser.GraphBinaryMessageSerializerV1;
+import org.apache.tinkerpop.gremlin.util.Tokens;
+import org.apache.tinkerpop.gremlin.util.ser.GraphSONMessageSerializerV1;
+import org.apache.tinkerpop.gremlin.util.ser.GraphSONMessageSerializerV2;
+import org.apache.tinkerpop.gremlin.util.ser.GraphSONMessageSerializerV3;
+import org.apache.tinkerpop.gremlin.util.ser.GraphSONUntypedMessageSerializerV1;
+import org.apache.tinkerpop.gremlin.util.ser.GraphSONUntypedMessageSerializerV2;
+import org.apache.tinkerpop.gremlin.util.ser.GraphSONUntypedMessageSerializerV3;
+import org.apache.tinkerpop.gremlin.util.ser.SerTokens;
import org.apache.tinkerpop.gremlin.server.auth.SimpleAuthenticator;
import org.apache.tinkerpop.gremlin.server.channel.HttpChannelizer;
import org.apache.http.Consts;
diff --cc gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/server/HttpDriverIntegrateTest.java
index 4b533fc021,528e325d8a..c9a04db99f
--- a/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/server/HttpDriverIntegrateTest.java
+++ b/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/server/HttpDriverIntegrateTest.java
@@@ -26,10 -27,14 +27,13 @@@ import org.apache.tinkerpop.gremlin.dri
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
import org.apache.tinkerpop.gremlin.server.channel.HttpChannelizer;
import org.apache.tinkerpop.gremlin.structure.Transaction;
-import org.apache.tinkerpop.gremlin.driver.ser.Serializers;
++import org.apache.tinkerpop.gremlin.util.ser.Serializers;
import org.junit.Test;
import static org.apache.tinkerpop.gremlin.process.traversal.AnonymousTraversalSource.traversal;
+ import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.endsWith;
+ import static org.hamcrest.core.AllOf.allOf;
+ import static org.hamcrest.core.StringContains.containsString;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
@@@ -89,6 -95,24 +94,24 @@@ public class HttpDriverIntegrateTest ex
}
}
+ @Test
+ public void shouldGetErrorForBytecodeWithUntypedGraphSON() throws Exception {
+ final Cluster cluster = TestClientFactory.build()
+ .channelizer(Channelizer.HttpChannelizer.class)
- .serializer(Serializers.GRAPHSON_V2D0_UNTYPED)
++ .serializer(Serializers.GRAPHSON_V2_UNTYPED)
+ .create();
+ try {
+ final GraphTraversalSource g = traversal().withRemote(DriverRemoteConnection.using(cluster));
+ g.inject("2").toList();
+ fail("Exception expected");
+ } catch (EncoderException ex) {
+ assertThat(ex.getMessage(), allOf(containsString("An error occurred during serialization of this request"),
+ containsString("it could not be sent to the server - Reason: only GraphSON3 and GraphBinary recommended for serialization of Bytecode requests, but used org.apache.tinkerpop.gremlin.")));
+ } finally {
+ cluster.close();
+ }
+ }
+
@Test
public void shouldSubmitBytecodeWithGraphBinary() throws Exception {
final Cluster cluster = TestClientFactory.build()
diff --cc gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/server/handler/HttpHandlerUtilTest.java
index 0000000000,6b911d9b2e..51aacf260f
mode 000000,100644..100644
--- a/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/server/handler/HttpHandlerUtilTest.java
+++ b/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/server/handler/HttpHandlerUtilTest.java
@@@ -1,0 -1,165 +1,165 @@@
+ /*
+ * 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.tinkerpop.gremlin.server.handler;
+
+ import io.netty.buffer.ByteBuf;
+ import io.netty.buffer.ByteBufAllocator;
+ import io.netty.handler.codec.http.DefaultFullHttpRequest;
+ import io.netty.handler.codec.http.DefaultHttpHeaders;
+ import io.netty.handler.codec.http.FullHttpRequest;
+ import io.netty.handler.codec.http.HttpHeaderNames;
+ import io.netty.handler.codec.http.HttpHeaders;
+ import io.netty.handler.codec.http.HttpMethod;
+ import io.netty.handler.codec.http.HttpVersion;
+ import io.netty.handler.codec.http.QueryStringEncoder;
+ import io.netty.util.CharsetUtil;
-import org.apache.tinkerpop.gremlin.driver.MessageSerializer;
-import org.apache.tinkerpop.gremlin.driver.Tokens;
-import org.apache.tinkerpop.gremlin.driver.message.RequestMessage;
-import org.apache.tinkerpop.gremlin.driver.ser.GraphBinaryMessageSerializerV1;
-import org.apache.tinkerpop.gremlin.driver.ser.GraphSONMessageSerializerV3d0;
-import org.apache.tinkerpop.gremlin.driver.ser.SerTokens;
-import org.apache.tinkerpop.gremlin.driver.ser.SerializationException;
++import org.apache.tinkerpop.gremlin.util.MessageSerializer;
++import org.apache.tinkerpop.gremlin.util.Tokens;
++import org.apache.tinkerpop.gremlin.util.message.RequestMessage;
++import org.apache.tinkerpop.gremlin.util.ser.GraphBinaryMessageSerializerV1;
++import org.apache.tinkerpop.gremlin.util.ser.GraphSONMessageSerializerV3;
++import org.apache.tinkerpop.gremlin.util.ser.SerTokens;
++import org.apache.tinkerpop.gremlin.util.ser.SerializationException;
+ import org.junit.Test;
+
+ import java.util.ArrayList;
+ import java.util.Arrays;
+ import java.util.HashMap;
+ import java.util.List;
+ import java.util.Map;
+ import java.util.UUID;
+
+ import static org.hamcrest.MatcherAssert.assertThat;
+ import static org.hamcrest.Matchers.samePropertyValuesAs;
+ import static org.junit.Assert.assertEquals;
+ import static org.junit.Assert.fail;
+
+ public class HttpHandlerUtilTest {
+
+ private final ByteBufAllocator allocator = ByteBufAllocator.DEFAULT;
+ private final GraphBinaryMessageSerializerV1 graphBinarySerializer = new GraphBinaryMessageSerializerV1();
- public final GraphSONMessageSerializerV3d0 graphSONSerializer = new GraphSONMessageSerializerV3d0();
++ public final GraphSONMessageSerializerV3 graphSONSerializer = new GraphSONMessageSerializerV3();
+
+ @Test
+ public void shouldFailWhenIncorrectSerializerUsed() throws SerializationException {
+ final RequestMessage request = RequestMessage.build(Tokens.OPS_BYTECODE)
+ .processor("traversal")
+ .overrideRequestId(UUID.randomUUID())
+ .addArg(Tokens.ARGS_GREMLIN, "g.V()")
+ .create();
+
+ final ByteBuf buffer = graphSONSerializer.serializeRequestAsBinary(request, allocator);
+
+ final HttpHeaders headers = new DefaultHttpHeaders();
- headers.add(HttpHeaderNames.CONTENT_TYPE, SerTokens.MIME_GRAPHBINARY_V1D0);
++ headers.add(HttpHeaderNames.CONTENT_TYPE, SerTokens.MIME_GRAPHBINARY_V1);
+
+ final FullHttpRequest httpRequest = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.POST, "some uri",
+ buffer, headers, new DefaultHttpHeaders());
+
+ final Map<String, MessageSerializer<?>> serializers = new HashMap<>();
- serializers.put(SerTokens.MIME_GRAPHBINARY_V1D0, graphBinarySerializer);
++ serializers.put(SerTokens.MIME_GRAPHBINARY_V1, graphBinarySerializer);
+
+ try {
+ HttpHandlerUtil.getRequestMessageFromHttpRequest(httpRequest, serializers);
+ fail("SerializationException expected");
+ } catch (IllegalArgumentException ex) {
+ assertEquals("Mime type mismatch. Value in content-type header is not equal payload header.", ex.getMessage());
+ }
+ }
+
+ @Test
+ public void shouldCorrectlyDeserializeRequestMessage() throws SerializationException {
+ final RequestMessage request = RequestMessage.build(Tokens.OPS_BYTECODE)
+ .processor("traversal")
+ .overrideRequestId(UUID.randomUUID())
+ .addArg(Tokens.ARGS_GREMLIN, "g.V()")
+ .create();
+
+ final ByteBuf buffer = graphBinarySerializer.serializeRequestAsBinary(request, allocator);
+
+ final HttpHeaders headers = new DefaultHttpHeaders();
- headers.add(HttpHeaderNames.CONTENT_TYPE, SerTokens.MIME_GRAPHBINARY_V1D0);
++ headers.add(HttpHeaderNames.CONTENT_TYPE, SerTokens.MIME_GRAPHBINARY_V1);
+
+ final FullHttpRequest httpRequest = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.POST, "some uri",
+ buffer, headers, new DefaultHttpHeaders());
+
+ final Map<String, MessageSerializer<?>> serializers = new HashMap<>();
- serializers.put(SerTokens.MIME_GRAPHBINARY_V1D0, graphBinarySerializer);
++ serializers.put(SerTokens.MIME_GRAPHBINARY_V1, graphBinarySerializer);
+
+ final RequestMessage deserialized = HttpHandlerUtil.getRequestMessageFromHttpRequest(httpRequest, serializers);
+ assertThat(request, samePropertyValuesAs(deserialized));
+ }
+
+ @Test
+ public void shouldCorrectlyDeserializeGremlinFromPostRequest() throws SerializationException {
+ final String gremlin = "g.V().hasLabel('person')";
+ final UUID requestId = UUID.randomUUID();
+ final ByteBuf buffer = allocator.buffer();
+ buffer.writeCharSequence("{ \"gremlin\": \"" + gremlin +
+ "\", \"requestId\": \"" + requestId +
+ "\", \"language\": \"gremlin-groovy\"}",
+ CharsetUtil.UTF_8);
+
+ final HttpHeaders headers = new DefaultHttpHeaders();
+ headers.add(HttpHeaderNames.CONTENT_TYPE, SerTokens.MIME_JSON);
+
+ final FullHttpRequest httpRequest = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.POST, "some uri",
+ buffer, headers, new DefaultHttpHeaders());
+
+ final Map<String, MessageSerializer<?>> serializers = new HashMap<>();
- serializers.put(SerTokens.MIME_GRAPHBINARY_V1D0, graphBinarySerializer);
++ serializers.put(SerTokens.MIME_GRAPHBINARY_V1, graphBinarySerializer);
+
+ final RequestMessage deserialized = HttpHandlerUtil.getRequestMessageFromHttpRequest(httpRequest, serializers);
+ assertEquals(gremlin, deserialized.getArgs().get(Tokens.ARGS_GREMLIN));
+ assertEquals(requestId, deserialized.getRequestId());
+ assertEquals("gremlin-groovy", deserialized.getArg(Tokens.ARGS_LANGUAGE));
+ }
+
+ @Test
+ public void shouldCorrectlyDeserializeGremlinFromGetRequest() throws SerializationException {
+ final String gremlin = "g.V().hasLabel('person')";
+ final UUID requestId = UUID.randomUUID();
+ final ByteBuf buffer = allocator.buffer();
+
+ final List<String> headerOptions = Arrays.asList("", null, SerTokens.MIME_JSON, "some invalid value");
+
+ for (final String contentTypeValue : headerOptions) {
+ final HttpHeaders headers = new DefaultHttpHeaders();
+ if (contentTypeValue != null) {
+ headers.add(HttpHeaderNames.CONTENT_TYPE, contentTypeValue);
+ }
+
+ final QueryStringEncoder encoder = new QueryStringEncoder("/");
+ encoder.addParam("gremlin", gremlin);
+ encoder.addParam("requestId", requestId.toString());
+ encoder.addParam("language", "gremlin-groovy");
+
+ final FullHttpRequest httpRequest = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET,
+ encoder.toString(), buffer, headers, new DefaultHttpHeaders());
+
+ final Map<String, MessageSerializer<?>> serializers = new HashMap<>();
- serializers.put(SerTokens.MIME_GRAPHBINARY_V1D0, graphBinarySerializer);
++ serializers.put(SerTokens.MIME_GRAPHBINARY_V1, graphBinarySerializer);
+
+ final RequestMessage deserialized = HttpHandlerUtil.getRequestMessageFromHttpRequest(httpRequest, serializers);
+ assertEquals(gremlin, deserialized.getArgs().get(Tokens.ARGS_GREMLIN));
+ assertEquals(requestId, deserialized.getRequestId());
+ assertEquals("gremlin-groovy", deserialized.getArg(Tokens.ARGS_LANGUAGE));
+ }
+ }
+ }
diff --cc gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONMessageSerializerV3Test.java
index 9ba58a8fd0,0000000000..584af0649d
mode 100644,000000..100644
--- a/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONMessageSerializerV3Test.java
+++ b/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONMessageSerializerV3Test.java
@@@ -1,387 -1,0 +1,419 @@@
+/*
+ * 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.tinkerpop.gremlin.util.ser;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufAllocator;
+import io.netty.buffer.UnpooledByteBufAllocator;
++import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
++import org.apache.tinkerpop.gremlin.structure.util.empty.EmptyGraph;
+import org.apache.tinkerpop.gremlin.util.MessageSerializer;
++import org.apache.tinkerpop.gremlin.util.Tokens;
+import org.apache.tinkerpop.gremlin.util.message.RequestMessage;
+import org.apache.tinkerpop.gremlin.util.message.ResponseMessage;
+import org.apache.tinkerpop.gremlin.util.message.ResponseStatusCode;
+import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
+import org.apache.tinkerpop.gremlin.process.traversal.step.util.Tree;
+import org.apache.tinkerpop.gremlin.structure.Edge;
+import org.apache.tinkerpop.gremlin.structure.Graph;
+import org.apache.tinkerpop.gremlin.structure.Property;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.apache.tinkerpop.gremlin.structure.VertexProperty;
+import org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONMapper;
+import org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONXModuleV3;
+import org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerFactory;
+import org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerGraph;
+import org.apache.tinkerpop.gremlin.util.iterator.IteratorUtils;
+import org.apache.tinkerpop.shaded.jackson.databind.JsonMappingException;
- import org.apache.tinkerpop.shaded.jackson.databind.ObjectMapper;
+import org.junit.Test;
+
++import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
++import static org.apache.tinkerpop.gremlin.util.MockitoHamcrestMatcherAdapter.reflectionEquals;
++import static org.hamcrest.MatcherAssert.assertThat;
++import static org.hamcrest.Matchers.hasItemInArray;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/**
+ * Serializer tests that cover non-lossy serialization/deserialization methods.
+ *
+ * @author Stephen Mallette (http://stephen.genoprime.com)
+ */
+@SuppressWarnings("unchecked")
+public class GraphSONMessageSerializerV3Test {
+
+ private final UUID requestId = UUID.fromString("6457272A-4018-4538-B9AE-08DD5DDC0AA1");
+ private final ResponseMessage.Builder responseMessageBuilder = ResponseMessage.build(requestId);
+ private final static ByteBufAllocator allocator = UnpooledByteBufAllocator.DEFAULT;
+
- public final MessageSerializer<ObjectMapper> serializer = new GraphSONMessageSerializerV3();
++ public final GraphSONMessageSerializerV3 serializer = new GraphSONMessageSerializerV3();
+
+ @Test
+ public void shouldSerializeIterable() throws Exception {
+ final ArrayList<Integer> list = new ArrayList<>();
+ list.add(1);
+ list.add(100);
+
+ final ResponseMessage response = convert(list);
+ assertCommon(response);
+
+ final List<Integer> deserializedFunList = (List<Integer>) response.getResult().getData();
+ assertEquals(2, deserializedFunList.size());
- assertEquals(new Integer(1), deserializedFunList.get(0));
- assertEquals(new Integer(100), deserializedFunList.get(1));
++ assertEquals(Integer.valueOf(1), deserializedFunList.get(0));
++ assertEquals(Integer.valueOf(100), deserializedFunList.get(1));
+ }
+
+ @Test
+ public void shouldSerializeIterableWithNull() throws Exception {
+ final ArrayList<Integer> list = new ArrayList<>();
+ list.add(1);
+ list.add(null);
+ list.add(100);
+
+ final ResponseMessage response = convert(list);
+ assertCommon(response);
+
+ final List<Integer> deserializedFunList = (List<Integer>) response.getResult().getData();
+ assertEquals(3, deserializedFunList.size());
- assertEquals(new Integer(1), deserializedFunList.get(0));
++ assertEquals(Integer.valueOf(1), deserializedFunList.get(0));
+ assertNull(deserializedFunList.get(1));
- assertEquals(new Integer(100), deserializedFunList.get(2));
++ assertEquals(Integer.valueOf(100), deserializedFunList.get(2));
+ }
+
+ @Test
+ public void shouldSerializeMap() throws Exception {
+ final Map<String, Object> map = new HashMap<>();
+ final Map<String, String> innerMap = new HashMap<>();
+ innerMap.put("a", "b");
+
+ map.put("w", true);
+ map.put("x", 1);
+ map.put("y", "some");
+ map.put("z", innerMap);
+
+ final ResponseMessage response = convert(map);
+ assertCommon(response);
+
+ final Map<String, Object> deserializedMap = (Map<String, Object>) response.getResult().getData();
+ assertEquals(4, deserializedMap.size());
+ assertEquals(true, deserializedMap.get("w"));
+ assertEquals(1, deserializedMap.get("x"));
+ assertEquals("some", deserializedMap.get("y"));
+
+ final Map<String, String> deserializedInnerMap = (Map<String, String>) deserializedMap.get("z");
+ assertEquals(1, deserializedInnerMap.size());
+ assertEquals("b", deserializedInnerMap.get("a"));
+ }
+
+ @Test
+ public void shouldSerializeMapEntries() throws Exception {
+ final Graph graph = TinkerGraph.open();
+ final Vertex v1 = graph.addVertex();
+ final Date d = new Date();
+
+ final Map<Object, Object> map = new HashMap<>();
+ map.put("x", 1);
+ map.put(v1, 100);
+ map.put(d, "test");
+
+ final ResponseMessage response = convert(IteratorUtils.asList(map.entrySet()));
+ assertCommon(response);
+
+ final List<Map<Object, Object>> deserializedEntries = (List<Map<Object, Object>>) response.getResult().getData();
+ assertEquals(3, deserializedEntries.size());
+ deserializedEntries.forEach(m -> {
+ final Map.Entry<Object,Object> e = m.entrySet().iterator().next();
+ if (e.getKey().equals("x"))
+ assertEquals(1, e.getValue());
+ else if (e.getKey() instanceof Vertex && e.getKey().equals(v1))
+ assertEquals(100, e.getValue());
+ else if (e.getKey() instanceof Date)
+ assertEquals("test", e.getValue());
+ else
+ fail("Map entries contains a key that is not part of what was serialized");
+ });
+ }
+
+ @Test
+ public void shouldSerializeEdge() throws Exception {
+ final Graph graph = TinkerGraph.open();
+ final Vertex v1 = graph.addVertex();
+ final Vertex v2 = graph.addVertex();
+ final Edge e = v1.addEdge("test", v2);
+ e.property("abc", 123);
+
+ final Iterable<Edge> iterable = IteratorUtils.list(graph.edges());
+
+ final ResponseMessage response = convert(iterable);
+ assertCommon(response);
+
+ final List<Edge> edgeList = (List<Edge>) response.getResult().getData();
+ assertEquals(1, edgeList.size());
+
+ final Edge deserializedEdge = edgeList.get(0);
+ assertEquals(e.id(), deserializedEdge.id());
+ assertEquals(v1.id(), deserializedEdge.outVertex().id());
+ assertEquals(v2.id(), deserializedEdge.inVertex().id());
+ assertEquals(v1.label(), deserializedEdge.outVertex().label());
+ assertEquals(v2.label(), deserializedEdge.inVertex().label());
+ assertEquals(e.label(), deserializedEdge.label());
+
+ final List<Property> properties = new ArrayList<>();
+ deserializedEdge.properties().forEachRemaining(properties::add);
+ assertEquals(1, properties.size());
+
+ assertNotNull(properties);
+ assertEquals("abc", properties.get(0).key());
+ assertEquals(123, properties.get(0).value());
+
+ }
+
+ @Test
+ public void shouldSerializeEdgeProperty() throws Exception {
+ final Graph graph = TinkerGraph.open();
+ final Vertex v1 = graph.addVertex();
+ final Vertex v2 = graph.addVertex();
+ final Edge e = v1.addEdge("test", v2);
+ e.property("abc", 123);
+
+ final Iterable<Property<Object>> iterable = IteratorUtils.list(e.properties("abc"));
+ final ResponseMessage response = convert(iterable);
+ assertCommon(response);
+
+ final List<Property> propertyList = (List<Property>) response.getResult().getData();
+ assertEquals(1, propertyList.size());
+ assertEquals(123, propertyList.get(0).value());
+ }
+
+ @Test
+ public void shouldSerializeVertexWithEmbeddedMap() throws Exception {
+ final Graph graph = TinkerGraph.open();
+ final Vertex v = graph.addVertex();
+ final Map<String, Object> map = new HashMap<>();
+ map.put("x", 500);
+ map.put("y", "some");
+
+ final ArrayList<Object> friends = new ArrayList<>();
+ friends.add("x");
+ friends.add(5);
+ friends.add(map);
+
+ v.property(VertexProperty.Cardinality.single, "friends", friends);
+
- final List list = IteratorUtils.list(graph.vertices());
++ final List<Vertex> list = IteratorUtils.list(graph.vertices());
+
+ final ResponseMessage response = convert(list);
+ assertCommon(response);
+
+ final List<Vertex> vertexList = (List<Vertex>) response.getResult().getData();
+ assertEquals(1, vertexList.size());
+
+ final Vertex deserializedVertex = vertexList.get(0);
+ assertEquals(v.id(), deserializedVertex.id());
+ assertEquals(Vertex.DEFAULT_LABEL, deserializedVertex.label());
+
+ final List<VertexProperty> properties = new ArrayList<>();
+ deserializedVertex.properties().forEachRemaining(properties::add);
+ assertEquals(1, properties.size());
+
+ final VertexProperty friendsProperty = properties.get(0);
+ final List<Object> deserializedInnerList = (List<Object>) friendsProperty.value();
+
+ assertEquals(3, deserializedInnerList.size());
+ assertEquals("x", deserializedInnerList.get(0));
+ assertEquals(5, deserializedInnerList.get(1));
+
+ final Map<String, Object> deserializedInnerInnerMap = (Map<String, Object>) deserializedInnerList.get(2);
+ assertEquals(2, deserializedInnerInnerMap.size());
+ assertEquals(500, deserializedInnerInnerMap.get("x"));
+ assertEquals("some", deserializedInnerInnerMap.get("y"));
+ }
+
+ @Test
+ public void shouldSerializeToJsonMapWithElementForKey() throws Exception {
+ final TinkerGraph graph = TinkerFactory.createClassic();
+ final GraphTraversalSource g = graph.traversal();
+ final Map<Vertex, Integer> map = new HashMap<>();
+ final Vertex v1 = g.V().has("name", "marko").next();
+ map.put(v1, 1000);
+
+ final ResponseMessage response = convert(map);
+ assertCommon(response);
+
+ final Map<Vertex, Integer> deserializedMap = (Map<Vertex, Integer>) response.getResult().getData();
+ assertEquals(1, deserializedMap.size());
- assertEquals(new Integer(1000), deserializedMap.get(v1));
++ assertEquals(Integer.valueOf(1000), deserializedMap.get(v1));
+ }
+
+ @Test
+ public void shouldSerializeToTreeJson() throws Exception {
+ final TinkerGraph graph = TinkerFactory.createClassic();
+ final GraphTraversalSource g = graph.traversal();
+ final Tree t = g.V(1).out().properties("name").tree().next();
+
+ final ResponseMessage response = convert(t);
+ assertCommon(response);
+
+ final Tree deserializedTree = (Tree)response.getResult().getData();
+
+ //check the first object and its key's properties
+ assertEquals(1, deserializedTree.size());
+ final Vertex v = ((Vertex) deserializedTree.keySet().iterator().next());
+ assertEquals(1, v.id());
+ assertEquals("marko", v.property("name").value());
+
+ final Tree firstTree = (Tree)deserializedTree.get(v);
+ assertEquals(3, firstTree.size());
+ Iterator<Vertex> vertexKeys = firstTree.keySet().iterator();
+
+ Map expectedValues = new HashMap<Integer, String>() {{
+ put(2, "vadas");
+ put(4, "lop");
+ put(6, "josh");
+ }};
+
+ Map actualValues = new HashMap<Integer, String>();
+ for (int i = 0; i < 3; i++) {
+ Tree t2 = (Tree)firstTree.get(vertexKeys.next());
+ VertexProperty vp = (VertexProperty)t2.keySet().iterator().next();
+ actualValues.put(vp.id(), vp.value());
+ }
+
+ assertEquals(expectedValues, actualValues);
+ }
+
+ @Test
+ public void shouldSerializeFullResponseMessage() throws Exception {
+ final UUID id = UUID.randomUUID();
+
+ final Map<String, Object> metaData = new HashMap<>();
+ metaData.put("test", "this");
+ metaData.put("one", 1);
+
+ final Map<String, Object> attributes = new HashMap<>();
+ attributes.put("test", "that");
+ attributes.put("two", 2);
+
+ final ResponseMessage response = ResponseMessage.build(id)
+ .responseMetaData(metaData)
+ .code(ResponseStatusCode.SUCCESS)
+ .result("some-result")
+ .statusAttributes(attributes)
+ .statusMessage("worked")
+ .create();
+
+ final ByteBuf bb = serializer.serializeResponseAsBinary(response, allocator);
+ final ResponseMessage deserialized = serializer.deserializeResponse(bb);
+
+ assertEquals(id, deserialized.getRequestId());
+ assertEquals("this", deserialized.getResult().getMeta().get("test"));
+ assertEquals(1, deserialized.getResult().getMeta().get("one"));
+ assertEquals("some-result", deserialized.getResult().getData());
+ assertEquals("that", deserialized.getStatus().getAttributes().get("test"));
+ assertEquals(2, deserialized.getStatus().getAttributes().get("two"));
+ assertEquals(ResponseStatusCode.SUCCESS.getValue(), deserialized.getStatus().getCode().getValue());
+ assertEquals("worked", deserialized.getStatus().getMessage());
+ }
+
+ @Test
+ public void shouldDeserializeNotPredicate() throws Exception {
+ final String requestMessageWithP = "{\"requestId\":{\"@type\":\"g:UUID\",\"@value\":\"0397b9c0-ffab-470e-a6a8-644fc80c01d6\"},\"op\":\"bytecode\",\"processor\":\"traversal\",\"args\":{\"gremlin\":{\"@type\":\"g:Bytecode\",\"@value\":{\"step\":[[\"V\"],[\"hasLabel\",\"person\"],[\"has\",\"age\",{\"@type\":\"g:P\",\"@value\":{\"predicate\":\"not\",\"value\":{\"@type\":\"g:P\",\"@value\":{\"predicate\":\"lte\",\"value\":{\"@type\":\"g:Int32\",\"@value\":10}}}}}]]}},\"aliases\":{\"g [...]
+ final ByteBuf bb = allocator.buffer(requestMessageWithP.length());
+ bb.writeBytes(requestMessageWithP.getBytes());
+ final RequestMessage m = serializer.deserializeRequest(bb);
+ assertEquals("bytecode", m.getOp());
+ assertNotNull(m.getArgs());
+ }
+
++ @Test
++ public void shouldSerializeAndDeserializeRequest() throws Exception {
++ final GraphTraversalSource g = EmptyGraph.instance().traversal();
++ final Traversal.Admin t = g.V().hasLabel("person").out().asAdmin();
++
++ final Map<String, String> aliases = new HashMap<>();
++ aliases.put("g","g");
++
++ final RequestMessage request = RequestMessage.build(Tokens.OPS_BYTECODE)
++ .processor("traversal")
++ .overrideRequestId(UUID.randomUUID())
++ .addArg(Tokens.ARGS_GREMLIN, t.getBytecode())
++ .addArg(Tokens.ARGS_ALIASES, aliases)
++ .create();
++
++ final ByteBuf buffer = serializer.serializeRequestAsBinary(request, allocator);
++ final int mimeLen = buffer.readByte();
++ final byte[] bytes = new byte[mimeLen];
++ buffer.readBytes(bytes);
++ final String mimeType = new String(bytes, StandardCharsets.UTF_8);
++
++ final RequestMessage deserialized = serializer.deserializeRequest(buffer);
++ assertThat(request, reflectionEquals(deserialized));
++ assertThat(serializer.mimeTypesSupported(), hasItemInArray(mimeType));
++ }
++
+ @Test
+ public void shouldRegisterGremlinServerModuleAutomaticallyWithMapper() throws SerializationException {
+ GraphSONMapper.Builder builder = GraphSONMapper.build().addCustomModule(GraphSONXModuleV3.build());
+ GraphSONMessageSerializerV3 graphSONMessageSerializerV3 = new GraphSONMessageSerializerV3(builder);
+
+ ResponseMessage rm = convert("hello", graphSONMessageSerializerV3);
+ assertEquals(rm.getRequestId(), requestId);
+ assertEquals(rm.getResult().getData(), "hello");
+ }
+
+ @Test
+ public void shouldFailOnMessageSerializerWithMapperIfNoGremlinServerModule() {
+ final GraphSONMapper.Builder builder = GraphSONMapper.build().addCustomModule(GraphSONXModuleV3.build());
+ final GraphSONMessageSerializerV3 graphSONMessageSerializerV3 = new GraphSONMessageSerializerV3(builder.create());
+
+ try {
+ convert("hello", graphSONMessageSerializerV3);
+ fail("Serialization should have failed since no GremlinServerModule registered.");
+ } catch (SerializationException e) {
+ assertTrue(e.getMessage().contains("Could not find a type identifier for the class"));
+ assertTrue(e.getCause() instanceof JsonMappingException);
+ assertTrue(e.getCause().getCause() instanceof IllegalArgumentException);
+ }
+ }
+
+ private void assertCommon(final ResponseMessage response) {
+ assertEquals(requestId, response.getRequestId());
+ assertEquals(ResponseStatusCode.SUCCESS, response.getStatus().getCode());
+ }
+
+ private ResponseMessage convert(final Object toSerialize, MessageSerializer<?> serializer) throws SerializationException {
+ final ByteBuf bb = serializer.serializeResponseAsBinary(responseMessageBuilder.result(toSerialize).create(), allocator);
+ return serializer.deserializeResponse(bb);
+ }
+
+ private ResponseMessage convert(final Object toSerialize) throws SerializationException {
+ return convert(toSerialize, this.serializer);
+ }
+}
diff --cc gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/binary/GraphBinaryMessageSerializerV1Test.java
index 43370cf45e,0000000000..09bc419701
mode 100644,000000..100644
--- a/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/binary/GraphBinaryMessageSerializerV1Test.java
+++ b/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/binary/GraphBinaryMessageSerializerV1Test.java
@@@ -1,262 -1,0 +1,279 @@@
+/*
+ * 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.tinkerpop.gremlin.util.ser.binary;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufAllocator;
++import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
++import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
++import org.apache.tinkerpop.gremlin.util.Tokens;
+import org.apache.tinkerpop.gremlin.util.message.RequestMessage;
+import org.apache.tinkerpop.gremlin.util.message.ResponseMessage;
+import org.apache.tinkerpop.gremlin.util.message.ResponseStatusCode;
+import org.apache.tinkerpop.gremlin.util.ser.GraphBinaryMessageSerializerV1;
+import org.apache.tinkerpop.gremlin.util.ser.SerializationException;
+import org.apache.tinkerpop.gremlin.structure.io.binary.TypeSerializerRegistry;
++import org.apache.tinkerpop.gremlin.structure.util.empty.EmptyGraph;
+import org.junit.Test;
+
++import java.nio.charset.StandardCharsets;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.apache.tinkerpop.gremlin.util.MockitoHamcrestMatcherAdapter.reflectionEquals;
+import static org.junit.Assert.assertEquals;
+import static org.hamcrest.MatcherAssert.assertThat;
++import static org.hamcrest.Matchers.hasItemInArray;
+
+public class GraphBinaryMessageSerializerV1Test {
+ private final ByteBufAllocator allocator = ByteBufAllocator.DEFAULT;
+ private final GraphBinaryMessageSerializerV1 serializer = new GraphBinaryMessageSerializerV1();
+
+ @Test
+ public void shouldSerializeAndDeserializeRequest() throws SerializationException {
- final RequestMessage request = RequestMessage.build("op1")
- .processor("proc1")
++ final GraphTraversalSource g = EmptyGraph.instance().traversal();
++ final Traversal.Admin t = g.V().hasLabel("person").out().asAdmin();
++
++ final Map<String, String> aliases = new HashMap<>();
++ aliases.put("g","g");
++
++ final RequestMessage request = RequestMessage.build(Tokens.OPS_BYTECODE)
++ .processor("traversal")
+ .overrideRequestId(UUID.randomUUID())
- .addArg("arg1", "value1")
++ .addArg(Tokens.ARGS_GREMLIN, t.getBytecode())
++ .addArg(Tokens.ARGS_ALIASES, aliases)
+ .create();
+
+ final ByteBuf buffer = serializer.serializeRequestAsBinary(request, allocator);
+ final int mimeLen = buffer.readByte();
- buffer.readBytes(new byte[mimeLen]);
++ final byte[] bytes = new byte[mimeLen];
++ buffer.readBytes(bytes);
++ final String mimeType = new String(bytes, StandardCharsets.UTF_8);
++
+ final RequestMessage deserialized = serializer.deserializeRequest(buffer);
+ assertThat(request, reflectionEquals(deserialized));
++ assertThat(serializer.mimeTypesSupported(), hasItemInArray(mimeType));
+ }
+
+ @Test
+ public void shouldSerializeAndDeserializeRequestOverText() throws SerializationException {
+ final RequestMessage request = RequestMessage.build("op1")
+ .processor("proc1")
+ .overrideRequestId(UUID.randomUUID())
+ .addArg("arg1", "value1")
+ .create();
+
+ final String base64 = serializer.serializeRequestAsString(request, allocator);
+ final RequestMessage deserialized = serializer.deserializeRequest(base64);
+ assertThat(request, reflectionEquals(deserialized));
+ }
+
+ @Test
+ public void shouldSerializeAndDeserializeRequestWithoutArgs() throws SerializationException {
+ final RequestMessage request = RequestMessage.build("op1")
+ .processor("proc1")
+ .overrideRequestId(UUID.randomUUID())
+ .create();
+
+ final ByteBuf buffer = serializer.serializeRequestAsBinary(request, allocator);
+ final int mimeLen = buffer.readByte();
+ buffer.readBytes(new byte[mimeLen]);
+ final RequestMessage deserialized = serializer.deserializeRequest(buffer);
+ assertThat(request, reflectionEquals(deserialized));
+ }
+
+ @Test
+ public void shouldSerializeAndDeserializeRequestWithUnsetProcessor() throws SerializationException {
+ final RequestMessage request = RequestMessage.build("op1")
+ .overrideRequestId(UUID.randomUUID())
+ .addArg("k", 1)
+ .create();
+
+ final ByteBuf buffer = serializer.serializeRequestAsBinary(request, allocator);
+ final int mimeLen = buffer.readByte();
+ buffer.readBytes(new byte[mimeLen]);
+ final RequestMessage deserialized = serializer.deserializeRequest(buffer);
+ assertThat(request, reflectionEquals(deserialized));
+ }
+
+ @Test
+ public void shouldSerializeAndDeserializeResponse() throws SerializationException {
+ final ResponseMessage response = ResponseMessage.build(UUID.randomUUID())
+ .code(ResponseStatusCode.SUCCESS)
+ .statusMessage("Found")
+ .statusAttribute("k1", 1)
+ .result("This is a fine message with a string")
+ .create();
+
+ final ByteBuf buffer = serializer.serializeResponseAsBinary(response, allocator);
+ final ResponseMessage deserialized = serializer.deserializeResponse(buffer);
+ assertResponseEquals(response, deserialized);
+ }
+
+ @Test
+ public void shouldSerializeAndDeserializeResponseOverText() throws SerializationException {
+ final ResponseMessage response = ResponseMessage.build(UUID.randomUUID())
+ .code(ResponseStatusCode.SUCCESS)
+ .statusMessage("Found")
+ .statusAttribute("k1", 1)
+ .result("This is a fine message with a string")
+ .create();
+
+ final String base64 = serializer.serializeResponseAsString(response, allocator);
+ final ResponseMessage deserialized = serializer.deserializeResponse(base64);
+ assertResponseEquals(response, deserialized);
+ }
+
+ @Test
+ public void shouldSerializeAndDeserializeResponseWithoutStatusMessage() throws SerializationException {
+ final ResponseMessage response = ResponseMessage.build(UUID.randomUUID())
+ .code(ResponseStatusCode.SUCCESS)
+ .statusAttribute("k1", 1)
+ .result(123.3)
+ .create();
+
+ final ByteBuf buffer = serializer.serializeResponseAsBinary(response, allocator);
+ final ResponseMessage deserialized = serializer.deserializeResponse(buffer);
+ assertResponseEquals(response, deserialized);
+ }
+
+ @Test
+ public void shouldSerializeAndDeserializeResponseWithoutStatusAttributes() throws SerializationException {
+ final ResponseMessage response = ResponseMessage.build(UUID.randomUUID())
+ .code(ResponseStatusCode.SUCCESS)
+ .result(123.3)
+ .create();
+
+ final ByteBuf buffer = serializer.serializeResponseAsBinary(response, allocator);
+ final ResponseMessage deserialized = serializer.deserializeResponse(buffer);
+ assertResponseEquals(response, deserialized);
+ }
+
+ @Test
+ public void shouldSerializeAndDeserializeResponseWithoutResult() throws SerializationException {
+ final ResponseMessage response = ResponseMessage.build(UUID.randomUUID())
+ .code(ResponseStatusCode.SERVER_ERROR)
+ .statusMessage("Something happened on the server")
+ .create();
+
+ final ByteBuf buffer = serializer.serializeResponseAsBinary(response, allocator);
+ final ResponseMessage deserialized = serializer.deserializeResponse(buffer);
+ assertResponseEquals(response, deserialized);
+ }
+
+ @Test
+ public void shouldSupportConfigurationOfRegistryBuilder() {
+ final GraphBinaryMessageSerializerV1 serializer = new GraphBinaryMessageSerializerV1();
+ final Map<String, Object> config = new HashMap<>();
+ int counter = SampleTypeSerializerRegistryBuilder.createCounter.get();
+
+ config.put(GraphBinaryMessageSerializerV1.TOKEN_BUILDER, "org.apache.tinkerpop.gremlin.util.ser.binary.GraphBinaryMessageSerializerV1Test$SampleTypeSerializerRegistryBuilder");
+ serializer.configure(config, null);
+
+ counter = SampleTypeSerializerRegistryBuilder.createCounter.get() - counter;
+ // There should be a call to `create()`
+ assertEquals(1, counter);
+ }
+
+ @Test(expected = IllegalStateException.class)
+ public void shouldThrowWhenConfigurationOfRegistryBuilderFails() {
+ final GraphBinaryMessageSerializerV1 serializer = new GraphBinaryMessageSerializerV1();
+ final Map<String, Object> config = new HashMap<>();
+ config.put(GraphBinaryMessageSerializerV1.TOKEN_BUILDER, "org.apache.tinkerpop.gremlin.util.ser.binary.NonExistentClass");
+
+ serializer.configure(config, null);
+ }
+
+ @Test
+ public void shouldToStringSerialize() throws SerializationException {
+ final GraphBinaryMessageSerializerV1 serializer = new GraphBinaryMessageSerializerV1();
+ final Map<String,Object> conf = new HashMap<String,Object>() {{
+ put(GraphBinaryMessageSerializerV1.TOKEN_SERIALIZE_RESULT_TO_STRING, true);
+ }};
+ serializer.configure(conf, Collections.emptyMap());
+
+ final ResponseMessage messageWithUnexpectedType = ResponseMessage.build(UUID.randomUUID()).
+ result(java.awt.Color.RED).create();
+ final ByteBuf buffer = serializer.serializeResponseAsBinary(messageWithUnexpectedType, allocator);
+ final ResponseMessage deserialized = serializer.deserializeResponse(buffer);
+
+ assertEquals(java.awt.Color.RED.toString(), deserialized.getResult().getData());
+ }
+
+ @Test
+ public void shouldToStringSerializeAsText() throws SerializationException {
+ final GraphBinaryMessageSerializerV1 serializer = new GraphBinaryMessageSerializerV1();
+ final Map<String,Object> conf = new HashMap<String,Object>() {{
+ put(GraphBinaryMessageSerializerV1.TOKEN_SERIALIZE_RESULT_TO_STRING, true);
+ }};
+ serializer.configure(conf, Collections.emptyMap());
+
+ final ResponseMessage messageWithUnexpectedType = ResponseMessage.build(UUID.randomUUID()).
+ result(java.awt.Color.RED).create();
+ final String base64 = serializer.serializeResponseAsString(messageWithUnexpectedType, allocator);
+ final ResponseMessage deserialized = serializer.deserializeResponse(base64);
+
+ assertEquals(java.awt.Color.RED.toString(), deserialized.getResult().getData());
+ }
+
+ @Test
+ public void shouldSerializeAndDeserializeRequestAsText() throws SerializationException {
+ final GraphBinaryMessageSerializerV1 serializer = new GraphBinaryMessageSerializerV1();
+ final Map<String,Object> conf = new HashMap<String,Object>() {{
+ put(GraphBinaryMessageSerializerV1.TOKEN_SERIALIZE_RESULT_TO_STRING, true);
+ }};
+ serializer.configure(conf, Collections.emptyMap());
+
+ final RequestMessage request = RequestMessage.build("op1")
+ .processor("proc1")
+ .overrideRequestId(UUID.randomUUID())
+ .addArg("arg1", "value1")
+ .create();
+
+ final ByteBuf buffer = serializer.serializeRequestAsBinary(request, allocator);
+ final int mimeLen = buffer.readByte();
+ buffer.readBytes(new byte[mimeLen]);
+ final RequestMessage deserialized = serializer.deserializeRequest(buffer);
+ assertThat(request, reflectionEquals(deserialized));
+ }
+
+ private static void assertResponseEquals(ResponseMessage expected, ResponseMessage actual) {
+ assertEquals(expected.getRequestId(), actual.getRequestId());
+ // Status
+ assertEquals(expected.getStatus().getCode(), actual.getStatus().getCode());
+ assertEquals(expected.getStatus().getMessage(), actual.getStatus().getMessage());
+ assertEquals(expected.getStatus().getAttributes(), actual.getStatus().getAttributes());
+ // Result
+ assertEquals(expected.getResult().getData(), actual.getResult().getData());
+ assertEquals(expected.getResult().getMeta(), actual.getResult().getMeta());
+ }
+
+ public static class SampleTypeSerializerRegistryBuilder extends TypeSerializerRegistry.Builder {
+ public static AtomicInteger createCounter = new AtomicInteger();
+
+ @Override
+ public TypeSerializerRegistry create() {
+ createCounter.incrementAndGet();
+ return super.create();
+ }
+ }
+}