[FABG-769] query chaincode's collection configuration

Change-Id: Ie6e82ba1980c930652e9ad5ad736ef2c6b92da81
Signed-off-by: 乔伦 徐 <jamesxql@gmail.com>

Author: gotoxu

pkg/client/resmgmt/resmgmt.go

@@ -574,27 +574,72 @@ func (rc *Client) QueryInstantiatedChaincodes(channelID string, options ...Reque
 	if len(opts.Targets) >= 1 {
 		target = opts.Targets[0]
 	} else {
-		// discover peers on this channel
-		discovery, err := chCtx.ChannelService().Discovery()
+		// select random channel peer
+		var err error
+		target, err = rc.selectRandomChannelPeer(chCtx)
 		if err != nil {
-			return nil, errors.WithMessage(err, "failed to get discovery service")
-		}
-		// default filter will be applied (if any)
-		targets, err2 := rc.getDefaultTargets(discovery)
-		if err2 != nil {
-			return nil, errors.WithMessage(err2, "failed to get default target for query instantiated chaincodes")
+			return nil, err
 		}
+	}
+
+	l, err := channel.NewLedger(channelID)
+	if err != nil {
+		return nil, err
+	}
 
-		// Filter by MSP since the LSCC only allows local calls
-		targets = filterTargets(targets, &mspFilter{mspID: chCtx.Identifier().MSPID})
+	reqCtx, cancel := rc.createRequestContext(opts, fab.PeerResponse)
+	defer cancel()
 
-		if len(targets) == 0 {
-			return nil, errors.Errorf("no targets in MSP [%s]", chCtx.Identifier().MSPID)
-		}
+	// Channel service membership is required to verify signature
+	channelService := chCtx.ChannelService()
+
+	membership, err := channelService.Membership()
+	if err != nil {
+		return nil, errors.WithMessage(err, "membership creation failed")
+	}
+
+	responses, err := l.QueryInstantiatedChaincodes(reqCtx, []fab.ProposalProcessor{target}, &verifier.Signature{Membership: membership})
+	if err != nil {
+		return nil, err
+	}
+
+	return responses[0], nil
+}
+
+// QueryCollectionsConfig queries the collections config on a peer for specific channel. If peer is not specified in options it will query random peer on this channel.
+// Parameters:
+// channel is mandatory channel name
+// chaincode is mandatory chaincode name
+// options hold optional request options
+//
+// Returns:
+// list of collections config
+func (rc *Client) QueryCollectionsConfig(channelID string, chaincodeName string, options ...RequestOption) (*common.CollectionConfigPackage, error) {
+	opts, err := rc.prepareRequestOpts(options...)
+	if err != nil {
+		return nil, err
+	}
+
+	chCtx, err := contextImpl.NewChannel(
+		func() (context.Client, error) {
+			return rc.ctx, nil
+		},
+		channelID,
+	)
+	if err != nil {
+		return nil, errors.WithMessage(err, "failed to create channel context")
+	}
 
+	var target fab.ProposalProcessor
+	if len(opts.Targets) >= 1 {
+		target = opts.Targets[0]
+	} else {
 		// select random channel peer
-		randomNumber := rand.Intn(len(targets))
-		target = targets[randomNumber]
+		var err error
+		target, err = rc.selectRandomChannelPeer(chCtx)
+		if err != nil {
+			return nil, err
+		}
 	}
 
 	l, err := channel.NewLedger(channelID)
@@ -613,14 +658,38 @@ func (rc *Client) QueryInstantiatedChaincodes(channelID string, options ...Reque
 		return nil, errors.WithMessage(err, "membership creation failed")
 	}
 
-	responses, err := l.QueryInstantiatedChaincodes(reqCtx, []fab.ProposalProcessor{target}, &verifier.Signature{Membership: membership})
+	responses, err := l.QueryCollectionsConfig(reqCtx, chaincodeName, []fab.ProposalProcessor{target}, &verifier.Signature{Membership: membership})
 	if err != nil {
 		return nil, err
 	}
 
 	return responses[0], nil
 }
 
+func (rc *Client) selectRandomChannelPeer(ctx context.Channel) (fab.ProposalProcessor, error) {
+	// discover peers on this channel
+	discovery, err := ctx.ChannelService().Discovery()
+	if err != nil {
+		return nil, errors.WithMessage(err, "failed to get discovery service")
+	}
+	// default filter will be applied (if any)
+	targets, err2 := rc.getDefaultTargets(discovery)
+	if err2 != nil {
+		return nil, errors.WithMessage(err2, "failed to get default target for query instantiated chaincodes")
+	}
+
+	// Filter by MSP since the LSCC only allows local calls
+	targets = filterTargets(targets, &mspFilter{mspID: ctx.Identifier().MSPID})
+
+	if len(targets) == 0 {
+		return nil, errors.Errorf("no targets in MSP [%s]", ctx.Identifier().MSPID)
+	}
+
+	// select random channel peer
+	randomNumber := rand.Intn(len(targets))
+	return targets[randomNumber], nil
+}
+
 // QueryChannels queries the names of all the channels that a peer has joined.
 //  Parameters:
 //  options hold optional request options

