api: support errors extended information

Since Tarantool 2.4.1, iproto error responses contain extended info with
backtrace [1]. After this patch, Error would contain ExtendedInfo field
(BoxError object), if it was provided. Error() handle now will print
extended info, if possible.

1. https://www.tarantool.io/en/doc/latest/dev_guide/internals/box_protocol/#responses-for-errors

Part of #209

Author: DifferentialOrange

CHANGELOG.md

@@ -11,6 +11,7 @@ Versioning](http://semver.org/spec/v2.0.0.html) except to the first release.
 ### Added
 
 - Support iproto feature discovery (#120).
+- Support errors extended information (#209).
 
 ### Changed
 

box_error.go

@@ -0,0 +1,180 @@
+package tarantool
+
+import (
+	"bytes"
+	"fmt"
+)
+
+// BoxError is a type representing Tarantool `box.error` object: a single
+// MP_ERROR_STACK object with a link to the previous stack error.
+// See https://www.tarantool.io/en/doc/latest/reference/reference_lua/box_error/error/
+//
+// Since 1.10.0
+type BoxError struct {
+	// Type is error type that implies its source (for example, "ClientError").
+	Type string
+	// File is a source code file where the error was caught.
+	File string
+	// Line is a number of line in the source code file where the error was caught.
+	Line uint64
+	// Msg is the text of reason.
+	Msg string
+	// Errno is the ordinal number of the error.
+	Errno uint64
+	// Code is the number of the error as defined in `errcode.h`.
+	Code uint64
+	// Fields are additional fields depending on error type. For example, if
+	// type is "AccessDeniedError", then it will include "object_type",
+	// "object_name", "access_type".
+	Fields map[string]interface{}
+	// Prev is the previous error in stack.
+	Prev *BoxError
+}
+
+// Error converts a BoxError to a string.
+func (e *BoxError) Error() string {
+	s := fmt.Sprintf("%s (%s, code 0x%x), see %s line %d",
+		e.Msg, e.Type, e.Code, e.File, e.Line)
+
+	if e.Prev != nil {
+		return fmt.Sprintf("%s: %s", s, e.Prev)
+	}
+
+	return s
+}
+
+// Depth computes the count of errors in stack, including the current one.
+func (e *BoxError) Depth() int {
+	depth := int(0)
+
+	cur := e
+	for cur != nil {
+		cur = cur.Prev
+		depth++
+	}
+
+	return depth
+}
+
+func decodeBoxError(d *decoder) (*BoxError, error) {
+	var l, larr, l1, l2 int
+	var errorStack []BoxError
+	var err error
+
+	if l, err = d.DecodeMapLen(); err != nil {
+		return nil, err
+	}
+
+	for ; l > 0; l-- {
+		var cd int
+		if cd, err = d.DecodeInt(); err != nil {
+			return nil, err
+		}
+		switch cd {
+		case KeyErrorStack:
+			if larr, err = d.DecodeArrayLen(); err != nil {
+				return nil, err
+			}
+
+			errorStack = make([]BoxError, larr)
+
+			for i := 0; i < larr; i++ {
+				if l1, err = d.DecodeMapLen(); err != nil {
+					return nil, err
+				}
+
+				for ; l1 > 0; l1-- {
+					var cd1 int
+					if cd1, err = d.DecodeInt(); err != nil {
+						return nil, err
+					}
+					switch cd1 {
+					case KeyErrorType:
+						if errorStack[i].Type, err = d.DecodeString(); err != nil {
+							return nil, err
+						}
+					case KeyErrorFile:
+						if errorStack[i].File, err = d.DecodeString(); err != nil {
+							return nil, err
+						}
+					case KeyErrorLine:
+						if errorStack[i].Line, err = d.DecodeUint64(); err != nil {
+							return nil, err
+						}
+					case KeyErrorMessage:
+						if errorStack[i].Msg, err = d.DecodeString(); err != nil {
+							return nil, err
+						}
+					case KeyErrorErrno:
+						if errorStack[i].Errno, err = d.DecodeUint64(); err != nil {
+							return nil, err
+						}
+					case KeyErrorErrcode:
+						if errorStack[i].Code, err = d.DecodeUint64(); err != nil {
+							return nil, err
+						}
+					case KeyErrorFields:
+						var mapk string
+						var mapv interface{}
+
+						errorStack[i].Fields = make(map[string]interface{})
+
+						if l2, err = d.DecodeMapLen(); err != nil {
+							return nil, err
+						}
+						for ; l2 > 0; l2-- {
+							if mapk, err = d.DecodeString(); err != nil {
+								return nil, err
+							}
+							if mapv, err = d.DecodeInterface(); err != nil {
+								return nil, err
+							}
+							errorStack[i].Fields[mapk] = mapv
+						}
+					default:
+						if err = d.Skip(); err != nil {
+							return nil, err
+						}
+					}
+				}
+
+				if i > 0 {
+					errorStack[i-1].Prev = &errorStack[i]
+				}
+			}
+		default:
+			if err = d.Skip(); err != nil {
+				return nil, err
+			}
+		}
+	}
+
+	if len(errorStack) > 0 {
+		return &errorStack[0], nil
+	}
+
+	return nil, nil
+}
+
+// UnmarshalMsgpack deserializes a BoxError value from a MessagePack
+// representation.
+func (e *BoxError) UnmarshalMsgpack(b []byte) error {
+	var val *BoxError
+	var err error
+
+	buf := bytes.NewBuffer(b)
+	dec := newDecoder(buf)
+
+	if val, err = decodeBoxError(dec); err != nil {
+		return err
+	}
+
+	if val != nil {
+		if e == nil {
+			e = &BoxError{}
+		}
+		*e = *val
+	}
+
+	return nil
+}

box_error_test.go

@@ -0,0 +1,193 @@
+package tarantool_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	. "github.com/tarantool/go-tarantool"
+)
+
+var samples = map[string]BoxError{
+	"SimpleError": {
+		Type:  "ClientError",
+		File:  "config.lua",
+		Line:  uint64(202),
+		Msg:   "Unknown error",
+		Errno: uint64(0),
+		Code:  uint64(0),
+	},
+	"AccessDeniedError": {
+		Type:  "AccessDeniedError",
+		File:  "/__w/sdk/sdk/tarantool-2.10/tarantool/src/box/func.c",
+		Line:  uint64(535),
+		Msg:   "Execute access to function 'forbidden_function' is denied for user 'no_grants'",
+		Errno: uint64(0),
+		Code:  uint64(42),
+		Fields: map[string]interface{}{
+			"object_type": "function",
+			"object_name": "forbidden_function",
+			"access_type": "Execute",
+		},
+	},
+	"ChainedError": {
+		Type:  "ClientError",
+		File:  "config.lua",
+		Line:  uint64(205),
+		Msg:   "Timeout exceeded",
+		Errno: uint64(0),
+		Code:  uint64(78),
+		Prev: &BoxError{
+			Type:  "ClientError",
+			File:  "config.lua",
+			Line:  uint64(202),
+			Msg:   "Unknown error",
+			Errno: uint64(0),
+			Code:  uint64(0),
+		},
+	},
+}
+
+var stringCases = map[string]struct {
+	e BoxError
+	s string
+}{
+	"SimpleError": {
+		samples["SimpleError"],
+		"Unknown error (ClientError, code 0x0), see config.lua line 202",
+	},
+	"AccessDeniedError": {
+		samples["AccessDeniedError"],
+		"Execute access to function 'forbidden_function' is denied for user " +
+			"'no_grants' (AccessDeniedError, code 0x2a), see " +
+			"/__w/sdk/sdk/tarantool-2.10/tarantool/src/box/func.c line 535",
+	},
+	"ChainedError": {
+		samples["ChainedError"],
+		"Timeout exceeded (ClientError, code 0x4e), see config.lua line 205: " +
+			"Unknown error (ClientError, code 0x0), see config.lua line 202",
+	},
+}
+
+func TestBoxErrorStringRepr(t *testing.T) {
+	for name, testcase := range stringCases {
+		t.Run(name, func(t *testing.T) {
+			require.Equal(t, testcase.s, testcase.e.Error())
+		})
+	}
+}
+
+var mpDecodeSamples = map[string]struct {
+	b   []byte
+	ok  bool
+	err string
+}{
+	"OuterMapInvalidLen": {
+		[]byte{0xc1},
+		false,
+		"msgpack: invalid code c1 decoding map length",
+	},
+	"OuterMapInvalidKey": {
+		[]byte{0x81, 0xc1},
+		false,
+		"msgpack: invalid code c1 decoding int64",
+	},
+	"OuterMapExtraKey": {
+		[]byte{0x81, 0x11, 0x00},
+		true,
+		"",
+	},
+	"OuterMapExtraInvalidKey": {
+		[]byte{0x81, 0x11, 0x81},
+		false,
+		"EOF",
+	},
+	"ArrayInvalidLen": {
+		[]byte{0x81, 0x00, 0xc1},
+		false,
+		"msgpack: invalid code c1 decoding array length",
+	},
+	"ArrayZeroLen": {
+		[]byte{0x81, 0x00, 0x90},
+		true,
+		"",
+	},
+	"InnerMapInvalidLen": {
+		[]byte{0x81, 0x00, 0x91, 0xc1},
+		false,
+		"msgpack: invalid code c1 decoding map length",
+	},
+	"InnerMapInvalidKey": {
+		[]byte{0x81, 0x00, 0x91, 0x81, 0xc1},
+		false,
+		"msgpack: invalid code c1 decoding int64",
+	},
+	"InnerMapInvalidErrorType": {
+		[]byte{0x81, 0x00, 0x91, 0x81, 0x00, 0xc1},
+		false,
+		"msgpack: invalid code c1 decoding bytes length",
+	},
+	"InnerMapInvalidErrorFile": {
+		[]byte{0x81, 0x00, 0x91, 0x81, 0x01, 0xc1},
+		false,
+		"msgpack: invalid code c1 decoding bytes length",
+	},
+	"InnerMapInvalidErrorLine": {
+		[]byte{0x81, 0x00, 0x91, 0x81, 0x02, 0xc1},
+		false,
+		"msgpack: invalid code c1 decoding uint64",
+	},
+	"InnerMapInvalidErrorMessage": {
+		[]byte{0x81, 0x00, 0x91, 0x81, 0x03, 0xc1},
+		false,
+		"msgpack: invalid code c1 decoding bytes length",
+	},
+	"InnerMapInvalidErrorErrno": {
+		[]byte{0x81, 0x00, 0x91, 0x81, 0x04, 0xc1},
+		false,
+		"msgpack: invalid code c1 decoding uint64",
+	},
+	"InnerMapInvalidErrorErrcode": {
+		[]byte{0x81, 0x00, 0x91, 0x81, 0x05, 0xc1},
+		false,
+		"msgpack: invalid code c1 decoding uint64",
+	},
+	"InnerMapInvalidErrorFields": {
+		[]byte{0x81, 0x00, 0x91, 0x81, 0x06, 0xc1},
+		false,
+		"msgpack: invalid code c1 decoding map length",
+	},
+	"InnerMapInvalidErrorFieldsKey": {
+		[]byte{0x81, 0x00, 0x91, 0x81, 0x06, 0x81, 0xc1},
+		false,
+		"msgpack: invalid code c1 decoding bytes length",
+	},
+	"InnerMapInvalidErrorFieldsValue": {
+		[]byte{0x81, 0x00, 0x91, 0x81, 0x06, 0x81, 0xa3, 0x6b, 0x65, 0x79, 0xc1},
+		false,
+		"msgpack: unknown code c1 decoding interface{}",
+	},
+	"InnerMapExtraKey": {
+		[]byte{0x81, 0x00, 0x91, 0x81, 0x21, 0x00},
+		true,
+		"",
+	},
+	"InnerMapExtraInvalidKey": {
+		[]byte{0x81, 0x00, 0x91, 0x81, 0x21, 0x81},
+		false,
+		"EOF",
+	},
+}
+
+func TestMessagePackDecode(t *testing.T) {
+	for name, testcase := range mpDecodeSamples {
+		t.Run(name, func(t *testing.T) {
+			var val *BoxError
+			err := val.UnmarshalMsgpack(testcase.b)
+			if testcase.ok {
+				require.Nilf(t, err, "No errors on decode")
+			} else {
+				require.Equal(t, testcase.err, err.Error())
+			}
+		})
+	}
+}