[FAB-1516] committer side upgrade processing Part I

This CR focuses on invalidating all transactions which
are "invokes" to upgraded chaincodes in the same block.
Invalid expired transactions in other blocks will be done
as part II. Some envelop unpacking works are duplicate
for logic part to be tested easier.

Change-Id: Iea7d1d29a1927e73973319ce088b1435f9ff8b55
Signed-off-by: jiangyaoguo <[email protected]>

Author: jiangyaoguo

core/committer/txvalidator/txvalidator_test.go

@@ -24,8 +24,12 @@ import (
 	util2 "github.com/hyperledger/fabric/common/util"
 	"github.com/hyperledger/fabric/core/ledger/ledgermgmt"
 	"github.com/hyperledger/fabric/core/ledger/util"
+	ledgerUtil "github.com/hyperledger/fabric/core/ledger/util"
 	mocktxvalidator "github.com/hyperledger/fabric/core/mocks/txvalidator"
 	"github.com/hyperledger/fabric/core/mocks/validator"
+	"github.com/hyperledger/fabric/msp"
+	mspmgmt "github.com/hyperledger/fabric/msp/mgmt"
+	msptesttools "github.com/hyperledger/fabric/msp/mgmt/testtools"
 	"github.com/hyperledger/fabric/protos/common"
 	"github.com/hyperledger/fabric/protos/peer"
 	"github.com/hyperledger/fabric/protos/utils"
@@ -70,7 +74,7 @@ func TestNewTxValidator_DuplicateTransactions(t *testing.T) {
 
 	tValidator := &txValidator{&mocktxvalidator.Support{LedgerVal: ledger}, &validator.MockVsccValidator{}}
 
-	// Create simeple endorsement transaction
+	// Create simple endorsement transaction
 	payload := &common.Payload{
 		Header: &common.Header{
 			ChannelHeader: utils.MarshalOrPanic(&common.ChannelHeader{
@@ -121,3 +125,120 @@ func TestNewTxValidator_DuplicateTransactions(t *testing.T) {
 	txsfltr := util.TxValidationFlags(block.Metadata.Metadata[common.BlockMetadataIndex_TRANSACTIONS_FILTER])
 	assert.True(t, txsfltr.IsInvalid(0))
 }
+
+func createCCUpgradeEnvelope(chainID, chaincodeName, chaincodeVersion string, signer msp.SigningIdentity) (*common.Envelope, error) {
+	creator, err := signer.Serialize()
+	if err != nil {
+		return nil, err
+	}
+
+	spec := &peer.ChaincodeSpec{
+		Type: peer.ChaincodeSpec_Type(peer.ChaincodeSpec_Type_value["GOLANG"]),
+		ChaincodeId: &peer.ChaincodeID{
+			Path:    "github.com/codePath",
+			Name:    chaincodeName,
+			Version: chaincodeVersion,
+		},
+	}
+
+	cds := &peer.ChaincodeDeploymentSpec{ChaincodeSpec: spec, CodePackage: []byte{}}
+	prop, _, err := utils.CreateUpgradeProposalFromCDS(chainID, cds, creator, []byte{}, []byte{}, []byte{})
+	if err != nil {
+		return nil, err
+	}
+
+	proposalResponse := &peer.ProposalResponse{
+		Response: &peer.Response{
+			Status: 200, // endorsed successfully
+		},
+		Endorsement: &peer.Endorsement{},
+	}
+
+	return utils.CreateSignedTx(prop, signer, proposalResponse)
+}
+
+func TestGetTxCCInstance(t *testing.T) {
+	// setup the MSP manager so that we can sign/verify
+	mspMgrConfigDir := "../../../msp/sampleconfig/"
+	err := msptesttools.LoadMSPSetupForTesting(mspMgrConfigDir)
+	if err != nil {
+		t.Fatalf("Could not initialize msp, err: %s", err)
+	}
+	signer, err := mspmgmt.GetLocalMSP().GetDefaultSigningIdentity()
+	if err != nil {
+		t.Fatalf("Could not initialize signer, err: %s", err)
+	}
+
+	chainID := util2.GetTestChainID()
+	upgradeCCName := "mycc"
+	upgradeCCVersion := "v1"
+
+	env, err := createCCUpgradeEnvelope(chainID, upgradeCCName, upgradeCCVersion, signer)
+	assert.NoError(t, err)
+
+	// get the payload from the envelope
+	payload, err := utils.GetPayload(env)
+	assert.NoError(t, err)
+
+	expectInvokeCCIns := &ChaincodeInstance{
+		ChainID:          chainID,
+		ChaincodeName:    "lscc",
+		ChaincodeVersion: "",
+	}
+	expectUpgradeCCIns := &ChaincodeInstance{
+		ChainID:          chainID,
+		ChaincodeName:    upgradeCCName,
+		ChaincodeVersion: upgradeCCVersion,
+	}
+
+	tValidator := &txValidator{}
+	invokeCCIns, upgradeCCIns, err := tValidator.getTxCCInstance(payload)
+	if err != nil {
+		t.Fatalf("Get chaincode from tx error: %s", err)
+	}
+	assert.EqualValues(t, expectInvokeCCIns, invokeCCIns)
+	assert.EqualValues(t, expectUpgradeCCIns, upgradeCCIns)
+}
+
+func TestInvalidTXsForUpgradeCC(t *testing.T) {
+	txsChaincodeNames := map[int]*ChaincodeInstance{
+		0: &ChaincodeInstance{"chain0", "cc0", "v0"}, // invoke cc0/chain0:v0, should not be affected by upgrade tx in other chain
+		1: &ChaincodeInstance{"chain1", "cc0", "v0"}, // invoke cc0/chain1:v0, should be invalided by cc1/chain1 upgrade tx
+		2: &ChaincodeInstance{"chain1", "lscc", ""},  // upgrade cc0/chain1 to v1, should be invalided by latter cc0/chain1 upgtade tx
+		3: &ChaincodeInstance{"chain1", "cc0", "v0"}, // invoke cc0/chain1:v0, should be invalided by cc1/chain1 upgrade tx
+		4: &ChaincodeInstance{"chain1", "cc0", "v1"}, // invoke cc0/chain1:v1, should be invalided by cc1/chain1 upgrade tx
+		5: &ChaincodeInstance{"chain1", "cc1", "v0"}, // invoke cc1/chain1:v0, should not be affected by other chaincode upgrade tx
+		6: &ChaincodeInstance{"chain1", "lscc", ""},  // upgrade cc0/chain1 to v2, should be invalided by latter cc0/chain1 upgtade tx
+		7: &ChaincodeInstance{"chain1", "lscc", ""},  // upgrade cc0/chain1 to v3
+	}
+	upgradedChaincodes := map[int]*ChaincodeInstance{
+		2: &ChaincodeInstance{"chain1", "cc0", "v1"},
+		6: &ChaincodeInstance{"chain1", "cc0", "v2"},
+		7: &ChaincodeInstance{"chain1", "cc0", "v3"},
+	}
+
+	txsfltr := ledgerUtil.NewTxValidationFlags(8)
+	txsfltr.SetFlag(0, peer.TxValidationCode_VALID)
+	txsfltr.SetFlag(1, peer.TxValidationCode_VALID)
+	txsfltr.SetFlag(2, peer.TxValidationCode_VALID)
+	txsfltr.SetFlag(3, peer.TxValidationCode_VALID)
+	txsfltr.SetFlag(4, peer.TxValidationCode_VALID)
+	txsfltr.SetFlag(5, peer.TxValidationCode_VALID)
+	txsfltr.SetFlag(6, peer.TxValidationCode_VALID)
+	txsfltr.SetFlag(7, peer.TxValidationCode_VALID)
+
+	expectTxsFltr := ledgerUtil.NewTxValidationFlags(8)
+	expectTxsFltr.SetFlag(0, peer.TxValidationCode_VALID)
+	expectTxsFltr.SetFlag(1, peer.TxValidationCode_EXPIRED_CHAINCODE)
+	expectTxsFltr.SetFlag(2, peer.TxValidationCode_EXPIRED_CHAINCODE)
+	expectTxsFltr.SetFlag(3, peer.TxValidationCode_EXPIRED_CHAINCODE)
+	expectTxsFltr.SetFlag(4, peer.TxValidationCode_EXPIRED_CHAINCODE)
+	expectTxsFltr.SetFlag(5, peer.TxValidationCode_VALID)
+	expectTxsFltr.SetFlag(6, peer.TxValidationCode_EXPIRED_CHAINCODE)
+	expectTxsFltr.SetFlag(7, peer.TxValidationCode_VALID)
+
+	tValidator := &txValidator{}
+	finalfltr := tValidator.invalidTXsForUpgradeCC(txsChaincodeNames, upgradedChaincodes, txsfltr)
+
+	assert.EqualValues(t, expectTxsFltr, finalfltr)
+}

core/committer/txvalidator/validator.go

@@ -104,11 +104,22 @@ func (v *txValidator) chainExists(chain string) bool {
 	return true
 }
 
+// ChaincodeInstance is unique identifier of chaincode instance
+type ChaincodeInstance struct {
+	ChainID          string
+	ChaincodeName    string
+	ChaincodeVersion string
+}
+
 func (v *txValidator) Validate(block *common.Block) error {
 	logger.Debug("START Block Validation")
 	defer logger.Debug("END Block Validation")
 	// Initialize trans as valid here, then set invalidation reason code upon invalidation below
 	txsfltr := ledgerUtil.NewTxValidationFlags(len(block.Data.Data))
+	// txsChaincodeNames records all the invoked chaincodes by tx in a block
+	txsChaincodeNames := make(map[int]*ChaincodeInstance)
+	// upgradedChaincodes records all the chaincodes that are upgrded in a block
+	txsUpgradedChaincodes := make(map[int]*ChaincodeInstance)
 	for tIdx, d := range block.Data.Data {
 		if d != nil {
 			if env, err := utils.GetEnvelopeFromBlock(d); err != nil {
@@ -164,6 +175,18 @@ func (v *txValidator) Validate(block *common.Block) error {
 						txsfltr.SetFlag(tIdx, peer.TxValidationCode_ENDORSEMENT_POLICY_FAILURE)
 						continue
 					}
+
+					invokeCC, upgradeCC, err := v.getTxCCInstance(payload)
+					if err != nil {
+						logger.Errorf("VSCCValidateTx for transaction txId = %s returned error %s", txID, err)
+						txsfltr.SetFlag(tIdx, peer.TxValidationCode_ENDORSEMENT_POLICY_FAILURE)
+						continue
+					}
+					txsChaincodeNames[tIdx] = invokeCC
+					if upgradeCC != nil {
+						logger.Infof("Find chaincode upgrade transaction for chaincode %s on chain %s with new version %s", upgradeCC.ChaincodeName, upgradeCC.ChainID, upgradeCC.ChaincodeVersion)
+						txsUpgradedChaincodes[tIdx] = upgradeCC
+					}
 				} else if common.HeaderType(chdr.Type) == common.HeaderType_CONFIG {
 					configEnvelope, err := configtx.UnmarshalConfigEnvelope(payload.Data)
 					if err != nil {
@@ -193,6 +216,9 @@ func (v *txValidator) Validate(block *common.Block) error {
 			}
 		}
 	}
+
+	txsfltr = v.invalidTXsForUpgradeCC(txsChaincodeNames, txsUpgradedChaincodes, txsfltr)
+
 	// Initialize metadata structure
 	utils.InitBlockMetadata(block)
 
@@ -201,6 +227,137 @@ func (v *txValidator) Validate(block *common.Block) error {
 	return nil
 }
 
+// generateCCKey generates a unique identifier for chaincode in specific chain
+func (v *txValidator) generateCCKey(ccName, chainID string) string {
+	return fmt.Sprintf("%s/%s", ccName, chainID)
+}
+
+// invalidTXsForUpgradeCC invalid all txs that should be invalided because of chaincode upgrade txs
+func (v *txValidator) invalidTXsForUpgradeCC(txsChaincodeNames map[int]*ChaincodeInstance, txsUpgradedChaincodes map[int]*ChaincodeInstance, txsfltr ledgerUtil.TxValidationFlags) ledgerUtil.TxValidationFlags {
+	if len(txsUpgradedChaincodes) == 0 {
+		return txsfltr
+	}
+
+	// Invalid former cc upgrade txs if there're two or more txs upgrade the same cc
+	finalValidUpgradeTXs := make(map[string]int)
+	upgradedChaincodes := make(map[string]*ChaincodeInstance)
+	for tIdx, cc := range txsUpgradedChaincodes {
+		if cc == nil {
+			continue
+		}
+		upgradedCCKey := v.generateCCKey(cc.ChaincodeName, cc.ChainID)
+
+		if finalIdx, exist := finalValidUpgradeTXs[upgradedCCKey]; !exist {
+			finalValidUpgradeTXs[upgradedCCKey] = tIdx
+			upgradedChaincodes[upgradedCCKey] = cc
+		} else if finalIdx < tIdx {
+			logger.Infof("Invalid transaction with index %d: chaincode was upgraded by latter tx", finalIdx)
+			txsfltr.SetFlag(finalIdx, peer.TxValidationCode_EXPIRED_CHAINCODE)
+
+			// record latter cc upgrade tx info
+			finalValidUpgradeTXs[upgradedCCKey] = tIdx
+			upgradedChaincodes[upgradedCCKey] = cc
+		} else {
+			logger.Infof("Invalid transaction with index %d: chaincode was upgraded by latter tx", tIdx)
+			txsfltr.SetFlag(tIdx, peer.TxValidationCode_EXPIRED_CHAINCODE)
+		}
+	}
+
+	// invalid txs which invoke the upgraded chaincodes
+	for tIdx, cc := range txsChaincodeNames {
+		if cc == nil {
+			continue
+		}
+		ccKey := v.generateCCKey(cc.ChaincodeName, cc.ChainID)
+		if _, exist := upgradedChaincodes[ccKey]; exist {
+			if txsfltr.IsValid(tIdx) {
+				logger.Infof("Invalid transaction with index %d: chaincode was upgraded in the same block", tIdx)
+				txsfltr.SetFlag(tIdx, peer.TxValidationCode_EXPIRED_CHAINCODE)
+			}
+		}
+	}
+
+	return txsfltr
+}
+
+func (v *txValidator) getTxCCInstance(payload *common.Payload) (invokeCCIns, upgradeCCIns *ChaincodeInstance, err error) {
+	// This is duplicated unpacking work, but make test easier.
+	chdr, err := utils.UnmarshalChannelHeader(payload.Header.ChannelHeader)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// Chain ID
+	chainID := chdr.ChannelId
+	if chainID == "" {
+		err := fmt.Errorf("transaction header does not contain an chain ID")
+		logger.Errorf("%s", err)
+		return nil, nil, err
+	}
+
+	// ChaincodeID
+	hdrExt, err := utils.GetChaincodeHeaderExtension(payload.Header)
+	if err != nil {
+		return nil, nil, err
+	}
+	invokeCC := hdrExt.ChaincodeId
+	invokeIns := &ChaincodeInstance{ChainID: chainID, ChaincodeName: invokeCC.Name, ChaincodeVersion: invokeCC.Version}
+
+	// Transaction
+	tx, err := utils.GetTransaction(payload.Data)
+	if err != nil {
+		logger.Errorf("GetTransaction failed: %s", err)
+		return invokeIns, nil, nil
+	}
+
+	// ChaincodeActionPayload
+	cap, err := utils.GetChaincodeActionPayload(tx.Actions[0].Payload)
+	if err != nil {
+		logger.Errorf("GetChaincodeActionPayload failed: %s", err)
+		return invokeIns, nil, nil
+	}
+
+	// ChaincodeProposalPayload
+	cpp, err := utils.GetChaincodeProposalPayload(cap.ChaincodeProposalPayload)
+	if err != nil {
+		logger.Errorf("GetChaincodeProposalPayload failed: %s", err)
+		return invokeIns, nil, nil
+	}
+
+	// ChaincodeInvocationSpec
+	cis := &peer.ChaincodeInvocationSpec{}
+	err = proto.Unmarshal(cpp.Input, cis)
+	if err != nil {
+		logger.Errorf("GetChaincodeInvokeSpec failed: %s", err)
+		return invokeIns, nil, nil
+	}
+
+	if invokeCC.Name == "lscc" {
+		if string(cis.ChaincodeSpec.Input.Args[0]) == "upgrade" {
+			upgradeIns, err := v.getUpgradeTxInstance(chainID, cis.ChaincodeSpec.Input.Args[2])
+			if err != nil {
+				return invokeIns, nil, nil
+			}
+			return invokeIns, upgradeIns, nil
+		}
+	}
+
+	return invokeIns, nil, nil
+}
+
+func (v *txValidator) getUpgradeTxInstance(chainID string, cdsBytes []byte) (*ChaincodeInstance, error) {
+	cds, err := utils.GetChaincodeDeploymentSpec(cdsBytes)
+	if err != nil {
+		return nil, err
+	}
+
+	return &ChaincodeInstance{
+		ChainID:          chainID,
+		ChaincodeName:    cds.ChaincodeSpec.ChaincodeId.Name,
+		ChaincodeVersion: cds.ChaincodeSpec.ChaincodeId.Version,
+	}, nil
+}
+
 func (v *vsccValidatorImpl) VSCCValidateTx(payload *common.Payload, envBytes []byte, env *common.Envelope) error {
 	// get channel header
 	chdr, err := utils.UnmarshalChannelHeader(payload.Header.ChannelHeader)