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 2024/04/22 17:12:14 UTC

(tinkerpop) branch valentyn/ResponseStatusCode-removal created (now 2b0352640b)

This is an automated email from the ASF dual-hosted git repository.

valentyn pushed a change to branch valentyn/ResponseStatusCode-removal
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git


      at 2b0352640b ResponseStatusCode removal

This branch includes the following new commits:

     new 2b0352640b ResponseStatusCode removal

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.



(tinkerpop) 01/01: ResponseStatusCode removal

Posted by va...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

valentyn pushed a commit to branch valentyn/ResponseStatusCode-removal
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git

commit 2b0352640ba21037d15a384bf85cbcfac10df5e3
Author: Valentyn Kahamlyk <Va...@improving.com>
AuthorDate: Mon Apr 22 10:12:03 2024 -0700

    ResponseStatusCode removal
---
 .../console/jsr223/DriverGremlinPlugin.java        |  24 ++--
 .../console/jsr223/DriverRemoteAcceptor.java       |   9 +-
 .../driver/exception/ResponseException.java        |  12 +-
 .../driver/handler/GremlinResponseHandler.java     |  10 +-
 .../driver/handler/HttpGremlinRequestEncoder.java  |   8 +-
 .../gremlin/driver/simple/AbstractClient.java      |   8 +-
 .../gremlin/server/auth/Authenticator.java         |   8 +-
 .../server/handler/HttpGremlinEndpointHandler.java |  12 +-
 .../gremlin/server/handler/HttpHandlerUtil.java    |   5 +-
 .../server/handler/SaslAuthenticationHandler.java  |  35 +++--
 .../gremlin/server/util/GremlinError.java          |  50 +++----
 .../gremlin/server/GremlinDriverIntegrateTest.java |  47 ++++---
 .../server/GremlinServerAuthKrb5IntegrateTest.java |  12 +-
 .../server/GremlinServerAuthzIntegrateTest.java    |  17 ++-
 .../server/GremlinServerHttpIntegrateTest.java     |  45 +++----
 .../gremlin/server/GremlinServerIntegrateTest.java |  68 +++++-----
 .../server/GremlinServerSslIntegrateTest.java      |  11 +-
 .../gremlin/server/HttpDriverIntegrateTest.java    |  14 +-
 .../gremlin/driver/SerializationBenchmark.java     |  10 +-
 .../socket/server/TestWSGremlinInitializer.java    |  32 ++---
 .../gremlin/util/message/ResponseMessage.java      |   5 +-
 .../gremlin/util/message/ResponseStatus.java       |  12 +-
 .../gremlin/util/message/ResponseStatusCode.java   | 150 ---------------------
 .../ser/AbstractGraphSONMessageSerializerV1.java   |  14 +-
 .../ser/AbstractGraphSONMessageSerializerV2.java   |   6 +-
 .../ser/AbstractGraphSONMessageSerializerV4.java   |   9 +-
 .../util/ser/GraphBinaryMessageSerializerV4.java   |  13 +-
 .../util/ser/GraphSONMessageSerializerV1.java      |   8 +-
 .../util/ser/GraphSONMessageSerializerV4.java      |  25 ----
 .../ser/GraphSONUntypedMessageSerializerV1.java    |   4 +-
 .../util/ser/ResponseMessageGryoSerializer.java    |   8 +-
 .../util/ser/binary/ResponseMessageSerializer.java |   6 +-
 .../io/AbstractTypedCompatibilityTest.java         |   4 +-
 .../io/AbstractUntypedCompatibilityTest.java       |   8 +-
 .../tinkerpop/gremlin/structure/io/Model.java      |   5 +-
 .../util/message/ResponseStatusCodeTest.java       |  36 -----
 .../util/ser/GraphSONMessageSerializerV1Test.java  |  12 +-
 .../util/ser/GraphSONMessageSerializerV2Test.java  |  19 ++-
 .../util/ser/GraphSONMessageSerializerV3Test.java  |  18 +--
 .../util/ser/GraphSONMessageSerializerV4Test.java  |  18 +--
 .../GraphSONUntypedMessageSerializerV1Test.java    |  12 +-
 .../GraphSONUntypedMessageSerializerV2Test.java    |  22 +--
 .../GraphSONUntypedMessageSerializerV3Test.java    |   8 +-
 .../GraphSONUntypedMessageSerializerV4Test.java    |  20 ++-
 .../binary/GraphBinaryMessageSerializerV1Test.java |  12 +-
 .../binary/GraphBinaryMessageSerializerV4Test.java |  12 +-
 46 files changed, 336 insertions(+), 567 deletions(-)

diff --git a/gremlin-console/src/main/java/org/apache/tinkerpop/gremlin/console/jsr223/DriverGremlinPlugin.java b/gremlin-console/src/main/java/org/apache/tinkerpop/gremlin/console/jsr223/DriverGremlinPlugin.java
index 476dc7d4f6..f31f9a8318 100644
--- a/gremlin-console/src/main/java/org/apache/tinkerpop/gremlin/console/jsr223/DriverGremlinPlugin.java
+++ b/gremlin-console/src/main/java/org/apache/tinkerpop/gremlin/console/jsr223/DriverGremlinPlugin.java
@@ -18,23 +18,29 @@
  */
 package org.apache.tinkerpop.gremlin.console.jsr223;
 
+import io.netty.handler.codec.http.HttpResponseStatus;
 import org.apache.tinkerpop.gremlin.driver.Client;
 import org.apache.tinkerpop.gremlin.driver.Cluster;
 import org.apache.tinkerpop.gremlin.driver.Host;
 import org.apache.tinkerpop.gremlin.driver.LoadBalancingStrategy;
-import org.apache.tinkerpop.gremlin.util.MessageSerializer;
 import org.apache.tinkerpop.gremlin.driver.Result;
 import org.apache.tinkerpop.gremlin.driver.ResultSet;
-import org.apache.tinkerpop.gremlin.util.Tokens;
 import org.apache.tinkerpop.gremlin.driver.exception.ConnectionException;
 import org.apache.tinkerpop.gremlin.driver.exception.ResponseException;
+import org.apache.tinkerpop.gremlin.driver.remote.DriverRemoteConnection;
+import org.apache.tinkerpop.gremlin.driver.remote.DriverRemoteTraversal;
+import org.apache.tinkerpop.gremlin.jsr223.AbstractGremlinPlugin;
+import org.apache.tinkerpop.gremlin.jsr223.DefaultImportCustomizer;
+import org.apache.tinkerpop.gremlin.jsr223.ImportCustomizer;
+import org.apache.tinkerpop.gremlin.jsr223.console.ConsoleCustomizer;
+import org.apache.tinkerpop.gremlin.jsr223.console.GremlinShellEnvironment;
+import org.apache.tinkerpop.gremlin.jsr223.console.RemoteAcceptor;
+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.ResponseResult;
 import org.apache.tinkerpop.gremlin.util.message.ResponseStatus;
-import org.apache.tinkerpop.gremlin.util.message.ResponseStatusCode;
-import org.apache.tinkerpop.gremlin.driver.remote.DriverRemoteConnection;
-import org.apache.tinkerpop.gremlin.driver.remote.DriverRemoteTraversal;
 import org.apache.tinkerpop.gremlin.util.ser.GraphBinaryMessageSerializerV1;
 import org.apache.tinkerpop.gremlin.util.ser.GraphSONMessageSerializerV1;
 import org.apache.tinkerpop.gremlin.util.ser.GraphSONMessageSerializerV2;
@@ -44,12 +50,6 @@ import org.apache.tinkerpop.gremlin.util.ser.MessageTextSerializer;
 import org.apache.tinkerpop.gremlin.util.ser.SerTokens;
 import org.apache.tinkerpop.gremlin.util.ser.SerializationException;
 import org.apache.tinkerpop.gremlin.util.ser.Serializers;
-import org.apache.tinkerpop.gremlin.jsr223.AbstractGremlinPlugin;
-import org.apache.tinkerpop.gremlin.jsr223.DefaultImportCustomizer;
-import org.apache.tinkerpop.gremlin.jsr223.ImportCustomizer;
-import org.apache.tinkerpop.gremlin.jsr223.console.ConsoleCustomizer;
-import org.apache.tinkerpop.gremlin.jsr223.console.GremlinShellEnvironment;
-import org.apache.tinkerpop.gremlin.jsr223.console.RemoteAcceptor;
 
 /**
  * @author Stephen Mallette (http://stephen.genoprime.com)
@@ -61,6 +61,7 @@ public class DriverGremlinPlugin extends AbstractGremlinPlugin {
     private static final ImportCustomizer imports = DefaultImportCustomizer.build()
             .addClassImports(Cluster.class,
                     Client.class,
+                    HttpResponseStatus.class,
                     Host.class,
                     LoadBalancingStrategy.class,
                     MessageSerializer.class,
@@ -73,7 +74,6 @@ public class DriverGremlinPlugin extends AbstractGremlinPlugin {
                     ResponseMessage.class,
                     ResponseResult.class,
                     ResponseStatus.class,
-                    ResponseStatusCode.class,
                     GraphSONMessageSerializerV1.class,
                     GraphSONUntypedMessageSerializerV1.class,
                     GraphSONMessageSerializerV2.class,
diff --git a/gremlin-console/src/main/java/org/apache/tinkerpop/gremlin/console/jsr223/DriverRemoteAcceptor.java b/gremlin-console/src/main/java/org/apache/tinkerpop/gremlin/console/jsr223/DriverRemoteAcceptor.java
index 56291f6662..54d6508fc5 100644
--- a/gremlin-console/src/main/java/org/apache/tinkerpop/gremlin/console/jsr223/DriverRemoteAcceptor.java
+++ b/gremlin-console/src/main/java/org/apache/tinkerpop/gremlin/console/jsr223/DriverRemoteAcceptor.java
@@ -18,21 +18,21 @@
  */
 package org.apache.tinkerpop.gremlin.console.jsr223;
 
+import io.netty.handler.codec.http.HttpResponseStatus;
 import org.apache.commons.lang3.exception.ExceptionUtils;
 import org.apache.tinkerpop.gremlin.driver.Client;
 import org.apache.tinkerpop.gremlin.driver.Cluster;
 import org.apache.tinkerpop.gremlin.driver.RequestOptions;
 import org.apache.tinkerpop.gremlin.driver.Result;
 import org.apache.tinkerpop.gremlin.driver.ResultSet;
-import org.apache.tinkerpop.gremlin.util.Tokens;
 import org.apache.tinkerpop.gremlin.driver.exception.NoHostAvailableException;
 import org.apache.tinkerpop.gremlin.driver.exception.ResponseException;
-import org.apache.tinkerpop.gremlin.util.message.ResponseStatusCode;
 import org.apache.tinkerpop.gremlin.jsr223.console.GremlinShellEnvironment;
 import org.apache.tinkerpop.gremlin.jsr223.console.RemoteAcceptor;
 import org.apache.tinkerpop.gremlin.jsr223.console.RemoteException;
 import org.apache.tinkerpop.gremlin.structure.util.ElementHelper;
 import org.apache.tinkerpop.gremlin.util.Gremlin;
+import org.apache.tinkerpop.gremlin.util.Tokens;
 
 import javax.security.sasl.SaslException;
 import java.io.File;
@@ -43,7 +43,6 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
-import java.util.UUID;
 import java.util.concurrent.TimeoutException;
 import java.util.stream.Stream;
 
