[FAB-9735] Move execute variants into one file

Change-Id: I15d11c3b000b58abd26be460281748e515b2515d
Signed-off-by: Matthew Sykes <sykesmat@us.ibm.com>

core/chaincode/chaincode_support.go

@@ -11,7 +11,10 @@ import (
 	"time"
 
 	"github.com/golang/protobuf/proto"
+	"github.com/hyperledger/fabric/common/resourcesconfig"
+	"github.com/hyperledger/fabric/common/util"
 	"github.com/hyperledger/fabric/core/chaincode/accesscontrol"
+	"github.com/hyperledger/fabric/core/chaincode/shim"
 	"github.com/hyperledger/fabric/core/common/ccprovider"
 	"github.com/hyperledger/fabric/core/common/sysccprovider"
 	"github.com/hyperledger/fabric/core/container"
@@ -288,3 +291,147 @@ func (cs *ChaincodeSupport) Execute(ctxt context.Context, cccid *ccprovider.CCCo
 
 	return ccresp, nil
 }
+
+//Execute - execute proposal, return original response of chaincode
+func (cs *ChaincodeSupport) ExecuteSpec(ctxt context.Context, cccid *ccprovider.CCContext, spec ccprovider.ChaincodeSpecGetter) (*pb.Response, *pb.ChaincodeEvent, error) {
+	var err error
+	var cds *pb.ChaincodeDeploymentSpec
+	var ci *pb.ChaincodeInvocationSpec
+
+	//init will call the Init method of a on a chain
+	cctyp := pb.ChaincodeMessage_INIT
+	if cds, _ = spec.(*pb.ChaincodeDeploymentSpec); cds == nil {
+		if ci, _ = spec.(*pb.ChaincodeInvocationSpec); ci == nil {
+			panic("Execute should be called with deployment or invocation spec")
+		}
+		cctyp = pb.ChaincodeMessage_TRANSACTION
+	}
+
+	_, cMsg, err := cs.Launch(ctxt, cccid, spec)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	cMsg.Decorations = cccid.ProposalDecorations
+
+	var ccMsg *pb.ChaincodeMessage
+	ccMsg, err = createCCMessage(cctyp, cccid.ChainID, cccid.TxID, cMsg)
+	if err != nil {
+		return nil, nil, errors.WithMessage(err, "failed to create chaincode message")
+	}
+
+	resp, err := cs.Execute(ctxt, cccid, ccMsg, cs.executetimeout)
+	if err != nil {
+		// Rollback transaction
+		return nil, nil, errors.WithMessage(err, "failed to execute transaction")
+	} else if resp == nil {
+		// Rollback transaction
+		return nil, nil, errors.Errorf("failed to receive a response for txid (%s)", cccid.TxID)
+	}
+
+	if resp.ChaincodeEvent != nil {
+		resp.ChaincodeEvent.ChaincodeId = cccid.Name
+		resp.ChaincodeEvent.TxId = cccid.TxID
+	}
+
+	if resp.Type == pb.ChaincodeMessage_COMPLETED {
+		res := &pb.Response{}
+		unmarshalErr := proto.Unmarshal(resp.Payload, res)
+		if unmarshalErr != nil {
+			return nil, nil, errors.Wrap(unmarshalErr, fmt.Sprintf("failed to unmarshal response for txid (%s)", cccid.TxID))
+		}
+
+		// Success
+		return res, resp.ChaincodeEvent, nil
+	} else if resp.Type == pb.ChaincodeMessage_ERROR {
+		// Rollback transaction
+		return nil, resp.ChaincodeEvent, errors.Errorf("transaction returned with failure: %s", string(resp.Payload))
+	}
+
+	//TODO - this should never happen ... a panic is more appropriate but will save that for future
+	return nil, nil, errors.Errorf("receive a response for txid (%s) but in invalid state (%d)", cccid.TxID, resp.Type)
+}
+
+// ExecuteWithErrorFilter is similar to Execute, but filters error contained in chaincode response and returns Payload of response only.
+// Mostly used by unit-test.
+func (cs *ChaincodeSupport) ExecuteWithErrorFilter(ctxt context.Context, cccid *ccprovider.CCContext, spec ccprovider.ChaincodeSpecGetter) ([]byte, *pb.ChaincodeEvent, error) {
+	res, event, err := cs.ExecuteSpec(ctxt, cccid, spec)
+	if err != nil {
+		chaincodeLogger.Errorf("ExecuteWithErrorFilter %s error: %+v", cccid.Name, err)
+		return nil, nil, err
+	}
+
+	if res == nil {
+		chaincodeLogger.Errorf("ExecuteWithErrorFilter %s get nil response without error", cccid.Name)
+		return nil, nil, err
+	}
+
+	if res.Status != shim.OK {
+		return nil, nil, errors.New(res.Message)
+	}
+
+	return res.Payload, event, nil
+}
+
+//create a chaincode invocation spec
+func createCIS(ccname string, args [][]byte) (*pb.ChaincodeInvocationSpec, error) {
+	var err error
+	spec := &pb.ChaincodeInvocationSpec{ChaincodeSpec: &pb.ChaincodeSpec{Type: pb.ChaincodeSpec_Type(pb.ChaincodeSpec_Type_value["GOLANG"]), ChaincodeId: &pb.ChaincodeID{Name: ccname}, Input: &pb.ChaincodeInput{Args: args}}}
+	if nil != err {
+		return nil, err
+	}
+	return spec, nil
+}
+
+// GetCDS retrieves a chaincode deployment spec for the required chaincode
+func (cs *ChaincodeSupport) GetCDS(ctxt context.Context, txid string, signedProp *pb.SignedProposal, prop *pb.Proposal, chainID string, chaincodeID string) ([]byte, error) {
+	version := util.GetSysCCVersion()
+	cccid := ccprovider.NewCCContext(chainID, "lscc", version, txid, true, signedProp, prop)
+	res, _, err := cs.ExecuteChaincode(ctxt, cccid, [][]byte{[]byte("getdepspec"), []byte(chainID), []byte(chaincodeID)})
+	if err != nil {
+		return nil, errors.WithMessage(err, fmt.Sprintf("execute getdepspec(%s, %s) of LSCC error", chainID, chaincodeID))
+	}
+	if res.Status != shim.OK {
+		return nil, errors.Errorf("get ChaincodeDeploymentSpec for %s/%s from LSCC error: %s", chaincodeID, chainID, res.Message)
+	}
+
+	return res.Payload, nil
+}
+
+// GetChaincodeDefinition returns resourcesconfig.ChaincodeDefinition for the chaincode with the supplied name
+func (cs *ChaincodeSupport) GetChaincodeDefinition(ctxt context.Context, txid string, signedProp *pb.SignedProposal, prop *pb.Proposal, chainID string, chaincodeID string) (resourcesconfig.ChaincodeDefinition, error) {
+	version := util.GetSysCCVersion()
+	cccid := ccprovider.NewCCContext(chainID, "lscc", version, txid, true, signedProp, prop)
+	res, _, err := cs.ExecuteChaincode(ctxt, cccid, [][]byte{[]byte("getccdata"), []byte(chainID), []byte(chaincodeID)})
+	if err == nil {
+		if res.Status != shim.OK {
+			return nil, errors.New(res.Message)
+		}
+		cd := &ccprovider.ChaincodeData{}
+		err = proto.Unmarshal(res.Payload, cd)
+		if err != nil {
+			return nil, err
+		}
+		return cd, nil
+	}
+
+	return nil, err
+}
+
+// ExecuteChaincode executes a given chaincode given chaincode name and arguments
+func (cs *ChaincodeSupport) ExecuteChaincode(ctxt context.Context, cccid *ccprovider.CCContext, args [][]byte) (*pb.Response, *pb.ChaincodeEvent, error) {
+	var spec *pb.ChaincodeInvocationSpec
+	var err error
+	var res *pb.Response
+	var ccevent *pb.ChaincodeEvent
+
+	spec, err = createCIS(cccid.Name, args)
+	res, ccevent, err = cs.ExecuteSpec(ctxt, cccid, spec)
+	if err != nil {
+		err = errors.WithMessage(err, "error executing chaincode")
+		chaincodeLogger.Errorf("%+v", err)
+		return nil, nil, err
+	}
+
+	return res, ccevent, err
+}