Get proposal response payload from chaincode action (#206)

This is the correct chaincode transaction response payload location. The response payload field is intended to contain metadata but the peer currently copies the transaction response payload here for convenience. This causes failures due to gRPC message size limits for large response payloads and so may be removed in the future.

Also changed a few build scripts to honour the GO_CMD environment variable.

Signed-off-by: Mark S. Lewis <[email protected]>

Author: bestbeforetoday

pkg/client/channel/chclient_test.go

@@ -15,6 +15,8 @@ import (
 	"github.com/pkg/errors"
 	"github.com/stretchr/testify/assert"
 
+	"github.com/hyperledger/fabric-protos-go/common"
+	pb "github.com/hyperledger/fabric-protos-go/peer"
 	"github.com/hyperledger/fabric-sdk-go/pkg/client/channel/invoke"
 	txnmocks "github.com/hyperledger/fabric-sdk-go/pkg/client/common/mocks"
 	"github.com/hyperledger/fabric-sdk-go/pkg/client/common/selection/staticselection"
@@ -27,8 +29,6 @@ import (
 	"github.com/hyperledger/fabric-sdk-go/pkg/fab/peer"
 	"github.com/hyperledger/fabric-sdk-go/pkg/fab/txn"
 	mspmocks "github.com/hyperledger/fabric-sdk-go/pkg/msp/test/mockmsp"
-	"github.com/hyperledger/fabric-protos-go/common"
-	pb "github.com/hyperledger/fabric-protos-go/peer"
 )
 
 const (

pkg/client/channel/invoke/txnhandler.go

@@ -10,6 +10,7 @@ import (
 	"bytes"
 	"strings"
 
+	"github.com/golang/protobuf/proto"
 	"github.com/hyperledger/fabric-sdk-go/pkg/common/errors/status"
 	"github.com/hyperledger/fabric-sdk-go/pkg/common/options"
 	"github.com/pkg/errors"
@@ -63,7 +64,13 @@ func (e *EndorsementHandler) Handle(requestContext *RequestContext, clientContex
 
 	requestContext.Response.Responses = transactionProposalResponses
 	if len(transactionProposalResponses) > 0 {
-		requestContext.Response.Payload = transactionProposalResponses[0].ProposalResponse.GetResponse().Payload
+		responsePayload, err := getResultFromProposalResponse(transactionProposalResponses[0].ProposalResponse)
+		if err != nil {
+			requestContext.Error = err
+			return
+		}
+
+		requestContext.Response.Payload = responsePayload
 		requestContext.Response.ChaincodeStatus = transactionProposalResponses[0].ChaincodeStatus
 	}
 
@@ -73,6 +80,24 @@ func (e *EndorsementHandler) Handle(requestContext *RequestContext, clientContex
 	}
 }
 
+func getResultFromProposalResponse(proposalResponse *pb.ProposalResponse) ([]byte, error) {
+	responsePayload := &pb.ProposalResponsePayload{}
+	if err := proto.Unmarshal(proposalResponse.GetPayload(), responsePayload); err != nil {
+		return nil, errors.Wrap(err, "failed to deserialize proposal response payload")
+	}
+
+	return getResultFromProposalResponsePayload(responsePayload)
+}
+
+func getResultFromProposalResponsePayload(responsePayload *pb.ProposalResponsePayload) ([]byte, error) {
+	chaincodeAction := &pb.ChaincodeAction{}
+	if err := proto.Unmarshal(responsePayload.GetExtension(), chaincodeAction); err != nil {
+		return nil, errors.Wrap(err, "failed to deserialize chaincode action")
+	}
+
+	return chaincodeAction.GetResponse().GetPayload(), nil
+}
+
 //ProposalProcessorHandler for selecting proposal processors
 type ProposalProcessorHandler struct {
 	next Handler

pkg/client/channel/invoke/txnhandler_test.go

@@ -14,6 +14,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/golang/protobuf/proto"
 	pb "github.com/hyperledger/fabric-protos-go/peer"
 	"github.com/pkg/errors"
 	"github.com/stretchr/testify/assert"
@@ -162,47 +163,104 @@ func TestExecuteTxHandlerErrors(t *testing.T) {
 func TestEndorsementHandler(t *testing.T) {
 	request := Request{ChaincodeID: "test", Fcn: "invoke", Args: [][]byte{[]byte("move"), []byte("a"), []byte("b"), []byte("1")}}
 
-	clientContext := setupChannelClientContext(nil, nil, nil, t)
-	requestContext := prepareRequestContext(request, Opts{Targets: nil}, t)
+	t.Run("no targets, produces an error", func(t *testing.T) {
+		clientContext := setupChannelClientContext(nil, nil, nil, t)
+		requestContext := prepareRequestContext(request, Opts{Targets: nil}, t)
+		handler := NewEndorsementHandler()
 
-	handler := NewEndorsementHandler()
-	handler.Handle(requestContext, clientContext)
-	assert.NotNil(t, requestContext.Error)
+		handler.Handle(requestContext, clientContext)
 
-	requestContext = prepareRequestContext(request, Opts{Targets: []fab.Peer{fcmocks.NewMockPeer("p2", "")}}, t)
+		require.Error(t, requestContext.Error)
+	})
 
-	handler = NewEndorsementHandler()
-	handler.Handle(requestContext, clientContext)
-	assert.Nil(t, requestContext.Error)
+	t.Run("with a target, runs without error", func(t *testing.T) {
+		clientContext := setupChannelClientContext(nil, nil, nil, t)
+		requestContext := prepareRequestContext(request, Opts{Targets: []fab.Peer{fcmocks.NewMockPeer("p2", "")}}, t)
+		handler := NewEndorsementHandler()
 
-	optsProviderCalled := false
-	optsProvider := func() []fab.TxnHeaderOpt {
-		optsProviderCalled = true
-		var opts []fab.TxnHeaderOpt
-		opts = append(opts, fab.WithCreator([]byte("somecreator")))
-		opts = append(opts, fab.WithNonce([]byte("somenonce")))
-		return opts
-	}
+		handler.Handle(requestContext, clientContext)
 
-	handler = NewEndorsementHandlerWithOpts(nil, optsProvider)
-	handler.Handle(requestContext, clientContext)
-	assert.Nil(t, requestContext.Error)
-	assert.Truef(t, optsProviderCalled, "expecting opts provider to be called")
-
-	errExpected := fmt.Errorf("error in simulation: failed to distribute private collection, txID 695560b")
-	clientContext.Transactor.(*txnmocks.MockTransactor).Err = errExpected
-	handler.Handle(requestContext, clientContext)
-	s, ok := requestContext.Error.(*status.Status)
-	require.True(t, ok)
-	require.Equal(t, status.EndorserServerStatus, s.Group)
-	require.Equal(t, status.PvtDataDisseminationFailed.ToInt32(), s.Code)
-
-	errExpected = fmt.Errorf("error in simulation")
-	clientContext.Transactor.(*txnmocks.MockTransactor).Err = errExpected
-	handler.Handle(requestContext, clientContext)
-	s, ok = requestContext.Error.(*status.Status)
-	require.False(t, ok)
-	require.EqualError(t, requestContext.Error, errExpected.Error())
+		require.NoError(t, requestContext.Error)
+	})
+
+	t.Run("calls opts provider", func(t *testing.T) {
+		clientContext := setupChannelClientContext(nil, nil, nil, t)
+		requestContext := prepareRequestContext(request, Opts{Targets: []fab.Peer{fcmocks.NewMockPeer("p2", "")}}, t)
+		optsProviderCalled := false
+		optsProvider := func() []fab.TxnHeaderOpt {
+			optsProviderCalled = true
+			return []fab.TxnHeaderOpt{
+				fab.WithCreator([]byte("somecreator")),
+				fab.WithNonce([]byte("somenonce")),
+			}
+		}
+		handler := NewEndorsementHandlerWithOpts(nil, optsProvider)
+
+		handler.Handle(requestContext, clientContext)
+		require.NoError(t, requestContext.Error)
+
+		require.True(t, optsProviderCalled, "expecting opts provider to be called")
+	})
+
+	t.Run("returns EndorserServerStatus error from Transactor", func(t *testing.T) {
+		clientContext := setupChannelClientContext(nil, nil, nil, t)
+		requestContext := prepareRequestContext(request, Opts{Targets: []fab.Peer{fcmocks.NewMockPeer("p2", "")}}, t)
+		handler := NewEndorsementHandler()
+		clientContext.Transactor.(*txnmocks.MockTransactor).Err = fmt.Errorf("error in simulation: failed to distribute private collection, txID 695560b")
+
+		handler.Handle(requestContext, clientContext)
+
+		s, ok := requestContext.Error.(*status.Status)
+		require.True(t, ok)
+		require.Equal(t, status.EndorserServerStatus, s.Group)
+		require.Equal(t, status.PvtDataDisseminationFailed.ToInt32(), s.Code)
+	})
+
+	t.Run("returns error from simulation", func(t *testing.T) {
+		clientContext := setupChannelClientContext(nil, nil, nil, t)
+		errExpected := fmt.Errorf("error in simulation")
+		requestContext := prepareRequestContext(request, Opts{Targets: []fab.Peer{fcmocks.NewMockPeer("p2", "")}}, t)
+		handler := NewEndorsementHandler()
+		clientContext.Transactor.(*txnmocks.MockTransactor).Err = errExpected
+
+		handler.Handle(requestContext, clientContext)
+
+		_, ok := requestContext.Error.(*status.Status)
+		require.False(t, ok)
+		require.EqualError(t, requestContext.Error, errExpected.Error())
+	})
+
+	t.Run("returns error deserializing proposal response payload", func(t *testing.T) {
+		clientContext := setupChannelClientContext(nil, nil, nil, t)
+		mockPeer := fcmocks.NewMockPeer("p2", "")
+		mockPeer.ProposalResponsePayload = []byte("invalid serialized protobuf message")
+		requestContext := prepareRequestContext(request, Opts{Targets: []fab.Peer{mockPeer}}, t)
+		handler := NewEndorsementHandler()
+
+		handler.Handle(requestContext, clientContext)
+
+		require.Error(t, requestContext.Error)
+		require.Contains(t, requestContext.Error.Error(), "failed to deserialize proposal response payload")
+	})
+
+	t.Run("returns error deserializing chaincode action", func(t *testing.T) {
+		proposalResponsePayload := &pb.ProposalResponsePayload{
+			Extension: []byte("invalid serialized protobuf message"),
+		}
+		proposalResponsePayloadBytes, err := proto.Marshal(proposalResponsePayload)
+		require.NoError(t, err)
+
+		clientContext := setupChannelClientContext(nil, nil, nil, t)
+		mockPeer := fcmocks.NewMockPeer("p2", "")
+		mockPeer.ProposalResponsePayload = proposalResponsePayloadBytes
+		requestContext := prepareRequestContext(request, Opts{Targets: []fab.Peer{mockPeer}}, t)
+		handler := NewEndorsementHandler()
+
+		handler.Handle(requestContext, clientContext)
+
+		require.Error(t, requestContext.Error)
+		require.Contains(t, requestContext.Error.Error(), "failed to deserialize chaincode action")
+	})
 }
 
 // Target filter

pkg/fab/mocks/mockpeer.go

@@ -21,21 +21,22 @@ import (
 
 // MockPeer is a mock fabricsdk.Peer.
 type MockPeer struct {
-	RWLock               *sync.RWMutex
-	Error                error
-	MockName             string
-	MockURL              string
-	MockRoles            []string
-	MockCert             *pem.Block
-	Payload              []byte
-	ResponseMessage      string
-	MockMSP              string
-	Status               int32
-	ProcessProposalCalls int
-	Endorser             []byte
-	ChaincodeID          string
-	RwSets               []*rwsetutil.NsRwSet
-	properties           fab.Properties
+	RWLock                  *sync.RWMutex
+	Error                   error
+	MockName                string
+	MockURL                 string
+	MockRoles               []string
+	MockCert                *pem.Block
+	Payload                 []byte
+	ResponseMessage         string
+	ProposalResponsePayload []byte // Overrides proposal response payload generated from other values
+	MockMSP                 string
+	Status                  int32
+	ProcessProposalCalls    int
+	Endorser                []byte
+	ChaincodeID             string
+	RwSets                  []*rwsetutil.NsRwSet
+	properties              fab.Properties
 }
 
 // NewMockPeer creates basic mock peer
@@ -146,43 +147,61 @@ func (p *MockPeer) getProposalResponsePayload() []byte {
 		p.ChaincodeID = p.RwSets[0].NameSpace
 	}
 
-	var err error
-	var resultBytes []byte
-	if len(p.RwSets) > 0 {
-		txRWSet := &rwsetutil.TxRwSet{
-			NsRwSets: p.RwSets,
-		}
-		resultBytes, err = txRWSet.ToProtoBytes()
-		if err != nil {
-			panic(err)
-		}
+	if len(p.ProposalResponsePayload) > 0 {
+		return p.ProposalResponsePayload
 	}
 
-	var chaincodeActionBytes []byte
-	if p.ChaincodeID != "" {
-		chaincodeAction := &pb.ChaincodeAction{
-			ChaincodeId: &pb.ChaincodeID{Name: p.ChaincodeID},
-			Events:      nil,
-			Response: &pb.Response{
-				Message: p.ResponseMessage,
-				Status:  p.Status,
-				Payload: p.Payload,
-			},
-			Results: resultBytes,
-		}
-		chaincodeActionBytes, err = proto.Marshal(chaincodeAction)
-		if err != nil {
-			panic(err)
-		}
+	payload := p.newProposalResponsePayload()
+	payloadBytes, err := proto.Marshal(payload)
+	if err != nil {
+		panic(err)
+	}
+
+	return payloadBytes
+}
+
+func (p *MockPeer) newProposalResponsePayload() *pb.ProposalResponsePayload {
+	chaincodeAction := p.newChaincodeAction()
+	chaincodeActionBytes, err := proto.Marshal(chaincodeAction)
+	if err != nil {
+		panic(err)
 	}
 
-	prp := &pb.ProposalResponsePayload{
+	return &pb.ProposalResponsePayload{
 		Extension: chaincodeActionBytes,
 	}
-	payloadBytes, err := proto.Marshal(prp)
+}
+
+func (p *MockPeer) newChaincodeAction() *pb.ChaincodeAction {
+	chaincodeAction := &pb.ChaincodeAction{
+		Events: nil,
+		Response: &pb.Response{
+			Message: p.ResponseMessage,
+			Status:  p.Status,
+			Payload: p.Payload,
+		},
+		Results: p.getRWSet(),
+	}
+
+	if p.ChaincodeID != "" {
+		chaincodeAction.ChaincodeId = &pb.ChaincodeID{Name: p.ChaincodeID}
+	}
+
+	return chaincodeAction
+}
+
+func (p *MockPeer) getRWSet() []byte {
+	if len(p.RwSets) == 0 {
+		return nil
+	}
+
+	txRWSet := &rwsetutil.TxRwSet{
+		NsRwSets: p.RwSets,
+	}
+	txRWSetBytes, err := txRWSet.ToProtoBytes()
 	if err != nil {
 		panic(err)
 	}
 
-	return payloadBytes
+	return txRWSetBytes
 }

pkg/fab/mocks/mocktransactor.go

@@ -10,6 +10,7 @@ import (
 	reqContex "context"
 	"net/http"
 
+	"github.com/golang/protobuf/proto"
 	pb "github.com/hyperledger/fabric-protos-go/peer"
 	"github.com/hyperledger/fabric-sdk-go/pkg/common/providers/fab"
 )
@@ -29,9 +30,13 @@ func (t *MockTransactor) CreateTransactionHeader(opts ...fab.TxnHeaderOpt) (fab.
 // SendTransactionProposal sends a TransactionProposal to the target peers.
 func (t *MockTransactor) SendTransactionProposal(proposal *fab.TransactionProposal, targets []fab.ProposalProcessor) ([]*fab.TransactionProposalResponse, error) {
 	response := make([]*fab.TransactionProposalResponse, 1)
+	txResponse := &pb.Response{Message: "success", Payload: []byte("abc"), Status: http.StatusOK}
 	response[0] = &fab.TransactionProposalResponse{Endorser: "example.com", Status: 200,
-		ProposalResponse: &pb.ProposalResponse{Response: &pb.Response{Message: "success", Payload: []byte("abc"), Status: http.StatusOK},
-			Endorsement: &pb.Endorsement{Endorser: []byte("example.com"), Signature: []byte("signature")}},
+		ProposalResponse: &pb.ProposalResponse{
+			Response:    txResponse,
+			Payload:     getProposalResponsePayloadBytes(txResponse),
+			Endorsement: &pb.Endorsement{Endorser: []byte("example.com"), Signature: []byte("signature")},
+		},
 	}
 	return response, nil
 }
@@ -54,3 +59,23 @@ func (t *MockTransactor) SendTransaction(tx *fab.Transaction) (*fab.TransactionR
 	}
 	return response, nil
 }
+
+func getProposalResponsePayloadBytes(response *pb.Response) []byte {
+	chaincodeAction := &pb.ChaincodeAction{
+		Response: response,
+	}
+	chaincodeActionBytes, err := proto.Marshal(chaincodeAction)
+	if err != nil {
+		panic(err)
+	}
+
+	prp := &pb.ProposalResponsePayload{
+		Extension: chaincodeActionBytes,
+	}
+	payloadBytes, err := proto.Marshal(prp)
+	if err != nil {
+		panic(err)
+	}
+
+	return payloadBytes
+}