// Invoke or query a chaincode. func invoke(ctx context.Context, spec *pb.ChaincodeSpec, typ pb.Transaction_Type) (*pb.ChaincodeEvent, string, []byte, error) { chaincodeInvocationSpec := &pb.ChaincodeInvocationSpec{ChaincodeSpec: spec} // Now create the Transactions message and send to Peer. uuid := util.GenerateUUID() var transaction *pb.Transaction var err error transaction, err = pb.NewChaincodeExecute(chaincodeInvocationSpec, uuid, typ) if err != nil { return nil, uuid, nil, fmt.Errorf("Error invoking chaincode: %s ", err) } var retval []byte var execErr error var ccevt *pb.ChaincodeEvent if typ == pb.Transaction_CHAINCODE_QUERY { retval, ccevt, execErr = chaincode.Execute(ctx, chaincode.GetChain(chaincode.DefaultChain), transaction) } else { ledger, _ := ledger.GetLedger() ledger.BeginTxBatch("1") retval, ccevt, execErr = chaincode.Execute(ctx, chaincode.GetChain(chaincode.DefaultChain), transaction) if err != nil { return nil, uuid, nil, fmt.Errorf("Error invoking chaincode: %s ", err) } ledger.CommitTxBatch("1", []*pb.Transaction{transaction}, nil, nil) } return ccevt, uuid, retval, execErr }
//TestRedeploy - deploy two times, second time should fail but example02 should remain deployed func TestRedeploy(t *testing.T) { chainID := util.GetTestChainID() //invalid arguments spec := &pb.ChaincodeSpec{Type: 1, ChaincodeID: &pb.ChaincodeID{Name: "ex02", Path: "github.com/hyperledger/fabric/examples/chaincode/go/chaincode_example02"}, CtorMsg: &pb.ChaincodeInput{Args: [][]byte{[]byte("init"), []byte("a"), []byte("100"), []byte("b"), []byte("200")}}} cccid := chaincode.NewCCContext(chainID, "ex02", "", "", false, nil) _, _, err := deploy(endorserServer, chainID, spec, nil) if err != nil { t.Fail() t.Logf("error in endorserServer.ProcessProposal %s", err) chaincode.GetChain().Stop(context.Background(), cccid, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec}) return } //second time should not fail as we are just simulating _, _, err = deploy(endorserServer, chainID, spec, nil) if err != nil { t.Fail() t.Logf("error in endorserServer.ProcessProposal %s", err) chaincode.GetChain().Stop(context.Background(), cccid, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec}) return } chaincode.GetChain().Stop(context.Background(), cccid, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec}) }
//TestDeploy deploy chaincode example01 func TestDeploy(t *testing.T) { chainID := util.GetTestChainID() spec := &pb.ChaincodeSpec{Type: 1, ChaincodeID: &pb.ChaincodeID{Name: "ex01", Path: "github.com/hyperledger/fabric/examples/chaincode/go/chaincode_example01"}, CtorMsg: &pb.ChaincodeInput{Args: [][]byte{[]byte("init"), []byte("a"), []byte("100"), []byte("b"), []byte("200")}}} cccid := chaincode.NewCCContext(chainID, "ex01", "", "", false, nil) _, _, err := deploy(endorserServer, chainID, spec, nil) if err != nil { t.Fail() t.Logf("Deploy-error in deploy %s", err) chaincode.GetChain().Stop(context.Background(), cccid, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec}) return } chaincode.GetChain().Stop(context.Background(), cccid, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec}) }
// TestDeployAndInvoke deploys and invokes chaincode_example01 func TestDeployAndInvoke(t *testing.T) { chainID := util.GetTestChainID() var ctxt = context.Background() url := "github.com/hyperledger/fabric/examples/chaincode/go/chaincode_example01" chaincodeID := &pb.ChaincodeID{Path: url, Name: "ex01"} args := []string{"10"} f := "init" argsDeploy := util.ToChaincodeArgs(f, "a", "100", "b", "200") spec := &pb.ChaincodeSpec{Type: 1, ChaincodeID: chaincodeID, CtorMsg: &pb.ChaincodeInput{Args: argsDeploy}} cccid := chaincode.NewCCContext(chainID, "ex01", "", "", false, nil) resp, prop, err := deploy(endorserServer, chainID, spec, nil) chaincodeID1 := spec.ChaincodeID.Name if err != nil { t.Fail() t.Logf("Error deploying <%s>: %s", chaincodeID1, err) chaincode.GetChain().Stop(ctxt, cccid, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: &pb.ChaincodeSpec{ChaincodeID: chaincodeID}}) return } err = endorserServer.(*Endorser).commitTxSimulation(prop, chainID, signer, resp) if err != nil { t.Fail() t.Logf("Error committing <%s>: %s", chaincodeID1, err) chaincode.GetChain().Stop(ctxt, cccid, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: &pb.ChaincodeSpec{ChaincodeID: chaincodeID}}) return } f = "invoke" invokeArgs := append([]string{f}, args...) spec = &pb.ChaincodeSpec{Type: 1, ChaincodeID: chaincodeID, CtorMsg: &pb.ChaincodeInput{Args: util.ToChaincodeArgs(invokeArgs...)}} resp, err = invoke(chainID, spec) if err != nil { t.Fail() t.Logf("Error invoking transaction: %s", err) chaincode.GetChain().Stop(ctxt, cccid, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: &pb.ChaincodeSpec{ChaincodeID: chaincodeID}}) return } fmt.Printf("Invoke test passed\n") t.Logf("Invoke test passed") chaincode.GetChain().Stop(ctxt, cccid, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: &pb.ChaincodeSpec{ChaincodeID: chaincodeID}}) }
func transferOwnership(owner crypto.Client, ownerCert crypto.CertificateHandler, asset string, newOwnerCert crypto.CertificateHandler) error { // Get a transaction handler to be used to submit the execute transaction // and bind the chaincode access control logic using the binding submittingCertHandler, err := owner.GetTCertificateHandlerNext() if err != nil { return err } txHandler, err := submittingCertHandler.GetTransactionHandler() if err != nil { return err } binding, err := txHandler.GetBinding() if err != nil { return err } chaincodeInput := &pb.ChaincodeInput{Function: "transfer", Args: []string{asset, string(newOwnerCert.GetCertificate())}} chaincodeInputRaw, err := proto.Marshal(chaincodeInput) if err != nil { return err } // Access control. Owner signs chaincodeInputRaw || binding to confirm his identity sigma, err := ownerCert.Sign(append(chaincodeInputRaw, binding...)) if err != nil { return err } // Prepare spec and submit spec := &pb.ChaincodeSpec{ Type: 1, ChaincodeID: &pb.ChaincodeID{Name: "mycc"}, CtorMsg: chaincodeInput, Metadata: sigma, // Proof of identity ConfidentialityLevel: pb.ConfidentialityLevel_PUBLIC, } var ctx = context.Background() chaincodeInvocationSpec := &pb.ChaincodeInvocationSpec{ChaincodeSpec: spec} tid := chaincodeInvocationSpec.ChaincodeSpec.ChaincodeID.Name // Now create the Transactions message and send to Peer. transaction, err := txHandler.NewChaincodeExecute(chaincodeInvocationSpec, tid) if err != nil { return fmt.Errorf("Error deploying chaincode: %s ", err) } ledger, err := ledger.GetLedger() ledger.BeginTxBatch("1") _, err = chaincode.Execute(ctx, chaincode.GetChain(chaincode.DefaultChain), transaction) if err != nil { return fmt.Errorf("Error deploying chaincode: %s", err) } ledger.CommitTxBatch("1", []*pb.Transaction{transaction}, nil, nil) return err }
func whoIsTheOwner(asset string) ([]byte, error) { chaincodeInput := &pb.ChaincodeInput{Args: util.ToChaincodeArgs("query", asset)} // Prepare spec and submit spec := &pb.ChaincodeSpec{ Type: 1, ChaincodeID: &pb.ChaincodeID{Name: "mycc"}, CtorMsg: chaincodeInput, ConfidentialityLevel: pb.ConfidentialityLevel_PUBLIC, } var ctx = context.Background() chaincodeInvocationSpec := &pb.ChaincodeInvocationSpec{ChaincodeSpec: spec} tid := chaincodeInvocationSpec.ChaincodeSpec.ChaincodeID.Name // Now create the Transactions message and send to Peer. transaction, err := administrator.NewChaincodeQuery(chaincodeInvocationSpec, tid) if err != nil { return nil, fmt.Errorf("Error deploying chaincode: %s ", err) } ledger, err := ledger.GetLedger() ledger.BeginTxBatch("1") result, _, err := chaincode.Execute(ctx, chaincode.GetChain(chaincode.DefaultChain), transaction) if err != nil { return nil, fmt.Errorf("Error deploying chaincode: %s", err) } ledger.CommitTxBatch("1", []*pb.Transaction{transaction}, nil, nil) return result, err }
func (handler *ConsensusHandler) doChainQuery(tx *pb.Transaction) error { var response *pb.Response var err error // Verify transaction signature if security is enabled secHelper := handler.coordinator.GetSecHelper() if nil != secHelper { if logger.IsEnabledFor(logging.DEBUG) { logger.Debug("Verifying transaction signature %s", tx.Uuid) } if tx, err = secHelper.TransactionPreValidation(tx); nil != err { response = &pb.Response{Status: pb.Response_FAILURE, Msg: []byte(err.Error())} logger.Debug("Failed to verify transaction %v", err) } } // execute if response nil (ie, no error) if nil == response { // The secHelper is set during creat ChaincodeSupport, so we don't need this step // cxt := context.WithValue(context.Background(), "security", secHelper) cxt := context.Background() result, err := chaincode.Execute(cxt, chaincode.GetChain(chaincode.DefaultChain), tx) if err != nil { response = &pb.Response{Status: pb.Response_FAILURE, Msg: []byte(fmt.Sprintf("Error:%s", err))} } else { response = &pb.Response{Status: pb.Response_SUCCESS, Msg: result} } } payload, _ := proto.Marshal(response) handler.SendMessage(&pb.Message{Type: pb.Message_RESPONSE, Payload: payload}) return nil }
func deploy(admCert crypto.CertificateHandler) error { // Prepare the spec. The metadata includes the identity of the administrator spec := &pb.ChaincodeSpec{ Type: 1, ChaincodeID: &pb.ChaincodeID{Name: "mycc"}, CtorMsg: &pb.ChaincodeInput{Args: util.ToChaincodeArgs("init")}, Metadata: admCert.GetCertificate(), ConfidentialityLevel: pb.ConfidentialityLevel_PUBLIC, } // First build and get the deployment spec var ctx = context.Background() chaincodeDeploymentSpec, err := getDeploymentSpec(ctx, spec) if err != nil { return err } tid := chaincodeDeploymentSpec.ChaincodeSpec.ChaincodeID.Name // Now create the Transactions message and send to Peer. transaction, err := administrator.NewChaincodeDeployTransaction(chaincodeDeploymentSpec, tid) if err != nil { return fmt.Errorf("Error deploying chaincode: %s ", err) } ledger, err := ledger.GetLedger() ledger.BeginTxBatch("1") _, _, err = chaincode.Execute(ctx, chaincode.GetChain(chaincode.DefaultChain), transaction) if err != nil { return fmt.Errorf("Error deploying chaincode: %s", err) } ledger.CommitTxBatch("1", []*pb.Transaction{transaction}, nil, nil) return err }
// TestUpgradeAndInvoke deploys chaincode_example01, upgrade it with chaincode_example02, then invoke it func TestDeployAndUpgrade(t *testing.T) { chainID := util.GetTestChainID() var ctxt = context.Background() url1 := "github.com/hyperledger/fabric/examples/chaincode/go/chaincode_example01" url2 := "github.com/hyperledger/fabric/examples/chaincode/go/chaincode_example02" chaincodeID1 := &pb.ChaincodeID{Path: url1, Name: "upgradeex01"} chaincodeID2 := &pb.ChaincodeID{Path: url2, Name: "upgradeex01"} f := "init" argsDeploy := util.ToChaincodeArgs(f, "a", "100", "b", "200") spec := &pb.ChaincodeSpec{Type: 1, ChaincodeID: chaincodeID1, CtorMsg: &pb.ChaincodeInput{Args: argsDeploy}} cccid1 := chaincode.NewCCContext(chainID, "upgradeex01", "", "", false, nil) cccid2 := chaincode.NewCCContext(chainID, "upgradeex02", "", "", false, nil) resp, prop, err := deploy(endorserServer, chainID, spec, nil) chaincodeName := spec.ChaincodeID.Name if err != nil { t.Fail() chaincode.GetChain().Stop(ctxt, cccid1, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: &pb.ChaincodeSpec{ChaincodeID: chaincodeID1}}) chaincode.GetChain().Stop(ctxt, cccid2, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: &pb.ChaincodeSpec{ChaincodeID: chaincodeID2}}) t.Logf("Error deploying <%s>: %s", chaincodeName, err) return } err = endorserServer.(*Endorser).commitTxSimulation(prop, chainID, signer, resp) if err != nil { t.Fail() chaincode.GetChain().Stop(ctxt, cccid1, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: &pb.ChaincodeSpec{ChaincodeID: chaincodeID1}}) chaincode.GetChain().Stop(ctxt, cccid2, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: &pb.ChaincodeSpec{ChaincodeID: chaincodeID2}}) t.Logf("Error committing <%s>: %s", chaincodeName, err) return } argsUpgrade := util.ToChaincodeArgs(f, "a", "150", "b", "300") spec = &pb.ChaincodeSpec{Type: 1, ChaincodeID: chaincodeID2, CtorMsg: &pb.ChaincodeInput{Args: argsUpgrade}} resp, prop, err = upgrade(endorserServer, chainID, spec, nil) if err != nil { t.Fail() chaincode.GetChain().Stop(ctxt, cccid1, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: &pb.ChaincodeSpec{ChaincodeID: chaincodeID1}}) chaincode.GetChain().Stop(ctxt, cccid2, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: &pb.ChaincodeSpec{ChaincodeID: chaincodeID2}}) t.Logf("Error upgrading <%s>: %s", chaincodeName, err) return } fmt.Printf("Upgrade test passed\n") t.Logf("Upgrade test passed") chaincode.GetChain().Stop(ctxt, cccid1, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: &pb.ChaincodeSpec{ChaincodeID: chaincodeID1}}) chaincode.GetChain().Stop(ctxt, cccid2, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: &pb.ChaincodeSpec{ChaincodeID: chaincodeID2}}) }
//TestDeployBadPayload set payload to nil and do a deploy. It should fail and example02 should not be deployed func TestDeployBadPayload(t *testing.T) { chainID := util.GetTestChainID() //invalid arguments spec := &pb.ChaincodeSpec{Type: 1, ChaincodeID: &pb.ChaincodeID{Name: "ex02", Path: "github.com/hyperledger/fabric/examples/chaincode/go/chaincode_example02"}, CtorMsg: &pb.ChaincodeInput{Args: [][]byte{[]byte("init"), []byte("a"), []byte("100"), []byte("b"), []byte("200")}}} cccid := chaincode.NewCCContext(chainID, "ex02", "", "", false, nil) f := func(cds *pb.ChaincodeDeploymentSpec) { cds.CodePackage = nil } _, _, err := deploy(endorserServer, chainID, spec, f) if err == nil { t.Fail() t.Log("DeployBadPayload-expected error in deploy but succeeded") chaincode.GetChain().Stop(context.Background(), cccid, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec}) return } chaincode.GetChain().Stop(context.Background(), cccid, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec}) }
func transferOwnership(owner crypto.Client, ownerCert crypto.CertificateHandler, fromAttributes string, newOwnerCert crypto.CertificateHandler, toAttributes string, amount string) error { // Get a transaction handler to be used to submit the execute transaction // and bind the chaincode access control logic using the binding submittingCertHandler, err := owner.GetTCertificateHandlerNext("role") if err != nil { return err } txHandler, err := submittingCertHandler.GetTransactionHandler() if err != nil { return err } chaincodeInput := &pb.ChaincodeInput{Args: util.ToChaincodeArgs( "transferOwnership", base64.StdEncoding.EncodeToString(ownerCert.GetCertificate()), fromAttributes, base64.StdEncoding.EncodeToString(newOwnerCert.GetCertificate()), toAttributes, amount)} // Prepare spec and submit spec := &pb.ChaincodeSpec{ Type: 1, ChaincodeID: &pb.ChaincodeID{Name: "mycc"}, CtorMsg: chaincodeInput, ConfidentialityLevel: pb.ConfidentialityLevel_PUBLIC, } var ctx = context.Background() chaincodeInvocationSpec := &pb.ChaincodeInvocationSpec{ChaincodeSpec: spec} tid := chaincodeInvocationSpec.ChaincodeSpec.ChaincodeID.Name // Now create the Transactions message and send to Peer. transaction, err := txHandler.NewChaincodeExecute(chaincodeInvocationSpec, tid) if err != nil { return fmt.Errorf("Error deploying chaincode: %s ", err) } ledger, err := ledger.GetLedger() ledger.BeginTxBatch("1") _, _, err = chaincode.Execute(ctx, chaincode.GetChain(chaincode.DefaultChain), transaction) if err != nil { return fmt.Errorf("Error deploying chaincode: %s", err) } ledger.CommitTxBatch("1", []*pb.Transaction{transaction}, nil, nil) return err }
// ProcessTransactionMsg processes a Message in context of a Transaction func (eng *EngineImpl) ProcessTransactionMsg(msg *pb.Message, tx *pb.Transaction) (response *pb.Response) { //TODO: Do we always verify security, or can we supply a flag on the invoke ot this functions so to bypass check for locally generated transactions? if tx.Type == pb.Transaction_CHAINCODE_QUERY { if !engine.helper.valid { logger.Warning("Rejecting query because state is currently not valid") return &pb.Response{Status: pb.Response_FAILURE, Msg: []byte("Error: state may be inconsistent, cannot query")} } // The secHelper is set during creat ChaincodeSupport, so we don't need this step // cxt := context.WithValue(context.Background(), "security", secHelper) cxt := context.Background() //query will ignore events as these are not stored on ledger (and query can report //"event" data synchronously anyway) result, _, err := chaincode.Execute(cxt, chaincode.GetChain(chaincode.DefaultChain), tx) if err != nil { response = &pb.Response{Status: pb.Response_FAILURE, Msg: []byte(fmt.Sprintf("Error:%s", err))} } else { response = &pb.Response{Status: pb.Response_SUCCESS, Msg: result} } } else { // Chaincode Transaction response = &pb.Response{Status: pb.Response_SUCCESS, Msg: []byte(tx.Uuid)} //TODO: Do we need to verify security, or can we supply a flag on the invoke ot this functions // If we fail to marshal or verify the tx, don't send it to consensus plugin if response.Status == pb.Response_FAILURE { return response } // Pass the message to the consenter (eg. PBFT) NOTE: Make sure engine has been initialized if eng.consenter == nil { return &pb.Response{Status: pb.Response_FAILURE, Msg: []byte("Engine not initialized")} } // TODO, do we want to put these requests into a queue? This will block until // the consenter gets around to handling the message, but it also provides some // natural feedback to the REST API to determine how long it takes to queue messages err := eng.consenter.RecvMsg(msg, eng.peerEndpoint.ID) if err != nil { response = &pb.Response{Status: pb.Response_FAILURE, Msg: []byte(err.Error())} } } return response }
// deployLocal deploys the supplied chaincode image to the local peer func deploySysCC(ctx context.Context, spec *protos.ChaincodeSpec) error { // First build and get the deployment spec chaincodeDeploymentSpec, err := buildSysCC(ctx, spec) if err != nil { sysccLogger.Error(fmt.Sprintf("Error deploying chaincode spec: %v\n\n error: %s", spec, err)) return err } transaction, err := protos.NewChaincodeDeployTransaction(chaincodeDeploymentSpec, chaincodeDeploymentSpec.ChaincodeSpec.ChaincodeID.Name) if err != nil { return fmt.Errorf("Error deploying chaincode: %s ", err) } _, _, err = chaincode.Execute(ctx, chaincode.GetChain(chaincode.DefaultChain), transaction) return err }
//deploy the chaincode after call to the system chaincode is successful func (e *Endorser) deploy(ctxt context.Context, cccid *chaincode.CCContext, cds *pb.ChaincodeDeploymentSpec) error { chaincodeSupport := chaincode.GetChain() _, err := chaincodeSupport.Deploy(ctxt, cccid, cds) if err != nil { return fmt.Errorf("Failed to deploy chaincode spec(%s)", err) } //launch and wait for ready _, _, err = chaincodeSupport.Launch(ctxt, cccid, cds) if err != nil { return fmt.Errorf("%s", err) } //stop now that we are done chaincodeSupport.Stop(ctxt, cccid, cds) return nil }
// DeployLocal deploys the supplied chaincode image to the local peer func DeployLocal(ctx context.Context, spec *protos.ChaincodeSpec, gbexists bool) (*protos.Transaction, []byte, error) { // First build and get the deployment spec chaincodeDeploymentSpec, err := BuildLocal(ctx, spec) if err != nil { genesisLogger.Error(fmt.Sprintf("Error deploying chaincode spec: %v\n\n error: %s", spec, err)) return nil, nil, err } var transaction *protos.Transaction if gbexists { ledger, err := ledger.GetLedger() if err != nil { return nil, nil, fmt.Errorf("Failed to get handle to ledger (%s)", err) } transaction, err = ledger.GetTransactionByUUID(chaincodeDeploymentSpec.ChaincodeSpec.ChaincodeID.Name) if err != nil { genesisLogger.Warning(fmt.Sprintf("cannot get deployment transaction for %s - %s", chaincodeDeploymentSpec.ChaincodeSpec.ChaincodeID.Name, err)) transaction = nil } else { genesisLogger.Debug("deployment transaction for %s exists", chaincodeDeploymentSpec.ChaincodeSpec.ChaincodeID.Name) } } if transaction == nil { transaction, err = protos.NewChaincodeDeployTransaction(chaincodeDeploymentSpec, chaincodeDeploymentSpec.ChaincodeSpec.ChaincodeID.Name) if err != nil { return nil, nil, fmt.Errorf("Error deploying chaincode: %s ", err) } } //chaincode.NewChaincodeSupport(chaincode.DefaultChain, peer.GetPeerEndpoint, false, 120000) // The secHelper is set during creat ChaincodeSupport, so we don't need this step //ctx = context.WithValue(ctx, "security", secCxt) result, err := chaincode.Execute(ctx, chaincode.GetChain(chaincode.DefaultChain), transaction) return transaction, result, err }
// Test deploy of a transaction. func TestExecuteDeploySysChaincode(t *testing.T) { testDBWrapper.CleanDB(t) var opts []grpc.ServerOption grpcServer := grpc.NewServer(opts...) viper.Set("peer.fileSystemPath", "/var/hyperledger/test/tmpdb") //use a different address than what we usually use for "peer" //we override the peerAddress set in chaincode_support.go peerAddress := "0.0.0.0:21726" lis, err := net.Listen("tcp", peerAddress) if err != nil { t.Fail() t.Logf("Error starting peer listener %s", err) return } getPeerEndpoint := func() (*pb.PeerEndpoint, error) { return &pb.PeerEndpoint{ID: &pb.PeerID{Name: "testpeer"}, Address: peerAddress}, nil } ccStartupTimeout := time.Duration(5000) * time.Millisecond pb.RegisterChaincodeSupportServer(grpcServer, chaincode.NewChaincodeSupport(chaincode.DefaultChain, getPeerEndpoint, false, ccStartupTimeout, nil)) go grpcServer.Serve(lis) var ctxt = context.Background() //set systemChaincodes to sample systemChaincodes = []*api.SystemChaincode{ { Enabled: true, Name: "sample_syscc", Path: "github.com/hyperledger/fabric/core/system_chaincode/samplesyscc", InitArgs: [][]byte{}, Chaincode: &samplesyscc.SampleSysCC{}, }, } // System chaincode has to be enabled viper.Set("chaincode.system", map[string]string{"sample_syscc": "true"}) RegisterSysCCs() url := "github.com/hyperledger/fabric/core/system_chaincode/sample_syscc" f := "putval" args := util.ToChaincodeArgs(f, "greeting", "hey there") spec := &pb.ChaincodeSpec{Type: 1, ChaincodeID: &pb.ChaincodeID{Name: "sample_syscc", Path: url}, CtorMsg: &pb.ChaincodeInput{Args: args}} _, _, _, err = invoke(ctxt, spec, pb.Transaction_CHAINCODE_INVOKE) if err != nil { closeListenerAndSleep(lis) t.Fail() t.Logf("Error invoking sample_syscc: %s", err) return } f = "getval" args = util.ToChaincodeArgs(f, "greeting") spec = &pb.ChaincodeSpec{Type: 1, ChaincodeID: &pb.ChaincodeID{Name: "sample_syscc", Path: url}, CtorMsg: &pb.ChaincodeInput{Args: args}} _, _, _, err = invoke(ctxt, spec, pb.Transaction_CHAINCODE_QUERY) if err != nil { closeListenerAndSleep(lis) t.Fail() t.Logf("Error invoking sample_syscc: %s", err) return } cds := &pb.ChaincodeDeploymentSpec{ExecEnv: 1, ChaincodeSpec: &pb.ChaincodeSpec{Type: 1, ChaincodeID: &pb.ChaincodeID{Name: "sample_syscc", Path: url}, CtorMsg: &pb.ChaincodeInput{Args: args}}} chaincode.GetChain(chaincode.DefaultChain).Stop(ctxt, cds) closeListenerAndSleep(lis) }
func read(invoker crypto.Client, invokerCert crypto.CertificateHandler) ([]byte, error) { // Get a transaction handler to be used to submit the query transaction // and bind the chaincode access control logic using the binding submittingCertHandler, err := invoker.GetTCertificateHandlerNext() if err != nil { return nil, err } txHandler, err := submittingCertHandler.GetTransactionHandler() if err != nil { return nil, err } binding, err := txHandler.GetBinding() if err != nil { return nil, err } chaincodeInput := &pb.ChaincodeInput{Args: util.ToChaincodeArgs("read")} chaincodeInputRaw, err := proto.Marshal(chaincodeInput) if err != nil { return nil, err } // Access control: // invokerCert signs invokerCert.GetCertificate() || chaincodeInputRaw || binding to confirm his identity sigma, err := invokerCert.Sign(append(invokerCert.GetCertificate(), append(chaincodeInputRaw, binding...)...)) if err != nil { return nil, err } rbacMetadata := RBACMetadata{invokerCert.GetCertificate(), sigma} rbacMetadataRaw, err := asn1.Marshal(rbacMetadata) if err != nil { return nil, err } // Prepare spec and submit spec := &pb.ChaincodeSpec{ Type: 1, ChaincodeID: &pb.ChaincodeID{Name: "mycc"}, CtorMsg: chaincodeInput, Metadata: rbacMetadataRaw, ConfidentialityLevel: pb.ConfidentialityLevel_PUBLIC, } var ctx = context.Background() chaincodeInvocationSpec := &pb.ChaincodeInvocationSpec{ChaincodeSpec: spec} tid := chaincodeInvocationSpec.ChaincodeSpec.ChaincodeID.Name // Now create the Transactions message and send to Peer. transaction, err := txHandler.NewChaincodeQuery(chaincodeInvocationSpec, tid) if err != nil { return nil, fmt.Errorf("Error deploying chaincode: %s ", err) } ledger, err := ledger.GetLedger() ledger.BeginTxBatch("1") result, _, err := chaincode.Execute(ctx, chaincode.GetChain(chaincode.DefaultChain), transaction) if err != nil { return nil, fmt.Errorf("Error deploying chaincode: %s", err) } ledger.CommitTxBatch("1", []*pb.Transaction{transaction}, nil, nil) return result, err }
func addRole(admCert crypto.CertificateHandler, idCert crypto.CertificateHandler, role string) error { // Get a transaction handler to be used to submit the execute transaction // and bind the chaincode access control logic using the binding submittingCertHandler, err := administrator.GetTCertificateHandlerNext() if err != nil { return err } txHandler, err := submittingCertHandler.GetTransactionHandler() if err != nil { return err } binding, err := txHandler.GetBinding() if err != nil { return err } chaincodeInput := &pb.ChaincodeInput{Function: "addRole", Args: []string{string(idCert.GetCertificate()), role}} chaincodeInputRaw, err := proto.Marshal(chaincodeInput) if err != nil { return err } // Access control: // admCert signs admCert.GetCertificate() || chaincodeInputRaw || binding to confirm his identity sigma, err := admCert.Sign(append(admCert.GetCertificate(), append(chaincodeInputRaw, binding...)...)) if err != nil { return err } rbacMetadata := RBACMetadata{admCert.GetCertificate(), sigma} rbacMetadataRaw, err := asn1.Marshal(rbacMetadata) if err != nil { return err } // Prepare spec and submit spec := &pb.ChaincodeSpec{ Type: 1, ChaincodeID: &pb.ChaincodeID{Name: "mycc"}, CtorMsg: chaincodeInput, Metadata: rbacMetadataRaw, // Proof of identity ConfidentialityLevel: pb.ConfidentialityLevel_PUBLIC, } var ctx = context.Background() chaincodeInvocationSpec := &pb.ChaincodeInvocationSpec{ChaincodeSpec: spec} tid := chaincodeInvocationSpec.ChaincodeSpec.ChaincodeID.Name // Now create the Transactions message and send to Peer. transaction, err := txHandler.NewChaincodeExecute(chaincodeInvocationSpec, tid) if err != nil { return fmt.Errorf("Error deploying chaincode: %s ", err) } ledger, err := ledger.GetLedger() ledger.BeginTxBatch("1") _, err = chaincode.Execute(ctx, chaincode.GetChain(chaincode.DefaultChain), transaction) if err != nil { return fmt.Errorf("Error deploying chaincode: %s", err) } ledger.CommitTxBatch("1", []*pb.Transaction{transaction}, nil, nil) return err }