This is an automated email from the ASF dual-hosted git repository.
colegreer pushed a commit to branch 3.8-dev
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git
The following commit(s) were added to refs/heads/3.8-dev by this push:
new 0833258a5a TINKERPOP-3219 Expose serialization functions for
alternative transport protocols in gremlin-go (#3285)
0833258a5a is described below
commit 0833258a5a4e0adca632b46a700d2a9051a67a44
Author: DR1N0 <[email protected]>
AuthorDate: Tue Jan 13 04:03:41 2026 +0800
TINKERPOP-3219 Expose serialization functions for alternative transport
protocols in gremlin-go (#3285)
These changes expose existing internal serialization functions by making
them public, bringing gremlin-go in line with other GLVs (Python, .NET,
JavaScript) that already expose their serialization layers.
Functions Made Public
In request.go:
- MakeBytecodeRequest() - Creates a request from bytecode (formerly
makeBytecodeRequest)
- MakeStringRequest() - Creates a request from string query (formerly
makeStringRequest)
In serializer.go:
- SerializeMessage() - Serializes request to GraphBinary format
(formerly serializeMessage)
- DeserializeMessage() - Deserializes GraphBinary to response (formerly
deserializeMessage)
- And also the Serializer interface for completeness
Types Made Public
To enable usage of the serialization functions, the following types and
their fields were made public:
Request handling:
- GraphBinarySerializer - The serializer implementation
Response handling:
- Response - Response structure with exported fields
- ResponseStatus - Status information (code, message, attributes)
- ResponseResult - Result data and metadata
This ensures users can create requests, serialize them, deserialize
responses, and access the result data.
New Functions
- NewResultSet(requestID, results) - Creates ResultSet from collected
results
---------
Co-authored-by: haiyuwang <[email protected]>
---
CHANGELOG.asciidoc | 4 +-
gremlin-go/driver/client.go | 4 +-
gremlin-go/driver/connection_test.go | 8 ++--
gremlin-go/driver/protocol.go | 18 ++++----
gremlin-go/driver/request.go | 46 ++++++++++++++++++++-
gremlin-go/driver/request_test.go | 13 +++---
gremlin-go/driver/response.go | 22 +++++-----
gremlin-go/driver/resultSet.go | 46 +++++++++++++++++++++
gremlin-go/driver/serializer.go | 80 ++++++++++++++++++++++++++----------
gremlin-go/driver/serializer_test.go | 34 +++++++--------
10 files changed, 201 insertions(+), 74 deletions(-)
diff --git a/CHANGELOG.asciidoc b/CHANGELOG.asciidoc
index c563199aa8..27c1e7673e 100644
--- a/CHANGELOG.asciidoc
+++ b/CHANGELOG.asciidoc
@@ -23,10 +23,10 @@
image::https://raw.githubusercontent.com/apache/tinkerpop/master/docs/static/ima
[[release-3-8-1]]
=== TinkerPop 3.8.1 (NOT OFFICIALLY RELEASED YET)
-* Fixed bug in pre-repeat() `emit()/until()` where `emit()` and `until()`
traversers weren't added to the results.
-
This release also includes changes from <<release-3-7-6, 3.7.6>>.
+* Fixed bug in pre-repeat() `emit()/until()` where `emit()` and `until()`
traversers weren't added to the results.
+* Expose serialization functions for alternative transport protocols in
gremlin-go
* Improved Gremlint formatting to keep the first argument for a step on the
same line if line breaks were required to meet max line length.
* Improved Gremlint formatting to do greedy argument packing when possible so
that more arguments can appear on a single line.
diff --git a/gremlin-go/driver/client.go b/gremlin-go/driver/client.go
index c484914f9d..705330192f 100644
--- a/gremlin-go/driver/client.go
+++ b/gremlin-go/driver/client.go
@@ -149,7 +149,7 @@ func (client *Client) Close() {
// SubmitWithOptions submits a Gremlin script to the server with specified
RequestOptions and returns a ResultSet.
func (client *Client) SubmitWithOptions(traversalString string, requestOptions
RequestOptions) (ResultSet, error) {
client.logHandler.logf(Debug, submitStartedString, traversalString)
- request := makeStringRequest(traversalString, client.traversalSource,
client.session, requestOptions)
+ request := MakeStringRequest(traversalString, client.traversalSource,
client.session, requestOptions)
result, err := client.connections.write(&request)
if err != nil {
client.logHandler.logf(Error, logErrorGeneric,
"Client.Submit()", err.Error())
@@ -171,7 +171,7 @@ func (client *Client) Submit(traversalString string,
bindings ...map[string]inte
// submitBytecode submits Bytecode to the server to execute and returns a
ResultSet.
func (client *Client) submitBytecode(bytecode *Bytecode) (ResultSet, error) {
client.logHandler.logf(Debug, submitStartedBytecode, *bytecode)
- request := makeBytecodeRequest(bytecode, client.traversalSource,
client.session)
+ request := MakeBytecodeRequest(bytecode, client.traversalSource,
client.session)
return client.connections.write(&request)
}
diff --git a/gremlin-go/driver/connection_test.go
b/gremlin-go/driver/connection_test.go
index 153084dbb7..fa9cc0381e 100644
--- a/gremlin-go/driver/connection_test.go
+++ b/gremlin-go/driver/connection_test.go
@@ -382,7 +382,7 @@ func TestConnection(t *testing.T) {
assert.NotNil(t, connection)
assert.Equal(t, established, connection.state)
defer deferredCleanup(t, connection)
- request := makeStringRequest("g.V().count()", "g", "",
*new(RequestOptions))
+ request := MakeStringRequest("g.V().count()", "g", "",
*new(RequestOptions))
resultSet, err := connection.write(&request)
assert.Nil(t, err)
assert.NotNil(t, resultSet)
@@ -400,7 +400,7 @@ func TestConnection(t *testing.T) {
assert.NotNil(t, connection)
assert.Equal(t, established, connection.state)
defer deferredCleanup(t, connection)
- request := makeStringRequest("g.V().count()", "g", "",
*new(RequestOptions))
+ request := MakeStringRequest("g.V().count()", "g", "",
*new(RequestOptions))
resultSet, err := connection.write(&request)
assert.Nil(t, err)
assert.NotNil(t, resultSet)
@@ -436,7 +436,7 @@ func TestConnection(t *testing.T) {
err = connection.close()
assert.Nil(t, err)
assert.Equal(t, closed, connection.state)
- request := makeStringRequest("g.V().count()", "g", "",
*new(RequestOptions))
+ request := MakeStringRequest("g.V().count()", "g", "",
*new(RequestOptions))
resultSet, err := connection.write(&request)
assert.Nil(t, resultSet)
assert.Equal(t, newError(err0102WriteConnectionClosedError),
err)
@@ -452,7 +452,7 @@ func TestConnection(t *testing.T) {
assert.Equal(t, established, connection.state)
assert.Nil(t, err)
time.Sleep(120 * time.Second)
- request := makeStringRequest("g.V().count()", "g", "",
*new(RequestOptions))
+ request := MakeStringRequest("g.V().count()", "g", "",
*new(RequestOptions))
resultSet, err := connection.write(&request)
assert.Nil(t, resultSet)
assert.NotNil(t, err)
diff --git a/gremlin-go/driver/protocol.go b/gremlin-go/driver/protocol.go
index da44bb7807..1a5a8e3df1 100644
--- a/gremlin-go/driver/protocol.go
+++ b/gremlin-go/driver/protocol.go
@@ -44,7 +44,7 @@ type protocolBase struct {
type gremlinServerWSProtocol struct {
*protocolBase
- serializer serializer
+ serializer Serializer
logHandler *logHandler
closed bool
mutex sync.Mutex
@@ -72,7 +72,7 @@ func (protocol *gremlinServerWSProtocol) readLoop(resultSets
*synchronizedMap, e
}
// Deserialize message and unpack.
- resp, err := protocol.serializer.deserializeMessage(msg)
+ resp, err := protocol.serializer.DeserializeMessage(msg)
if err != nil {
protocol.logHandler.logf(Error, logErrorGeneric,
"gremlinServerWSProtocol.readLoop()", err.Error())
readErrorHandler(resultSets, errorCallback, err,
protocol.logHandler)
@@ -94,9 +94,9 @@ func readErrorHandler(resultSets *synchronizedMap,
errorCallback func(), err err
errorCallback()
}
-func (protocol *gremlinServerWSProtocol) responseHandler(resultSets
*synchronizedMap, response response) error {
- responseID, statusCode, metadata, data := response.responseID,
response.responseStatus.code,
- response.responseResult.meta, response.responseResult.data
+func (protocol *gremlinServerWSProtocol) responseHandler(resultSets
*synchronizedMap, response Response) error {
+ responseID, statusCode, metadata, data := response.ResponseID,
response.ResponseStatus.code,
+ response.ResponseResult.Meta, response.ResponseResult.Data
responseIDString := responseID.String()
if resultSets.load(responseIDString) == nil {
return newError(err0501ResponseHandlerResultSetNotCreatedError)
@@ -113,7 +113,7 @@ func (protocol *gremlinServerWSProtocol)
responseHandler(resultSets *synchronize
} else if statusCode == http.StatusOK {
// Add data and status attributes to the ResultSet.
resultSets.load(responseIDString).addResult(&Result{data})
-
resultSets.load(responseIDString).setStatusAttributes(response.responseStatus.attributes)
+
resultSets.load(responseIDString).setStatusAttributes(response.ResponseStatus.attributes)
resultSets.load(responseIDString).Close()
protocol.logHandler.logf(Debug, readComplete, responseIDString)
} else if statusCode == http.StatusPartialContent {
@@ -137,10 +137,10 @@ func (protocol *gremlinServerWSProtocol)
responseHandler(resultSets *synchronize
}
} else {
resultSets.load(responseIDString).Close()
- return newError(err0503ResponseHandlerAuthError,
response.responseStatus, response.responseResult)
+ return newError(err0503ResponseHandlerAuthError,
response.ResponseStatus, response.ResponseResult)
}
} else {
- newError := newError(err0502ResponseHandlerReadLoopError,
response.responseStatus, statusCode)
+ newError := newError(err0502ResponseHandlerReadLoopError,
response.ResponseStatus, statusCode)
resultSets.load(responseIDString).setError(newError)
resultSets.load(responseIDString).Close()
protocol.logHandler.logf(Error, logErrorGeneric,
"gremlinServerWSProtocol.responseHandler()", newError.Error())
@@ -149,7 +149,7 @@ func (protocol *gremlinServerWSProtocol)
responseHandler(resultSets *synchronize
}
func (protocol *gremlinServerWSProtocol) write(request *request) error {
- bytes, err := protocol.serializer.serializeMessage(request)
+ bytes, err := protocol.serializer.SerializeMessage(request)
if err != nil {
return err
}
diff --git a/gremlin-go/driver/request.go b/gremlin-go/driver/request.go
index 31a57ef8cd..436a8a39fd 100644
--- a/gremlin-go/driver/request.go
+++ b/gremlin-go/driver/request.go
@@ -36,7 +36,28 @@ const sessionProcessor = "session"
const stringOp = "eval"
const stringProcessor = ""
-func makeStringRequest(stringGremlin string, traversalSource string, sessionId
string, requestOptions RequestOptions) (req request) {
+// MakeStringRequest creates a request from a Gremlin string query for
submission to a Gremlin server.
+//
+// This function is exposed publicly to enable alternative transport protocols
(gRPC, HTTP/2, etc.)
+// to construct properly formatted requests outside the standard WebSocket
client. The returned
+// request can then be serialized using SerializeMessage().
+//
+// Parameters:
+// - stringGremlin: The Gremlin query string to execute
+// - traversalSource: The name of the traversal source (typically "g")
+// - sessionId: Optional session ID for stateful requests (use "" for
stateless)
+// - requestOptions: Options such as bindings, timeout, batch size, etc.
+//
+// Returns:
+// - request: A request structure ready for serialization
+//
+// Example for alternative transports:
+//
+// req := MakeStringRequest("g.V().count()", "g", "", RequestOptions{})
+// serializer := newGraphBinarySerializer(nil)
+// bytes, _ := serializer.(graphBinarySerializer).SerializeMessage(&req)
+// // Send bytes over gRPC, HTTP/2, etc.
+func MakeStringRequest(stringGremlin string, traversalSource string, sessionId
string, requestOptions RequestOptions) (req request) {
newProcessor := stringProcessor
newArgs := map[string]interface{}{
"gremlin": stringGremlin,
@@ -88,7 +109,28 @@ const bytecodeProcessor = "traversal"
const authOp = "authentication"
const authProcessor = "traversal"
-func makeBytecodeRequest(bytecodeGremlin *Bytecode, traversalSource string,
sessionId string) (req request) {
+// MakeBytecodeRequest creates a request from Gremlin bytecode for submission
to a Gremlin server.
+//
+// This function is exposed publicly to enable alternative transport protocols
(gRPC, HTTP/2, etc.)
+// to construct properly formatted requests outside the standard WebSocket
client. The returned
+// request can then be serialized using SerializeMessage().
+//
+// Parameters:
+// - bytecodeGremlin: The Gremlin bytecode to execute
+// - traversalSource: The name of the traversal source (typically "g")
+// - sessionId: Optional session ID for stateful requests (use "" for
stateless)
+//
+// Returns:
+// - request: A request structure ready for serialization
+//
+// Example for alternative transports:
+//
+// bytecode := g.V().HasLabel("person").Bytecode
+// req := MakeBytecodeRequest(bytecode, "g", "")
+// serializer := newGraphBinarySerializer(nil)
+// bytes, _ := serializer.(graphBinarySerializer).SerializeMessage(&req)
+// // Send bytes over gRPC, HTTP/2, etc.
+func MakeBytecodeRequest(bytecodeGremlin *Bytecode, traversalSource string,
sessionId string) (req request) {
newProcessor := bytecodeProcessor
newArgs := map[string]interface{}{
"gremlin": *bytecodeGremlin,
diff --git a/gremlin-go/driver/request_test.go
b/gremlin-go/driver/request_test.go
index c388a1273e..e20a5a06de 100644
--- a/gremlin-go/driver/request_test.go
+++ b/gremlin-go/driver/request_test.go
@@ -20,28 +20,29 @@ under the License.
package gremlingo
import (
- "github.com/google/uuid"
"testing"
+ "github.com/google/uuid"
+
"github.com/stretchr/testify/assert"
)
func TestRequest(t *testing.T) {
t.Run("Test makeStringRequest() with custom requestID", func(t
*testing.T) {
requestId := uuid.New()
- r := makeStringRequest("g.V()", "g", "",
+ r := MakeStringRequest("g.V()", "g", "",
new(RequestOptionsBuilder).SetRequestId(requestId).Create())
assert.Equal(t, requestId, r.requestID)
})
t.Run("Test makeStringRequest() with no bindings", func(t *testing.T) {
- r := makeStringRequest("g.V()", "g", "", *new(RequestOptions))
+ r := MakeStringRequest("g.V()", "g", "", *new(RequestOptions))
assert.NotNil(t, r.requestID)
assert.NotEqual(t, uuid.Nil, r.requestID)
})
t.Run("Test makeStringRequest() with custom evaluationTimeout", func(t
*testing.T) {
- r := makeStringRequest("g.V()", "g", "",
+ r := MakeStringRequest("g.V()", "g", "",
new(RequestOptionsBuilder).SetEvaluationTimeout(1234).Create())
assert.NotNil(t, r.requestID)
assert.NotEqual(t, uuid.Nil, r.requestID)
@@ -49,7 +50,7 @@ func TestRequest(t *testing.T) {
})
t.Run("Test makeStringRequest() with custom batchSize", func(t
*testing.T) {
- r := makeStringRequest("g.V()", "g", "",
+ r := MakeStringRequest("g.V()", "g", "",
new(RequestOptionsBuilder).SetBatchSize(123).Create())
assert.NotNil(t, r.requestID)
assert.NotEqual(t, uuid.Nil, r.requestID)
@@ -57,7 +58,7 @@ func TestRequest(t *testing.T) {
})
t.Run("Test makeStringRequest() with custom userAgent", func(t
*testing.T) {
- r := makeStringRequest("g.V()", "g", "",
+ r := MakeStringRequest("g.V()", "g", "",
new(RequestOptionsBuilder).SetUserAgent("TestUserAgent").Create())
assert.NotNil(t, r.requestID)
assert.NotEqual(t, uuid.Nil, r.requestID)
diff --git a/gremlin-go/driver/response.go b/gremlin-go/driver/response.go
index 67430116ba..6eadf351b5 100644
--- a/gremlin-go/driver/response.go
+++ b/gremlin-go/driver/response.go
@@ -21,22 +21,22 @@ package gremlingo
import "github.com/google/uuid"
-// responseStatus contains the status info of the response.
-type responseStatus struct {
+// ResponseStatus contains the status info of the response.
+type ResponseStatus struct {
code uint16
message string
attributes map[string]interface{}
}
-// responseResult contains the result info of the response.
-type responseResult struct {
- meta map[string]interface{}
- data interface{}
+// ResponseResult contains the result info of the response.
+type ResponseResult struct {
+ Meta map[string]interface{}
+ Data interface{}
}
-// response represents a response from the server.
-type response struct {
- responseID uuid.UUID
- responseStatus responseStatus
- responseResult responseResult
+// Response represents a Response from the server.
+type Response struct {
+ ResponseID uuid.UUID
+ ResponseStatus ResponseStatus
+ ResponseResult ResponseResult
}
diff --git a/gremlin-go/driver/resultSet.go b/gremlin-go/driver/resultSet.go
index 73269deddd..6472880b77 100644
--- a/gremlin-go/driver/resultSet.go
+++ b/gremlin-go/driver/resultSet.go
@@ -211,3 +211,49 @@ func newChannelResultSetCapacity(requestID string,
container *synchronizedMap, c
func newChannelResultSet(requestID string, container *synchronizedMap)
ResultSet {
return newChannelResultSetCapacity(requestID, container,
defaultCapacity)
}
+
+// NewResultSet creates a new ResultSet from a slice of Result objects.
+// This function enables custom transport implementations to create ResultSets
from
+// results collected via alternative protocols.
+//
+// The function creates a channel-based ResultSet, pre-populates it with the
provided results,
+// and closes the channel to indicate completion.
+//
+// Parameters:
+// - requestID: The request identifier for this ResultSet
+// - results: A slice of Result objects to include in the ResultSet
+//
+// Returns:
+// - ResultSet: A ResultSet containing all the provided results
+//
+// Example usage:
+//
+// var results []*Result
+// // Collect results from custom transport
+// for _, responseBytes := range responses {
+// result, _ := DeserializeResult(responseBytes)
+// results = append(results, result)
+// }
+// resultSet := NewResultSet("request-123", results)
+// allResults, _ := resultSet.All()
+func NewResultSet(requestID string, results []*Result) ResultSet {
+ // Create a channel-based result set with capacity for all results
+ channelSize := len(results)
+ if channelSize == 0 {
+ channelSize = 1 // Ensure at least size 1
+ }
+ rs := newChannelResultSetCapacity(requestID,
&synchronizedMap{make(map[string]ResultSet), sync.Mutex{}},
channelSize).(*channelResultSet)
+
+ // Add all results to the channel
+ for _, result := range results {
+ rs.channel <- result
+ }
+
+ // Close the channel to indicate no more results
+ rs.channelMutex.Lock()
+ rs.closed = true
+ close(rs.channel)
+ rs.channelMutex.Unlock()
+
+ return rs
+}
diff --git a/gremlin-go/driver/serializer.go b/gremlin-go/driver/serializer.go
index 52034c7a0d..28f1c0ff07 100644
--- a/gremlin-go/driver/serializer.go
+++ b/gremlin-go/driver/serializer.go
@@ -32,14 +32,14 @@ import (
const graphBinaryMimeType = "application/vnd.graphbinary-v1.0"
-// serializer interface for serializers.
-type serializer interface {
- serializeMessage(request *request) ([]byte, error)
- deserializeMessage(message []byte) (response, error)
+// Serializer interface for serializers.
+type Serializer interface {
+ SerializeMessage(request *request) ([]byte, error)
+ DeserializeMessage(message []byte) (Response, error)
}
-// graphBinarySerializer serializes/deserializes message to/from GraphBinary.
-type graphBinarySerializer struct {
+// GraphBinarySerializer serializes/deserializes message to/from GraphBinary.
+type GraphBinarySerializer struct {
ser *graphBinaryTypeSerializer
}
@@ -61,14 +61,14 @@ func init() {
initDeserializers()
}
-func newGraphBinarySerializer(handler *logHandler) serializer {
+func newGraphBinarySerializer(handler *logHandler) Serializer {
serializer := graphBinaryTypeSerializer{handler}
- return graphBinarySerializer{&serializer}
+ return GraphBinarySerializer{&serializer}
}
const versionByte byte = 0x81
-func convertArgs(request *request, gs graphBinarySerializer)
(map[string]interface{}, error) {
+func convertArgs(request *request, gs GraphBinarySerializer)
(map[string]interface{}, error) {
if request.op != bytecodeProcessor {
return request.args, nil
}
@@ -95,8 +95,28 @@ func convertArgs(request *request, gs graphBinarySerializer)
(map[string]interfa
}
}
-// serializeMessage serializes a request message into GraphBinary.
-func (gs graphBinarySerializer) serializeMessage(request *request) ([]byte,
error) {
+// SerializeMessage serializes a request message into GraphBinary format.
+//
+// This method is part of the serializer interface and is used internally by
the WebSocket driver.
+// It is also exposed publicly to enable alternative transport protocols
(gRPC, HTTP/2, etc.) to
+// serialize requests created with MakeBytecodeRequest() or
MakeStringRequest().
+//
+// The serialized bytes can be transmitted over any transport protocol that
supports binary data.
+//
+// Parameters:
+// - request: The request to serialize (created via MakeBytecodeRequest or
MakeStringRequest)
+//
+// Returns:
+// - []byte: The GraphBinary-encoded request ready for transmission
+// - error: Any serialization error encountered
+//
+// Example for alternative transports:
+//
+// req := MakeBytecodeRequest(bytecode, "g", "")
+// serializer := newGraphBinarySerializer(nil)
+// bytes, err := serializer.(graphBinarySerializer).SerializeMessage(&req)
+// // Send bytes over custom transport
+func (gs GraphBinarySerializer) SerializeMessage(request *request) ([]byte,
error) {
args, err := convertArgs(request, gs)
if err != nil {
return nil, err
@@ -108,7 +128,7 @@ func (gs graphBinarySerializer) serializeMessage(request
*request) ([]byte, erro
return finalMessage, nil
}
-func (gs *graphBinarySerializer) buildMessage(id uuid.UUID, mimeLen byte, op
string, processor string, args map[string]interface{}) ([]byte, error) {
+func (gs *GraphBinarySerializer) buildMessage(id uuid.UUID, mimeLen byte, op
string, processor string, args map[string]interface{}) ([]byte, error) {
buffer := bytes.Buffer{}
// mime header
@@ -184,9 +204,27 @@ func uuidToBigInt(requestID uuid.UUID) big.Int {
return bigInt
}
-// deserializeMessage deserializes a response message.
-func (gs graphBinarySerializer) deserializeMessage(message []byte) (response,
error) {
- var msg response
+// DeserializeMessage deserializes a GraphBinary-encoded response message.
+//
+// This method is part of the serializer interface and is used internally by
the WebSocket driver.
+// It is also exposed publicly to enable alternative transport protocols
(gRPC, HTTP/2, etc.) to
+// deserialize responses received from a Gremlin server.
+//
+// Parameters:
+// - message: The GraphBinary-encoded response bytes
+//
+// Returns:
+// - response: The deserialized response containing results and metadata
+// - error: Any deserialization error encountered
+//
+// Example for alternative transports:
+//
+// // Receive bytes from custom transport
+// serializer := newGraphBinarySerializer(nil)
+// resp, err :=
serializer.(graphBinarySerializer).DeserializeMessage(responseBytes)
+// results := resp.responseResult.data
+func (gs GraphBinarySerializer) DeserializeMessage(message []byte) (Response,
error) {
+ var msg Response
if message == nil || len(message) == 0 {
gs.ser.logHandler.log(Error, nullInput)
@@ -199,27 +237,27 @@ func (gs graphBinarySerializer)
deserializeMessage(message []byte) (response, er
if err != nil {
return msg, err
}
- msg.responseID = id.(uuid.UUID)
- msg.responseStatus.code = uint16(readUint32Safe(&message, &i) & 0xFF)
+ msg.ResponseID = id.(uuid.UUID)
+ msg.ResponseStatus.code = uint16(readUint32Safe(&message, &i) & 0xFF)
isMessageValid := readByteSafe(&message, &i)
if isMessageValid == 0 {
message, err := readString(&message, &i)
if err != nil {
return msg, err
}
- msg.responseStatus.message = message.(string)
+ msg.ResponseStatus.message = message.(string)
}
attr, err := readMapUnqualified(&message, &i)
if err != nil {
return msg, err
}
- msg.responseStatus.attributes = attr.(map[string]interface{})
+ msg.ResponseStatus.attributes = attr.(map[string]interface{})
meta, err := readMapUnqualified(&message, &i)
if err != nil {
return msg, err
}
- msg.responseResult.meta = meta.(map[string]interface{})
- msg.responseResult.data, err = readFullyQualifiedNullable(&message, &i,
true)
+ msg.ResponseResult.Meta = meta.(map[string]interface{})
+ msg.ResponseResult.Data, err = readFullyQualifiedNullable(&message, &i,
true)
if err != nil {
return msg, err
}
diff --git a/gremlin-go/driver/serializer_test.go
b/gremlin-go/driver/serializer_test.go
index c2e1d2d4f0..b8689da16b 100644
--- a/gremlin-go/driver/serializer_test.go
+++ b/gremlin-go/driver/serializer_test.go
@@ -42,7 +42,7 @@ func TestSerializer(t *testing.T) {
args: map[string]interface{}{"gremlin":
"g.V().count()", "aliases": map[string]interface{}{"g": "g"}},
}
serializer :=
newGraphBinarySerializer(newLogHandler(&defaultLogger{}, Error,
language.English))
- serialized, _ := serializer.serializeMessage(&testRequest)
+ serialized, _ := serializer.SerializeMessage(&testRequest)
stringified := fmt.Sprintf("%v", serialized)
if stringified != mapDataOrder1 && stringified != mapDataOrder2
{
assert.Fail(t, "Error, expected serialized map data to
match one of the provided binary arrays. Can vary based on ordering of keyset,
but must map to one of two.")
@@ -52,14 +52,14 @@ func TestSerializer(t *testing.T) {
t.Run("test serialized response message", func(t *testing.T) {
responseByteArray := []byte{129, 0, 251, 37, 42, 74, 117, 221,
71, 191, 183, 78, 86, 53, 0, 12, 132, 100, 0, 0, 0, 200, 0, 0, 0, 0, 0, 0, 0,
0, 1, 3, 0, 0, 0, 0, 4, 104, 111, 115, 116, 3, 0, 0, 0, 0, 16, 47, 49, 50, 55,
46, 48, 46, 48, 46, 49, 58, 54, 50, 48, 51, 53, 0, 0, 0, 0, 9, 0, 0, 0, 0, 1,
2, 0, 0, 0, 0, 0, 0, 0, 0, 0}
serializer :=
newGraphBinarySerializer(newLogHandler(&defaultLogger{}, Error,
language.English))
- response, err :=
serializer.deserializeMessage(responseByteArray)
+ response, err :=
serializer.DeserializeMessage(responseByteArray)
assert.Nil(t, err)
- assert.Equal(t, "fb252a4a-75dd-47bf-b74e-5635000c8464",
response.responseID.String())
- assert.Equal(t, uint16(200), response.responseStatus.code)
- assert.Equal(t, "", response.responseStatus.message)
- assert.Equal(t, map[string]interface{}{"host":
"/127.0.0.1:62035"}, response.responseStatus.attributes)
- assert.Equal(t, map[string]interface{}{},
response.responseResult.meta)
- assert.Equal(t, []interface{}{int64(0)},
response.responseResult.data)
+ assert.Equal(t, "fb252a4a-75dd-47bf-b74e-5635000c8464",
response.ResponseID.String())
+ assert.Equal(t, uint16(200), response.ResponseStatus.code)
+ assert.Equal(t, "", response.ResponseStatus.message)
+ assert.Equal(t, map[string]interface{}{"host":
"/127.0.0.1:62035"}, response.ResponseStatus.attributes)
+ assert.Equal(t, map[string]interface{}{},
response.ResponseResult.Meta)
+ assert.Equal(t, []interface{}{int64(0)},
response.ResponseResult.Data)
})
t.Run("test serialized response message w/ custom type", func(t
*testing.T) {
@@ -69,14 +69,14 @@ func TestSerializer(t *testing.T) {
}()
responseByteArray := []byte{129, 0, 69, 222, 40, 55, 95, 62,
75, 249, 134, 133, 155, 133, 43, 151, 221, 68, 0, 0, 0, 200, 0, 0, 0, 0, 0, 0,
0, 0, 1, 3, 0, 0, 0, 0, 4, 104, 111, 115, 116, 3, 0, 0, 0, 0, 18, 47, 49, 48,
46, 50, 52, 52, 46, 48, 46, 51, 51, 58, 53, 49, 52, 55, 48, 0, 0, 0, 0, 9, 0,
0, 0, 0, 1, 33, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 29, 106, 97, 110, 117,
115, 103, 114, 97, 112, 104, 46, 82, 101, 108, 97, 116, 105, 111, 110, 73, 100,
101, 110, 116, 105, 102, 105, 101, 1 [...]
serializer :=
newGraphBinarySerializer(newLogHandler(&defaultLogger{}, Error,
language.English))
- response, err :=
serializer.deserializeMessage(responseByteArray)
+ response, err :=
serializer.DeserializeMessage(responseByteArray)
assert.Nil(t, err)
- assert.Equal(t, "45de2837-5f3e-4bf9-8685-9b852b97dd44",
response.responseID.String())
- assert.Equal(t, uint16(200), response.responseStatus.code)
- assert.Equal(t, "", response.responseStatus.message)
- assert.Equal(t, map[string]interface{}{"host":
"/10.244.0.33:51470"}, response.responseStatus.attributes)
- assert.Equal(t, map[string]interface{}{},
response.responseResult.meta)
- assert.NotNil(t, response.responseResult.data)
+ assert.Equal(t, "45de2837-5f3e-4bf9-8685-9b852b97dd44",
response.ResponseID.String())
+ assert.Equal(t, uint16(200), response.ResponseStatus.code)
+ assert.Equal(t, "", response.ResponseStatus.message)
+ assert.Equal(t, map[string]interface{}{"host":
"/10.244.0.33:51470"}, response.ResponseStatus.attributes)
+ assert.Equal(t, map[string]interface{}{},
response.ResponseResult.Meta)
+ assert.NotNil(t, response.ResponseResult.Data)
})
}
@@ -91,7 +91,7 @@ func TestSerializerFailures(t *testing.T) {
args: map[string]interface{}{"invalidInput":
"invalidInput", "aliases": map[string]interface{}{"g": "g"}},
}
serializer :=
newGraphBinarySerializer(newLogHandler(&defaultLogger{}, Error,
language.English))
- resp, err := serializer.serializeMessage(&testRequest)
+ resp, err := serializer.SerializeMessage(&testRequest)
assert.Nil(t, resp)
assert.NotNil(t, err)
assert.True(t,
isSameErrorCode(newError(err0704ConvertArgsNoSerializerError), err))
@@ -100,7 +100,7 @@ func TestSerializerFailures(t *testing.T) {
t.Run("test unkownCustomType failure", func(t *testing.T) {
responseByteArray := []byte{129, 0, 69, 222, 40, 55, 95, 62,
75, 249, 134, 133, 155, 133, 43, 151, 221, 68, 0, 0, 0, 200, 0, 0, 0, 0, 0, 0,
0, 0, 1, 3, 0, 0, 0, 0, 4, 104, 111, 115, 116, 3, 0, 0, 0, 0, 18, 47, 49, 48,
46, 50, 52, 52, 46, 48, 46, 51, 51, 58, 53, 49, 52, 55, 48, 0, 0, 0, 0, 9, 0,
0, 0, 0, 1, 33, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 29, 106, 97, 110, 117,
115, 103, 114, 97, 112, 104, 46, 82, 101, 108, 97, 116, 105, 111, 110, 73, 100,
101, 110, 116, 105, 102, 105, 101, 1 [...]
serializer :=
newGraphBinarySerializer(newLogHandler(&defaultLogger{}, Error,
language.English))
- resp, err := serializer.deserializeMessage(responseByteArray)
+ resp, err := serializer.DeserializeMessage(responseByteArray)
// a partial message will still be returned
assert.NotNil(t, resp)
assert.NotNil(t, err)
