chaincode configuration (#440)

Signed-off-by: Angelo De Caro <[email protected]>

Author: adecaro

docs/core-fabric.md

@@ -304,6 +304,8 @@ fabric:
         # whether this is the default channel or not
         # TBD: What is the meaning of a default channel ?
         default: true
+        numRetries: 3 # number of retries on a chaincode operation failure
+        retrySleep: 1s # waiting time before retry again a failed chaincode operation
         chaincodes:
             # chaincode id
           - name: mychaincode

integration/fabric/atsa/chaincode/views/assets.go

@@ -8,6 +8,7 @@ package views
 
 import (
 	"encoding/json"
+	"time"
 
 	"github.com/hyperledger-labs/fabric-smart-client/platform/fabric/services/chaincode"
 	"github.com/hyperledger-labs/fabric-smart-client/platform/view/services/assert"
@@ -33,7 +34,7 @@ func (c *CreateAssetView) Call(context view.Context) (interface{}, error) {
 			"CreateAsset",
 			c.AssetProperties.ID,
 			c.PublicDescription,
-		).WithTransientEntry("asset_properties", apRaw).WithEndorsersFromMyOrg(),
+		).WithTransientEntry("asset_properties", apRaw).WithEndorsersFromMyOrg().WithNumRetries(2).WithRetrySleep(2 * time.Second),
 	)
 	assert.NoError(err, "failed creating asset")
 
@@ -58,7 +59,10 @@ type ReadAssetView struct {
 }
 
 func (r *ReadAssetView) Call(context view.Context) (interface{}, error) {
-	res, err := context.RunView(chaincode.NewQueryView("asset_transfer", "ReadAsset", r.ID).WithEndorsersFromMyOrg())
+	res, err := context.RunView(
+		chaincode.NewQueryView(
+			"asset_transfer", "ReadAsset", r.ID,
+		).WithEndorsersFromMyOrg().WithNumRetries(2).WithRetrySleep(2 * time.Second).WithMatchEndorsementPolicy())
 	assert.NoError(err, "failed reading asset")
 	return res, nil
 }

integration/fabric/fpc/echo/views/echo.go

@@ -8,6 +8,7 @@ package views
 
 import (
 	"encoding/json"
+	"time"
 
 	"github.com/hyperledger-labs/fabric-smart-client/platform/fabric"
 	"github.com/hyperledger-labs/fabric-smart-client/platform/fabric/services/chaincode"
@@ -100,7 +101,7 @@ func (e *EchoView) Call(context view.Context) (interface{}, error) {
 		fpc.StringsToArgs(e.Args)...,
 	).WithSignerIdentity(
 		fabric.GetDefaultFNS(context).LocalMembership().AnonymousIdentity(),
-	).Endorse(context)
+	).WithNumRetries(4).WithRetrySleep(2 * time.Second).Endorse(context)
 	assert.NoError(err, "failed endorsing echo")
 	assert.Equal(e.Function, string(res))
 	assert.NoError(fabric.GetDefaultFNS(context).Ordering().Broadcast(envelope))

integration/nwo/fabric/topology/core_template.go

@@ -298,6 +298,8 @@ fabric:
     channels: {{ range .Channels }}
       - name: {{ .Name }}
         default: {{ .Default }}
+        numRetries: 3
+        retrySleep: 1s
         chaincodes: {{range Chaincodes .Name }}
           - name: {{ .Chaincode.Name }}
             private: {{ .Private }}

platform/fabric/chaincode.go

@@ -8,6 +8,7 @@ package fabric
 
 import (
 	"encoding/json"
+	"time"
 
 	"github.com/hyperledger-labs/fabric-smart-client/platform/fabric/driver"
 	"github.com/hyperledger-labs/fabric-smart-client/platform/view/view"
@@ -82,7 +83,7 @@ func (c *Chaincode) Query(function string, args ...interface{}) *ChaincodeQuery
 }
 
 func (c *Chaincode) Endorse(function string, args ...interface{}) *ChaincodeEndorse {
-	ci := &ChaincodeEndorse{ci: c.chaincode.NewInvocation(function, args...)}
+	ci := &ChaincodeEndorse{ChaincodeInvocation: c.chaincode.NewInvocation(function, args...)}
 	ci.WithInvokerIdentity(c.fns.LocalMembership().DefaultIdentity())
 	return ci
 }
