[FAB-10028] Prepare discovery for cc2cc queries

This change set refacors the endorsement logic in order to prepare
a smoother landing for the cc2cc query support.

It also adds stricter validation for chaincode queries.

Change-Id: Id17e139fc5c7294ce2ec5fb54e8f1415a74960a3
Signed-off-by: yacovm <yacovm@il.ibm.com>

Author: yacovm

discovery/endorsement/collection.go

@@ -15,6 +15,20 @@ import (
 
 type filterPrincipalSets func(collectionName string, principalSets policies.PrincipalSets) (policies.PrincipalSets, error)
 
+func (f filterPrincipalSets) forCollections(ccName string, collections ...string) filterFunc {
+	return func(principalSets policies.PrincipalSets) (policies.PrincipalSets, error) {
+		var err error
+		for _, col := range collections {
+			principalSets, err = f(col, principalSets)
+			if err != nil {
+				logger.Warningf("Failed filtering collection for chaincode %s, collection %s: %v", ccName, col, err)
+				return nil, err
+			}
+		}
+		return principalSets, nil
+	}
+}
+
 func newCollectionFilter(configBytes []byte) (filterPrincipalSets, error) {
 	mapFilter := make(principalSetsByCollectionName)
 	if len(configBytes) == 0 {

discovery/endorsement/collection_test.go

@@ -13,9 +13,36 @@ import (
 	"github.com/hyperledger/fabric/protos/common"
 	"github.com/hyperledger/fabric/protos/msp"
 	"github.com/hyperledger/fabric/protos/utils"
+	"github.com/pkg/errors"
 	"github.com/stretchr/testify/assert"
 )
 
+func TestForCollections(t *testing.T) {
+	foos := policies.PrincipalSets{{orgPrincipal("foo")}}
+	bars := policies.PrincipalSets{{orgPrincipal("bar")}}
+	f := filterPrincipalSets(func(collectionName string, principalSets policies.PrincipalSets) (policies.PrincipalSets, error) {
+		switch collectionName {
+		case "foo":
+			return foos, nil
+		case "bar":
+			return bars, nil
+		default:
+			return nil, errors.Errorf("collection %s doesn't exist", collectionName)
+		}
+	})
+
+	res, err := f.forCollections("mycc", "foo")(nil)
+	assert.NoError(t, err)
+	assert.Equal(t, foos, res)
+
+	res, err = f.forCollections("mycc", "bar")(nil)
+	assert.NoError(t, err)
+	assert.Equal(t, bars, res)
+
+	res, err = f.forCollections("mycc", "baz")(nil)
+	assert.Equal(t, "collection baz doesn't exist", err.Error())
+}
+
 func TestCollectionFilter(t *testing.T) {
 	org1AndOrg2 := []*msp.MSPPrincipal{orgPrincipal("Org1MSP"), orgPrincipal("Org2MSP")}
 	org1AndOrg3 := []*msp.MSPPrincipal{orgPrincipal("Org1MSP"), orgPrincipal("Org3MSP")}

discovery/endorsement/endorsement.go

@@ -79,14 +79,18 @@ type peerPrincipalEvaluator func(member discovery2.NetworkMember, principal *msp
 
 // PeersForEndorsement returns an EndorsementDescriptor for a given set of peers, channel, and chaincode
 func (ea *endorsementAnalyzer) PeersForEndorsement(chainID common.ChainID, interest *discovery.ChaincodeInterest) (*discovery.EndorsementDescriptor, error) {
-	chaincode := interest.Chaincodes[0]
-	loadCollections := len(chaincode.CollectionNames) > 0
-	ccMD := ea.Metadata(string(chainID), chaincode.Name, loadCollections)
-	if ccMD == nil {
-		return nil, errors.Errorf("No metadata was found for chaincode %s in channel %s", chaincode.Name, string(chainID))
+	// For now we only support a single chaincode
+	if len(interest.Chaincodes) != 1 {
+		return nil, errors.New("only a single chaincode is supported")
+	}
+	interest.Chaincodes = []*discovery.ChaincodeCall{interest.Chaincodes[0]}
+
+	metadataAndCollectionFilters, err := loadMetadataAndFilters(chainID, interest, ea)
+	if err != nil {
+		return nil, errors.WithStack(err)
 	}
 	// Filter out peers that don't have the chaincode installed on them
-	chanMembership := ea.PeersOfChannel(chainID).Filter(peersWithChaincode(ccMD))
+	chanMembership := ea.PeersOfChannel(chainID).Filter(peersWithChaincode(metadataAndCollectionFilters.md...))
 	channelMembersById := chanMembership.ByID()
 	// Choose only the alive messages of those that have joined the channel
 	aliveMembership := ea.Peers().Intersect(chanMembership)
@@ -95,68 +99,179 @@ func (ea *endorsementAnalyzer) PeersForEndorsement(chainID common.ChainID, inter
 	identities := ea.IdentityInfo()
 	identitiesOfMembers := computeIdentitiesOfMembers(identities, membersById)
 
-	// Retrieve the policy for the chaincode
-	pol := ea.PolicyByChaincode(string(chainID), chaincode.Name)
-	if pol == nil {
-		logger.Debug("Policy for chaincode '", chaincode, "'doesn't exist")
-		return nil, errors.New("policy not found")
+	// Retrieve the policies for the chaincodes
+	pols, err := ea.loadPolicies(chainID, interest)
+	if err != nil {
+		return nil, errors.WithStack(err)
 	}
+	// For now we take the first policy and ignore the rest
+	pol := pols[0]
 
 	// Compute the combinations of principals (principal sets) that satisfy the endorsement policy
 	principalsSets := policies.PrincipalSets(pol.SatisfiedBy())
 
-	// Obtain the MSP IDs of the members of the channel that are alive
-	mspIDsOfChannelPeers := mspIDsOfMembers(membersById, identities.ByID())
 	// Filter out principal sets that contain MSP IDs for peers that don't have the chaincode(s) installed
-	principalsSets = principalsSets.ContainingOnly(func(principal *msp.MSPPrincipal) bool {
-		mspID := ea.MSPOfPrincipal(principal)
-		_, exists := mspIDsOfChannelPeers[mspID]
-		return mspID != "" && exists
-	})
+	principalsSets = ea.excludeIfCCNotInstalled(principalsSets, membersById, identities.ByID())
 
-	if loadCollections {
-		filterByCollections, err := newCollectionFilter(ccMD.CollectionsConfig)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed creating collection filter")
-		}
-		for _, col := range chaincode.CollectionNames {
-			principalsSets, err = filterByCollections(col, principalsSets)
-			if err != nil {
-				return nil, errors.Wrapf(err, "failed filtering collection %s for chaincode %s", col, chaincode.Name)
-			}
-		}
+	// Filter the principal sets by the collections (if applicable)
+	principalsSets, err = metadataAndCollectionFilters.filter(principalsSets)
+	if err != nil {
+		return nil, errors.WithStack(err)
 	}
 
+	return ea.computeEndorsementResponse(&context{
+		chaincode:           interest.Chaincodes[0].Name,
+		channel:             string(chainID),
+		principalsSets:      principalsSets,
+		channelMembersById:  channelMembersById,
+		aliveMembership:     aliveMembership,
+		identitiesOfMembers: identitiesOfMembers,
+	})
+}
+
+type context struct {
+	chaincode           string
+	channel             string
+	aliveMembership     discovery2.Members
+	principalsSets      []policies.PrincipalSet
+	channelMembersById  map[string]discovery2.NetworkMember
+	identitiesOfMembers memberIdentities
+}
+
+func (ea *endorsementAnalyzer) computeEndorsementResponse(ctx *context) (*discovery.EndorsementDescriptor, error) {
 	// mapPrincipalsToGroups returns a mapping from principals to their corresponding groups.
 	// groups are just human readable representations that mask the principals behind them
-	principalGroups := mapPrincipalsToGroups(principalsSets)
+	principalGroups := mapPrincipalsToGroups(ctx.principalsSets)
 	// principalsToPeersGraph computes a bipartite graph (V1 U V2 , E)
 	// such that V1 is the peers, V2 are the principals,
 	// and each e=(peer,principal) is in E if the peer satisfies the principal
 	satGraph := principalsToPeersGraph(principalAndPeerData{
-		members: aliveMembership,
+		members: ctx.aliveMembership,
 		pGrps:   principalGroups,
-	}, ea.satisfiesPrincipal(string(chainID), identitiesOfMembers))
+	}, ea.satisfiesPrincipal(ctx.channel, ctx.identitiesOfMembers))
 
-	layouts := computeLayouts(principalsSets, principalGroups, satGraph)
+	layouts := computeLayouts(ctx.principalsSets, principalGroups, satGraph)
 	if len(layouts) == 0 {
 		return nil, errors.New("cannot satisfy any principal combination")
 	}
 
 	criteria := &peerMembershipCriteria{
 		possibleLayouts: layouts,
 		satGraph:        satGraph,
-		chanMemberById:  channelMembersById,
-		idOfMembers:     identitiesOfMembers,
+		chanMemberById:  ctx.channelMembersById,
+		idOfMembers:     ctx.identitiesOfMembers,
 	}
 
 	return &discovery.EndorsementDescriptor{
-		Chaincode:         chaincode.Name,
+		Chaincode:         ctx.chaincode,
 		Layouts:           layouts,
 		EndorsersByGroups: endorsersByGroup(criteria),
 	}, nil
 }
 
+func (ea *endorsementAnalyzer) excludeIfCCNotInstalled(principalsSets policies.PrincipalSets, membersById map[string]discovery2.NetworkMember, identitiesByID map[string]api.PeerIdentityInfo) policies.PrincipalSets {
+	// Obtain the MSP IDs of the members of the channel that are alive
+	mspIDsOfChannelPeers := mspIDsOfMembers(membersById, identitiesByID)
+	principalsSets = ea.excludePrincipals(func(principal *msp.MSPPrincipal) bool {
+		mspID := ea.MSPOfPrincipal(principal)
+		_, exists := mspIDsOfChannelPeers[mspID]
+		return mspID != "" && exists
+	}, principalsSets)
+	return principalsSets
+}
+
+func (ea *endorsementAnalyzer) excludePrincipals(filter func(principal *msp.MSPPrincipal) bool, sets ...policies.PrincipalSets) policies.PrincipalSets {
+	var res []policies.PrincipalSets
+	for _, principalSets := range sets {
+		principalSets = principalSets.ContainingOnly(filter)
+		if len(principalSets) == 0 {
+			continue
+		}
+		res = append(res, principalSets)
+	}
+	if len(res) == 0 {
+		return nil
+	}
+	return res[0]
+}
+
+func (ea *endorsementAnalyzer) loadPolicies(chainID common.ChainID, interest *discovery.ChaincodeInterest) ([]policies.InquireablePolicy, error) {
+	var res []policies.InquireablePolicy
+	for _, chaincode := range interest.Chaincodes {
+		pol := ea.PolicyByChaincode(string(chainID), chaincode.Name)
+		if pol == nil {
+			logger.Debug("Policy for chaincode '", chaincode, "'doesn't exist")
+			return nil, errors.New("policy not found")
+		}
+		res = append(res, pol)
+	}
+	return res, nil
+}
+
+type filterFunc func(policies.PrincipalSets) (policies.PrincipalSets, error)
+
+type filterFunctions []filterFunc
+
+type metadataAndColFilter struct {
+	md     []*chaincode.Metadata
+	filter filterFunc
+}
+
+func loadMetadataAndFilters(chainID common.ChainID, interest *discovery.ChaincodeInterest, fetch chaincodeMetadataFetcher) (*metadataAndColFilter, error) {
+	var metadata []*chaincode.Metadata
+	var filters filterFunctions
+
+	for _, chaincode := range interest.Chaincodes {
+		ccMD := fetch.Metadata(string(chainID), chaincode.Name, len(chaincode.CollectionNames) > 0)
+		if ccMD == nil {
+			return nil, errors.Errorf("No metadata was found for chaincode %s in channel %s", chaincode.Name, string(chainID))
+		}
+		metadata = append(metadata, ccMD)
+		if len(chaincode.CollectionNames) == 0 {
+			continue
+		}
+		f, err := newCollectionFilter(ccMD.CollectionsConfig)
+		if err != nil {
+			logger.Warningf("Failed initializing collection filter for chaincode %s: %v", chaincode.Name, err)
+			return nil, errors.WithStack(err)
+		}
+		filters = append(filters, f.forCollections(chaincode.Name, chaincode.CollectionNames...))
+	}
+
+	return computeFiltersWithMetadata(filters, metadata), nil
+}
+
+func computeFiltersWithMetadata(filters filterFunctions, metadata []*chaincode.Metadata) *metadataAndColFilter {
+	if len(filters) == 0 {
+		return &metadataAndColFilter{
+			md:     metadata,
+			filter: noopFilter,
+		}
+	}
+
+	return &metadataAndColFilter{
+		md:     metadata,
+		filter: filters.combine(),
+	}
+}
+
+func noopFilter(policies policies.PrincipalSets) (policies.PrincipalSets, error) {
+	return policies, nil
+}
+
+func (filters filterFunctions) combine() filterFunc {
+	return func(principals policies.PrincipalSets) (policies.PrincipalSets, error) {
+		var err error
+		for _, filter := range filters {
+			principals, err = filter(principals)
+			if err != nil {
+				return nil, err
+			}
+		}
+		return principals, nil
+	}
+}
+
 func (ea *endorsementAnalyzer) satisfiesPrincipal(channel string, identitiesOfMembers memberIdentities) peerPrincipalEvaluator {
 	return func(member discovery2.NetworkMember, principal *msp.MSPPrincipal) bool {
 		err := ea.SatisfiesPrincipal(channel, identitiesOfMembers.identityByPKIID(member.PKIid), principal)
@@ -373,17 +488,23 @@ func (l layouts) groupsSet() map[string]struct{} {
 	return m
 }
 
-func peersWithChaincode(ccMD *chaincode.Metadata) func(member discovery2.NetworkMember) bool {
+func peersWithChaincode(metadata ...*chaincode.Metadata) func(member discovery2.NetworkMember) bool {
 	return func(member discovery2.NetworkMember) bool {
 		if member.Properties == nil {
 			return false
 		}
-		for _, cc := range member.Properties.Chaincodes {
-			if cc.Name == ccMD.Name && cc.Version == ccMD.Version {
-				return true
+		for _, ccMD := range metadata {
+			var found bool
+			for _, cc := range member.Properties.Chaincodes {
+				if cc.Name == ccMD.Name && cc.Version == ccMD.Version {
+					found = true
+				}
+			}
+			if !found {
+				return false
 			}
 		}
-		return false
+		return true
 	}
 }
 

discovery/service.go

@@ -119,11 +119,11 @@ func (s *service) dispatch(q *discovery.Query) *discovery.QueryResult {
 }
 
 func (s *service) chaincodeQuery(q *discovery.Query) *discovery.QueryResult {
+	if err := validateCCQuery(q.GetCcQuery()); err != nil {
+		return wrapError(err)
+	}
 	var descriptors []*discovery.EndorsementDescriptor
 	for _, interest := range q.GetCcQuery().Interests {
-		if len(interest.Chaincodes) == 0 || interest.Chaincodes[0] == nil {
-			return wrapError(errors.Errorf("must include at least one chaincode"))
-		}
 		desc, err := s.PeersForEndorsement(common2.ChainID(q.Channel), interest)
 		if err != nil {
 			logger.Errorf("Failed constructing descriptor for chaincode %s,: %v", interest, err)
@@ -247,6 +247,26 @@ func validateStructure(ctx context.Context, request *discovery.SignedRequest, ad
 	return req, nil
 }
 
+func validateCCQuery(ccQuery *discovery.ChaincodeQuery) error {
+	if len(ccQuery.Interests) == 0 {
+		return errors.New("chaincode query must have at least one chaincode interest")
+	}
+	for _, interest := range ccQuery.Interests {
+		if interest == nil {
+			return errors.New("chaincode interest is nil")
+		}
+		if len(interest.Chaincodes) == 0 {
+			return errors.New("chaincode interest must contain at least one chaincode")
+		}
+		for _, cc := range interest.Chaincodes {
+			if cc.Name == "" {
+				return errors.New("chaincode name in interest cannot be empty")
+			}
+		}
+	}
+	return nil
+}
+
 func wrapError(err error) *discovery.QueryResult {
 	return &discovery.QueryResult{
 		Result: &discovery.QueryResult_Error{