tMerge branch 'release/v1.3.0'

Author: dancannon

Diff for: CHANGELOG.md

@@ -2,6 +2,15 @@
 All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](http://semver.org/).
 
+## v1.3.0 - 2016-01-11
+
+### Added
+ - Added new error types, the following error types can now be returned: `RQLClientError`, `RQLCompileError`, `RQLDriverCompileError`, `RQLServerCompileError`, `RQLAuthError`, `RQLRuntimeError`, `RQLQueryLogicError`, `RQLNonExistenceError`, `RQLResourceLimitError`, `RQLUserError`, `RQLInternalError`, `RQLTimeoutError`, `RQLAvailabilityError`, `RQLOpFailedError`, `RQLOpIndeterminateError`, `RQLDriverError`, `RQLConnectionError`. Please note that some other errors can be returned.
+ - Added `IsConnected` function to `Session`.
+ 
+### Fixed
+ - Fixed panic when scanning through results caused by incorrect queue implementation.
+
 ## v1.2.0 - 2015-11-19
 ### Added
  - Added `UUID` term

Diff for: README.md

@@ -8,7 +8,7 @@
 
 ![GoRethink Logo](https://raw.github.com/wiki/dancannon/gorethink/gopher-and-thinker-s.png "Golang Gopher and RethinkDB Thinker")
 
-Current version: v1.2.0 (RethinkDB v2.2)
+Current version: v1.3.0 (RethinkDB v2.2)
 
 Please note that this version of the driver only supports versions of RethinkDB using the v0.4 protocol (any versions of the driver older than RethinkDB 2.0 will not work).
 

Diff for: connection.go

@@ -21,6 +21,7 @@ const (
 type Response struct {
 	Token     int64
 	Type      p.Response_ResponseType   `json:"t"`
+	ErrorType p.Response_ErrorType      `json:"e"`
 	Notes     []p.Response_ResponseNote `json:"n"`
 	Responses []json.RawMessage         `json:"r"`
 	Backtrace []interface{}             `json:"b"`
@@ -187,7 +188,7 @@ func (c *Connection) sendQuery(q Query) error {
 	// Build query
 	b, err := json.Marshal(q.build())
 	if err != nil {
-		return RQLDriverError{"Error building query"}
+		return RQLDriverError{rqlError("Error building query")}
 	}
 
 	// Set timeout
@@ -200,7 +201,7 @@ func (c *Connection) sendQuery(q Query) error {
 	// Send the JSON encoding of the query itself.
 	if err = c.writeQuery(q.Token, b); err != nil {
 		c.bad = true
-		return RQLConnectionError{err.Error()}
+		return RQLConnectionError{rqlError(err.Error())}
 	}
 
 	return nil
@@ -237,14 +238,14 @@ func (c *Connection) readResponse() (*Response, error) {
 
 	if _, err := c.read(b, int(messageLength)); err != nil {
 		c.bad = true
-		return nil, RQLConnectionError{err.Error()}
+		return nil, RQLConnectionError{rqlError(err.Error())}
 	}
 
 	// Decode the response
 	var response = newCachedResponse()
 	if err := json.Unmarshal(b, response); err != nil {
 		c.bad = true
-		return nil, RQLDriverError{err.Error()}
+		return nil, RQLDriverError{rqlError(err.Error())}
 	}
 	response.Token = responseToken
 
@@ -254,11 +255,11 @@ func (c *Connection) readResponse() (*Response, error) {
 func (c *Connection) processResponse(q Query, response *Response) (*Response, *Cursor, error) {
 	switch response.Type {
 	case p.Response_CLIENT_ERROR:
-		return c.processErrorResponse(q, response, RQLClientError{rqlResponseError{response, q.Term}})
+		return c.processErrorResponse(q, response, RQLClientError{rqlServerError{response, q.Term}})
 	case p.Response_COMPILE_ERROR:
-		return c.processErrorResponse(q, response, RQLCompileError{rqlResponseError{response, q.Term}})
+		return c.processErrorResponse(q, response, RQLCompileError{rqlServerError{response, q.Term}})
 	case p.Response_RUNTIME_ERROR:
-		return c.processErrorResponse(q, response, RQLRuntimeError{rqlResponseError{response, q.Term}})
+		return c.processErrorResponse(q, response, createRuntimeError(response.ErrorType, response, q.Term))
 	case p.Response_SUCCESS_ATOM, p.Response_SERVER_INFO:
 		return c.processAtomResponse(q, response)
 	case p.Response_SUCCESS_PARTIAL:
@@ -269,7 +270,7 @@ func (c *Connection) processResponse(q Query, response *Response) (*Response, *C
 		return c.processWaitResponse(q, response)
 	default:
 		putResponse(response)
-		return nil, nil, RQLDriverError{"Unexpected response type"}
+		return nil, nil, RQLDriverError{rqlError("Unexpected response type")}
 	}
 }
 

Diff for: connection_helper.go

@@ -14,7 +14,7 @@ import (
 func (c *Connection) writeData(data []byte) error {
 	_, err := c.Conn.Write(data[:])
 	if err != nil {
-		return RQLConnectionError{err.Error()}
+		return RQLConnectionError{rqlError(err.Error())}
 	}
 
 	return nil
@@ -52,14 +52,14 @@ func (c *Connection) readHandshakeSuccess() error {
 		if err == io.EOF {
 			return fmt.Errorf("Unexpected EOF: %s", string(line))
 		}
-		return RQLConnectionError{err.Error()}
+		return RQLConnectionError{rqlError(err.Error())}
 	}
 	// convert to string and remove trailing NUL byte
 	response := string(line[:len(line)-1])
 	if response != "SUCCESS" {
 		response = strings.TrimSpace(response)
 		// we failed authorization or something else terrible happened
-		return RQLDriverError{fmt.Sprintf("Server dropped connection with message: \"%s\"", response)}
+		return RQLDriverError{rqlError(fmt.Sprintf("Server dropped connection with message: \"%s\"", response))}
 	}
 
 	return nil

Diff for: cursor.go

@@ -26,6 +26,8 @@ func newCursor(conn *Connection, cursorType string, token int64, term *Term, opt
 		cursorType: cursorType,
 		term:       term,
 		opts:       opts,
+		buffer:     make([]interface{}, 0),
+		responses:  make([]json.RawMessage, 0),
 	}
 
 	return cursor
@@ -61,8 +63,8 @@ type Cursor struct {
 	closed    bool
 	finished  bool
 	isAtom    bool
-	buffer    queue
-	responses queue
+	buffer    []interface{}
+	responses []json.RawMessage
 	profile   interface{}
 }
 
@@ -136,8 +138,8 @@ func (c *Cursor) Close() error {
 
 	c.closed = true
 	c.conn = nil
-	c.buffer.elems = nil
-	c.responses.elems = nil
+	c.buffer = nil
+	c.responses = nil
 
 	return err
 }
@@ -183,11 +185,11 @@ func (c *Cursor) loadNextLocked(dest interface{}) (bool, error) {
 		}
 
 		// Check if response is closed/finished
-		if c.buffer.Len() == 0 && c.responses.Len() == 0 && c.closed {
+		if len(c.buffer) == 0 && len(c.responses) == 0 && c.closed {
 			return false, errCursorClosed
 		}
 
-		if c.buffer.Len() == 0 && c.responses.Len() == 0 && !c.finished {
+		if len(c.buffer) == 0 && len(c.responses) == 0 && !c.finished {
 			c.mu.Unlock()
 			err := c.fetchMore()
 			c.mu.Lock()
@@ -196,42 +198,44 @@ func (c *Cursor) loadNextLocked(dest interface{}) (bool, error) {
 			}
 		}
 
-		if c.buffer.Len() == 0 && c.responses.Len() == 0 && c.finished {
+		if len(c.buffer) == 0 && len(c.responses) == 0 && c.finished {
 			return false, nil
 		}
 
-		if c.buffer.Len() == 0 && c.responses.Len() > 0 {
-			if response, ok := c.responses.Pop().(json.RawMessage); ok {
-				var value interface{}
-				decoder := json.NewDecoder(bytes.NewBuffer(response))
-				if c.conn.opts.UseJSONNumber {
-					decoder.UseNumber()
-				}
-				err := decoder.Decode(&value)
-				if err != nil {
-					return false, err
-				}
+		if len(c.buffer) == 0 && len(c.responses) > 0 {
+			var response json.RawMessage
+			response, c.responses = c.responses[0], c.responses[1:]
 
-				value, err = recursivelyConvertPseudotype(value, c.opts)
-				if err != nil {
-					return false, err
-				}
+			var value interface{}
+			decoder := json.NewDecoder(bytes.NewBuffer(response))
+			if c.conn.opts.UseJSONNumber {
+				decoder.UseNumber()
+			}
+			err := decoder.Decode(&value)
+			if err != nil {
+				return false, err
+			}
 
-				// If response is an ATOM then try and convert to an array
-				if data, ok := value.([]interface{}); ok && c.isAtom {
-					for _, v := range data {
-						c.buffer.Push(v)
-					}
-				} else if value == nil {
-					c.buffer.Push(nil)
-				} else {
-					c.buffer.Push(value)
+			value, err = recursivelyConvertPseudotype(value, c.opts)
+			if err != nil {
+				return false, err
+			}
+
+			// If response is an ATOM then try and convert to an array
+			if data, ok := value.([]interface{}); ok && c.isAtom {
+				for _, v := range data {
+					c.buffer = append(c.buffer, v)
 				}
+			} else if value == nil {
+				c.buffer = append(c.buffer, nil)
+			} else {
+				c.buffer = append(c.buffer, value)
 			}
 		}
 
-		if c.buffer.Len() > 0 {
-			data := c.buffer.Pop()
+		if len(c.buffer) > 0 {
+			var data interface{}
+			data, c.buffer = c.buffer[0], c.buffer[1:]
 
 			err := encoding.Decode(dest, data)
 			if err != nil {
@@ -362,25 +366,23 @@ func (c *Cursor) IsNil() bool {
 	c.mu.RLock()
 	defer c.mu.RUnlock()
 
-	if c.buffer.Len() > 0 {
-		bufferedItem := c.buffer.Peek()
+	if len(c.buffer) > 0 {
+		bufferedItem := c.buffer[0]
 		if bufferedItem == nil {
 			return true
 		}
 
 		return false
 	}
 
-	if c.responses.Len() > 0 {
-		response := c.responses.Peek()
+	if len(c.responses) > 0 {
+		response := c.responses[0]
 		if response == nil {
 			return true
 		}
 
-		if response, ok := response.(json.RawMessage); ok {
-			if string(response) == "null" {
-				return true
-			}
+		if string(response) == "null" {
+			return true
 		}
 
 		return false
@@ -447,7 +449,7 @@ func (c *Cursor) extend(response *Response) {
 
 func (c *Cursor) extendLocked(response *Response) {
 	for _, response := range response.Responses {
-		c.responses.Push(response)
+		c.responses = append(c.responses, response)
 	}
 
 	c.finished = response.Type != p.Response_SUCCESS_PARTIAL
@@ -456,67 +458,3 @@ func (c *Cursor) extendLocked(response *Response) {
 
 	putResponse(response)
 }
-
-// Queue structure used for storing responses
-
-type queue struct {
-	elems               []interface{}
-	nelems, popi, pushi int
-}
-
-func (q *queue) Len() int {
-	if len(q.elems) == 0 {
-		return 0
-	}
-
-	return q.nelems
-}
-func (q *queue) Push(elem interface{}) {
-	if q.nelems == len(q.elems) {
-		q.expand()
-	}
-	q.elems[q.pushi] = elem
-	q.nelems++
-	q.pushi = (q.pushi + 1) % len(q.elems)
-}
-func (q *queue) Pop() (elem interface{}) {
-	if q.nelems == 0 {
-		return nil
-	}
-	elem = q.elems[q.popi]
-	q.elems[q.popi] = nil // Help GC.
-	q.nelems--
-	q.popi = (q.popi + 1) % len(q.elems)
-	return elem
-}
-func (q *queue) Peek() (elem interface{}) {
-	if q.nelems == 0 {
-		return nil
-	}
-	return q.elems[q.popi]
-}
-func (q *queue) expand() {
-	curcap := len(q.elems)
-	var newcap int
-	if curcap == 0 {
-		newcap = 8
-	} else if curcap < 1024 {
-		newcap = curcap * 2
-	} else {
-		newcap = curcap + (curcap / 4)
-	}
-	elems := make([]interface{}, newcap)
-	if q.popi == 0 {
-		copy(elems, q.elems)
-		q.pushi = curcap
-	} else {
-		newpopi := newcap - (curcap - q.popi)
-		copy(elems, q.elems[:q.popi])
-		copy(elems[newpopi:], q.elems[q.popi:])
-		q.popi = newpopi
-	}
-	for i := range q.elems {
-		q.elems[i] = nil // Help GC.
-	}
-	q.elems = elems
-}

Diff for: doc.go

@@ -1,6 +1,6 @@
 // Package gorethink implements a Go driver for RethinkDB
 //
-// Current version: v1.2.0 (RethinkDB v2.2)
+// Current version: v1.3.0 (RethinkDB v2.2)
 // For more in depth information on how to use RethinkDB check out the API docs
 // at http://rethinkdb.com/api
 package gorethink