[FAB-8422] Refactor broadcast to sign proposal

This change moves signing of broadcasts to the
broadcast method.

Change-Id: I0af49bcce888c8213baeb372fa0f6444c3baf6c5
Signed-off-by: Troy Ronda <troy@troyronda.com>

Author: troyronda

api/apifabclient/resource.go

@@ -40,10 +40,6 @@ type CreateChannelRequest struct {
 	// required by the channel create policy when using the `config` parameter.
 	// see signChannelConfig() method of this package
 	Signatures []*common.ConfigSignature
-
-	// TODO: InvokeChannelRequest allows the TransactionID to be passed in.
-	// This request struct also has the field for consistency but perhaps it should be removed.
-	TxnID TransactionID
 }
 
 // InstallChaincodeRequest requests chaincode installation on the network

pkg/fabric-client/channel/block.go

@@ -71,22 +71,12 @@ func (c *Channel) block(pos *ab.SeekPosition) (*common.Block, error) {
 		return nil, errors.Wrap(err, "marshal seek info failed")
 	}
 
-	seekPayload := &common.Payload{
+	payload := common.Payload{
 		Header: seekHeader,
 		Data:   seekInfoBytes,
 	}
 
-	seekPayloadBytes, err := proto.Marshal(seekPayload)
-	if err != nil {
-		return nil, err
-	}
-
-	signedEnvelope, err := txn.SignPayload(c.clientContext, seekPayloadBytes)
-	if err != nil {
-		return nil, errors.WithMessage(err, "SignPayload failed")
-	}
-
-	return txn.SendEnvelope(c.clientContext, signedEnvelope, c.Orderers())
+	return txn.SendPayload(c.clientContext, &payload, c.Orderers())
 }
 
 // newNewestSeekPosition returns a SeekPosition that requests the newest block

pkg/fabric-client/resource/resource.go

@@ -21,7 +21,6 @@ import (
 	"github.com/hyperledger/fabric-sdk-go/pkg/logging"
 	"github.com/hyperledger/fabric-sdk-go/third_party/github.com/hyperledger/fabric/protos/common"
 	pb "github.com/hyperledger/fabric-sdk-go/third_party/github.com/hyperledger/fabric/protos/peer"
-	protos_utils "github.com/hyperledger/fabric-sdk-go/third_party/github.com/hyperledger/fabric/protos/utils"
 )
 
 var logger = logging.NewLogger("fabric_sdk_go")
