// 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
}