@@ -172,9 +171,9 @@ public class DriverRemoteAcceptor implements RemoteAcceptor {
             if (inner.isPresent()) {
                 final ResponseException responseException = inner.get();
                 // todo: use exception type to handle error properly
-                if (responseException.getResponseStatusCode() == ResponseStatusCode.SERVER_ERROR) {
+                if (responseException.getResponseStatusCode() == HttpResponseStatus.INTERNAL_SERVER_ERROR) {
                     throw new RemoteException(String.format("%s - try increasing the timeout with the :remote command", responseException.getMessage()));
-                } else if (responseException.getResponseStatusCode() == ResponseStatusCode.SERVER_ERROR)
+                } else if (responseException.getResponseStatusCode() == HttpResponseStatus.INTERNAL_SERVER_ERROR)
                     throw new RemoteException(String.format(
                             "Server could not serialize the result requested. Server error - %s. Note that the class must be serializable by the client and server for proper operation.", responseException.getMessage()),
                             responseException.getRemoteStackTrace().orElse(null));
diff --git a/gremlin-driver/src/main/java/org/apache/tinkerpop/gremlin/driver/exception/ResponseException.java b/gremlin-driver/src/main/java/org/apache/tinkerpop/gremlin/driver/exception/ResponseException.java
index fc4b5d5b4e..13aaeed725 100644
--- a/gremlin-driver/src/main/java/org/apache/tinkerpop/gremlin/driver/exception/ResponseException.java
+++ b/gremlin-driver/src/main/java/org/apache/tinkerpop/gremlin/driver/exception/ResponseException.java
@@ -18,7 +18,7 @@
  */
 package org.apache.tinkerpop.gremlin.driver.exception;
 
-import org.apache.tinkerpop.gremlin.util.message.ResponseStatusCode;
+import io.netty.handler.codec.http.HttpResponseStatus;
 
 import java.util.Collections;
 import java.util.List;
@@ -29,21 +29,21 @@ import java.util.Optional;
  * @author Stephen Mallette (http://stephen.genoprime.com)
  */
 public class ResponseException extends Exception {
-    private final ResponseStatusCode responseStatusCode;
+    private final HttpResponseStatus responseStatusCode;
     private final String remoteStackTrace;
     private final List<String> remoteExceptionHierarchy;
     private final Map<String,Object> attributes;
 
-    public ResponseException(final ResponseStatusCode responseStatusCode, final String serverMessage) {
+    public ResponseException(final HttpResponseStatus responseStatusCode, final String serverMessage) {
         this(responseStatusCode, serverMessage, null, null);
     }
 
-    public ResponseException(final ResponseStatusCode responseStatusCode, final String serverMessage,
+    public ResponseException(final HttpResponseStatus responseStatusCode, final String serverMessage,
                              final List<String> remoteExceptionHierarchy, final String remoteStackTrace) {
         this(responseStatusCode, serverMessage, remoteExceptionHierarchy, remoteStackTrace, null);
     }
 
-    public ResponseException(final ResponseStatusCode responseStatusCode, final String serverMessage,
+    public ResponseException(final HttpResponseStatus responseStatusCode, final String serverMessage,
                              final List<String> remoteExceptionHierarchy, final String remoteStackTrace,
                              final Map<String,Object> statusAttributes) {
         super(serverMessage);
@@ -53,7 +53,7 @@ public class ResponseException extends Exception {
         this.attributes = statusAttributes != null ? Collections.unmodifiableMap(statusAttributes) : null;
     }
 
-    public ResponseStatusCode getResponseStatusCode() {
+    public HttpResponseStatus getResponseStatusCode() {
         return responseStatusCode;
     }
 
diff --git a/gremlin-driver/src/main/java/org/apache/tinkerpop/gremlin/driver/handler/GremlinResponseHandler.java b/gremlin-driver/src/main/java/org/apache/tinkerpop/gremlin/driver/handler/GremlinResponseHandler.java
index 2d00dddf37..74a29cfa67 100644
--- a/gremlin-driver/src/main/java/org/apache/tinkerpop/gremlin/driver/handler/GremlinResponseHandler.java
+++ b/gremlin-driver/src/main/java/org/apache/tinkerpop/gremlin/driver/handler/GremlinResponseHandler.java
@@ -20,6 +20,7 @@ package org.apache.tinkerpop.gremlin.driver.handler;
 
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.SimpleChannelInboundHandler;
+import io.netty.handler.codec.http.HttpResponseStatus;
 import io.netty.util.AttributeMap;
 import org.apache.commons.lang3.exception.ExceptionUtils;
 import org.apache.tinkerpop.gremlin.driver.Result;
@@ -28,7 +29,6 @@ import org.apache.tinkerpop.gremlin.driver.exception.ResponseException;
 import org.apache.tinkerpop.gremlin.util.Tokens;
 import org.apache.tinkerpop.gremlin.util.iterator.IteratorUtils;
 import org.apache.tinkerpop.gremlin.util.message.ResponseMessage;
-import org.apache.tinkerpop.gremlin.util.message.ResponseStatusCode;
 import org.apache.tinkerpop.gremlin.util.ser.SerializationException;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -68,14 +68,14 @@ public class GremlinResponseHandler extends SimpleChannelInboundHandler<Response
     protected void channelRead0(final ChannelHandlerContext channelHandlerContext, final ResponseMessage response) throws Exception {
         final UUID requestId = ((AttributeMap) channelHandlerContext).attr(REQUEST_ID).get();
 
-        final ResponseStatusCode statusCode = response.getStatus() == null ? ResponseStatusCode.PARTIAL_CONTENT : response.getStatus().getCode();
+        final HttpResponseStatus statusCode = response.getStatus() == null ? HttpResponseStatus.PARTIAL_CONTENT : response.getStatus().getCode();
         final ResultQueue queue = pending.get(requestId);
         System.out.println("GremlinResponseHandler get requestId: " + requestId);
         if (response.getResult().getData() != null) {
             System.out.println("GremlinResponseHandler payload size: " + ((List) response.getResult().getData()).size());
         }
 
-        if (statusCode == ResponseStatusCode.SUCCESS || statusCode == ResponseStatusCode.PARTIAL_CONTENT) {
+        if (statusCode == HttpResponseStatus.OK || statusCode == HttpResponseStatus.PARTIAL_CONTENT) {
             final Object data = response.getResult().getData();
 
             // this is a "result" from the server which is either the result of a script or a
@@ -90,7 +90,7 @@ public class GremlinResponseHandler extends SimpleChannelInboundHandler<Response
             }
         } else {
             // this is a "success" but represents no results otherwise it is an error
-            if (statusCode != ResponseStatusCode.NO_CONTENT) {
+            if (statusCode != HttpResponseStatus.NO_CONTENT) {
                 final Map<String, Object> attributes = response.getStatus().getAttributes();
                 final String stackTrace = attributes.containsKey(Tokens.STATUS_ATTRIBUTE_STACK_TRACE) ?
                         (String) attributes.get(Tokens.STATUS_ATTRIBUTE_STACK_TRACE) : null;
@@ -103,7 +103,7 @@ public class GremlinResponseHandler extends SimpleChannelInboundHandler<Response
 
         // todo:
         // as this is a non-PARTIAL_CONTENT code - the stream is done.
-        if (statusCode != ResponseStatusCode.PARTIAL_CONTENT) {
+        if (statusCode != HttpResponseStatus.PARTIAL_CONTENT) {
             pending.remove(requestId).markComplete(response.getStatus().getAttributes());
         }
 
diff --git 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
index 0acfa8a10e..5e0467a368 100644
--- 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
@@ -26,6 +26,7 @@ import io.netty.handler.codec.http.DefaultFullHttpRequest;
 import io.netty.handler.codec.http.FullHttpRequest;
 import io.netty.handler.codec.http.HttpHeaderNames;
 import io.netty.handler.codec.http.HttpMethod;
+import io.netty.handler.codec.http.HttpResponseStatus;
 import io.netty.handler.codec.http.HttpVersion;
 import io.netty.util.Attribute;
 import io.netty.util.AttributeKey;
@@ -35,7 +36,6 @@ import org.apache.tinkerpop.gremlin.driver.exception.ResponseException;
 import org.apache.tinkerpop.gremlin.process.traversal.Bytecode;
 import org.apache.tinkerpop.gremlin.util.MessageSerializer;
 import org.apache.tinkerpop.gremlin.util.message.RequestMessageV4;
-import org.apache.tinkerpop.gremlin.util.message.ResponseStatusCode;
 import org.apache.tinkerpop.gremlin.util.ser.MessageTextSerializerV4;
 import org.apache.tinkerpop.gremlin.util.ser.SerTokens;
 
@@ -79,7 +79,8 @@ public final class HttpGremlinRequestEncoder extends MessageToMessageEncoder<Req
         if (requestMessage.getField("gremlin") instanceof Bytecode &&
                 !mimeType.equals(SerTokens.MIME_GRAPHSON_V3) &&
                 !mimeType.equals(SerTokens.MIME_GRAPHBINARY_V1)) {
-            throw new ResponseException(ResponseStatusCode.REQUEST_ERROR_SERIALIZATION, String.format(
+            // todo: correct status code !!!
+            throw new ResponseException(HttpResponseStatus.INTERNAL_SERVER_ERROR, 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()));
         }
@@ -97,7 +98,8 @@ public final class HttpGremlinRequestEncoder extends MessageToMessageEncoder<Req
 
             System.out.println("----------------------------");
         } catch (Exception ex) {
-            throw new ResponseException(ResponseStatusCode.REQUEST_ERROR_SERIALIZATION, String.format(
+            // todo: correct status code !!!
+            throw new ResponseException(HttpResponseStatus.INTERNAL_SERVER_ERROR, String.format(
                     "An error occurred during serialization of this request [%s] - it could not be sent to the server - Reason: %s",
                     requestMessage, ex));
         }
diff --git a/gremlin-driver/src/main/java/org/apache/tinkerpop/gremlin/driver/simple/AbstractClient.java b/gremlin-driver/src/main/java/org/apache/tinkerpop/gremlin/driver/simple/AbstractClient.java
index b79abed7b1..a6c935584d 100644
--- a/gremlin-driver/src/main/java/org/apache/tinkerpop/gremlin/driver/simple/AbstractClient.java
+++ b/gremlin-driver/src/main/java/org/apache/tinkerpop/gremlin/driver/simple/AbstractClient.java
@@ -22,6 +22,7 @@ import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.EventLoopGroup;
 import io.netty.channel.SimpleChannelInboundHandler;
 import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.handler.codec.http.HttpResponseStatus;
 import org.apache.commons.lang3.concurrent.BasicThreadFactory;
 import org.apache.tinkerpop.gremlin.util.message.RequestMessageV4;
 import org.apache.tinkerpop.gremlin.util.message.ResponseMessage;
@@ -32,8 +33,6 @@ import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.TimeUnit;
 import java.util.function.Consumer;
 
-import static org.apache.tinkerpop.gremlin.util.message.ResponseStatusCode.NO_CONTENT;
-
 /**
  * @author Stephen Mallette (http://stephen.genoprime.com)
  */
@@ -68,13 +67,14 @@ public abstract class AbstractClient implements SimpleClient {
         final CompletableFuture<List<ResponseMessage>> f = new CompletableFuture<>();
         callbackResponseHandler.callback = response -> {
             // message with trailers
-            if (f.isDone() && response.getStatus().getCode() != NO_CONTENT)
+            if (f.isDone() && response.getStatus().getCode() != HttpResponseStatus.NO_CONTENT)
                 throw new RuntimeException("A terminating message was already encountered - no more messages should have been received");
 
             results.add(response);
 
             // check if the current message is terminating - if it is then we can mark complete
-            if (response.getStatus() != null && response.getStatus().getCode().isFinalResponse()) {
+            if (response.getStatus() != null && response.getStatus().getCode() != HttpResponseStatus.PARTIAL_CONTENT
+                    && response.getStatus().getCode() != HttpResponseStatus.PROXY_AUTHENTICATION_REQUIRED) {
                 f.complete(results);
             }
         };
diff --git a/gremlin-server/src/main/java/org/apache/tinkerpop/gremlin/server/auth/Authenticator.java b/gremlin-server/src/main/java/org/apache/tinkerpop/gremlin/server/auth/Authenticator.java
index d3a291c3cf..961406386b 100644
--- a/gremlin-server/src/main/java/org/apache/tinkerpop/gremlin/server/auth/Authenticator.java
+++ b/gremlin-server/src/main/java/org/apache/tinkerpop/gremlin/server/auth/Authenticator.java
@@ -18,10 +18,10 @@
  */
 package org.apache.tinkerpop.gremlin.server.auth;
 
+import io.netty.handler.codec.http.HttpResponseStatus;
+import org.apache.tinkerpop.gremlin.server.Channelizer;
 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.server.Channelizer;
 
 import java.net.InetAddress;
 import java.util.Map;
@@ -77,8 +77,8 @@ public interface Authenticator {
          * finished. If so, an {@link AuthenticatedUser} is obtained by calling {@link #getAuthenticatedUser()} and
          * that user associated with the active connection. If the negotiation is not yet complete,
          * the byte[] is returned to the client as a further challenge in an
-         * {@link ResponseMessage} with {@link ResponseStatusCode#AUTHENTICATE}. This continues until the negotiation
-         * does complete or an error is encountered.
+         * {@link ResponseMessage} with {@link HttpResponseStatus#PROXY_AUTHENTICATION_REQUIRED}. This continues until
+         * the negotiation does complete or an error is encountered.
          */
         public byte[] evaluateResponse(final byte[] clientResponse) throws AuthenticationException;
 
diff --git 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
index 4d7fd29b39..17935cff4a 100644
--- 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
@@ -28,6 +28,7 @@ import io.netty.handler.codec.http.DefaultHttpContent;
 import io.netty.handler.codec.http.DefaultHttpResponse;
 import io.netty.handler.codec.http.HttpHeaderNames;
 import io.netty.handler.codec.http.HttpResponse;
+import io.netty.handler.codec.http.HttpResponseStatus;
 import org.apache.commons.lang3.exception.ExceptionUtils;
 import org.apache.tinkerpop.gremlin.groovy.engine.GremlinExecutor;
 import org.apache.tinkerpop.gremlin.groovy.jsr223.TimedInterruptTimeoutException;
@@ -46,9 +47,9 @@ import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalInterruptedE
 import org.apache.tinkerpop.gremlin.server.Context;
 import org.apache.tinkerpop.gremlin.server.GraphManager;
 import org.apache.tinkerpop.gremlin.server.GremlinServer;
+import org.apache.tinkerpop.gremlin.server.ProcessingException;
 import org.apache.tinkerpop.gremlin.server.Settings;
 import org.apache.tinkerpop.gremlin.server.auth.AuthenticatedUser;
-import org.apache.tinkerpop.gremlin.server.ProcessingException;
 import org.apache.tinkerpop.gremlin.server.util.GremlinError;
 import org.apache.tinkerpop.gremlin.server.util.MetricManager;
 import org.apache.tinkerpop.gremlin.server.util.TraverserIterator;
@@ -62,7 +63,6 @@ import org.apache.tinkerpop.gremlin.util.Tokens;
 import org.apache.tinkerpop.gremlin.util.iterator.IteratorUtils;
 import org.apache.tinkerpop.gremlin.util.message.RequestMessageV4;
 import org.apache.tinkerpop.gremlin.util.message.ResponseMessage;
-import org.apache.tinkerpop.gremlin.util.message.ResponseStatusCode;
 import org.apache.tinkerpop.gremlin.util.ser.MessageTextSerializerV4;
 import org.codehaus.groovy.control.MultipleCompilationErrorsException;
 import org.javatuples.Pair;
@@ -436,7 +436,7 @@ public class HttpGremlinEndpointHandler extends SimpleChannelInboundHandler<Requ
                 // it needs to be released here
                 if (chunk != null) chunk.release();
             }
-            sendTrailingHeaders(nettyContext, ResponseStatusCode.SUCCESS, "OK");
+            sendTrailingHeaders(nettyContext, HttpResponseStatus.OK, "OK");
             return;
         }
 
@@ -517,7 +517,7 @@ public class HttpGremlinEndpointHandler extends SimpleChannelInboundHandler<Requ
                     nettyContext.writeAndFlush(new DefaultHttpContent(chunk));
 
                     if (!hasMore) {
-                        sendTrailingHeaders(nettyContext, ResponseStatusCode.SUCCESS, "OK");
+                        sendTrailingHeaders(nettyContext, HttpResponseStatus.OK, "OK");
                     }
                 }
             } else {
@@ -563,7 +563,7 @@ public class HttpGremlinEndpointHandler extends SimpleChannelInboundHandler<Requ
 
                 // need to put status in last message
                 if (ctx.getRequestState() == FINISHING || ctx.getRequestState() == CHUNKING_NOT_SUPPORTED) {
-                    builder.code(ResponseStatusCode.SUCCESS).statusMessage("OK");
+                    builder.code(HttpResponseStatus.OK).statusMessage("OK");
                 }
 
                 responseMessage = builder.create();
@@ -583,7 +583,7 @@ public class HttpGremlinEndpointHandler extends SimpleChannelInboundHandler<Requ
 
                     return serializer.serializeResponseAsBinary(ResponseMessage.buildV4()
                             .result(aggregate)
-                            .code(ResponseStatusCode.SUCCESS)
+                            .code(HttpResponseStatus.OK)
                             .statusMessage("OK")
                             .create(), nettyContext.alloc());
 
diff --git 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
index bfdf18fe24..eb40a9e5d2 100644
--- 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
@@ -35,7 +35,6 @@ import org.apache.tinkerpop.gremlin.server.util.GremlinError;
 import org.apache.tinkerpop.gremlin.server.util.MetricManager;
 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.MessageTextSerializerV4;
 import org.apache.tinkerpop.gremlin.util.ser.SerTokens;
 import org.apache.tinkerpop.gremlin.util.ser.SerializationException;
@@ -114,9 +113,9 @@ public class HttpHandlerUtil {
         writeError(context, responseMessage, serializer);
     }
 
-    static void sendTrailingHeaders(final ChannelHandlerContext ctx, final ResponseStatusCode statusCode, final String message) {
+    static void sendTrailingHeaders(final ChannelHandlerContext ctx, final HttpResponseStatus statusCode, final String message) {
         final DefaultLastHttpContent defaultLastHttpContent = new DefaultLastHttpContent();
-        defaultLastHttpContent.trailingHeaders().add(SerTokens.TOKEN_CODE, statusCode.getValue());
+        defaultLastHttpContent.trailingHeaders().add(SerTokens.TOKEN_CODE, statusCode.code());
         try {
             defaultLastHttpContent.trailingHeaders().add(
                     SerTokens.TOKEN_MESSAGE, URLEncoder.encode(message, StandardCharsets.UTF_8.name()));
diff --git a/gremlin-server/src/main/java/org/apache/tinkerpop/gremlin/server/handler/SaslAuthenticationHandler.java b/gremlin-server/src/main/java/org/apache/tinkerpop/gremlin/server/handler/SaslAuthenticationHandler.java
index abc600356f..b8f4c81c99 100644
--- a/gremlin-server/src/main/java/org/apache/tinkerpop/gremlin/server/handler/SaslAuthenticationHandler.java
+++ b/gremlin-server/src/main/java/org/apache/tinkerpop/gremlin/server/handler/SaslAuthenticationHandler.java
@@ -21,29 +21,28 @@ package org.apache.tinkerpop.gremlin.server.handler;
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelHandler;
 import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.http.HttpResponseStatus;
 import io.netty.util.Attribute;
-
-import java.net.InetAddress;
-import java.net.InetSocketAddress;
-import java.net.SocketAddress;
-import java.util.Base64;
-import java.util.HashMap;
-import java.util.Map;
-
 import io.netty.util.AttributeMap;
-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.server.GremlinServer;
 import org.apache.tinkerpop.gremlin.server.Settings;
 import org.apache.tinkerpop.gremlin.server.auth.AuthenticatedUser;
 import org.apache.tinkerpop.gremlin.server.auth.AuthenticationException;
 import org.apache.tinkerpop.gremlin.server.auth.Authenticator;
 import org.apache.tinkerpop.gremlin.server.authz.Authorizer;
+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.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.util.Base64;
+import java.util.HashMap;
+import java.util.Map;
+
 /**
  * A SASL authentication handler that allows the {@link Authenticator} to be plugged into it. This handler is meant
  * to be used with protocols that process a {@link RequestMessage}
@@ -77,7 +76,7 @@ public class SaslAuthenticationHandler extends AbstractAuthenticationHandler {
                     negotiator.set(authenticator.newSaslNegotiator(getRemoteInetAddress(ctx)));
                     request.set(requestMessage);
                     final ResponseMessage authenticate = ResponseMessage.build(requestMessage)
-                            .code(ResponseStatusCode.AUTHENTICATE).create();
+                            .code(HttpResponseStatus.PROXY_AUTHENTICATION_REQUIRED).create();
                     ctx.writeAndFlush(authenticate);
                 } catch (Exception ex) {
                     // newSaslNegotiator can cause troubles - if we don't catch and respond nicely the driver seems
@@ -88,7 +87,7 @@ public class SaslAuthenticationHandler extends AbstractAuthenticationHandler {
 
                     final ResponseMessage error = ResponseMessage.build(requestMessage)
                             .statusMessage("Authenticator is not ready to handle requests")
-                            .code(ResponseStatusCode.SERVER_ERROR).create();
+                            .code(HttpResponseStatus.INTERNAL_SERVER_ERROR).create();
                     ctx.writeAndFlush(error);
                 }
             } else {
@@ -102,7 +101,7 @@ public class SaslAuthenticationHandler extends AbstractAuthenticationHandler {
                     } else {
                         final ResponseMessage error = ResponseMessage.build(request.get())
                                 .statusMessage("Incorrect type for : " + Tokens.ARGS_SASL + " - base64 encoded String is expected")
-                                .code(ResponseStatusCode.BAD_REQUEST).create();
+                                .code(HttpResponseStatus.BAD_REQUEST).create();
                         ctx.writeAndFlush(error);
                         return;
                     }
@@ -131,19 +130,19 @@ public class SaslAuthenticationHandler extends AbstractAuthenticationHandler {
                             metadata.put(Tokens.ARGS_SASL, BASE64_ENCODER.encodeToString(saslMessage));
                             final ResponseMessage authenticate = ResponseMessage.build(requestMessage)
                                     .statusAttributes(metadata)
-                                    .code(ResponseStatusCode.AUTHENTICATE).create();
+                                    .code(HttpResponseStatus.PROXY_AUTHENTICATION_REQUIRED).create();
                             ctx.writeAndFlush(authenticate);
                         }
                     } catch (AuthenticationException ae) {
                         final ResponseMessage error = ResponseMessage.build(request.get())
                                 .statusMessage(ae.getMessage())
-                                .code(ResponseStatusCode.UNAUTHORIZED).create();
+                                .code(HttpResponseStatus.UNAUTHORIZED).create();
                         ctx.writeAndFlush(error);
                     }
                 } else {
                     final ResponseMessage error = ResponseMessage.build(requestMessage)
                             .statusMessage("Failed to authenticate")
-                            .code(ResponseStatusCode.UNAUTHORIZED).create();
+                            .code(HttpResponseStatus.UNAUTHORIZED).create();
                     ctx.writeAndFlush(error);
                 }
             }
diff --git a/gremlin-server/src/main/java/org/apache/tinkerpop/gremlin/server/util/GremlinError.java b/gremlin-server/src/main/java/org/apache/tinkerpop/gremlin/server/util/GremlinError.java
index 1e1185e3fd..481781b89d 100644
--- a/gremlin-server/src/main/java/org/apache/tinkerpop/gremlin/server/util/GremlinError.java
+++ b/gremlin-server/src/main/java/org/apache/tinkerpop/gremlin/server/util/GremlinError.java
@@ -18,27 +18,27 @@
  */
 package org.apache.tinkerpop.gremlin.server.util;
 
+import io.netty.handler.codec.http.HttpResponseStatus;
 import org.apache.tinkerpop.gremlin.process.traversal.Failure;
 import org.apache.tinkerpop.gremlin.util.ExceptionHelper;
 import org.apache.tinkerpop.gremlin.util.Tokens;
 import org.apache.tinkerpop.gremlin.util.message.RequestMessageV4;
-import org.apache.tinkerpop.gremlin.util.message.ResponseStatusCode;
 
 import java.util.Set;
 
 public class GremlinError {
-    private final ResponseStatusCode code;
+    private final HttpResponseStatus code;
     private final String message;
     private final String exception;
 
-    private GremlinError(ResponseStatusCode code, String message, String exception) {
+    private GremlinError(HttpResponseStatus code, String message, String exception) {
 
         this.code = code;
         this.message = message;
         this.exception = exception;
     }
 
-    public ResponseStatusCode getCode() {
+    public HttpResponseStatus getCode() {
         return code;
     }
 
@@ -56,38 +56,38 @@ public class GremlinError {
     public static GremlinError invalidGremlinType(final RequestMessageV4 requestMessage ) {
         final String message = String.format("Message could not be parsed. Check the format of the request. [%s]",
                 requestMessage);
-        return new GremlinError(ResponseStatusCode.BAD_REQUEST, message, "InvalidRequestException");
+        return new GremlinError(HttpResponseStatus.BAD_REQUEST, message, "InvalidRequestException");
     }
 
     public static GremlinError unknownGremlinType(final RequestMessageV4 requestMessage ) {
         final String message = String.format("Message with gremlin of type [%s] is not recognized.",
                 requestMessage.getGremlinType());
-        return new GremlinError(ResponseStatusCode.BAD_REQUEST, message, "InvalidRequestException");
+        return new GremlinError(HttpResponseStatus.BAD_REQUEST, message, "InvalidRequestException");
     }
 
     // script errors
     public static GremlinError binding() {
         final String message = String.format("The [%s] message is using one or more invalid binding keys - they must be of type String and cannot be null",
                 Tokens.OPS_EVAL);
-        return new GremlinError(ResponseStatusCode.BAD_REQUEST, message, "InvalidRequestException");
+        return new GremlinError(HttpResponseStatus.BAD_REQUEST, message, "InvalidRequestException");
     }
 
     public static GremlinError binding(final Set<String> badBindings) {
         final String message = String.format("The [%s] message supplies one or more invalid parameters key of [%s] - these are reserved names.",
                 Tokens.OPS_EVAL, badBindings);
-        return new GremlinError(ResponseStatusCode.BAD_REQUEST, message, "InvalidRequestException");
+        return new GremlinError(HttpResponseStatus.BAD_REQUEST, message, "InvalidRequestException");
     }
 
     public static GremlinError binding(final int bindingsCount, final int allowedSize) {
         final String message = String.format("The [%s] message contains %s bindings which is more than is allowed by the server %s configuration",
                 Tokens.OPS_EVAL, bindingsCount, allowedSize);
-        return new GremlinError(ResponseStatusCode.BAD_REQUEST, message, "InvalidRequestException");
+        return new GremlinError(HttpResponseStatus.BAD_REQUEST, message, "InvalidRequestException");
     }
 
     public static GremlinError binding(final String aliased) {
         final String message = String.format("Could not alias [%s] to [%s] as [%s] not in the Graph or TraversalSource global bindings",
                 Tokens.ARGS_G, aliased, aliased);
-        return new GremlinError(ResponseStatusCode.BAD_REQUEST, message, "InvalidRequestException");
+        return new GremlinError(HttpResponseStatus.BAD_REQUEST, message, "InvalidRequestException");
     }
 
     // bytecode errors
@@ -95,79 +95,79 @@ public class GremlinError {
     public static GremlinError gremlinType() {
         final String message = String.format("A [%s] message requires a gremlin argument that is of type %s.",
                 Tokens.OPS_BYTECODE, Tokens.ARGS_GREMLIN);
-        return new GremlinError(ResponseStatusCode.BAD_REQUEST, message, "InvalidRequestException");
+        return new GremlinError(HttpResponseStatus.BAD_REQUEST, message, "InvalidRequestException");
     }
 
     public static GremlinError traversalSource() {
         final String message = String.format("A [%s] message requires a [%s] argument.", Tokens.OPS_BYTECODE, Tokens.ARGS_G);
-        return new GremlinError(ResponseStatusCode.BAD_REQUEST, message, "InvalidRequestException");
+        return new GremlinError(HttpResponseStatus.BAD_REQUEST, message, "InvalidRequestException");
     }
 
     public static GremlinError traversalSource(final String traversalSourceName ) {
         final String message = String.format("The traversal source [%s] for alias [%s] is not configured on the server.",
                 traversalSourceName, Tokens.VAL_TRAVERSAL_SOURCE_ALIAS);
-        return new GremlinError(ResponseStatusCode.BAD_REQUEST, message, "InvalidRequestException");
+        return new GremlinError(HttpResponseStatus.BAD_REQUEST, message, "InvalidRequestException");
     }
 
     public static GremlinError lambdaNotSupported(final Throwable t) {
-        return new GremlinError(ResponseStatusCode.BAD_REQUEST, t.getMessage(), "InvalidRequestException");
+        return new GremlinError(HttpResponseStatus.BAD_REQUEST, t.getMessage(), "InvalidRequestException");
     }
 
     public static GremlinError deserializeTraversal(final Throwable t) {
-        return new GremlinError(ResponseStatusCode.BAD_REQUEST, t.getMessage(), "InvalidRequestException");
+        return new GremlinError(HttpResponseStatus.BAD_REQUEST, t.getMessage(), "InvalidRequestException");
     }
 
     // execution errors
     public static GremlinError timeout(final RequestMessageV4 requestMessage ) {
         final String message = String.format("A timeout occurred during traversal evaluation of [%s] - consider increasing the limit given to evaluationTimeout",
                 requestMessage);
-        return new GremlinError(ResponseStatusCode.SERVER_ERROR, message, "ServerTimeoutExceededException");
+        return new GremlinError(HttpResponseStatus.INTERNAL_SERVER_ERROR, message, "ServerTimeoutExceededException");
     }
 
     public static GremlinError timedInterruptTimeout() {
-        return new GremlinError(ResponseStatusCode.SERVER_ERROR,
+        return new GremlinError(HttpResponseStatus.INTERNAL_SERVER_ERROR,
                 "Timeout during script evaluation triggered by TimedInterruptCustomizerProvider",
                 "ServerTimeoutExceededException");
     }
 
     public static GremlinError rateLimiting() {
-        return new GremlinError(ResponseStatusCode.TOO_MANY_REQUESTS,
+        return new GremlinError(HttpResponseStatus.TOO_MANY_REQUESTS,
                 "Too many requests have been sent in a given amount of time.", "TooManyRequestsException");
     }
 
     public static GremlinError serialization(Exception ex) {
         final String message = String.format("Error during serialization: %s", ExceptionHelper.getMessageFromExceptionOrCause(ex));
-        return new GremlinError(ResponseStatusCode.SERVER_ERROR, message, "ServerSerializationException");
+        return new GremlinError(HttpResponseStatus.INTERNAL_SERVER_ERROR, message, "ServerSerializationException");
     }
 
     public static GremlinError wrongSerializer(Exception ex) {
         final String message = String.format("Error during serialization: %s", ExceptionHelper.getMessageFromExceptionOrCause(ex));
-        return new GremlinError(ResponseStatusCode.SERVER_ERROR, message, "ServerSerializationException");
+        return new GremlinError(HttpResponseStatus.INTERNAL_SERVER_ERROR, message, "ServerSerializationException");
     }
 
     public static GremlinError longFrame(Throwable t) {
         final String message = t.getMessage() + " - increase the maxContentLength";
         // todo: ResponseEntityTooLargeException? !!!
-        return new GremlinError(ResponseStatusCode.PAYLOAD_TOO_LARGE, message, "RequestEntityTooLargeException");
+        return new GremlinError(HttpResponseStatus.REQUEST_ENTITY_TOO_LARGE, message, "RequestEntityTooLargeException");
     }
 
     public static GremlinError longRequest(final RequestMessageV4 requestMessage ) {
         final String message = String.format("The Gremlin statement that was submitted exceeds the maximum compilation size allowed by the JVM, please split it into multiple smaller statements - %s", requestMessage.trimMessage(1021));
-        return new GremlinError(ResponseStatusCode.PAYLOAD_TOO_LARGE, message, "RequestEntityTooLargeException");
+        return new GremlinError(HttpResponseStatus.REQUEST_ENTITY_TOO_LARGE, message, "RequestEntityTooLargeException");
     }
 
     public static GremlinError temporary(final Throwable t) {
-        return new GremlinError(ResponseStatusCode.SERVER_ERROR, t.getMessage(), "ServerEvaluationException");
+        return new GremlinError(HttpResponseStatus.INTERNAL_SERVER_ERROR, t.getMessage(), "ServerEvaluationException");
     }
 
     public static GremlinError failStep(final Failure failure) {
         // todo: double check message
-        return new GremlinError(ResponseStatusCode.SERVER_ERROR,
+        return new GremlinError(HttpResponseStatus.INTERNAL_SERVER_ERROR,
                 failure.getMessage() + ". " + failure.format(), "ServerFailStepException");
     }
 
     public static GremlinError general(final Throwable t) {
         final String message = (t.getMessage() == null) ? t.toString() : t.getMessage();
-        return new GremlinError(ResponseStatusCode.SERVER_ERROR, message, "ServerErrorException");
+        return new GremlinError(HttpResponseStatus.INTERNAL_SERVER_ERROR, message, "ServerErrorException");
     }
 }
diff --git a/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/server/GremlinDriverIntegrateTest.java b/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/server/GremlinDriverIntegrateTest.java
index 19e65228ba..d92325e1ec 100644
--- a/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/server/GremlinDriverIntegrateTest.java
+++ b/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/server/GremlinDriverIntegrateTest.java
@@ -20,36 +20,36 @@ package org.apache.tinkerpop.gremlin.server;
 
 import ch.qos.logback.classic.Level;
 import ch.qos.logback.classic.Logger;
+import io.netty.handler.codec.http.HttpResponseStatus;
 import nl.altindag.log.LogCaptor;
-import org.apache.tinkerpop.gremlin.driver.Channelizer;
-import org.apache.tinkerpop.gremlin.driver.handler.GremlinResponseHandler;
-import org.apache.tinkerpop.gremlin.server.channel.HttpChannelizer;
-import org.apache.tinkerpop.gremlin.util.ExceptionHelper;
 import org.apache.tinkerpop.gremlin.TestHelper;
+import org.apache.tinkerpop.gremlin.driver.Channelizer;
 import org.apache.tinkerpop.gremlin.driver.Client;
 import org.apache.tinkerpop.gremlin.driver.Cluster;
 import org.apache.tinkerpop.gremlin.driver.RequestOptions;
 import org.apache.tinkerpop.gremlin.driver.Result;
 import org.apache.tinkerpop.gremlin.driver.ResultSet;
-import org.apache.tinkerpop.gremlin.util.Tokens;
 import org.apache.tinkerpop.gremlin.driver.exception.ConnectionException;
 import org.apache.tinkerpop.gremlin.driver.exception.NoHostAvailableException;
 import org.apache.tinkerpop.gremlin.driver.exception.ResponseException;
-import org.apache.tinkerpop.gremlin.util.message.RequestMessageV4;
-import org.apache.tinkerpop.gremlin.util.message.ResponseStatusCode;
+import org.apache.tinkerpop.gremlin.driver.handler.GremlinResponseHandler;
 import org.apache.tinkerpop.gremlin.driver.remote.DriverRemoteConnection;
-import org.apache.tinkerpop.gremlin.util.ser.GraphBinaryMessageSerializerV1;
-import org.apache.tinkerpop.gremlin.util.ser.Serializers;
 import org.apache.tinkerpop.gremlin.jsr223.ScriptFileGremlinPlugin;
 import org.apache.tinkerpop.gremlin.process.traversal.Bytecode;
 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
+import org.apache.tinkerpop.gremlin.server.channel.HttpChannelizer;
 import org.apache.tinkerpop.gremlin.structure.Vertex;
 import org.apache.tinkerpop.gremlin.structure.io.Storage;
 import org.apache.tinkerpop.gremlin.structure.util.detached.DetachedVertex;
 import org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerFactory;
+import org.apache.tinkerpop.gremlin.util.ExceptionHelper;
 import org.apache.tinkerpop.gremlin.util.TimeUtil;
+import org.apache.tinkerpop.gremlin.util.Tokens;
 import org.apache.tinkerpop.gremlin.util.function.FunctionUtils;
 import org.apache.tinkerpop.gremlin.util.iterator.IteratorUtils;
+import org.apache.tinkerpop.gremlin.util.message.RequestMessageV4;
+import org.apache.tinkerpop.gremlin.util.ser.GraphBinaryMessageSerializerV1;
+import org.apache.tinkerpop.gremlin.util.ser.Serializers;
 import org.junit.After;
 import org.junit.AfterClass;
 import org.junit.Before;
@@ -59,9 +59,8 @@ import org.mockito.ArgumentCaptor;
 import org.mockito.Mockito;
 import org.slf4j.LoggerFactory;
 
-import java.awt.Color;
+import java.awt.*;
 import java.net.ConnectException;
-import java.time.Instant;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
@@ -84,6 +83,7 @@ import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
 import static org.apache.tinkerpop.gremlin.process.traversal.AnonymousTraversalSource.traversal;
+import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.core.AllOf.allOf;
 import static org.hamcrest.core.IsInstanceOf.instanceOf;
@@ -98,7 +98,6 @@ import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
-import static org.hamcrest.CoreMatchers.is;
 import static org.mockito.Mockito.verify;
 
 /**
@@ -263,7 +262,7 @@ public class GremlinDriverIntegrateTest extends AbstractGremlinServerIntegration
             } catch (Exception ex) {
                 final Throwable inner = ExceptionHelper.getRootCause(ex);
                 assertThat(inner, instanceOf(ResponseException.class));
-                assertEquals(ResponseStatusCode.BAD_REQUEST, ((ResponseException) inner).getResponseStatusCode());
+                assertEquals(HttpResponseStatus.BAD_REQUEST, ((ResponseException) inner).getResponseStatusCode());
                 assertTrue(ex.getMessage().contains("An error occurred during serialization of this request"));
             }
 
@@ -285,7 +284,7 @@ public class GremlinDriverIntegrateTest extends AbstractGremlinServerIntegration
             fail("Should have timed out");
         } catch (Exception ex) {
             final ResponseException re = (ResponseException) ex.getCause();
-            assertEquals(ResponseStatusCode.SERVER_ERROR, re.getResponseStatusCode());
+            assertEquals(HttpResponseStatus.INTERNAL_SERVER_ERROR, re.getResponseStatusCode());
         } finally {
             cluster.close();
         }
@@ -301,7 +300,7 @@ public class GremlinDriverIntegrateTest extends AbstractGremlinServerIntegration
             fail("Should have timed out");
         } catch (Exception ex) {
             final ResponseException re = (ResponseException) ex.getCause();
-            assertEquals(ResponseStatusCode.SERVER_ERROR, re.getResponseStatusCode());
+            assertEquals(HttpResponseStatus.INTERNAL_SERVER_ERROR, re.getResponseStatusCode());
         } finally {
             cluster.close();
         }
@@ -529,7 +528,7 @@ public class GremlinDriverIntegrateTest extends AbstractGremlinServerIntegration
             } catch (Exception ex) {
                 final Throwable inner = ExceptionHelper.getRootCause(ex);
                 assertThat(inner, instanceOf(ResponseException.class));
-                assertEquals(ResponseStatusCode.SERVER_ERROR, ((ResponseException) inner).getResponseStatusCode());
+                assertEquals(HttpResponseStatus.INTERNAL_SERVER_ERROR, ((ResponseException) inner).getResponseStatusCode());
             }
 
             // should not die completely just because we had a bad serialization error.  that kind of stuff happens
@@ -870,7 +869,7 @@ public class GremlinDriverIntegrateTest extends AbstractGremlinServerIntegration
             } catch (Exception ex) {
                 final Throwable inner = ExceptionHelper.getRootCause(ex);
                 assertTrue(inner instanceof ResponseException);
-                assertEquals(ResponseStatusCode.SERVER_ERROR, ((ResponseException) inner).getResponseStatusCode());
+                assertEquals(HttpResponseStatus.INTERNAL_SERVER_ERROR, ((ResponseException) inner).getResponseStatusCode());
             }
 
             // should not die completely just because we had a bad serialization error.  that kind of stuff happens
@@ -1409,7 +1408,7 @@ public class GremlinDriverIntegrateTest extends AbstractGremlinServerIntegration
             final Throwable root = ExceptionHelper.getRootCause(ex);
             assertThat(root, instanceOf(ResponseException.class));
             final ResponseException re = (ResponseException) root;
-            assertEquals(ResponseStatusCode.BAD_REQUEST, re.getResponseStatusCode());
+            assertEquals(HttpResponseStatus.BAD_REQUEST, re.getResponseStatusCode());
         } finally {
             cluster.close();
         }
@@ -1428,7 +1427,7 @@ public class GremlinDriverIntegrateTest extends AbstractGremlinServerIntegration
             final Throwable root = ExceptionHelper.getRootCause(ex);
             assertThat(root, instanceOf(ResponseException.class));
             final ResponseException re = (ResponseException) root;
-            assertEquals(ResponseStatusCode.BAD_REQUEST, re.getResponseStatusCode());
+            assertEquals(HttpResponseStatus.BAD_REQUEST, re.getResponseStatusCode());
 
             final Client rebound = cluster.connect().alias("graph");
             final Vertex v = rebound.submit("g.addVertex(T.label,'person')").all().get().get(0).getVertex();
@@ -1450,7 +1449,7 @@ public class GremlinDriverIntegrateTest extends AbstractGremlinServerIntegration
             final Throwable root = ExceptionHelper.getRootCause(ex);
             assertThat(root, instanceOf(ResponseException.class));
             final ResponseException re = (ResponseException) root;
-            assertEquals(ResponseStatusCode.SERVER_ERROR, re.getResponseStatusCode());
+            assertEquals(HttpResponseStatus.INTERNAL_SERVER_ERROR, re.getResponseStatusCode());
 
             final Client rebound = cluster.connect().alias("graph");
             final Vertex v = rebound.submit("g.addVertex(label,'person','name','jason')").all().get().get(0).getVertex();
@@ -1472,7 +1471,7 @@ public class GremlinDriverIntegrateTest extends AbstractGremlinServerIntegration
                 final Throwable root = ExceptionHelper.getRootCause(ex);
                 assertThat(root, instanceOf(ResponseException.class));
                 final ResponseException re = (ResponseException) root;
-                assertEquals(ResponseStatusCode.SERVER_ERROR, re.getResponseStatusCode());
+                assertEquals(HttpResponseStatus.INTERNAL_SERVER_ERROR, re.getResponseStatusCode());
             }
 
             final Client clientAliased = client.alias("g1");
@@ -1495,7 +1494,7 @@ public class GremlinDriverIntegrateTest extends AbstractGremlinServerIntegration
             final Throwable root = ExceptionHelper.getRootCause(ex);
             assertThat(root, instanceOf(ResponseException.class));
             final ResponseException re = (ResponseException) root;
-            assertEquals(ResponseStatusCode.SERVER_ERROR, re.getResponseStatusCode());
+            assertEquals(HttpResponseStatus.INTERNAL_SERVER_ERROR, re.getResponseStatusCode());
             client.close();
         }
 
@@ -1521,7 +1520,7 @@ public class GremlinDriverIntegrateTest extends AbstractGremlinServerIntegration
             final Throwable root = ExceptionHelper.getRootCause(ex);
             assertThat(root, instanceOf(ResponseException.class));
             final ResponseException re = (ResponseException) root;
-            assertEquals(ResponseStatusCode.SERVER_ERROR, re.getResponseStatusCode());
+            assertEquals(HttpResponseStatus.INTERNAL_SERVER_ERROR, re.getResponseStatusCode());
         }
 
         final Client clientAliased = client.alias("g1");
@@ -1626,7 +1625,7 @@ public class GremlinDriverIntegrateTest extends AbstractGremlinServerIntegration
         } catch (Exception ex) {
             final Throwable root = ExceptionHelper.getRootCause(ex);
             assertThat(root, instanceOf(ResponseException.class));
-            assertEquals(ResponseStatusCode.SERVER_ERROR, ((ResponseException) root).getResponseStatusCode());
+            assertEquals(HttpResponseStatus.INTERNAL_SERVER_ERROR, ((ResponseException) root).getResponseStatusCode());
             assertThat(root.getMessage(), allOf(startsWith("Evaluation exceeded"), containsString("250 ms")));
         }
     }
diff --git a/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/server/GremlinServerAuthKrb5IntegrateTest.java b/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/server/GremlinServerAuthKrb5IntegrateTest.java
index 2a534bfa8c..28fa27e424 100644
--- a/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/server/GremlinServerAuthKrb5IntegrateTest.java
+++ b/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/server/GremlinServerAuthKrb5IntegrateTest.java
@@ -18,23 +18,23 @@
  */
 package org.apache.tinkerpop.gremlin.server;
 
-import org.apache.tinkerpop.gremlin.util.ExceptionHelper;
+import io.netty.handler.codec.http.HttpResponseStatus;
 import org.apache.tinkerpop.gremlin.driver.Client;
 import org.apache.tinkerpop.gremlin.driver.Cluster;
-import org.apache.tinkerpop.gremlin.util.MessageSerializer;
 import org.apache.tinkerpop.gremlin.driver.exception.ResponseException;
-import org.apache.tinkerpop.gremlin.util.message.ResponseStatusCode;
-import org.apache.tinkerpop.gremlin.util.ser.GraphBinaryMessageSerializerV1;
 import org.apache.tinkerpop.gremlin.server.auth.Krb5Authenticator;
+import org.apache.tinkerpop.gremlin.util.ExceptionHelper;
+import org.apache.tinkerpop.gremlin.util.MessageSerializer;
+import org.apache.tinkerpop.gremlin.util.ser.GraphBinaryMessageSerializerV1;
 import org.ietf.jgss.GSSException;
 import org.junit.Test;
 import org.slf4j.LoggerFactory;
 
+import javax.security.auth.login.LoginException;
 import java.io.File;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.ExecutionException;
-import javax.security.auth.login.LoginException;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
@@ -239,7 +239,7 @@ public class GremlinServerAuthKrb5IntegrateTest extends AbstractGremlinServerInt
             fail("The kerberos config is a bust so this request should fail");
         } catch (Exception ex) {
             final ResponseException re = (ResponseException) ex.getCause();
-            assertEquals(ResponseStatusCode.SERVER_ERROR, re.getResponseStatusCode());
+            assertEquals(HttpResponseStatus.INTERNAL_SERVER_ERROR, re.getResponseStatusCode());
             assertEquals("Authenticator is not ready to handle requests", re.getMessage());
         } finally {
             cluster.close();
diff --git a/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/server/GremlinServerAuthzIntegrateTest.java b/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/server/GremlinServerAuthzIntegrateTest.java
index 0700973aa5..bf57a21557 100644
--- a/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/server/GremlinServerAuthzIntegrateTest.java
+++ b/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/server/GremlinServerAuthzIntegrateTest.java
@@ -18,6 +18,7 @@
  */
 package org.apache.tinkerpop.gremlin.server;
 
+import io.netty.handler.codec.http.HttpResponseStatus;
 import nl.altindag.log.LogCaptor;
 import org.apache.http.client.methods.CloseableHttpResponse;
 import org.apache.http.client.methods.HttpGet;
@@ -27,16 +28,14 @@ import org.apache.http.util.EntityUtils;
 import org.apache.tinkerpop.gremlin.driver.Client;
 import org.apache.tinkerpop.gremlin.driver.Cluster;
 import org.apache.tinkerpop.gremlin.driver.exception.ResponseException;
-import org.apache.tinkerpop.gremlin.server.handler.HttpBasicAuthenticationHandler;
-import org.apache.tinkerpop.gremlin.util.message.ResponseStatusCode;
 import org.apache.tinkerpop.gremlin.driver.remote.DriverRemoteConnection;
 import org.apache.tinkerpop.gremlin.process.traversal.AnonymousTraversalSource;
 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
-import org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.AbstractWarningVerificationStrategy;
 import org.apache.tinkerpop.gremlin.server.auth.AllowAllAuthenticator;
 import org.apache.tinkerpop.gremlin.server.auth.SimpleAuthenticator;
 import org.apache.tinkerpop.gremlin.server.authz.AllowListAuthorizer;
 import org.apache.tinkerpop.gremlin.server.channel.HttpChannelizer;
+import org.apache.tinkerpop.gremlin.server.handler.HttpBasicAuthenticationHandler;
 import org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONTokens;
 import org.apache.tinkerpop.gremlin.util.function.Lambda;
 import org.apache.tinkerpop.shaded.jackson.databind.JsonNode;
@@ -170,7 +169,7 @@ public class GremlinServerAuthzIntegrateTest extends AbstractGremlinServerIntegr
             fail("Authorization for bytecode request with lambda should fail");
         } catch (Exception ex) {
             final ResponseException re = (ResponseException) ex.getCause();
-            assertEquals(ResponseStatusCode.UNAUTHORIZED, re.getResponseStatusCode());
+            assertEquals(HttpResponseStatus.UNAUTHORIZED, re.getResponseStatusCode());
             assertEquals("Failed to authorize: User not authorized for bytecode requests on [gmodern] using lambdas.", re.getMessage());
 
             // wait for logger to flush - (don't think there is a way to detect this)
@@ -198,7 +197,7 @@ public class GremlinServerAuthzIntegrateTest extends AbstractGremlinServerIntegr
                 fail("Authorization for bytecode request with lambda should fail");
             } catch (Exception ex) {
                 final ResponseException re = (ResponseException) ex.getCause();
-                assertEquals(ResponseStatusCode.UNAUTHORIZED, re.getResponseStatusCode());
+                assertEquals(HttpResponseStatus.UNAUTHORIZED, re.getResponseStatusCode());
                 assertEquals("Failed to authorize: User not authorized for bytecode requests on [gmodern] using lambdas.", re.getMessage());
             }
             assertEquals(6, (long) g.V().count().next());
@@ -231,7 +230,7 @@ public class GremlinServerAuthzIntegrateTest extends AbstractGremlinServerIntegr
             fail("Authorization without authentication should fail");
         } catch (Exception ex) {
             final ResponseException re = (ResponseException) ex.getCause();
-            assertEquals(ResponseStatusCode.UNAUTHORIZED, re.getResponseStatusCode());
+            assertEquals(HttpResponseStatus.UNAUTHORIZED, re.getResponseStatusCode());
             assertEquals("Failed to authorize: User not authorized for string-based requests.", re.getMessage());
 
             // wait for logger to flush - (don't think there is a way to detect this)
@@ -255,7 +254,7 @@ public class GremlinServerAuthzIntegrateTest extends AbstractGremlinServerIntegr
             fail("Authorization without authentication should fail");
         } catch (Exception ex) {
             final ResponseException re = (ResponseException) ex.getCause();
-            assertEquals(ResponseStatusCode.UNAUTHORIZED, re.getResponseStatusCode());
+            assertEquals(HttpResponseStatus.UNAUTHORIZED, re.getResponseStatusCode());
             assertEquals("Failed to authorize: User not authorized for string-based requests.", re.getMessage());
         } finally {
             cluster.close();
@@ -286,7 +285,7 @@ public class GremlinServerAuthzIntegrateTest extends AbstractGremlinServerIntegr
             fail("Authorization without authentication should fail");
         } catch (Exception ex) {
             final ResponseException re = (ResponseException) ex.getCause();
-            assertEquals(ResponseStatusCode.UNAUTHORIZED, re.getResponseStatusCode());
+            assertEquals(HttpResponseStatus.UNAUTHORIZED, re.getResponseStatusCode());
             assertEquals("Failed to authorize: User not authorized for bytecode requests on [gclassic].", re.getMessage());
         } finally {
             cluster.close();
@@ -303,7 +302,7 @@ public class GremlinServerAuthzIntegrateTest extends AbstractGremlinServerIntegr
             fail("Authorization without authentication should fail");
         } catch (Exception ex) {
             final ResponseException re = (ResponseException) ex.getCause();
-            assertEquals(ResponseStatusCode.UNAUTHORIZED, re.getResponseStatusCode());
+            assertEquals(HttpResponseStatus.UNAUTHORIZED, re.getResponseStatusCode());
             assertEquals("Failed to authorize: User not authorized for string-based requests.", re.getMessage());
         } finally {
             cluster.close();
diff --git 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
index 8e2909f9b7..be52d154fd 100644
--- 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
@@ -22,49 +22,48 @@ import io.netty.buffer.ByteBuf;
 import io.netty.buffer.Unpooled;
 import io.netty.buffer.UnpooledByteBufAllocator;
 import org.apache.commons.lang3.RandomStringUtils;
+import org.apache.http.Consts;
 import org.apache.http.Header;
 import org.apache.http.HttpEntity;
 import org.apache.http.HttpHeaders;
 import org.apache.http.HttpVersion;
 import org.apache.http.client.config.RequestConfig;
+import org.apache.http.client.methods.CloseableHttpResponse;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.client.methods.HttpPost;
 import org.apache.http.conn.EofSensorInputStream;
 import org.apache.http.entity.ByteArrayEntity;
+import org.apache.http.entity.StringEntity;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.client.HttpClients;
 import org.apache.http.impl.io.ChunkedInputStream;
-import org.apache.tinkerpop.gremlin.driver.exception.ResponseException;
+import org.apache.http.util.EntityUtils;
+import org.apache.tinkerpop.gremlin.TestHelper;
 import org.apache.tinkerpop.gremlin.process.traversal.Bytecode;
-import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
-import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
+import org.apache.tinkerpop.gremlin.server.auth.SimpleAuthenticator;
+import org.apache.tinkerpop.gremlin.server.channel.HttpChannelizer;
 import org.apache.tinkerpop.gremlin.server.handler.HttpBasicAuthenticationHandler;
+import org.apache.tinkerpop.gremlin.structure.io.Storage;
+import org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONTokens;
 import org.apache.tinkerpop.gremlin.structure.util.empty.EmptyGraph;
-import org.apache.tinkerpop.gremlin.util.Tokens;
-import org.apache.tinkerpop.gremlin.util.function.Lambda;
 import org.apache.tinkerpop.gremlin.util.message.RequestMessageV4;
 import org.apache.tinkerpop.gremlin.util.message.ResponseMessage;
-import org.apache.tinkerpop.gremlin.util.message.ResponseStatusCode;
 import org.apache.tinkerpop.gremlin.util.ser.GraphBinaryMessageSerializerV4;
 import org.apache.tinkerpop.gremlin.util.ser.GraphSONMessageSerializerV4;
 import org.apache.tinkerpop.gremlin.util.ser.GraphSONUntypedMessageSerializerV4;
 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;
-import org.apache.http.client.methods.CloseableHttpResponse;
-import org.apache.http.client.methods.HttpGet;
-import org.apache.http.client.methods.HttpPost;
-import org.apache.http.entity.StringEntity;
-import org.apache.http.impl.client.CloseableHttpClient;
-import org.apache.http.impl.client.HttpClients;
-import org.apache.http.util.EntityUtils;
-import org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONTokens;
 import org.apache.tinkerpop.gremlin.util.ser.Serializers;
 import org.apache.tinkerpop.shaded.jackson.databind.JsonNode;
 import org.apache.tinkerpop.shaded.jackson.databind.ObjectMapper;
+import org.hamcrest.CoreMatchers;
+import org.junit.Assert;
 import org.junit.Test;
 
 import javax.script.SimpleBindings;
 import java.io.IOException;
 import java.lang.reflect.Field;
 import java.time.Instant;
+import java.util.Arrays;
 import java.util.Base64;
 import java.util.HashMap;
 import java.util.List;
@@ -76,7 +75,6 @@ import java.util.concurrent.Future;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
 
-import static org.apache.tinkerpop.gremlin.process.traversal.AnonymousTraversalSource.traversal;
 import static org.apache.tinkerpop.gremlin.server.handler.HttpRequestIdHandler.REQUEST_ID_HEADER_NAME;
 import static org.apache.tinkerpop.gremlin.util.Tokens.ARGS_MATERIALIZE_PROPERTIES;
 import static org.apache.tinkerpop.gremlin.util.Tokens.MATERIALIZE_PROPERTIES_ALL;
@@ -84,15 +82,12 @@ import static org.apache.tinkerpop.gremlin.util.Tokens.MATERIALIZE_PROPERTIES_TO
 import static org.apache.tinkerpop.gremlin.util.Tokens.TIMEOUT_MS;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.core.Is.is;
-import static org.hamcrest.core.IsInstanceOf.instanceOf;
-import static org.hamcrest.core.StringRegularExpression.matchesRegex;
 import static org.hamcrest.core.StringStartsWith.startsWith;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
 
 /**
  * Integration tests for server-side settings and processing.
@@ -1237,15 +1232,15 @@ public class GremlinServerHttpIntegrateTest extends AbstractGremlinServerIntegra
             final String json = EntityUtils.toString(response.getEntity());
             final JsonNode node = mapper.readTree(json);
             assertEquals(0, node.get("result").get(GraphSONTokens.VALUEPROP).get(0).get(GraphSONTokens.VALUEPROP).intValue());
-            assertEquals("some error", node.get("status").get("message").textValue());
-            assertEquals(595, node.get("status").get("code").intValue());
+            Assert.assertThat(node.get("status").get("message").textValue(), startsWith("some error"));
+            assertEquals(500, node.get("status").get("code").intValue());
 
             final Header[] footers = getTrailingHeaders(response);
             assertEquals(2, footers.length);
             assertEquals("code", footers[0].getName());
-            assertEquals("595", footers[0].getValue());
+            assertEquals("500", footers[0].getValue());
             assertEquals("message", footers[1].getName());
-            assertEquals("some+error", footers[1].getValue());
+            Assert.assertThat(footers[1].getValue(), startsWith("some+error"));
         }
     }
 
diff --git a/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/server/GremlinServerIntegrateTest.java b/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/server/GremlinServerIntegrateTest.java
index 68df70a1f3..3d4b35ef7a 100644
--- a/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/server/GremlinServerIntegrateTest.java
+++ b/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/server/GremlinServerIntegrateTest.java
@@ -18,39 +18,38 @@
  */
 package org.apache.tinkerpop.gremlin.server;
 
-import ch.qos.logback.classic.Level;
 import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.http.HttpResponseStatus;
 import io.netty.util.AttributeKey;
 import nl.altindag.log.LogCaptor;
 import org.apache.commons.configuration2.BaseConfiguration;
 import org.apache.commons.configuration2.Configuration;
-import org.apache.tinkerpop.gremlin.server.channel.HttpTestChannelizer;
-import org.apache.tinkerpop.gremlin.server.channel.TestChannelizer;
-import org.apache.tinkerpop.gremlin.util.ExceptionHelper;
 import org.apache.tinkerpop.gremlin.TestHelper;
 import org.apache.tinkerpop.gremlin.driver.Client;
 import org.apache.tinkerpop.gremlin.driver.Cluster;
 import org.apache.tinkerpop.gremlin.driver.Result;
+import org.apache.tinkerpop.gremlin.driver.UserAgent;
 import org.apache.tinkerpop.gremlin.driver.exception.ResponseException;
-import org.apache.tinkerpop.gremlin.util.message.RequestMessageV4;
-import org.apache.tinkerpop.gremlin.util.message.ResponseMessage;
-import org.apache.tinkerpop.gremlin.util.message.ResponseStatusCode;
 import org.apache.tinkerpop.gremlin.driver.remote.DriverRemoteConnection;
-import org.apache.tinkerpop.gremlin.util.ser.Serializers;
 import org.apache.tinkerpop.gremlin.driver.simple.SimpleClient;
-import org.apache.tinkerpop.gremlin.driver.UserAgent;
 import org.apache.tinkerpop.gremlin.groovy.jsr223.GremlinGroovyScriptEngine;
 import org.apache.tinkerpop.gremlin.groovy.jsr223.GroovyCompilerGremlinPlugin;
 import org.apache.tinkerpop.gremlin.groovy.jsr223.customizer.SimpleSandboxExtension;
 import org.apache.tinkerpop.gremlin.jsr223.ScriptFileGremlinPlugin;
-import org.apache.tinkerpop.gremlin.structure.RemoteGraph;
 import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
+import org.apache.tinkerpop.gremlin.server.channel.HttpTestChannelizer;
+import org.apache.tinkerpop.gremlin.server.channel.TestChannelizer;
 import org.apache.tinkerpop.gremlin.structure.Graph;
+import org.apache.tinkerpop.gremlin.structure.RemoteGraph;
 import org.apache.tinkerpop.gremlin.structure.T;
 import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.apache.tinkerpop.gremlin.util.ExceptionHelper;
 import org.apache.tinkerpop.gremlin.util.function.Lambda;
+import org.apache.tinkerpop.gremlin.util.message.RequestMessageV4;
+import org.apache.tinkerpop.gremlin.util.message.ResponseMessage;
+import org.apache.tinkerpop.gremlin.util.ser.Serializers;
 import org.hamcrest.CoreMatchers;
 import org.hamcrest.Matchers;
 import org.junit.After;
@@ -58,7 +57,6 @@ import org.junit.AfterClass;
 import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.Test;
-
 import org.slf4j.LoggerFactory;
 
 import java.util.HashMap;
@@ -286,7 +284,7 @@ public class GremlinServerIntegrateTest extends AbstractGremlinServerIntegration
 //        for (int ix = 0; ix < 512 && !errorTriggered.get(); ix++) {
 //            blockers.add(client.submit("'test'").all().exceptionally(t -> {
 //                final ResponseException re = (ResponseException) t.getCause();
-//                errorTriggered.compareAndSet(false, ResponseStatusCode.TOO_MANY_REQUESTS == re.getResponseStatusCode());
+//                errorTriggered.compareAndSet(false, HttpResponseStatus.TOO_MANY_REQUESTS == re.getResponseStatusCode());
 //                return null;
 //            }));
 //        }
@@ -314,7 +312,7 @@ public class GremlinServerIntegrateTest extends AbstractGremlinServerIntegration
         } catch (Exception ex) {
             final Throwable t = ex.getCause();
             assertThat(t, instanceOf(ResponseException.class));
-            assertEquals(ResponseStatusCode.BAD_REQUEST, ((ResponseException) t).getResponseStatusCode());
+            assertEquals(HttpResponseStatus.BAD_REQUEST, ((ResponseException) t).getResponseStatusCode());
         }
 
         // make a graph with a cycle in it to force a long run traversal
@@ -327,7 +325,7 @@ public class GremlinServerIntegrateTest extends AbstractGremlinServerIntegration
         } catch (Exception ex) {
             final Throwable t = ex.getCause();
             assertThat(t, instanceOf(ResponseException.class));
-            assertEquals(ResponseStatusCode.SERVER_ERROR, ((ResponseException) t).getResponseStatusCode());
+            assertEquals(HttpResponseStatus.INTERNAL_SERVER_ERROR, ((ResponseException) t).getResponseStatusCode());
         }
 
         g.close();
@@ -344,7 +342,7 @@ public class GremlinServerIntegrateTest extends AbstractGremlinServerIntegration
         } catch (Exception ex) {
             final Throwable t = ex.getCause();
             assertThat(t, instanceOf(ResponseException.class));
-            assertEquals(ResponseStatusCode.SERVER_ERROR, ((ResponseException) t).getResponseStatusCode());
+            assertEquals(HttpResponseStatus.INTERNAL_SERVER_ERROR, ((ResponseException) t).getResponseStatusCode());
         }
 
         // make a graph with a cycle in it to force a long run traversal
@@ -357,7 +355,7 @@ public class GremlinServerIntegrateTest extends AbstractGremlinServerIntegration
         } catch (Exception ex) {
             final Throwable t = ex.getCause();
             assertThat(t, instanceOf(ResponseException.class));
-            assertEquals(ResponseStatusCode.SERVER_ERROR, ((ResponseException) t).getResponseStatusCode());
+            assertEquals(HttpResponseStatus.INTERNAL_SERVER_ERROR, ((ResponseException) t).getResponseStatusCode());
         }
 
         g.close();
@@ -374,7 +372,7 @@ public class GremlinServerIntegrateTest extends AbstractGremlinServerIntegration
         } catch (Exception ex) {
             final Throwable t = ex.getCause();
             assertThat(t, instanceOf(ResponseException.class));
-            assertEquals(ResponseStatusCode.SERVER_ERROR, ((ResponseException) t).getResponseStatusCode());
+            assertEquals(HttpResponseStatus.INTERNAL_SERVER_ERROR, ((ResponseException) t).getResponseStatusCode());
         }
 
         // make a graph with a cycle in it to force a long run traversal
@@ -387,7 +385,7 @@ public class GremlinServerIntegrateTest extends AbstractGremlinServerIntegration
         } catch (Exception ex) {
             final Throwable t = ex.getCause();
             assertThat(t, instanceOf(ResponseException.class));
-            assertEquals(ResponseStatusCode.SERVER_ERROR, ((ResponseException) t).getResponseStatusCode());
+            assertEquals(HttpResponseStatus.INTERNAL_SERVER_ERROR, ((ResponseException) t).getResponseStatusCode());
         }
 
         g.close();
@@ -418,7 +416,7 @@ public class GremlinServerIntegrateTest extends AbstractGremlinServerIntegration
             } catch (Exception ex) {
                 final Throwable t = ex.getCause();
                 assertThat("Unexpected exception with script evaluation timeout: " + timeout, t, instanceOf(ResponseException.class));
-                assertEquals(ResponseStatusCode.SERVER_ERROR, ((ResponseException) t).getResponseStatusCode());
+                assertEquals(HttpResponseStatus.INTERNAL_SERVER_ERROR, ((ResponseException) t).getResponseStatusCode());
             }
         }
 
@@ -562,8 +560,8 @@ public class GremlinServerIntegrateTest extends AbstractGremlinServerIntegration
             final CountDownLatch latch = new CountDownLatch(1);
             final AtomicBoolean pass = new AtomicBoolean(false);
             client.submit(request, result -> {
-                if (result.getStatus().getCode() != ResponseStatusCode.PARTIAL_CONTENT) {
-                    pass.set(ResponseStatusCode.BAD_REQUEST == result.getStatus().getCode());
+                if (result.getStatus().getCode() != HttpResponseStatus.PARTIAL_CONTENT) {
+                    pass.set(HttpResponseStatus.BAD_REQUEST == result.getStatus().getCode());
                     latch.countDown();
                 }
             });
@@ -581,8 +579,8 @@ public class GremlinServerIntegrateTest extends AbstractGremlinServerIntegration
             final CountDownLatch latch = new CountDownLatch(1);
             final AtomicBoolean pass = new AtomicBoolean(false);
             client.submit(request, result -> {
-                if (result.getStatus().getCode() != ResponseStatusCode.PARTIAL_CONTENT) {
-                    pass.set(ResponseStatusCode.BAD_REQUEST == result.getStatus().getCode());
+                if (result.getStatus().getCode() != HttpResponseStatus.PARTIAL_CONTENT) {
+                    pass.set(HttpResponseStatus.BAD_REQUEST == result.getStatus().getCode());
                     latch.countDown();
                 }
             });
@@ -604,8 +602,8 @@ public class GremlinServerIntegrateTest extends AbstractGremlinServerIntegration
             final CountDownLatch latch = new CountDownLatch(1);
             final AtomicBoolean pass = new AtomicBoolean(false);
             client.submit(request, result -> {
-                if (result.getStatus().getCode() != ResponseStatusCode.PARTIAL_CONTENT) {
-                    pass.set(ResponseStatusCode.BAD_REQUEST == result.getStatus().getCode());
+                if (result.getStatus().getCode() != HttpResponseStatus.PARTIAL_CONTENT) {
+                    pass.set(HttpResponseStatus.BAD_REQUEST == result.getStatus().getCode());
                     latch.countDown();
                 }
             });
@@ -623,8 +621,8 @@ public class GremlinServerIntegrateTest extends AbstractGremlinServerIntegration
             final CountDownLatch latch = new CountDownLatch(1);
             final AtomicBoolean pass = new AtomicBoolean(false);
             client.submit(request, result -> {
-                if (result.getStatus().getCode() != ResponseStatusCode.PARTIAL_CONTENT) {
-                    pass.set(ResponseStatusCode.SUCCESS == result.getStatus().getCode() && (((int) ((List) result.getResult().getData()).get(0) == 246)));
+                if (result.getStatus().getCode() != HttpResponseStatus.PARTIAL_CONTENT) {
+                    pass.set(HttpResponseStatus.OK == result.getStatus().getCode() && (((int) ((List) result.getResult().getData()).get(0) == 246)));
                     latch.countDown();
                 }
             });
@@ -645,8 +643,8 @@ public class GremlinServerIntegrateTest extends AbstractGremlinServerIntegration
             final CountDownLatch latch = new CountDownLatch(1);
             final AtomicBoolean pass = new AtomicBoolean(false);
             client.submit(request, result -> {
-                if (result.getStatus().getCode() != ResponseStatusCode.PARTIAL_CONTENT) {
-                    pass.set(ResponseStatusCode.BAD_REQUEST == result.getStatus().getCode());
+                if (result.getStatus().getCode() != HttpResponseStatus.PARTIAL_CONTENT) {
+                    pass.set(HttpResponseStatus.BAD_REQUEST == result.getStatus().getCode());
                     latch.countDown();
                 }
             });
@@ -882,7 +880,7 @@ public class GremlinServerIntegrateTest extends AbstractGremlinServerIntegration
             final RequestMessageV4 request = RequestMessageV4.build("10").create();
             final List<ResponseMessage> responses = client.submit(request);
             assertEquals(1, responses.size());
-            assertEquals(ResponseStatusCode.SUCCESS, responses.get(0).getStatus().getCode());
+            assertEquals(HttpResponseStatus.OK, responses.get(0).getStatus().getCode());
         }
     }
 
@@ -896,9 +894,9 @@ public class GremlinServerIntegrateTest extends AbstractGremlinServerIntegration
             // first message have no status
             assertNull(responses.get(0).getStatus());
             // second one contains last piece of data
-            assertEquals(ResponseStatusCode.SUCCESS, responses.get(1).getStatus().getCode());
+            assertEquals(HttpResponseStatus.OK, responses.get(1).getStatus().getCode());
             // last message with no data, but with trailing headers
-            assertEquals(ResponseStatusCode.NO_CONTENT, responses.get(2).getStatus().getCode());
+            assertEquals(HttpResponseStatus.NO_CONTENT, responses.get(2).getStatus().getCode());
         }
     }
 
@@ -907,7 +905,7 @@ public class GremlinServerIntegrateTest extends AbstractGremlinServerIntegration
         try (SimpleClient client = TestClientFactory.createSimpleHttpClient()) {
             final RequestMessageV4 request = RequestMessageV4.build("new String().doNothingAtAllBecauseThis is a syntax error").create();
             final List<ResponseMessage> responses = client.submit(request);
-            assertEquals(ResponseStatusCode.SERVER_ERROR, responses.get(0).getStatus().getCode());
+            assertEquals(HttpResponseStatus.INTERNAL_SERVER_ERROR, responses.get(0).getStatus().getCode());
             assertEquals(1, responses.size());
         }
     }
@@ -985,7 +983,7 @@ public class GremlinServerIntegrateTest extends AbstractGremlinServerIntegration
             final Throwable t = ex.getCause();
             assertThat(t, instanceOf(ResponseException.class));
             assertEquals("try again!", t.getMessage());
-            assertEquals(ResponseStatusCode.SERVER_ERROR, ((ResponseException) t).getResponseStatusCode());
+            assertEquals(HttpResponseStatus.INTERNAL_SERVER_ERROR, ((ResponseException) t).getResponseStatusCode());
         } finally {
             cluster.close();
         }
@@ -1025,7 +1023,7 @@ public class GremlinServerIntegrateTest extends AbstractGremlinServerIntegration
             final Throwable t = ex.getCause();
             assertThat(t, instanceOf(ResponseException.class));
             assertThat(t.getMessage(), startsWith("make it stop"));
-            assertEquals(ResponseStatusCode.SERVER_ERROR, ((ResponseException) t).getResponseStatusCode());
+            assertEquals(HttpResponseStatus.INTERNAL_SERVER_ERROR, ((ResponseException) t).getResponseStatusCode());
         }
     }
 }
diff --git a/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/server/GremlinServerSslIntegrateTest.java b/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/server/GremlinServerSslIntegrateTest.java
index 846dc549a7..05d1836a48 100644
--- a/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/server/GremlinServerSslIntegrateTest.java
+++ b/gremlin-server/src/test/java/org/apache/tinkerpop/gremlin/server/GremlinServerSslIntegrateTest.java
@@ -18,20 +18,19 @@
  */
 package org.apache.tinkerpop.gremlin.server;
 
+import io.netty.handler.codec.http.HttpResponseStatus;
 import io.netty.handler.ssl.ClientAuth;
 import io.netty.handler.ssl.SslContext;
 import io.netty.handler.ssl.SslContextBuilder;
 import io.netty.handler.ssl.SslProvider;
 import io.netty.handler.ssl.util.InsecureTrustManagerFactory;
 import io.netty.handler.ssl.util.SelfSignedCertificate;
-import org.apache.tinkerpop.gremlin.driver.simple.SimpleClient;
-import org.apache.tinkerpop.gremlin.util.ExceptionHelper;
 import org.apache.tinkerpop.gremlin.driver.Client;
 import org.apache.tinkerpop.gremlin.driver.Cluster;
 import org.apache.tinkerpop.gremlin.driver.exception.NoHostAvailableException;
-import org.apache.tinkerpop.gremlin.util.Tokens;
+import org.apache.tinkerpop.gremlin.driver.simple.SimpleClient;
+import org.apache.tinkerpop.gremlin.util.ExceptionHelper;
 import org.apache.tinkerpop.gremlin.util.message.RequestMessageV4;
-import org.apache.tinkerpop.gremlin.util.message.ResponseStatusCode;
 import org.junit.Test;
 
 import javax.net.ssl.SSLException;
@@ -174,8 +173,8 @@ public class GremlinServerSslIntegrateTest extends AbstractGremlinServerIntegrat
             final AtomicBoolean pass = new AtomicBoolean(false);
             client.submit(request, result -> {
                 System.out.println(result.getStatus());
-                if (result.getStatus().getCode() != ResponseStatusCode.PARTIAL_CONTENT) {
-                    pass.set(ResponseStatusCode.SUCCESS == result.getStatus().getCode() &&
+                if (result.getStatus().getCode() != HttpResponseStatus.PARTIAL_CONTENT) {
+                    pass.set(HttpResponseStatus.OK == result.getStatus().getCode() &&
                             (((int) ((List) result.getResult().getData()).get(0) == 246)));
                 }
                 latch.countDown();
diff --git 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
index 3f1d9f3784..b70d8c18f7 100644
--- 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
@@ -18,6 +18,7 @@
  */
 package org.apache.tinkerpop.gremlin.server;
 
+import io.netty.handler.codec.http.HttpResponseStatus;
 import org.apache.commons.lang3.exception.ExceptionUtils;
 import org.apache.tinkerpop.gremlin.driver.Client;
 import org.apache.tinkerpop.gremlin.driver.Cluster;
@@ -30,7 +31,6 @@ import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSo
 import org.apache.tinkerpop.gremlin.server.channel.HttpChannelizer;
 import org.apache.tinkerpop.gremlin.structure.Transaction;
 import org.apache.tinkerpop.gremlin.util.ExceptionHelper;
-import org.apache.tinkerpop.gremlin.util.message.ResponseStatusCode;
 import org.junit.Ignore;
 import org.junit.Test;
 
@@ -211,7 +211,7 @@ public class HttpDriverIntegrateTest extends AbstractGremlinServerIntegrationTes
             } catch (Exception ex) {
                 final Throwable inner = ExceptionHelper.getRootCause(ex);
                 assertThat(inner, instanceOf(ResponseException.class));
-                assertEquals(ResponseStatusCode.BAD_REQUEST, ((ResponseException) inner).getResponseStatusCode());
+                assertEquals(HttpResponseStatus.BAD_REQUEST, ((ResponseException) inner).getResponseStatusCode());
                 assertTrue(ex.getMessage().contains("An error occurred during serialization of this request"));
             }
 
@@ -234,7 +234,7 @@ public class HttpDriverIntegrateTest extends AbstractGremlinServerIntegrationTes
             fail("Should have timed out");
         } catch (Exception ex) {
             final ResponseException re = (ResponseException) ex.getCause();
-            assertEquals(ResponseStatusCode.SERVER_ERROR, re.getResponseStatusCode());
+            assertEquals(HttpResponseStatus.INTERNAL_SERVER_ERROR, re.getResponseStatusCode());
         } finally {
             cluster.close();
         }
@@ -251,7 +251,7 @@ public class HttpDriverIntegrateTest extends AbstractGremlinServerIntegrationTes
             fail("Should have timed out");
         } catch (Exception ex) {
             final ResponseException re = (ResponseException) ex.getCause();
-            assertEquals(ResponseStatusCode.SERVER_ERROR, re.getResponseStatusCode());
+            assertEquals(HttpResponseStatus.INTERNAL_SERVER_ERROR, re.getResponseStatusCode());
         } finally {
             cluster.close();
         }
@@ -271,7 +271,7 @@ public class HttpDriverIntegrateTest extends AbstractGremlinServerIntegrationTes
             } catch (Exception ex) {
                 final Throwable inner = ExceptionHelper.getRootCause(ex);
                 assertThat(inner, instanceOf(ResponseException.class));
-                assertEquals(ResponseStatusCode.SERVER_ERROR, ((ResponseException) inner).getResponseStatusCode());
+                assertEquals(HttpResponseStatus.INTERNAL_SERVER_ERROR, ((ResponseException) inner).getResponseStatusCode());
             }
 
             // should not die completely just because we had a bad serialization error.  that kind of stuff happens
@@ -296,7 +296,7 @@ public class HttpDriverIntegrateTest extends AbstractGremlinServerIntegrationTes
                 final Throwable inner = ExceptionHelper.getRootCause(ex);
                 assertTrue(inner instanceof ResponseException);
                 assertThat(inner.getMessage(), endsWith("Division by zero"));
-                assertEquals(ResponseStatusCode.SERVER_ERROR, ((ResponseException) inner).getResponseStatusCode());
+                assertEquals(HttpResponseStatus.INTERNAL_SERVER_ERROR, ((ResponseException) inner).getResponseStatusCode());
             }
 
             // should not die completely just because we had a bad serialization error.  that kind of stuff happens
@@ -482,7 +482,7 @@ public class HttpDriverIntegrateTest extends AbstractGremlinServerIntegrationTes
                 final Throwable inner = ExceptionHelper.getRootCause(ex);
                 assertTrue(inner instanceof ResponseException);
                 assertThat(inner.getMessage(), startsWith("Error during serialization"));
-                assertEquals(ResponseStatusCode.SERVER_ERROR, ((ResponseException) inner).getResponseStatusCode());
+                assertEquals(HttpResponseStatus.INTERNAL_SERVER_ERROR, ((ResponseException) inner).getResponseStatusCode());
             }
 
             // should not die completely just because we had a bad serialization error.  that kind of stuff happens
diff --git a/gremlin-tools/gremlin-benchmark/src/main/java/org/apache/tinkerpop/gremlin/driver/SerializationBenchmark.java b/gremlin-tools/gremlin-benchmark/src/main/java/org/apache/tinkerpop/gremlin/driver/SerializationBenchmark.java
index 4385abb33e..6a91312d6c 100644
--- a/gremlin-tools/gremlin-benchmark/src/main/java/org/apache/tinkerpop/gremlin/driver/SerializationBenchmark.java
+++ b/gremlin-tools/gremlin-benchmark/src/main/java/org/apache/tinkerpop/gremlin/driver/SerializationBenchmark.java
@@ -21,17 +21,17 @@ package org.apache.tinkerpop.gremlin.driver;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.Unpooled;
 import io.netty.buffer.UnpooledByteBufAllocator;
+import io.netty.handler.codec.http.HttpResponseStatus;
 import org.apache.tinkerpop.benchmark.util.AbstractBenchmarkBase;
+import org.apache.tinkerpop.gremlin.process.traversal.Bytecode;
+import org.apache.tinkerpop.gremlin.structure.io.binary.DataType;
+import org.apache.tinkerpop.gremlin.structure.util.reference.ReferenceVertex;
 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.GraphSONMessageSerializerV3;
 import org.apache.tinkerpop.gremlin.util.ser.SerializationException;
-import org.apache.tinkerpop.gremlin.process.traversal.Bytecode;
-import org.apache.tinkerpop.gremlin.structure.io.binary.DataType;
-import org.apache.tinkerpop.gremlin.structure.util.reference.ReferenceVertex;
 import org.openjdk.jmh.annotations.Benchmark;
 import org.openjdk.jmh.annotations.Warmup;
 
@@ -103,7 +103,7 @@ public class SerializationBenchmark extends AbstractBenchmarkBase {
     private static final UUID id = UUID.randomUUID();
 
     private static final ResponseMessage response = ResponseMessage
-            .build(UUID.randomUUID()).code(ResponseStatusCode.SUCCESS).result(new ReferenceVertex(1, "person"))
+            .build(UUID.randomUUID()).code(HttpResponseStatus.OK).result(new ReferenceVertex(1, "person"))
             .create();
 
     private static final Bytecode bytecode = new Bytecode();
diff --git a/gremlin-tools/gremlin-socket-server/src/main/java/org/apache/tinkerpop/gremlin/socket/server/TestWSGremlinInitializer.java b/gremlin-tools/gremlin-socket-server/src/main/java/org/apache/tinkerpop/gremlin/socket/server/TestWSGremlinInitializer.java
index f3a6ce61fd..dbae78e509 100644
--- a/gremlin-tools/gremlin-socket-server/src/main/java/org/apache/tinkerpop/gremlin/socket/server/TestWSGremlinInitializer.java
+++ b/gremlin-tools/gremlin-socket-server/src/main/java/org/apache/tinkerpop/gremlin/socket/server/TestWSGremlinInitializer.java
@@ -18,30 +18,30 @@
  */
 package org.apache.tinkerpop.gremlin.socket.server;
 
+import io.netty.buffer.ByteBuf;
 import io.netty.buffer.ByteBufAllocator;
 import io.netty.buffer.UnpooledByteBufAllocator;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelPipeline;
+import io.netty.handler.codec.MessageToMessageDecoder;
 import io.netty.handler.codec.http.HttpHeaders;
+import io.netty.handler.codec.http.HttpResponseStatus;
+import io.netty.handler.codec.http.websocketx.BinaryWebSocketFrame;
+import io.netty.handler.codec.http.websocketx.CloseWebSocketFrame;
 import io.netty.handler.codec.http.websocketx.WebSocketServerProtocolHandler;
+import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
+import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerFactory;
+import org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerGraph;
+import org.apache.tinkerpop.gremlin.util.message.RequestMessage;
+import org.apache.tinkerpop.gremlin.util.message.ResponseMessage;
 import org.apache.tinkerpop.gremlin.util.ser.AbstractMessageSerializer;
 import org.apache.tinkerpop.gremlin.util.ser.GraphBinaryMessageSerializerV1;
+import org.apache.tinkerpop.gremlin.util.ser.GraphSONMessageSerializerV2;
 import org.apache.tinkerpop.gremlin.util.ser.GraphSONMessageSerializerV3;
+import org.apache.tinkerpop.gremlin.util.ser.SerializationException;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-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.GraphSONMessageSerializerV2;
-import org.apache.tinkerpop.gremlin.util.ser.SerializationException;
-import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
-import org.apache.tinkerpop.gremlin.structure.Vertex;
-import org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerFactory;
-import org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerGraph;
-import io.netty.buffer.ByteBuf;
-import io.netty.channel.ChannelHandlerContext;
-import io.netty.channel.ChannelPipeline;
-import io.netty.handler.codec.MessageToMessageDecoder;
-import io.netty.handler.codec.http.websocketx.BinaryWebSocketFrame;
-import io.netty.handler.codec.http.websocketx.CloseWebSocketFrame;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -131,7 +131,7 @@ public class TestWSGremlinInitializer extends TestChannelizers.TestWebSocketServ
                 logger.info("waiting for 1 sec");
                 Thread.sleep(1000);
                 final ResponseMessage responseMessage = ResponseMessage.build(msg)
-                        .code(ResponseStatusCode.SERVER_ERROR)
+                        .code(HttpResponseStatus.INTERNAL_SERVER_ERROR)
                         .statusAttributeException(new RuntimeException()).create();
                 ctx.channel().writeAndFlush(new BinaryWebSocketFrame(SERIALIZER.serializeResponseAsBinary(responseMessage, allocator)));
             } else if (msg.getRequestId().equals(settings.CLOSE_CONNECTION_REQUEST_ID) || msg.getRequestId().equals(settings.CLOSE_CONNECTION_REQUEST_ID_2)) {
diff --git a/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/message/ResponseMessage.java b/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/message/ResponseMessage.java
index 94dbca4a3a..5348f2b06b 100644
--- a/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/message/ResponseMessage.java
+++ b/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/message/ResponseMessage.java
@@ -18,6 +18,7 @@
  */
 package org.apache.tinkerpop.gremlin.util.message;
 
+import io.netty.handler.codec.http.HttpResponseStatus;
 import org.apache.commons.lang3.exception.ExceptionUtils;
 import org.apache.tinkerpop.gremlin.util.Tokens;
 import org.apache.tinkerpop.gremlin.util.iterator.IteratorUtils;
@@ -122,7 +123,7 @@ public final class ResponseMessage {
     public final static class Builder {
 
         private final UUID requestId;
-        private ResponseStatusCode code = null;
+        private HttpResponseStatus code = null;
         private Object result = null;
         private String statusMessage = null;
         private String exception = null;
@@ -145,7 +146,7 @@ public final class ResponseMessage {
             this.requestId = requestId;
         }
 
-        public Builder code(final ResponseStatusCode code) {
+        public Builder code(final HttpResponseStatus code) {
             this.code = code;
             return this;
         }
diff --git a/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/message/ResponseStatus.java b/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/message/ResponseStatus.java
index 4bc2ca6ecb..9a27b62944 100644
--- a/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/message/ResponseStatus.java
+++ b/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/message/ResponseStatus.java
@@ -18,6 +18,8 @@
  */
 package org.apache.tinkerpop.gremlin.util.message;
 
+import io.netty.handler.codec.http.HttpResponseStatus;
+
 import java.util.Collections;
 import java.util.Map;
 
@@ -25,19 +27,19 @@ import java.util.Map;
  * @author Stephen Mallette (http://stephen.genoprime.com)
  */
 public final class ResponseStatus {
-    private final ResponseStatusCode code;
+    private final HttpResponseStatus code;
     private final String message;
     private final String exception;
     private final Map<String, Object> attributes;
 
-    public ResponseStatus(final ResponseStatusCode code, final String message, final Map<String, Object> attributes) {
+    public ResponseStatus(final HttpResponseStatus code, final String message, final Map<String, Object> attributes) {
         this.code = code;
         this.message = message;
         this.attributes = attributes;
         this.exception = null;
     }
 
-    public ResponseStatus(final ResponseStatusCode code, final String message, final String exception) {
+    public ResponseStatus(final HttpResponseStatus code, final String message, final String exception) {
         this.code = code;
         this.message = message;
         this.exception = exception;
@@ -45,9 +47,9 @@ public final class ResponseStatus {
     }
 
     /**
-     * Gets the {@link ResponseStatusCode} that describes how the server responded to the request.
+     * Gets the {@link HttpResponseStatus} that describes how the server responded to the request.
      */
-    public ResponseStatusCode getCode() {
+    public HttpResponseStatus getCode() {
         return code;
     }
 
diff --git a/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/message/ResponseStatusCode.java b/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/message/ResponseStatusCode.java
deleted file mode 100644
index b972bfc884..0000000000
--- a/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/message/ResponseStatusCode.java
+++ /dev/null
@@ -1,150 +0,0 @@
-/*
- * 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.message;
-
-import org.apache.tinkerpop.gremlin.process.traversal.Failure;
-import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
-
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.stream.Stream;
-
-/**
- * Response status codes for Gremlin Server responses. Result codes tend to map to
- * <a href="http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html">HTTP status codes</a>.  It is not a one-to-one
- * mapping and there are mapper status codes to be considered.
- *
- * @author Stephen Mallette (http://stephen.genoprime.com)
- */
-public enum ResponseStatusCode {
-
-    /**
-     * Code 200: The server successfully processed a request to completion - there are no messages remaining in this
-     * stream.
-     *
-     * @since 3.0.0-incubating
-     */
-    SUCCESS(200),
-
-    /**
-     * Code 204: The server processed the request but there is no result to return (e.g. an {@link Iterator} with no
-     * elements).
-     *
-     * @since 3.0.0-incubating
-     */
-    NO_CONTENT(204),
-
-    /**
-     * Code 206: The server successfully returned some content, but there is more in the stream to arrive - wait for a
-     * {@link #SUCCESS} to signify the end of the stream.
-     *
-     * @since 3.0.0-incubating
-     */
-    PARTIAL_CONTENT(206),
-
-    /**
-     * The server cannot or will not process the request due to an apparent client error (e.g., malformed request
-     * syntax, size too large, invalid request message framing, or deceptive request routing).
-     *
-     * @since 4.0.0
-     */
-    BAD_REQUEST(400),
-
-    /**
-     * Code 401: The server could not authenticate the request or the client requested a resource it did not have
-     * access to.
-     *
-     * @since 3.0.0-incubating
-     */
-    UNAUTHORIZED(401),
-
-    /**
-     * Code 403: The server could authenticate the request, but will not fulfill it.  This is a general purpose code
-     * that would typically be returned if the request is authenticated but not authorized to do what it is doing.
-     *
-     * @since 3.0.1-incubating
-     */
-    FORBIDDEN(403),
-
-    /**
-     * Code 407: A challenge from the server for the client to authenticate its request.
-     *
-     * @since 3.0.1-incubating
-     */
-    AUTHENTICATE(407),
-
-    /**
-     * The request is larger than the server is willing or able to process.
-     *
-     * @since 4.0.0
-     */
-    PAYLOAD_TOO_LARGE(413),
-
-    /**
-     * Code 429: Indicates that too many requests have been sent in a given amount of time.
-     *
-     * @since 3.5.0
-     */
-    TOO_MANY_REQUESTS(429),
-
-    /**
-     * Code 497: The request message contains objects that were not serializable on the client side.
-     *
-     * @since 3.3.6
-     */
-    REQUEST_ERROR_SERIALIZATION(497),
-
-    /**
-     * Code 500: A general server error occurred that prevented the request from being processed.
-     *
-     * @since 3.0.0-incubating
-     */
-    SERVER_ERROR(500);
-
-    private final int value;
-    private final static Map<Integer, ResponseStatusCode> codeValueMap = new HashMap<>();
-
-    static {
-        Stream.of(ResponseStatusCode.values()).forEach(code -> codeValueMap.put(code.getValue(), code));
-    }
-
-    public static ResponseStatusCode getFromValue(final int codeValue) {
-        return codeValueMap.get(codeValue);
-    }
-
-    ResponseStatusCode(final int value) {
-        this.value = value;
-    }
-
-    public int getValue() {
-        return value;
-    }
-
-    public boolean isSuccess() {
-        return String.valueOf(this.value).startsWith("2");
-    }
-
-    /**
-     * Indicates whether the status code can only be used in the last response for a particular request.
-     */
-    public boolean isFinalResponse() {
-        return this != PARTIAL_CONTENT && this != AUTHENTICATE;
-    }
-}
diff --git a/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/ser/AbstractGraphSONMessageSerializerV1.java b/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/ser/AbstractGraphSONMessageSerializerV1.java
index 66fe869b98..5dbad261af 100644
--- a/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/ser/AbstractGraphSONMessageSerializerV1.java
+++ b/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/ser/AbstractGraphSONMessageSerializerV1.java
@@ -18,17 +18,17 @@
  */
 package org.apache.tinkerpop.gremlin.util.ser;
 
-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.structure.Graph;
-import org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONMapper;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.ByteBufAllocator;
+import io.netty.handler.codec.http.HttpResponseStatus;
 import io.netty.util.ReferenceCountUtil;
+import org.apache.tinkerpop.gremlin.structure.Graph;
+import org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONMapper;
 import org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONTokens;
 import org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONUtil;
 import org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONVersion;
+import org.apache.tinkerpop.gremlin.util.message.RequestMessage;
+import org.apache.tinkerpop.gremlin.util.message.ResponseMessage;
 import org.apache.tinkerpop.shaded.jackson.core.JsonGenerationException;
 import org.apache.tinkerpop.shaded.jackson.core.JsonGenerator;
 import org.apache.tinkerpop.shaded.jackson.core.JsonProcessingException;
@@ -136,7 +136,7 @@ public abstract class AbstractGraphSONMessageSerializerV1 extends AbstractMessag
             final Map<String, Object> status = (Map<String, Object>) responseData.get(SerTokens.TOKEN_STATUS);
             final Map<String, Object> result = (Map<String, Object>) responseData.get(SerTokens.TOKEN_RESULT);
             return ResponseMessage.build(UUID.fromString(responseData.get(SerTokens.TOKEN_REQUEST).toString()))
-                    .code(ResponseStatusCode.getFromValue((Integer) status.get(SerTokens.TOKEN_CODE)))
+                    .code(HttpResponseStatus.valueOf((Integer) status.get(SerTokens.TOKEN_CODE)))
                     .statusMessage(String.valueOf(status.get(SerTokens.TOKEN_MESSAGE)))
                     .statusAttributes((Map<String, Object>) status.get(SerTokens.TOKEN_ATTRIBUTES))
                     .result(result.get(SerTokens.TOKEN_DATA))
@@ -210,7 +210,7 @@ public abstract class AbstractGraphSONMessageSerializerV1 extends AbstractMessag
 
             if (typeSerializer != null) jsonGenerator.writeStringField(GraphSONTokens.CLASS, HashMap.class.getName());
             jsonGenerator.writeStringField(SerTokens.TOKEN_MESSAGE, responseMessage.getStatus().getMessage());
-            jsonGenerator.writeNumberField(SerTokens.TOKEN_CODE, responseMessage.getStatus().getCode().getValue());
+            jsonGenerator.writeNumberField(SerTokens.TOKEN_CODE, responseMessage.getStatus().getCode().code());
             jsonGenerator.writeObjectField(SerTokens.TOKEN_ATTRIBUTES, responseMessage.getStatus().getAttributes());
             jsonGenerator.writeEndObject();
 
diff --git a/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/ser/AbstractGraphSONMessageSerializerV2.java b/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/ser/AbstractGraphSONMessageSerializerV2.java
index 123ed0daa3..3b8c9959b1 100644
--- a/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/ser/AbstractGraphSONMessageSerializerV2.java
+++ b/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/ser/AbstractGraphSONMessageSerializerV2.java
@@ -20,10 +20,10 @@ package org.apache.tinkerpop.gremlin.util.ser;
 
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.ByteBufAllocator;
+import io.netty.handler.codec.http.HttpResponseStatus;
 import io.netty.util.ReferenceCountUtil;
 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.structure.Graph;
 import org.apache.tinkerpop.gremlin.structure.io.graphson.AbstractObjectDeserializer;
 import org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONMapper;
@@ -262,7 +262,7 @@ public abstract class AbstractGraphSONMessageSerializerV2 extends AbstractMessag
 
             GraphSONUtil.writeStartObject(responseMessage, jsonGenerator, typeSerializer);
             jsonGenerator.writeStringField(SerTokens.TOKEN_MESSAGE, responseMessage.getStatus().getMessage());
-            jsonGenerator.writeNumberField(SerTokens.TOKEN_CODE, responseMessage.getStatus().getCode().getValue());
+            jsonGenerator.writeNumberField(SerTokens.TOKEN_CODE, responseMessage.getStatus().getCode().code());
             jsonGenerator.writeObjectField(SerTokens.TOKEN_ATTRIBUTES, responseMessage.getStatus().getAttributes());
             GraphSONUtil.writeEndObject(responseMessage, jsonGenerator, typeSerializer);
 
@@ -295,7 +295,7 @@ public abstract class AbstractGraphSONMessageSerializerV2 extends AbstractMessag
             final Map<String, Object> status = (Map<String, Object>) data.get(SerTokens.TOKEN_STATUS);
             final Map<String, Object> result = (Map<String, Object>) data.get(SerTokens.TOKEN_RESULT);
             return ResponseMessage.build(UUID.fromString(data.get(SerTokens.TOKEN_REQUEST).toString()))
-                    .code(ResponseStatusCode.getFromValue((Integer) status.get(SerTokens.TOKEN_CODE)))
+                    .code(HttpResponseStatus.valueOf((Integer) status.get(SerTokens.TOKEN_CODE)))
                     .statusMessage(String.valueOf(status.get(SerTokens.TOKEN_MESSAGE)))
                     .statusAttributes((Map<String, Object>) status.get(SerTokens.TOKEN_ATTRIBUTES))
                     .result(result.get(SerTokens.TOKEN_DATA))
diff --git a/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/ser/AbstractGraphSONMessageSerializerV4.java b/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/ser/AbstractGraphSONMessageSerializerV4.java
index 0b3a5b69ba..52cb961e00 100644
--- a/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/ser/AbstractGraphSONMessageSerializerV4.java
+++ b/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/ser/AbstractGraphSONMessageSerializerV4.java
@@ -20,6 +20,7 @@ package org.apache.tinkerpop.gremlin.util.ser;
 
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.ByteBufAllocator;
+import io.netty.handler.codec.http.HttpResponseStatus;
 import io.netty.util.ReferenceCountUtil;
 import org.apache.tinkerpop.gremlin.structure.io.graphson.AbstractObjectDeserializer;
 import org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONMapper;
@@ -27,7 +28,6 @@ import org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONUtil;
 import org.apache.tinkerpop.gremlin.util.message.RequestMessage;
 import org.apache.tinkerpop.gremlin.util.message.RequestMessageV4;
 import org.apache.tinkerpop.gremlin.util.message.ResponseMessage;
-import org.apache.tinkerpop.gremlin.util.message.ResponseStatusCode;
 import org.apache.tinkerpop.shaded.jackson.core.JsonGenerator;
 import org.apache.tinkerpop.shaded.jackson.core.JsonProcessingException;
 import org.apache.tinkerpop.shaded.jackson.databind.ObjectMapper;
@@ -41,7 +41,6 @@ import java.io.IOException;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
-import java.util.UUID;
 
 public abstract class AbstractGraphSONMessageSerializerV4 extends AbstractGraphSONMessageSerializerV2 implements MessageTextSerializerV4<ObjectMapper> {
     private static final Logger logger = LoggerFactory.getLogger(AbstractGraphSONMessageSerializerV4.class);
@@ -365,8 +364,8 @@ public abstract class AbstractGraphSONMessageSerializerV4 extends AbstractGraphS
             jsonGenerator.writeFieldName(SerTokens.TOKEN_STATUS);
             GraphSONUtil.writeStartObject(responseMessage, jsonGenerator, typeSerializer);
             jsonGenerator.writeStringField(SerTokens.TOKEN_MESSAGE, responseMessage.getStatus().getMessage());
-            jsonGenerator.writeNumberField(SerTokens.TOKEN_CODE, responseMessage.getStatus().getCode().getValue());
-            if (responseMessage.getStatus().getCode() != ResponseStatusCode.SUCCESS &&
+            jsonGenerator.writeNumberField(SerTokens.TOKEN_CODE, responseMessage.getStatus().getCode().code());
+            if (responseMessage.getStatus().getCode() != HttpResponseStatus.OK &&
                     responseMessage.getStatus().getException() != null) {
                 jsonGenerator.writeStringField(SerTokens.TOKEN_EXCEPTION, responseMessage.getStatus().getException());
             }
@@ -385,7 +384,7 @@ public abstract class AbstractGraphSONMessageSerializerV4 extends AbstractGraphS
         public ResponseMessage createObject(final Map<String, Object> data) {
             final Map<String, Object> status = (Map<String, Object>) data.get(SerTokens.TOKEN_STATUS);
             return ResponseMessage.build()
-                    .code(ResponseStatusCode.getFromValue((Integer) status.get(SerTokens.TOKEN_CODE)))
+                    .code(HttpResponseStatus.valueOf((Integer) status.get(SerTokens.TOKEN_CODE)))
                     .statusMessage(String.valueOf(status.get(SerTokens.TOKEN_MESSAGE)))
                     .exception(String.valueOf(status.get(SerTokens.TOKEN_EXCEPTION)))
                     .result(data.get(SerTokens.TOKEN_RESULT))
diff --git a/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/ser/GraphBinaryMessageSerializerV4.java b/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/ser/GraphBinaryMessageSerializerV4.java
index 7a9feb7b87..af5529447f 100644
--- a/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/ser/GraphBinaryMessageSerializerV4.java
+++ b/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/ser/GraphBinaryMessageSerializerV4.java
@@ -20,6 +20,7 @@ package org.apache.tinkerpop.gremlin.util.ser;
 
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.ByteBufAllocator;
+import io.netty.handler.codec.http.HttpResponseStatus;
 import org.apache.tinkerpop.gremlin.structure.io.Buffer;
 import org.apache.tinkerpop.gremlin.structure.io.binary.GraphBinaryMapper;
 import org.apache.tinkerpop.gremlin.structure.io.binary.GraphBinaryWriter;
@@ -28,7 +29,6 @@ import org.apache.tinkerpop.gremlin.structure.io.binary.TypeSerializerRegistry;
 import org.apache.tinkerpop.gremlin.util.message.RequestMessageV4;
 import org.apache.tinkerpop.gremlin.util.message.ResponseMessage;
 import org.apache.tinkerpop.gremlin.util.message.ResponseStatus;
-import org.apache.tinkerpop.gremlin.util.message.ResponseStatusCode;
 import org.apache.tinkerpop.gremlin.util.ser.binary.RequestMessageSerializerV4;
 import org.javatuples.Triplet;
 
@@ -37,7 +37,6 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.EnumSet;
 import java.util.List;
-import java.util.UUID;
 
 import static java.nio.charset.StandardCharsets.UTF_8;
 
@@ -148,7 +147,7 @@ public class GraphBinaryMessageSerializerV4 extends AbstractGraphBinaryMessageSe
                 // we don't know how much data we have, so need a special object
                 writer.write(Marker.END_OF_STREAM, buffer);
                 // Status code
-                writer.writeValue(status.getCode().getValue(), buffer, false);
+                writer.writeValue(status.getCode().code(), buffer, false);
                 // Nullable status message
                 writer.writeValue(status.getMessage(), buffer, true);
                 // Nullable exception
@@ -179,8 +178,8 @@ public class GraphBinaryMessageSerializerV4 extends AbstractGraphBinaryMessageSe
         return result;
     }
 
-    private Triplet<ResponseStatusCode, String, String> readFooter(final Buffer buffer) throws IOException {
-        final ResponseStatusCode statusCode = ResponseStatusCode.getFromValue(reader.readValue(buffer, Integer.class, false));
+    private Triplet<HttpResponseStatus, String, String> readFooter(final Buffer buffer) throws IOException {
+        final HttpResponseStatus statusCode = HttpResponseStatus.valueOf(reader.readValue(buffer, Integer.class, false));
         final String message = reader.readValue(buffer, String.class, true);
         final String exception = reader.readValue(buffer, String.class, true);
 
@@ -195,7 +194,7 @@ public class GraphBinaryMessageSerializerV4 extends AbstractGraphBinaryMessageSe
             // empty input buffer
             if (buffer.readableBytes() == 0) {
                 return ResponseMessage.buildV4().
-                        code(ResponseStatusCode.NO_CONTENT).result(Collections.emptyList()).create();
+                        code(HttpResponseStatus.NO_CONTENT).result(Collections.emptyList()).create();
             }
 
             if (isFirstChunk) {
@@ -217,7 +216,7 @@ public class GraphBinaryMessageSerializerV4 extends AbstractGraphBinaryMessageSe
                         .create();
             }
 
-            final Triplet<ResponseStatusCode, String, String> footer = readFooter(buffer);
+            final Triplet<HttpResponseStatus, String, String> footer = readFooter(buffer);
             return ResponseMessage.buildV4()
                     .result(result)
                     .code(footer.getValue0())
diff --git a/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONMessageSerializerV1.java b/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONMessageSerializerV1.java
index 8b2b781dd5..5ff7cc1ff1 100644
--- a/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONMessageSerializerV1.java
+++ b/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONMessageSerializerV1.java
@@ -19,11 +19,11 @@
 package org.apache.tinkerpop.gremlin.util.ser;
 
 import io.netty.buffer.ByteBufAllocator;
-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 io.netty.handler.codec.http.HttpResponseStatus;
 import org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONMapper;
 import org.apache.tinkerpop.gremlin.structure.io.graphson.TypeInfo;
+import org.apache.tinkerpop.gremlin.util.message.RequestMessage;
+import org.apache.tinkerpop.gremlin.util.message.ResponseMessage;
 import org.apache.tinkerpop.shaded.jackson.databind.ObjectMapper;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -81,7 +81,7 @@ public final class GraphSONMessageSerializerV1 extends AbstractGraphSONMessageSe
             final Map<String, Object> status = (Map<String, Object>) responseData.get(SerTokens.TOKEN_STATUS);
             final Map<String, Object> result = (Map<String, Object>) responseData.get(SerTokens.TOKEN_RESULT);
             return ResponseMessage.build(UUID.fromString(responseData.get(SerTokens.TOKEN_REQUEST).toString()))
-                    .code(ResponseStatusCode.getFromValue((Integer) status.get(SerTokens.TOKEN_CODE)))
+                    .code(HttpResponseStatus.valueOf((Integer) status.get(SerTokens.TOKEN_CODE)))
                     .statusMessage(String.valueOf(status.get(SerTokens.TOKEN_MESSAGE)))
                     .statusAttributes((Map<String, Object>) status.get(SerTokens.TOKEN_ATTRIBUTES))
                     .result(result.get(SerTokens.TOKEN_DATA))
diff --git a/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONMessageSerializerV4.java b/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONMessageSerializerV4.java
index c085283fd5..4ff6406460 100644
--- a/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONMessageSerializerV4.java
+++ b/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONMessageSerializerV4.java
@@ -18,39 +18,14 @@
  */
 package org.apache.tinkerpop.gremlin.util.ser;
 
-import io.netty.buffer.ByteBuf;
-import io.netty.buffer.ByteBufAllocator;
-import io.netty.util.ReferenceCountUtil;
-import org.apache.tinkerpop.gremlin.structure.io.Buffer;
-import org.apache.tinkerpop.gremlin.structure.io.binary.GraphBinaryWriter;
-import org.apache.tinkerpop.gremlin.structure.io.binary.Marker;
-import org.apache.tinkerpop.gremlin.structure.io.graphson.AbstractObjectDeserializer;
 import org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONMapper;
-import org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONUtil;
 import org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONVersion;
 import org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONXModuleV3;
-import org.apache.tinkerpop.gremlin.util.message.RequestMessage;
 import org.apache.tinkerpop.gremlin.util.message.RequestMessageV4;
 import org.apache.tinkerpop.gremlin.util.message.ResponseMessage;
-import org.apache.tinkerpop.gremlin.util.message.ResponseStatus;
-import org.apache.tinkerpop.gremlin.util.message.ResponseStatusCode;
-import org.apache.tinkerpop.shaded.jackson.core.JsonGenerator;
-import org.apache.tinkerpop.shaded.jackson.core.JsonProcessingException;
-import org.apache.tinkerpop.shaded.jackson.databind.ObjectMapper;
-import org.apache.tinkerpop.shaded.jackson.databind.SerializerProvider;
-import org.apache.tinkerpop.shaded.jackson.databind.jsontype.TypeSerializer;
 import org.apache.tinkerpop.shaded.jackson.databind.module.SimpleModule;
-import org.apache.tinkerpop.shaded.jackson.databind.ser.std.StdSerializer;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
-import java.io.IOException;
 import java.nio.ByteBuffer;
-import java.util.Collections;
-import java.util.EnumSet;
-import java.util.List;
-import java.util.Map;
-import java.util.UUID;
 
 /**
  * Serialize results to JSON with version 4.0.x schema and the extended module.
diff --git a/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONUntypedMessageSerializerV1.java b/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONUntypedMessageSerializerV1.java
index 520111b9fb..6eb50ecc4c 100644
--- a/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONUntypedMessageSerializerV1.java
+++ b/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONUntypedMessageSerializerV1.java
@@ -19,9 +19,9 @@
 package org.apache.tinkerpop.gremlin.util.ser;
 
 import io.netty.buffer.ByteBufAllocator;
+import io.netty.handler.codec.http.HttpResponseStatus;
 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.structure.io.graphson.GraphSONMapper;
 import org.apache.tinkerpop.gremlin.structure.io.graphson.TypeInfo;
 import org.apache.tinkerpop.shaded.jackson.databind.ObjectMapper;
@@ -82,7 +82,7 @@ public final class GraphSONUntypedMessageSerializerV1 extends AbstractGraphSONMe
             final Map<String, Object> status = (Map<String, Object>) responseData.get(SerTokens.TOKEN_STATUS);
             final Map<String, Object> result = (Map<String, Object>) responseData.get(SerTokens.TOKEN_RESULT);
             return ResponseMessage.build(UUID.fromString(responseData.get(SerTokens.TOKEN_REQUEST).toString()))
-                    .code(ResponseStatusCode.getFromValue((Integer) status.get(SerTokens.TOKEN_CODE)))
+                    .code(HttpResponseStatus.valueOf((Integer) status.get(SerTokens.TOKEN_CODE)))
                     .statusMessage(String.valueOf(status.get(SerTokens.TOKEN_MESSAGE)))
                     .statusAttributes((Map<String, Object>) status.get(SerTokens.TOKEN_ATTRIBUTES))
                     .result(result.get(SerTokens.TOKEN_DATA))
diff --git a/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/ser/ResponseMessageGryoSerializer.java b/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/ser/ResponseMessageGryoSerializer.java
index 84392a98e4..7eb036b1f6 100644
--- a/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/ser/ResponseMessageGryoSerializer.java
+++ b/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/ser/ResponseMessageGryoSerializer.java
@@ -18,12 +18,12 @@
  */
 package org.apache.tinkerpop.gremlin.util.ser;
 
-import org.apache.tinkerpop.gremlin.util.message.ResponseMessage;
-import org.apache.tinkerpop.gremlin.util.message.ResponseStatusCode;
+import io.netty.handler.codec.http.HttpResponseStatus;
 import org.apache.tinkerpop.gremlin.structure.io.gryo.kryoshim.InputShim;
 import org.apache.tinkerpop.gremlin.structure.io.gryo.kryoshim.KryoShim;
 import org.apache.tinkerpop.gremlin.structure.io.gryo.kryoshim.OutputShim;
 import org.apache.tinkerpop.gremlin.structure.io.gryo.kryoshim.SerializerShim;
+import org.apache.tinkerpop.gremlin.util.message.ResponseMessage;
 
 import java.util.Map;
 import java.util.UUID;
@@ -37,7 +37,7 @@ public class ResponseMessageGryoSerializer implements SerializerShim<ResponseMes
         kryo.writeObjectOrNull(output, responseMessage.getRequestId() != null ? responseMessage.getRequestId() : null, UUID.class);
 
         // status
-        output.writeShort((short) responseMessage.getStatus().getCode().getValue());
+        output.writeShort((short) responseMessage.getStatus().getCode().code());
         output.writeString(responseMessage.getStatus().getMessage());
         kryo.writeClassAndObject(output, responseMessage.getStatus().getAttributes());
 
@@ -57,7 +57,7 @@ public class ResponseMessageGryoSerializer implements SerializerShim<ResponseMes
         final Map<String,Object> metaAttributes = (Map<String,Object>) kryo.readClassAndObject(input);
 
         return ResponseMessage.build(requestId)
-                .code(ResponseStatusCode.getFromValue(status))
+                .code(HttpResponseStatus.valueOf(status))
                 .statusMessage(statusMsg)
                 .statusAttributes(statusAttributes)
                 .result(result)
diff --git a/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/ser/binary/ResponseMessageSerializer.java b/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/ser/binary/ResponseMessageSerializer.java
index f6cc304494..2009726081 100644
--- a/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/ser/binary/ResponseMessageSerializer.java
+++ b/gremlin-util/src/main/java/org/apache/tinkerpop/gremlin/util/ser/binary/ResponseMessageSerializer.java
@@ -19,11 +19,11 @@
 package org.apache.tinkerpop.gremlin.util.ser.binary;
 
 import io.netty.buffer.ByteBuf;
+import io.netty.handler.codec.http.HttpResponseStatus;
 import org.apache.tinkerpop.gremlin.util.ser.NettyBufferFactory;
 import org.apache.tinkerpop.gremlin.util.message.ResponseMessage;
 import org.apache.tinkerpop.gremlin.util.message.ResponseResult;
 import org.apache.tinkerpop.gremlin.util.message.ResponseStatus;
-import org.apache.tinkerpop.gremlin.util.message.ResponseStatusCode;
 import org.apache.tinkerpop.gremlin.util.ser.SerializationException;
 import org.apache.tinkerpop.gremlin.structure.io.Buffer;
 import org.apache.tinkerpop.gremlin.structure.io.binary.GraphBinaryReader;
@@ -49,7 +49,7 @@ public class ResponseMessageSerializer {
 
         try {
             return ResponseMessage.build(context.readValue(buffer, UUID.class, true))
-                    .code(ResponseStatusCode.getFromValue(context.readValue(buffer, Integer.class, false)))
+                    .code(HttpResponseStatus.valueOf(context.readValue(buffer, Integer.class, false)))
                     .statusMessage(context.readValue(buffer, String.class, true))
                     .statusAttributes(context.readValue(buffer, Map.class, false))
                     .responseMetaData(context.readValue(buffer, Map.class, false))
@@ -73,7 +73,7 @@ public class ResponseMessageSerializer {
             // Nullable request id
             context.writeValue(value.getRequestId(), buffer, true);
             // Status code
-            context.writeValue(status.getCode().getValue(), buffer, false);
+            context.writeValue(status.getCode().code(), buffer, false);
             // Nullable status message
             context.writeValue(status.getMessage(), buffer, true);
             // Status attributes
diff --git a/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/structure/io/AbstractTypedCompatibilityTest.java b/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/structure/io/AbstractTypedCompatibilityTest.java
index d0264c4393..bd80313e24 100644
--- a/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/structure/io/AbstractTypedCompatibilityTest.java
+++ b/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/structure/io/AbstractTypedCompatibilityTest.java
@@ -978,14 +978,14 @@ public abstract class AbstractTypedCompatibilityTest extends AbstractCompatibili
     private static void assertResponseMessage(final ResponseMessage resource, final ResponseMessage fromStatic,
                                               final ResponseMessage recycled) {
         assertEquals(resource.getRequestId(), recycled.getRequestId());
-        assertEquals(resource.getStatus().getCode().getValue(), recycled.getStatus().getCode().getValue());
+        assertEquals(resource.getStatus().getCode().code(), recycled.getStatus().getCode().code());
         assertEquals(resource.getStatus().getMessage(), recycled.getStatus().getMessage());
         assertEquals(resource.getStatus().getAttributes(), recycled.getStatus().getAttributes());
         assertEquals(resource.getResult().getData(), recycled.getResult().getData());
         assertEquals(resource.getResult().getMeta(), recycled.getResult().getMeta());
         assertEquals(resource.getStatus().getMessage(), recycled.getStatus().getMessage());
         assertEquals(resource.getRequestId(), fromStatic.getRequestId());
-        assertEquals(resource.getStatus().getCode().getValue(), fromStatic.getStatus().getCode().getValue());
+        assertEquals(resource.getStatus().getCode().code(), fromStatic.getStatus().getCode().code());
         assertEquals(resource.getStatus().getMessage(), fromStatic.getStatus().getMessage());
         assertEquals(resource.getStatus().getAttributes(), fromStatic.getStatus().getAttributes());
         assertEquals(resource.getResult().getData(), fromStatic.getResult().getData());
diff --git a/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/structure/io/AbstractUntypedCompatibilityTest.java b/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/structure/io/AbstractUntypedCompatibilityTest.java
index a607d2a973..14d3bfaaf8 100644
--- a/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/structure/io/AbstractUntypedCompatibilityTest.java
+++ b/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/structure/io/AbstractUntypedCompatibilityTest.java
@@ -18,6 +18,7 @@
  */
 package org.apache.tinkerpop.gremlin.structure.io;
 
+import io.netty.handler.codec.http.HttpResponseStatus;
 import org.apache.tinkerpop.gremlin.process.traversal.Path;
 import org.apache.tinkerpop.gremlin.structure.Edge;
 import org.apache.tinkerpop.gremlin.structure.Property;
@@ -26,7 +27,6 @@ import org.apache.tinkerpop.gremlin.structure.VertexProperty;
 import org.apache.tinkerpop.gremlin.util.iterator.IteratorUtils;
 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.junit.Test;
 
 import java.util.HashMap;
@@ -52,9 +52,9 @@ public abstract class AbstractUntypedCompatibilityTest extends AbstractCompatibi
         assertNotSame(fromStatic, recycled);
         assertEquals(fromStatic, recycled);
         assertEquals(resource.getRequestId().toString(), fromStatic.get("requestId"));
-        assertEquals(ResponseStatusCode.AUTHENTICATE.getValue(), ((Map) fromStatic.get("status")).get("code"));
+        assertEquals(HttpResponseStatus.PROXY_AUTHENTICATION_REQUIRED.code(), ((Map) fromStatic.get("status")).get("code"));
         assertEquals(resource.getRequestId().toString(), recycled.get("requestId"));
-        assertEquals(ResponseStatusCode.AUTHENTICATE.getValue(), ((Map) recycled.get("status")).get("code"));
+        assertEquals(HttpResponseStatus.PROXY_AUTHENTICATION_REQUIRED.code(), ((Map) recycled.get("status")).get("code"));
     }
 
     @Test
@@ -316,7 +316,7 @@ public abstract class AbstractUntypedCompatibilityTest extends AbstractCompatibi
         assertNotSame(fromStatic, recycled);
         assertEquals(fromStatic, recycled);
         assertEquals(resource.getRequestId().toString(), fromStatic.get("requestId"));
-        assertEquals(resource.getStatus().getCode().getValue(), ((Map) fromStatic.get("status")).get("code"));
+        assertEquals(resource.getStatus().getCode().code(), ((Map) fromStatic.get("status")).get("code"));
         assertEquals(resource.getStatus().getMessage(), ((Map) fromStatic.get("status")).get("message"));
         assertEquals(resource.getStatus().getAttributes(), ((Map) fromStatic.get("status")).get("attributes"));
         assertEquals(resource.getResult().getMeta(), ((Map) fromStatic.get("result")).get("meta"));
diff --git a/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/structure/io/Model.java b/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/structure/io/Model.java
index 19969f2760..738efa28d4 100644
--- a/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/structure/io/Model.java
+++ b/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/structure/io/Model.java
@@ -18,6 +18,7 @@
  */
 package org.apache.tinkerpop.gremlin.structure.io;
 
+import io.netty.handler.codec.http.HttpResponseStatus;
 import org.apache.commons.configuration2.BaseConfiguration;
 import org.apache.commons.configuration2.Configuration;
 import org.apache.tinkerpop.gremlin.process.traversal.Bytecode;
@@ -188,10 +189,10 @@ public class Model {
         addRequestMessageEntry(requestMessage, "Sessionless Eval Aliased", "The following `RequestMessage` is an example of a sessionless request for a script evaluation with an alias that binds the `TraversalSource` of \"g\" to \"social\".");
 
         ResponseMessage responseMessage = ResponseMessage.build(UUID.fromString("41d2e28a-20a4-4ab0-b379-d810dede3786")).
-                code(org.apache.tinkerpop.gremlin.util.message.ResponseStatusCode.AUTHENTICATE).create();
+                code(HttpResponseStatus.PROXY_AUTHENTICATION_REQUIRED).create();
         addResponseMessageEntry(responseMessage, "Authentication Challenge", "When authentication is enabled, an initial request to the server will result in an authentication challenge. The typical response message will appear as follows, but handling it could be different depending on the SASL implementation (e.g. multiple challenges maybe requested in some cases, but not in the default provided by Gremlin Server).");
         responseMessage = ResponseMessage.build(UUID.fromString("41d2e28a-20a4-4ab0-b379-d810dede3786")).
-                code(org.apache.tinkerpop.gremlin.util.message.ResponseStatusCode.SUCCESS).
+                code(HttpResponseStatus.OK).
                 result(Collections.singletonList(graph.vertices().next())).create();
         addResponseMessageEntry(responseMessage, "Standard Result", "The following `ResponseMessage` is a typical example of the typical successful response Gremlin Server will return when returning results from a script.");
         
diff --git a/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/message/ResponseStatusCodeTest.java b/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/message/ResponseStatusCodeTest.java
deleted file mode 100644
index ed2697ecff..0000000000
--- a/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/message/ResponseStatusCodeTest.java
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- * 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.message;
-
-import org.junit.Test;
-
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-public class ResponseStatusCodeTest {
-
-    @Test
-    public void shouldIndicateFinalMessagesStatusCodes() {
-        assertFalse(ResponseStatusCode.AUTHENTICATE.isFinalResponse());
-        assertFalse(ResponseStatusCode.PARTIAL_CONTENT.isFinalResponse());
-        assertTrue(ResponseStatusCode.SUCCESS.isFinalResponse());
-        assertTrue(ResponseStatusCode.SERVER_ERROR.isFinalResponse());
-    }
-}
\ No newline at end of file
diff --git a/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONMessageSerializerV1Test.java b/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONMessageSerializerV1Test.java
index c43ba24bed..6e7a1a10f0 100644
--- a/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONMessageSerializerV1Test.java
+++ b/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONMessageSerializerV1Test.java
@@ -21,9 +21,7 @@ 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.util.MessageSerializer;
-import org.apache.tinkerpop.gremlin.util.message.ResponseMessage;
-import org.apache.tinkerpop.gremlin.util.message.ResponseStatusCode;
+import io.netty.handler.codec.http.HttpResponseStatus;
 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
 import org.apache.tinkerpop.gremlin.structure.Edge;
 import org.apache.tinkerpop.gremlin.structure.Graph;
@@ -33,7 +31,9 @@ import org.apache.tinkerpop.gremlin.structure.VertexProperty;
 import org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONTokens;
 import org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerFactory;
 import org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerGraph;
+import org.apache.tinkerpop.gremlin.util.MessageSerializer;
 import org.apache.tinkerpop.gremlin.util.iterator.IteratorUtils;
+import org.apache.tinkerpop.gremlin.util.message.ResponseMessage;
 import org.apache.tinkerpop.shaded.jackson.databind.ObjectMapper;
 import org.apache.tinkerpop.shaded.jackson.databind.util.StdDateFormat;
 import org.junit.Test;
@@ -304,7 +304,7 @@ public class GraphSONMessageSerializerV1Test {
 
         final ResponseMessage response = ResponseMessage.build(id)
                 .responseMetaData(metaData)
-                .code(ResponseStatusCode.SUCCESS)
+                .code(HttpResponseStatus.OK)
                 .result("some-result")
                 .statusAttributes(attributes)
                 .statusMessage("worked")
@@ -319,13 +319,13 @@ public class GraphSONMessageSerializerV1Test {
         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(HttpResponseStatus.OK.code(), deserialized.getStatus().getCode().code());
         assertEquals("worked", deserialized.getStatus().getMessage());
     }
     
     private void assertCommon(final ResponseMessage response) {
         assertEquals(requestId, response.getRequestId());
-        assertEquals(ResponseStatusCode.SUCCESS, response.getStatus().getCode());
+        assertEquals(HttpResponseStatus.OK, response.getStatus().getCode());
     }
 
     private ResponseMessage convert(final Object toSerialize) throws SerializationException {
diff --git a/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONMessageSerializerV2Test.java b/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONMessageSerializerV2Test.java
index 54ce7cd251..906cf0cafc 100644
--- a/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONMessageSerializerV2Test.java
+++ b/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONMessageSerializerV2Test.java
@@ -21,10 +21,7 @@ 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.util.MessageSerializer;
-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 io.netty.handler.codec.http.HttpResponseStatus;
 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;
@@ -43,7 +40,10 @@ import org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONXModuleV2;
 import org.apache.tinkerpop.gremlin.structure.io.graphson.TinkerPopJacksonModule;
 import org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerFactory;
 import org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerGraph;
+import org.apache.tinkerpop.gremlin.util.MessageSerializer;
 import org.apache.tinkerpop.gremlin.util.iterator.IteratorUtils;
+import org.apache.tinkerpop.gremlin.util.message.RequestMessage;
+import org.apache.tinkerpop.gremlin.util.message.ResponseMessage;
 import org.apache.tinkerpop.shaded.jackson.core.JsonGenerationException;
 import org.apache.tinkerpop.shaded.jackson.core.JsonGenerator;
 import org.apache.tinkerpop.shaded.jackson.databind.JsonMappingException;
@@ -55,7 +55,7 @@ import org.apache.tinkerpop.shaded.jackson.databind.ser.std.StdScalarSerializer;
 import org.apache.tinkerpop.shaded.jackson.databind.util.StdDateFormat;
 import org.junit.Test;
 
-import java.awt.Color;
+import java.awt.*;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.util.ArrayList;
@@ -405,7 +405,7 @@ public class GraphSONMessageSerializerV2Test {
 
         final ResponseMessage response = ResponseMessage.build(id)
                 .responseMetaData(metaData)
-                .code(ResponseStatusCode.SUCCESS)
+                .code(HttpResponseStatus.OK)
                 .result("some-result")
                 .statusAttributes(attributes)
                 .statusMessage("worked")
@@ -420,7 +420,7 @@ public class GraphSONMessageSerializerV2Test {
         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(HttpResponseStatus.OK.code(), deserialized.getStatus().getCode().code());
         assertEquals("worked", deserialized.getStatus().getMessage());
     }
     
@@ -530,7 +530,7 @@ public class GraphSONMessageSerializerV2Test {
         final Graph graph = TinkerFactory.createModern();
 
         final ResponseMessage responseMessage = ResponseMessage.build(UUID.fromString("41d2e28a-20a4-4ab0-b379-d810dede3786")).
-                code(org.apache.tinkerpop.gremlin.util.message.ResponseStatusCode.SUCCESS).
+                code(HttpResponseStatus.OK).
                 result(Collections.singletonList(graph.vertices().next())).create();
 
         final String respJson = om.writeValueAsString(responseMessage);
@@ -540,8 +540,7 @@ public class GraphSONMessageSerializerV2Test {
         assertEquals(responseMessage.getResult().getMeta(), responseMessageRead.getResult().getMeta());
         assertEquals(responseMessage.getResult().getData(), responseMessageRead.getResult().getData());
         assertEquals(responseMessage.getStatus().getAttributes(), responseMessageRead.getStatus().getAttributes());
-        assertEquals(responseMessage.getStatus().getCode().getValue(), responseMessageRead.getStatus().getCode().getValue());
-        assertEquals(responseMessage.getStatus().getCode().isSuccess(), responseMessageRead.getStatus().getCode().isSuccess());
+        assertEquals(responseMessage.getStatus().getCode().code(), responseMessageRead.getStatus().getCode().code());
         assertEquals(responseMessage.getStatus().getMessage(), responseMessageRead.getStatus().getMessage());
     }
 
diff --git 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
index ae8b5012ee..c117153522 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
@@ -21,13 +21,8 @@ package org.apache.tinkerpop.gremlin.util.ser;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.ByteBufAllocator;
 import io.netty.buffer.UnpooledByteBufAllocator;
+import io.netty.handler.codec.http.HttpResponseStatus;
 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;
@@ -37,9 +32,14 @@ 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.structure.util.empty.EmptyGraph;
 import org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerFactory;
 import org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerGraph;
+import org.apache.tinkerpop.gremlin.util.MessageSerializer;
+import org.apache.tinkerpop.gremlin.util.Tokens;
 import org.apache.tinkerpop.gremlin.util.iterator.IteratorUtils;
+import org.apache.tinkerpop.gremlin.util.message.RequestMessage;
+import org.apache.tinkerpop.gremlin.util.message.ResponseMessage;
 import org.apache.tinkerpop.shaded.jackson.databind.JsonMappingException;
 import org.junit.Test;
 
@@ -324,7 +324,7 @@ public class GraphSONMessageSerializerV3Test {
 
         final ResponseMessage response = ResponseMessage.build(id)
                 .responseMetaData(metaData)
-                .code(ResponseStatusCode.SUCCESS)
+                .code(HttpResponseStatus.OK)
                 .result("some-result")
                 .statusAttributes(attributes)
                 .statusMessage("worked")
@@ -339,7 +339,7 @@ public class GraphSONMessageSerializerV3Test {
         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(HttpResponseStatus.OK.code(), deserialized.getStatus().getCode().code());
         assertEquals("worked", deserialized.getStatus().getMessage());
     }
 
@@ -406,7 +406,7 @@ public class GraphSONMessageSerializerV3Test {
 
     private void assertCommon(final ResponseMessage response) {
         assertEquals(requestId, response.getRequestId());
-        assertEquals(ResponseStatusCode.SUCCESS, response.getStatus().getCode());
+        assertEquals(HttpResponseStatus.OK, response.getStatus().getCode());
     }
 
     protected ResponseMessage convert(final Object toSerialize, MessageSerializer<?> serializer) throws SerializationException {
diff --git a/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONMessageSerializerV4Test.java b/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONMessageSerializerV4Test.java
index dadcf91da9..3086a08af9 100644
--- a/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONMessageSerializerV4Test.java
+++ b/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONMessageSerializerV4Test.java
@@ -21,9 +21,9 @@ package org.apache.tinkerpop.gremlin.util.ser;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.ByteBufAllocator;
 import io.netty.buffer.UnpooledByteBufAllocator;
+import io.netty.handler.codec.http.HttpResponseStatus;
 import io.netty.util.CharsetUtil;
 import org.apache.tinkerpop.gremlin.util.message.ResponseMessage;
-import org.apache.tinkerpop.gremlin.util.message.ResponseStatusCode;
 import org.apache.tinkerpop.shaded.jackson.core.JsonProcessingException;
 import org.apache.tinkerpop.shaded.jackson.databind.JsonNode;
 import org.apache.tinkerpop.shaded.jackson.databind.ObjectMapper;
@@ -53,7 +53,7 @@ public class GraphSONMessageSerializerV4Test {
 
         final ResponseMessage footer = ResponseMessage.buildV4()
                 .result(Arrays.asList("footer", 3))
-                .code(ResponseStatusCode.SUCCESS)
+                .code(HttpResponseStatus.OK)
                 .statusMessage("OK")
                 .create();
 
@@ -78,7 +78,7 @@ public class GraphSONMessageSerializerV4Test {
         bbCombined.resetReaderIndex();
         final ResponseMessage deserialized = serializer.deserializeResponse(bbCombined);
         assertNull(deserialized.getRequestId());
-        assertEquals(200, deserialized.getStatus().getCode().getValue());
+        assertEquals(200, deserialized.getStatus().getCode().code());
         assertEquals("OK", deserialized.getStatus().getMessage());
         assertEquals(8, ((List)deserialized.getResult().getData()).size());
     }
@@ -86,7 +86,7 @@ public class GraphSONMessageSerializerV4Test {
     @Test
     public void shouldSerializeResponseMessageWithoutData() throws SerializationException, JsonProcessingException {
         final ResponseMessage header = ResponseMessage.buildV4()
-                .code(ResponseStatusCode.SUCCESS)
+                .code(HttpResponseStatus.OK)
                 .statusMessage("OK")
                 .create();
 
@@ -103,7 +103,7 @@ public class GraphSONMessageSerializerV4Test {
         bb0.resetReaderIndex();
         final ResponseMessage deserialized = serializer.deserializeResponse(bb0);
         assertNull(deserialized.getRequestId());
-        assertEquals(200, deserialized.getStatus().getCode().getValue());
+        assertEquals(200, deserialized.getStatus().getCode().code());
         assertEquals("OK", deserialized.getStatus().getMessage());
         assertEquals(0, ((List)deserialized.getResult().getData()).size());
     }
@@ -112,7 +112,7 @@ public class GraphSONMessageSerializerV4Test {
     public void shouldSerializeChunkedResponseMessageWithEmptyData() throws SerializationException, JsonProcessingException {
         final ResponseMessage header = ResponseMessage.buildV4()
                 .result(new ArrayList<>())
-                .code(ResponseStatusCode.SUCCESS)
+                .code(HttpResponseStatus.OK)
                 .statusMessage("OK")
                 .create();
 
@@ -129,7 +129,7 @@ public class GraphSONMessageSerializerV4Test {
         bb0.resetReaderIndex();
         final ResponseMessage deserialized = serializer.deserializeResponse(bb0);
         assertNull(deserialized.getRequestId());
-        assertEquals(200, deserialized.getStatus().getCode().getValue());
+        assertEquals(200, deserialized.getStatus().getCode().code());
         assertEquals("OK", deserialized.getStatus().getMessage());
         assertEquals(0, ((List)deserialized.getResult().getData()).size());
     }
@@ -142,7 +142,7 @@ public class GraphSONMessageSerializerV4Test {
 
         final ResponseMessage footer = ResponseMessage.buildV4()
                 .result(Arrays.asList("footer", 3))
-                .code(ResponseStatusCode.SERVER_ERROR)
+                .code(HttpResponseStatus.INTERNAL_SERVER_ERROR)
                 .statusMessage("SERVER_ERROR")
                 .create();
 
@@ -166,7 +166,7 @@ public class GraphSONMessageSerializerV4Test {
         bbCombined.resetReaderIndex();
         final ResponseMessage deserialized = serializer.deserializeResponse(bbCombined);
         assertNull(deserialized.getRequestId());
-        assertEquals(500, deserialized.getStatus().getCode().getValue());
+        assertEquals(500, deserialized.getStatus().getCode().code());
         assertEquals("SERVER_ERROR", deserialized.getStatus().getMessage());
         assertEquals(6, ((List)deserialized.getResult().getData()).size());
     }
diff --git a/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONUntypedMessageSerializerV1Test.java b/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONUntypedMessageSerializerV1Test.java
index 023b4714d0..fae5e73c13 100644
--- a/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONUntypedMessageSerializerV1Test.java
+++ b/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONUntypedMessageSerializerV1Test.java
@@ -19,9 +19,7 @@
 package org.apache.tinkerpop.gremlin.util.ser;
 
 import io.netty.buffer.ByteBufAllocator;
-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 io.netty.handler.codec.http.HttpResponseStatus;
 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;
@@ -35,6 +33,8 @@ import org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONTokens;
 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.gremlin.util.message.RequestMessage;
+import org.apache.tinkerpop.gremlin.util.message.ResponseMessage;
 import org.apache.tinkerpop.shaded.jackson.core.JsonGenerationException;
 import org.apache.tinkerpop.shaded.jackson.core.JsonGenerator;
 import org.apache.tinkerpop.shaded.jackson.databind.JsonNode;
@@ -389,7 +389,7 @@ public class GraphSONUntypedMessageSerializerV1Test {
 
         final ResponseMessage response = ResponseMessage.build(id)
                 .responseMetaData(metaData)
-                .code(ResponseStatusCode.SUCCESS)
+                .code(HttpResponseStatus.OK)
                 .result("some-result")
                 .statusAttributes(attributes)
                 .statusMessage("worked")
@@ -404,7 +404,7 @@ public class GraphSONUntypedMessageSerializerV1Test {
         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(HttpResponseStatus.OK.code(), deserialized.getStatus().getCode().code());
         assertEquals("worked", deserialized.getStatus().getMessage());
     }
 
@@ -418,7 +418,7 @@ public class GraphSONUntypedMessageSerializerV1Test {
 
         final ResponseMessage response = ResponseMessage.build(id)
                 .responseMetaData(metaData)
-                .code(ResponseStatusCode.SERVER_ERROR)
+                .code(HttpResponseStatus.INTERNAL_SERVER_ERROR)
                 .result("some-result")
                 .statusAttributes(attributes)
                 // explicitly pass the null value
diff --git a/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONUntypedMessageSerializerV2Test.java b/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONUntypedMessageSerializerV2Test.java
index 4eae80ba5a..f933a6e70c 100644
--- a/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONUntypedMessageSerializerV2Test.java
+++ b/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONUntypedMessageSerializerV2Test.java
@@ -18,16 +18,9 @@
  */
 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.structure.io.graphson.AbstractObjectDeserializer;
-import org.apache.tinkerpop.gremlin.util.MessageSerializer;
-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 io.netty.handler.codec.http.HttpResponseStatus;
 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;
@@ -39,6 +32,8 @@ import org.apache.tinkerpop.gremlin.structure.io.graphson.GraphSONTokens;
 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.gremlin.util.message.RequestMessage;
+import org.apache.tinkerpop.gremlin.util.message.ResponseMessage;
 import org.apache.tinkerpop.shaded.jackson.core.JsonGenerationException;
 import org.apache.tinkerpop.shaded.jackson.core.JsonGenerator;
 import org.apache.tinkerpop.shaded.jackson.databind.JsonNode;
@@ -51,15 +46,13 @@ import org.apache.tinkerpop.shaded.jackson.databind.util.StdDateFormat;
 import org.junit.Assert;
 import org.junit.Test;
 
-import java.awt.Color;
+import java.awt.*;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Date;
 import java.util.HashMap;
-import java.util.Iterator;
-import java.util.List;
 import java.util.Map;
 import java.util.UUID;
 
@@ -67,7 +60,6 @@ import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.core.Is.is;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
 import static org.junit.Assert.fail;
 
 /**
@@ -397,7 +389,7 @@ public class GraphSONUntypedMessageSerializerV2Test {
 
         final ResponseMessage response = ResponseMessage.build(id)
                 .responseMetaData(metaData)
-                .code(ResponseStatusCode.SUCCESS)
+                .code(HttpResponseStatus.OK)
                 .result("some-result")
                 .statusAttributes(attributes)
                 .statusMessage("worked")
@@ -412,7 +404,7 @@ public class GraphSONUntypedMessageSerializerV2Test {
         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(HttpResponseStatus.OK.code(), deserialized.getStatus().getCode().code());
         assertEquals("worked", deserialized.getStatus().getMessage());
     }
 
@@ -426,7 +418,7 @@ public class GraphSONUntypedMessageSerializerV2Test {
 
         final ResponseMessage response = ResponseMessage.build(id)
                 .responseMetaData(metaData)
-                .code(ResponseStatusCode.SERVER_ERROR)
+                .code(HttpResponseStatus.INTERNAL_SERVER_ERROR)
                 .result("some-result")
                 .statusAttributes(attributes)
                 // explicitly pass the null value
diff --git a/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONUntypedMessageSerializerV3Test.java b/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONUntypedMessageSerializerV3Test.java
index 65340629b3..ade0299e3d 100644
--- a/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONUntypedMessageSerializerV3Test.java
+++ b/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONUntypedMessageSerializerV3Test.java
@@ -19,6 +19,7 @@
 package org.apache.tinkerpop.gremlin.util.ser;
 
 import io.netty.buffer.ByteBufAllocator;
+import io.netty.handler.codec.http.HttpResponseStatus;
 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
 import org.apache.tinkerpop.gremlin.structure.Edge;
 import org.apache.tinkerpop.gremlin.structure.Graph;
@@ -33,7 +34,6 @@ import org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerGraph;
 import org.apache.tinkerpop.gremlin.util.iterator.IteratorUtils;
 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.shaded.jackson.core.JsonGenerationException;
 import org.apache.tinkerpop.shaded.jackson.core.JsonGenerator;
 import org.apache.tinkerpop.shaded.jackson.databind.JsonNode;
@@ -389,7 +389,7 @@ public class GraphSONUntypedMessageSerializerV3Test {
 
         final ResponseMessage response = ResponseMessage.build(id)
                 .responseMetaData(metaData)
-                .code(ResponseStatusCode.SUCCESS)
+                .code(HttpResponseStatus.OK)
                 .result("some-result")
                 .statusAttributes(attributes)
                 .statusMessage("worked")
@@ -404,7 +404,7 @@ public class GraphSONUntypedMessageSerializerV3Test {
         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(HttpResponseStatus.OK.code(), deserialized.getStatus().getCode().code());
         assertEquals("worked", deserialized.getStatus().getMessage());
     }
 
@@ -418,7 +418,7 @@ public class GraphSONUntypedMessageSerializerV3Test {
 
         final ResponseMessage response = ResponseMessage.build(id)
                 .responseMetaData(metaData)
-                .code(ResponseStatusCode.SERVER_ERROR)
+                .code(HttpResponseStatus.INTERNAL_SERVER_ERROR)
                 .result("some-result")
                 .statusAttributes(attributes)
                 // explicitly pass the null value
diff --git a/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONUntypedMessageSerializerV4Test.java b/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONUntypedMessageSerializerV4Test.java
index 4a48ca6f12..9ffb9e0aeb 100644
--- a/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONUntypedMessageSerializerV4Test.java
+++ b/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/GraphSONUntypedMessageSerializerV4Test.java
@@ -21,10 +21,9 @@ package org.apache.tinkerpop.gremlin.util.ser;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.ByteBufAllocator;
 import io.netty.buffer.UnpooledByteBufAllocator;
+import io.netty.handler.codec.http.HttpResponseStatus;
 import io.netty.util.CharsetUtil;
-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.shaded.jackson.core.JsonProcessingException;
 import org.apache.tinkerpop.shaded.jackson.databind.JsonNode;
 import org.apache.tinkerpop.shaded.jackson.databind.ObjectMapper;
@@ -33,7 +32,6 @@ import org.junit.Test;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
-import java.util.UUID;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
@@ -53,7 +51,7 @@ public class GraphSONUntypedMessageSerializerV4Test {
 
         final ResponseMessage footer = ResponseMessage.buildV4()
                 .result(Arrays.asList("footer", 3))
-                .code(ResponseStatusCode.SUCCESS)
+                .code(HttpResponseStatus.OK)
                 .statusMessage("OK")
                 .create();
 
@@ -78,7 +76,7 @@ public class GraphSONUntypedMessageSerializerV4Test {
         bbCombined.resetReaderIndex();
         final ResponseMessage deserialized = serializer.deserializeResponse(bbCombined);
         assertNull(deserialized.getRequestId());
-        assertEquals(200, deserialized.getStatus().getCode().getValue());
+        assertEquals(200, deserialized.getStatus().getCode().code());
         assertEquals("OK", deserialized.getStatus().getMessage());
         assertEquals(8, ((List)deserialized.getResult().getData()).size());
     }
@@ -86,7 +84,7 @@ public class GraphSONUntypedMessageSerializerV4Test {
     @Test
     public void shouldSerializeResponseMessageWithoutData() throws SerializationException, JsonProcessingException {
         final ResponseMessage header = ResponseMessage.buildV4()
-                .code(ResponseStatusCode.SUCCESS)
+                .code(HttpResponseStatus.OK)
                 .statusMessage("OK")
                 .create();
 
@@ -103,7 +101,7 @@ public class GraphSONUntypedMessageSerializerV4Test {
         bb0.resetReaderIndex();
         final ResponseMessage deserialized = serializer.deserializeResponse(bb0);
         assertNull(deserialized.getRequestId());
-        assertEquals(200, deserialized.getStatus().getCode().getValue());
+        assertEquals(200, deserialized.getStatus().getCode().code());
         assertEquals("OK", deserialized.getStatus().getMessage());
         assertEquals(0, ((List)deserialized.getResult().getData()).size());
     }
@@ -112,7 +110,7 @@ public class GraphSONUntypedMessageSerializerV4Test {
     public void shouldSerializeChunkedResponseMessageWithEmptyData() throws SerializationException, JsonProcessingException {
         final ResponseMessage header = ResponseMessage.buildV4()
                 .result(new ArrayList<>())
-                .code(ResponseStatusCode.SUCCESS)
+                .code(HttpResponseStatus.OK)
                 .statusMessage("OK")
                 .create();
 
@@ -129,7 +127,7 @@ public class GraphSONUntypedMessageSerializerV4Test {
         bb0.resetReaderIndex();
         final ResponseMessage deserialized = serializer.deserializeResponse(bb0);
         assertNull(deserialized.getRequestId());
-        assertEquals(200, deserialized.getStatus().getCode().getValue());
+        assertEquals(200, deserialized.getStatus().getCode().code());
         assertEquals("OK", deserialized.getStatus().getMessage());
         assertEquals(0, ((List)deserialized.getResult().getData()).size());
     }
@@ -142,7 +140,7 @@ public class GraphSONUntypedMessageSerializerV4Test {
 
         final ResponseMessage footer = ResponseMessage.buildV4()
                 .result(Arrays.asList("footer", 3))
-                .code(ResponseStatusCode.SERVER_ERROR)
+                .code(HttpResponseStatus.INTERNAL_SERVER_ERROR)
                 .statusMessage("SERVER_ERROR")
                 .create();
 
@@ -166,7 +164,7 @@ public class GraphSONUntypedMessageSerializerV4Test {
         bbCombined.resetReaderIndex();
         final ResponseMessage deserialized = serializer.deserializeResponse(bbCombined);
         assertNull(deserialized.getRequestId());
-        assertEquals(500, deserialized.getStatus().getCode().getValue());
+        assertEquals(500, deserialized.getStatus().getCode().code());
         assertEquals("SERVER_ERROR", deserialized.getStatus().getMessage());
         assertEquals(6, ((List)deserialized.getResult().getData()).size());
     }
diff --git 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
index 09bc419701..e6205cadf3 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
@@ -20,12 +20,12 @@ package org.apache.tinkerpop.gremlin.util.ser.binary;
 
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.ByteBufAllocator;
+import io.netty.handler.codec.http.HttpResponseStatus;
 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;
@@ -118,7 +118,7 @@ public class GraphBinaryMessageSerializerV1Test {
     @Test
     public void shouldSerializeAndDeserializeResponse() throws SerializationException {
         final ResponseMessage response = ResponseMessage.build(UUID.randomUUID())
-                .code(ResponseStatusCode.SUCCESS)
+                .code(HttpResponseStatus.OK)
                 .statusMessage("Found")
                 .statusAttribute("k1", 1)
                 .result("This is a fine message with a string")
@@ -132,7 +132,7 @@ public class GraphBinaryMessageSerializerV1Test {
     @Test
     public void shouldSerializeAndDeserializeResponseOverText() throws SerializationException {
         final ResponseMessage response = ResponseMessage.build(UUID.randomUUID())
-                .code(ResponseStatusCode.SUCCESS)
+                .code(HttpResponseStatus.OK)
                 .statusMessage("Found")
                 .statusAttribute("k1", 1)
                 .result("This is a fine message with a string")
@@ -146,7 +146,7 @@ public class GraphBinaryMessageSerializerV1Test {
     @Test
     public void shouldSerializeAndDeserializeResponseWithoutStatusMessage() throws SerializationException {
         final ResponseMessage response = ResponseMessage.build(UUID.randomUUID())
-                .code(ResponseStatusCode.SUCCESS)
+                .code(HttpResponseStatus.OK)
                 .statusAttribute("k1", 1)
                 .result(123.3)
                 .create();
@@ -159,7 +159,7 @@ public class GraphBinaryMessageSerializerV1Test {
     @Test
     public void shouldSerializeAndDeserializeResponseWithoutStatusAttributes() throws SerializationException {
         final ResponseMessage response = ResponseMessage.build(UUID.randomUUID())
-                .code(ResponseStatusCode.SUCCESS)
+                .code(HttpResponseStatus.OK)
                 .result(123.3)
                 .create();
 
@@ -171,7 +171,7 @@ public class GraphBinaryMessageSerializerV1Test {
     @Test
     public void shouldSerializeAndDeserializeResponseWithoutResult() throws SerializationException {
         final ResponseMessage response = ResponseMessage.build(UUID.randomUUID())
-                .code(ResponseStatusCode.SERVER_ERROR)
+                .code(HttpResponseStatus.INTERNAL_SERVER_ERROR)
                 .statusMessage("Something happened on the server")
                 .create();
 
diff --git a/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/binary/GraphBinaryMessageSerializerV4Test.java b/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/binary/GraphBinaryMessageSerializerV4Test.java
index f73a1d825f..9a4dc0bc72 100644
--- a/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/binary/GraphBinaryMessageSerializerV4Test.java
+++ b/gremlin-util/src/test/java/org/apache/tinkerpop/gremlin/util/ser/binary/GraphBinaryMessageSerializerV4Test.java
@@ -20,8 +20,8 @@ package org.apache.tinkerpop.gremlin.util.ser.binary;
 
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.ByteBufAllocator;
+import io.netty.handler.codec.http.HttpResponseStatus;
 import org.apache.tinkerpop.gremlin.util.message.ResponseMessage;
-import org.apache.tinkerpop.gremlin.util.message.ResponseStatusCode;
 import org.apache.tinkerpop.gremlin.util.ser.GraphBinaryMessageSerializerV4;
 import org.apache.tinkerpop.gremlin.util.ser.SerializationException;
 import org.junit.Test;
@@ -43,7 +43,7 @@ public class GraphBinaryMessageSerializerV4Test {
     @Test
     public void shouldSerializeAndDeserializeResponseInSingleChunk() throws SerializationException {
         final ResponseMessage response = ResponseMessage.build(UUID.randomUUID())
-                .code(ResponseStatusCode.SUCCESS)
+                .code(HttpResponseStatus.OK)
                 .statusMessage("OK")
                 .result(Arrays.asList(1, "test"))
                 .create();
@@ -77,7 +77,7 @@ public class GraphBinaryMessageSerializerV4Test {
     public void shouldSerializeAndDeserializeResponseInFooterChunk() throws SerializationException {
         final ResponseMessage response = ResponseMessage.build()
                 .result(Arrays.asList(1, "test"))
-                .code(ResponseStatusCode.SUCCESS)
+                .code(HttpResponseStatus.OK)
                 .statusMessage("OK")
                 .create();
 
@@ -89,7 +89,7 @@ public class GraphBinaryMessageSerializerV4Test {
     @Test
     public void shouldSerializeAndDeserializeErrorResponseWithEmptyData() throws SerializationException {
         final ResponseMessage response = ResponseMessage.build(UUID.randomUUID())
-                .code(ResponseStatusCode.FORBIDDEN)
+                .code(HttpResponseStatus.FORBIDDEN)
                 .statusMessage("FORBIDDEN")
                 .create();
 
@@ -111,7 +111,7 @@ public class GraphBinaryMessageSerializerV4Test {
         final List footerData = Arrays.asList(0xFF, "footer");
         final ResponseMessage footer = ResponseMessage.build()
                 .result(footerData)
-                .code(ResponseStatusCode.SUCCESS)
+                .code(HttpResponseStatus.OK)
                 .statusMessage("OK")
                 .create();
 
@@ -147,7 +147,7 @@ public class GraphBinaryMessageSerializerV4Test {
         final List footerData = Arrays.asList(0xFF, "footer");
         final ResponseMessage footer = ResponseMessage.build()
                 .result(footerData)
-                .code(ResponseStatusCode.SERVER_ERROR)
+                .code(HttpResponseStatus.INTERNAL_SERVER_ERROR)
                 .statusMessage("SERVER_ERROR")
                 .exception("fire in data center")
                 .create();