Invoke VSCC from committer

This change-set adds the call to VSCC to the committer's code path. There are
still a few missing pieces that we can only address once LCCC is finalized
(e.g. identify the right VSCC, extract policies). The change-set also contains
a minor refactoring of the tx-assembly code as discussed with Manish.

Change-Id: Ibf8807dbb2934dcf4929c3e1a3edd4e5ec9f40ea
Signed-off-by: Alessandro Sorniotti <[email protected]>

Author: ale-linux

core/committer/noopssinglechain/client.go

@@ -35,11 +35,13 @@ import (
 
 	"fmt"
 
+	"github.com/hyperledger/fabric/core/ledger"
 	"github.com/hyperledger/fabric/core/peer"
 	"github.com/hyperledger/fabric/gossip/gossip"
 	"github.com/hyperledger/fabric/gossip/integration"
 	gossip_proto "github.com/hyperledger/fabric/gossip/proto"
 	"github.com/hyperledger/fabric/gossip/state"
+	pb "github.com/hyperledger/fabric/protos/peer"
 )
 
 var logger *logging.Logger // package-level logger
@@ -224,6 +226,49 @@ func (d *DeliverService) isDone() bool {
 	return atomic.LoadInt32(&d.stopFlag) == 1
 }
 
+func isTxValidForVscc(envBytes []byte) error {
+	// TODO: Extract the VSCC/policy from LCCC as soon as this is ready
+	vscc := "vscc"
+
+	// TODO - get chainname from the envelope
+	chainName := string(chaincode.DefaultChain)
+
+	txid := "N/A" // FIXME: is that appropriate?
+
+	// build arguments for VSCC invocation
+	// args[0] - function name (not used now)
+	// args[1] - serialized Envelope
+	args := [][]byte{[]byte(""), envBytes}
+
+	// create VSCC invocation proposal
+	vsccCis := &pb.ChaincodeInvocationSpec{ChaincodeSpec: &pb.ChaincodeSpec{Type: pb.ChaincodeSpec_GOLANG, ChaincodeID: &pb.ChaincodeID{Name: vscc}, CtorMsg: &pb.ChaincodeInput{Args: args}}}
+	prop, err := putils.CreateProposalFromCIS(txid, util.GetTestChainID(), vsccCis, []byte(""))
+	if err != nil {
+		logger.Errorf("Cannot create a proposal to invoke VSCC, err %s\n", err)
+		return err
+	}
+
+	// get context for the chaincode execution
+	var txsim ledger.TxSimulator
+	lgr := kvledger.GetLedger(chainName)
+	txsim, err = lgr.NewTxSimulator()
+	if err != nil {
+		logger.Errorf("Cannot obtain tx simulator, err %s\n", err)
+		return err
+	}
+	defer txsim.Done()
+	ctxt := context.WithValue(context.Background(), chaincode.TXSimulatorKey, txsim)
+
+	// invoke VSCC
+	_, _, err = chaincode.ExecuteChaincode(ctxt, txid, prop, chainName, vscc, args)
+	if err != nil {
+		logger.Errorf("VSCC check failed for transaction, error %s", err)
+		return err
+	}
+
+	return nil
+}
+
 func (d *DeliverService) readUntilClose() {
 	for {
 		msg, err := d.client.Recv()
@@ -264,7 +309,15 @@ func (d *DeliverService) readUntilClose() {
 							// in validation is just dropped on the floor
 							logger.Errorf("Invalid transaction, error %s", err)
 						} else {
-							// TODO: call VSCC now
+							err = isTxValidForVscc(d)
+							if err != nil {
+								// TODO: this code needs to receive a bit more attention and discussion:
+								// it's not clear what it means if a transaction which causes a failure
+								// in validation is just dropped on the floor
+								logger.Errorf("isTxValidForVscc returned error %s", err)
+								continue
+							}
+
 							if t, err := proto.Marshal(env); err == nil {
 								block.Data.Data = append(block.Data.Data, t)
 							} else {

core/system_chaincode/vscc/validator_onevalidsignature.go

@@ -24,8 +24,11 @@ import (
 	"github.com/hyperledger/fabric/msp"
 	"github.com/hyperledger/fabric/protos/common"
 	"github.com/hyperledger/fabric/protos/utils"
+	"github.com/op/go-logging"
 )
 
+var logger = logging.MustGetLogger("vscc")
+
 // ValidatorOneValidSignature implements the default transaction validation policy,
 // which is to check the correctness of the read-write set and the endorsement
 // signatures
@@ -59,33 +62,40 @@ func (vscc *ValidatorOneValidSignature) Invoke(stub shim.ChaincodeStubInterface)
 		return nil, errors.New("No block to validate")
 	}
 
+	logger.Infof("VSCC invoked")
+
 	// get the envelope...
 	env, err := utils.GetEnvelope(args[1])
 	if err != nil {
+		logger.Errorf("VSCC error: GetEnvelope failed, err %s", err)
 		return nil, err
 	}
 
 	// ...and the payload...
 	payl, err := utils.GetPayload(env)
 	if err != nil {
+		logger.Errorf("VSCC error: GetPayload failed, err %s", err)
 		return nil, err
 	}
 
 	// 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 nil, fmt.Errorf("Only Endorser Transactions are supported, provided type %d", payl.Header.ChainHeader.Type)
 	}
 
 	// ...and the transaction...
 	tx, err := utils.GetTransaction(payl.Data)
 	if err != nil {
+		logger.Errorf("VSCC error: GetTransaction failed, err %s", err)
 		return nil, err
 	}
 
 	// loop through each of the actions within
 	for _, act := range tx.Actions {
 		cap, err := utils.GetChaincodeActionPayload(act.Payload)
 		if err != nil {
+			logger.Errorf("VSCC error: GetChaincodeActionPayload failed, err %s", err)
 			return nil, err
 		}
 
@@ -97,23 +107,28 @@ func (vscc *ValidatorOneValidSignature) Invoke(stub shim.ChaincodeStubInterface)
 			// extract the identity of the signer
 			end, err := msp.GetManager().DeserializeIdentity(endorsement.Endorser)
 			if err != nil {
+				logger.Errorf("VSCC error: DeserializeIdentity failed, err %s", err)
 				return nil, err
 			}
 
 			// validate it
 			valid, err := end.Validate()
 			if err != nil || !valid {
+				logger.Errorf("Invalid endorser, err %s, valid %t", err, valid)
 				return nil, fmt.Errorf("Invalid endorser, err %s, valid %t", err, valid)
 			}
 
 			// verify the signature
 			valid, err = end.Verify(append(prespBytes, endorsement.Endorser...), endorsement.Signature)
 			if err != nil || !valid {
+				logger.Errorf("Invalid signature, err %s, valid %t", err, valid)
 				return nil, fmt.Errorf("Invalid signature, err %s, valid %t", err, valid)
 			}
 		}
 	}
 
+	logger.Infof("VSCC exists successfully")
+
 	return nil, nil
 }
 

