[FAB-6734] Define discovery service support interface

The discovery service requires certain capabilities from the peer layers
such as message, identity verification, peer enumeration, etc.

This change set defines the interface.

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

Author: yacovm

discovery/api.go

@@ -0,0 +1,42 @@
+/*
+Copyright IBM Corp. All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package discovery
+
+import (
+	"github.com/hyperledger/fabric/gossip/api"
+	"github.com/hyperledger/fabric/gossip/common"
+	"github.com/hyperledger/fabric/gossip/discovery"
+	common2 "github.com/hyperledger/fabric/protos/common"
+	discovery2 "github.com/hyperledger/fabric/protos/discovery"
+)
+
+// support defines an interface that allows the discovery service
+// to obtain information that other peer components have
+type support interface {
+	// IdentityInfo returns identity information about peers
+	IdentityInfo() api.PeerIdentitySet
+
+	// ChannelExists returns whether a given channel exists or not
+	ChannelExists(channel string) bool
+
+	// PeersOfChannel returns the NetworkMembers considered alive
+	// and also subscribed to the channel given
+	PeersOfChannel(common.ChainID) discovery.Members
+
+	// Peers returns the NetworkMembers considered alive
+	Peers() discovery.Members
+
+	// PeersForEndorsement returns an EndorsementDescriptor for a given set of peers, channel, and chaincode
+	PeersForEndorsement(chaincode string, channel common.ChainID) (*discovery2.EndorsementDescriptor, error)
+
+	// Eligible returns whether the given peer is eligible for receiving
+	// service from the discovery service for a given channel
+	EligibleForService(channel string, data common2.SignedData) error
+
+	// Config returns the channel's configuration
+	Config(channel string) (*discovery2.ConfigResult, error)
+}

gossip/api/api_test.go

@@ -6,8 +6,26 @@ SPDX-License-Identifier: Apache-2.0
 
 package api
 
-import "testing"
+import (
+	"testing"
 
-func TestNoop(t *testing.T) {
-	// This is just to make this package included in the code-coverage statistics
+	"github.com/stretchr/testify/assert"
+)
+
+func TestPeerIdentitySetByOrg(t *testing.T) {
+	p1 := PeerIdentityInfo{
+		Organization: OrgIdentityType("ORG1"),
+		Identity:     PeerIdentityType("Peer1"),
+	}
+	p2 := PeerIdentityInfo{
+		Organization: OrgIdentityType("ORG2"),
+		Identity:     PeerIdentityType("Peer2"),
+	}
+	is := PeerIdentitySet{
+		p1, p2,
+	}
+	m := is.ByOrg()
+	assert.Len(t, m, 2)
+	assert.Equal(t, PeerIdentitySet{p1}, m["ORG1"])
+	assert.Equal(t, PeerIdentitySet{p2}, m["ORG2"])
 }

gossip/api/crypto.go

@@ -60,6 +60,26 @@ type MessageCryptoService interface {
 	Expiration(peerIdentity PeerIdentityType) (time.Time, error)
 }
 
+// PeerIdentityInfo aggregates a peer's identity,
+// and also additional metadata about it
+type PeerIdentityInfo struct {
+	PKIId        common.PKIidType
+	Identity     PeerIdentityType
+	Organization OrgIdentityType
+}
+
+// PeerIdentitySet aggregates a PeerIdentityInfo slice
+type PeerIdentitySet []PeerIdentityInfo
+
+// ByOrg sorts the PeerIdentitySet by organizations of its peers
+func (pis PeerIdentitySet) ByOrg() map[string]PeerIdentitySet {
+	m := make(map[string]PeerIdentitySet)
+	for _, id := range pis {
+		m[string(id.Organization)] = append(m[string(id.Organization)], id)
+	}
+	return m
+}
+
 // PeerIdentityType is the peer's certificate
 type PeerIdentityType []byte
 

gossip/discovery/discovery.go

@@ -75,6 +75,7 @@ type NetworkMember struct {
 	PKIid            common.PKIidType
 	InternalEndpoint string
 	Properties       *proto.Properties
+	*proto.Envelope
 }
 
 // String returns a string representation of the NetworkMember
@@ -133,3 +134,39 @@ type Discovery interface {
 	// and whether the action was successful or not
 	Connect(member NetworkMember, id identifier)
 }
+
+// Members represents an aggregation of NetworkMembers
+type Members []NetworkMember
+
+// ByID returns a mapping from the PKI-IDs (in string form)
+// to NetworkMember
+func (members Members) ByID() map[string]NetworkMember {
+	res := make(map[string]NetworkMember, len(members))
+	for _, peer := range members {
+		res[string(peer.PKIid)] = peer
+	}
+	return res
+}
+
+// Intersect returns the intersection of 2 Members
+func (members Members) Intersect(otherMembers Members) Members {
+	var res Members
+	m := otherMembers.ByID()
+	for _, member := range members {
+		if _, exists := m[string(member.PKIid)]; exists {
+			res = append(res, member)
+		}
+	}
+	return res
+}
+
+// Filter returns only members that satisfy the given filter
+func (members Members) Filter(filter func(member NetworkMember) bool) Members {
+	var res Members
+	for _, member := range members {
+		if filter(member) {
+			res = append(res, member)
+		}
+	}
+	return res
+}

gossip/discovery/discovery_test.go

@@ -1232,6 +1232,45 @@ func TestMemRespDisclosurePol(t *testing.T) {
 	assert.NotZero(t, d2.sentMsgCount())
 }
 
+func TestMembersByID(t *testing.T) {
+	members := Members{
+		{PKIid: common.PKIidType("p0"), Endpoint: "p0"},
+		{PKIid: common.PKIidType("p1"), Endpoint: "p1"},
+	}
+	byID := members.ByID()
+	assert.Len(t, byID, 2)
+	assert.Equal(t, "p0", byID["p0"].Endpoint)
+	assert.Equal(t, "p1", byID["p1"].Endpoint)
+}
+
+func TestFilter(t *testing.T) {
+	members := Members{
+		{PKIid: common.PKIidType("p0"), Endpoint: "p0", Properties: &proto.Properties{
+			Chaincodes: []*proto.Chaincode{{Name: "cc", Version: "1.0"}},
+		}},
+		{PKIid: common.PKIidType("p1"), Endpoint: "p1", Properties: &proto.Properties{
+			Chaincodes: []*proto.Chaincode{{Name: "cc", Version: "2.0"}},
+		}},
+	}
+	res := members.Filter(func(member NetworkMember) bool {
+		cc := member.Properties.Chaincodes[0]
+		return cc.Version == "2.0" && cc.Name == "cc"
+	})
+	assert.Equal(t, Members{members[1]}, res)
+}
+
+func TestMembersIntersect(t *testing.T) {
+	members1 := Members{
+		{PKIid: common.PKIidType("p0"), Endpoint: "p0"},
+		{PKIid: common.PKIidType("p1"), Endpoint: "p1"},
+	}
+	members2 := Members{
+		{PKIid: common.PKIidType("p1"), Endpoint: "p1"},
+		{PKIid: common.PKIidType("p2"), Endpoint: "p2"},
+	}
+	assert.Equal(t, Members{{PKIid: common.PKIidType("p1"), Endpoint: "p1"}}, members1.Intersect(members2))
+}
+
 func waitUntilOrFail(t *testing.T, pred func() bool) {
 	waitUntilTimeoutOrFail(t, pred, timeout)
 }