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:17 UTC
(tinkerpop) branch 3.7-dev updated (ed4dac94af -> 0abb82d87f)
This is an automated email from the ASF dual-hosted git repository.
valentyn pushed a change to branch 3.7-dev
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git
from ed4dac94af [TINKERPOP-3016] Fix for reading value from different read operation (#2343)
add 8365421f25 Bytecode support for HTTP requests (#2336)
new 0abb82d87f merge bytecode over HTTP PR
The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
.../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(-)
create mode 100644 gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/server/handler/HttpHandlerUtilTest.java
(tinkerpop) 01/01: merge bytecode over HTTP PR
Posted by va...@apache.org.
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();
+ }
+ }
+}