//deploy the command via Endorser
func deploy(cmd *cobra.Command, cf *ChaincodeCmdFactory) (*protcommon.Envelope, error) {
spec, err := getChaincodeSpecification(cmd)
if err != nil {
return nil, err
}
cds, err := getChaincodeBytes(spec)
if err != nil {
return nil, fmt.Errorf("Error getting chaincode code %s: %s", chainFuncName, err)
}
creator, err := cf.Signer.Serialize()
if err != nil {
return nil, fmt.Errorf("Error serializing identity for %s: %s\n", cf.Signer.GetIdentifier(), err)
}
uuid := util.GenerateUUID()
prop, err := utils.CreateDeployProposalFromCDS(uuid, chainID, cds, creator)
if err != nil {
return nil, fmt.Errorf("Error creating proposal %s: %s\n", chainFuncName, err)
}
var signedProp *pb.SignedProposal
signedProp, err = utils.GetSignedProposal(prop, cf.Signer)
if err != nil {
return nil, fmt.Errorf("Error creating signed proposal %s: %s\n", chainFuncName, err)
}
proposalResponse, err := cf.EndorserClient.ProcessProposal(context.Background(), signedProp)
if err != nil {
return nil, fmt.Errorf("Error endorsing %s: %s\n", chainFuncName, err)
}
if proposalResponse != nil {
// assemble a signed transaction (it's an Envelope message)
env, err := utils.CreateSignedTx(prop, cf.Signer, proposalResponse)
if err != nil {
return nil, fmt.Errorf("Could not assemble transaction, err %s", err)
}
return env, nil
}
return nil, nil
}
func executeJoin(cf *JoinCmdFactory) (err error) {
spec, err := getJoinCCSpec()
if err != nil {
return err
}
// Build the ChaincodeInvocationSpec message
invocation := &pb.ChaincodeInvocationSpec{ChaincodeSpec: spec}
creator, err := cf.Signer.Serialize()
if err != nil {
return fmt.Errorf("Error serializing identity for %s: %s\n", cf.Signer.GetIdentifier(), err)
}
uuid := cutil.GenerateUUID()
var prop *pb.Proposal
prop, err = putils.CreateProposalFromCIS(uuid, "", invocation, creator)
if err != nil {
return fmt.Errorf("Error creating proposal for join %s\n", err)
}
var signedProp *pb.SignedProposal
signedProp, err = putils.GetSignedProposal(prop, cf.Signer)
if err != nil {
return fmt.Errorf("Error creating signed proposal %s\n", err)
}
var proposalResp *pb.ProposalResponse
proposalResp, err = cf.EndorserClient.ProcessProposal(context.Background(), signedProp)
if err != nil {
return fmt.Errorf("Error endorsing %s\n", err)
}
if proposalResp == nil {
return fmt.Errorf("Error on join by endorsing: %s\n", err)
}
fmt.Printf("Join Result: %s\n", string(proposalResp.Response.Payload))
return nil
}
// chaincodeInvokeOrQuery invokes or queries the chaincode. If successful, the
// INVOKE form prints the ProposalResponse to STDOUT, and the QUERY form prints
// the query result on STDOUT. A command-line flag (-r, --raw) determines
// whether the query result is output as raw bytes, or as a printable string.
// The printable form is optionally (-x, --hex) a hexadecimal representation
// of the query response. If the query response is NIL, nothing is output.
//
// NOTE - Query will likely go away as all interactions with the endorser are
// Proposal and ProposalResponses
func chaincodeInvokeOrQuery(cmd *cobra.Command, args []string, invoke bool, cf *ChaincodeCmdFactory) (err error) {
spec, err := getChaincodeSpecification(cmd)
if err != nil {
return err
}
// Build the ChaincodeInvocationSpec message
invocation := &pb.ChaincodeInvocationSpec{ChaincodeSpec: spec}
if customIDGenAlg != common.UndefinedParamValue {
invocation.IdGenerationAlg = customIDGenAlg
}
creator, err := cf.Signer.Serialize()
if err != nil {
return fmt.Errorf("Error serializing identity for %s: %s\n", cf.Signer.GetIdentifier(), err)
}
uuid := cutil.GenerateUUID()
var prop *pb.Proposal
prop, err = putils.CreateProposalFromCIS(uuid, chainID, invocation, creator)
if err != nil {
return fmt.Errorf("Error creating proposal %s: %s\n", chainFuncName, err)
}
var signedProp *pb.SignedProposal
signedProp, err = putils.GetSignedProposal(prop, cf.Signer)
if err != nil {
return fmt.Errorf("Error creating signed proposal %s: %s\n", chainFuncName, err)
}
var proposalResp *pb.ProposalResponse
proposalResp, err = cf.EndorserClient.ProcessProposal(context.Background(), signedProp)
if err != nil {
return fmt.Errorf("Error endorsing %s: %s\n", chainFuncName, err)
}
if invoke {
if proposalResp != nil {
// assemble a signed transaction (it's an Envelope message)
env, err := putils.CreateSignedTx(prop, cf.Signer, proposalResp)
if err != nil {
return fmt.Errorf("Could not assemble transaction, err %s", err)
}
// send the envelope for ordering
if err = cf.BroadcastClient.Send(env); err != nil {
return fmt.Errorf("Error sending transaction %s: %s\n", chainFuncName, err)
}
}
logger.Infof("Invoke result: %v", proposalResp)
} else {
if proposalResp == nil {
return fmt.Errorf("Error query %s by endorsing: %s\n", chainFuncName, err)
}
if chaincodeQueryRaw {
if chaincodeQueryHex {
err = errors.New("Options --raw (-r) and --hex (-x) are not compatible\n")
return
}
fmt.Print("Query Result (Raw): ")
os.Stdout.Write(proposalResp.Response.Payload)
} else {
if chaincodeQueryHex {
fmt.Printf("Query Result: %x\n", proposalResp.Response.Payload)
} else {
fmt.Printf("Query Result: %s\n", string(proposalResp.Response.Payload))
}
}
}
return nil
}
func TestGoodPath(t *testing.T) {
// get a toy proposal
prop, err := getProposal()
if err != nil {
t.Fatalf("getProposal failed, err %s", err)
return
}
// sign it
sProp, err := utils.GetSignedProposal(prop, signer)
if err != nil {
t.Fatalf("GetSignedProposal failed, err %s", err)
return
}
// validate it
_, _, _, err = ValidateProposalMessage(sProp)
if err != nil {
t.Fatalf("ValidateProposalMessage failed, err %s", err)
return
}
simRes := []byte("simulation_result")
// endorse it to get a proposal response
presp, err := utils.CreateProposalResponse(prop.Header, prop.Payload, simRes, nil, nil, signer)
if err != nil {
t.Fatalf("CreateProposalResponse failed, err %s", err)
return
}
// assemble a transaction from that proposal and endorsement
tx, err := utils.CreateSignedTx(prop, signer, presp)
if err != nil {
t.Fatalf("CreateSignedTx failed, err %s", err)
return
}
// validate the transaction
_, act, err := ValidateTransaction(tx)
if err != nil {
t.Fatalf("ValidateTransaction failed, err %s", err)
return
}
// expect one single action
if len(act) != 1 {
t.Fatalf("Ivalid number of TransactionAction, expected 1, got %d", len(act))
return
}
// get the payload of the action
_, simResBack, err := utils.GetPayloads(act[0])
if err != nil {
t.Fatalf("GetPayloads failed, err %s", err)
return
}
// compare it to the original action and expect it to be equal
if string(simRes) != string(simResBack.Results) {
t.Fatalf("Simulation results are different")
return
}
}
func TestBadProp(t *testing.T) {
// get a toy proposal
prop, err := getProposal()
if err != nil {
t.Fatalf("getProposal failed, err %s", err)
return
}
// sign it
sProp, err := utils.GetSignedProposal(prop, signer)
if err != nil {
t.Fatalf("GetSignedProposal failed, err %s", err)
return
}
// mess with the signature
corrupt(sProp.Signature)
// validate it - it should fail
_, _, _, err = ValidateProposalMessage(sProp)
if err == nil {
t.Fatalf("ValidateProposalMessage should have failed")
return
}
// sign it again
sProp, err = utils.GetSignedProposal(prop, signer)
if err != nil {
t.Fatalf("GetSignedProposal failed, err %s", err)
return
}
// mess with the message
corrupt(sProp.ProposalBytes)
// validate it - it should fail
_, _, _, err = ValidateProposalMessage(sProp)
if err == nil {
t.Fatalf("ValidateProposalMessage should have failed")
return
}
// get a bad signing identity
badSigner, err := msp.NewNoopMsp().GetDefaultSigningIdentity()
if err != nil {
t.Fatalf("Couldn't get noop signer")
return
}
// sign it again with the bad signer
sProp, err = utils.GetSignedProposal(prop, badSigner)
if err != nil {
t.Fatalf("GetSignedProposal failed, err %s", err)
return
}
// validate it - it should fail
_, _, _, err = ValidateProposalMessage(sProp)
if err == nil {
t.Fatalf("ValidateProposalMessage should have failed")
return
}
}