gremlin

README

Gremlin Server Client for Go

This library will allow you to connect to any graph database that supports TinkerPop3 using Go. This includes databases like Titan and Neo4J. TinkerPop3 uses Gremlin Server to communicate with clients using either WebSockets or REST API. This library talks to Gremlin Server using WebSockets.

Installation

go get github.com/go-gremlin/gremlin

Usage

Export the list of databases you want to connect to as GREMLIN_SERVERS like so:-

export GREMLIN_SERVERS="ws://server1:8182, ws://server2:8182"

Import the library eg import "github.com/go-gremlin/gremlin".

Parse and save your cluster of services. You only need to do this once before submitting any queries (Perhaps in main()):-

	if err := gremlin.NewCluster(); err != nil {
		// handle error here
	}

Instead of using an environment variable, you can also pass the servers directly to NewCluster(). This is more convenient in development. For example:-

	if err := gremlin.NewCluster("ws://dev.local:8182", "ws://staging.local:8182"); err != nil {
		// handle error
	}

To actually run queries against the database, make sure the package is imported and issue a gremlin query like this:-

	data, err := gremlin.Query(`g.V()`).Exec()
	if err != nil  {
		// handle error
	}

data is a JSON array in bytes []byte if any data is returned otherwise it is nil. For example you can print it using:-

	fmt.Println(string(data))

or unmarshal it as desired.

You can also execute a query with bindings like this:-

	data, err := gremlin.Query(`g.V().has("name", userName).valueMap()`).Bindings(gremlin.Bind{"userName": "john"}).Exec()

Documentation

Index

• Constants
• Variables
• func CreateConnection() (conn net.Conn, server *url.URL, err error)
• func NewCluster(s ...string) (err error)
• func ReadResponse(ws *websocket.Conn) (data []byte, err error)
• func SplitServers(connString string) (servers []*url.URL, err error)
• type Bind
• type Request
  • func Query(query string) *Request
  • func (req *Request) Bindings(bindings Bind) *Request
  • func (req *Request) Exec() (data []byte, err error)
• type RequestArgs
• type Response
• type ResponseResult
• type ResponseStatus

Constants

const (
	StatusSuccess                  = 200
	StatusNoContent                = 204
	StatusPartialContent           = 206
	StatusUnauthorized             = 401
	StatusAuthenticate             = 407
	StatusMalformedRequest         = 498
	StatusInvalidRequestArguments  = 499
	StatusServerError              = 500
	StatusScriptEvaluationError    = 597
	StatusServerTimeout            = 598
	StatusServerSerializationError = 599
)

Variables

var ErrorMsg = map[int]string{
	StatusUnauthorized:             "Unauthorized",
	StatusAuthenticate:             "Authenticate",
	StatusMalformedRequest:         "Malformed Request",
	StatusInvalidRequestArguments:  "Invalid Request Arguments",
	StatusServerError:              "Server Error",
	StatusScriptEvaluationError:    "Script Evaluation Error",
	StatusServerTimeout:            "Server Timeout",
	StatusServerSerializationError: "Server Serialization Error",
}

Functions

func CreateConnection

func CreateConnection() (conn net.Conn, server *url.URL, err error)

func NewCluster

func NewCluster(s ...string) (err error)

func ReadResponse

func ReadResponse(ws *websocket.Conn) (data []byte, err error)

func SplitServers

func SplitServers(connString string) (servers []*url.URL, err error)

Types

type Bind

type Bind map[string]interface{}

type Request

type Request struct {
	RequestId string       `json:"requestId"`
	Op        string       `json:"op"`
	Processor string       `json:"processor"`
	Args      *RequestArgs `json:"args"`
}

func Query

func Query(query string) *Request

func (*Request) Bindings

func (req *Request) Bindings(bindings Bind) *Request

func (*Request) Exec

func (req *Request) Exec() (data []byte, err error)

type RequestArgs

type RequestArgs struct {
	Gremlin    string `json:"gremlin,omitempty"`
	Session    string `json:"session,omitempty"`
	Bindings   Bind   `json:"bindings,omitempty"`
	Language   string `json:"language,omitempty"`
	Rebindings Bind   `json:"rebindings,omitempty"`
	Sasl       []byte `json:"sasl,omitempty"`
	BatchSize  int    `json:"batchSize,omitempty"`
}

type Response

type Response struct {
	RequestId string          `json:"requestId"`
	Status    *ResponseStatus `json:"status"`
	Result    *ResponseResult `json:"result"`
}

type ResponseResult

type ResponseResult struct {
	Data json.RawMessage        `json:"data"`
	Meta map[string]interface{} `json:"meta"`
}

type ResponseStatus

type ResponseStatus struct {
	Code       int                    `json:"code"`
	Attributes map[string]interface{} `json:"attributes"`
	Message    string                 `json:"message"`
}