protos/testutils/txtestutils.go

@@ -107,22 +107,15 @@ func ConstructSingedTxEnv(txid string, chainID string, ccName string, simulation
 	return env, nil
 }
 
+var mspLcl msp.PeerMSP
+var sigId msp.SigningIdentity
+
 // ConstructUnsingedTxEnv creates a Transaction envelope from given inputs
 func ConstructUnsingedTxEnv(txid string, chainID string, ccName string, simulationResults []byte, events []byte, visibility []byte) (*common.Envelope, error) {
-	prop, err := putils.CreateChaincodeProposal(txid, chainID, &pb.ChaincodeInvocationSpec{ChaincodeSpec: &pb.ChaincodeSpec{ChaincodeID: &pb.ChaincodeID{Name: ccName}}}, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	presp, err := putils.ConstructUnsignedProposalResponse(prop.Header, prop.Payload, simulationResults, nil, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	env, err := putils.ConstructUnsignedTxEnvelope(prop, presp)
-	if err != nil {
-		return nil, err
+	if mspLcl == nil {
+		mspLcl = msp.NewNoopMsp()
+		sigId, _ = mspLcl.GetSigningIdentity(nil)
 	}
-	return env, nil
 
+	return ConstructSingedTxEnv(txid, chainID, ccName, simulationResults, events, visibility, sigId)
 }

protos/utils/txutils.go

@@ -59,7 +59,7 @@ func GetPayloads(txActions *peer.TransactionAction) (*peer.ChaincodeActionPayloa
 	return ccPayload, respPayload, nil
 }
 
-// GetEndorserTxFromBlock gets Transaction2 from Block.Data.Data
+// GetEndorserTxFromBlock gets Transaction from Block.Data.Data
 func GetEnvelopeFromBlock(data []byte) (*common.Envelope, error) {
 	//Block always begins with an envelope
 	var err error
@@ -71,42 +71,10 @@ func GetEnvelopeFromBlock(data []byte) (*common.Envelope, error) {
 	return env, nil
 }
 
-// CreateSignedTx assembles an Envelope message from proposal, endorsements and a signer.
+// assemble an Envelope message from proposal, endorsements and a signer.
 // This function should be called by a client when it has collected enough endorsements
 // for a proposal to create a transaction and submit it to peers for ordering
 func CreateSignedTx(proposal *peer.Proposal, signer msp.SigningIdentity, resps ...*peer.ProposalResponse) (*common.Envelope, error) {
-	// the original header
-	hdr, err := GetHeader(proposal.Header)
-	if err != nil {
-		return nil, fmt.Errorf("Could not unmarshal the proposal header")
-	}
-	// check that the signer is the same that is referenced in the header
-	// TODO: maybe worth removing?
-	signerBytes, err := signer.Serialize()
-	if err != nil {
-		return nil, err
-	}
-
-	if bytes.Compare(signerBytes, hdr.SignatureHeader.Creator) != 0 {
-		return nil, fmt.Errorf("The signer needs to be the same as the one referenced in the header")
-	}
-
-	// create the payload
-	txEnvelope, err := ConstructUnsignedTxEnvelope(proposal, resps...)
-	if err != nil {
-		return nil, err
-	}
-	// sign the payload
-	sig, err := signer.Sign(txEnvelope.Payload)
-	if err != nil {
-		return nil, err
-	}
-	txEnvelope.Signature = sig
-	return txEnvelope, nil
-}
-
-// ConstructUnsignedTxEnvelope constructs payload for the transaction from proposal and endorsements.
-func ConstructUnsignedTxEnvelope(proposal *peer.Proposal, resps ...*peer.ProposalResponse) (*common.Envelope, error) {
 	if len(resps) == 0 {
 		return nil, fmt.Errorf("At least one proposal response is necessary")
 	}
@@ -123,6 +91,17 @@ func ConstructUnsignedTxEnvelope(proposal *peer.Proposal, resps ...*peer.Proposa
 		return nil, fmt.Errorf("Could not unmarshal the proposal payload")
 	}
 
+	// check that the signer is the same that is referenced in the header
+	// TODO: maybe worth removing?
+	signerBytes, err := signer.Serialize()
+	if err != nil {
+		return nil, err
+	}
+
+	if bytes.Compare(signerBytes, hdr.SignatureHeader.Creator) != 0 {
+		return nil, fmt.Errorf("The signer needs to be the same as the one referenced in the header")
+	}
+
 	// get header extensions so we have the visibility field
 	hdrExt, err := GetChaincodeHeaderExtension(hdr)
 	if err != nil {
@@ -184,40 +163,25 @@ func ConstructUnsignedTxEnvelope(proposal *peer.Proposal, resps ...*peer.Proposa
 	if err != nil {
 		return nil, err
 	}
+
+	// create the payload
 	payl := &common.Payload{Header: hdr, Data: txBytes}
 	paylBytes, err := GetBytesPayload(payl)
 	if err != nil {
 		return nil, err
 	}
 
-	// here's the envelope
-	return &common.Envelope{Payload: paylBytes, Signature: nil}, nil
-}
-
-// CreateProposalResponse creates the proposal response and endorses the payload
-func CreateProposalResponse(hdr []byte, payl []byte, results []byte, events []byte, visibility []byte, signingEndorser msp.SigningIdentity) (*peer.ProposalResponse, error) {
-	resp, err := ConstructUnsignedProposalResponse(hdr, payl, results, events, visibility)
+	// sign the payload
+	sig, err := signer.Sign(paylBytes)
 	if err != nil {
 		return nil, err
 	}
-	// serialize the signing identity
-	endorser, err := signingEndorser.Serialize()
-	if err != nil {
-		return nil, fmt.Errorf("Could not serialize the signing identity for %s, err %s", signingEndorser.Identifier(), err)
-	}
 
-	// sign the concatenation of the proposal response and the serialized endorser identity with this endorser's key
-	signature, err := signingEndorser.Sign(append(resp.Payload, endorser...))
-	if err != nil {
-		return nil, fmt.Errorf("Could not sign the proposal response payload, err %s", err)
-	}
-	resp.Endorsement.Endorser = endorser
-	resp.Endorsement.Signature = signature
-	return resp, nil
+	// here's the envelope
+	return &common.Envelope{Payload: paylBytes, Signature: sig}, nil
 }
 
-// ConstructUnsignedProposalResponse constructs the proposal response structure only
-func ConstructUnsignedProposalResponse(hdr []byte, payl []byte, results []byte, events []byte, visibility []byte) (*peer.ProposalResponse, error) {
+func CreateProposalResponse(hdr []byte, payl []byte, results []byte, events []byte, visibility []byte, signingEndorser msp.SigningIdentity) (*peer.ProposalResponse, error) {
 	// obtain the proposal hash given proposal header, payload and the requested visibility
 	pHashBytes, err := GetProposalHash1(hdr, payl, visibility)
 	if err != nil {
@@ -229,10 +193,23 @@ func ConstructUnsignedProposalResponse(hdr []byte, payl []byte, results []byte,
 	if err != nil {
 		return nil, errors.New("Failure while unmarshalling the ProposalResponsePayload")
 	}
+
+	// serialize the signing identity
+	endorser, err := signingEndorser.Serialize()
+	if err != nil {
+		return nil, fmt.Errorf("Could not serialize the signing identity for %s, err %s", signingEndorser.Identifier(), err)
+	}
+
+	// sign the concatenation of the proposal response and the serialized endorser identity with this endorser's key
+	signature, err := signingEndorser.Sign(append(prpBytes, endorser...))
+	if err != nil {
+		return nil, fmt.Errorf("Could not sign the proposal response payload, err %s", err)
+	}
+
 	resp := &peer.ProposalResponse{
 		// Timestamp: TODO!
 		Version:     1, // TODO: pick right version number
-		Endorsement: &peer.Endorsement{Signature: nil, Endorser: nil},
+		Endorsement: &peer.Endorsement{Signature: signature, Endorser: endorser},
 		Payload:     prpBytes,
 		Response:    &peer.Response{Status: 200, Message: "OK"}}