@@ -163,6 +164,18 @@ func (i *ChaincodeInvocation) WithInvokerIdentity(id view.Identity) *ChaincodeIn
 	return i
 }
 
+// WithNumRetries sets the number of times the chaincode operation should be retried before returning a failure
+func (i *ChaincodeInvocation) WithNumRetries(numRetries uint) *ChaincodeInvocation {
+	i.ChaincodeInvocation.WithNumRetries(numRetries)
+	return i
+}
+
+// WithRetrySleep sets the time interval between each retry
+func (i *ChaincodeInvocation) WithRetrySleep(duration time.Duration) *ChaincodeInvocation {
+	i.ChaincodeInvocation.WithRetrySleep(duration)
+	return i
+}
+
 type ChaincodeQuery struct {
 	driver.ChaincodeInvocation
 }
@@ -206,47 +219,78 @@ func (i *ChaincodeQuery) WithTxID(id TxID) *ChaincodeQuery {
 	return i
 }
 
+// WithMatchEndorsementPolicy enforces that the query is perfomed against a set of peers that satisfy the
+// endorsement policy of the chaincode
+func (i *ChaincodeQuery) WithMatchEndorsementPolicy() *ChaincodeQuery {
+	i.ChaincodeInvocation.WithMatchEndorsementPolicy()
+	return i
+}
+
+// WithNumRetries sets the number of times the chaincode operation should be retried before returning a failure
+func (i *ChaincodeQuery) WithNumRetries(numRetries uint) *ChaincodeQuery {
+	i.ChaincodeInvocation.WithNumRetries(numRetries)
+	return i
+}
+
+// WithRetrySleep sets the time interval between each retry
+func (i *ChaincodeQuery) WithRetrySleep(duration time.Duration) *ChaincodeQuery {
+	i.ChaincodeInvocation.WithRetrySleep(duration)
+	return i
+}
+
 type ChaincodeEndorse struct {
-	ci driver.ChaincodeInvocation
+	ChaincodeInvocation driver.ChaincodeInvocation
 }
 
 func (i *ChaincodeEndorse) Call() (*Envelope, error) {
-	env, err := i.ci.Endorse()
+	env, err := i.ChaincodeInvocation.Endorse()
 	if err != nil {
 		return nil, err
 	}
 	return &Envelope{e: env}, nil
 }
 
 func (i *ChaincodeEndorse) WithTransientEntry(k string, v interface{}) *ChaincodeEndorse {
-	i.ci.WithTransientEntry(k, v)
+	i.ChaincodeInvocation.WithTransientEntry(k, v)
 	return i
 }
 
 func (i *ChaincodeEndorse) WithEndorsersByMSPIDs(mspIDs ...string) *ChaincodeEndorse {
-	i.ci.WithEndorsersByMSPIDs(mspIDs...)
+	i.ChaincodeInvocation.WithEndorsersByMSPIDs(mspIDs...)
 	return i
 }
 
 func (i *ChaincodeEndorse) WithEndorsersFromMyOrg() *ChaincodeEndorse {
-	i.ci.WithEndorsersFromMyOrg()
+	i.ChaincodeInvocation.WithEndorsersFromMyOrg()
 	return i
 }
 
 func (i *ChaincodeEndorse) WithInvokerIdentity(id view.Identity) *ChaincodeEndorse {
-	i.ci.WithSignerIdentity(id)
+	i.ChaincodeInvocation.WithSignerIdentity(id)
 	return i
 }
 
 func (i *ChaincodeEndorse) WithTxID(id TxID) *ChaincodeEndorse {
-	i.ci.WithTxID(driver.TxID{
+	i.ChaincodeInvocation.WithTxID(driver.TxID{
 		Nonce:   id.Nonce,
 		Creator: id.Creator,
 	})
 	return i
 }
 
 func (i *ChaincodeEndorse) WithImplicitCollections(mspIDs ...string) *ChaincodeEndorse {
-	i.ci.WithImplicitCollections(mspIDs...)
+	i.ChaincodeInvocation.WithImplicitCollections(mspIDs...)
+	return i
+}
+
+// WithNumRetries sets the number of times the chaincode operation should be retried before returning a failure
+func (i *ChaincodeEndorse) WithNumRetries(numRetries uint) *ChaincodeEndorse {
+	i.ChaincodeInvocation.WithNumRetries(numRetries)
+	return i
+}
+
+// WithRetrySleep sets the time interval between each retry
+func (i *ChaincodeEndorse) WithRetrySleep(duration time.Duration) *ChaincodeEndorse {
+	i.ChaincodeInvocation.WithRetrySleep(duration)
 	return i
 }

platform/fabric/core/generic/chaincode/chaincode.go

@@ -8,29 +8,35 @@ package chaincode
 
 import (
 	"sync"
+	"time"
 
 	"github.com/ReneKroon/ttlcache/v2"
 	"github.com/hyperledger-labs/fabric-smart-client/platform/fabric/driver"
 	"github.com/hyperledger-labs/fabric-smart-client/platform/view"
 )
 
 type Chaincode struct {
-	name    string
-	sp      view.ServiceProvider
-	network Network
-	channel Channel
+	name       string
+	sp         view.ServiceProvider
+	network    Network
+	channel    Channel
+	NumRetries uint
+	RetrySleep time.Duration
 
 	discoveryResultsCacheLock sync.RWMutex
 	discoveryResultsCache     ttlcache.SimpleCache
 }
 
 func NewChaincode(name string, sp view.ServiceProvider, network Network, channel Channel) *Chaincode {
 	return &Chaincode{
-		name:                  name,
-		sp:                    sp,
-		network:               network,
-		channel:               channel,
-		discoveryResultsCache: ttlcache.NewCache(),
+		name:                      name,
+		sp:                        sp,
+		network:                   network,
+		channel:                   channel,
+		NumRetries:                channel.Config().NumRetries,
+		RetrySleep:                channel.Config().RetrySleep,
+		discoveryResultsCacheLock: sync.RWMutex{},
+		discoveryResultsCache:     ttlcache.NewCache(),
 	}
 }
 

platform/fabric/core/generic/chaincode/invoke.go

@@ -7,11 +7,13 @@ SPDX-License-Identifier: Apache-2.0
 package chaincode
 
 import (
+	"bytes"
 	"context"
 	"encoding/base64"
 	"strconv"
 	"strings"
 	"sync"
+	"time"
 
 	peer2 "github.com/hyperledger-labs/fabric-smart-client/platform/fabric/core/generic/peer"
 	"github.com/hyperledger-labs/fabric-smart-client/platform/fabric/core/generic/transaction"
@@ -44,6 +46,9 @@ type Invoke struct {
 	DiscoveredEndorsersByEndpoints []string
 	Function                       string
 	Args                           []interface{}
+	MatchEndorsementPolicy         bool
+	NumRetries                     int
+	RetrySleep                     time.Duration
 }
 
 func NewInvoke(chaincode *Chaincode, function string, args ...interface{}) *Invoke {
@@ -55,10 +60,27 @@ func NewInvoke(chaincode *Chaincode, function string, args ...interface{}) *Invo
 		ChaincodeName:   chaincode.name,
 		Function:        function,
 		Args:            args,
+		NumRetries:      int(chaincode.NumRetries),
+		RetrySleep:      chaincode.RetrySleep,
 	}
 }
 
 func (i *Invoke) Endorse() (driver.Envelope, error) {
+	for j := 0; j < i.NumRetries; j++ {
+		res, err := i.endorse()
+		if err != nil {
+			if j+1 >= i.NumRetries {
+				return nil, err
+			}
+			time.Sleep(i.RetrySleep)
+			continue
+		}
+		return res, nil
+	}
+	return nil, errors.Errorf("failed to perform endorse")
+}
+
+func (i *Invoke) endorse() (driver.Envelope, error) {
 	_, prop, responses, signer, err := i.prepare(false)
 	if err != nil {
 		return nil, err
@@ -79,21 +101,74 @@ func (i *Invoke) Endorse() (driver.Envelope, error) {
 }
 
 func (i *Invoke) Query() ([]byte, error) {
-	_, _, responses, _, err := i.prepare(true)
+	for j := 0; j < i.NumRetries; j++ {
+		res, err := i.query()
+		if err != nil {
+			if j+1 >= i.NumRetries {
+				return nil, err
+			}
+			time.Sleep(i.RetrySleep)
+			continue
+		}
+		return res, nil
+	}
+	return nil, errors.Errorf("failed to perform query")
+}
+
+func (i *Invoke) query() ([]byte, error) {
+	_, _, responses, _, err := i.prepare(!i.MatchEndorsementPolicy)
 	if err != nil {
 		return nil, err
 	}
-	proposalResp := responses[0]
-	if proposalResp == nil {
+
+	// check all responses match
+	resp := responses[0]
+	if resp == nil {
 		return nil, errors.New("error during query: received nil proposal response")
 	}
-	if proposalResp.Endorsement == nil {
-		return nil, errors.Errorf("endorsement failure during query. response: %v", proposalResp.Response)
+	if resp.Endorsement == nil {
+		return nil, errors.Errorf("endorsement failure during query. endorsement is nil: [%v]", resp.Response)
+	}
+	if resp.Response == nil {
+		return nil, errors.Errorf("endorsement failure during query. response is nil: [%v]", resp.Endorsement)
+	}
+	for i := 1; i < len(responses); i++ {
+		if responses[i].Endorsement == nil {
+			return nil, errors.Errorf("endorsement failure during query. endorsement is nil: [%v]", resp.Response)
+		}
+		if responses[i].Response == nil {
+			return nil, errors.Errorf("endorsement failure during query. response is nil: [%v]", resp.Endorsement)
+		}
+		if !bytes.Equal(responses[i].Response.Payload, resp.Response.Payload) {
+			return nil, errors.Errorf("endorsement failure during query. response payload does not match")
+		}
+		if responses[i].Response.Status != resp.Response.Status {
+			return nil, errors.Errorf("endorsement failure during query. response status does not match")
+		}
+		if responses[i].Response.Message != resp.Response.Message {
+			return nil, errors.Errorf("endorsement failure during query. response message does not match")
+		}
 	}
-	return proposalResp.Response.Payload, nil
+
+	return resp.Response.Payload, nil
 }
 
 func (i *Invoke) Submit() (string, []byte, error) {
+	for j := 0; j < i.NumRetries; j++ {
+		txID, res, err := i.submit()
+		if err != nil {
+			if j+1 >= i.NumRetries {
+				return "", nil, err
+			}
+			time.Sleep(i.RetrySleep)
+			continue
+		}
+		return txID, res, nil
+	}
+	return "", nil, errors.Errorf("failed to perform submit")
+}
+
+func (i *Invoke) submit() (string, []byte, error) {
 	txID, prop, responses, signer, err := i.prepare(false)
 	if err != nil {
 		return "", nil, err
@@ -148,6 +223,11 @@ func (i *Invoke) WithDiscoveredEndorsersByEndpoints(endpoints ...string) driver.
 	return i
 }
 
+func (i *Invoke) WithMatchEndorsementPolicy() driver.ChaincodeInvocation {
+	i.MatchEndorsementPolicy = true
+	return i
+}
+
 func (i *Invoke) WithSignerIdentity(id view.Identity) driver.ChaincodeInvocation {
 	i.SignerIdentity = id
 	return i
@@ -168,6 +248,16 @@ func (i *Invoke) WithTxID(id driver.TxID) driver.ChaincodeInvocation {
 	return i
 }
 
+func (i *Invoke) WithNumRetries(numRetries uint) driver.ChaincodeInvocation {
+	i.NumRetries = int(numRetries)
+	return i
+}
+
+func (i *Invoke) WithRetrySleep(duration time.Duration) driver.ChaincodeInvocation {
+	i.RetrySleep = duration
+	return i
+}
+
 func (i *Invoke) prepare(query bool) (string, *pb.Proposal, []*pb.ProposalResponse, driver.SigningIdentity, error) {
 	// TODO: improve by providing grpc connection pool
 	var peerClients []peer2.Client