api: change Response type to interface

This commit creates a new `Response` interface.
But still, only one `Response` implementation exists:
`ConnResponse`. Custom responses (including mocks)
are expected to implement this interface.

Create a `Response` interface and its implementation
`ConnResponse`.

For the `Future` method `Get` now returns response data.
To get the actual response new method `GetResponse` is added.

`IsPush()` method is added to the response iterator. It returns
the information if the current response is a `Push`.
Right now it does not have a lot of usage, but it will be
crucial once we create a separate response for pushes.

Part of #237

Author: DerekBum

CHANGELOG.md

@@ -28,6 +28,8 @@ Versioning](http://semver.org/spec/v2.0.0.html) except to the first release.
   in requests instead of their IDs.
 - `GetSchema` function to get the actual schema (#7)
 - Support connection via an existing socket fd (#321)
+- `Header` struct for the response header (#237). It can be accessed via
+  `Header()` method of the `Response` interface.
 
 ### Changed
 
@@ -67,6 +69,12 @@ Versioning](http://semver.org/spec/v2.0.0.html) except to the first release.
   it (#321)
 - Rename `pool.GetPoolInfo` to `pool.GetInfo`. Change return type to
   `map[string]ConnectionInfo` (#321)
+- All responses are now implementations of an `Response` interface (#237)
+- `IsPush()` method is added to the response iterator (#237). It returns
+  the information if the current response is a `PushResponse`.
+  `PushCode` constant is removed.
+- Method `Get` for `Future` now returns response data (#237). To get the actual 
+  response new method added `GetResponse`.
 
 ### Deprecated
 

README.md

@@ -128,12 +128,13 @@ func main() {
 	if err != nil {
 		fmt.Println("Connection refused:", err)
 	}
-	resp, err := conn.Do(tarantool.NewInsertRequest(999).
+	data, err := conn.Do(tarantool.NewInsertRequest(999).
 		Tuple([]interface{}{99999, "BB"}),
 	).Get()
 	if err != nil {
 		fmt.Println("Error", err)
-		fmt.Println("Code", resp.Code)
+	} else {
+		fmt.Printf("Data: %v", data)
 	}
 }
 ```
@@ -241,7 +242,10 @@ of the requests is an array instead of array of arrays.
 
 #### IPROTO constants
 
-IPROTO constants have been moved to a separate package [go-iproto](https://github.com/tarantool/go-iproto).
+* IPROTO constants have been moved to a separate package [go-iproto](https://github.com/tarantool/go-iproto).
+* `PushCode` constant is removed. To get information, if the current response is
+  a push response, new `IsPush()` method of the response iterator could be used
+  instead.
 
 #### Request changes
 
@@ -255,6 +259,19 @@ needs to be passed instead.
 * `UpdateRequest` and `UpsertRequest` structs no longer accept `interface{}`
 for an `ops` field. `*Operations` needs to be used instead.
 
+#### Response changes
+
+* New interface `Response` added.
+* Response header stored in a new `Header` struct. It could be accessed via
+  `Header()` method.
+* Method `IsPush()` is added to the `ResponseIterator` interface.
+  It returns true if the current response is a push response.
+
+#### Future changes
+
+* Method `Get` now returns response data instead of the actual response.
+* New method `GetResponse` added to get an actual response.
+
 #### Connect function
 
 `connection.Connect` no longer return non-working connection objects. This function

box_error_test.go

@@ -306,9 +306,11 @@ func TestErrorTypeEval(t *testing.T) {
 		t.Run(name, func(t *testing.T) {
 			resp, err := conn.Eval("return ...", []interface{}{&testcase.tuple.val})
 			require.Nil(t, err)
-			require.NotNil(t, resp.Data)
-			require.Equal(t, len(resp.Data), 1)
-			actual, ok := resp.Data[0].(*BoxError)
+			data, err := resp.Decode()
+			require.Nil(t, err)
+			require.NotNil(t, data)
+			require.Equal(t, len(data), 1)
+			actual, ok := data[0].(*BoxError)
 			require.Truef(t, ok, "Response data has valid type")
 			require.Equal(t, testcase.tuple.val, *actual)
 		})
@@ -436,15 +438,17 @@ func TestErrorTypeSelect(t *testing.T) {
 			_, err := conn.Eval(insertEval, []interface{}{})
 			require.Nilf(t, err, "Tuple has been successfully inserted")
 
-			var resp *Response
+			var resp Response
 			var offset uint32 = 0
 			var limit uint32 = 1
 			resp, err = conn.Select(space, index, offset, limit, IterEq,
 				[]interface{}{testcase.tuple.pk})
 			require.Nil(t, err)
-			require.NotNil(t, resp.Data)
-			require.Equalf(t, len(resp.Data), 1, "Exactly one tuple had been found")
-			tpl, ok := resp.Data[0].([]interface{})
+			data, err := resp.Decode()
+			require.Nil(t, err)
+			require.NotNil(t, data)
+			require.Equalf(t, len(data), 1, "Exactly one tuple had been found")
+			tpl, ok := data[0].([]interface{})
 			require.Truef(t, ok, "Tuple has valid type")
 			require.Equal(t, testcase.tuple.pk, tpl[0])
 			actual, ok := tpl[1].(*BoxError)

connection.go

@@ -97,9 +97,9 @@ func (d defaultLogger) Report(event ConnLogKind, conn *Connection, v ...interfac
 		log.Printf("tarantool: last reconnect to %s failed: %s, giving it up",
 			conn.Addr(), err)
 	case LogUnexpectedResultId:
-		resp := v[0].(*Response)
+		header := v[0].(Header)
 		log.Printf("tarantool: connection %s got unexpected resultId (%d) in response",
-			conn.Addr(), resp.RequestId)
+			conn.Addr(), header.RequestId)
 	case LogWatchEventReadFailed:
 		err := v[0].(error)
 		log.Printf("tarantool: unable to parse watch event: %s", err)
@@ -807,8 +807,8 @@ func (conn *Connection) reader(r io.Reader, c Conn) {
 			conn.reconnect(err, c)
 			return
 		}
-		resp := &Response{buf: smallBuf{b: respBytes}}
-		err = resp.decodeHeader(conn.dec)
+		buf := smallBuf{b: respBytes}
+		header, err := decodeHeader(conn.dec, &buf)
 		if err != nil {
 			err = ClientError{
 				ErrProtocolError,
@@ -818,8 +818,9 @@ func (conn *Connection) reader(r io.Reader, c Conn) {
 			return
 		}
 
+		resp := &ConnResponse{header: header, buf: buf}
 		var fut *Future = nil
-		if iproto.Type(resp.Code) == iproto.IPROTO_EVENT {
+		if iproto.Type(header.Code) == iproto.IPROTO_EVENT {
 			if event, err := readWatchEvent(&resp.buf); err == nil {
 				events <- event
 			} else {
@@ -830,19 +831,19 @@ func (conn *Connection) reader(r io.Reader, c Conn) {
 				conn.opts.Logger.Report(LogWatchEventReadFailed, conn, err)
 			}
 			continue
-		} else if resp.Code == PushCode {
-			if fut = conn.peekFuture(resp.RequestId); fut != nil {
+		} else if header.Code == uint32(iproto.IPROTO_CHUNK) {
+			if fut = conn.peekFuture(header.RequestId); fut != nil {
 				fut.AppendPush(resp)
 			}
 		} else {
-			if fut = conn.fetchFuture(resp.RequestId); fut != nil {
+			if fut = conn.fetchFuture(header.RequestId); fut != nil {
 				fut.SetResponse(resp)
 				conn.markDone(fut)
 			}
 		}
 
 		if fut == nil {
-			conn.opts.Logger.Report(LogUnexpectedResultId, conn, resp)
+			conn.opts.Logger.Report(LogUnexpectedResultId, conn, header)
 		}
 	}
 }
@@ -1052,10 +1053,7 @@ func (conn *Connection) putFuture(fut *Future, req Request, streamId uint64) {
 
 	if req.Async() {
 		if fut = conn.fetchFuture(reqid); fut != nil {
-			resp := &Response{
-				RequestId: reqid,
-				Code:      OkCode,
-			}
+			resp := &ConnResponse{}
 			fut.SetResponse(resp)
 			conn.markDone(fut)
 		}
@@ -1236,7 +1234,7 @@ func (conn *Connection) SetSchema(s Schema) {
 // NewPrepared passes a sql statement to Tarantool for preparation synchronously.
 func (conn *Connection) NewPrepared(expr string) (*Prepared, error) {
 	req := NewPrepareRequest(expr)
-	resp, err := conn.Do(req).Get()
+	resp, err := conn.Do(req).GetResponse()
 	if err != nil {
 		return nil, err
 	}

connector.go

@@ -13,41 +13,41 @@ type Connector interface {
 
 	// Deprecated: the method will be removed in the next major version,
 	// use a PingRequest object + Do() instead.
-	Ping() (*Response, error)
+	Ping() (Response, error)
 	// Deprecated: the method will be removed in the next major version,
 	// use a SelectRequest object + Do() instead.
 	Select(space, index interface{}, offset, limit uint32, iterator Iter,
-		key interface{}) (*Response, error)
+		key interface{}) (Response, error)
 	// Deprecated: the method will be removed in the next major version,
 	// use an InsertRequest object + Do() instead.
-	Insert(space interface{}, tuple interface{}) (*Response, error)
+	Insert(space interface{}, tuple interface{}) (Response, error)
 	// Deprecated: the method will be removed in the next major version,
 	// use a ReplicaRequest object + Do() instead.
-	Replace(space interface{}, tuple interface{}) (*Response, error)
+	Replace(space interface{}, tuple interface{}) (Response, error)
 	// Deprecated: the method will be removed in the next major version,
 	// use a DeleteRequest object + Do() instead.
-	Delete(space, index interface{}, key interface{}) (*Response, error)
+	Delete(space, index interface{}, key interface{}) (Response, error)
 	// Deprecated: the method will be removed in the next major version,
 	// use a UpdateRequest object + Do() instead.
-	Update(space, index interface{}, key interface{}, ops *Operations) (*Response, error)
+	Update(space, index interface{}, key interface{}, ops *Operations) (Response, error)
 	// Deprecated: the method will be removed in the next major version,
 	// use a UpsertRequest object + Do() instead.
-	Upsert(space interface{}, tuple interface{}, ops *Operations) (*Response, error)
+	Upsert(space interface{}, tuple interface{}, ops *Operations) (Response, error)
 	// Deprecated: the method will be removed in the next major version,
 	// use a CallRequest object + Do() instead.
-	Call(functionName string, args interface{}) (*Response, error)
+	Call(functionName string, args interface{}) (Response, error)
 	// Deprecated: the method will be removed in the next major version,
 	// use a Call16Request object + Do() instead.
-	Call16(functionName string, args interface{}) (*Response, error)
+	Call16(functionName string, args interface{}) (Response, error)
 	// Deprecated: the method will be removed in the next major version,
 	// use a Call17Request object + Do() instead.
-	Call17(functionName string, args interface{}) (*Response, error)
+	Call17(functionName string, args interface{}) (Response, error)
 	// Deprecated: the method will be removed in the next major version,
 	// use an EvalRequest object + Do() instead.
-	Eval(expr string, args interface{}) (*Response, error)
+	Eval(expr string, args interface{}) (Response, error)
 	// Deprecated: the method will be removed in the next major version,
 	// use an ExecuteRequest object + Do() instead.
-	Execute(expr string, args interface{}) (*Response, error)
+	Execute(expr string, args interface{}) (Response, error)
 
 	// Deprecated: the method will be removed in the next major version,
 	// use a SelectRequest object + Do() instead.

const.go

@@ -9,6 +9,5 @@ const (
 )
 
 const (
-	OkCode   = uint32(iproto.IPROTO_OK)
-	PushCode = uint32(iproto.IPROTO_CHUNK)
+	OkCode = uint32(iproto.IPROTO_OK)
 )

crud/tarantool_test.go

@@ -517,39 +517,32 @@ func testSelectGeneratedData(t *testing.T, conn tarantool.Connector,
 		Limit(20).
 		Iterator(tarantool.IterGe).
 		Key([]interface{}{uint(1010)})
-	resp, err := conn.Do(req).Get()
+	data, err := conn.Do(req).Get()
 	if err != nil {
 		t.Fatalf("Failed to Select: %s", err.Error())
 	}
-	if resp == nil {
-		t.Fatalf("Response is nil after Select")
-	}
-	if len(resp.Data) != expectedTuplesCount {
-		t.Fatalf("Response Data len %d != %d", len(resp.Data), expectedTuplesCount)
+	if len(data) != expectedTuplesCount {
+		t.Fatalf("Response Data len %d != %d", len(data), expectedTuplesCount)
 	}
 }
 
 func testCrudRequestCheck(t *testing.T, req tarantool.Request,
-	resp *tarantool.Response, err error, expectedLen int) {
+	data []interface{}, err error, expectedLen int) {
 	t.Helper()
 
 	if err != nil {
 		t.Fatalf("Failed to Do CRUD request: %s", err.Error())
 	}
 
-	if resp == nil {
-		t.Fatalf("Response is nil after Do CRUD request")
-	}
-
-	if len(resp.Data) < expectedLen {
+	if len(data) < expectedLen {
 		t.Fatalf("Response Body len < %#v, actual len %#v",
-			expectedLen, len(resp.Data))
+			expectedLen, len(data))
 	}
 
 	// resp.Data[0] - CRUD res.
 	// resp.Data[1] - CRUD err.
-	if expectedLen >= 2 && resp.Data[1] != nil {
-		if crudErr, err := getCrudError(req, resp.Data[1]); err != nil {
+	if expectedLen >= 2 && data[1] != nil {
+		if crudErr, err := getCrudError(req, data[1]); err != nil {
 			t.Fatalf("Failed to get CRUD error: %#v", err)
 		} else if crudErr != nil {
 			t.Fatalf("Failed to perform CRUD request on CRUD side: %#v", crudErr)
@@ -569,8 +562,8 @@ func TestCrudGenerateData(t *testing.T) {
 				conn.Do(req).Get()
 			}
 
-			resp, err := conn.Do(testCase.req).Get()
-			testCrudRequestCheck(t, testCase.req, resp,
+			data, err := conn.Do(testCase.req).Get()
+			testCrudRequestCheck(t, testCase.req, data,
 				err, testCase.expectedRespLen)
 
 			testSelectGeneratedData(t, conn, testCase.expectedTuplesCount)
@@ -591,8 +584,8 @@ func TestCrudProcessData(t *testing.T) {
 	for _, testCase := range testProcessDataCases {
 		t.Run(testCase.name, func(t *testing.T) {
 			testCrudRequestPrepareData(t, conn)
-			resp, err := conn.Do(testCase.req).Get()
-			testCrudRequestCheck(t, testCase.req, resp,
+			data, err := conn.Do(testCase.req).Get()
+			testCrudRequestCheck(t, testCase.req, data,
 				err, testCase.expectedRespLen)
 			for i := 1010; i < 1020; i++ {
 				req := tarantool.NewDeleteRequest(spaceName).
@@ -623,8 +616,8 @@ func TestCrudUpdateSplice(t *testing.T) {
 		Opts(simpleOperationOpts)
 
 	testCrudRequestPrepareData(t, conn)
-	resp, err := conn.Do(req).Get()
-	testCrudRequestCheck(t, req, resp,
+	data, err := conn.Do(req).Get()
+	testCrudRequestCheck(t, req, data,
 		err, 2)
 }
 
@@ -648,8 +641,8 @@ func TestCrudUpsertSplice(t *testing.T) {
 		Opts(simpleOperationOpts)
 
 	testCrudRequestPrepareData(t, conn)
-	resp, err := conn.Do(req).Get()
-	testCrudRequestCheck(t, req, resp,
+	data, err := conn.Do(req).Get()
+	testCrudRequestCheck(t, req, data,
 		err, 2)
 }
 
@@ -673,8 +666,8 @@ func TestCrudUpsertObjectSplice(t *testing.T) {
 		Opts(simpleOperationOpts)
 
 	testCrudRequestPrepareData(t, conn)
-	resp, err := conn.Do(req).Get()
-	testCrudRequestCheck(t, req, resp,
+	data, err := conn.Do(req).Get()
+	testCrudRequestCheck(t, req, data,
 		err, 2)
 }
 
@@ -719,11 +712,11 @@ func TestUnflattenRows(t *testing.T) {
 	req := crud.MakeReplaceRequest(spaceName).
 		Tuple(tuple).
 		Opts(simpleOperationOpts)
-	resp, err := conn.Do(req).Get()
-	testCrudRequestCheck(t, req, resp, err, 2)
+	data, err := conn.Do(req).Get()
+	testCrudRequestCheck(t, req, data, err, 2)
 
-	if res, ok = resp.Data[0].(map[interface{}]interface{}); !ok {
-		t.Fatalf("Unexpected CRUD result: %#v", resp.Data[0])
+	if res, ok = data[0].(map[interface{}]interface{}); !ok {
+		t.Fatalf("Unexpected CRUD result: %#v", data[0])
 	}
 
 	if rawMetadata, ok := res["metadata"]; !ok {
@@ -1293,21 +1286,21 @@ func TestNoreturnOption(t *testing.T) {
 				conn.Do(req).Get()
 			}
 
-			resp, err := conn.Do(testCase.req).Get()
+			data, err := conn.Do(testCase.req).Get()
 			if err != nil {
 				t.Fatalf("Failed to Do CRUD request: %s", err)
 			}
 
-			if len(resp.Data) == 0 {
+			if len(data) == 0 {
 				t.Fatalf("Expected explicit nil")
 			}
 
-			if resp.Data[0] != nil {
-				t.Fatalf("Expected nil result, got %v", resp.Data[0])
+			if data[0] != nil {
+				t.Fatalf("Expected nil result, got %v", data[0])
 			}
 
-			if len(resp.Data) >= 2 && resp.Data[1] != nil {
-				t.Fatalf("Expected no returned errors, got %v", resp.Data[1])
+			if len(data) >= 2 && data[1] != nil {
+				t.Fatalf("Expected no returned errors, got %v", data[1])
 			}
 
 			for i := 1010; i < 1020; i++ {