pkg/client/resmgmt/resmgmt_test.go

@@ -460,6 +460,24 @@ func TestQueryInstantiatedChaincodes(t *testing.T) {
 	}
 }
 
+func TestQueryCollectionsConfig(t *testing.T) {
+	rc := setupDefaultResMgmtClient(t)
+
+	_, err := rc.QueryCollectionsConfig("mychannel", "mychaincode")
+	if err == nil {
+		t.Fatal("QueryInstalledChaincodes: peer cannot be nil")
+	}
+
+	peer := &fcmocks.MockPeer{MockName: "Peer1", MockURL: "http://peer1.com", MockRoles: []string{}, MockCert: nil, MockMSP: "Org1MSP", Status: http.StatusOK}
+	coll, err := rc.QueryCollectionsConfig("mychannel", "mychaincode", WithTargets(peer))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(coll.Config) != 0 {
+		t.Fatalf("There is no collection configuration on peer")
+	}
+}
+
 func TestQueryChannels(t *testing.T) {
 
 	rc := setupDefaultResMgmtClient(t)

pkg/fab/channel/ledger.go

@@ -25,8 +25,9 @@ import (
 var logger = logging.NewLogger("fabsdk/fab")
 
 const (
-	lscc           = "lscc"
-	lsccChaincodes = "getchaincodes"
+	lscc                  = "lscc"
+	lsccChaincodes        = "getchaincodes"
+	lsccCollectionsConfig = "getcollectionsconfig"
 )
 
 // Ledger is a client that provides access to the underlying ledger of a channel.
@@ -207,6 +208,32 @@ func createChaincodeQueryResponse(tpr *fab.TransactionProposalResponse) (*pb.Cha
 	return &response, nil
 }
 
+// QueryCollectionsConfig queries the collections config for a chaincode on this channel.
+func (c *Ledger) QueryCollectionsConfig(reqCtx reqContext.Context, chaincodeName string, targets []fab.ProposalProcessor, verifier ResponseVerifier) ([]*common.CollectionConfigPackage, error) {
+	cir := createCollectionsConfigInvokeRequest(chaincodeName)
+	tprs, errs := queryChaincode(reqCtx, c.chName, cir, targets, verifier)
+
+	responses := []*common.CollectionConfigPackage{}
+	for _, tpr := range tprs {
+		r, err := createCollectionsConfigQueryResponse(tpr)
+		if err != nil {
+			errs = multi.Append(errs, errors.WithMessage(err, "From target: "+tpr.Endorser))
+		} else {
+			responses = append(responses, r)
+		}
+	}
+	return responses, errs
+}
+
+func createCollectionsConfigQueryResponse(tpr *fab.TransactionProposalResponse) (*common.CollectionConfigPackage, error) {
+	response := common.CollectionConfigPackage{}
+	err := proto.Unmarshal(tpr.ProposalResponse.GetResponse().Payload, &response)
+	if err != nil {
+		return nil, errors.Wrap(err, "unmarshal of transaction proposal response failed")
+	}
+	return &response, nil
+}
+
 // QueryConfigBlock returns the current configuration block for the specified channel. If the
 // peer doesn't belong to the channel, return error
 func (c *Ledger) QueryConfigBlock(reqCtx reqContext.Context, targets []fab.ProposalProcessor, verifier ResponseVerifier) (*common.Block, error) {
@@ -273,3 +300,12 @@ func createChaincodeInvokeRequest() fab.ChaincodeInvokeRequest {
 	}
 	return cir
 }
+
+func createCollectionsConfigInvokeRequest(chaincodeName string) fab.ChaincodeInvokeRequest {
+	cir := fab.ChaincodeInvokeRequest{
+		ChaincodeID: lscc,
+		Fcn:         lsccCollectionsConfig,
+		Args:        [][]byte{[]byte(chaincodeName)},
+	}
+	return cir
+}

test/integration/pkg/client/resmgmt/main_test.go

@@ -11,11 +11,15 @@ import (
 	"github.com/hyperledger/fabric-sdk-go/pkg/fabsdk"
 	"github.com/hyperledger/fabric-sdk-go/test/integration"
 	"github.com/hyperledger/fabric-sdk-go/test/integration/util/runner"
+	"github.com/stretchr/testify/require"
 )
 
 const (
 	org1Name      = "Org1"
+	org2Name      = "Org2"
 	org1AdminUser = "Admin"
+	org2AdminUser = "Admin"
+	orgChannelID  = "orgchannel"
 )
 
 var mainSDK *fabsdk.FabricSDK
@@ -31,3 +35,9 @@ func TestMain(m *testing.M) {
 
 	r.Run(m)
 }
+
+func setupMultiOrgContext(t *testing.T, sdk *fabsdk.FabricSDK) []*integration.OrgContext {
+	orgContext, err := integration.SetupMultiOrgContext(sdk, org1Name, org2Name, org1AdminUser, org2AdminUser)
+	require.NoError(t, err)
+	return orgContext
+}

test/integration/pkg/client/resmgmt/resmgmt_queries_pvt_test.go

@@ -0,0 +1,107 @@
+/*
+Copyright SecureKey Technologies Inc. All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package resmgmt
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/hyperledger/fabric-sdk-go/pkg/client/resmgmt"
+	"github.com/hyperledger/fabric-sdk-go/pkg/fabsdk"
+	"github.com/hyperledger/fabric-sdk-go/test/integration"
+	"github.com/hyperledger/fabric-sdk-go/third_party/github.com/hyperledger/fabric/common/cauthdsl"
+	cb "github.com/hyperledger/fabric-sdk-go/third_party/github.com/hyperledger/fabric/protos/common"
+	"github.com/stretchr/testify/require"
+)
+
+const (
+	collCfgName              = "collection1"
+	collCfgBlockToLive       = 1000
+	collCfgRequiredPeerCount = 0
+	collCfgMaximumPeerCount  = 2
+	collCfgPolicy            = "OR('Org1MSP.member','Org2MSP.member')"
+)
+
+func TestQueryCollectionsConfig(t *testing.T) {
+	sdk := mainSDK
+
+	orgsContext := setupMultiOrgContext(t, sdk)
+	err := integration.EnsureChannelCreatedAndPeersJoined(t, sdk, orgChannelID, "orgchannel.tx", orgsContext)
+	require.NoError(t, err)
+
+	ccID := integration.GenerateExamplePvtID(true)
+	collConfig, err := newCollectionConfig(collCfgName, collCfgPolicy, collCfgRequiredPeerCount, collCfgMaximumPeerCount, collCfgBlockToLive)
+	require.NoError(t, err)
+
+	err = integration.InstallExamplePvtChaincode(orgsContext, ccID)
+	require.NoError(t, err)
+	err = integration.InstantiateExamplePvtChaincode(orgsContext, orgChannelID, ccID, "OR('Org1MSP.member','Org2MSP.member')", collConfig)
+	require.NoError(t, err)
+
+	org1AdminClientContext := sdk.Context(fabsdk.WithUser(org1AdminUser), fabsdk.WithOrg(org1Name))
+	client, err := resmgmt.New(org1AdminClientContext)
+	if err != nil {
+		t.Fatalf("Failed to create new resource management client: %s", err)
+	}
+
+	resp, err := client.QueryCollectionsConfig(orgChannelID, ccID)
+	if err != nil {
+		t.Fatalf("QueryCollectionsConfig return error: %s", err)
+	}
+	if len(resp.Config) != 1 {
+		t.Fatalf("The number of collection config is incorrect, expected 1, got %d", len(resp.Config))
+	}
+
+	conf := resp.Config[0]
+	switch cconf := conf.Payload.(type) {
+	case *cb.CollectionConfig_StaticCollectionConfig:
+		checkStaticCollectionConfig(t, cconf.StaticCollectionConfig)
+	default:
+		t.Fatalf("The CollectionConfig.Payload's type is incorrect, expected `CollectionConfig_StaticCollectionConfig`, got %+v", reflect.TypeOf(conf.Payload))
+	}
+}
+
+func checkStaticCollectionConfig(t *testing.T, collConf *cb.StaticCollectionConfig) {
+	if collConf.Name != collCfgName {
+		t.Fatalf("CollectionConfig'name is incorrect, expected collection1, got %s", collConf.Name)
+	}
+	if collConf.BlockToLive != collCfgBlockToLive {
+		t.Fatalf("The property of BlockToLive is incorrect, expected 1000, got %d", collConf.BlockToLive)
+	}
+	if collConf.RequiredPeerCount != collCfgRequiredPeerCount {
+		t.Fatalf("The property of RequiredPeerCount is incorrect, expected 0, got %d", collConf.RequiredPeerCount)
+	}
+	if collConf.MaximumPeerCount != collCfgMaximumPeerCount {
+		t.Fatalf("The property of MaximumPeerCount is incorrect, expected 2, got %d", collConf.MaximumPeerCount)
+	}
+	if collConf.MemberOrgsPolicy.GetSignaturePolicy() == nil {
+		t.Fatalf("The property of MemberOrgsPolicy must be SignaturePolicy")
+	}
+}
+
+func newCollectionConfig(colName, policy string, reqPeerCount, maxPeerCount int32, blockToLive uint64) (*cb.CollectionConfig, error) {
+	p, err := cauthdsl.FromString(policy)
+	if err != nil {
+		return nil, err
+	}
+	cpc := &cb.CollectionPolicyConfig{
+		Payload: &cb.CollectionPolicyConfig_SignaturePolicy{
+			SignaturePolicy: p,
+		},
+	}
+	return &cb.CollectionConfig{
+		Payload: &cb.CollectionConfig_StaticCollectionConfig{
+			StaticCollectionConfig: &cb.StaticCollectionConfig{
+				Name:              colName,
+				MemberOrgsPolicy:  cpc,
+				RequiredPeerCount: reqPeerCount,
+				MaximumPeerCount:  maxPeerCount,
+				BlockToLive:       blockToLive,
+			},
+		},
+	}, nil
+}