// Deploy a chaincode - i.e., build and initialize. func deploy(ctx context.Context, spec *pb.ChaincodeSpec) ([]byte, error) { // First build and get the deployment spec chaincodeDeploymentSpec, err := getDeploymentSpec(ctx, spec) if err != nil { return nil, err } tid := chaincodeDeploymentSpec.ChaincodeSpec.ChaincodeID.Name // Now create the Transactions message and send to Peer. transaction, err := pb.NewChaincodeDeployTransaction(chaincodeDeploymentSpec, tid) if err != nil { return nil, fmt.Errorf("Error deploying chaincode: %s ", err) } ledger, err := ledger.GetLedger() ledger.BeginTxBatch("1") b, err := Execute(ctx, GetChain(DefaultChain), transaction) if err != nil { return nil, fmt.Errorf("Error deploying chaincode: %s", err) } ledger.CommitTxBatch("1", []*pb.Transaction{transaction}, nil, nil) return b, err }
// GetBlock returns a block from the chain func (h *Helper) GetBlock(blockNumber uint64) (block *pb.Block, err error) { ledger, err := ledger.GetLedger() if err != nil { return nil, fmt.Errorf("Failed to get the ledger :%v", err) } return ledger.GetBlockByNumber(blockNumber) }
// ApplyStateDelta applies a state delta to the current state // The result of this function can be retrieved using GetCurrentStateDelta // To commit the result, call CommitStateDelta, or to roll it back // call RollbackStateDelta func (h *Helper) ApplyStateDelta(id interface{}, delta *statemgmt.StateDelta) error { ledger, err := ledger.GetLedger() if err != nil { return fmt.Errorf("Failed to get the ledger :%v", err) } return ledger.ApplyStateDelta(id, delta) }
// GetBlockchainSize returns the current size of the blockchain func (h *Helper) GetBlockchainSize() (uint64, error) { ledger, err := ledger.GetLedger() if err != nil { return 0, fmt.Errorf("Failed to get the ledger :%v", err) } return ledger.GetBlockchainSize(), nil }
// RollbackStateDelta undoes the results of ApplyStateDelta to revert // the current state back to the state before ApplyStateDelta was invoked func (h *Helper) RollbackStateDelta(id interface{}) error { ledger, err := ledger.GetLedger() if err != nil { return fmt.Errorf("Failed to get the ledger :%v", err) } return ledger.RollbackStateDelta(id) }
// EmptyState completely empties the state and prepares it to restore a snapshot func (h *Helper) EmptyState() error { ledger, err := ledger.GetLedger() if err != nil { return fmt.Errorf("Failed to get the ledger :%v", err) } return ledger.DeleteALLStateKeysAndValues() }
// GetCurrentStateHash returns the current/temporary state hash func (h *Helper) GetCurrentStateHash() (stateHash []byte, err error) { ledger, err := ledger.GetLedger() if err != nil { return nil, fmt.Errorf("Failed to get the ledger :%v", err) } return ledger.GetTempStateHash() }
// VerifyBlockchain checks the integrity of the blockchain between indices start and finish, // returning the first block who's PreviousBlockHash field does not match the hash of the previous block func (h *Helper) VerifyBlockchain(start, finish uint64) (uint64, error) { ledger, err := ledger.GetLedger() if err != nil { return finish, fmt.Errorf("Failed to get the ledger :%v", err) } return ledger.VerifyChain(start, finish) }
func (i *Noops) getBlockData() (*pb.Block, *statemgmt.StateDelta, error) { ledger, err := ledger.GetLedger() if err != nil { return nil, nil, fmt.Errorf("Fail to get the ledger: %v", err) } blockHeight := ledger.GetBlockchainSize() if logger.IsEnabledFor(logging.DEBUG) { logger.Debug("Preparing to broadcast with block number %v", blockHeight) } block, err := ledger.GetBlockByNumber(blockHeight - 1) if nil != err { return nil, nil, err } //delta, err := ledger.GetStateDeltaBytes(blockHeight) delta, err := ledger.GetStateDelta(blockHeight - 1) if nil != err { return nil, nil, err } if logger.IsEnabledFor(logging.DEBUG) { logger.Debug("Got the delta state of block number %v", blockHeight) } return block, delta, nil }
func whoIsTheOwner(asset string) ([]byte, error) { chaincodeInput := &pb.ChaincodeInput{Function: "query", Args: []string{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 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 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{Function: "init", Args: []string{}}, 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 }
// PutBlock inserts a raw block into the blockchain at the specified index, nearly no error checking is performed func (h *Helper) PutBlock(blockNumber uint64, block *pb.Block) error { ledger, err := ledger.GetLedger() if err != nil { return fmt.Errorf("Failed to get the ledger :%v", err) } return ledger.PutRawBlock(block, blockNumber) }
// Invoke or query a chaincode. func invoke(ctx context.Context, spec *pb.ChaincodeSpec, typ pb.Transaction_Type) (string, []byte, error) { chaincodeInvocationSpec := &pb.ChaincodeInvocationSpec{ChaincodeSpec: spec} // Now create the Transactions message and send to Peer. uuid := util.GenerateUUID() transaction, err := pb.NewChaincodeExecute(chaincodeInvocationSpec, uuid, typ) if err != nil { return uuid, nil, fmt.Errorf("Error invoking chaincode: %s ", err) } var retval []byte var execErr error if typ == pb.Transaction_CHAINCODE_QUERY { retval, execErr = Execute(ctx, GetChain(DefaultChain), transaction) } else { ledger, _ := ledger.GetLedger() ledger.BeginTxBatch("1") retval, execErr = Execute(ctx, GetChain(DefaultChain), transaction) if err != nil { return uuid, nil, fmt.Errorf("Error invoking chaincode: %s ", err) } ledger.CommitTxBatch("1", []*pb.Transaction{transaction}, nil, nil) } return uuid, retval, execErr }
// Handles query to ledger to get state func (handler *Handler) handleGetState(msg *pb.ChaincodeMessage) { // The defer followed by triggering a go routine dance is needed to ensure that the previous state transition // is completed before the next one is triggered. The previous state transition is deemed complete only when // the afterGetState function is exited. Interesting bug fix!! go func() { // Check if this is the unique state request from this chaincode uuid uniqueReq := handler.createUUIDEntry(msg.Uuid) if !uniqueReq { // Drop this request chaincodeLogger.Debug("Another state request pending for this Uuid. Cannot process.") return } var serialSendMsg *pb.ChaincodeMessage defer func() { handler.deleteUUIDEntry(msg.Uuid) chaincodeLogger.Debug("[%s]handleGetState serial send %s", shortuuid(serialSendMsg.Uuid), serialSendMsg.Type) handler.serialSend(serialSendMsg) }() key := string(msg.Payload) ledgerObj, ledgerErr := ledger.GetLedger() if ledgerErr != nil { // Send error msg back to chaincode. GetState will not trigger event payload := []byte(ledgerErr.Error()) chaincodeLogger.Debug("Failed to get chaincode state. Sending %s", pb.ChaincodeMessage_ERROR) // Remove uuid from current set serialSendMsg = &pb.ChaincodeMessage{Type: pb.ChaincodeMessage_ERROR, Payload: payload, Uuid: msg.Uuid} return } // Invoke ledger to get state chaincodeID := handler.ChaincodeID.Name // ToDo: Eventually, once consensus is plugged in, we need to set bool to true for ledger res, err := ledgerObj.GetState(chaincodeID, key, false) if err != nil { // Send error msg back to chaincode. GetState will not trigger event payload := []byte(err.Error()) chaincodeLogger.Debug("[%s]Failed to get chaincode state. Sending %s", shortuuid(msg.Uuid), pb.ChaincodeMessage_ERROR) serialSendMsg = &pb.ChaincodeMessage{Type: pb.ChaincodeMessage_ERROR, Payload: payload, Uuid: msg.Uuid} } else { // Decrypt the data if the confidential is enabled if res, err = handler.decrypt(msg.Uuid, res); err == nil { // Send response msg back to chaincode. GetState will not trigger event chaincodeLogger.Debug("[%s]Got state. Sending %s", shortuuid(msg.Uuid), pb.ChaincodeMessage_RESPONSE) serialSendMsg = &pb.ChaincodeMessage{Type: pb.ChaincodeMessage_RESPONSE, Payload: res, Uuid: msg.Uuid} } else { // Send err msg back to chaincode. chaincodeLogger.Debug("[%s]Got error while decrypting. Sending %s", shortuuid(msg.Uuid), pb.ChaincodeMessage_ERROR) errBytes := []byte(err.Error()) serialSendMsg = &pb.ChaincodeMessage{Type: pb.ChaincodeMessage_ERROR, Payload: errBytes, Uuid: msg.Uuid} } } }() }
// RollbackTxBatch discards all the state changes that may have taken // place during the execution of current transaction-batch func (h *Helper) RollbackTxBatch(id interface{}) error { ledger, err := ledger.GetLedger() if err != nil { return fmt.Errorf("Failed to get the ledger: %v", err) } if err := ledger.RollbackTxBatch(id); err != nil { return fmt.Errorf("Failed to rollback transaction with the ledger: %v", err) } return nil }
// CommitTxBatch gets invoked when the current transaction-batch needs // to be committed. This function returns successfully iff the // transactions details and state changes (that may have happened // during execution of this transaction-batch) have been committed to // permanent storage. func (h *Helper) CommitTxBatch(id interface{}, transactions []*pb.Transaction, transactionsResults []*pb.TransactionResult, metadata []byte) error { ledger, err := ledger.GetLedger() if err != nil { return fmt.Errorf("Failed to get the ledger: %v", err) } if err := ledger.CommitTxBatch(id, transactions, nil, metadata); err != nil { return fmt.Errorf("Failed to commit transaction to the ledger: %v", err) } return nil }
// NewOpenchainServer creates a new instance of the ServerOpenchain. func NewOpenchainServer() (*ServerOpenchain, error) { // Get a handle to the Ledger singleton. ledger, err := ledger.GetLedger() if err != nil { return nil, err } s := &ServerOpenchain{ledger: ledger} return s, nil }
// PreviewCommitTxBatchBlock retrieves a preview copy of the block that would be inserted into the ledger if CommitTxBatch were invoked. // As a preview copy, it only guarantees that the hashable portions of the block will match the committed block. Consequently, // this preview block should only be used for hash computations and never distributed, passed into PutBlock, etc.. // The guarantee of hashable equality will be violated if additional ExecTXs calls are invoked. func (h *Helper) PreviewCommitTxBatchBlock(id interface{}, txs []*pb.Transaction, metadata []byte) (*pb.Block, error) { ledger, err := ledger.GetLedger() if err != nil { return nil, fmt.Errorf("Failed to get the ledger: %v", err) } block, err := ledger.GetTXBatchPreviewBlock(id, txs, metadata) if err != nil { return nil, fmt.Errorf("Failed to commit transaction to the ledger: %v", err) } return block, err }
// RollbackTxBatch discards all the state changes that may have taken // place during the execution of current transaction-batch func (h *Helper) RollbackTxBatch(id interface{}) error { ledger, err := ledger.GetLedger() if err != nil { return fmt.Errorf("Failed to get the ledger: %v", err) } if err := ledger.RollbackTxBatch(id); err != nil { return fmt.Errorf("Failed to rollback transaction with the ledger: %v", err) } h.curBatch = nil // TODO, remove after issue 579 return nil }
// PreviewCommitTxBatch retrieves a preview copy of the block that would be inserted into the ledger if CommitTxBatch were invoked. // As a preview copy, it only guarantees that the hashable portions of the block will match the committed block. Consequently, // this preview block should only be used for hash computations and never distributed, passed into PutBlock, etc.. // The guarantee of hashable equality will be violated if additional ExecTXs calls are invoked. func (h *Helper) PreviewCommitTxBatch(id interface{}, metadata []byte) (*pb.Block, error) { ledger, err := ledger.GetLedger() if err != nil { return nil, fmt.Errorf("Failed to get the ledger: %v", err) } // TODO fix this once the underlying API is fixed block, err := ledger.GetTXBatchPreviewBlock(id, h.curBatch, metadata) if err != nil { return nil, fmt.Errorf("Failed to commit transaction to the ledger: %v", err) } return block, err }
func (validator *validatorImpl) verifyValidityPeriod(tx *obc.Transaction) (*obc.Transaction, error) { if tx.Cert != nil && tx.Signature != nil { // Unmarshal cert cert, err := utils.DERToX509Certificate(tx.Cert) if err != nil { validator.peer.node.log.Error("verifyValidityPeriod: failed unmarshalling cert %s:", err) return tx, err } cid := viper.GetString("pki.validity-period.chaincodeHash") ledger, err := ledger.GetLedger() if err != nil { validator.peer.node.log.Error("verifyValidityPeriod: failed getting access to the ledger %s:", err) return tx, err } vp_bytes, err := ledger.GetState(cid, "system.validity.period", true) if err != nil { validator.peer.node.log.Error("verifyValidityPeriod: failed reading validity period from the ledger %s:", err) return tx, err } i, err := strconv.ParseInt(string(vp_bytes[:]), 10, 64) if err != nil { validator.peer.node.log.Error("verifyValidityPeriod: failed to parse validity period %s:", err) return tx, err } vp := time.Unix(i, 0) var errMsg string = "" // Verify the validity period of the TCert switch { case cert.NotAfter.Before(cert.NotBefore): errMsg = "verifyValidityPeriod: certificate validity period is invalid" case vp.Before(cert.NotBefore): errMsg = "verifyValidityPeriod: certificate validity period is in the future" case vp.After(cert.NotAfter): errMsg = "verifyValidityPeriod: certificate validity period is in the past" } if errMsg != "" { validator.peer.node.log.Error(errMsg) return tx, errors.New(errMsg) } } return tx, nil }
// Check the correctness of the final state after transaction execution. func checkFinalState(uuid string, chaincodeID string) error { // Check the state in the ledger ledgerObj, ledgerErr := ledger.GetLedger() if ledgerErr != nil { return fmt.Errorf("Error checking ledger for <%s>: %s", chaincodeID, ledgerErr) } _, delta, err := ledgerObj.GetTempStateHashWithTxDeltaStateHashes() if err != nil { return fmt.Errorf("Error getting delta for invoke transaction <%s>: %s", chaincodeID, err) } if delta[uuid] == nil { return fmt.Errorf("%s <%s> but found nil", expectedDeltaStringPrefix, uuid) } fmt.Printf("found delta for transaction <%s>\n", uuid) // Invoke ledger to get state var Aval, Bval int resbytes, resErr := ledgerObj.GetState(chaincodeID, "a", false) if resErr != nil { return fmt.Errorf("Error retrieving state from ledger for <%s>: %s", chaincodeID, resErr) } fmt.Printf("Got string: %s\n", string(resbytes)) Aval, resErr = strconv.Atoi(string(resbytes)) if resErr != nil { return fmt.Errorf("Error retrieving state from ledger for <%s>: %s", chaincodeID, resErr) } if Aval != 90 { return fmt.Errorf("Incorrect result. Aval is wrong for <%s>", chaincodeID) } resbytes, resErr = ledgerObj.GetState(chaincodeID, "b", false) if resErr != nil { return fmt.Errorf("Error retrieving state from ledger for <%s>: %s", chaincodeID, resErr) } Bval, resErr = strconv.Atoi(string(resbytes)) if resErr != nil { return fmt.Errorf("Error retrieving state from ledger for <%s>: %s", chaincodeID, resErr) } if Bval != 210 { return fmt.Errorf("Incorrect result. Bval is wrong for <%s>", chaincodeID) } // Success fmt.Printf("Aval = %d, Bval = %d\n", Aval, Bval) return nil }
//ExecuteTransactions - will execute transactions on the array one by one //will return an array of errors one for each transaction. If the execution //succeeded, array element will be nil. returns state hash func ExecuteTransactions(ctxt context.Context, cname ChainName, xacts []*pb.Transaction, secCxt crypto.Peer) ([]byte, []error) { var chain = GetChain(cname) if chain == nil { panic(fmt.Sprintf("[ExecuteTransactions]Chain %s not found\n", cname)) } errs := make([]error, len(xacts)+1) for i, t := range xacts { _, errs[i] = Execute(ctxt, chain, t, secCxt) } ledger, hasherr := ledger.GetLedger() var statehash []byte if hasherr == nil { statehash, hasherr = ledger.GetTempStateHash() } errs[len(errs)-1] = hasherr return statehash, errs }
//ExecuteTransactions - will execute transactions on the array one by one //will return an array of errors one for each transaction. If the execution //succeeded, array element will be nil. returns state hash func ExecuteTransactions(ctxt context.Context, cname ChainName, xacts []*pb.Transaction) ([]byte, []error) { var chain = GetChain(cname) if chain == nil { // TODO: We should never get here, but otherwise a good reminder to better handle panic(fmt.Sprintf("[ExecuteTransactions]Chain %s not found\n", cname)) } errs := make([]error, len(xacts)+1) for i, t := range xacts { _, errs[i] = Execute(ctxt, chain, t) } ledger, hasherr := ledger.GetLedger() var statehash []byte if hasherr == nil { statehash, hasherr = ledger.GetTempStateHash() } errs[len(errs)-1] = hasherr return statehash, errs }
// NewPeerWithHandler returns a Peer which uses the supplied handler factory function for creating new handlers on new Chat service invocations. func NewPeerWithHandler(handlerFact func(MessageHandlerCoordinator, ChatStream, bool, MessageHandler) (MessageHandler, error)) (*PeerImpl, error) { peer := new(PeerImpl) if handlerFact == nil { return nil, errors.New("Cannot supply nil handler factory") } peer.handlerFactory = handlerFact peer.handlerMap = &handlerMap{m: make(map[string]MessageHandler)} // Install security object for peer if viper.GetBool("security.enabled") { enrollID := viper.GetString("security.enrollID") enrollSecret := viper.GetString("security.enrollSecret") var err error if viper.GetBool("peer.validator.enabled") { peerLogger.Debug("Registering validator with enroll ID: %s", enrollID) if err = crypto.RegisterValidator(enrollID, nil, enrollID, enrollSecret); nil != err { return nil, err } peerLogger.Debug("Initializing validator with enroll ID: %s", enrollID) peer.secHelper, err = crypto.InitValidator(enrollID, nil) if nil != err { return nil, err } } else { peerLogger.Debug("Registering non-validator with enroll ID: %s", enrollID) if err = crypto.RegisterPeer(enrollID, nil, enrollID, enrollSecret); nil != err { return nil, err } peerLogger.Debug("Initializing non-validator with enroll ID: %s", enrollID) peer.secHelper, err = crypto.InitPeer(enrollID, nil) if nil != err { return nil, err } } } ledgerPtr, err := ledger.GetLedger() if err != nil { return nil, fmt.Errorf("Error constructing NewPeerWithHandler: %s", err) } peer.ledgerWrapper = &ledgerWrapper{ledger: ledgerPtr} go peer.chatWithPeer(viper.GetString("peer.discovery.rootnode")) return peer, nil }
func getTimeout(cID *pb.ChaincodeID) (time.Duration, error) { ledger, err := ledger.GetLedger() if err == nil { chaincodeID := cID.Name txUUID, err := ledger.GetState(chaincodeID, "github.com_openblockchain_obc-peer_chaincode_id", true) if err == nil { tx, err := ledger.GetTransactionByUUID(string(txUUID)) if err == nil { chaincodeDeploymentSpec := &pb.ChaincodeDeploymentSpec{} proto.Unmarshal(tx.Payload, chaincodeDeploymentSpec) chaincodeSpec := chaincodeDeploymentSpec.GetChaincodeSpec() timeout := time.Duration(time.Duration(chaincodeSpec.Timeout) * time.Millisecond) return timeout, nil } } } return -1, errFailedToGetChainCodeSpecForTransaction }
// CommitTxBatch gets invoked when the current transaction-batch needs // to be committed. This function returns successfully iff the // transactions details and state changes (that may have happened // during execution of this transaction-batch) have been committed to // permanent storage. func (h *Helper) CommitTxBatch(id interface{}, metadata []byte) (*pb.Block, error) { ledger, err := ledger.GetLedger() if err != nil { return nil, fmt.Errorf("Failed to get the ledger: %v", err) } // TODO fix this one the ledger has been fixed to implement if err := ledger.CommitTxBatch(id, h.curBatch, nil, metadata); err != nil { return nil, fmt.Errorf("Failed to commit transaction to the ledger: %v", err) } size := ledger.GetBlockchainSize() h.curBatch = nil // TODO, remove after issue 579 block, err := ledger.GetBlockByNumber(size - 1) if err != nil { return nil, fmt.Errorf("Failed to get the block at the head of the chain: %v", err) } return block, nil }
// Check the correctness of the final state after transaction execution. func checkFinalState(uuid string, chaincodeID string) error { // Check the state in the ledger ledgerObj, ledgerErr := ledger.GetLedger() if ledgerErr != nil { return fmt.Errorf("Error checking ledger for <%s>: %s", chaincodeID, ledgerErr) } // Invoke ledger to get state var Aval, Bval int resbytes, resErr := ledgerObj.GetState(chaincodeID, "a", false) if resErr != nil { return fmt.Errorf("Error retrieving state from ledger for <%s>: %s", chaincodeID, resErr) } fmt.Printf("Got string: %s\n", string(resbytes)) Aval, resErr = strconv.Atoi(string(resbytes)) if resErr != nil { return fmt.Errorf("Error retrieving state from ledger for <%s>: %s", chaincodeID, resErr) } if Aval != 90 { return fmt.Errorf("Incorrect result. Aval is wrong for <%s>", chaincodeID) } resbytes, resErr = ledgerObj.GetState(chaincodeID, "b", false) if resErr != nil { return fmt.Errorf("Error retrieving state from ledger for <%s>: %s", chaincodeID, resErr) } Bval, resErr = strconv.Atoi(string(resbytes)) if resErr != nil { return fmt.Errorf("Error retrieving state from ledger for <%s>: %s", chaincodeID, resErr) } if Bval != 210 { return fmt.Errorf("Incorrect result. Bval is wrong for <%s>", chaincodeID) } // Success fmt.Printf("Aval = %d, Bval = %d\n", Aval, Bval) return nil }
func getValidityPeriodFromLedger(t *testing.T) int64 { cid := viper.GetString("pki.validity-period.chaincodeHash") ledger, err := ledger.GetLedger() if err != nil { t.Logf("Failed getting access to the ledger: %s", err) t.Fail() } vp_bytes, err := ledger.GetState(cid, "system.validity.period", true) if err != nil { t.Logf("Failed reading validity period from the ledger: %s", err) t.Fail() } i, err := strconv.ParseInt(string(vp_bytes[:]), 10, 64) if err != nil { t.Logf("Failed to parse validity period: %s", err) t.Fail() } return i }