You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tinkerpop.apache.org by xi...@apache.org on 2025/02/25 22:24:56 UTC
(tinkerpop) branch gremlin-go-http updated: Replace websockets with http. Changed connection pooling to be delegated to aio http library. Added POC changes to request serialization just to make happy path work. Full connection configuration and response chunking not yet implemented. (#3057)
This is an automated email from the ASF dual-hosted git repository.
xiazcy pushed a commit to branch gremlin-go-http
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git
The following commit(s) were added to refs/heads/gremlin-go-http by this push:
new b95344eb79 Replace websockets with http. Changed connection pooling to be delegated to aio http library. Added POC changes to request serialization just to make happy path work. Full connection configuration and response chunking not yet implemented. (#3057)
b95344eb79 is described below
commit b95344eb792abb2f82579e5fb2b3b973b45f23db
Author: andreachild <an...@improving.com>
AuthorDate: Tue Feb 25 14:24:51 2025 -0800
Replace websockets with http. Changed connection pooling to be delegated to aio http library. Added POC changes to request serialization just to make happy path work. Full connection configuration and response chunking not yet implemented. (#3057)
---
docker/gremlin-server/docker-entrypoint.sh | 6 +-
gremlin-go/README.md | 2 +-
gremlin-go/build/generate.groovy | 3 +-
gremlin-go/docker-compose.yml | 10 +-
gremlin-go/driver/client.go | 78 ++--
gremlin-go/driver/client_test.go | 8 +-
gremlin-go/driver/connection.go | 82 ----
gremlin-go/driver/connectionPool.go | 175 ---------
gremlin-go/driver/connectionPool_test.go | 134 -------
gremlin-go/driver/connection_test.go | 413 +++------------------
gremlin-go/driver/cucumber/cucumberWorld.go | 2 +-
gremlin-go/driver/cucumber/gremlin.go | 145 +++++---
gremlin-go/driver/driverRemoteConnection.go | 32 +-
gremlin-go/driver/error_codes.go | 11 -
gremlin-go/driver/gorillaTransporter.go | 201 ----------
gremlin-go/driver/gorillaTransporter_test.go | 163 --------
gremlin-go/driver/graphBinary.go | 4 +-
gremlin-go/driver/httpProtocol.go | 197 ++++++++++
gremlin-go/driver/httpTransporter.go | 141 +++++++
gremlin-go/driver/logger.go | 6 -
gremlin-go/driver/performance/performanceSuite.go | 6 +-
gremlin-go/driver/protocol.go | 199 ----------
gremlin-go/driver/protocol_test.go | 91 -----
gremlin-go/driver/request.go | 3 +-
gremlin-go/driver/serializer.go | 105 +-----
gremlin-go/driver/strategies.go | 6 +-
gremlin-go/driver/strategies_test.go | 4 +-
gremlin-go/driver/transporter.go | 40 --
gremlin-go/driver/transporterFactory.go | 53 ---
gremlin-go/driver/traversal.go | 12 +-
gremlin-go/driver/user_agent.go | 2 +-
gremlin-go/examples/basic_gremlin.go | 4 +-
gremlin-go/examples/connections.go | 4 +-
gremlin-go/examples/modern_traversals.go | 2 +-
gremlin-go/go.mod | 2 -
gremlin-go/go.sum | 4 -
gremlin-go/pom.xml | 75 ++--
.../server/handler/HttpGremlinEndpointHandler.java | 2 +-
.../server/handler/HttpRequestMessageDecoder.java | 5 +-
.../util/ser/GraphBinaryMessageSerializerV4.java | 18 +
40 files changed, 625 insertions(+), 1825 deletions(-)
diff --git a/docker/gremlin-server/docker-entrypoint.sh b/docker/gremlin-server/docker-entrypoint.sh
index fc412f736c..4662211776 100644
--- a/docker/gremlin-server/docker-entrypoint.sh
+++ b/docker/gremlin-server/docker-entrypoint.sh
@@ -43,9 +43,9 @@ echo "##########################################################################
echo IP is $IP
echo
echo Available Gremlin Server instances:
-echo "ws://${IP}:45940/gremlin with anonymous access"
-echo "ws://${IP}:45941/gremlin with basic authentication (stephen/password)"
-echo "ws://${IP}:45942/gremlin with kerberos authentication (stephen/password)"
+echo "http://${IP}:45940/gremlin with anonymous access"
+echo "http://${IP}:45941/gremlin with basic authentication (stephen/password)"
+echo "http://${IP}:45942/gremlin with kerberos authentication (stephen/password)"
echo
echo "See docker/gremlin-server/docker-entrypoints.sh for transcripts per GLV."
echo "#############################################################################"
diff --git a/gremlin-go/README.md b/gremlin-go/README.md
index 3a081b5e12..43d34bb6f3 100644
--- a/gremlin-go/README.md
+++ b/gremlin-go/README.md
@@ -49,7 +49,7 @@ import (
func main() {
// Creating the connection to the server with default settings.
- driverRemoteConnection, err := gremlingo.NewDriverRemoteConnection("ws://localhost:8182/gremlin")
+ driverRemoteConnection, err := gremlingo.NewDriverRemoteConnection("http://localhost:8182/gremlin")
// Handle error
if err != nil {
fmt.Println(err)
diff --git a/gremlin-go/build/generate.groovy b/gremlin-go/build/generate.groovy
index 760c959839..c6ac4d3a86 100644
--- a/gremlin-go/build/generate.groovy
+++ b/gremlin-go/build/generate.groovy
@@ -82,8 +82,7 @@ radishGremlinFile.withWriter('UTF-8') { Writer writer ->
gremlins.each { k,v ->
// skipping lambdas until we decide for sure that they are out in 4.x
- if (v.any { it.contains('l1')} || v.any { it.contains('pred1')} || v.any { it.contains('Lambda')}) {
- writer.writeLine(" \"${k}\": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}}, // skipping as it contains a lambda")
+ if (v.any { it.contains('l1')} || v.any { it.contains('l2')} || v.any { it.contains('c1')} || v.any { it.contains('c2')} || v.any { it.contains('pred1')} || v.any { it.contains('Lambda')}) {
} else if (staticTranslate.containsKey(k)) {
writer.writeLine(staticTranslate[k])
} else {
diff --git a/gremlin-go/docker-compose.yml b/gremlin-go/docker-compose.yml
index 07c49a7a15..9919e288e7 100644
--- a/gremlin-go/docker-compose.yml
+++ b/gremlin-go/docker-compose.yml
@@ -35,7 +35,7 @@ services:
- ${HOME}/.m2:/root/.m2
- ${ABS_PROJECT_HOME}/gremlin-test/target:/opt/gremlin-test
healthcheck:
- test: [ "CMD-SHELL", "apk add curl && curl -f http://localhost:45940?gremlin=100-1" ]
+ test: [ "CMD-SHELL", "apk add curl && curl -X POST -d '{\"gremlin\":\"g.inject(1)\"}' http://localhost:45940" ]
interval: 30s
timeout: 10s
retries: 30
@@ -45,7 +45,7 @@ services:
gremlin-go-integration-tests:
container_name: gremlin-go-integration-tests
- image: golang:1.21
+ image: golang:1.22
volumes:
- .:/go_app
- ../gremlin-test/src/main/resources/org/apache/tinkerpop/gremlin/test/features:/gremlin-test
@@ -53,12 +53,12 @@ services:
- ../gremlin-tools/gremlin-socket-server/conf:/go_app/gremlin-socket-server/conf/
environment:
- CUCUMBER_FEATURE_FOLDER=/gremlin-test
- - GREMLIN_SERVER_URL=ws://gremlin-server-test:45940/gremlin
- - GREMLIN_SERVER_BASIC_AUTH_URL=wss://gremlin-server-test:45941/gremlin
+ - GREMLIN_SERVER_URL=http://gremlin-server-test:45940/gremlin
+ - GREMLIN_SERVER_BASIC_AUTH_URL=https://gremlin-server-test:45941/gremlin
- RUN_INTEGRATION_TESTS=true
- RUN_INTEGRATION_WITH_ALIAS_TESTS=true
- RUN_BASIC_AUTH_INTEGRATION_TESTS=true
- - GREMLIN_SOCKET_SERVER_URL=ws://gremlin-socket-server-go
+ - GREMLIN_SOCKET_SERVER_URL=http://gremlin-socket-server-go
- GREMLIN_SOCKET_SERVER_CONFIG_PATH=/go_app/gremlin-socket-server/conf/test-ws-gremlin.yaml
working_dir: /go_app
command: >
diff --git a/gremlin-go/driver/client.go b/gremlin-go/driver/client.go
index e30f7daae5..e47d0335fb 100644
--- a/gremlin-go/driver/client.go
+++ b/gremlin-go/driver/client.go
@@ -30,7 +30,6 @@ import (
// ClientSettings is used to modify a Client's settings on initialization.
type ClientSettings struct {
TraversalSource string
- TransporterType TransporterType
LogVerbosity LogVerbosity
Logger Logger
Language language.Tag
@@ -43,32 +42,26 @@ type ClientSettings struct {
ReadBufferSize int
WriteBufferSize int
- // Minimum amount of concurrent active traversals on a connection to trigger creation of a new connection
- NewConnectionThreshold int
// Maximum number of concurrent connections. Default: number of runtime processors
MaximumConcurrentConnections int
- // Initial amount of instantiated connections. Default: 1
- InitialConcurrentConnections int
EnableUserAgentOnConnect bool
}
// Client is used to connect and interact with a Gremlin-supported server.
type Client struct {
- url string
- traversalSource string
- logHandler *logHandler
- transporterType TransporterType
- connections connectionPool
- session string
+ url string
+ traversalSource string
+ logHandler *logHandler
+ session string
+ connectionSettings *connectionSettings
+ httpProtocol *httpProtocol
}
-// NewClient creates a Client and configures it with the given parameters. During creation of the Client, a connection
-// is created, which establishes a websocket.
+// NewClient creates a Client and configures it with the given parameters.
// Important note: to avoid leaking a connection, always close the Client.
func NewClient(url string, configurations ...func(settings *ClientSettings)) (*Client, error) {
settings := &ClientSettings{
TraversalSource: "g",
- TransporterType: Gorilla,
LogVerbosity: Info,
Logger: &defaultLogger{},
Language: language.English,
@@ -85,9 +78,7 @@ func NewClient(url string, configurations ...func(settings *ClientSettings)) (*C
ReadBufferSize: 0,
WriteBufferSize: 0,
- NewConnectionThreshold: defaultNewConnectionThreshold,
MaximumConcurrentConnections: runtime.NumCPU(),
- InitialConcurrentConnections: defaultInitialConcurrentConnections,
}
for _, configuration := range configurations {
configuration(settings)
@@ -107,27 +98,18 @@ func NewClient(url string, configurations ...func(settings *ClientSettings)) (*C
logHandler := newLogHandler(settings.Logger, settings.LogVerbosity, settings.Language)
- if settings.InitialConcurrentConnections > settings.MaximumConcurrentConnections {
- logHandler.logf(Warning, poolInitialExceedsMaximum, settings.InitialConcurrentConnections,
- settings.MaximumConcurrentConnections, settings.MaximumConcurrentConnections)
- settings.InitialConcurrentConnections = settings.MaximumConcurrentConnections
- }
- pool, err := newLoadBalancingPool(url, logHandler, connSettings, settings.NewConnectionThreshold,
- settings.MaximumConcurrentConnections, settings.InitialConcurrentConnections)
+ httpProt, err := newHttpProtocol(logHandler, url, connSettings)
if err != nil {
- if err != nil {
- logHandler.logf(Error, logErrorGeneric, "NewClient", err.Error())
- }
return nil, err
}
client := &Client{
- url: url,
- traversalSource: settings.TraversalSource,
- logHandler: logHandler,
- transporterType: settings.TransporterType,
- connections: pool,
- session: "",
+ url: url,
+ traversalSource: settings.TraversalSource,
+ logHandler: logHandler,
+ session: "",
+ connectionSettings: connSettings,
+ httpProtocol: httpProt,
}
return client, nil
@@ -138,25 +120,23 @@ func NewClient(url string, configurations ...func(settings *ClientSettings)) (*C
func (client *Client) Close() {
// If it is a session, call closeSession
if client.session != "" {
- err := client.closeSession()
- if err != nil {
- client.logHandler.logf(Warning, closeSessionRequestError, client.url, client.session, err.Error())
- }
+ // TODO remove references to session
client.session = ""
}
client.logHandler.logf(Info, closeClient, client.url)
- client.connections.close()
+}
+
+func (client *Client) errorCallback() {
+ client.logHandler.log(Error, errorCallback)
}
// 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)
- result, err := client.connections.write(&request)
- if err != nil {
- client.logHandler.logf(Error, logErrorGeneric, "Client.Submit()", err.Error())
- }
- return result, err
+
+ rs, err := client.httpProtocol.send(&request)
+ return rs, err
}
// Submit submits a Gremlin script to the server and returns a ResultSet. Submit can optionally accept a map of bindings
@@ -177,22 +157,12 @@ func (client *Client) submitGremlinLang(gremlinLang *GremlinLang) (ResultSet, er
// TODO placeholder
requestOptionsBuilder := new(RequestOptionsBuilder)
request := makeStringRequest(gremlinLang.GetGremlin(), client.traversalSource, client.session, requestOptionsBuilder.Create())
- return client.connections.write(&request)
+ return client.httpProtocol.send(&request)
}
// 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)
- return client.connections.write(&request)
-}
-
-func (client *Client) closeSession() error {
- message := makeCloseSessionRequest(client.session)
- result, err := client.connections.write(&message)
- if err != nil {
- return err
- }
- _, err = result.All()
- return err
+ return client.httpProtocol.send(&request)
}
diff --git a/gremlin-go/driver/client_test.go b/gremlin-go/driver/client_test.go
index 52a9bdef4e..0da9dc925e 100644
--- a/gremlin-go/driver/client_test.go
+++ b/gremlin-go/driver/client_test.go
@@ -72,10 +72,6 @@ func TestClient(t *testing.T) {
assert.NotNil(t, resultSet)
client.Close()
- pool := client.connections.(*loadBalancingPool)
- assert.Equal(t, 1, len(pool.connections))
- assert.True(t, pool.isClosed)
- assert.Equal(t, closed, pool.connections[0].state)
})
t.Run("Test client.Submit()", func(t *testing.T) {
@@ -265,7 +261,7 @@ func TestClientAgainstSocketServer(t *testing.T) {
// Integration test variables.
testNoAuthEnable := getEnvOrDefaultBool("RUN_INTEGRATION_TESTS", true)
settings := FromYaml(getEnvOrDefaultString("GREMLIN_SOCKET_SERVER_CONFIG_PATH", "../../gremlin-tools/gremlin-socket-server/conf/test-ws-gremlin.yaml"))
- testSocketServerUrl := getEnvOrDefaultString("GREMLIN_SOCKET_SERVER_URL", "ws://localhost")
+ testSocketServerUrl := getEnvOrDefaultString("GREMLIN_SOCKET_SERVER_URL", "http://localhost")
testSocketServerUrl = fmt.Sprintf("%s:%v/gremlin", testSocketServerUrl, settings.PORT)
/**
@@ -316,7 +312,7 @@ func TestClientAgainstSocketServer(t *testing.T) {
})
/**
- * Tests that no user agent (other than the default one provided by gorilla) is sent to server when
+ * Tests that no user agent (other than the default one) is sent to server when
* that behaviour is disabled.
*/
t.Run("Should not include user agent in handshake request if disabled", func(t *testing.T) {
diff --git a/gremlin-go/driver/connection.go b/gremlin-go/driver/connection.go
index a721044340..0aacaf2a19 100644
--- a/gremlin-go/driver/connection.go
+++ b/gremlin-go/driver/connection.go
@@ -25,22 +25,6 @@ import (
"time"
)
-type connectionState int
-
-const (
- initialized connectionState = iota + 1
- established
- closed
- closedDueToError
-)
-
-type connection struct {
- logHandler *logHandler
- protocol protocol
- results *synchronizedMap
- state connectionState
-}
-
type connectionSettings struct {
authInfo AuthInfoProvider
tlsConfig *tls.Config
@@ -53,72 +37,6 @@ type connectionSettings struct {
enableUserAgentOnConnect bool
}
-func (connection *connection) errorCallback() {
- connection.logHandler.log(Error, errorCallback)
- connection.state = closedDueToError
-
- // This callback is called from within protocol.readLoop. Therefore,
- // it cannot wait for it to finish to avoid a deadlock.
- if err := connection.protocol.close(false); err != nil {
- connection.logHandler.logf(Error, failedToCloseInErrorCallback, err.Error())
- }
-}
-
-func (connection *connection) close() error {
- if connection.state != established {
- return newError(err0101ConnectionCloseError)
- }
- connection.logHandler.log(Info, closeConnection)
- var err error
- if connection.protocol != nil {
- err = connection.protocol.close(true)
- }
- connection.state = closed
- return err
-}
-
-func (connection *connection) write(request *request) (ResultSet, error) {
- if connection.state != established {
- return nil, newError(err0102WriteConnectionClosedError)
- }
- connection.logHandler.log(Debug, writeRequest)
- requestID := request.requestID.String()
- connection.logHandler.logf(Debug, creatingRequest, requestID)
- resultSet := newChannelResultSet(requestID, connection.results)
- connection.results.store(requestID, resultSet)
- return resultSet, connection.protocol.write(request)
-}
-
-func (connection *connection) activeResults() int {
- return connection.results.size()
-}
-
-// createConnection establishes a connection with the given parameters. A connection should always be closed to avoid
-// leaking connections. The connection has the following states:
-//
-// initialized: connection struct is created but has not established communication with server
-// established: connection has established communication established with the server
-// closed: connection was closed by the user.
-// closedDueToError: connection was closed internally due to an error.
-func createConnection(url string, logHandler *logHandler, connSettings *connectionSettings) (*connection, error) {
- conn := &connection{
- logHandler,
- nil,
- &synchronizedMap{map[string]ResultSet{}, sync.Mutex{}},
- initialized,
- }
- logHandler.log(Info, connectConnection)
- protocol, err := newGremlinServerWSProtocol(logHandler, Gorilla, url, connSettings, conn.results, conn.errorCallback)
- if err != nil {
- logHandler.logf(Warning, failedConnection)
- conn.state = closedDueToError
- return nil, err
- }
- conn.protocol = protocol
- conn.state = established
- return conn, err
-}
-
type synchronizedMap struct {
internalMap map[string]ResultSet
syncLock sync.Mutex
diff --git a/gremlin-go/driver/connectionPool.go b/gremlin-go/driver/connectionPool.go
deleted file mode 100644
index 7f800ef25f..0000000000
--- a/gremlin-go/driver/connectionPool.go
+++ /dev/null
@@ -1,175 +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 gremlingo
-
-import (
- "sync"
-)
-
-type connectionPool interface {
- write(*request) (ResultSet, error)
- close()
-}
-
-const defaultNewConnectionThreshold = 4
-const defaultInitialConcurrentConnections = 1
-
-// loadBalancingPool has two configurations: maximumConcurrentConnections/cap(connections) and newConnectionThreshold.
-// maximumConcurrentConnections denotes the maximum amount of active connections at any given time.
-// newConnectionThreshold specifies the minimum amount of concurrent active traversals on the least used connection
-// which will trigger creation of a new connection if maximumConcurrentConnections has not been reached.
-// loadBalancingPool will use the least-used connection, and as a part of the process, getLeastUsedConnection(), will
-// remove any errored connections from the pool and ensure that the returned connection is usable.
-type loadBalancingPool struct {
- url string
- logHandler *logHandler
- connSettings *connectionSettings
-
- newConnectionThreshold int
- connections []*connection
- loadBalanceLock sync.Mutex
- isClosed bool
-}
-
-func (pool *loadBalancingPool) close() {
- pool.loadBalanceLock.Lock()
- defer pool.loadBalanceLock.Unlock()
-
- if !pool.isClosed {
- for _, connection := range pool.connections {
- err := connection.close()
- if err != nil {
- pool.logHandler.logf(Warning, errorClosingConnection, err.Error())
- }
- }
- pool.isClosed = true
- }
-}
-
-func (pool *loadBalancingPool) write(request *request) (ResultSet, error) {
- pool.loadBalanceLock.Lock()
- defer pool.loadBalanceLock.Unlock()
-
- if pool.isClosed {
- return nil, newError(err0103ConnectionPoolClosedError)
- }
-
- conn, err := pool.getLeastUsedConnection()
- if err != nil {
- return nil, err
- }
- return conn.write(request)
-}
-
-// Not thread-safe. Should only be called by write which ensures no concurrency.
-func (pool *loadBalancingPool) getLeastUsedConnection() (*connection, error) {
- // newConnection should only be called within getLeastUsedConnection and therefore is a lambda.
- newConnection := func() (*connection, error) {
- connection, err := createConnection(pool.url, pool.logHandler, pool.connSettings)
- if err != nil {
- return nil, err
- }
- pool.connections = append(pool.connections, connection)
- return connection, nil
- }
-
- // If our pool is empty, return a new connection.
- if len(pool.connections) == 0 {
- return newConnection()
- }
-
- // Remove connections which are dead and find least used.
- var leastUsed *connection = nil
- validConnections := make([]*connection, 0, cap(pool.connections))
- for _, connection := range pool.connections {
- if connection.state == established || connection.state == initialized {
- validConnections = append(validConnections, connection)
- }
- if connection.state == established {
- // Set the least used connection.
- if leastUsed == nil || connection.activeResults() < leastUsed.activeResults() {
- leastUsed = connection
- }
- }
- }
- pool.connections = validConnections
-
- if leastUsed == nil {
- // If no valid connection is found.
- if len(pool.connections) >= cap(pool.connections) {
- // Return error if pool is full and no valid connection was found (should not ever happen).
- return nil, newError(err0105ConnectionPoolFullButNoneValid)
- } else {
- // Return new connection if no valid connection was found and pool has capacity.
- return newConnection()
- }
- } else if leastUsed.activeResults() >= pool.newConnectionThreshold && len(pool.connections) < cap(pool.connections) {
- // If the number of active results in our least used connection has reached the threshold
- // AND our pool size has not reached the capacity, attempt to return a new connection.
- newConnection, err := newConnection()
- if err != nil {
- // New connection creation failed; use existing grabbed least-used connection.
- pool.logHandler.logf(Warning, poolNewConnectionError, err.Error())
- return leastUsed, nil
- }
- return newConnection, nil
- } else {
- // If our pool is at capacity OR our least busy connection is less than the threshold, return the least used connection.
- return leastUsed, nil
- }
-}
-
-func newLoadBalancingPool(url string, logHandler *logHandler, connSettings *connectionSettings,
- newConnectionThreshold int, maximumConcurrentConnections int, initialConcurrentConnections int) (connectionPool, error) {
- var wg sync.WaitGroup
- wg.Add(initialConcurrentConnections)
- var appendLock sync.Mutex
-
- pool := make([]*connection, 0, maximumConcurrentConnections)
- errorList := make([]error, 0, maximumConcurrentConnections)
- for i := 0; i < initialConcurrentConnections; i++ {
- go func() {
- defer wg.Done()
- connection, err := createConnection(url, logHandler, connSettings)
-
- appendLock.Lock()
- defer appendLock.Unlock()
- if err != nil {
- logHandler.logf(Warning, createConnectionError, err.Error())
- errorList = append(errorList, err)
- } else {
- pool = append(pool, connection)
- }
- }()
- }
-
- wg.Wait()
- if len(pool) == 0 && len(errorList) != 0 {
- // If all instantiation fails return the first error's details.
- return nil, newError(err0104ConnectionPoolInstantiateFail, errorList[0].Error())
- }
- return &loadBalancingPool{
- url: url,
- logHandler: logHandler,
- connSettings: connSettings,
- newConnectionThreshold: newConnectionThreshold,
- connections: pool,
- }, nil
-}
diff --git a/gremlin-go/driver/connectionPool_test.go b/gremlin-go/driver/connectionPool_test.go
deleted file mode 100644
index 238833e2db..0000000000
--- a/gremlin-go/driver/connectionPool_test.go
+++ /dev/null
@@ -1,134 +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 gremlingo
-
-import (
- "github.com/stretchr/testify/assert"
- "golang.org/x/text/language"
- "strconv"
- "sync"
- "testing"
-)
-
-// Arbitrarily high value to use to not trigger creation of new connections
-const newConnectionThreshold = 100
-
-var logger = newLogHandler(&defaultLogger{}, Info, language.English)
-
-func getPoolForTesting() *loadBalancingPool {
- return &loadBalancingPool{
- url: "",
- connSettings: newDefaultConnectionSettings(),
- logHandler: newLogHandler(&defaultLogger{}, Info, language.English),
- newConnectionThreshold: newConnectionThreshold,
- connections: nil,
- loadBalanceLock: sync.Mutex{},
- }
-}
-
-func getMockConnection() *connection {
- return &connection{
- logHandler: logger,
- protocol: nil,
- results: &synchronizedMap{
- internalMap: make(map[string]ResultSet),
- syncLock: sync.Mutex{},
- },
- state: established,
- }
-}
-
-func TestConnectionPool(t *testing.T) {
- t.Run("loadBalancingPool", func(t *testing.T) {
- smallMap := make(map[string]ResultSet)
- bigMap := make(map[string]ResultSet)
- for i := 1; i < 4; i++ {
- bigMap[strconv.Itoa(i)] = nil
- if i < 3 {
- smallMap[strconv.Itoa(i)] = nil
- }
- }
-
- t.Run("getLeastUsedConnection", func(t *testing.T) {
- t.Run("getting the least used connection", func(t *testing.T) {
- pool := getPoolForTesting()
- defer pool.close()
- mockConnection1 := getMockConnection()
- mockConnection2 := getMockConnection()
- mockConnection3 := getMockConnection()
- mockConnection1.results.internalMap = bigMap
- mockConnection2.results.internalMap = smallMap
- mockConnection3.results.internalMap = bigMap
- connections := []*connection{mockConnection1, mockConnection2, mockConnection3}
- pool.connections = connections
-
- connection, err := pool.getLeastUsedConnection()
- assert.Nil(t, err)
- assert.Equal(t, mockConnection2, connection)
- })
-
- t.Run("purge non-established connections", func(t *testing.T) {
- pool := getPoolForTesting()
- defer pool.close()
- mockConnection := getMockConnection()
- mockConnection.results.internalMap = smallMap
- nonEstablished := &connection{
- logHandler: logger,
- protocol: nil,
- results: nil,
- state: closed,
- }
- connections := []*connection{nonEstablished, mockConnection}
- pool.connections = connections
-
- connection, err := pool.getLeastUsedConnection()
- assert.Nil(t, err)
- assert.Equal(t, mockConnection, connection)
- assert.Len(t, pool.connections, 1)
- })
- })
-
- t.Run("close", func(t *testing.T) {
- pool := getPoolForTesting()
- empty := &synchronizedMap{
- internalMap: make(map[string]ResultSet),
- syncLock: sync.Mutex{},
- }
- openConn1 := &connection{
- logHandler: logger,
- protocol: nil,
- results: empty,
- state: established,
- }
- openConn2 := &connection{
- logHandler: logger,
- protocol: nil,
- results: empty,
- state: established,
- }
- connections := []*connection{openConn1, openConn2}
- pool.connections = connections
-
- pool.close()
- assert.Equal(t, closed, openConn1.state)
- assert.Equal(t, closed, openConn2.state)
- })
- })
-}
diff --git a/gremlin-go/driver/connection_test.go b/gremlin-go/driver/connection_test.go
index fc7497b767..9377a62294 100644
--- a/gremlin-go/driver/connection_test.go
+++ b/gremlin-go/driver/connection_test.go
@@ -21,19 +21,16 @@ package gremlingo
import (
"crypto/tls"
+ "fmt"
+ "github.com/google/uuid"
+ "github.com/stretchr/testify/assert"
"math/big"
"os"
"reflect"
- "runtime"
"sort"
"strconv"
"sync"
"testing"
- "time"
-
- "github.com/google/uuid"
- "github.com/stretchr/testify/assert"
- "golang.org/x/text/language"
)
const personLabel = "Person"
@@ -41,16 +38,17 @@ const testLabel = "Test"
const nameKey = "name"
const integrationTestSuiteName = "integration"
const basicAuthIntegrationTestSuite = "basic authentication integration"
-const validHostInvalidPortValidPath = "ws://localhost:12341253/gremlin"
-const invalidHostValidPortValidPath = "ws://invalidhost:8182/gremlin"
+const validHostInvalidPortValidPath = "http://localhost:12341253/gremlin"
+const invalidHostValidPortValidPath = "http://invalidhost:8182/gremlin"
const testServerModernGraphAlias = "gmodern"
const testServerGraphAlias = "gimmutable"
const testServerCrewGraphAlias = "gcrew"
const manualTestSuiteName = "manual"
-const nonRoutableIPForConnectionTimeout = "ws://10.255.255.1/"
+const nonRoutableIPForConnectionTimeout = "http://10.255.255.1/"
// transaction is enabled on the same port as no auth url
-const noAuthUrl = "ws://localhost:45940/gremlin"
+const noAuthUrl = "http://localhost:45940/gremlin"
+const noAuthSslUrl = "https://localhost:45941/gremlin"
const basicAuthWithSsl = "wss://localhost:45941/gremlin"
var testNames = []string{"Lyndon", "Yang", "Simon", "Rithin", "Alexey", "Valentyn"}
@@ -257,10 +255,6 @@ func skipTestsIfNotEnabled(t *testing.T, testSuiteName string, testSuiteEnabled
}
}
-func deferredCleanup(t *testing.T, connection *connection) {
- assert.Nil(t, connection.close())
-}
-
func TestConnection(t *testing.T) {
// Integration test variables.
testNoAuthUrl := getEnvOrDefaultString("GREMLIN_SERVER_URL", noAuthUrl)
@@ -275,346 +269,58 @@ func TestConnection(t *testing.T) {
testNoAuthWithAliasTlsConfig := &tls.Config{}
// Basic authentication integration test variables.
- // TODO using "wss:" to connect to an auth server without ssl enabled ("ws:") will give an "EOF" error in NewDriverRemoteConnection, bug?
+ // TODO using "wss:" to connect to an auth server without ssl enabled ("http:") will give an "EOF" error in NewDriverRemoteConnection, bug?
testBasicAuthUrl := getEnvOrDefaultString("GREMLIN_SERVER_BASIC_AUTH_URL", basicAuthWithSsl)
testBasicAuthEnable := getEnvOrDefaultBool("RUN_BASIC_AUTH_INTEGRATION_TESTS", false)
testBasicAuthAuthInfo := getBasicAuthInfo()
testBasicAuthTlsConfig := &tls.Config{InsecureSkipVerify: true}
- testManual := getEnvOrDefaultBool("RUN_MANUAL_TEST", false)
-
- t.Run("Test createConnection without valid server", func(t *testing.T) {
- connection, err := createConnection(invalidHostValidPortValidPath, newLogHandler(&defaultLogger{}, Info,
- language.English), newDefaultConnectionSettings())
- assert.NotNil(t, err)
- assert.Nil(t, connection)
- })
-
- t.Run("Test createConnection without valid port", func(t *testing.T) {
- connection, err := createConnection(validHostInvalidPortValidPath, newLogHandler(&defaultLogger{}, Info,
- language.English), newDefaultConnectionSettings())
- assert.NotNil(t, err)
- assert.Nil(t, connection)
- })
-
- t.Run("Test createConnection without valid path", func(t *testing.T) {
- connSettings := newDefaultConnectionSettings()
- t.Run("Test 1 second timeout", func(t *testing.T) {
- connSettings.connectionTimeout = 1 * time.Second
- t1 := time.Now()
- connection, err := createConnection(nonRoutableIPForConnectionTimeout, newLogHandler(&defaultLogger{}, Info,
- language.English), connSettings)
- t2 := time.Since(t1)
- assert.True(t, t2.Seconds() < 1.5 && t2.Seconds() > 0.5)
- assert.NotNil(t, err)
- assert.Nil(t, connection)
- })
-
- t.Run("Test 2 second timeout", func(t *testing.T) {
- connSettings.connectionTimeout = 2 * time.Second
- t1 := time.Now()
- connection, err := createConnection(nonRoutableIPForConnectionTimeout, newLogHandler(&defaultLogger{}, Info,
- language.English), connSettings)
- t2 := time.Since(t1)
- assert.True(t, t2.Seconds() < 2.5 && t2.Seconds() > 1.5)
- assert.NotNil(t, err)
- assert.Nil(t, connection)
- })
-
- t.Run("Test 3 second timeout", func(t *testing.T) {
- connSettings.connectionTimeout = 3 * time.Second
- t1 := time.Now()
- connection, err := createConnection(nonRoutableIPForConnectionTimeout, newLogHandler(&defaultLogger{}, Info,
- language.English), connSettings)
- t2 := time.Since(t1)
- assert.True(t, t2.Seconds() < 3.5 && t2.Seconds() > 2.5)
- assert.NotNil(t, err)
- assert.Nil(t, connection)
- })
- })
-
- t.Run("Test DriverRemoteConnection GraphTraversal", func(t *testing.T) {
- skipTestsIfNotEnabled(t, integrationTestSuiteName, testNoAuthEnable)
-
- // Initialize graph
- g := initializeGraph(t, testNoAuthUrl, testNoAuthAuthInfo, testNoAuthTlsConfig)
- defer g.remoteConnection.Close()
-
- // Read test data out of the graph and check that it is correct.
- readTestDataVertexProperties(t, g)
- readTestDataValues(t, g)
-
- // Reset Graph
- resetGraph(t, g)
- })
-
- t.Run("Test createConnection", func(t *testing.T) {
- skipTestsIfNotEnabled(t, integrationTestSuiteName, testNoAuthEnable)
- connection, err := createConnection(testNoAuthUrl, newLogHandler(&defaultLogger{}, Info, language.English),
- newDefaultConnectionSettings())
- assert.Nil(t, err)
- assert.NotNil(t, connection)
- assert.Equal(t, established, connection.state)
- defer deferredCleanup(t, connection)
- })
-
- t.Run("Test createConnection with compression", func(t *testing.T) {
- skipTestsIfNotEnabled(t, integrationTestSuiteName, testNoAuthEnable)
- setting := newDefaultConnectionSettings()
- setting.enableCompression = true
- connection, err := createConnection(testNoAuthUrl, newLogHandler(&defaultLogger{}, Info, language.English),
- setting)
- assert.Nil(t, err)
- assert.NotNil(t, connection)
- assert.Equal(t, established, connection.state)
- defer deferredCleanup(t, connection)
- })
-
- t.Run("Test connection.write() with small buffer size", func(t *testing.T) {
- skipTestsIfNotEnabled(t, integrationTestSuiteName, testNoAuthEnable)
- setting := newDefaultConnectionSettings()
- setting.readBufferSize = 100
- setting.writeBufferSize = 150
- setting.connectionTimeout = 1 * time.Second
- connection, err := createConnection(testNoAuthUrl, newLogHandler(&defaultLogger{}, Info, language.English),
- setting)
- assert.Nil(t, err)
- assert.NotNil(t, connection)
- assert.Equal(t, established, connection.state)
- defer deferredCleanup(t, connection)
- request := makeStringRequest("g.V().count()", "g", "", *new(RequestOptions))
- resultSet, err := connection.write(&request)
- assert.Nil(t, err)
- assert.NotNil(t, resultSet)
- result, ok, err := resultSet.One()
- assert.Nil(t, err)
- assert.True(t, ok)
- assert.NotNil(t, result)
- })
-
- t.Run("Test connection.write()", func(t *testing.T) {
- skipTestsIfNotEnabled(t, integrationTestSuiteName, testNoAuthEnable)
- connection, err := createConnection(testNoAuthUrl, newLogHandler(&defaultLogger{}, Info, language.English),
- newDefaultConnectionSettings())
- assert.Nil(t, err)
- assert.NotNil(t, connection)
- assert.Equal(t, established, connection.state)
- defer deferredCleanup(t, connection)
- request := makeStringRequest("g.V().count()", "g", "", *new(RequestOptions))
- resultSet, err := connection.write(&request)
- assert.Nil(t, err)
- assert.NotNil(t, resultSet)
- result, ok, err := resultSet.One()
- assert.Nil(t, err)
- assert.True(t, ok)
- assert.NotNil(t, result)
- })
-
- t.Run("Test connection.close() failure", func(t *testing.T) {
- skipTestsIfNotEnabled(t, integrationTestSuiteName, testNoAuthEnable)
- connection, err := createConnection(testNoAuthUrl, newLogHandler(&defaultLogger{}, Info, language.English),
- newDefaultConnectionSettings())
- assert.Equal(t, established, connection.state)
- assert.Nil(t, err)
- err = connection.close()
- assert.Nil(t, err)
- assert.Equal(t, closed, connection.state)
- err = connection.close()
- assert.Equal(t, newError(err0101ConnectionCloseError), err)
- assert.Equal(t, closed, connection.state)
- err = connection.close()
- assert.Equal(t, newError(err0101ConnectionCloseError), err)
- assert.Equal(t, closed, connection.state)
- })
-
- t.Run("Test connection.write() after close() failure", func(t *testing.T) {
- skipTestsIfNotEnabled(t, integrationTestSuiteName, testNoAuthEnable)
- connection, err := createConnection(testNoAuthUrl, newLogHandler(&defaultLogger{}, Info, language.English),
- newDefaultConnectionSettings())
- assert.Equal(t, established, connection.state)
- assert.Nil(t, err)
- err = connection.close()
- assert.Nil(t, err)
- assert.Equal(t, closed, connection.state)
- request := makeStringRequest("g.V().count()", "g", "", *new(RequestOptions))
- resultSet, err := connection.write(&request)
- assert.Nil(t, resultSet)
- assert.Equal(t, newError(err0102WriteConnectionClosedError), err)
- assert.Equal(t, closed, connection.state)
- })
-
- t.Run("Test server closes websocket", func(t *testing.T) {
- skipTestsIfNotEnabled(t, manualTestSuiteName, testManual)
- connSettings := newDefaultConnectionSettings()
- connSettings.keepAliveInterval = 500 * keepAliveIntervalDefault
- connection, err := createConnection(testNoAuthUrl, newLogHandler(&defaultLogger{}, Info, language.English),
- connSettings)
- assert.Equal(t, established, connection.state)
- assert.Nil(t, err)
- time.Sleep(120 * time.Second)
- request := makeStringRequest("g.V().count()", "g", "", *new(RequestOptions))
- resultSet, err := connection.write(&request)
- assert.Nil(t, resultSet)
- assert.NotNil(t, err)
- })
-
- t.Run("Test newLoadBalancingPool", func(t *testing.T) {
+ // this test is used to test the ws->http POC changes via manual execution with a local TP 4.0 gremlin server running on 8182
+ t.Run("Test client.submit()", func(t *testing.T) {
skipTestsIfNotEnabled(t, integrationTestSuiteName, testNoAuthEnable)
- newPoolSize := 2
- pool, err := newLoadBalancingPool(testNoAuthUrl, newLogHandler(&defaultLogger{}, Info, language.English),
- newDefaultConnectionSettings(), 4, 4, newPoolSize)
- assert.Nil(t, err)
- defer pool.close()
- assert.Len(t, pool.(*loadBalancingPool).connections, newPoolSize)
- })
- t.Run("Test loadBalancingPool.newConnection", func(t *testing.T) {
- newPoolSize := 0
- skipTestsIfNotEnabled(t, integrationTestSuiteName, testNoAuthEnable)
- pool, err := newLoadBalancingPool(testNoAuthUrl, newLogHandler(&defaultLogger{}, Info, language.English),
- newDefaultConnectionSettings(), 4, 4, newPoolSize)
- assert.Nil(t, err)
- defer pool.close()
- lhp := pool.(*loadBalancingPool)
- // Pool instantiated with no connections so this will invoke newConnection
- newConn, err := lhp.getLeastUsedConnection()
- assert.Nil(t, err)
- assert.Len(t, lhp.connections, newPoolSize+1)
- // Workaround for false positive in race condition check
- found := false
- for _, conn := range lhp.connections {
- if conn == newConn {
- found = true
- }
+ tlsConf := tls.Config{
+ InsecureSkipVerify: true,
}
- assert.True(t, found)
- })
-
- t.Run("Test loadBalancingPool.getLeastUsedConnection", func(t *testing.T) {
- newConnectionThreshold := 2
- maximumConcurrentConnections := 2
- logHandler := newLogHandler(&defaultLogger{}, Info, language.English)
- skipTestsIfNotEnabled(t, integrationTestSuiteName, testNoAuthEnable)
-
- t.Run("pool is empty", func(t *testing.T) {
- pool, err := newLoadBalancingPool(testNoAuthUrl, newLogHandler(&defaultLogger{}, Info, language.English),
- newDefaultConnectionSettings(),
- newConnectionThreshold, maximumConcurrentConnections, 0)
- assert.Nil(t, err)
- lbp := pool.(*loadBalancingPool)
- defer lbp.close()
- conn, err := lbp.getLeastUsedConnection()
- assert.Nil(t, err)
- assert.NotNil(t, conn)
- assert.Len(t, lbp.connections, 1)
- })
-
- t.Run("newConcurrentThreshold reached with capacity remaining", func(t *testing.T) {
- pool, err := newLoadBalancingPool(testNoAuthUrl, newLogHandler(&defaultLogger{}, Info, language.English),
- newDefaultConnectionSettings(),
- newConnectionThreshold, maximumConcurrentConnections, 0)
- assert.Nil(t, err)
- lbp := pool.(*loadBalancingPool)
- defer lbp.close()
- thresholdReachedResults := &synchronizedMap{
- internalMap: map[string]ResultSet{},
- syncLock: sync.Mutex{},
- }
- thresholdReachedResults.store("1", nil)
- thresholdReachedResults.store("2", nil)
- fullConnection := &connection{
- logHandler: logHandler,
- protocol: nil,
- results: thresholdReachedResults,
- state: established,
- }
- capacityAvailablePool := make([]*connection, 0, maximumConcurrentConnections)
- capacityAvailablePool = append(capacityAvailablePool, fullConnection)
- lbp.connections = capacityAvailablePool
- conn, err := lbp.getLeastUsedConnection()
- assert.Nil(t, err)
- assert.NotNil(t, conn)
- assert.NotEqual(t, fullConnection, conn)
- assert.Len(t, lbp.connections, 2)
- })
-
- t.Run("newConcurrentThreshold reached with no capacity remaining", func(t *testing.T) {
- capacityFullConnectionPool, err := newLoadBalancingPool(testNoAuthUrl, newLogHandler(&defaultLogger{}, Info,
- language.English), newDefaultConnectionSettings(),
- 1, 1, 1)
- assert.Nil(t, err)
- assert.NotNil(t, capacityFullConnectionPool)
- capacityFullLbp := capacityFullConnectionPool.(*loadBalancingPool)
- defer capacityFullLbp.close()
- capacityFullLbp.connections[0].results.store("mockFillCapacity",
- newChannelResultSet("mockFillCapacity", capacityFullLbp.connections[0].results))
- conn, err := capacityFullLbp.getLeastUsedConnection()
- assert.Nil(t, err)
- assert.NotNil(t, conn)
- assert.Len(t, capacityFullLbp.connections, 1)
- })
-
- t.Run("all connections in pool invalid", func(t *testing.T) {
- pool, err := newLoadBalancingPool(testNoAuthUrl, newLogHandler(&defaultLogger{}, Info, language.English),
- newDefaultConnectionSettings(),
- newConnectionThreshold, maximumConcurrentConnections, 0)
- assert.Nil(t, err)
- lbp := pool.(*loadBalancingPool)
- defer lbp.close()
- invalidConnection1 := &connection{
- logHandler: logHandler,
- protocol: nil,
- results: nil,
- state: closed,
- }
- invalidConnection2 := &connection{
- logHandler: logHandler,
- protocol: nil,
- results: nil,
- state: closedDueToError,
- }
- invalidPool := []*connection{invalidConnection1, invalidConnection2}
- lbp.connections = invalidPool
- conn, err := lbp.getLeastUsedConnection()
- assert.Nil(t, err)
- assert.NotNil(t, conn)
- assert.NotEqual(t, invalidConnection1, conn)
- assert.NotEqual(t, invalidConnection2, conn)
- assert.Len(t, lbp.connections, 1)
- assert.NotContains(t, lbp.connections, invalidConnection1)
- assert.NotContains(t, lbp.connections, invalidConnection2)
- })
- })
-
- t.Run("Test client.submit()", func(t *testing.T) {
- skipTestsIfNotEnabled(t, integrationTestSuiteName, testNoAuthEnable)
client, err := NewClient(testNoAuthUrl,
+ //client, err := NewClient(noAuthSslUrl,
func(settings *ClientSettings) {
- settings.TlsConfig = testNoAuthTlsConfig
+ settings.TlsConfig = &tlsConf
settings.AuthInfo = testNoAuthAuthInfo
+ settings.WriteBufferSize = 1024
+ settings.EnableCompression = true
})
assert.Nil(t, err)
assert.NotNil(t, client)
defer client.Close()
- resultSet, err := client.Submit("g.V().count()")
- assert.Nil(t, err)
- assert.NotNil(t, resultSet)
- result, ok, err := resultSet.One()
- assert.Nil(t, err)
- assert.True(t, ok)
- assert.NotNil(t, result)
+ // synchronous
+ for i := 0; i < 5; i++ {
+ submitCount(i, client, t)
+ }
- g := cloneGraphTraversalSource(&Graph{}, NewGremlinLang(nil), nil)
- b := g.V().Count().Bytecode
- resultSet, err = client.submitBytecode(b)
- assert.Nil(t, err)
- assert.NotNil(t, resultSet)
- result, ok, err = resultSet.One()
- assert.Nil(t, err)
- assert.True(t, ok)
- assert.NotNil(t, result)
+ // async
+ var wg sync.WaitGroup
+ for i := 0; i < 5; i++ {
+ wg.Add(1)
+ go func(i int) {
+ defer wg.Done()
+ submitCount(i, client, t)
+ }(i)
+ }
+ wg.Wait()
+
+ //
+ //g := cloneGraphTraversalSource(&Graph{}, NewGremlinLang(nil), nil)
+ //b := g.V().Count().Bytecode
+ //resultSet, err = client.submitBytecode(b)
+ //assert.Nil(t, err)
+ //assert.NotNil(t, resultSet)
+ //result, ok, err = resultSet.One()
+ //assert.Nil(t, err)
+ //assert.True(t, ok)
+ //assert.NotNil(t, result)
})
t.Run("Test client.submit() on session", func(t *testing.T) {
@@ -1105,28 +811,6 @@ func TestConnection(t *testing.T) {
dropGraph(t, g)
})
- // This test needs to be run as a standalone since other tests running can cause goroutine count to fluctuate.
- // If this test is not run manually and isolated it will have floating failures.
- t.Run("Test connection goroutine cleanup", func(t *testing.T) {
- skipTestsIfNotEnabled(t, manualTestSuiteName, testManual)
-
- startCount := runtime.NumGoroutine()
-
- connection, err := createConnection(testNoAuthUrl, newLogHandler(&defaultLogger{}, Info, language.English),
- newDefaultConnectionSettings())
- assert.Nil(t, err)
- assert.NotNil(t, connection)
- assert.Equal(t, established, connection.state)
-
- // Read loop, write loop, this routine.
- assert.Equal(t, startCount+2, runtime.NumGoroutine())
-
- assert.Nil(t, connection.close())
-
- // This routine.
- assert.Equal(t, startCount, runtime.NumGoroutine())
- })
-
t.Run("Test per-request arguments", func(t *testing.T) {
skipTestsIfNotEnabled(t, integrationTestSuiteName, testNoAuthEnable)
@@ -1268,3 +952,16 @@ func TestConnection(t *testing.T) {
}
})
}
+
+func submitCount(i int, client *Client, t *testing.T) {
+ resultSet, err := client.Submit("g.V().count().as('c').math('c + " + strconv.Itoa(i) + "')")
+ assert.Nil(t, err)
+ assert.NotNil(t, resultSet)
+ result, ok, err := resultSet.One()
+ assert.Nil(t, err)
+ assert.True(t, ok)
+ assert.NotNil(t, result)
+ c, err := result.GetInt()
+ assert.Equal(t, 6+i, c)
+ _, _ = fmt.Fprintf(os.Stdout, "Received result : %s\n", result)
+}
diff --git a/gremlin-go/driver/cucumber/cucumberWorld.go b/gremlin-go/driver/cucumber/cucumberWorld.go
index f0498d1536..46f1d00177 100644
--- a/gremlin-go/driver/cucumber/cucumberWorld.go
+++ b/gremlin-go/driver/cucumber/cucumberWorld.go
@@ -68,7 +68,7 @@ func getEnvOrDefaultInt(key string, defaultValue int) int {
}
func scenarioUrl() string {
- return getEnvOrDefaultString("GREMLIN_SERVER_URL", "ws://localhost:45940/gremlin")
+ return getEnvOrDefaultString("GREMLIN_SERVER_URL", "http://localhost:45940/gremlin")
}
func NewCucumberWorld() *CucumberWorld {
diff --git a/gremlin-go/driver/cucumber/gremlin.go b/gremlin-go/driver/cucumber/gremlin.go
index 667ae6d1f3..ff50ce70ca 100644
--- a/gremlin-go/driver/cucumber/gremlin.go
+++ b/gremlin-go/driver/cucumber/gremlin.go
@@ -32,13 +32,11 @@ import (
)
var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal{
- "g_V_branchXlabel_eq_person__a_bX_optionXa__ageX_optionXb__langX_optionXb__nameX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}}, // skipping as it contains a lambda
"g_V_branchXlabel_isXpersonX_countX_optionX1__ageX_optionX0__langX_optionX0__nameX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Branch(gremlingo.T__.Label().Is("person").Count()).Option(p["xx1"], gremlingo.T__.Values("age")).Option(p["xx2"], gremlingo.T__.Values("lang")).Option(p["xx2"], gremlingo.T__.Values("name"))}},
"g_V_branchXlabel_isXpersonX_countX_optionX1__ageX_optionX0__langX_optionX0__nameX_optionXany__labelX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Branch(gremlingo.T__.Label().Is("person").Count()).Option(p["xx1"], gremlingo.T__.Values("age")).Option(p["xx2"], gremlingo.T__.Values("lang")).Option(p["xx2"], gremlingo.T__.Values("name")).Option(gremlingo.Pick.Any, gremlingo.T__.Label())}},
"g_V_branchXageX_optionXltX30X__youngX_optionXgtX30X__oldX_optionXnone__on_the_edgeX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("person").Branch(gremlingo.T__.Values("age")).Option(gremlingo.P.Lt(30), gremlingo.T__.Constant("young")).Option(gremlingo.P.Gt(30), gremlingo.T__.Constant("old")).Option(gremlingo.Pick.None, gremlingo.T__.Constant("on the edge"))}},
"g_V_branchXidentityX_optionXhasLabelXsoftwareX__inXcreatedX_name_order_foldX_optionXhasXname_vadasX__ageX_optionXneqX123X__bothE_countX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Branch(gremlingo.T__.Identity()).Option(gremlingo.T__.HasLabel("software"), gremlingo.T__.In("created").Values("name").Order().Fold()).Option(gremlingo.T__.Has("name", "vadas"), gremlingo.T__.Values("age")).Option(gremlingo.P.Neq(123), gremli [...]
"g_V_chooseXout_countX_optionX2L_nameX_optionX3L_ageX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Choose(gremlingo.T__.Out().Count()).Option(p["xx1"], gremlingo.T__.Values("name")).Option(p["xx2"], gremlingo.T__.Values("age"))}},
- "g_V_chooseXlabel_eqXpersonX__outXknowsX__inXcreatedXX_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}}, // skipping as it contains a lambda
"g_V_chooseXhasLabelXpersonX_and_outXcreatedX__outXknowsX__identityX_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Choose(gremlingo.T__.HasLabel("person").And().Out("created"), gremlingo.T__.Out("knows"), gremlingo.T__.Identity()).Values("name")}},
"g_V_chooseXlabelX_optionXblah__outXknowsXX_optionXbleep__outXcreatedXX_optionXnone__identityX_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Choose(gremlingo.T__.Label()).Option("blah", gremlingo.T__.Out("knows")).Option("bleep", gremlingo.T__.Out("created")).Option(gremlingo.Pick.None, gremlingo.T__.Identity()).Values("name")}},
"g_V_chooseXoutXknowsX_count_isXgtX0XX__outXknowsXX_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Choose(gremlingo.T__.Out("knows").Count().Is(gremlingo.P.Gt(0)), gremlingo.T__.Out("knows")).Values("name")}},
@@ -75,7 +73,6 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
"g_VX1X_repeatXgroupCountXmX_byXloopsX_outX_timesX3X_capXmX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Repeat(gremlingo.T__.GroupCount("m").By(gremlingo.T__.Loops()).Out()).Times(3).Cap("m")}},
"g_V_repeatXbothX_timesX10X_asXaX_out_asXbX_selectXa_bX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Repeat(gremlingo.T__.Both()).Times(10).As("a").Out().As("b").Select("a", "b").Count()}},
"g_VX1X_repeatXoutX_untilXoutE_count_isX0XX_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Repeat(gremlingo.T__.Out()).Until(gremlingo.T__.OutE().Count().Is(0)).Values("name")}},
- "g_V_repeatXbothX_untilXname_eq_marko_or_loops_gt_1X_groupCount_byXnameX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}}, // skipping as it contains a lambda
"g_V_hasXname_markoX_repeatXoutE_inV_simplePathX_untilXhasXname_rippleXX_path_byXnameX_byXlabelX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has("name", "marko").Repeat(gremlingo.T__.OutE().InV().SimplePath()).Until(gremlingo.T__.Has("name", "ripple")).Path().By("name").By(gremlingo.T.Label)}},
"g_V_hasXloop_name_loopX_repeatXinX_timesX5X_path_by_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has("loops", "name", "loop").Repeat(gremlingo.T__.In()).Times(5).Path().By("name")}},
"g_V_repeatXout_repeatXout_order_byXname_descXX_timesX1XX_timesX1X_limitX1X_path_byXnameX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Repeat(gremlingo.T__.Out().Repeat(gremlingo.T__.Out().Order().By("name", gremlingo.Order.Desc)).Times(1)).Times(1).Limit(1).Path().By("name")}},
@@ -135,6 +132,7 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
"g_injectXnull_nullX_anyXeqXnullXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Any(gremlingo.P.Eq(nil))}},
"g_injectX3_threeX_anyXeqX3XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Any(gremlingo.P.Eq(3))}},
"g_V_coinX1X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Coin(1.0)}},
+ "g_V_coinX1varX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Coin(p["xx1"])}},
"g_V_coinX0X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Coin(0.0)}},
"g_withStrategiesXSeedStrategyX_V_order_byXnameX_coinX50X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithStrategies(gremlingo.SeedStrategy(gremlingo.SeedStrategyConfig{Seed: 999999})).V().Order().By("name").Coin(0.5)}},
"g_VX1X_outXcreatedX_inXcreatedX_cyclicPath": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Out("created").In("created").CyclicPath()}},
@@ -147,7 +145,6 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
"g_V_out_asXxX_in_asXyX_selectXx_yX_byXnameX_fold_dedupXlocal_x_yX_unfold": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().As("x").In().As("y").Select("x", "y").By("name").Fold().Dedup(gremlingo.Scope.Local, "x", "y").Unfold()}},
"g_V_both_dedup_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Both().Dedup().Values("name")}},
"g_V_both_hasXlabel_softwareX_dedup_byXlangX_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Both().Has(gremlingo.T.Label, "software").Dedup().By("lang").Values("name")}},
- "g_V_both_name_order_byXa_bX_dedup_value": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Both().Properties("name").Order().By(p["c1"]).Dedup().Value()}},
"g_V_both_both_name_dedup": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Both().Both().Values("name").Dedup()}},
"g_V_both_both_dedup": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Both().Both().Dedup()}},
"g_V_both_both_dedup_byXlabelX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Both().Both().Dedup().By(gremlingo.T.Label)}},
@@ -173,24 +170,21 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
"g_V_count_discard": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Count().Discard()}},
"g_V_hasLabelXpersonX_discard": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("person").Discard()}},
"g_VX1X_outXcreatedX_discard": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Out("created").Discard()}},
+ "g_V_discard": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Discard()}},
+ "g_V_discard_discard": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Discard().Discard()}},
+ "g_V_discard_fold": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Discard().Fold()}},
+ "g_V_discard_fold_discard": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Discard().Fold().Discard()}},
+ "g_V_discard_fold_constantX1X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Discard().Fold().Constant(1)}},
+ "g_V_projectXxX_byXcoalesceXage_isXgtX29XX_discardXX_selectXxX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Project("x").By(gremlingo.T__.Coalesce(gremlingo.T__.Values("age").Is(gremlingo.P.Gt(29)), gremlingo.T__.Discard())).Select("x")}},
"g_V_drop": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV().As("a").AddV().As("b").AddE("knows").To("a")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Drop()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {ret [...]
"g_V_outE_drop": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV().As("a").AddV().As("b").AddE("knows").To("a")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().OutE().Drop()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTr [...]
"g_V_properties_drop": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV().Property("name", "bob").AddV().Property("name", "alice")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Properties().Drop()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V()}, func(g *gremlingo.GraphTraversalSource, p map[string]interfa [...]
"g_E_propertiesXweightX_drop": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh").Property("age", 32).As("josh").AddV("software").Property("name", "ripple").Property("lang", [...]
"g_V_properties_propertiesXstartTimeX_drop": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV().Property("name", "bob").Property(gremlingo.Cardinality.List, "location", "ny", "startTime", 2014, "endTime", 2016).Property(gremlingo.Cardinality.List, "location", "va", "startTime", 2016).AddV().Property("name", "alice").Property(gremlingo.Cardinality.List, "location", "va", "startTime", 2014, "endTime", 2016).Property(gremlingo.C [...]
- "g_V_filterXfalseX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}}, // skipping as it contains a lambda
- "g_V_filterXtrueX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}}, // skipping as it contains a lambda
- "g_V_filterXlang_eq_javaX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}}, // skipping as it contains a lambda
- "g_VX1X_filterXage_gt_30X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}}, // skipping as it contains a lambda
- "g_VX2X_filterXage_gt_30X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}}, // skipping as it contains a lambda
- "g_VX1X_out_filterXage_gt_30X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}}, // skipping as it contains a lambda
- "g_V_filterXname_startsWith_m_OR_name_startsWith_pX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}}, // skipping as it contains a lambda
- "g_E_filterXfalseX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}}, // skipping as it contains a lambda
- "g_E_filterXtrueX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}}, // skipping as it contains a lambda
- "g_V_outXcreatedX_hasXname__mapXlengthX_isXgtX3XXX_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}}, // skipping as it contains a lambda
"g_VX1X_hasXnameX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Has("name")}},
"g_VX1X_hasXcircumferenceX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Has("circumference")}},
"g_VX1X_hasXname_markoX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Has("name", "marko")}},
+ "g_VX1X_hasXname_markovarX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Has("name", p["xx1"])}},
"g_VX2X_hasXname_markoX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Has("name", "marko")}},
"g_V_hasXname_markoX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has("name", "marko")}},
"g_V_hasXname_blahX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has("name", "blah")}},
@@ -198,6 +192,7 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
"g_V_hasXage_isXgt_30XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has("age", gremlingo.T__.Is(gremlingo.P.Gt(30)))}},
"g_V_hasXlabel_isXsoftwareXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has(gremlingo.T.Label, gremlingo.T__.Is("software"))}},
"g_VX1X_hasXage_gt_30X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Has("age", gremlingo.P.Gt(30))}},
+ "g_V_hasXpersonvar_age_gt_30X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has(p["xx1"], "age", gremlingo.P.Gt(30))}},
"g_VX4X_hasXage_gt_30X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid4"]).Has("age", gremlingo.P.Gt(30))}},
"g_VXv1X_hasXage_gt_30X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["v1"]).Has("age", gremlingo.P.Gt(30))}},
"g_VXv4X_hasXage_gt_30X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["v4"]).Has("age", gremlingo.P.Gt(30))}},
@@ -247,6 +242,8 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
"g_V_hasIdXnullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasId(nil)}},
"g_V_hasIdXeqXnullXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasId(gremlingo.P.Eq(nil))}},
"g_V_hasIdX2_nullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasId(p["vid2"], nil)}},
+ "g_V_hasIdXmarkovar_vadasvarX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasId(p["vid1"], p["vid2"])}},
+ "g_V_hasIdXmarkovar_vadasvar_petervarX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasId(p["vid1"], p["vid2"])}},
"g_V_hasIdX2AsString_nullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasId(p["vid2"], nil)}},
"g_V_hasIdX1AsString_2AsString_nullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasId(p["vid1"], p["vid2"], nil)}},
"g_V_hasIdXnull_2X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasId(nil, p["vid2"])}},
@@ -273,6 +270,7 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
"g_E_hasLabelXknowsX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E().HasLabel("knows")}},
"g_E_hasLabelXuses_traversesX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E().HasLabel("uses", "traverses")}},
"g_V_hasLabelXperson_software_blahX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("person", "software", "blah")}},
+ "g_V_hasLabelXperson_softwarevarX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("person", p["xx1"])}},
"g_V_hasLabelXpersonX_hasLabelXsoftwareX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("person").HasLabel("software")}},
"g_V_hasLabelXpersonvarX_hasLabelXsoftwareX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel(p["xx1"]).HasLabel("software")}},
"g_V_hasLabelXpersonvar_softwarevarX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel(p["xx1"], p["xx2"])}},
@@ -289,8 +287,11 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
"g_V_properties_hasValueXnull_nullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Properties().HasValue(nil, nil)}},
"g_V_properties_hasValueXnull_joshX_value": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Properties().HasValue(nil, "josh").Value()}},
"g_V_valuesXageX_isX32X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("age").Is(32)}},
+ "g_V_valuesXageX_isX32varX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("age").Is(p["xx1"])}},
"g_V_valuesXageX_isXlte_30X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("age").Is(gremlingo.P.Lte(30))}},
+ "g_V_valuesXageX_isXlte_30varX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("age").Is(gremlingo.P.Lte(p["xx1"]))}},
"g_V_valuesXageX_isXgte_29X_isXlt_34X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("age").Is(gremlingo.P.Gte(29)).Is(gremlingo.P.Lt(34))}},
+ "g_V_valuesXageX_isXgte_29vaarX_isXlt_34varX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("age").Is(gremlingo.P.Gte(p["xx1"])).Is(gremlingo.P.Lt(p["xx2"]))}},
"g_V_whereXinXcreatedX_count_isX1XX_valuesXnameX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Where(gremlingo.T__.In("created").Count().Is(1)).Values("name")}},
"g_V_whereXinXcreatedX_count_isXgte_2XX_valuesXnameX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Where(gremlingo.T__.In("created").Count().Is(gremlingo.P.Gte(2))).Values("name")}},
"g_V_valuesXageX_noneXgtX32XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("age").None(gremlingo.P.Gt(32))}},
@@ -310,23 +311,25 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
"g_V_orXoutEXknowsX__hasXlabel_softwareX_or_hasXage_gte_35XX_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Or(gremlingo.T__.OutE("knows"), gremlingo.T__.Has(gremlingo.T.Label, "software").Or().Has("age", gremlingo.P.Gte(35))).Values("name")}},
"g_V_asXaX_orXselectXaX_selectXaXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("a").Or(gremlingo.T__.Select("a"), gremlingo.T__.Select("a"))}},
"g_VX1X_out_limitX2X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Out().Limit(2)}},
+ "g_VX1X_out_limitX2varX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Out().Limit(p["xx1"])}},
"g_V_localXoutE_limitX1X_inVX_limitX3X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Local(gremlingo.T__.OutE().Limit(1)).InV().Limit(3)}},
"g_VX1X_outXknowsX_outEXcreatedX_rangeX0_1X_inV": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Out("knows").OutE("created").Range(0, 1).InV()}},
"g_VX1X_outXknowsX_outXcreatedX_rangeX0_1X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Out("knows").Out("created").Range(0, 1)}},
"g_VX1X_outXcreatedX_inXcreatedX_rangeX1_3X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Out("created").In("created").Range(1, 3)}},
+ "g_VX1X_outXcreatedX_inXcreatedX_rangeX1var_3varX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Out("created").In("created").Range(p["xx1"], p["xx2"])}},
"g_VX1X_outXcreatedX_inEXcreatedX_rangeX1_3X_outV": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Out("created").InE("created").Range(1, 3).OutV()}},
"g_V_repeatXbothX_timesX3X_rangeX5_11X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Repeat(gremlingo.T__.Both()).Times(3).Range(5, 11)}},
"g_V_asXaX_in_asXbX_in_asXcX_selectXa_b_cX_byXnameX_limitXlocal_2X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("a").In().As("b").In().As("c").Select("a", "b", "c").By("name").Limit(gremlingo.Scope.Local, 2)}},
+ "g_V_asXaX_in_asXbX_in_asXcX_selectXa_b_cX_byXnameX_limitXlocal_2varX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("a").In().As("b").In().As("c").Select("a", "b", "c").By("name").Limit(gremlingo.Scope.Local, p["xx1"])}},
"g_V_asXaX_in_asXbX_in_asXcX_selectXa_b_cX_byXnameX_limitXlocal_1X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("a").In().As("b").In().As("c").Select("a", "b", "c").By("name").Limit(gremlingo.Scope.Local, 1)}},
"g_V_asXaX_out_asXbX_out_asXcX_selectXa_b_cX_byXnameX_rangeXlocal_1_3X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("a").Out().As("b").Out().As("c").Select("a", "b", "c").By("name").Range(gremlingo.Scope.Local, 1, 3)}},
+ "g_V_asXaX_out_asXbX_out_asXcX_selectXa_b_cX_byXnameX_rangeXlocal_1var_3varX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("a").Out().As("b").Out().As("c").Select("a", "b", "c").By("name").Range(gremlingo.Scope.Local, p["xx1"], p["xx2"])}},
"g_V_asXaX_out_asXbX_out_asXcX_selectXa_b_cX_byXnameX_rangeXlocal_1_2X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("a").Out().As("b").Out().As("c").Select("a", "b", "c").By("name").Range(gremlingo.Scope.Local, 1, 2)}},
- "g_V_asXaX_out_asXaX_out_asXaX_selectXmixed_aX_byXunfold_valuesXnameX_foldX_rangeXlocal_1_3X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("a").Out().As("a").Out().As("a").Select(gremlingo.Pop.Mixed, "a").By(gremlingo.T__.Unfold().Values("name").Fold()).Range(gremlingo.Scope.Local, 1, 3)}},
- "g_V_asXaX_out_asXaX_out_asXaX_selectXmixed_aX_byXunfold_valuesXnameX_foldX_rangeXlocal_1_2X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("a").Out().As("a").Out().As("a").Select(gremlingo.Pop.Mixed, "a").By(gremlingo.T__.Unfold().Values("name").Fold()).Range(gremlingo.Scope.Local, 1, 2)}},
"g_V_hasLabelXpersonX_order_byXageX_skipX1X_valuesXnameX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("person").Order().By("age").Skip(1).Values("name")}},
- "g_V_asXaX_out_asXaX_out_asXaX_selectXmixed_aX_byXunfold_valuesXnameX_foldX_rangeXlocal_4_5X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("a").Out().As("a").Out().As("a").Select(gremlingo.Pop.Mixed, "a").By(gremlingo.T__.Unfold().Values("name").Fold()).Range(gremlingo.Scope.Local, 4, 5)}},
+ "g_V_hasLabelXpersonX_order_byXageX_skipX1varX_valuesXnameX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("person").Order().By("age").Skip(p["xx1"]).Values("name")}},
+ "g_V_foldX_rangeXlocal_6_7X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Fold().Range(gremlingo.Scope.Local, 6, 7)}},
"g_V_outE_valuesXweightX_fold_orderXlocalX_skipXlocal_2X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().OutE().Values("weight").Fold().Order(gremlingo.Scope.Local).Skip(gremlingo.Scope.Local, 2)}},
- "g_V_asXaX_in_asXaX_in_asXaX_selectXmixed_aX_byXunfold_valuesXnameX_foldX_limitXlocal_1X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("a").In().As("a").In().As("a").Select(gremlingo.Pop.Mixed, "a").By(gremlingo.T__.Unfold().Values("name").Fold()).Limit(gremlingo.Scope.Local, 1)}},
- "g_V_asXaX_in_asXaX_in_asXaX_selectXmixed_aX_byXunfold_valuesXnameX_foldX_limitXlocal_2X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("a").In().As("a").In().As("a").Select(gremlingo.Pop.Mixed, "a").By(gremlingo.T__.Unfold().Values("name").Fold()).Limit(gremlingo.Scope.Local, 2)}},
+ "g_V_outE_valuesXweightX_fold_orderXlocalX_skipXlocal_2varX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().OutE().Values("weight").Fold().Order(gremlingo.Scope.Local).Skip(gremlingo.Scope.Local, p["xx1"])}},
"g_V_hasLabelXpersonX_order_byXageX_valuesXnameX_skipX1X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("person").Order().By("age").Values("name").Skip(1)}},
"g_VX1X_valuesXageX_rangeXlocal_20_30X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Values("age").Range(gremlingo.Scope.Local, 20, 30)}},
"g_V_mapXin_hasIdX1XX_limitX2X_valuesXnameX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Map(gremlingo.T__.In().HasId(p["vid1"])).Limit(2).Values("name")}},
@@ -344,6 +347,7 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
"g_V_both_asXaX_both_asXbX_simplePath_path_byXageX__fromXaX_toXbX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Both().As("a").Both().As("b").SimplePath().Path().By("age").From("a").To("b")}},
"g_V_valuesXnameX_order_tailXglobal_2X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Order().Tail(gremlingo.Scope.Global, 2)}},
"g_V_valuesXnameX_order_tailX2X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Order().Tail(2)}},
+ "g_V_valuesXnameX_order_tailX2varX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Order().Tail(p["xx1"])}},
"g_V_valuesXnameX_order_tail": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Order().Tail()}},
"g_V_valuesXnameX_order_tailX7X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Order().Tail(7)}},
"g_V_repeatXbothX_timesX3X_tailX7X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Repeat(gremlingo.T__.Both()).Times(3).Tail(7)}},
@@ -351,6 +355,7 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
"g_V_asXaX_out_asXaX_out_asXaX_selectXaX_byXunfold_valuesXnameX_foldX_tailXlocal_1X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("a").Out().As("a").Out().As("a").Select("a").By(gremlingo.T__.Unfold().Values("name").Fold()).Tail(gremlingo.Scope.Local, 1)}},
"g_V_asXaX_out_asXaX_out_asXaX_selectXaX_byXunfold_valuesXnameX_foldX_tailXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("a").Out().As("a").Out().As("a").Select("a").By(gremlingo.T__.Unfold().Values("name").Fold()).Tail(gremlingo.Scope.Local)}},
"g_V_asXaX_out_asXbX_out_asXcX_selectXa_b_cX_byXnameX_tailXlocal_2X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("a").Out().As("b").Out().As("c").Select("a", "b", "c").By("name").Tail(gremlingo.Scope.Local, 2)}},
+ "g_V_asXaX_out_asXbX_out_asXcX_selectXa_b_cX_byXnameX_tailXlocal_2varX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("a").Out().As("b").Out().As("c").Select("a", "b", "c").By("name").Tail(gremlingo.Scope.Local, p["xx1"])}},
"g_V_asXaX_out_asXbX_out_asXcX_selectXa_b_cX_byXnameX_tailXlocal_1X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("a").Out().As("b").Out().As("c").Select("a", "b", "c").By("name").Tail(gremlingo.Scope.Local, 1)}},
"g_V_asXaX_out_asXaX_out_asXaX_selectXmixed_aX_byXunfold_valuesXnameX_foldX_tailXlocal_1X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("a").Out().As("a").Out().As("a").Select(gremlingo.Pop.Mixed, "a").By(gremlingo.T__.Unfold().Values("name").Fold()).Tail(gremlingo.Scope.Local, 1)}},
"g_V_asXaX_out_asXaX_out_asXaX_selectXmixed_aX_byXunfold_valuesXnameX_foldX_tailXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("a").Out().As("a").Out().As("a").Select(gremlingo.Pop.Mixed, "a").By(gremlingo.T__.Unfold().Values("name").Fold()).Tail(gremlingo.Scope.Local)}},
@@ -362,7 +367,7 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
"g_V_hasXageX_asXaX_out_in_hasXageX_asXbX_selectXa_bX_whereXb_hasXname_markoXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has("age").As("a").Out().In().Has("age").As("b").Select("a", "b").Where(gremlingo.T__.As("b").Has("name", "marko"))}},
"g_V_hasXageX_asXaX_out_in_hasXageX_asXbX_selectXa_bX_whereXa_outXknowsX_bX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has("age").As("a").Out().In().Has("age").As("b").Select("a", "b").Where(gremlingo.T__.As("a").Out("knows").As("b"))}},
"g_V_asXaX_outXcreatedX_whereXasXaX_name_isXjoshXX_inXcreatedX_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("a").Out("created").Where(gremlingo.T__.As("a").Values("name").Is("josh")).In("created").Values("name")}},
- "g_withSideEffectXa_josh_peterX_VX1X_outXcreatedX_inXcreatedX_name_whereXwithinXaXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithSideEffect("a", p["xx1"]).V(p["vid1"]).Out("created").In("created").Values("name").Where(gremlingo.P.Within("a"))}},
+ "g_withSideEffectXa_josh_peterX_VX1X_outXcreatedX_inXcreatedX_name_whereXwithinXaXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithSideEffect("a", []interface{}{"josh", "peter"}).V(p["vid1"]).Out("created").In("created").Values("name").Where(gremlingo.P.Within("a"))}},
"g_VX1X_asXaX_outXcreatedX_inXcreatedX_asXbX_whereXa_neqXbXX_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).As("a").Out("created").In("created").As("b").Where("a", gremlingo.P.Neq("b")).Values("name")}},
"g_VX1X_asXaX_outXcreatedX_inXcreatedX_asXbX_whereXasXbX_outXcreatedX_hasXname_rippleXX_valuesXage_nameX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).As("a").Out("created").In("created").As("b").Where(gremlingo.T__.As("b").Out("created").Has("name", "ripple")).Values("age", "name")}},
"g_VX1X_asXaX_outXcreatedX_inXcreatedX_whereXeqXaXX_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).As("a").Out("created").In("created").Where(gremlingo.P.Eq("a")).Values("name")}},
@@ -419,8 +424,6 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
"g_withoutStrategiesXIncidentToAdjacentStrategyX_V_outE_inV": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithoutStrategies(IncidentToAdjacentStrategy).V().OutE().InV()}},
"g_withStrategiesXInlineFilterStrategyX_V_filterXhasXname_markoXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithStrategies(gremlingo.InlineFilterStrategy()).V().Filter(gremlingo.T__.Has("name", "marko"))}},
"g_withoutStrategiesXInlineFilterStrategyX_V_filterXhasXname_markoXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithoutStrategies(InlineFilterStrategy).V().Filter(gremlingo.T__.Has("name", "marko"))}},
- "g_withStrategiesXLambdaRestrictionStrategyX_V": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}}, // skipping as it contains a lambda
- "g_withoutStrategiesXLambdaRestrictionStrategyX_V": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}}, // skipping as it contains a lambda
"g_withStrategiesXLazyBarrierStrategyX_V_out_bothE_count": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithStrategies(gremlingo.LazyBarrierStrategy()).V().Out().BothE().Count()}},
"g_withoutStrategiesXLazyBarrierStrategyX_V_out_bothE_count": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithoutStrategies(LazyBarrierStrategy).V().Out().BothE().Count()}},
"g_withStrategiesXMatchAlgorithmStrategyXmatchAlgorithm_CountMatchAlgorithmXX_V_matchXa_knows_b__a_created_cX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithStrategies(gremlingo.MatchAlgorithmStrategy(gremlingo.MatchAlgorithmStrategyConfig{MatchAlgorithm: "org.apache.tinkerpop.gremlin.process.traversal.step.map.MatchStep$CountMatchAlgorithm"})).V().Match(gremlingo.T__.As("a").Out("knows").As("b"), gremlingo.T__.As("a").Out [...]
@@ -567,11 +570,16 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
"g_V_hasXname_markoX_asXaX_outEXcreatedX_asXbX_inV_addEXselectXbX_labelX_toXaX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh").Property("age", 32).As("josh").AddV("softw [...]
"g_addEXV_outE_label_groupCount_orderXlocalX_byXvalues_descX_selectXkeysX_unfold_limitX1XX_fromXV_hasXname_vadasXX_toXV_hasXname_lopXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java").As("lop").AddV("person").Property("n [...]
"g_addEXknowsX_fromXaX_toXbX_propertyXweight_0_1X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh").Property("age", 32).As("josh").AddV("software").Property("name", "rippl [...]
+ "g_addEXknowsvarX_fromXaX_toXbX_propertyXweight_0_1X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh").Property("age", 32).As("josh").AddV("software").Property("name", "ri [...]
"g_VXaX_addEXknowsX_toXbX_propertyXweight_0_1X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh").Property("age", 32).As("josh").AddV("software").Property("name", "ripple") [...]
"g_addEXknowsXpropertyXweight_nullXfromXV_hasXname_markoXX_toXV_hasXname_vadasXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).AddV("person").Property("name", "vadas").Property("age", 27)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddE("knows").Property("weight", nil).From(gremlingo.T__.V().Has("name", "ma [...]
+ "g_addEXknowsvarXpropertyXweight_nullXfromXV_hasXname_markoXX_toXV_hasXname_vadasXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).AddV("person").Property("name", "vadas").Property("age", 27)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddE(p["xx1"]).Property("weight", nil).From(gremlingo.T__.V().Has("name", [...]
+ "g_unionXaddEXknowsvarXpropertyXweight_nullXfromXV_hasXname_markoXX_toXV_hasXname_vadasXXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).AddV("person").Property("name", "vadas").Property("age", 27)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Union(gremlingo.T__.AddE(p["xx1"]).Property("weight", 1).From(grem [...]
"g_VX1X_addVXanimalX_propertyXage_selectXaX_byXageXX_propertyXname_puppyX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh").Property("age", 32).As("josh").AddV("software") [...]
"g_V_addVXanimalX_propertyXage_0X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh").Property("age", 32).As("josh").AddV("software").Property("name", "ripple").Property("la [...]
+ "g_V_addVXanimalvarX_propertyXage_0varX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh").Property("age", 32).As("josh").AddV("software").Property("name", "ripple").Proper [...]
"g_addVXpersonX_propertyXname_stephenX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh").Property("age", 32).As("josh").AddV("software").Property("name", "ripple").Propert [...]
+ "g_addVXpersonvarX_propertyXname_stephenvarX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh").Property("age", 32).As("josh").AddV("software").Property("name", "ripple").P [...]
"g_V_hasLabelXpersonX_propertyXname_nullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh").Property("age", 32).As("josh").AddV("software").Property("name", "ripple").Prop [...]
"g_addVXpersonX_propertyXsingle_name_stephenX_propertyXsingle_name_stephenmX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh").Property("age", 32).As("josh").AddV("softwar [...]
"get_g_addVXpersonX_propertyXsingle_name_stephenX_propertyXsingle_name_stephenm_since_2010X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh").Property("age", 32).As("josh" [...]
@@ -585,6 +593,9 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
"g_V_asXaX_hasXname_markoX_outXcreatedX_asXbX_addVXselectXaX_labelX_propertyXtest_selectXbX_labelX_valueMap_withXtokensX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh"). [...]
"g_addVXV_hasXname_markoX_propertiesXnameX_keyX_label": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh").Property("age", 32).As("josh").AddV("software").Property("name", "r [...]
"g_addV_propertyXlabel_personX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV().Property(gremlingo.T.Label, "person")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("person")}},
+ "g_addV_propertyXlabel_personvarX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV().Property(gremlingo.T.Label, p["xx1"])}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("person")}},
+ "g_addV_propertyXid_1X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV().Property(gremlingo.T.Id, 1)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasId("1")}},
+ "g_addV_propertyXidvar_1varX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV().Property(gremlingo.T.Id, p["xx1"])}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasId("1")}},
"g_addV_propertyXmapX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV().Property(map[interface{}]interface{}{"name": "foo", "age": 42 })}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has("name", "foo")}},
"g_addV_propertyXsingle_mapX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV().Property(gremlingo.Cardinality.Single, map[interface{}]interface{}{"name": "foo", "age": 42 })}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has("name", "foo")}},
"g_V_hasXname_fooX_propertyXname_setXbarX_age_43X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV().Property(gremlingo.Cardinality.Single, "name", "foo").Property("age", 42)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has("name", "foo").Property(map[interface{}]interface{}{"name": gremlingo.CardinalityValue.Set("bar"), "age": 43 })}, func(g *gremlingo.GraphTra [...]
@@ -649,6 +660,7 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
"g_V_fold_combineXconstantXnullXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Fold().Combine(gremlingo.T__.Constant(nil))}},
"g_V_fold_combineXVX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Fold().Combine(gremlingo.T__.V())}},
"g_V_valuesXnameX_fold_combineX2X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Combine(2)}},
+ "g_V_valuesXnameX_fold_combineX2varX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Combine(p["xx1"])}},
"g_V_valuesXnameX_fold_combineXnullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Combine(nil)}},
"g_V_valuesXnonexistantX_fold_combineXV_valuesXnameX_foldX_unfold": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("nonexistant").Fold().Combine(gremlingo.T__.V().Values("name").Fold()).Unfold()}},
"g_V_valuesXnameX_fold_combineXV_valuesXnonexistantX_foldX_unfold": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Combine(gremlingo.T__.V().Values("nonexistant").Fold()).Unfold()}},
@@ -725,6 +737,7 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
"g_V_fold_differenceXconstantXnullXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Fold().Difference(gremlingo.T__.Constant(nil))}},
"g_V_fold_differenceXVX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Fold().Difference(gremlingo.T__.V())}},
"g_V_valuesXnameX_fold_differenceX2X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Difference(2)}},
+ "g_V_valuesXnameX_fold_differenceX2varX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Difference(p["xx1"])}},
"g_V_valuesXnameX_fold_differenceXnullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Difference(nil)}},
"g_V_valuesXnonexistantX_fold_differenceXV_valuesXnameX_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("nonexistant").Fold().Difference(gremlingo.T__.V().Values("name").Fold())}},
"g_V_valuesXnameX_fold_differenceXV_valuesXnonexistantX_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Difference(gremlingo.T__.V().Values("nonexistant").Fold())}},
@@ -744,6 +757,7 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
"g_V_fold_disjunctXconstantXnullXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Fold().Disjunct(gremlingo.T__.Constant(nil))}},
"g_V_fold_disjunctXVX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Fold().Disjunct(gremlingo.T__.V())}},
"g_V_valuesXnameX_fold_disjunctX2X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Disjunct(2)}},
+ "g_V_valuesXnameX_fold_disjunctX3varX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Disjunct(p["xx1"])}},
"g_V_valuesXnameX_fold_disjunctXnullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Disjunct(nil)}},
"g_V_valuesXnonexistantX_fold_disjunctXV_valuesXnameX_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("nonexistant").Fold().Disjunct(gremlingo.T__.V().Values("name").Fold())}},
"g_V_valuesXnameX_fold_disjunctXV_valuesXnonexistantX_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Disjunct(gremlingo.T__.V().Values("nonexistant").Fold())}},
@@ -756,12 +770,33 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
"g_injectXa_null_bX_disjunctXa_cX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Disjunct(p["xx2"])}},
"g_injectXa_null_bX_disjunctXa_null_cX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Disjunct(p["xx2"])}},
"g_injectX3_threeX_disjunctXfive_three_7X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"]).Disjunct(p["xx2"])}},
+ "g_E": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E()}},
+ "g_EX11X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E(p["eid11"])}},
+ "g_EX11AsStringX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E(p["eid11"])}},
+ "g_EXe11X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E(p["e11"])}},
+ "g_EXe7_e11X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E(p["e7"], p["e11"])}},
+ "g_EXlistXe7_e11XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E(p["xx1"])}},
+ "g_EXnullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E(nil)}},
+ "g_EXlistXnullXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E(p["xx1"])}},
+ "g_EX11_nullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E(p["eid11"], nil)}},
"g_V_EX11X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().E(p["eid11"])}},
"g_EX11X_E": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E(p["eid11"]).E()}},
"g_V_EXnullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().E(nil)}},
"g_V_EXlistXnullXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().E(p["xx1"])}},
"g_injectX1X_EX11_nullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(1).E(p["eid11"], nil)}},
"g_injectX1X_coalesceXEX_hasLabelXtestsX_addEXtestsX_from_V_hasXnameX_XjoshXX_toXV_hasXnameX_XvadasXXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "josh").AddV("person").Property("name", "vadas")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(1).Coalesce(gremlingo.T__.E().HasLabel("tests"), gremlingo.T__.AddE("tests").From(gremli [...]
+ "g_VX1X_outE_inV": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).OutE().InV()}},
+ "g_VX2X_inE_outV": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid2"]).InE().OutV()}},
+ "g_V_outE_hasXweight_1X_outV": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().OutE().Has("weight", 1.0).OutV()}},
+ "g_VX1X_outE_otherV": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).OutE().OtherV()}},
+ "g_VX4X_bothE_otherV": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid4"]).BothE().OtherV()}},
+ "g_VX4X_bothE_hasXweight_lt_1X_otherV": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid4"]).BothE().Has("weight", gremlingo.P.Lt(1.0)).OtherV()}},
+ "get_g_VX1X_outE_otherV": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).OutE().OtherV()}},
+ "g_VX1X_outEXknowsX_inV": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).OutE("knows").InV()}},
+ "g_VX1X_outEXknows_createdX_inV": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).OutE("knows", "created").InV()}},
+ "g_VX1X_outEXknowsX_bothV": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).OutE("knows").BothV()}},
+ "g_VX1X_outEXknowsX_bothV_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).OutE("knows").BothV().Values("name")}},
+ "g_V_toEXout_knowsvarX_valuesXweightX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().ToE(gremlingo.Direction.Out, p["xx1"]).Values("weight")}},
"g_VX1X_properties_element": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["v2"]).Properties().Element().Limit(1)}},
"g_V_properties_element": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Properties().Element()}},
"g_V_propertiesXageX_element": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Properties("age").Element()}},
@@ -804,6 +839,7 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
"g_V_fold_intersectXconstantXnullXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Fold().Intersect(gremlingo.T__.Constant(nil))}},
"g_V_fold_intersectXVX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Fold().Intersect(gremlingo.T__.V())}},
"g_V_valuesXnameX_fold_intersectX2X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Intersect(2)}},
+ "g_V_valuesXnameX_fold_intersectX5varX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Intersect(p["xx1"])}},
"g_V_valuesXnameX_fold_intersectXnullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Intersect(nil)}},
"g_V_valuesXnonexistantX_fold_intersectXV_valuesXnameX_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("nonexistant").Fold().Intersect(gremlingo.T__.V().Values("name").Fold())}},
"g_V_valuesXnameX_fold_intersectXV_valuesXnonexistantX_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Intersect(gremlingo.T__.V().Values("nonexistant").Fold())}},
@@ -832,12 +868,6 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
"g_VX1X_repeatXboth_simplePathX_untilXhasXname_peterX_or_loops_isX2XX_hasXname_peterX_path_byXnameX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Repeat(gremlingo.T__.Both().SimplePath()).Until(gremlingo.T__.Has("name", "peter").Or().Loops().Is(2)).Has("name", "peter").Path().By("name")}},
"g_VX1X_repeatXboth_simplePathX_untilXhasXname_peterX_and_loops_isX3XX_hasXname_peterX_path_byXnameX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Repeat(gremlingo.T__.Both().SimplePath()).Until(gremlingo.T__.Has("name", "peter").And().Loops().Is(3)).Has("name", "peter").Path().By("name")}},
"g_V_emitXhasXname_markoX_or_loops_isX2XX_repeatXoutX_valuesXnameX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Emit(gremlingo.T__.Has("name", "marko").Or().Loops().Is(2)).Repeat(gremlingo.T__.Out()).Values("name")}},
- "g_VX1X_mapXnameX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}}, // skipping as it contains a lambda
- "g_VX1X_outE_label_mapXlengthX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}}, // skipping as it contains a lambda
- "g_VX1X_out_mapXnameX_mapXlengthX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}}, // skipping as it contains a lambda
- "g_VX1X_out_mapXlambdaXnameXX_mapXlambdaXlengthXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}}, // skipping as it contains a lambda
- "g_withPath_V_asXaX_out_mapXa_nameX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}}, // skipping as it contains a lambda
- "g_withPath_V_asXaX_out_out_mapXa_name_it_nameX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}}, // skipping as it contains a lambda
"g_V_mapXselectXaXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("a").Map(gremlingo.T__.Select("a"))}},
"g_V_mapXconstantXnullXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Map(gremlingo.T__.Constant(nil))}},
"g_V_valueMap_matchXa_selectXnameX_bX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().ValueMap().Match(gremlingo.T__.As("a").Select("name").As("b"))}},
@@ -946,10 +976,14 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
"g_V_mergeEXlabel_selfX_optionXonMatch_emptyX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).AddE("self")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().MergeE(p["xx1"]).Option(gremlingo.Merge.OnMatch, map[interface{}]interface{}{ })}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *greml [...]
"g_V_mergeEXlabel_selfX_optionXonMatch_nullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).AddE("self")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().MergeE(p["xx1"]).Option(gremlingo.Merge.OnMatch, nil)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return [...]
"g_V_mergeEXemptyX_optionXonCreate_nullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("v").MergeE(p["xx1"]).Option(gremlingo.Merge.OnCreate, nil).Option(gremlingo.Merge.OutV, gremlingo.T__.Select("v")).Option(gremlingo.Merge.InV, gremlingo.T__.Select("v")) [...]
+ "g_V_mergeE_inlineXemptyX_optionXonCreate_nullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("v").MergeE(map[interface{}]interface{}{gremlingo.T.Label: "self", gremlingo.Direction.Out: gremlingo.Merge.OutV, gremlingo.Direction.In: gremlingo.Merge.InV }).Op [...]
"g_mergeEXemptyX_exists": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).AddE("self")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeE(map[interface{}]interface{}{ })}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E()}, func(g *gremlingo.GraphTraversal [...]
"g_mergeEXemptyX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeE(map[interface{}]interface{}{ })}},
"g_V_mergeEXemptyX_two_exist": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).AddV("person").Property("name", "vadas").Property("age", 27)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("v").MergeE(p["xx1"]).Option(gremlingo.Merge.OutV, gremlingo.T__.Select("v")).Option(gremlingo.Merge.InV, gremlingo.T__.S [...]
+ "g_V_mergeE_inlineXemptyX_two_exist": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).AddV("person").Property("name", "vadas").Property("age", 27)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("v").MergeE(map[interface{}]interface{}{gremlingo.T.Label: "self", gremlingo.Direction.Out: gremlingo.Merge.OutV, [...]
"g_mergeEXnullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeE(nil)}},
+ "g_mergeEXnullvarX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeE(p["xx1"])}},
+ "g_V_limitX1X_mergeEXnullvarX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Limit(1).MergeE(p["xx1"])}},
"g_V_mergeEXnullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().MergeE(nil)}},
"g_mergeEXlabel_knows_out_marko_in_vadasX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").AddV("person").Property("name", "vadas")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeE(p["xx1"])}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has("person", "name", "marko") [...]
"g_withSideEffectXa_label_knows_out_marko_in_vadasX_mergeEXselectXaXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").AddV("person").Property("name", "vadas")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithSideEffect("a", p["xx1"]).MergeE(gremlingo.T__.Select("a"))}, func(g *gremlingo.GraphTraversalSource, p map[string]interfac [...]
@@ -972,7 +1006,9 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
"g_injectXlabel_knows_out_marko_in_vadas_label_self_out_vadas_in_vadasX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").AddV("person").Property("name", "vadas")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"], p["xx2"]).MergeE()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTrave [...]
"g_withSideEffectXc_created_YX_withSideEffectXm_matchedX_mergeEXlabel_knows_out_marko_in_vadasX_optionXonCreate_selectXcXX_optionXonMatch_sideEffectXpropertiesXweightX_dropX_selectXmXX_exists": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").As("a").AddV("person").Property("name", "vadas").As("b").AddE("knows").Property("weight", 1.0).From("a").To("b")}, func(g *gremlingo.GraphTraversalSou [...]
"g_mergeE_with_outVinV_options_map": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").AddV("person").Property("name", "vadas")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeE(p["xx1"]).Option(gremlingo.Merge.OutV, p["xx2"]).Option(gremlingo.Merge.InV, p["xx3"])}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) [...]
+ "g_mergeE_inline_with_outVinV_options_map": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").AddV("person").Property("name", "vadas")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeE(map[interface{}]interface{}{gremlingo.Direction.Out: gremlingo.Merge.OutV, gremlingo.Direction.In: gremlingo.Merge.InV, gremlingo.T.Label: "knows" } [...]
"g_mergeE_with_outVinV_options_select": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").AddV("person").Property("name", "vadas")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).As("x").V(p["vid2"]).As("y").MergeE(p["xx1"]).Option(gremlingo.Merge.OutV, gremlingo.T__.Select("x")).Option(gremlingo.Merge.InV, gremlingo.T__.Se [...]
+ "g_mergeE_inline_with_outVinV_options_select": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").AddV("person").Property("name", "vadas")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).As("x").V(p["vid2"]).As("y").MergeE(map[interface{}]interface{}{gremlingo.Direction.Out: gremlingo.Merge.OutV, gremlingo.Direction.In: grem [...]
"g_mergeE_with_eid_specified_and_inheritance_1": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").AddV("person").Property("name", "vadas")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeE(p["xx1"]).Option(gremlingo.Merge.OnCreate, p["xx2"])}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraver [...]
"g_mergeE_with_eid_specified_and_inheritance_2": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").AddV("person").Property("name", "vadas")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeE(p["xx1"]).Option(gremlingo.Merge.OnCreate, p["xx2"])}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraver [...]
"g_mergeE_outV_override_prohibited": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").AddV("person").Property("name", "vadas")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeE(p["xx1"]).Option(gremlingo.Merge.OnCreate, p["xx2"])}},
@@ -986,6 +1022,8 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
"g_mergeEXlabel_knows_out_marko_in_vadasX_optionXonMatch_sideEffectXpropertyXweight_0XX_constantXemptyXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").As("a").AddV("person").Property("name", "vadas").As("b").AddE("knows").Property("weight", 1).From("a").To("b")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeE(p["xx1"]).Optio [...]
"g_injectXlist1_list2X_mergeEXlimitXlocal_1XX_optionXonCreate_rangeXlocal_1_2XX_optionXonMatch_tailXlocalXX_to_match": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh").Prop [...]
"g_injectXlist1_list2X_mergeEXlimitXlocal_1XX_optionXonCreate_rangeXlocal_1_2XX_optionXonMatch_tailXlocalXX_to_create": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).As("marko").AddV("person").Property("name", "vadas").Property("age", 27).As("vadas").AddV("software").Property("name", "lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh").Pro [...]
+ "g_mergeEXlabel_knows_out_marko_in_vadasX_optionXonMatch_weight_nullX_allowed": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").As("a").AddV("person").Property("name", "vadas").As("b").AddE("knows").From("a").To("b").Property("weight", 1.0)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeE(p["xx1"]).Option(gremlingo.Merge.OnMatch [...]
+ "g_mergeEXlabel_knows_out_marko_in_vadasX_optionXonMatch_weight_nullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").As("a").AddV("person").Property("name", "vadas").As("b").AddE("knows").From("a").To("b").Property("weight", 1.0)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeE(p["xx1"]).Option(gremlingo.Merge.OnMatch, p["xx2 [...]
"g_mergeVXemptyX_optionXonMatch_nullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeV(map[interface{}]interface{}{ }).Option(gremlingo.Merge.OnMatch, nil)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g. [...]
"g_V_mergeVXemptyX_optionXonMatch_nullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().MergeV(map[interface{}]interface{}{ }).Option(gremlingo.Merge.OnMatch, nil)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {ret [...]
"g_mergeVXnullX_optionXonCreate_label_null_name_markoX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeV(p["xx1"])}},
@@ -999,6 +1037,7 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
"g_mergeVXemptyX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeV(map[interface{}]interface{}{ })}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has("person", "name", "marko").Has("age", 29)}},
"g_V_mergeVXemptyX_two_exist": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29).AddV("person").Property("name", "vadas").Property("age", 27)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().MergeV(map[interface{}]interface{}{ })}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphT [...]
"g_mergeVXnullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeV(nil)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V()}},
+ "g_mergeVXnullvarX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeV(p["xx1"])}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V()}},
"g_V_mergeVXnullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().MergeV(nil)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V()}},
"g_mergeVXlabel_person_name_stephenX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeV(p["xx1"])}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has("person", "name", "stephen")}},
"g_mergeVXlabel_person_name_markoX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeV(p["xx1"])}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has("person", "name", "marko")}},
@@ -1047,6 +1086,8 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
"g_mergeV_hidden_label_key_onMatch_matched_prohibited": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeV(map[interface{}]interface{}{ }).Option(gremlingo.Merge.OnMatch, p["xx1"])}},
"g_injectXlist1_list2X_mergeVXlimitXlocal_1XX_optionXonCreate_rangeXlocal_1_2X_optionXonMatch_tailXlocalXX_to_match": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"], p["xx1"], p["xx2"]).Fold().As("m").MergeV(gremlingo.T__.Select("m").Limit(gremlingo.S [...]
"g_injectXlist1_list2X_mergeVXlimitXlocal_1XX_optionXonCreate_rangeXlocal_1_2X_optionXonMatch_tailXlocalXX_to_create": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"], p["xx1"], p["xx2"]).Fold().As("m").MergeV(gremlingo.T__.Select("m").Limit(gremlingo. [...]
+ "g_mergeVXlabel_person_name_marko_age_29X_optionXonMatch_age_nullX_allowed": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeV(p["xx1"]).Option(gremlingo.Merge.OnMatch, p["xx2"])}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.Graph [...]
+ "g_mergeVXlabel_person_name_marko_age_29X_optionXonMatch_age_nullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", "marko").Property("age", 29)}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.MergeV(p["xx1"]).Option(gremlingo.Merge.OnMatch, p["xx2"])}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversa [...]
"g_V_age_min": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("age").Min()}},
"g_V_foo_min": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("foo").Min()}},
"g_V_name_min": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Min()}},
@@ -1067,15 +1108,12 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
"g_VX1X_valuesXageX_minXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Values("age").Min(gremlingo.Scope.Local)}},
"g_V_localXunionXvaluesXageX_outE_valuesXweightXX_foldX_minXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Local(gremlingo.T__.Union(gremlingo.T__.Values("age"), gremlingo.T__.OutE().Values("weight")).Fold()).Min(gremlingo.Scope.Local)}},
"g_V_name_order": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Order()}},
- "g_V_name_order_byXa1_b1X_byXb2_a2X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Order().By(p["c1"]).By(p["c2"])}},
"g_V_order_byXname_ascX_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Order().By("name", gremlingo.Order.Asc).Values("name")}},
"g_V_order_byXnameX_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Order().By("name").Values("name")}},
"g_V_outE_order_byXweight_descX_weight": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().OutE().Order().By("weight", gremlingo.Order.Desc).Values("weight")}},
- "g_V_order_byXname_a1_b1X_byXname_b2_a2X_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Order().By("name", p["c1"]).By("name", p["c2"]).Values("name")}},
"g_V_asXaX_outXcreatedX_asXbX_order_byXshuffleX_selectXa_bX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("a").Out("created").As("b").Order().By(gremlingo.Order.Shuffle).Select("a", "b")}},
"g_V_both_hasLabelXpersonX_order_byXage_descX_limitX5X_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Both().HasLabel("person").Order().By("age", gremlingo.Order.Desc).Limit(5).Values("name")}},
"g_V_properties_order_byXkey_descX_key": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Properties().Order().By(gremlingo.T.Key, gremlingo.Order.Desc).Key()}},
- "g_V_hasLabelXpersonX_order_byXvalueXageX_descX_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}}, // skipping as it contains a lambda
"g_V_hasLabelXpersonX_group_byXnameX_byXoutE_weight_sumX_orderXlocalX_byXvaluesX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("person").Group().By("name").By(gremlingo.T__.OutE().Values("weight").Sum()).Order(gremlingo.Scope.Local).By(gremlingo.Column.Values)}},
"g_V_mapXbothE_weight_foldX_order_byXsumXlocalX_descX_byXcountXlocalX_descX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Map(gremlingo.T__.BothE().Values("weight").Order().By(gremlingo.Order.Asc).Fold()).Order().By(gremlingo.T__.Sum(gremlingo.Scope.Local), gremlingo.Order.Desc).By(gremlingo.T__.Count(gremlingo.Scope.Local), gremlingo.Order.Desc)}},
"g_V_group_byXlabelX_byXname_order_byXdescX_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Group().By(gremlingo.T.Label).By(gremlingo.T__.Values("name").Order().By(gremlingo.Order.Desc).Fold())}},
@@ -1090,7 +1128,6 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
"g_V_fold_orderXlocalX_byXage_descX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Fold().Order(gremlingo.Scope.Local).By("age", gremlingo.Order.Desc)}},
"g_V_orXhasLabelXpersonX_hasXsoftware_name_lopXX_order_byXageX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Or(gremlingo.T__.HasLabel("person"), gremlingo.T__.Has("software", "name", "lop")).Order().By("age")}},
"g_withStrategiesXProductiveByStrategyX_V_orXhasLabelXpersonX_hasXsoftware_name_lopXX_order_byXageX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithStrategies(gremlingo.ProductiveByStrategy()).V().Or(gremlingo.T__.HasLabel("person"), gremlingo.T__.Has("software", "name", "lop")).Order().By("age")}},
- "g_VX1X_hasXlabel_personX_mapXmapXint_ageXX_orderXlocalX_byXvalues_descX_byXkeys_ascX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}}, // skipping as it contains a lambda
"g_V_hasXsong_name_OHBOYX_outXfollowedByX_outXfollowedByX_order_byXperformancesX_byXsongType_descX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has("song", "name", "OH BOY").Out("followedBy").Out("followedBy").Order().By("performances").By("songType", gremlingo.Order.Desc).By("name")}},
"g_V_hasLabelXsongX_order_byXperformances_descX_byXnameX_rangeX110_120X_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("song").Order().By("performances", gremlingo.Order.Desc).By("name").Range(110, 120).Values("name")}},
"g_VX1X_elementMap_orderXlocalX_byXkeys_descXunfold": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).ElementMap().Order(gremlingo.Scope.Local).By(gremlingo.Column.Keys, gremlingo.Order.Desc).Unfold()}},
@@ -1124,6 +1161,7 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
"g_V_fold_productXconstantXnullXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Fold().Product(gremlingo.T__.Constant(nil))}},
"g_V_fold_productXVX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Fold().Product(gremlingo.T__.V())}},
"g_V_valuesXnameX_fold_productX2X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Product(2)}},
+ "g_V_valuesXnameX_fold_productX7varX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Product(p["xx1"])}},
"g_V_valuesXnameX_fold_productXnullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Product(nil)}},
"g_V_valuesXnonexistantX_fold_productXV_valuesXnameX_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("nonexistant").Fold().Product(gremlingo.T__.V().Values("name").Fold())}},
"g_V_valuesXnameX_fold_productXV_valuesXnonexistantX_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").Fold().Product(gremlingo.T__.V().Values("nonexistant").Fold())}},
@@ -1235,8 +1273,19 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
"g_V_asXa_nX_selectXa_nX_byXageX_byXnameX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("a", "n").Select("a", "n").By("age").By("name")}},
"g_withStrategiesXProductiveByStrategyX_V_asXaX_selectXaX_byXageX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithStrategies(gremlingo.ProductiveByStrategy()).V().As("a").Select("a").By("age")}},
"g_withSideEffectXk_nullX_injectXxX_selectXkX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.WithSideEffect("k", nil).Inject("x").Select("k")}},
- "g_V_out_in_selectXall_a_a_aX_byXunfold_name_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("A").Property("name", "a1").As("a1").AddV("A").Property("name", "a2").As("a2").AddV("A").Property("name", "a3").As("a3").AddV("B").Property("name", "b1").As("b1").AddV("B").Property("name", "b2").As("b2").AddV("B").Property("name", "b3").As("b3").AddE("ab").From("a1").To("b1").AddE("ab").From("a2").To("b2").AddE("ab").From("a [...]
+ "g_V_out_in_selectXall_a_a_aX_byXunfold_name_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("A").Property("name", "a1").As("a1").AddV("B").Property("name", "b1").As("b1").AddE("ab").From("a1").To("b1")}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("a").Out().As("a").In().As("a").Select(gremlingo.Pop.All, "a", "a", "a").By(gremlingo.T__.Unfold().Values( [...]
"g_withoutStrategiesXLazyBarrierStrategyX_V_asXlabelX_aggregateXlocal_xX_selectXxX_selectXlabelX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V()}},
+ "g_V_name_asXaX_selectXfirst_aX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").As("a").Select(gremlingo.Pop.First, "a")}},
+ "g_V_name_asXaX_selectXlast_aX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").As("a").Select(gremlingo.Pop.Last, "a")}},
+ "g_V_name_asXaX_selectXmixed_aX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").As("a").Select(gremlingo.Pop.Mixed, "a")}},
+ "g_V_name_asXaX_selectXall_aX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Values("name").As("a").Select(gremlingo.Pop.All, "a")}},
+ "g_V_hasLabelXpersonX_name_asXaX_concatXXX_asXaX_length_asXaX_selectXaX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("person").Values("name").As("a").Concat("X").As("a").Length().As("a").Select("a")}},
+ "g_V_hasLabelXpersonX_name_asXaX_concatXXX_asXaX_length_asXaX_selectXfirst_aX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("person").Values("name").As("a").Concat("X").As("a").Length().As("a").Select(gremlingo.Pop.First, "a")}},
+ "g_V_hasLabelXpersonX_name_asXaX_concatXXX_asXaX_length_asXaX_selectXlast_aX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("person").Values("name").As("a").Concat("X").As("a").Length().As("a").Select(gremlingo.Pop.Last, "a")}},
+ "g_V_hasLabelXpersonX_name_asXaX_concatXXX_asXaX_concatXYZX_asXaX_selectXmixed_aX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("person").Values("name").As("a").Concat("X").As("a").Concat("YZ").As("a").Select(gremlingo.Pop.Mixed, "a")}},
+ "g_V_hasLabelXpersonX_name_asXaX_concatXXX_asXaX_concatXYZX_asXaX_selectXall_aX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("person").Values("name").As("a").Concat("X").As("a").Concat("YZ").As("a").Select(gremlingo.Pop.All, "a")}},
+ "g_V_asXaX_out_asXaX_out_asXaX_selectXmixed_aX_byXunfold_valuesXnameX_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("a").Out().As("a").Out().As("a").Select(gremlingo.Pop.Mixed, "a").By(gremlingo.T__.Unfold().Values("name").Fold())}},
+ "g_V_asXaX_out_asXaX_out_asXaX_selectXall_aX_byXunfold_valuesXnameX_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().As("a").Out().As("a").Out().As("a").Select(gremlingo.Pop.All, "a").By(gremlingo.T__.Unfold().Values("name").Fold())}},
"g_V_shortestPath": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().ShortestPath()}},
"g_V_both_dedup_shortestPath": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Both().Dedup().ShortestPath()}},
"g_V_shortestPath_edgesIncluded": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().ShortestPath().With("~tinkerpop.shortestPath.includeEdges")}},
@@ -1317,7 +1366,6 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
"g_V_valuesXnameX_trim": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", " marko ").Property("age", 29).As("marko").AddV("person").Property("name", " vadas ").Property("age", 27).As("vadas").AddV("software").Property("name", " lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh ").Property("age", 32).As("josh").AddV("software").Property("name", " ripple ").Propert [...]
"g_V_valuesXnameX_order_fold_trimXlocalX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.AddV("person").Property("name", " marko ").Property("age", 29).As("marko").AddV("person").Property("name", " vadas ").Property("age", 27).As("vadas").AddV("software").Property("name", " lop").Property("lang", "java").As("lop").AddV("person").Property("name", "josh ").Property("age", 32).As("josh").AddV("software").Property("name", " r [...]
"g_V_localXoutE_foldX_unfold": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Local(gremlingo.T__.OutE().Fold()).Unfold()}},
- "g_V_valueMap_unfold_mapXkeyX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}}, // skipping as it contains a lambda
"g_VX1X_repeatXboth_simplePathX_untilXhasIdX6XX_path_byXnameX_unfold": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Repeat(gremlingo.T__.Both().SimplePath()).Until(gremlingo.T__.HasId(p["vid6"])).Path().By("name").Unfold()}},
"g_V_valueMap": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().ValueMap()}},
"g_V_valueMapXtrueX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().ValueMap(true)}},
@@ -1343,34 +1391,17 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
"g_VX1X_out": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Out()}},
"g_VX2X_in": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid2"]).In()}},
"g_VX4X_both": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid4"]).Both()}},
- "g_E": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E()}},
- "g_EX11X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E(p["eid11"])}},
- "g_EX11AsStringX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E(p["eid11"])}},
- "g_EXe11X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E(p["e11"])}},
- "g_EXe7_e11X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E(p["e7"], p["e11"])}},
- "g_EXlistXe7_e11XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E(p["xx1"])}},
- "g_EXnullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E(nil)}},
- "g_EXlistXnullXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E(p["xx1"])}},
- "g_EX11_nullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E(p["eid11"], nil)}},
"g_VX1X_outE": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).OutE()}},
"g_VX2X_outE": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid2"]).InE()}},
"g_VX4X_bothEXcreatedX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid4"]).BothE("created")}},
+ "g_VX4X_bothEXcreatedvarX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid4"]).BothE(p["xx1"])}},
"g_VX4X_bothE": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid4"]).BothE()}},
- "g_VX1X_outE_inV": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Both()}},
- "g_VX2X_inE_outV": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid2"]).InE().OutV()}},
- "g_V_outE_hasXweight_1X_outV": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().OutE().Has("weight", 1.0).OutV()}},
"g_V_out_outE_inV_inE_inV_both_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().OutE().InV().InE().InV().Both().Values("name")}},
- "g_VX1X_outEXknowsX_bothV_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).OutE("knows").BothV().Values("name")}},
- "g_VX1X_outE_otherV": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).OutE().OtherV()}},
- "g_VX4X_bothE_otherV": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid4"]).BothE().OtherV()}},
- "g_VX4X_bothE_hasXweight_lt_1X_otherV": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid4"]).BothE().Has("weight", gremlingo.P.Lt(1.0)).OtherV()}},
"g_VX2X_inE": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid2"]).BothE()}},
- "get_g_VX1X_outE_otherV": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).OutE().OtherV()}},
"g_VX1X_outXknowsX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Out("knows")}},
"g_VX1AsStringX_outXknowsX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Out("knows")}},
"g_VX1X_outXknows_createdX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Out("knows", "created")}},
- "g_VX1X_outEXknowsX_inV": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).OutE("knows").InV()}},
- "g_VX1X_outEXknows_createdX_inV": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).OutE("knows", "created").InV()}},
+ "g_VX1X_outXknowsvar_createdvarX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Out(p["xx2"], p["xx3"])}},
"g_V_out_out": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Out()}},
"g_VX1X_out_out_out": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Out().Out().Out()}},
"g_VX1X_out_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Out().Values("name")}},
@@ -1549,7 +1580,6 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
"g_V_hasXlangX_group_byXlangX_byXcountX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has("lang").Group().By("lang").By(gremlingo.T__.Count())}},
"g_V_group_byXoutE_countX_byXnameX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Order().By("name").Group().By(gremlingo.T__.OutE().Count()).By("name")}},
"g_V_repeatXbothXfollowedByXX_timesX2X_group_byXsongTypeX_byXcountX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Repeat(gremlingo.T__.Both("followedBy")).Times(2).Group().By("songType").By(gremlingo.T__.Count())}},
- "g_V_group_byXname_substring_1X_byXconstantX1XX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}}, // skipping as it contains a lambda
"g_V_out_group_byXlabelX_selectXpersonX_unfold_outXcreatedX_name_limitX2X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out().Group().By(gremlingo.T.Label).Select("person").Unfold().Out("created").Values("name").Limit(2)}},
"g_V_hasLabelXsongX_group_byXnameX_byXproperties_groupCount_byXlabelXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("song").Group().By("name").By(gremlingo.T__.Properties().GroupCount().By(gremlingo.T.Label))}},
"g_V_outXfollowedByX_group_byXsongTypeX_byXbothE_group_byXlabelX_byXweight_sumXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Out("followedBy").Group().By("songType").By(gremlingo.T__.BothE().Group().By(gremlingo.T.Label).By(gremlingo.T__.Values("weight").Sum()))}},
@@ -1573,7 +1603,6 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
"g_V_both_groupCountXaX_out_capXaX_selectXkeysX_unfold_both_groupCountXaX_capXaX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Both().GroupCount("a").Out().Cap("a").Select(gremlingo.Column.Keys).Unfold().Both().GroupCount("a").Cap("a")}},
"g_V_hasXperson_name_markoX_bothXknowsX_groupCount_byXvaluesXnameX_foldX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Has("person", "name", "marko").Both("knows").GroupCount().By(gremlingo.T__.Values("name").Fold())}},
"g_VX1X_out_injectXv2X_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Out().Inject(p["v2"]).Values("name")}},
- "g_VX1X_out_name_injectXdanielX_asXaX_mapXlengthX_path": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}}, // skipping as it contains a lambda
"g_VX1X_injectXg_VX4XX_out_name": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["vid1"]).Inject(p["v2"]).Out().Values("name")}},
"g_injectXnull_1_3_nullX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(nil, 1, 3, nil)}},
"g_injectX10_20_null_20_10_10X_groupCountXxX_dedup_asXyX_projectXa_bX_by_byXselectXxX_selectXselectXyXXX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(10, 20, nil, 20, 10, 10).GroupCount("x").Dedup().As("y").Project("a", "b").By().By(gremlingo.T__.Select("x").Select(gremlingo.T__.Select("y")))}},
@@ -1586,9 +1615,14 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
"g_VX1X_valuesXageX_inject": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V(p["xx1"]).Values("age").Inject()}},
"g_injectXnull_1_3_nullX_asXaX_selectXaX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(nil, 1, 3, nil).As("a").Select("a")}},
"g_injectX1_3X_injectX100_300X": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(1, 3).Inject(100, 300)}},
+ "g_injectX1var_3varX_injectX100var_300varX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"], p["xx2"]).Inject(p["xx3"], p["xx4"])}},
"g_injectX1_3_100_300X_list": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject([]interface{}{1, 3, 100, 300})}},
+ "g_injectX1_3_100_300X_listvar": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"])}},
"g_injectX1_3_100_300X_set": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(gremlingo.NewSimpleSet(1, 3, 100, 300))}},
+ "g_injectX1_3_100_300X_setvar": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"])}},
"g_injectX1_1X_set": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(gremlingo.NewSimpleSet(1, 1))}},
+ "g_injectX1_1X_setvar": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"])}},
+ "g_injectX_set": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Inject(p["xx1"])}},
"g_io_readXkryoX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Io("data/tinkerpop-modern.kryo").Read()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E()}},
"g_io_read_withXreader_gryoX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Io("data/tinkerpop-modern.kryo").With(gremlingo.IO.Reader, gremlingo.IO.Gryo).Read()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E()}},
"g_io_readXgraphsonX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.Io("data/tinkerpop-modern.json").Read()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V()}, func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.E()}},
@@ -1611,7 +1645,6 @@ var translationMap = map[string][]func(g *gremlingo.GraphTraversalSource, p map[
"g_V_repeatXout_groupXaX_byXnameX_byXcountX_timesX2X_capXaX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Repeat(gremlingo.T__.Out().Group("a").By("name").By(gremlingo.T__.Count())).Times(2).Cap("a")}},
"g_V_groupXaX_byXlabelX_byXoutE_weight_sumX_capXaX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Group("a").By(gremlingo.T.Label).By(gremlingo.T__.OutE().Values("weight").Sum()).Cap("a")}},
"g_V_repeatXbothXfollowedByXX_timesX2X_groupXaX_byXsongTypeX_byXcountX_capXaX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Repeat(gremlingo.T__.Both("followedBy")).Times(2).Group("a").By("songType").By(gremlingo.T__.Count()).Cap("a")}},
- "g_V_groupXaX_byXname_substring_1X_byXconstantX1XX_capXaX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return nil}}, // skipping as it contains a lambda
"g_V_hasLabelXsongX_groupXaX_byXnameX_byXproperties_groupCount_byXlabelXX_out_capXaX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("song").Group("a").By("name").By(gremlingo.T__.Properties().GroupCount().By(gremlingo.T.Label)).Out().Cap("a")}},
"g_V_hasLabelXpersonX_asXpX_outXcreatedX_groupXaX_byXnameX_byXselectXpX_valuesXageX_sumX_capXaX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().HasLabel("person").As("p").Out("created").Group("a").By("name").By(gremlingo.T__.Select("p").Values("age").Sum()).Cap("a")}},
"g_V_groupXmX_byXnameX_byXinXknowsX_nameX_capXmX": {func(g *gremlingo.GraphTraversalSource, p map[string]interface{}) *gremlingo.GraphTraversal {return g.V().Group("m").By("name").By(gremlingo.T__.In("knows").Values("name")).Cap("m")}},
diff --git a/gremlin-go/driver/driverRemoteConnection.go b/gremlin-go/driver/driverRemoteConnection.go
index a8dce4985c..95b7341d09 100644
--- a/gremlin-go/driver/driverRemoteConnection.go
+++ b/gremlin-go/driver/driverRemoteConnection.go
@@ -33,7 +33,6 @@ type DriverRemoteConnectionSettings struct {
session string
TraversalSource string
- TransporterType TransporterType
LogVerbosity LogVerbosity
Logger Logger
Language language.Tag
@@ -65,7 +64,7 @@ type DriverRemoteConnection struct {
// NewDriverRemoteConnection creates a new DriverRemoteConnection.
// If no custom connection settings are passed in, a connection will be created with "g" as the default TraversalSource,
-// Gorilla as the default Transporter, Info as the default LogVerbosity, a default logger struct, and English and as the
+// Info as the default LogVerbosity, a default logger struct, and English and as the
// default language
func NewDriverRemoteConnection(
url string,
@@ -74,7 +73,6 @@ func NewDriverRemoteConnection(
session: "",
TraversalSource: "g",
- TransporterType: Gorilla,
LogVerbosity: Info,
Logger: &defaultLogger{},
Language: language.English,
@@ -86,14 +84,12 @@ func NewDriverRemoteConnection(
EnableCompression: false,
EnableUserAgentOnConnect: true,
// ReadBufferSize and WriteBufferSize specify I/O buffer sizes in bytes. The default is 1048576.
- // If a buffer size is set zero, then the Gorilla websocket 4096 default size is used. The I/O buffer
+ // If a buffer size is set zero, then the default size is used. The I/O buffer
// sizes do not limit the size of the messages that can be sent or received.
ReadBufferSize: 1048576,
WriteBufferSize: 1048576,
- NewConnectionThreshold: defaultNewConnectionThreshold,
MaximumConcurrentConnections: runtime.NumCPU(),
- InitialConcurrentConnections: defaultInitialConcurrentConnections,
}
for _, configuration := range configurations {
configuration(settings)
@@ -117,27 +113,18 @@ func NewDriverRemoteConnection(
settings.MaximumConcurrentConnections = 1
}
- if settings.InitialConcurrentConnections > settings.MaximumConcurrentConnections {
- logHandler.logf(Warning, poolInitialExceedsMaximum, settings.InitialConcurrentConnections,
- settings.MaximumConcurrentConnections, settings.MaximumConcurrentConnections)
- settings.InitialConcurrentConnections = settings.MaximumConcurrentConnections
- }
- pool, err := newLoadBalancingPool(url, logHandler, connSettings, settings.NewConnectionThreshold,
- settings.MaximumConcurrentConnections, settings.InitialConcurrentConnections)
+ httpProt, err := newHttpProtocol(logHandler, url, connSettings)
if err != nil {
- if err != nil {
- logHandler.logf(Error, logErrorGeneric, "NewDriverRemoteConnection", err.Error())
- }
return nil, err
}
client := &Client{
- url: url,
- traversalSource: settings.TraversalSource,
- logHandler: logHandler,
- transporterType: settings.TransporterType,
- connections: pool,
- session: settings.session,
+ url: url,
+ traversalSource: settings.TraversalSource,
+ logHandler: logHandler,
+ connectionSettings: connSettings,
+ session: settings.session,
+ httpProtocol: httpProt,
}
return &DriverRemoteConnection{client: client, isClosed: false, settings: settings}, nil
@@ -216,7 +203,6 @@ func (driver *DriverRemoteConnection) CreateSession(sessionId ...string) (*Drive
}
// copy other settings from parent
settings.TraversalSource = driver.settings.TraversalSource
- settings.TransporterType = driver.settings.TransporterType
settings.Logger = driver.settings.Logger
settings.LogVerbosity = driver.settings.LogVerbosity
settings.Language = driver.settings.Language
diff --git a/gremlin-go/driver/error_codes.go b/gremlin-go/driver/error_codes.go
index 875b10c1d9..1ccbbdf5e3 100644
--- a/gremlin-go/driver/error_codes.go
+++ b/gremlin-go/driver/error_codes.go
@@ -36,11 +36,6 @@ const (
err0101ConnectionCloseError errorCode = "E0101_CONNECTION_CLOSE_ERROR"
err0102WriteConnectionClosedError errorCode = "E0102_CONNECTION_WRITE_CLOSED_ERROR"
- // connectionPool.go errors
- err0103ConnectionPoolClosedError errorCode = "E0103_CONNECTIONPOOL_CLOSED_ERROR"
- err0104ConnectionPoolInstantiateFail errorCode = "E0104_CONNECTIONPOOL_INSTANTIATE_FAIL"
- err0105ConnectionPoolFullButNoneValid errorCode = "E0105_CONNECTIONPOOL_FULL_NONE_VALID"
-
// driverRemoteConnection.go errors
err0201CreateSessionMultipleIdsError errorCode = "E0201_DRIVER_REMOTE_CONNECTION_CREATESESSION_MULTIPLE_UUIDS_ERROR"
err0202CreateSessionFromSessionError errorCode = "E0202_DRIVER_REMOTE_CONNECTION_CREATESESSION_SESSION_FROM_SESSION_ERROR"
@@ -83,9 +78,6 @@ const (
err0703ReadMapNonStringKeyError errorCode = "E0703_SERIALIZER_READMAP_NON_STRING_KEY_ERROR"
err0704ConvertArgsNoSerializerError errorCode = "E0704_SERIALIZER_CONVERTARGS_NO_SERIALIZER_ERROR"
- // transporterFactory.go errors
- err0801GetTransportLayerNoTypeError errorCode = "E0801_TRANSPORTERFACTORY_GETTRANSPORTLAYER_NO_TYPE_ERROR"
-
// traversal.go errors
err0901ToListAnonTraversalError errorCode = "E0901_TRAVERSAL_TOLIST_ANON_TRAVERSAL_ERROR"
err0902IterateAnonTraversalError errorCode = "E0902_TRAVERSAL_ITERATE_ANON_TRAVERSAL_ERROR"
@@ -99,9 +91,6 @@ const (
err1102TransactionRollbackNotOpenedError errorCode = "E1102_TRANSACTION_ROLLBACK_NOT_OPENED_ERROR"
err1103TransactionCommitNotOpenedError errorCode = "E1103_TRANSACTION_COMMIT_NOT_OPENED_ERROR"
err1104TransactionRepeatedCloseError errorCode = "E1104_TRANSACTION_REPEATED_CLOSE_ERROR"
-
- // gorillaTransporter.go errors
- err1201RequestSizeExceedsWriteBufferError errorCode = "E1201_REQUEST_SIZE_EXCEEDS_WRITE_BUFFER_ERROR"
)
var localizer *i18n.Localizer
diff --git a/gremlin-go/driver/gorillaTransporter.go b/gremlin-go/driver/gorillaTransporter.go
deleted file mode 100644
index 6d9d128656..0000000000
--- a/gremlin-go/driver/gorillaTransporter.go
+++ /dev/null
@@ -1,201 +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 gremlingo
-
-import (
- "net/http"
- "net/url"
- "sync"
- "time"
-
- "github.com/gorilla/websocket"
-)
-
-const keepAliveIntervalDefault = 5 * time.Second
-const writeDeadlineDefault = 3 * time.Second
-const writeChannelSizeDefault = 100
-const connectionTimeoutDefault = 5 * time.Second
-
-// Transport layer that uses gorilla/websocket: https://github.com/gorilla/websocket
-// Gorilla WebSocket is a widely used and stable Go implementation of the WebSocket protocol.
-type gorillaTransporter struct {
- url string
- connection websocketConn
- isClosed bool
- logHandler *logHandler
- connSettings *connectionSettings
- writeChannel chan []byte
- wg *sync.WaitGroup
-}
-
-// Connect used to establish a connection.
-func (transporter *gorillaTransporter) Connect() (err error) {
- if transporter.connection != nil {
- return
- }
-
- var u *url.URL
- u, err = url.Parse(transporter.url)
- if err != nil {
- return
- }
-
- dialer := &websocket.Dialer{
- Proxy: http.ProxyFromEnvironment,
- HandshakeTimeout: transporter.connSettings.connectionTimeout,
- TLSClientConfig: transporter.connSettings.tlsConfig,
- EnableCompression: transporter.connSettings.enableCompression,
- ReadBufferSize: transporter.connSettings.readBufferSize,
- WriteBufferSize: transporter.connSettings.writeBufferSize,
- }
-
- header := transporter.getAuthInfo().GetHeader()
- if transporter.connSettings.enableUserAgentOnConnect {
- if header == nil {
- header = make(http.Header)
- }
- header.Set(userAgentHeader, userAgent)
- }
-
- // Nil is accepted as a valid header, so it can always be passed directly through.
- conn, _, err := dialer.Dial(u.String(), header)
- if err != nil {
- return err
- }
- transporter.connection = conn
- transporter.connection.SetPongHandler(func(string) error {
- err := transporter.connection.SetReadDeadline(time.Now().Add(2 * transporter.connSettings.keepAliveInterval))
- if err != nil {
- return err
- }
- return nil
- })
- transporter.wg.Add(1)
- go transporter.writeLoop()
- return
-}
-
-// Write used to write data to the transporter. Opens connection if closed.
-func (transporter *gorillaTransporter) Write(data []byte) error {
- if transporter.connection == nil {
- err := transporter.Connect()
- if err != nil {
- return err
- }
- }
- if len(data) > transporter.connSettings.writeBufferSize {
- return newError(err1201RequestSizeExceedsWriteBufferError)
- }
- transporter.writeChannel <- data
- return nil
-}
-
-func (transporter *gorillaTransporter) getAuthInfo() AuthInfoProvider {
- if transporter.connSettings.authInfo == nil {
- return NoopAuthInfo
- }
- return transporter.connSettings.authInfo
-}
-
-// Read used to read data from the transporter. Opens connection if closed.
-func (transporter *gorillaTransporter) Read() ([]byte, error) {
- if transporter.connection == nil {
- err := transporter.Connect()
- if err != nil {
- return nil, err
- }
- }
-
- err := transporter.connection.SetReadDeadline(time.Now().Add(transporter.connSettings.keepAliveInterval * 2))
- if err != nil {
- return nil, err
- }
- _, bytes, err := transporter.connection.ReadMessage()
- return bytes, err
-
-}
-
-// Close used to close a connection if it is opened.
-func (transporter *gorillaTransporter) Close() (err error) {
- if !transporter.isClosed {
- if transporter.writeChannel != nil {
- close(transporter.writeChannel)
- }
- if transporter.wg != nil {
- transporter.wg.Wait()
- }
- err = transporter.connection.Close()
- transporter.isClosed = true
- if err != nil {
- return err
- }
- }
- return
-}
-
-// IsClosed returns true when the transporter is closed.
-func (transporter *gorillaTransporter) IsClosed() bool {
- return transporter.isClosed
-}
-
-func (transporter *gorillaTransporter) writeLoop() {
- defer transporter.wg.Done()
-
- ticker := time.NewTicker(transporter.connSettings.keepAliveInterval)
- defer ticker.Stop()
-
- for {
- select {
- case message, ok := <-transporter.writeChannel:
- if !ok {
- // Channel was closed, we can disconnect and exit.
- return
- }
-
- // Set write deadline.
- err := transporter.connection.SetWriteDeadline(time.Now().Add(transporter.connSettings.writeDeadline))
- if err != nil {
- transporter.logHandler.logf(Error, failedToSetWriteDeadline, err.Error())
- return
- }
-
- // Write binary message that was submitted to channel.
- err = transporter.connection.WriteMessage(websocket.BinaryMessage, message)
- if err != nil {
- transporter.logHandler.logf(Error, failedToWriteMessage, "BinaryMessage", err.Error())
- return
- }
- case <-ticker.C:
- // Set write deadline.
- err := transporter.connection.SetWriteDeadline(time.Now().Add(transporter.connSettings.keepAliveInterval))
- if err != nil {
- transporter.logHandler.logf(Error, failedToSetWriteDeadline, err.Error())
- return
- }
-
- // Write pong message.
- err = transporter.connection.WriteMessage(websocket.PingMessage, nil)
- if err != nil {
- transporter.logHandler.logf(Error, failedToWriteMessage, "PingMessage", err.Error())
- return
- }
- }
- }
-}
diff --git a/gremlin-go/driver/gorillaTransporter_test.go b/gremlin-go/driver/gorillaTransporter_test.go
deleted file mode 100644
index e8d2e4175b..0000000000
--- a/gremlin-go/driver/gorillaTransporter_test.go
+++ /dev/null
@@ -1,163 +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 gremlingo
-
-import (
- "errors"
- "sync"
- "testing"
- "time"
-
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/mock"
- "golang.org/x/text/language"
-)
-
-const mockMessage string = "MockMessage"
-const mockReadErrMessage string = "MockReadMessageErrMessage"
-
-type mockWebsocketConn struct {
- mock.Mock
-}
-
-func (conn *mockWebsocketConn) WriteMessage(messageType int, data []byte) error {
- args := conn.Called(messageType, data)
- return args.Error(0)
-}
-
-func (conn *mockWebsocketConn) ReadMessage() (int, []byte, error) {
- args := conn.Called()
- return args.Get(0).(int), args.Get(1).([]byte), args.Error(2)
-}
-
-func (conn *mockWebsocketConn) Close() error {
- args := conn.Called()
- return args.Error(0)
-}
-
-func (conn *mockWebsocketConn) SetReadDeadline(time time.Time) error {
- args := conn.Called(time)
- return args.Error(0)
-}
-
-func (conn *mockWebsocketConn) SetWriteDeadline(time time.Time) error {
- args := conn.Called(time)
- return args.Error(0)
-}
-
-func (conn *mockWebsocketConn) SetPongHandler(h func(appData string) error) {
- conn.Called(h)
-}
-
-func getNewGorillaTransporter() (gorillaTransporter, *mockWebsocketConn) {
- return getNewGorillaTransporterWithSettings(newDefaultConnectionSettings())
-}
-
-func getNewGorillaTransporterWithSettings(connectionSettings *connectionSettings) (gorillaTransporter, *mockWebsocketConn) {
- mockConn := new(mockWebsocketConn)
- return gorillaTransporter{
- url: "ws://mockHost:8182/gremlin",
- logHandler: newLogHandler(&defaultLogger{}, Info, language.English),
- connection: mockConn,
- isClosed: false,
- connSettings: connectionSettings,
- writeChannel: make(chan []byte, 100),
- wg: &sync.WaitGroup{},
- }, mockConn
-}
-
-func TestGorillaTransporter(t *testing.T) {
- t.Run("Success", func(t *testing.T) {
- transporter, mockConn := getNewGorillaTransporter()
- t.Run("WriteMessage", func(t *testing.T) {
- mockConn.On("WriteMessage", 2, make([]byte, 10)).Return(nil)
- err := transporter.Write(make([]byte, 10))
- assert.Nil(t, err)
- })
-
- t.Run("Read", func(t *testing.T) {
- mockConn.On("ReadMessage").Return(0, []byte(mockMessage), nil)
- mockConn.On("SetPongHandler", mock.AnythingOfType("func(string) error")).Return(nil)
- mockConn.On("SetReadDeadline", mock.Anything).Return(nil)
- mockConn.On("SetWriteDeadline", mock.Anything).Return(nil)
- message, err := transporter.Read()
- assert.Nil(t, err)
- assert.Equal(t, mockMessage, string(message[:]))
- })
-
- t.Run("Close and IsClosed", func(t *testing.T) {
- mockConn.On("Close").Return(nil)
- isClosed := transporter.IsClosed()
- assert.False(t, isClosed)
- err := transporter.Close()
- assert.Nil(t, err)
- isClosed = transporter.IsClosed()
- assert.True(t, isClosed)
- })
- })
-
- t.Run("Error", func(t *testing.T) {
- transporter, mockConn := getNewGorillaTransporter()
- t.Run("Read", func(t *testing.T) {
- mockConn.On("ReadMessage").Return(0, []byte{}, errors.New(mockReadErrMessage))
- mockConn.On("SetPongHandler", mock.AnythingOfType("func(string) error")).Return(nil)
- mockConn.On("SetReadDeadline", mock.Anything).Return(nil)
- mockConn.On("SetWriteDeadline", mock.Anything).Return(nil)
- mockConn.On("WriteMessage", mock.Anything, mock.Anything).Return(nil)
- _, err := transporter.Read()
- assert.NotNil(t, err)
- assert.Equal(t, mockReadErrMessage, err.Error())
- })
-
- t.Run("Close and IsClosed", func(t *testing.T) {
- mockConn.On("Close").Return(nil)
- isClosed := transporter.IsClosed()
- assert.False(t, isClosed)
- err := transporter.Close()
- assert.Nil(t, err)
- isClosed = transporter.IsClosed()
- assert.True(t, isClosed)
- })
- })
-
- t.Run("Should error if request size exceeds WriteBufferSize", func(t *testing.T) {
- connSettings := newDefaultConnectionSettings()
- connSettings.writeBufferSize = 30
- transporter, mockConn := getNewGorillaTransporterWithSettings(connSettings)
-
- t.Run("Small message should succeed", func(t *testing.T) {
- mockConn.On("WriteMessage", 2, make([]byte, 10)).Return(nil)
- err := transporter.Write(make([]byte, 10))
- assert.Nil(t, err)
- })
-
- t.Run("Large message should error", func(t *testing.T) {
- mockConn.On("WriteMessage", 2, make([]byte, 10)).Return(nil)
- err := transporter.Write(make([]byte, 31))
- assert.Equal(t, newError(err1201RequestSizeExceedsWriteBufferError), err)
- })
-
- t.Run("Exact size should succeed", func(t *testing.T) {
- mockConn.On("WriteMessage", 2, make([]byte, 10)).Return(nil)
- err := transporter.Write(make([]byte, 30))
- assert.Nil(t, err)
- })
- })
-}
diff --git a/gremlin-go/driver/graphBinary.go b/gremlin-go/driver/graphBinary.go
index 5ffc83773d..5137a9cf27 100644
--- a/gremlin-go/driver/graphBinary.go
+++ b/gremlin-go/driver/graphBinary.go
@@ -878,7 +878,7 @@ func vertexReaderReadingProperties(data *[]byte, i *int, readProperties bool) (i
if err != nil {
return nil, err
}
- label, err := readUnqualified(data, i, listType, false)
+ label, err := readList(data, i, 0)
if err != nil {
return nil, err
}
@@ -957,7 +957,7 @@ func vertexPropertyReader(data *[]byte, i *int) (interface{}, error) {
if err != nil {
return nil, err
}
- label, err := readUnqualified(data, i, listType, false)
+ label, err := readList(data, i, 0)
if err != nil {
return nil, err
}
diff --git a/gremlin-go/driver/httpProtocol.go b/gremlin-go/driver/httpProtocol.go
new file mode 100644
index 0000000000..68e38a1fd6
--- /dev/null
+++ b/gremlin-go/driver/httpProtocol.go
@@ -0,0 +1,197 @@
+/*
+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 gremlingo
+
+import (
+ "encoding/base64"
+ "fmt"
+ "net/http"
+ "os"
+ "sync"
+)
+
+const authenticationFailed = uint16(151)
+
+type httpProtocol struct {
+ serializer serializer
+ logHandler *logHandler
+ url string
+ connSettings *connectionSettings
+ httpClient *http.Client
+}
+
+func newHttpProtocol(handler *logHandler, url string, connSettings *connectionSettings) (*httpProtocol, error) {
+ transport := &http.Transport{
+ TLSClientConfig: connSettings.tlsConfig,
+ MaxConnsPerHost: 0, // TODO
+ IdleConnTimeout: 0, // TODO
+ DisableCompression: !connSettings.enableCompression,
+ }
+
+ httpClient := http.Client{
+ Transport: transport,
+ Timeout: connSettings.connectionTimeout,
+ }
+
+ httpProt := &httpProtocol{
+ serializer: newGraphBinarySerializer(handler),
+ logHandler: handler,
+ url: url,
+ connSettings: connSettings,
+ httpClient: &httpClient,
+ }
+ return httpProt, nil
+}
+
+func (protocol *httpProtocol) send(request *request) (ResultSet, error) {
+ // TODO remove need for result set container map
+ results := &synchronizedMap{map[string]ResultSet{}, sync.Mutex{}}
+ rs := newChannelResultSet(request.requestID.String(), results)
+ results.store(request.requestID.String(), rs)
+
+ fmt.Println("Serializing request")
+ bytes, err := protocol.serializer.serializeMessage(request)
+ if err != nil {
+ return nil, err
+ }
+
+ transport := NewHttpTransporter(protocol.url, protocol.connSettings, protocol.httpClient)
+
+ // async send request and wait for response
+ transport.wg.Add(1)
+ go func() {
+ defer transport.wg.Done()
+ err := transport.Write(bytes)
+ if err != nil {
+ rs.setError(err)
+ rs.Close()
+ protocol.errorCallback()
+ err = transport.Close()
+ }
+ }()
+
+ // async receive response msg data
+ transport.wg.Add(1)
+ go func() {
+ defer transport.wg.Done()
+ msg, err := transport.Read()
+ if err != nil {
+ rs.setError(err)
+ rs.Close()
+ protocol.errorCallback()
+ err = transport.Close()
+ } else {
+ protocol.receive(rs, msg, protocol.errorCallback)
+ }
+ rs.Close()
+ err = transport.Close()
+ }()
+
+ return rs, err
+}
+
+func (protocol *httpProtocol) receive(rs ResultSet, msg []byte, errorCallback func()) {
+ fmt.Println("Deserializing response")
+ resp, err := protocol.serializer.deserializeMessage(msg)
+ if err != nil {
+ protocol.logHandler.logf(Error, logErrorGeneric, "receive()", err.Error())
+ rs.Close()
+ return
+ }
+
+ fmt.Println("Handling response")
+ err = protocol.handleResponse(rs, resp)
+ if err != nil {
+ protocol.logHandler.logf(Error, logErrorGeneric, "receive()", err.Error())
+ rs.Close()
+ errorCallback()
+ return
+ }
+}
+
+func (protocol *httpProtocol) handleResponse(rs ResultSet, response response) error {
+ fmt.Println("Handling response")
+
+ // TODO http specific response handling - below is just copy-pasted from web socket implementation for now
+
+ responseID, statusCode, metadata, data := response.responseID, response.responseStatus.code,
+ response.responseResult.meta, response.responseResult.data
+ responseIDString := responseID.String()
+ if rs == nil {
+ return newError(err0501ResponseHandlerResultSetNotCreatedError)
+ }
+ if aggregateTo, ok := metadata["aggregateTo"]; ok {
+ rs.setAggregateTo(aggregateTo.(string))
+ }
+
+ // Handle status codes appropriately. If status code is http.StatusPartialContent, we need to re-read data.
+ if statusCode == http.StatusNoContent {
+ rs.addResult(&Result{make([]interface{}, 0)})
+ rs.Close()
+ protocol.logHandler.logf(Debug, readComplete, responseIDString)
+ } else if statusCode == http.StatusOK {
+ // Add data and status attributes to the ResultSet.
+ rs.addResult(&Result{data})
+ rs.setStatusAttributes(response.responseStatus.attributes)
+ rs.Close()
+ protocol.logHandler.logf(Debug, readComplete, responseIDString)
+ } else if statusCode == http.StatusPartialContent {
+ // Add data to the ResultSet.
+ rs.addResult(&Result{data})
+ } else if statusCode == http.StatusProxyAuthRequired || statusCode == authenticationFailed {
+ // http status code 151 is not defined here, but corresponds with 403, i.e. authentication has failed.
+ // Server has requested basic auth.
+ authInfo := protocol.getAuthInfo()
+ if ok, username, password := authInfo.GetBasicAuth(); ok {
+ authBytes := make([]byte, 0)
+ authBytes = append(authBytes, 0)
+ authBytes = append(authBytes, []byte(username)...)
+ authBytes = append(authBytes, 0)
+ authBytes = append(authBytes, []byte(password)...)
+ encoded := base64.StdEncoding.EncodeToString(authBytes)
+ request := makeBasicAuthRequest(encoded)
+ // TODO retry
+ _, err := fmt.Fprintf(os.Stdout, "Skipping retry of failed request : %s\n", request.requestID)
+ if err != nil {
+ return err
+ }
+ } else {
+ rs.Close()
+ return newError(err0503ResponseHandlerAuthError, response.responseStatus, response.responseResult)
+ }
+ } else {
+ newError := newError(err0502ResponseHandlerReadLoopError, response.responseStatus, statusCode)
+ rs.setError(newError)
+ rs.Close()
+ protocol.logHandler.logf(Error, logErrorGeneric, "httpProtocol.responseHandler()", newError.Error())
+ }
+ return nil
+}
+
+func (protocol *httpProtocol) getAuthInfo() AuthInfoProvider {
+ if protocol.connSettings.authInfo == nil {
+ return NoopAuthInfo
+ }
+ return protocol.connSettings.authInfo
+}
+
+func (protocol *httpProtocol) errorCallback() {
+ protocol.logHandler.log(Error, errorCallback)
+}
diff --git a/gremlin-go/driver/httpTransporter.go b/gremlin-go/driver/httpTransporter.go
new file mode 100644
index 0000000000..431c0a19cd
--- /dev/null
+++ b/gremlin-go/driver/httpTransporter.go
@@ -0,0 +1,141 @@
+/*
+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 gremlingo
+
+import (
+ "bytes"
+ "compress/zlib"
+ "encoding/hex"
+ "errors"
+ "fmt"
+ "io"
+ "net"
+ "net/http"
+ "net/url"
+ "os"
+ "sync"
+ "time"
+)
+
+const keepAliveIntervalDefault = 5 * time.Second
+const writeDeadlineDefault = 3 * time.Second
+const writeChannelSizeDefault = 100
+const connectionTimeoutDefault = 5 * time.Second
+
+type HttpTransporter struct {
+ url string
+ isClosed bool
+ connSettings *connectionSettings
+ responseChannel chan []byte
+ httpClient *http.Client
+ wg *sync.WaitGroup
+}
+
+func NewHttpTransporter(url string, connSettings *connectionSettings, httpClient *http.Client) *HttpTransporter {
+ wg := &sync.WaitGroup{}
+
+ return &HttpTransporter{
+ url: url,
+ connSettings: connSettings,
+ responseChannel: make(chan []byte, writeChannelSizeDefault),
+ httpClient: httpClient,
+ wg: wg,
+ }
+}
+
+func (transporter *HttpTransporter) Write(data []byte) error {
+ fmt.Println("Sending request message")
+ u, err := url.Parse(transporter.url)
+ if err != nil {
+ return err
+ }
+ host, _, err := net.SplitHostPort(u.Host)
+ if err != nil {
+ return err
+ }
+
+ header := http.Header{
+ "content-type": {graphBinaryMimeType},
+ "host": {host},
+ "accept": {graphBinaryMimeType},
+ }
+ if transporter.connSettings.enableUserAgentOnConnect {
+ header.Set(userAgentHeader, userAgent)
+ }
+ if transporter.connSettings.enableCompression {
+ header.Set("accept-encoding", "deflate")
+ }
+
+ body := io.NopCloser(bytes.NewReader(data))
+ req := http.Request{
+ Method: "POST",
+ URL: u,
+ Header: header,
+ Body: body,
+ ContentLength: int64(len(data)),
+ }
+
+ resp, err := transporter.httpClient.Do(&req)
+ if err != nil {
+ return err
+ }
+
+ reader := resp.Body
+ if resp.Header.Get("content-encoding") == "deflate" {
+ reader, err = zlib.NewReader(resp.Body)
+ if err != nil {
+ return err
+ }
+ }
+
+ // TODO handle chunked encoding
+
+ all, err := io.ReadAll(reader)
+ if err != nil {
+ return err
+ }
+
+ str := hex.EncodeToString(all)
+ _, _ = fmt.Fprintf(os.Stdout, "Received response data : %s\n", str)
+
+ fmt.Println("Sending response to responseChannel")
+ transporter.responseChannel <- all
+ return nil
+}
+
+func (transporter *HttpTransporter) Read() ([]byte, error) {
+ fmt.Println("Reading from responseChannel")
+ msg, ok := <-transporter.responseChannel
+ if !ok {
+ return []byte{}, errors.New("failed to read from channel")
+ }
+ return msg, nil
+}
+
+func (transporter *HttpTransporter) Close() (err error) {
+ fmt.Println("Closing http transporter")
+ if !transporter.isClosed {
+ if transporter.responseChannel != nil {
+ close(transporter.responseChannel)
+ }
+ transporter.isClosed = true
+ }
+ return
+}
diff --git a/gremlin-go/driver/logger.go b/gremlin-go/driver/logger.go
index 3cc623cbb4..c920804819 100644
--- a/gremlin-go/driver/logger.go
+++ b/gremlin-go/driver/logger.go
@@ -104,9 +104,7 @@ const (
unexpectedNull errorKey = "UNEXPECTED_NULL_VALUE"
closeConnection errorKey = "CLOSING_CONNECTION"
connectConnection errorKey = "OPENING_CONNECTION"
- failedConnection errorKey = "FAILED_CONNECTION"
writeRequest errorKey = "WRITE_REQUEST"
- readLoopError errorKey = "READ_LOOP_ERROR"
errorCallback errorKey = "ERROR_CALLBACK"
creatingRequest errorKey = "CREATING_REQUEST"
readComplete errorKey = "READ_COMPLETE"
@@ -122,9 +120,5 @@ const (
closeDriverRemoteConnection errorKey = "CLOSE_DRIVER_REMOTE_CONNECTION"
closingSpawnedSessions errorKey = "CLOSING_SPAWNED_SESSIONS"
closeClient errorKey = "CLOSE_CLIENT"
- errorClosingConnection errorKey = "ERROR_CLOSING_CONNECTION"
- createConnectionError errorKey = "CREATE_CONNECTION_ERROR"
- poolNewConnectionError errorKey = "POOL_NEW_CONNECTION_ERROR"
sessionDetected errorKey = "SESSION_DETECTED"
- poolInitialExceedsMaximum errorKey = "POOL_INITIAL_EXCEEDS_MAXIMUM"
)
diff --git a/gremlin-go/driver/performance/performanceSuite.go b/gremlin-go/driver/performance/performanceSuite.go
index 3adb3b38ad..ba2b493b91 100644
--- a/gremlin-go/driver/performance/performanceSuite.go
+++ b/gremlin-go/driver/performance/performanceSuite.go
@@ -364,16 +364,14 @@ const threshold = 4 // same as default
const bufferSize = 314572800
const poolingBufferSize = 26214400
-//
// createConnection: Creates a connection to a remote endpoint and returns a
// GraphTraversalSource that can be used to submit Gremlin queries.
-//
func createConnection(host string, port, poolSize, buffersSize int) (*GraphTraversalSource, *DriverRemoteConnection, error) {
var g *GraphTraversalSource
var drc *DriverRemoteConnection
var err error
- endpoint := fmt.Sprintf("ws://%s:%d/gremlin", host, port)
+ endpoint := fmt.Sprintf("http://%s:%d/gremlin", host, port)
log.Println("Attempting to connect to : " + endpoint)
// Establish a new connection and catch any errors that may occur
@@ -416,9 +414,7 @@ Options:
`
)
-//
// main: Program entry point. Create the connection, run performance tests, shutdown.
-//
func main() {
hostPtr := flag.String("host", Host, "Server host, the default is localhost.")
portPtr := flag.Int("port", Port, "Server port, the default is 45940.")
diff --git a/gremlin-go/driver/protocol.go b/gremlin-go/driver/protocol.go
deleted file mode 100644
index da44bb7807..0000000000
--- a/gremlin-go/driver/protocol.go
+++ /dev/null
@@ -1,199 +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 gremlingo
-
-import (
- "encoding/base64"
- "net/http"
- "sync"
-)
-
-// protocol handles invoking serialization and deserialization, as well as handling the lifecycle of raw data passed to
-// and received from the transport layer.
-type protocol interface {
- readLoop(resultSets *synchronizedMap, errorCallback func())
- write(request *request) error
- close(wait bool) error
-}
-
-const authenticationFailed = uint16(151)
-
-type protocolBase struct {
- protocol
-
- transporter transporter
-}
-
-type gremlinServerWSProtocol struct {
- *protocolBase
-
- serializer serializer
- logHandler *logHandler
- closed bool
- mutex sync.Mutex
- wg *sync.WaitGroup
-}
-
-func (protocol *gremlinServerWSProtocol) readLoop(resultSets *synchronizedMap, errorCallback func()) {
- defer protocol.wg.Done()
-
- for {
- // Read from transport layer. If the channel is closed, this will error out and exit.
- msg, err := protocol.transporter.Read()
- protocol.mutex.Lock()
- if protocol.closed {
- protocol.mutex.Unlock()
- return
- }
- protocol.mutex.Unlock()
- if err != nil {
- // Ignore error here, we already got an error on read, cannot do anything with this.
- _ = protocol.transporter.Close()
- protocol.logHandler.logf(Error, readLoopError, err.Error())
- readErrorHandler(resultSets, errorCallback, err, protocol.logHandler)
- return
- }
-
- // Deserialize message and unpack.
- resp, err := protocol.serializer.deserializeMessage(msg)
- if err != nil {
- protocol.logHandler.logf(Error, logErrorGeneric, "gremlinServerWSProtocol.readLoop()", err.Error())
- readErrorHandler(resultSets, errorCallback, err, protocol.logHandler)
- return
- }
-
- err = protocol.responseHandler(resultSets, resp)
- if err != nil {
- readErrorHandler(resultSets, errorCallback, err, protocol.logHandler)
- return
- }
- }
-}
-
-// If there is an error, we need to close the ResultSets and then pass the error back.
-func readErrorHandler(resultSets *synchronizedMap, errorCallback func(), err error, log *logHandler) {
- log.logf(Error, readLoopError, err.Error())
- resultSets.closeAll(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
- responseIDString := responseID.String()
- if resultSets.load(responseIDString) == nil {
- return newError(err0501ResponseHandlerResultSetNotCreatedError)
- }
- if aggregateTo, ok := metadata["aggregateTo"]; ok {
- resultSets.load(responseIDString).setAggregateTo(aggregateTo.(string))
- }
-
- // Handle status codes appropriately. If status code is http.StatusPartialContent, we need to re-read data.
- if statusCode == http.StatusNoContent {
- resultSets.load(responseIDString).addResult(&Result{make([]interface{}, 0)})
- resultSets.load(responseIDString).Close()
- protocol.logHandler.logf(Debug, readComplete, responseIDString)
- } 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).Close()
- protocol.logHandler.logf(Debug, readComplete, responseIDString)
- } else if statusCode == http.StatusPartialContent {
- // Add data to the ResultSet.
- resultSets.load(responseIDString).addResult(&Result{data})
- } else if statusCode == http.StatusProxyAuthRequired || statusCode == authenticationFailed {
- // http status code 151 is not defined here, but corresponds with 403, i.e. authentication has failed.
- // Server has requested basic auth.
- authInfo := protocol.transporter.getAuthInfo()
- if ok, username, password := authInfo.GetBasicAuth(); ok {
- authBytes := make([]byte, 0)
- authBytes = append(authBytes, 0)
- authBytes = append(authBytes, []byte(username)...)
- authBytes = append(authBytes, 0)
- authBytes = append(authBytes, []byte(password)...)
- encoded := base64.StdEncoding.EncodeToString(authBytes)
- request := makeBasicAuthRequest(encoded)
- err := protocol.write(&request)
- if err != nil {
- return err
- }
- } else {
- resultSets.load(responseIDString).Close()
- return newError(err0503ResponseHandlerAuthError, response.responseStatus, response.responseResult)
- }
- } else {
- newError := newError(err0502ResponseHandlerReadLoopError, response.responseStatus, statusCode)
- resultSets.load(responseIDString).setError(newError)
- resultSets.load(responseIDString).Close()
- protocol.logHandler.logf(Error, logErrorGeneric, "gremlinServerWSProtocol.responseHandler()", newError.Error())
- }
- return nil
-}
-
-func (protocol *gremlinServerWSProtocol) write(request *request) error {
- bytes, err := protocol.serializer.serializeMessage(request)
- if err != nil {
- return err
- }
- return protocol.transporter.Write(bytes)
-}
-
-func (protocol *gremlinServerWSProtocol) close(wait bool) error {
- var err error
-
- protocol.mutex.Lock()
- if !protocol.closed {
- err = protocol.transporter.Close()
- protocol.closed = true
- }
- protocol.mutex.Unlock()
-
- if wait {
- protocol.wg.Wait()
- }
-
- return err
-}
-
-func newGremlinServerWSProtocol(handler *logHandler, transporterType TransporterType, url string, connSettings *connectionSettings, results *synchronizedMap,
- errorCallback func()) (protocol, error) {
- wg := &sync.WaitGroup{}
- transport, err := getTransportLayer(transporterType, url, connSettings, handler)
- if err != nil {
- return nil, err
- }
-
- gremlinProtocol := &gremlinServerWSProtocol{
- protocolBase: &protocolBase{transporter: transport},
- serializer: newGraphBinarySerializer(handler),
- logHandler: handler,
- closed: false,
- mutex: sync.Mutex{},
- wg: wg,
- }
- err = gremlinProtocol.transporter.Connect()
- if err != nil {
- return nil, err
- }
- wg.Add(1)
- go gremlinProtocol.readLoop(results, errorCallback)
- return gremlinProtocol, nil
-}
diff --git a/gremlin-go/driver/protocol_test.go b/gremlin-go/driver/protocol_test.go
deleted file mode 100644
index 08bcbf85a3..0000000000
--- a/gremlin-go/driver/protocol_test.go
+++ /dev/null
@@ -1,91 +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 gremlingo
-
-import (
- "sync"
- "testing"
- "time"
-
- "github.com/stretchr/testify/assert"
- "golang.org/x/text/language"
-)
-
-func TestProtocol(t *testing.T) {
- t.Run("Test protocol connect error.", func(t *testing.T) {
- connSettings := newDefaultConnectionSettings()
- connSettings.authInfo, connSettings.tlsConfig = nil, nil
- connSettings.keepAliveInterval, connSettings.writeDeadline, connSettings.writeDeadline = keepAliveIntervalDefault, writeDeadlineDefault, connectionTimeoutDefault
-
- protocol, err := newGremlinServerWSProtocol(newLogHandler(&defaultLogger{}, Info, language.English), Gorilla,
- "ws://localhost:9000/gremlin", connSettings,
- nil, nil)
- assert.NotNil(t, err)
- assert.Nil(t, protocol)
- })
-
- t.Run("Test protocol close wait", func(t *testing.T) {
- wg := &sync.WaitGroup{}
- protocol := &gremlinServerWSProtocol{
- closed: true,
- mutex: sync.Mutex{},
- wg: wg,
- }
- wg.Add(1)
-
- done := make(chan bool)
-
- go func() {
- protocol.close(true)
- done <- true
- }()
-
- select {
- case <-time.After(1 * time.Second):
- // Ok. Close must wait.
- case <-done:
- t.Fatal("protocol.close is not waiting")
- }
- })
-
- t.Run("Test protocol close no wait", func(t *testing.T) {
- wg := &sync.WaitGroup{}
- protocol := &gremlinServerWSProtocol{
- closed: true,
- mutex: sync.Mutex{},
- wg: wg,
- }
- wg.Add(1)
-
- done := make(chan bool)
-
- go func() {
- protocol.close(false)
- done <- true
- }()
-
- select {
- case <-time.After(1 * time.Second):
- t.Fatal("protocol.close is waiting")
- case <-done:
- // Ok. Close must not wait.
- }
- })
-}
diff --git a/gremlin-go/driver/request.go b/gremlin-go/driver/request.go
index e64195adb5..3aa1cd4577 100644
--- a/gremlin-go/driver/request.go
+++ b/gremlin-go/driver/request.go
@@ -39,7 +39,8 @@ const stringProcessor = ""
func makeStringRequest(stringGremlin string, traversalSource string, sessionId string, requestOptions RequestOptions) (req request) {
newProcessor := stringProcessor
newArgs := map[string]interface{}{
- "gremlin": stringGremlin,
+ "gremlin": stringGremlin,
+ "language": "gremlin-lang",
"aliases": map[string]interface{}{
"g": traversalSource,
},
diff --git a/gremlin-go/driver/serializer.go b/gremlin-go/driver/serializer.go
index c4d7da3922..0b056fb907 100644
--- a/gremlin-go/driver/serializer.go
+++ b/gremlin-go/driver/serializer.go
@@ -22,15 +22,15 @@ package gremlingo
import (
"bytes"
"encoding/binary"
- "math/big"
+ "fmt"
+ "os"
"reflect"
- "strings"
"sync"
"github.com/google/uuid"
)
-const graphBinaryMimeType = "application/vnd.graphbinary-v1.0"
+const graphBinaryMimeType = "application/vnd.graphbinary-v4.0"
// serializer interface for serializers.
type serializer interface {
@@ -111,79 +111,22 @@ func (gs graphBinarySerializer) serializeMessage(request *request) ([]byte, erro
func (gs *graphBinarySerializer) buildMessage(id uuid.UUID, mimeLen byte, op string, processor string, args map[string]interface{}) ([]byte, error) {
buffer := bytes.Buffer{}
- // mime header
- buffer.WriteByte(mimeLen)
- buffer.WriteString(graphBinaryMimeType)
-
// Version
buffer.WriteByte(versionByte)
- // Request uuid
- bigIntUUID := uuidToBigInt(id)
- lower := bigIntUUID.Uint64()
- upperBigInt := bigIntUUID.Rsh(&bigIntUUID, 64)
- upper := upperBigInt.Uint64()
- err := binary.Write(&buffer, binary.BigEndian, upper)
- if err != nil {
- return nil, err
- }
- err = binary.Write(&buffer, binary.BigEndian, lower)
- if err != nil {
- return nil, err
- }
-
- // op
- err = binary.Write(&buffer, binary.BigEndian, uint32(len(op)))
- if err != nil {
- return nil, err
- }
-
- _, err = buffer.WriteString(op)
- if err != nil {
- return nil, err
- }
-
- // processor
- err = binary.Write(&buffer, binary.BigEndian, uint32(len(processor)))
+ _, err := gs.ser.writeValue(args, &buffer, false)
if err != nil {
return nil, err
}
-
- _, err = buffer.WriteString(processor)
+ gremlin := args["gremlin"]
+ _, err = gs.ser.writeValue(gremlin, &buffer, false)
if err != nil {
return nil, err
}
- // args
- err = binary.Write(&buffer, binary.BigEndian, uint32(len(args)))
- if err != nil {
- return nil, err
- }
- for k, v := range args {
- _, err = gs.ser.write(k, &buffer)
- if err != nil {
- return nil, err
- }
-
- switch t := v.(type) {
- case []byte:
- _, err = buffer.Write(t)
- default:
- _, err = gs.ser.write(t, &buffer)
- }
- if err != nil {
- return nil, err
- }
- }
return buffer.Bytes(), nil
}
-func uuidToBigInt(requestID uuid.UUID) big.Int {
- var bigInt big.Int
- bigInt.SetString(strings.Replace(requestID.String(), "-", "", 4), 16)
- return bigInt
-}
-
// deserializeMessage deserializes a response message.
func (gs graphBinarySerializer) deserializeMessage(message []byte) (response, error) {
var msg response
@@ -193,36 +136,18 @@ func (gs graphBinarySerializer) deserializeMessage(message []byte) (response, er
return msg, newError(err0405ReadValueInvalidNullInputError)
}
- // Skip version and nullable byte.
+ //Skip version and nullable byte.
i := 2
- id, err := readUuid(&message, &i)
- if err != nil {
- return msg, err
- }
- 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)
- }
- attr, err := readMapUnqualified(&message, &i)
- if err != nil {
- return msg, err
- }
- 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)
+ n, err := readFullyQualifiedNullable(&message, &i, true)
if err != nil {
return msg, err
}
+ _, _ = fmt.Fprintf(os.Stdout, "Deserialized data : %s\n", n)
+ msg.responseResult.data = n
+ // TODO deserialize status code from response
+ msg.responseStatus.code = 200
+ msg.responseStatus.message = "OK"
+ msg.responseStatus.attributes = map[string]interface{}{}
return msg, nil
}
@@ -309,7 +234,7 @@ func initDeserializers() {
// Customer
customType: customTypeReader,
- markerType: markerReader,
+ markerType: readByte,
}
customDeserializers = map[string]CustomTypeReader{}
}
diff --git a/gremlin-go/driver/strategies.go b/gremlin-go/driver/strategies.go
index ca53da00c9..5f40439e89 100644
--- a/gremlin-go/driver/strategies.go
+++ b/gremlin-go/driver/strategies.go
@@ -204,7 +204,7 @@ type MatchAlgorithmStrategyConfig struct {
func EdgeLabelVerificationStrategy(config EdgeLabelVerificationStrategyConfig) TraversalStrategy {
configMap := map[string]interface{}{
"logWarning": config.LogWarning,
- "throwException": config.ThrowExcecption,
+ "throwException": config.ThrowException,
}
return &traversalStrategy{name: "EdgeLabelVerificationStrategy", configuration: configMap}
@@ -213,8 +213,8 @@ func EdgeLabelVerificationStrategy(config EdgeLabelVerificationStrategyConfig) T
// EdgeLabelVerificationStrategyConfig provides configuration options for EdgeLabelVerificationStrategy.
// Zeroed (unset) values are used.
type EdgeLabelVerificationStrategyConfig struct {
- LogWarning bool
- ThrowExcecption bool
+ LogWarning bool
+ ThrowException bool
}
// LambdaRestrictionStrategy does not allow lambdas to be used in a Traversal. The contents of a lambda
diff --git a/gremlin-go/driver/strategies_test.go b/gremlin-go/driver/strategies_test.go
index 3649eedb5a..6f85a2804b 100644
--- a/gremlin-go/driver/strategies_test.go
+++ b/gremlin-go/driver/strategies_test.go
@@ -330,8 +330,8 @@ func TestStrategy(t *testing.T) {
defer g.remoteConnection.Close()
config := EdgeLabelVerificationStrategyConfig{
- LogWarning: true,
- ThrowExcecption: true,
+ LogWarning: true,
+ ThrowException: true,
}
count, err := g.WithStrategies(EdgeLabelVerificationStrategy(config)).V().Count().ToList()
assert.Nil(t, err)
diff --git a/gremlin-go/driver/transporter.go b/gremlin-go/driver/transporter.go
deleted file mode 100644
index 11d65f5e73..0000000000
--- a/gremlin-go/driver/transporter.go
+++ /dev/null
@@ -1,40 +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 gremlingo
-
-import "time"
-
-type transporter interface {
- Connect() error
- Write(data []byte) error
- Read() ([]byte, error)
- Close() error
- IsClosed() bool
- getAuthInfo() AuthInfoProvider
-}
-
-type websocketConn interface {
- WriteMessage(int, []byte) error
- ReadMessage() (int, []byte, error)
- SetPongHandler(h func(appData string) error)
- Close() error
- SetReadDeadline(t time.Time) error
- SetWriteDeadline(t time.Time) error
-}
diff --git a/gremlin-go/driver/transporterFactory.go b/gremlin-go/driver/transporterFactory.go
deleted file mode 100644
index 6177120ec4..0000000000
--- a/gremlin-go/driver/transporterFactory.go
+++ /dev/null
@@ -1,53 +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 gremlingo
-
-import (
- "sync"
-)
-
-// TransporterType is an alias for valid transport protocols.
-type TransporterType int
-
-const (
- // Gorilla transport layer: github.com/gorilla/websocket
- Gorilla TransporterType = iota + 1
-)
-
-func getTransportLayer(transporterType TransporterType, url string, connSettings *connectionSettings, logHandler *logHandler) (transporter, error) {
- var transporter transporter
- switch transporterType {
- case Gorilla:
- transporter = &gorillaTransporter{
- url: url,
- logHandler: logHandler,
- connSettings: connSettings,
- writeChannel: make(chan []byte, writeChannelSizeDefault),
- wg: &sync.WaitGroup{},
- }
- default:
- return nil, newError(err0801GetTransportLayerNoTypeError)
- }
- err := transporter.Connect()
- if err != nil {
- return nil, err
- }
- return transporter, nil
-}
diff --git a/gremlin-go/driver/traversal.go b/gremlin-go/driver/traversal.go
index 83fb19f2a5..e2680a1516 100644
--- a/gremlin-go/driver/traversal.go
+++ b/gremlin-go/driver/traversal.go
@@ -654,7 +654,7 @@ var WithOptions = withOptions{
Map: 1,
}
-type io struct {
+type ioconfig struct {
Graphson string
Gryo string
Graphml string
@@ -663,14 +663,14 @@ type io struct {
Registry string
}
-// IO holds configuration options to be passed to the GraphTraversal.io.
-var IO = io{
+// IO holds configuration options to be passed to the GraphTraversal.ioconfig.
+var IO = ioconfig{
Graphson: "graphson",
Gryo: "gryo",
Graphml: "graphml",
- Reader: "~tinkerpop.io.reader",
- Writer: "~tinkerpop.io.writer",
- Registry: "~tinkerpop.io.registry",
+ Reader: "~tinkerpop.ioconfig.reader",
+ Writer: "~tinkerpop.ioconfig.writer",
+ Registry: "~tinkerpop.ioconfig.registry",
}
// Metrics holds metrics data; typically for .profile()-step analysis. Metrics may be nested. Nesting enables
diff --git a/gremlin-go/driver/user_agent.go b/gremlin-go/driver/user_agent.go
index 16572e7b2d..afdf50bb32 100644
--- a/gremlin-go/driver/user_agent.go
+++ b/gremlin-go/driver/user_agent.go
@@ -27,7 +27,7 @@ import (
)
/**
- * User Agent body to be sent in web socket handshake
+ * User Agent header to be sent in the http request
* Has the form of:
* [Application Name] [GLV Name]/[Version] [Language Runtime Version] [OS]/[Version] [CPU Architecture]
* Note: Go does not have any builtin functionality to detect the OS version, therefore OS version will always be
diff --git a/gremlin-go/examples/basic_gremlin.go b/gremlin-go/examples/basic_gremlin.go
index 0ab2b1117f..9586130204 100644
--- a/gremlin-go/examples/basic_gremlin.go
+++ b/gremlin-go/examples/basic_gremlin.go
@@ -26,7 +26,7 @@ import (
)
func main() {
- driverRemoteConnection, err := gremlingo.NewDriverRemoteConnection("ws://localhost:8182/gremlin")
+ driverRemoteConnection, err := gremlingo.NewDriverRemoteConnection("http://localhost:8182/gremlin")
if err != nil {
fmt.Println(err)
return
@@ -66,4 +66,4 @@ func main() {
for _, person := range peopleMarkoKnows {
fmt.Println("marko knows", person.GetString())
}
-}
\ No newline at end of file
+}
diff --git a/gremlin-go/examples/connections.go b/gremlin-go/examples/connections.go
index 284720ab44..c263644c62 100644
--- a/gremlin-go/examples/connections.go
+++ b/gremlin-go/examples/connections.go
@@ -30,7 +30,7 @@ func main() {
func withRemote() {
// Creating the connection to the server
- driverRemoteConnection, err := gremlingo.NewDriverRemoteConnection("ws://localhost:8182/gremlin")
+ driverRemoteConnection, err := gremlingo.NewDriverRemoteConnection("http://localhost:8182/gremlin")
// Error handling
if err != nil {
@@ -56,7 +56,7 @@ func withRemote() {
func withConfigs() {
// Connecting to the server with customized configurations
- driverRemoteConnection, err := gremlingo.NewDriverRemoteConnection("ws://localhost:8182/gremlin",
+ driverRemoteConnection, err := gremlingo.NewDriverRemoteConnection("http://localhost:8182/gremlin",
func(settings *gremlingo.DriverRemoteConnectionSettings) {
settings.TraversalSource = "g"
settings.NewConnectionThreshold = 4
diff --git a/gremlin-go/examples/modern_traversals.go b/gremlin-go/examples/modern_traversals.go
index a1c9ad8320..514196ba21 100644
--- a/gremlin-go/examples/modern_traversals.go
+++ b/gremlin-go/examples/modern_traversals.go
@@ -30,7 +30,7 @@ var T = gremlingo.T
var P = gremlingo.P
func main() {
- driverRemoteConnection, err := gremlingo.NewDriverRemoteConnection("ws://localhost:8182/gremlin")
+ driverRemoteConnection, err := gremlingo.NewDriverRemoteConnection("http://localhost:8182/gremlin")
if err != nil {
fmt.Println(err)
return
diff --git a/gremlin-go/go.mod b/gremlin-go/go.mod
index 8fdbf98bc1..4aeb8c9a86 100644
--- a/gremlin-go/go.mod
+++ b/gremlin-go/go.mod
@@ -22,7 +22,6 @@ go 1.22.0
require (
github.com/cucumber/godog v0.15.0
github.com/google/uuid v1.6.0
- github.com/gorilla/websocket v1.5.3
github.com/nicksnyder/go-i18n/v2 v2.5.0
github.com/stretchr/testify v1.9.0
golang.org/x/text v0.21.0
@@ -39,5 +38,4 @@ require (
github.com/hashicorp/golang-lru v0.5.4 // indirect
github.com/pmezard/go-difflib v1.0.0 // indirect
github.com/spf13/pflag v1.0.5 // indirect
- github.com/stretchr/objx v0.5.2 // indirect
)
diff --git a/gremlin-go/go.sum b/gremlin-go/go.sum
index 6586cbb584..87eb5eae01 100644
--- a/gremlin-go/go.sum
+++ b/gremlin-go/go.sum
@@ -16,8 +16,6 @@ github.com/gofrs/uuid v4.3.1+incompatible h1:0/KbAdpx3UXAx1kEOWHJeOkpbgRFGHVgv+C
github.com/gofrs/uuid v4.3.1+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM=
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
-github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
github.com/hashicorp/go-immutable-radix v1.3.0/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60=
github.com/hashicorp/go-immutable-radix v1.3.1 h1:DKHmCUm2hRBK510BaiZlwvpD40f8bJFeZnpfm2KLowc=
github.com/hashicorp/go-immutable-radix v1.3.1/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60=
@@ -46,8 +44,6 @@ github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
-github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=
-github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
diff --git a/gremlin-go/pom.xml b/gremlin-go/pom.xml
index bbd953205a..41973b9dff 100644
--- a/gremlin-go/pom.xml
+++ b/gremlin-go/pom.xml
@@ -86,10 +86,9 @@ limitations under the License.
<id>glv-go</id>
<activation>
<activeByDefault>false</activeByDefault>
- <!-- TODO re-enable after gremlin-go is implemented -->
-<!-- <file>-->
-<!-- <exists>.glv</exists>-->
-<!-- </file>-->
+ <file>
+ <exists>.glv</exists>
+ </file>
</activation>
<build>
<directory>${basedir}/target</directory>
@@ -124,40 +123,40 @@ limitations under the License.
</arguments>
</configuration>
</execution>
- <execution>
- <id>shutdown-container</id>
- <phase>integration-test</phase>
- <goals>
- <goal>exec</goal>
- </goals>
- <configuration>
- <skip>${skipTests}</skip>
- <!-- don't need to set env variables for container tear down -->
- <executable>docker</executable>
- <arguments>
- <argument>compose</argument>
- <argument>down</argument>
- </arguments>
- </configuration>
- </execution>
- <execution>
- <id>remove-dangling-images</id>
- <phase>integration-test</phase>
- <goals>
- <goal>exec</goal>
- </goals>
- <configuration>
- <skip>${skipTests}</skip>
- <executable>docker</executable>
- <arguments>
- <argument>image</argument>
- <argument>prune</argument>
- <argument>--filter</argument>
- <argument>label=maintainer=dev@tinkerpop.apache.org</argument>
- <argument>-f</argument>
- </arguments>
- </configuration>
- </execution>
+<!-- <execution>-->
+<!-- <id>shutdown-container</id>-->
+<!-- <phase>integration-test</phase>-->
+<!-- <goals>-->
+<!-- <goal>exec</goal>-->
+<!-- </goals>-->
+<!-- <configuration>-->
+<!-- <skip>${skipTests}</skip>-->
+<!-- <!– don't need to set env variables for container tear down –>-->
+<!-- <executable>docker</executable>-->
+<!-- <arguments>-->
+<!-- <argument>compose</argument>-->
+<!-- <argument>down</argument>-->
+<!-- </arguments>-->
+<!-- </configuration>-->
+<!-- </execution>-->
+<!-- <execution>-->
+<!-- <id>remove-dangling-images</id>-->
+<!-- <phase>integration-test</phase>-->
+<!-- <goals>-->
+<!-- <goal>exec</goal>-->
+<!-- </goals>-->
+<!-- <configuration>-->
+<!-- <skip>${skipTests}</skip>-->
+<!-- <executable>docker</executable>-->
+<!-- <arguments>-->
+<!-- <argument>image</argument>-->
+<!-- <argument>prune</argument>-->
+<!-- <argument>--filter</argument>-->
+<!-- <argument>label=maintainer=dev@tinkerpop.apache.org</argument>-->
+<!-- <argument>-f</argument>-->
+<!-- </arguments>-->
+<!-- </configuration>-->
+<!-- </execution>-->
</executions>
</plugin>
<plugin>
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 81388de4ed..47d155b0f3 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
@@ -300,7 +300,7 @@ public class HttpGremlinEndpointHandler extends SimpleChannelInboundHandler<Requ
return GremlinError.parsing((GremlinParserException) t);
}
- logger.warn(String.format("Exception processing request [%s].", requestMessage));
+ logger.warn(String.format("Exception processing request [%s].", requestMessage), t);
return GremlinError.general(t);
}
diff --git a/gremlin-server/src/main/java/org/apache/tinkerpop/gremlin/server/handler/HttpRequestMessageDecoder.java b/gremlin-server/src/main/java/org/apache/tinkerpop/gremlin/server/handler/HttpRequestMessageDecoder.java
index aef8dd536c..c342ae73a4 100644
--- a/gremlin-server/src/main/java/org/apache/tinkerpop/gremlin/server/handler/HttpRequestMessageDecoder.java
+++ b/gremlin-server/src/main/java/org/apache/tinkerpop/gremlin/server/handler/HttpRequestMessageDecoder.java
@@ -80,6 +80,7 @@ public class HttpRequestMessageDecoder extends MessageToMessageDecoder<FullHttpR
@Override
protected void decode(final ChannelHandlerContext ctx, final FullHttpRequest req, final List<Object> objects) throws Exception {
+ System.out.println("Received FullHttpRequest " + req.method() + " " + req.uri());
ctx.channel().attr(StateKey.REQUEST_HEADERS).set(req.headers());
final String acceptMime = Optional.ofNullable(req.headers().get(HttpHeaderNames.ACCEPT)).orElse("application/json");
@@ -160,7 +161,9 @@ public class HttpRequestMessageDecoder extends MessageToMessageDecoder<FullHttpR
final ByteBuf buffer = request.content();
try {
- return serializer.deserializeBinaryRequest(buffer);
+ RequestMessage requestMessage = serializer.deserializeBinaryRequest(buffer);
+ System.out.println("Deserialized " + requestMessage);
+ return requestMessage;
} catch (Exception e) {
throw new SerializationException("Unable to deserialize request using: " + serializer.getClass().getSimpleName(), e);
}
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 e26d02a017..cbd8cb34e9 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
@@ -234,12 +234,14 @@ public class GraphBinaryMessageSerializerV4 extends AbstractMessageSerializer<Gr
: aggregate;
if (data != null) {
for (final Object item : (List) data) {
+ System.out.println("Writing item: " + item);
writer.write(item, buffer);
}
}
}
if (parts.contains(MessageParts.FOOTER)) {
+ System.out.println("Writing footer");
final ResponseStatus status = responseMessage.getStatus();
// we don't know how much data we have, so need a special object
@@ -254,9 +256,25 @@ public class GraphBinaryMessageSerializerV4 extends AbstractMessageSerializer<Gr
} catch (IOException e) {
throw new SerializationException(e);
}
+
+ ByteBuf copy = byteBuf.copy();
+ byte[] copyBytes = new byte[copy.readableBytes()];
+ copy.readBytes(copyBytes);
+ System.out.println("Wrote hex str: " + bytesToHex(copyBytes));
return byteBuf;
}
+ private static final char[] HEX_ARRAY = "0123456789ABCDEF".toCharArray();
+ public static String bytesToHex(byte[] bytes) {
+ char[] hexChars = new char[bytes.length * 2];
+ for (int j = 0; j < bytes.length; j++) {
+ int v = bytes[j] & 0xFF;
+ hexChars[j * 2] = HEX_ARRAY[v >>> 4];
+ hexChars[j * 2 + 1] = HEX_ARRAY[v & 0x0F];
+ }
+ return new String(hexChars).toLowerCase();
+ }
+
//////////////// read message methods
@Override