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();
 +        }
 +    }
 +}