@@ -70,21 +69,47 @@ func (c *Resource) SignChannelConfig(config []byte, signer fab.IdentityContext)
 
 // CreateChannel calls the orderer to start building the new channel.
 func (c *Resource) CreateChannel(request fab.CreateChannelRequest) (fab.TransactionID, error) {
-	haveEnvelope := false
+	if request.Orderer == nil {
+		return fab.TransactionID{}, errors.New("missing orderer request parameter for the initialize channel")
+	}
+
+	if request.Name == "" {
+		return fab.TransactionID{}, errors.New("missing name request parameter for the new channel")
+	}
+
 	if request.Envelope != nil {
-		logger.Debug("createChannel - have envelope")
-		haveEnvelope = true
+		return c.createChannelFromEnvelope(request)
 	}
 
-	if !haveEnvelope && request.TxnID.ID == "" {
-		txnID, err := txn.NewID(c.clientContext)
-		if err != nil {
-			return txnID, err
-		}
-		request.TxnID = txnID
+	if request.Config == nil {
+		return fab.TransactionID{}, errors.New("missing envelope request parameter containing the configuration of the new channel")
 	}
 
-	return request.TxnID, c.createOrUpdateChannel(request, haveEnvelope)
+	if request.Signatures == nil {
+		return fab.TransactionID{}, errors.New("missing signatures request parameter for the new channel")
+	}
+
+	txnID, err := txn.NewID(c.clientContext)
+	if err != nil {
+		return txnID, err
+	}
+
+	return txnID, c.createOrUpdateChannel(txnID, request)
+}
+
+// TODO: this function was extracted from createOrUpdateChannel, but needs a closer examination.
+func (c *Resource) createChannelFromEnvelope(request fab.CreateChannelRequest) (fab.TransactionID, error) {
+	env, err := c.extractSignedEnvelope(request.Envelope)
+	if err != nil {
+		return fab.TransactionID{}, errors.WithMessage(err, "signed envelope not valid")
+	}
+
+	// Send request
+	_, err = request.Orderer.SendBroadcast(env)
+	if err != nil {
+		return fab.TransactionID{}, errors.WithMessage(err, "failed broadcast to orderer")
+	}
+	return fab.TransactionID{}, nil
 }
 
 // GenesisBlockFromOrderer returns the genesis block from the defined orderer that may be
@@ -107,6 +132,10 @@ func (c *Resource) GenesisBlockFromOrderer(channelName string, orderer fab.Order
 		Stop:     seekStop,
 		Behavior: ab.SeekInfo_BLOCK_UNTIL_READY,
 	}
+	seekInfoBytes, err := proto.Marshal(seekInfo)
+	if err != nil {
+		return nil, errors.Wrap(err, "marshaling of seek info header failed")
+	}
 
 	tlsCertHash := ccomm.TLSCertHash(c.clientContext.Config())
 	channelHeaderOpts := txn.ChannelHeaderOpts{
@@ -116,24 +145,15 @@ func (c *Resource) GenesisBlockFromOrderer(channelName string, orderer fab.Order
 	}
 	seekInfoHeader, err := txn.CreateChannelHeader(common.HeaderType_DELIVER_SEEK_INFO, channelHeaderOpts)
 	if err != nil {
-		return nil, errors.Wrap(err, "BuildChannelHeader failed")
-	}
-	seekHeader, err := txn.CreateHeader(c.clientContext, seekInfoHeader, txnID)
-	if err != nil {
-		return nil, errors.Wrap(err, "BuildHeader failed")
-	}
-	seekPayload := &common.Payload{
-		Header: seekHeader,
-		Data:   protos_utils.MarshalOrPanic(seekInfo),
+		return nil, errors.Wrap(err, "CreateChannelHeader failed")
 	}
-	seekPayloadBytes := protos_utils.MarshalOrPanic(seekPayload)
 
-	signedEnvelope, err := txn.SignPayload(c.clientContext, seekPayloadBytes)
+	payload, err := txn.CreatePayload(txnID, seekInfoHeader, seekInfoBytes)
 	if err != nil {
-		return nil, errors.WithMessage(err, "SignPayload failed")
+		return nil, errors.Wrap(err, "CreatePayload failed")
 	}
 
-	block, err := txn.SendEnvelope(c.clientContext, signedEnvelope, orderers)
+	block, err := txn.SendPayload(c.clientContext, payload, orderers)
 	if err != nil {
 		return nil, errors.WithMessage(err, "SendEnvelope failed")
 	}
@@ -168,101 +188,50 @@ func (c *Resource) JoinChannel(request fab.JoinChannelRequest) error {
 	return err
 }
 
-// createOrUpdateChannel creates a new channel or updates an existing channel.
-func (c *Resource) createOrUpdateChannel(request fab.CreateChannelRequest, haveEnvelope bool) error {
-	// Validate request
-	if request.Config == nil && !haveEnvelope {
-		return errors.New("missing envelope request parameter containing the configuration of the new channel")
+func (c *Resource) extractSignedEnvelope(reqEnvelope []byte) (*fab.SignedEnvelope, error) {
+	envelope := &common.Envelope{}
+	err := proto.Unmarshal(reqEnvelope, envelope)
+	if err != nil {
+		return nil, errors.Wrap(err, "unmarshal request envelope failed")
 	}
-
-	if request.Signatures == nil && !haveEnvelope {
-		return errors.New("missing signatures request parameter for the new channel")
+	se := fab.SignedEnvelope{
+		Signature: envelope.Signature,
+		Payload:   envelope.Payload,
 	}
+	return &se, nil
+}
 
-	if request.TxnID.ID == "" && !haveEnvelope {
-		return errors.New("txId required")
-	}
+// createOrUpdateChannel creates a new channel or updates an existing channel.
+func (c *Resource) createOrUpdateChannel(txnID fab.TransactionID, request fab.CreateChannelRequest) error {
 
-	if request.TxnID.Nonce == nil && !haveEnvelope {
-		return errors.New("nonce required")
+	configUpdateEnvelope := &common.ConfigUpdateEnvelope{
+		ConfigUpdate: request.Config,
+		Signatures:   request.Signatures,
 	}
-
-	if request.Orderer == nil {
-		return errors.New("missing orderer request parameter for the initialize channel")
+	configUpdateEnvelopeBytes, err := proto.Marshal(configUpdateEnvelope)
+	if err != nil {
+		return errors.Wrap(err, "marshal configUpdateEnvelope failed")
 	}
 
-	if request.Name == "" {
-		return errors.New("missing name request parameter for the new channel")
+	channelHeaderOpts := txn.ChannelHeaderOpts{
+		ChannelID:   request.Name,
+		TxnID:       txnID,
+		TLSCertHash: ccomm.TLSCertHash(c.clientContext.Config()),
 	}
-
-	// channel = null;
-	var signature []byte
-	var payloadBytes []byte
-
-	if haveEnvelope {
-		logger.Debug("createOrUpdateChannel - have envelope")
-		envelope := &common.Envelope{}
-		err := proto.Unmarshal(request.Envelope, envelope)
-		if err != nil {
-			return errors.Wrap(err, "unmarshal request envelope failed")
-		}
-		signature = envelope.Signature
-		payloadBytes = envelope.Payload
-	} else {
-		logger.Debug("createOrUpdateChannel - have config_update")
-		configUpdateEnvelope := &common.ConfigUpdateEnvelope{
-			ConfigUpdate: request.Config,
-			Signatures:   request.Signatures,
-		}
-
-		// TODO: Move
-		channelHeaderOpts := txn.ChannelHeaderOpts{
-			ChannelID:   request.Name,
-			TxnID:       request.TxnID,
-			TLSCertHash: ccomm.TLSCertHash(c.clientContext.Config()),
-		}
-		channelHeader, err := txn.CreateChannelHeader(common.HeaderType_CONFIG_UPDATE, channelHeaderOpts)
-		if err != nil {
-			return errors.WithMessage(err, "BuildChannelHeader failed")
-		}
-
-		header, err := txn.CreateHeader(c.clientContext, channelHeader, request.TxnID)
-		if err != nil {
-			return errors.Wrap(err, "BuildHeader failed")
-		}
-		configUpdateEnvelopeBytes, err := proto.Marshal(configUpdateEnvelope)
-		if err != nil {
-			return errors.Wrap(err, "marshal configUpdateEnvelope failed")
-		}
-		payload := &common.Payload{
-			Header: header,
-			Data:   configUpdateEnvelopeBytes,
-		}
-		payloadBytes, err = proto.Marshal(payload)
-		if err != nil {
-			return errors.Wrap(err, "marshal payload failed")
-		}
-
-		signingMgr := c.clientContext.SigningManager()
-		if signingMgr == nil {
-			return errors.New("signing manager is nil")
-		}
-
-		signature, err = signingMgr.Sign(payloadBytes, c.clientContext.PrivateKey())
-		if err != nil {
-			return errors.WithMessage(err, "signing payload failed")
-		}
+	channelHeader, err := txn.CreateChannelHeader(common.HeaderType_CONFIG_UPDATE, channelHeaderOpts)
+	if err != nil {
+		return errors.WithMessage(err, "CreateChannelHeader failed")
 	}
 
-	// Send request
-	_, err := request.Orderer.SendBroadcast(&fab.SignedEnvelope{
-		Signature: signature,
-		Payload:   payloadBytes,
-	})
+	payload, err := txn.CreatePayload(txnID, channelHeader, configUpdateEnvelopeBytes)
 	if err != nil {
-		return errors.WithMessage(err, "failed broadcast to orderer")
+		return errors.WithMessage(err, "CreatePayload failed")
 	}
 
+	_, err = txn.BroadcastPayload(c.clientContext, payload, []fab.Orderer{request.Orderer})
+	if err != nil {
+		return errors.WithMessage(err, "SendEnvelope failed")
+	}
 	return nil
 }
 

pkg/fabric-client/txn/env.go

@@ -72,16 +72,19 @@ func computeTxnID(nonce, creator []byte, h hash.Hash) (string, error) {
 	return id, nil
 }
 
-// SignPayload signs payload
-//
-// TODO: Determine if this function should be exported after refactoring is completed.
-func SignPayload(ctx context, payload []byte) (*fab.SignedEnvelope, error) {
+// signPayload signs payload
+func signPayload(ctx context, payload *common.Payload) (*fab.SignedEnvelope, error) {
+	payloadBytes, err := proto.Marshal(payload)
+	if err != nil {
+		return nil, errors.WithMessage(err, "marshaling of payload failed")
+	}
+
 	signingMgr := ctx.SigningManager()
-	signature, err := signingMgr.Sign(payload, ctx.PrivateKey())
+	signature, err := signingMgr.Sign(payloadBytes, ctx.PrivateKey())
 	if err != nil {
-		return nil, err
+		return nil, errors.WithMessage(err, "signing of payload failed")
 	}
-	return &fab.SignedEnvelope{Payload: payload, Signature: signature}, nil
+	return &fab.SignedEnvelope{Payload: payloadBytes, Signature: signature}, nil
 }
 
 // ChannelHeaderOpts holds the parameters to create a ChannelHeader.
@@ -133,15 +136,11 @@ func CreateChannelHeader(headerType common.HeaderType, opts ChannelHeaderOpts) (
 	return channelHeader, nil
 }
 
-// CreateHeader creates a Header from a ChannelHeader.
-func CreateHeader(ctx fab.IdentityContext, channelHeader *common.ChannelHeader, txnID fab.TransactionID) (*common.Header, error) {
-	creator, err := ctx.Identity()
-	if err != nil {
-		return nil, errors.WithMessage(err, "extracting creator from identity context failed")
-	}
+// createHeader creates a Header from a ChannelHeader.
+func createHeader(txnID fab.TransactionID, channelHeader *common.ChannelHeader) (*common.Header, error) {
 
 	signatureHeader := &common.SignatureHeader{
-		Creator: creator,
+		Creator: txnID.Creator,
 		Nonce:   txnID.Nonce,
 	}
 	sh, err := proto.Marshal(signatureHeader)
@@ -152,9 +151,24 @@ func CreateHeader(ctx fab.IdentityContext, channelHeader *common.ChannelHeader,
 	if err != nil {
 		return nil, errors.Wrap(err, "marshal channelHeader failed")
 	}
-	header := &common.Header{
+	header := common.Header{
 		SignatureHeader: sh,
 		ChannelHeader:   ch,
 	}
-	return header, nil
+	return &header, nil
+}
+
+// CreatePayload creates a slice of payload bytes from a ChannelHeader and a data slice.
+func CreatePayload(txnID fab.TransactionID, channelHeader *common.ChannelHeader, data []byte) (*common.Payload, error) {
+	header, err := createHeader(txnID, channelHeader)
+	if err != nil {
+		return nil, errors.Wrap(err, "header creation failed")
+	}
+
+	payload := common.Payload{
+		Header: header,
+		Data:   data,
+	}
+
+	return &payload, nil
 }