Query installed +lifecycle chaincodes from CLI

This CR adds the functionality to query chaincodes that
have been installed with +lifecycle. The name, version,
and hash for each installed chaincode will be printed.

FAB-11534 #done

Change-Id: Ib2a7a36f70e04ed4513d3c9a15815d9ea47b6304
Signed-off-by: Will Lahti <wtlahti@us.ibm.com>

Author: wlahti

core/common/ccprovider/ccprovider.go

@@ -346,8 +346,7 @@ func GetInstalledChaincodes() (*pb.ChaincodeQueryResponse, error) {
 			ccpack, err := GetChaincodeFromFS(ccname, ccversion)
 			if err != nil {
 				// either chaincode on filesystem has been tampered with or
-				// a non-chaincode file has been found in the chaincodes directory
-				ccproviderLogger.Errorf("Unreadable chaincode file found on filesystem: %s", file.Name())
+				// +lifecycle chaincode files exist in the chaincodes directory.
 				continue
 			}
 

peer/chaincode/list.go

@@ -17,6 +17,7 @@ import (
 	"github.com/golang/protobuf/proto"
 	cb "github.com/hyperledger/fabric/protos/common"
 	pb "github.com/hyperledger/fabric/protos/peer"
+	lb "github.com/hyperledger/fabric/protos/peer/lifecycle"
 	"github.com/hyperledger/fabric/protos/utils"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
@@ -26,7 +27,8 @@ var getInstalledChaincodes bool
 var getInstantiatedChaincodes bool
 var chaincodeListCmd *cobra.Command
 
-// installCmd returns the cobra command for Chaincode Deploy
+// listCmd returns the cobra command for listing
+// the installed or instantiated chaincodes
 func listCmd(cf *ChaincodeCmdFactory) *cobra.Command {
 	chaincodeListCmd = &cobra.Command{
 		Use:   "list",
@@ -44,6 +46,7 @@ func listCmd(cf *ChaincodeCmdFactory) *cobra.Command {
 		"peerAddresses",
 		"tlsRootCertFiles",
 		"connectionProfile",
+		"newLifecycle",
 	}
 	attachFlags(chaincodeListCmd, flagList)
 
@@ -71,52 +74,85 @@ func getChaincodes(cmd *cobra.Command, cf *ChaincodeCmdFactory) error {
 	}
 
 	var prop *pb.Proposal
-	if getInstalledChaincodes && (!getInstantiatedChaincodes) {
-		prop, _, err = utils.CreateGetInstalledChaincodesProposal(creator)
-	} else if getInstantiatedChaincodes && (!getInstalledChaincodes) {
+
+	if (getInstalledChaincodes && getInstantiatedChaincodes) || (!getInstalledChaincodes && !getInstantiatedChaincodes) {
+		return errors.New("must explicitly specify \"--installed\" or \"--instantiated\"")
+	}
+
+	if getInstalledChaincodes {
+		prop, err = getInstalledChaincodesProposal(newLifecycle, creator)
+	}
+
+	if getInstantiatedChaincodes {
 		prop, _, err = utils.CreateGetChaincodesProposal(channelID, creator)
-	} else {
-		return fmt.Errorf("Must explicitly specify \"--installed\" or \"--instantiated\"")
 	}
 
 	if err != nil {
-		return fmt.Errorf("Error creating proposal %s: %s", chainFuncName, err)
+		return errors.WithMessage(err, "error creating proposal")
 	}
 
 	var signedProp *pb.SignedProposal
 	signedProp, err = utils.GetSignedProposal(prop, cf.Signer)
 	if err != nil {
-		return fmt.Errorf("Error creating signed proposal  %s: %s", chainFuncName, err)
+		return errors.WithMessage(err, "error creating signed proposal")
 	}
 
 	// list is currently only supported for one peer
 	proposalResponse, err := cf.EndorserClients[0].ProcessProposal(context.Background(), signedProp)
 	if err != nil {
-		return errors.Errorf("Error endorsing %s: %s", chainFuncName, err)
+		return errors.WithMessage(err, "error endorsing proposal")
 	}
 
 	if proposalResponse.Response == nil {
-		return errors.Errorf("Proposal response had nil 'response'")
+		return errors.Errorf("proposal response had nil response")
 	}
 
 	if proposalResponse.Response.Status != int32(cb.Status_SUCCESS) {
-		return errors.Errorf("Bad response: %d - %s", proposalResponse.Response.Status, proposalResponse.Response.Message)
+		return errors.Errorf("bad response: %d - %s", proposalResponse.Response.Status, proposalResponse.Response.Message)
 	}
 
-	cqr := &pb.ChaincodeQueryResponse{}
-	err = proto.Unmarshal(proposalResponse.Response.Payload, cqr)
-	if err != nil {
-		return err
+	return printResponse(getInstalledChaincodes, proposalResponse)
+}
+
+// printResponse prints the information included in the response
+// from the server. If getInstalledChaincodes is set to false, the
+// proposal response will be interpreted as containing instantiated
+// chaincode information.
+func printResponse(getInstalledChaincodes bool, proposalResponse *pb.ProposalResponse) error {
+	var qicr *lb.QueryInstalledChaincodesResult
+	var cqr *pb.ChaincodeQueryResponse
+
+	if newLifecycle {
+		qicr = &lb.QueryInstalledChaincodesResult{}
+		err := proto.Unmarshal(proposalResponse.Response.Payload, qicr)
+		if err != nil {
+			return err
+		}
+	} else {
+		cqr = &pb.ChaincodeQueryResponse{}
+		err := proto.Unmarshal(proposalResponse.Response.Payload, cqr)
+		if err != nil {
+			return err
+		}
 	}
 
 	if getInstalledChaincodes {
 		fmt.Println("Get installed chaincodes on peer:")
 	} else {
 		fmt.Printf("Get instantiated chaincodes on channel %s:\n", channelID)
 	}
+
+	if qicr != nil {
+		for _, chaincode := range qicr.InstalledChaincodes {
+			fmt.Printf("Name: %s, Version: %s, Hash: %x\n", chaincode.Name, chaincode.Version, chaincode.Hash)
+		}
+		return nil
+	}
+
 	for _, chaincode := range cqr.Chaincodes {
 		fmt.Printf("%v\n", ccInfo{chaincode}.String())
 	}
+
 	return nil
 }
 
@@ -150,3 +186,35 @@ func (cci ccInfo) String() string {
 func isBytes(v reflect.Value) bool {
 	return v.Kind() == reflect.Slice && v.Type().Elem().Kind() == reflect.Uint8
 }
+
+func getInstalledChaincodesProposal(newLifecycle bool, creator []byte) (*pb.Proposal, error) {
+	if newLifecycle {
+		return createNewLifecycleQueryInstalledChaincodeProposal(creator)
+	}
+	proposal, _, err := utils.CreateGetInstalledChaincodesProposal(creator)
+	return proposal, err
+}
+
+func createNewLifecycleQueryInstalledChaincodeProposal(creatorBytes []byte) (*pb.Proposal, error) {
+	args := &lb.QueryInstalledChaincodesArgs{}
+
+	argsBytes, err := proto.Marshal(args)
+	if err != nil {
+		return nil, err
+	}
+	ccInput := &pb.ChaincodeInput{Args: [][]byte{[]byte("QueryInstalledChaincodes"), argsBytes}}
+
+	cis := &pb.ChaincodeInvocationSpec{
+		ChaincodeSpec: &pb.ChaincodeSpec{
+			ChaincodeId: &pb.ChaincodeID{Name: "+lifecycle"},
+			Input:       ccInput,
+		},
+	}
+
+	proposal, _, err := utils.CreateProposalFromCIS(cb.HeaderType_ENDORSER_TRANSACTION, "", cis, creatorBytes)
+	if err != nil {
+		return nil, errors.WithMessage(err, "error creating proposal for ChaincodeInvocationSpec")
+	}
+
+	return proposal, nil
+}

peer/chaincode/list_test.go

@@ -14,6 +14,7 @@ import (
 	"github.com/golang/protobuf/proto"
 	"github.com/hyperledger/fabric/peer/common"
 	pb "github.com/hyperledger/fabric/protos/peer"
+	lb "github.com/hyperledger/fabric/protos/peer/lifecycle"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -31,7 +32,7 @@ func TestChaincodeListCmd(t *testing.T) {
 	}
 	installedCqrBytes, err := proto.Marshal(installedCqr)
 	if err != nil {
-		t.Fatalf("Marshale error: %s", err)
+		t.Fatalf("Marshal error: %s", err)
 	}
 
 	mockResponse := &pb.ProposalResponse{
@@ -46,61 +47,99 @@ func TestChaincodeListCmd(t *testing.T) {
 		BroadcastClient: mockBroadcastClient,
 	}
 
-	// reset channelID, it might have been set by previous test
-	channelID = ""
-
-	// Get installed chaincodes
-	installedChaincodesCmd := listCmd(mockCF)
-
-	args := []string{"--installed"}
-	installedChaincodesCmd.SetArgs(args)
-	if err := installedChaincodesCmd.Execute(); err != nil {
-		t.Errorf("Run chaincode list cmd to get installed chaincodes error:%v", err)
-	}
-
-	resetFlags()
-
-	// Get instantiated chaincodes
-	instantiatedChaincodesCmd := listCmd(mockCF)
-	args = []string{"--instantiated"}
-	instantiatedChaincodesCmd.SetArgs(args)
-	err = instantiatedChaincodesCmd.Execute()
-	assert.Error(t, err, "Run chaincode list cmd to get instantiated chaincodes should fail if invoked without -C flag")
-
-	args = []string{"--instantiated", "-C", "mychannel"}
-	instantiatedChaincodesCmd.SetArgs(args)
-	if err := instantiatedChaincodesCmd.Execute(); err != nil {
-		t.Errorf("Run chaincode list cmd to get instantiated chaincodes error:%v", err)
-	}
-
-	resetFlags()
-
-	// Wrong case: Set both "--installed" and "--instantiated"
-	Cmd := listCmd(mockCF)
-	args = []string{"--installed", "--instantiated"}
-	Cmd.SetArgs(args)
-	err = Cmd.Execute()
-	assert.Error(t, err, "Run chaincode list cmd to get instantiated/installed chaincodes should fail if invoked without -C flag")
-
-	args = []string{"--installed", "--instantiated", "-C", "mychannel"}
-	Cmd.SetArgs(args)
-	expectErr := fmt.Errorf("Must explicitly specify \"--installed\" or \"--instantiated\"")
-	if err := Cmd.Execute(); err == nil || err.Error() != expectErr.Error() {
-		t.Errorf("Expect error: %s", expectErr)
-	}
-
-	resetFlags()
-
-	// Wrong case: Miss "--intsalled" and "--instantiated"
-	nilCmd := listCmd(mockCF)
-
-	args = []string{"-C", "mychannel"}
-	nilCmd.SetArgs(args)
-
-	expectErr = fmt.Errorf("Must explicitly specify \"--installed\" or \"--instantiated\"")
-	if err := nilCmd.Execute(); err == nil || err.Error() != expectErr.Error() {
-		t.Errorf("Expect error: %s", expectErr)
-	}
+	cmd := listCmd(mockCF)
+
+	t.Run("get installed chaincodes - legacy lscc", func(t *testing.T) {
+		resetFlags()
+
+		args := []string{"--installed"}
+		cmd.SetArgs(args)
+		if err := cmd.Execute(); err != nil {
+			t.Errorf("Run chaincode list cmd to get installed chaincodes error:%v", err)
+		}
+	})
+
+	t.Run("get installed chaincodes - +lifecycle", func(t *testing.T) {
+		resetFlags()
+		queryInstalledChaincodeResult := &lb.QueryInstalledChaincodesResult{
+			InstalledChaincodes: []*lb.QueryInstalledChaincodesResult_InstalledChaincode{
+				{Name: "test1", Version: "v1.0", Hash: []byte("hash1")},
+				{Name: "testcc2", Version: "v2.0", Hash: []byte("hash2")},
+			},
+		}
+		qicrBytes, err := proto.Marshal(queryInstalledChaincodeResult)
+		if err != nil {
+			t.Fatalf("Marshal error: %s", err)
+		}
+
+		mockResponse.Response = &pb.Response{Status: 200, Payload: qicrBytes}
+
+		args := []string{"--installed", "--newLifecycle"}
+		cmd.SetArgs(args)
+		if err := cmd.Execute(); err != nil {
+			t.Errorf("Run chaincode list cmd to get installed chaincodes error:%v", err)
+		}
+	})
+
+	t.Run("get instantiated chaincodes - no channel", func(t *testing.T) {
+		resetFlags()
+
+		args := []string{"--instantiated"}
+		cmd.SetArgs(args)
+		err = cmd.Execute()
+		assert.Error(t, err, "Run chaincode list cmd to get instantiated chaincodes should fail if invoked without -C flag")
+	})
+
+	t.Run("get instantiated chaincodes - no channel", func(t *testing.T) {
+		resetFlags()
+
+		args := []string{"--instantiated"}
+		cmd.SetArgs(args)
+		err = cmd.Execute()
+		assert.Error(t, err, "Run chaincode list cmd to get instantiated chaincodes should fail if invoked without -C flag")
+	})
+
+	t.Run("get instantiated chaincodes - success", func(t *testing.T) {
+		resetFlags()
+		instantiatedChaincodesCmd := listCmd(mockCF)
+		args := []string{"--instantiated", "-C", "mychannel"}
+		instantiatedChaincodesCmd.SetArgs(args)
+		if err := instantiatedChaincodesCmd.Execute(); err != nil {
+			t.Errorf("Run chaincode list cmd to get instantiated chaincodes error:%v", err)
+		}
+	})
+
+	t.Run("both --installed and --instantiated set - no channel", func(t *testing.T) {
+		resetFlags()
+
+		// Wrong case: Set both "--installed" and "--instantiated"
+		cmd = listCmd(mockCF)
+		args := []string{"--installed", "--instantiated"}
+		cmd.SetArgs(args)
+		err = cmd.Execute()
+		assert.Error(t, err, "Run chaincode list cmd to get instantiated/installed chaincodes should fail if invoked without -C flag")
+	})
+
+	t.Run("both --installed and --instantiated set - no channel", func(t *testing.T) {
+		resetFlags()
+		args := []string{"--installed", "--instantiated", "-C", "mychannel"}
+		cmd.SetArgs(args)
+		expectErr := fmt.Errorf("must explicitly specify \"--installed\" or \"--instantiated\"")
+		if err := cmd.Execute(); err == nil || err.Error() != expectErr.Error() {
+			t.Errorf("Expect error: %s", expectErr)
+		}
+	})
+
+	t.Run("neither --installed nor --instantiated set", func(t *testing.T) {
+		resetFlags()
+		args := []string{"-C", "mychannel"}
+		cmd.SetArgs(args)
+
+		expectErr := fmt.Errorf("must explicitly specify \"--installed\" or \"--instantiated\"")
+		if err := cmd.Execute(); err == nil || err.Error() != expectErr.Error() {
+			t.Errorf("Expect error: %s", expectErr)
+		}
+	})
 }
 
 func TestChaincodeListFailure(t *testing.T) {
@@ -132,7 +171,7 @@ func TestChaincodeListFailure(t *testing.T) {
 	instantiatedChaincodesCmd.SetArgs(args)
 	err = instantiatedChaincodesCmd.Execute()
 	assert.Error(t, err)
-	assert.Regexp(t, "Bad response: 500 - error message", err.Error())
+	assert.Regexp(t, "bad response: 500 - error message", err.Error())
 }
 
 func TestString(t *testing.T) {