[FAB-2033] Proto switch ChainHeader->ChannelHeader

https://jira.hyperledger.org/browse/FAB-2033

The user facing documentation refers to channels, but the vast majority
of the fabric code refers to chains.  This CR switches the protos to
refer to channels as they are generally the interface between the user
and fabric code.

Change-Id: I869e6d68c1228e638a99e2460274889f18f2543d
Signed-off-by: Jason Yellick <jyellick@us.ibm.com>

common/configtx/manager_test.go

@@ -77,7 +77,7 @@ func makeConfigItem(id, modificationPolicy string, lastModified uint64, data []b
 
 func makeMarshaledConfig(chainID string, configItems ...*cb.ConfigItem) []byte {
 	config := &cb.Config{
-		Header: &cb.ChainHeader{ChannelId: chainID},
+		Header: &cb.ChannelHeader{ChannelId: chainID},
 		Items:  configItems,
 	}
 	return utils.MarshalOrPanic(config)

common/configtx/template.go

@@ -97,7 +97,7 @@ func (st *simpleTemplate) Envelope(chainID string) (*cb.ConfigEnvelope, error) {
 	}
 
 	marshaledConfig, err := proto.Marshal(&cb.ConfigNext{
-		Header: &cb.ChainHeader{
+		Header: &cb.ChannelHeader{
 			ChannelId: chainID,
 			Type:      int32(cb.HeaderType_CONFIGURATION_ITEM),
 		},
@@ -172,7 +172,7 @@ func (ct *compositeTemplate) Envelope(chainID string) (*cb.ConfigEnvelope, error
 	}
 
 	marshaledConfig, err := proto.Marshal(&cb.ConfigNext{
-		Header: &cb.ChainHeader{
+		Header: &cb.ChannelHeader{
 			ChannelId: chainID,
 			Type:      int32(cb.HeaderType_CONFIGURATION_ITEM),
 		},
@@ -239,9 +239,9 @@ func MakeChainCreationTransaction(creationPolicy string, chainID string, signer
 		return nil, err
 	}
 
-	payloadChainHeader := utils.MakeChainHeader(cb.HeaderType_CONFIGURATION_TRANSACTION, msgVersion, chainID, epoch)
+	payloadChannelHeader := utils.MakeChannelHeader(cb.HeaderType_CONFIGURATION_TRANSACTION, msgVersion, chainID, epoch)
 	payloadSignatureHeader := utils.MakeSignatureHeader(sSigner, utils.CreateNonceOrPanic())
-	payloadHeader := utils.MakePayloadHeader(payloadChainHeader, payloadSignatureHeader)
+	payloadHeader := utils.MakePayloadHeader(payloadChannelHeader, payloadSignatureHeader)
 	payload := &cb.Payload{Header: payloadHeader, Data: utils.MarshalOrPanic(newConfigEnv)}
 	paylBytes := utils.MarshalOrPanic(payload)
 

common/genesis/genesis.go

@@ -48,9 +48,9 @@ func (f *factory) Block(chainID string) (*cb.Block, error) {
 		return nil, err
 	}
 
-	payloadChainHeader := utils.MakeChainHeader(cb.HeaderType_CONFIGURATION_TRANSACTION, msgVersion, chainID, epoch)
+	payloadChannelHeader := utils.MakeChannelHeader(cb.HeaderType_CONFIGURATION_TRANSACTION, msgVersion, chainID, epoch)
 	payloadSignatureHeader := utils.MakeSignatureHeader(nil, utils.CreateNonceOrPanic())
-	payloadHeader := utils.MakePayloadHeader(payloadChainHeader, payloadSignatureHeader)
+	payloadHeader := utils.MakePayloadHeader(payloadChannelHeader, payloadSignatureHeader)
 	payload := &cb.Payload{Header: payloadHeader, Data: utils.MarshalOrPanic(configEnv)}
 	envelope := &cb.Envelope{Payload: utils.MarshalOrPanic(payload), Signature: nil}
 

common/ledger/blkstorage/fsblkstorage/block_serialization.go

@@ -207,5 +207,5 @@ func extractTxID(txEnvelopBytes []byte) (string, error) {
 	if err != nil {
 		return "", nil
 	}
-	return txPayload.Header.ChainHeader.TxId, nil
+	return txPayload.Header.ChannelHeader.TxId, nil
 }

core/committer/txvalidator/txvalidator_test.go

@@ -75,7 +75,7 @@ func TestNewTxValidator_DuplicateTransactions(t *testing.T) {
 	// Create simeple endorsement transaction
 	payload := &common.Payload{
 		Header: &common.Header{
-			ChainHeader: &common.ChainHeader{
+			ChannelHeader: &common.ChannelHeader{
 				TxId:      "simple_txID", // Fake txID
 				Type:      int32(common.HeaderType_ENDORSER_TRANSACTION),
 				ChannelId: util2.GetTestChainID(),

core/committer/txvalidator/validator.go

@@ -118,17 +118,17 @@ func (v *txValidator) Validate(block *common.Block) error {
 					continue
 				}
 
-				chain := payload.Header.ChainHeader.ChannelId
+				chain := payload.Header.ChannelHeader.ChannelId
 				logger.Debug("Transaction is for chain %s", chain)
 
 				if !v.chainExists(chain) {
 					logger.Errorf("Dropping transaction for non-existent chain %s", chain)
 					continue
 				}
 
-				if common.HeaderType(payload.Header.ChainHeader.Type) == common.HeaderType_ENDORSER_TRANSACTION {
+				if common.HeaderType(payload.Header.ChannelHeader.Type) == common.HeaderType_ENDORSER_TRANSACTION {
 					// Check duplicate transactions
-					txID := payload.Header.ChainHeader.TxId
+					txID := payload.Header.ChannelHeader.TxId
 					if _, err := v.support.Ledger().GetTransactionByID(txID); err == nil {
 						logger.Warning("Duplicate transaction found, ", txID, ", skipping")
 						continue
@@ -141,7 +141,7 @@ func (v *txValidator) Validate(block *common.Block) error {
 						logger.Errorf("VSCCValidateTx for transaction txId = %s returned error %s", txID, err)
 						continue
 					}
-				} else if common.HeaderType(payload.Header.ChainHeader.Type) == common.HeaderType_CONFIGURATION_TRANSACTION {
+				} else if common.HeaderType(payload.Header.ChannelHeader.Type) == common.HeaderType_CONFIGURATION_TRANSACTION {
 					configEnvelope, err := configtx.UnmarshalConfigEnvelope(payload.Data)
 					if err != nil {
 						err := fmt.Errorf("Error unmarshaling config which passed initial validity checks: %s", err)
@@ -179,16 +179,16 @@ func (v *txValidator) Validate(block *common.Block) error {
 
 func (v *vsccValidatorImpl) VSCCValidateTx(payload *common.Payload, envBytes []byte) error {
 	// Chain ID
-	chainID := payload.Header.ChainHeader.ChannelId
+	chainID := payload.Header.ChannelHeader.ChannelId
 	if chainID == "" {
 		err := fmt.Errorf("transaction header does not contain an chain ID")
 		logger.Errorf("%s", err)
 		return err
 	}
 
 	// Get transaction id
-	txid := payload.Header.ChainHeader.TxId
-	logger.Info("[XXX remove me XXX] Transaction type,", common.HeaderType(payload.Header.ChainHeader.Type))
+	txid := payload.Header.ChannelHeader.TxId
+	logger.Info("[XXX remove me XXX] Transaction type,", common.HeaderType(payload.Header.ChannelHeader.Type))
 	if txid == "" {
 		err := fmt.Errorf("transaction header does not contain transaction ID")
 		logger.Errorf("%s", err)

core/common/validation/msgvalidation.go

@@ -78,7 +78,7 @@ func ValidateProposalMessage(signedProp *pb.SignedProposal) (*pb.Proposal, *comm
 	}
 
 	// validate the signature
-	err = checkSignatureFromCreator(hdr.SignatureHeader.Creator, signedProp.Signature, signedProp.ProposalBytes, hdr.ChainHeader.ChannelId)
+	err = checkSignatureFromCreator(hdr.SignatureHeader.Creator, signedProp.Signature, signedProp.ProposalBytes, hdr.ChannelHeader.ChannelId)
 	if err != nil {
 		return nil, nil, nil, err
 	}
@@ -88,7 +88,7 @@ func ValidateProposalMessage(signedProp *pb.SignedProposal) (*pb.Proposal, *comm
 	// TODO: perform a check against replay attacks
 
 	// continue the validation in a way that depends on the type specified in the header
-	switch common.HeaderType(hdr.ChainHeader.Type) {
+	switch common.HeaderType(hdr.ChannelHeader.Type) {
 	case common.HeaderType_CONFIGURATION_TRANSACTION:
 		//which the types are different the validation is the same
 		//viz, validate a proposal to a chaincode. If we need other
@@ -105,7 +105,7 @@ func ValidateProposalMessage(signedProp *pb.SignedProposal) (*pb.Proposal, *comm
 		return prop, hdr, chaincodeHdrExt, err
 	default:
 		//NOTE : we proably need a case
-		return nil, nil, nil, fmt.Errorf("Unsupported proposal type %d", common.HeaderType(hdr.ChainHeader.Type))
+		return nil, nil, nil, fmt.Errorf("Unsupported proposal type %d", common.HeaderType(hdr.ChannelHeader.Type))
 	}
 }
 
@@ -172,11 +172,11 @@ func validateSignatureHeader(sHdr *common.SignatureHeader) error {
 	return nil
 }
 
-// checks for a valid ChainHeader
-func validateChainHeader(cHdr *common.ChainHeader) error {
+// checks for a valid ChannelHeader
+func validateChannelHeader(cHdr *common.ChannelHeader) error {
 	// check for nil argument
 	if cHdr == nil {
-		return fmt.Errorf("Nil ChainHeader provided")
+		return fmt.Errorf("Nil ChannelHeader provided")
 	}
 
 	// validate the header type
@@ -186,7 +186,7 @@ func validateChainHeader(cHdr *common.ChainHeader) error {
 		return fmt.Errorf("invalid header type %s", common.HeaderType(cHdr.Type))
 	}
 
-	putilsLogger.Infof("validateChainHeader info: header type %d", common.HeaderType(cHdr.Type))
+	putilsLogger.Infof("validateChannelHeader info: header type %d", common.HeaderType(cHdr.Type))
 
 	// TODO: validate chainID in cHdr.ChainID
 
@@ -203,7 +203,7 @@ func validateCommonHeader(hdr *common.Header) error {
 		return fmt.Errorf("Nil header")
 	}
 
-	err := validateChainHeader(hdr.ChainHeader)
+	err := validateChannelHeader(hdr.ChannelHeader)
 	if err != nil {
 		return err
 	}
@@ -296,8 +296,8 @@ func validateEndorserTransaction(data []byte, hdr *common.Header) error {
 		}
 
 		// build the original header by stitching together
-		// the common ChainHeader and the per-action SignatureHeader
-		hdrOrig := &common.Header{ChainHeader: hdr.ChainHeader, SignatureHeader: sHdr}
+		// the common ChannelHeader and the per-action SignatureHeader
+		hdrOrig := &common.Header{ChannelHeader: hdr.ChannelHeader, SignatureHeader: sHdr}
 		hdrBytes, err := utils.GetBytesHeader(hdrOrig) // FIXME: here we hope that hdrBytes will be the same one that the endorser had
 		if err != nil {
 			return err
@@ -342,7 +342,7 @@ func ValidateTransaction(e *common.Envelope) (*common.Payload, error) {
 	}
 
 	// validate the signature in the envelope
-	err = checkSignatureFromCreator(payload.Header.SignatureHeader.Creator, e.Signature, e.Payload, payload.Header.ChainHeader.ChannelId)
+	err = checkSignatureFromCreator(payload.Header.SignatureHeader.Creator, e.Signature, e.Payload, payload.Header.ChannelHeader.ChannelId)
 	if err != nil {
 		return nil, err
 	}
@@ -352,7 +352,7 @@ func ValidateTransaction(e *common.Envelope) (*common.Payload, error) {
 	// TODO: perform a check against replay attacks
 
 	// continue the validation in a way that depends on the type specified in the header
-	switch common.HeaderType(payload.Header.ChainHeader.Type) {
+	switch common.HeaderType(payload.Header.ChannelHeader.Type) {
 	case common.HeaderType_ENDORSER_TRANSACTION:
 		err = validateEndorserTransaction(payload.Data, payload.Header)
 		putilsLogger.Infof("ValidateTransactionEnvelope returns err %s", err)
@@ -362,6 +362,6 @@ func ValidateTransaction(e *common.Envelope) (*common.Payload, error) {
 		putilsLogger.Infof("ValidateTransactionEnvelope returns err %s", err)
 		return payload, err
 	default:
-		return nil, fmt.Errorf("Unsupported transaction payload type %d", common.HeaderType(payload.Header.ChainHeader.Type))
+		return nil, fmt.Errorf("Unsupported transaction payload type %d", common.HeaderType(payload.Header.ChannelHeader.Type))
 	}
 }

core/deliverservice/blocksprovider/blocksprovider.go

@@ -178,7 +178,7 @@ func (b *blocksProviderImpl) seekOldest() error {
 	return b.client.Send(&common.Envelope{
 		Payload: utils.MarshalOrPanic(&common.Payload{
 			Header: &common.Header{
-				ChainHeader: &common.ChainHeader{
+				ChannelHeader: &common.ChannelHeader{
 					ChannelId: b.chainID,
 				},
 				SignatureHeader: &common.SignatureHeader{},
@@ -196,7 +196,7 @@ func (b *blocksProviderImpl) seekLatestFromCommitter(height uint64) error {
 	return b.client.Send(&common.Envelope{
 		Payload: utils.MarshalOrPanic(&common.Payload{
 			Header: &common.Header{
-				ChainHeader: &common.ChainHeader{
+				ChannelHeader: &common.ChannelHeader{
 					ChannelId: b.chainID,
 				},
 				SignatureHeader: &common.SignatureHeader{},

core/endorser/endorser.go

@@ -273,7 +273,7 @@ func (e *Endorser) ProcessProposal(ctx context.Context, signedProp *pb.SignedPro
 		return &pb.ProposalResponse{Response: &pb.Response{Status: 500, Message: err.Error()}}, err
 	}
 
-	chainID := hdr.ChainHeader.ChannelId
+	chainID := hdr.ChannelHeader.ChannelId
 
 	//chainless MSPs have "" chain name
 	ischainless := syscc.IsChainlessSysCC(hdrExt.ChaincodeId.Name)
@@ -290,7 +290,7 @@ func (e *Endorser) ProcessProposal(ctx context.Context, signedProp *pb.SignedPro
 
 	//TODO check for uniqueness of prop.TxID with ledger
 
-	txid := hdr.ChainHeader.TxId
+	txid := hdr.ChannelHeader.TxId
 	if txid == "" {
 		err = fmt.Errorf("Invalid txID")
 		return &pb.ProposalResponse{Response: &pb.Response{Status: 500, Message: err.Error()}}, err

core/ledger/kvledger/history/historydb/historyleveldb/historyleveldb.go

@@ -106,7 +106,7 @@ func (historyDB *historyDB) Commit(block *common.Block) error {
 			return err
 		}
 
-		if common.HeaderType(payload.Header.ChainHeader.Type) == common.HeaderType_ENDORSER_TRANSACTION {
+		if common.HeaderType(payload.Header.ChannelHeader.Type) == common.HeaderType_ENDORSER_TRANSACTION {
 
 			// extract actions from the envelope message
 			respPayload, err := putils.GetActionFromEnvelope(envBytes)

core/ledger/kvledger/history/historydb/historyleveldb/historyleveldb_query_executer.go

@@ -122,7 +122,7 @@ func getTxIDandKeyWriteValueFromTran(
 		return "", nil, err
 	}
 
-	txID := payload.Header.ChainHeader.TxId
+	txID := payload.Header.ChannelHeader.TxId
 
 	txRWSet := &rwset.TxReadWriteSet{}
 

core/ledger/kvledger/txmgmt/validator/statebasedval/state_based_validator.go

@@ -107,7 +107,7 @@ func (v *Validator) ValidateAndPrepareBatch(block *common.Block, doMVCCValidatio
 		}
 
 		valid := false
-		if common.HeaderType(payload.Header.ChainHeader.Type) == common.HeaderType_ENDORSER_TRANSACTION {
+		if common.HeaderType(payload.Header.ChannelHeader.Type) == common.HeaderType_ENDORSER_TRANSACTION {
 			txRWSet, err := v.validateEndorserTX(envBytes, doMVCCValidation, updates)
 			if err != nil {
 				return nil, err
@@ -118,13 +118,13 @@ func (v *Validator) ValidateAndPrepareBatch(block *common.Block, doMVCCValidatio
 				addWriteSetToBatch(txRWSet, committingTxHeight, updates)
 				valid = true
 			}
-		} else if common.HeaderType(payload.Header.ChainHeader.Type) == common.HeaderType_CONFIGURATION_TRANSACTION {
+		} else if common.HeaderType(payload.Header.ChannelHeader.Type) == common.HeaderType_CONFIGURATION_TRANSACTION {
 			valid, err = v.validateConfigTX(env)
 			if err != nil {
 				return nil, err
 			}
 		} else {
-			logger.Errorf("Skipping transaction %d that's not an endorsement or configuration %d", txIndex, payload.Header.ChainHeader.Type)
+			logger.Errorf("Skipping transaction %d that's not an endorsement or configuration %d", txIndex, payload.Header.ChannelHeader.Type)
 			valid = false
 		}
 

core/peer/peer.go

@@ -143,7 +143,7 @@ func getCurrConfigBlockFromLedger(ledger ledger.PeerLedger) (*common.Block, erro
 				currBlockNumber = block.Header.Number - 1
 				continue
 			}
-			if tx.Header.ChainHeader.Type == int32(common.HeaderType_CONFIGURATION_TRANSACTION) {
+			if tx.Header.ChannelHeader.Type == int32(common.HeaderType_CONFIGURATION_TRANSACTION) {
 				return block, nil
 			}
 		}

core/scc/cscc/configer_test.go

@@ -234,6 +234,6 @@ func getChainID(blockBytes []byte) (string, error) {
 	if err := proto.Unmarshal(envelope.Payload, payload); err != nil {
 		return "", err
 	}
-	fmt.Printf("chain id: %v\n", payload.Header.ChainHeader.ChannelId)
-	return payload.Header.ChainHeader.ChannelId, nil
+	fmt.Printf("Channel id: %v\n", payload.Header.ChannelHeader.ChannelId)
+	return payload.Header.ChannelHeader.ChannelId, nil
 }

core/scc/vscc/validator_onevalidsignature.go

@@ -86,7 +86,7 @@ func (vscc *ValidatorOneValidSignature) Invoke(stub shim.ChaincodeStubInterface)
 	}
 
 	// get the policy
-	mgr := mspmgmt.GetManagerForChain(payl.Header.ChainHeader.ChannelId)
+	mgr := mspmgmt.GetManagerForChain(payl.Header.ChannelHeader.ChannelId)
 	pProvider := cauthdsl.NewPolicyProvider(mgr)
 	policy, err := pProvider.NewPolicy(args[2])
 	if err != nil {
@@ -95,9 +95,9 @@ func (vscc *ValidatorOneValidSignature) Invoke(stub shim.ChaincodeStubInterface)
 	}
 
 	// validate the payload type
-	if common.HeaderType(payl.Header.ChainHeader.Type) != common.HeaderType_ENDORSER_TRANSACTION {
-		logger.Errorf("Only Endorser Transactions are supported, provided type %d", payl.Header.ChainHeader.Type)
-		return shim.Error(fmt.Sprintf("Only Endorser Transactions are supported, provided type %d", payl.Header.ChainHeader.Type))
+	if common.HeaderType(payl.Header.ChannelHeader.Type) != common.HeaderType_ENDORSER_TRANSACTION {
+		logger.Errorf("Only Endorser Transactions are supported, provided type %d", payl.Header.ChannelHeader.Type)
+		return shim.Error(fmt.Sprintf("Only Endorser Transactions are supported, provided type %d", payl.Header.ChannelHeader.Type))
 	}
 
 	// ...and the transaction...

events/events_test.go

@@ -84,15 +84,15 @@ func (a *Adapter) Disconnected(err error) {
 }
 
 func createTestBlock(t *testing.T) *common.Block {
-	chdr := &common.ChainHeader{
+	chdr := &common.ChannelHeader{
 		Type:    int32(common.HeaderType_ENDORSER_TRANSACTION),
 		Version: 1,
 		Timestamp: &timestamp.Timestamp{
 			Seconds: time.Now().Unix(),
 			Nanos:   0,
 		},
 		ChannelId: "test"}
-	hdr := &common.Header{ChainHeader: chdr}
+	hdr := &common.Header{ChannelHeader: chdr}
 	payload := &common.Payload{Header: hdr}
 	cea := &ehpb.ChaincodeEndorsedAction{}
 	ccaPayload := &ehpb.ChaincodeActionPayload{Action: cea}

events/producer/eventhelper.go

@@ -49,7 +49,7 @@ func SendProducerBlockEvent(block *common.Block) error {
 					return fmt.Errorf("Could not extract payload from envelope, err %s", err)
 				}
 
-				if common.HeaderType(payload.Header.ChainHeader.Type) == common.HeaderType_ENDORSER_TRANSACTION {
+				if common.HeaderType(payload.Header.ChannelHeader.Type) == common.HeaderType_ENDORSER_TRANSACTION {
 					tx, err := utils.GetTransaction(payload.Data)
 					if err != nil {
 						return fmt.Errorf("Error unmarshalling transaction payload for block event: %s", err)

examples/events/block-listener/block-listener.go

@@ -99,7 +99,7 @@ func getChainCodeEvents(tdata []byte) (*pb.ChaincodeEvent, error) {
 			return nil, fmt.Errorf("Could not extract payload from envelope, err %s", err)
 		}
 
-		if common.HeaderType(payload.Header.ChainHeader.Type) == common.HeaderType_ENDORSER_TRANSACTION {
+		if common.HeaderType(payload.Header.ChannelHeader.Type) == common.HeaderType_ENDORSER_TRANSACTION {
 			tx, err := utils.GetTransaction(payload.Data)
 			if err != nil {
 				return nil, fmt.Errorf("Error unmarshalling transaction payload for block event: %s", err)
@@ -158,7 +158,7 @@ func main() {
 						fmt.Printf("\n")
 						fmt.Printf("Received invalid transaction\n")
 						fmt.Printf("--------------\n")
-						fmt.Printf("Transaction invalid: TxID: %s\n", tx.Header.ChainHeader.TxId)
+						fmt.Printf("Transaction invalid: TxID: %s\n", tx.Header.ChannelHeader.TxId)
 					}
 				} else {
 					fmt.Printf("Transaction:\n\t[%v]\n", r)