fabric: github.com/hyperledger/fabric/core/ledger Index | Files | Directories

package ledger

import "github.com/hyperledger/fabric/core/ledger"

Index

Package Files

ledger_interface.go

type BlockAndPvtData Uses

type BlockAndPvtData struct {
    Block          *common.Block
    PvtData        TxPvtDataMap
    MissingPvtData TxMissingPvtDataMap
}

BlockAndPvtData encapsulates the block and a map that contains the tuples <seqInBlock, *TxPvtData> The map is expected to contain the entries only for the transactions that has associated pvt data

type BlockPvtdata Uses

type BlockPvtdata struct {
    PvtData        TxPvtDataMap
    MissingPvtData TxMissingPvtDataMap
}

BlockPvtdata contains the retrieved private data as well as missing and ineligible private data for use at commit time

type ChaincodeDefinition Uses

type ChaincodeDefinition struct {
    Name              string
    Hash              []byte
    Version           string
    CollectionConfigs *common.CollectionConfigPackage
}

ChaincodeDefinition captures the info about chaincode

func (*ChaincodeDefinition) String Uses

func (cdef *ChaincodeDefinition) String() string

type ChaincodeLifecycleDetails Uses

type ChaincodeLifecycleDetails struct {
    Updated bool // true, if an existing chaincode is updated (false for newly deployed chaincodes).
    // Following attributes are meaningful only if 'Updated' is true
    HashChanged        bool     // true, if the chaincode code package is changed
    CollectionsUpdated []string // names of the explicit collections that are either added or updated
    CollectionsRemoved []string // names of the explicit collections that are removed
}

ChaincodeLifecycleDetails captures the finer details of chaincode lifecycle event

type ChaincodeLifecycleEventListener Uses

type ChaincodeLifecycleEventListener interface {
    // HandleChaincodeDeploy is invoked when chaincode installed + defined becomes true.
    // The expected usage are to creates all the necessary statedb structures (such as indexes) and update
    // service discovery info. This function is invoked immediately before the committing the state changes
    // that contain chaincode definition or when a chaincode install happens
    HandleChaincodeDeploy(chaincodeDefinition *ChaincodeDefinition, dbArtifactsTar []byte) error
    // ChaincodeDeployDone is invoked after the chaincode deployment is finished - `succeeded` indicates
    // whether the deploy finished successfully
    ChaincodeDeployDone(succeeded bool)
}

ChaincodeLifecycleEventListener interface enables ledger components (mainly, intended for statedb) to be able to listen to chaincode lifecycle events. 'dbArtifactsTar' represents db specific artifacts (such as index specs) packaged in a tar. Note that this interface is redefined here (in addition to the one defined in ledger/cceventmgmt package). Using the same interface for the new lifecycle path causes a cyclic import dependency. Moreover, eventually the whole package ledger/cceventmgmt is intented to be removed when migration to new lifecycle is mandated.

type ChaincodeLifecycleEventProvider Uses

type ChaincodeLifecycleEventProvider interface {
    RegisterListener(channelID string, listener ChaincodeLifecycleEventListener)
}

type ChaincodeLifecycleInfo Uses

type ChaincodeLifecycleInfo struct {
    Name    string
    Deleted bool
    Details *ChaincodeLifecycleDetails // Can contain finer details about lifecycle event that can be used for certain optimization
}

ChaincodeLifecycleInfo captures the update info of a chaincode

type CollConfigNotDefinedError Uses

type CollConfigNotDefinedError struct {
    Ns string
}

CollConfigNotDefinedError is returned whenever an operation is requested on a collection whose config has not been defined

func (*CollConfigNotDefinedError) Error Uses

func (e *CollConfigNotDefinedError) Error() string

type CollectionConfigInfo Uses

type CollectionConfigInfo struct {
    CollectionConfig   *common.CollectionConfigPackage
    CommittingBlockNum uint64
}

CollectionConfigInfo encapsulates a collection config for a chaincode and its committing block number

type CollectionPvtdataInfo Uses

type CollectionPvtdataInfo struct {
    Namespace, Collection string
    ExpectedHash          []byte
    CollectionConfig      *common.StaticCollectionConfig
    Endorsers             []*peer.Endorsement
}

CollectionPvtdataInfo contains information about the private data for a given collection

type CommitOptions Uses

type CommitOptions struct {
    FetchPvtDataFromLedger bool
}

CommitOptions encapsulates options associated with a block commit.

type Config Uses

type Config struct {
    // RootFSPath is the top-level directory where ledger files are stored.
    RootFSPath string
    // StateDBConfig holds the configuration parameters for the state database.
    StateDBConfig *StateDBConfig
    // PrivateDataConfig holds the configuration parameters for the private data store.
    PrivateDataConfig *PrivateDataConfig
    // HistoryDBConfig holds the configuration parameters for the transaction history database.
    HistoryDBConfig *HistoryDBConfig
}

Config is a structure used to configure a ledger provider.

type ConfigHistoryRetriever Uses

type ConfigHistoryRetriever interface {
    CollectionConfigAt(blockNum uint64, chaincodeName string) (*CollectionConfigInfo, error)
    MostRecentCollectionConfigBelow(blockNum uint64, chaincodeName string) (*CollectionConfigInfo, error)
}

ConfigHistoryRetriever allow retrieving history of collection configs

type CustomTxProcessor Uses

type CustomTxProcessor interface {
    GenerateSimulationResults(txEnvelop *common.Envelope, simulator TxSimulator, initializingLedger bool) error
}

CustomTxProcessor allows to generate simulation results during commit time for custom transactions. A custom processor may represent the information in a propriety fashion and can use this process to translate the information into the form of `TxSimulationResults`. Because, the original information is signed in a custom representation, an implementation of a `Processor` should be cautious that the custom representation is used for simulation in an deterministic fashion and should take care of compatibility cross fabric versions. 'initializingLedger' true indicates that either the transaction being processed is from the genesis block or the ledger is synching the state (which could happen during peer startup if the statedb is found to be lagging behind the blockchain). In the former case, the transactions processed are expected to be valid and in the latter case, only valid transactions are reprocessed and hence any validation can be skipped.

type DeployedChaincodeInfo Uses

type DeployedChaincodeInfo struct {
    Name                        string
    Hash                        []byte
    Version                     string
    ExplicitCollectionConfigPkg *common.CollectionConfigPackage
    IsLegacy                    bool
}

DeployedChaincodeInfo encapsulates chaincode information from the deployed chaincodes

type DeployedChaincodeInfoProvider Uses

type DeployedChaincodeInfoProvider interface {
    // Namespaces returns the slice of the namespaces that are used for maintaining chaincode lifecycle data
    Namespaces() []string
    // UpdatedChaincodes returns the chaincodes that are getting updated by the supplied 'stateUpdates'
    UpdatedChaincodes(stateUpdates map[string][]*kvrwset.KVWrite) ([]*ChaincodeLifecycleInfo, error)
    // ChaincodeInfo returns the info about a deployed chaincode
    ChaincodeInfo(channelName, chaincodeName string, qe SimpleQueryExecutor) (*DeployedChaincodeInfo, error)
    // CollectionInfo returns the proto msg that defines the named collection. This function can be called for both explicit and implicit collections
    CollectionInfo(channelName, chaincodeName, collectionName string, qe SimpleQueryExecutor) (*common.StaticCollectionConfig, error)
    // ImplicitCollections returns a slice that contains one proto msg for each of the implicit collections
    ImplicitCollections(channelName, chaincodeName string, qe SimpleQueryExecutor) ([]*common.StaticCollectionConfig, error)
    // AllCollectionsConfigPkg returns a combined collection config pkg that contains both explicit and implicit collections
    AllCollectionsConfigPkg(channelName, chaincodeName string, qe SimpleQueryExecutor) (*common.CollectionConfigPackage, error)
}

DeployedChaincodeInfoProvider is a dependency that is used by ledger to build collection config history LSCC module is expected to provide an implementation for this dependencies

type ErrCollectionConfigNotYetAvailable Uses

type ErrCollectionConfigNotYetAvailable struct {
    MaxBlockNumCommitted uint64
    Msg                  string
}

ErrCollectionConfigNotYetAvailable is an error which is returned from the function ConfigHistoryRetriever.CollectionConfigAt() if the latest block number committed is lower than the block number specified in the request.

func (*ErrCollectionConfigNotYetAvailable) Error Uses

func (e *ErrCollectionConfigNotYetAvailable) Error() string

type Hasher Uses

type Hasher interface {
    Hash(msg []byte, opts bccsp.HashOpts) (hash []byte, err error)
}

Hasher implements the hash function that should be used for all ledger components. Currently works at a stepping stone to decrease surface area of bccsp

type HealthCheckRegistry Uses

type HealthCheckRegistry interface {
    RegisterChecker(string, healthz.HealthChecker) error
}

type HistoryDBConfig Uses

type HistoryDBConfig struct {
    Enabled bool
}

HistoryDBConfig is a structure used to configure the transaction history database.

type HistoryQueryExecutor Uses

type HistoryQueryExecutor interface {
    // GetHistoryForKey retrieves the history of values for a key.
    // The returned ResultsIterator contains results of type *KeyModification which is defined in fabric-protos/ledger/queryresult.
    GetHistoryForKey(namespace string, key string) (commonledger.ResultsIterator, error)
}

HistoryQueryExecutor executes the history queries

type Initializer Uses

type Initializer struct {
    StateListeners                  []StateListener
    DeployedChaincodeInfoProvider   DeployedChaincodeInfoProvider
    MembershipInfoProvider          MembershipInfoProvider
    ChaincodeLifecycleEventProvider ChaincodeLifecycleEventProvider
    MetricsProvider                 metrics.Provider
    HealthCheckRegistry             HealthCheckRegistry
    Config                          *Config
    CustomTxProcessors              map[common.HeaderType]CustomTxProcessor
    Hasher                          Hasher
}

Initializer encapsulates dependencies for PeerLedgerProvider

type InvalidCollNameError Uses

type InvalidCollNameError struct {
    Ns, Coll string
}

InvalidCollNameError is returned whenever an operation is requested on a collection whose name is invalid

func (*InvalidCollNameError) Error Uses

func (e *InvalidCollNameError) Error() string

type InvalidTxError Uses

type InvalidTxError struct {
    Msg string
}

InvalidTxError is expected to be thrown by a custom transaction processor if it wants the ledger to record a particular transaction as invalid

func (*InvalidTxError) Error Uses

func (e *InvalidTxError) Error() string

type KVStateUpdates Uses

type KVStateUpdates struct {
    PublicUpdates   []*kvrwset.KVWrite
    CollHashUpdates map[string][]*kvrwset.KVWriteHash
}

KVStateUpdates captures the state updates for a namespace for KV datamodel

type MembershipInfoProvider Uses

type MembershipInfoProvider interface {
    // AmMemberOf checks whether the current peer is a member of the given collection
    AmMemberOf(channelName string, collectionPolicyConfig *common.CollectionPolicyConfig) (bool, error)
}

MembershipInfoProvider is a dependency that is used by ledger to determine whether the current peer is a member of a collection. Gossip module is expected to provide the dependency to ledger

type MissingBlockPvtdataInfo Uses

type MissingBlockPvtdataInfo map[uint64][]*MissingCollectionPvtDataInfo

MissingBlockPvtdataInfo is a map of transaction number (within the block) to MissingCollectionPvtDataInfo

type MissingCollectionPvtDataInfo Uses

type MissingCollectionPvtDataInfo struct {
    Namespace, Collection string
}

MissingCollectionPvtDataInfo includes the name of the chaincode and collection for which private data is missing

type MissingPvtData Uses

type MissingPvtData struct {
    Namespace  string
    Collection string
    IsEligible bool
}

MissingPvtData contains a namespace and collection for which the pvtData is not present. It also denotes whether the missing pvtData is eligible (i.e., whether the peer is member of the [namespace, collection]

type MissingPvtDataInfo Uses

type MissingPvtDataInfo map[uint64]MissingBlockPvtdataInfo

MissingPvtDataInfo is a map of block number to MissingBlockPvtdataInfo

func (MissingPvtDataInfo) Add Uses

func (missingPvtDataInfo MissingPvtDataInfo) Add(blkNum, txNum uint64, ns, coll string)

Add adds a missing data entry to the MissingPvtDataInfo Map

type MissingPvtDataTracker Uses

type MissingPvtDataTracker interface {
    GetMissingPvtDataInfoForMostRecentBlocks(maxBlocks int) (MissingPvtDataInfo, error)
}

MissingPvtDataTracker allows getting information about the private data that is not missing on the peer

type NotFoundInIndexErr Uses

type NotFoundInIndexErr string

NotFoundInIndexErr is used to indicate missing entry in the index

func (NotFoundInIndexErr) Error Uses

func (NotFoundInIndexErr) Error() string

type PeerLedger Uses

type PeerLedger interface {
    commonledger.Ledger
    // GetTransactionByID retrieves a transaction by id
    GetTransactionByID(txID string) (*peer.ProcessedTransaction, error)
    // GetBlockByHash returns a block given it's hash
    GetBlockByHash(blockHash []byte) (*common.Block, error)
    // GetBlockByTxID returns a block which contains a transaction
    GetBlockByTxID(txID string) (*common.Block, error)
    // GetTxValidationCodeByTxID returns reason code of transaction validation
    GetTxValidationCodeByTxID(txID string) (peer.TxValidationCode, error)
    // NewTxSimulator gives handle to a transaction simulator.
    // A client can obtain more than one 'TxSimulator's for parallel execution.
    // Any snapshoting/synchronization should be performed at the implementation level if required
    NewTxSimulator(txid string) (TxSimulator, error)
    // NewQueryExecutor gives handle to a query executor.
    // A client can obtain more than one 'QueryExecutor's for parallel execution.
    // Any synchronization should be performed at the implementation level if required
    NewQueryExecutor() (QueryExecutor, error)
    // NewHistoryQueryExecutor gives handle to a history query executor.
    // A client can obtain more than one 'HistoryQueryExecutor's for parallel execution.
    // Any synchronization should be performed at the implementation level if required
    NewHistoryQueryExecutor() (HistoryQueryExecutor, error)
    // GetPvtDataAndBlockByNum returns the block and the corresponding pvt data.
    // The pvt data is filtered by the list of 'ns/collections' supplied
    // A nil filter does not filter any results and causes retrieving all the pvt data for the given blockNum
    GetPvtDataAndBlockByNum(blockNum uint64, filter PvtNsCollFilter) (*BlockAndPvtData, error)
    // GetPvtDataByNum returns only the pvt data  corresponding to the given block number
    // The pvt data is filtered by the list of 'ns/collections' supplied in the filter
    // A nil filter does not filter any results and causes retrieving all the pvt data for the given blockNum
    GetPvtDataByNum(blockNum uint64, filter PvtNsCollFilter) ([]*TxPvtData, error)
    // CommitLegacy commits the block and the corresponding pvt data in an atomic operation following the v14 validation/commit path
    // TODO: add a new Commit() path that replaces CommitLegacy() for the validation refactor described in FAB-12221
    CommitLegacy(blockAndPvtdata *BlockAndPvtData, commitOpts *CommitOptions) error
    // GetConfigHistoryRetriever returns the ConfigHistoryRetriever
    GetConfigHistoryRetriever() (ConfigHistoryRetriever, error)
    // CommitPvtDataOfOldBlocks commits the private data corresponding to already committed block
    // If hashes for some of the private data supplied in this function does not match
    // the corresponding hash present in the block, the unmatched private data is not
    // committed and instead the mismatch inforation is returned back
    CommitPvtDataOfOldBlocks(reconciledPvtdata []*ReconciledPvtdata) ([]*PvtdataHashMismatch, error)
    // GetMissingPvtDataTracker return the MissingPvtDataTracker
    GetMissingPvtDataTracker() (MissingPvtDataTracker, error)
    // DoesPvtDataInfoExist returns true when
    // (1) the ledger has pvtdata associated with the given block number (or)
    // (2) a few or all pvtdata associated with the given block number is missing but the
    //     missing info is recorded in the ledger (or)
    // (3) the block is committed and does not contain any pvtData.
    DoesPvtDataInfoExist(blockNum uint64) (bool, error)
}

PeerLedger differs from the OrdererLedger in that PeerLedger locally maintain a bitmask that tells apart valid transactions from invalid ones

type PeerLedgerProvider Uses

type PeerLedgerProvider interface {
    // Create creates a new ledger with the given genesis block.
    // This function guarantees that the creation of ledger and committing the genesis block would an atomic action
    // The chain id retrieved from the genesis block is treated as a ledger id
    Create(genesisBlock *common.Block) (PeerLedger, error)
    // Open opens an already created ledger
    Open(ledgerID string) (PeerLedger, error)
    // Exists tells whether the ledger with given id exists
    Exists(ledgerID string) (bool, error)
    // List lists the ids of the existing ledgers
    List() ([]string, error)
    // Close closes the PeerLedgerProvider
    Close()
}

PeerLedgerProvider provides handle to ledger instances

type PrivateDataConfig Uses

type PrivateDataConfig struct {
    // BatchesInterval is the minimum duration (milliseconds) between batches
    // for converting ineligible missing data entries into eligible entries.
    BatchesInterval int
    // MatchBatchSize is the maximum size of batches when converting ineligible
    // missing data entries into eligible entries.
    MaxBatchSize int
    // PurgeInterval is the number of blocks to wait until purging expired
    // private data entries.
    PurgeInterval int
}

PrivateDataConfig is a structure used to configure a private data storage provider.

type PvtCollFilter Uses

type PvtCollFilter map[string]bool

PvtCollFilter represents the set of the collection names (as keys of the map with value 'true')

type PvtNsCollFilter Uses

type PvtNsCollFilter map[string]PvtCollFilter

PvtNsCollFilter specifies the tuple <namespace, PvtCollFilter>

func NewPvtNsCollFilter Uses

func NewPvtNsCollFilter() PvtNsCollFilter

NewPvtNsCollFilter constructs an empty PvtNsCollFilter

func (PvtNsCollFilter) Add Uses

func (filter PvtNsCollFilter) Add(ns string, coll string)

Add adds a namespace-collection tuple to the filter

func (PvtNsCollFilter) Has Uses

func (filter PvtNsCollFilter) Has(ns string, coll string) bool

Has returns true if the filter has the entry for tuple namespace-collection

type PvtdataHashMismatch Uses

type PvtdataHashMismatch struct {
    BlockNum, TxNum       uint64
    Namespace, Collection string
    ExpectedHash          []byte
}

PvtdataHashMismatch is used when the hash of private write-set does not match the corresponding hash present in the block See function `PeerLedger.CommitPvtData` for the usages

type QueryExecutor Uses

type QueryExecutor interface {
    SimpleQueryExecutor
    // GetStateMetadata returns the metadata for given namespace and key
    GetStateMetadata(namespace, key string) (map[string][]byte, error)
    // GetStateMultipleKeys gets the values for multiple keys in a single call
    GetStateMultipleKeys(namespace string, keys []string) ([][]byte, error)
    // GetStateRangeScanIteratorWithMetadata returns an iterator that contains all the key-values between given key ranges.
    // startKey is included in the results and endKey is excluded. An empty startKey refers to the first available key
    // and an empty endKey refers to the last available key. For scanning all the keys, both the startKey and the endKey
    // can be supplied as empty strings. However, a full scan should be used judiciously for performance reasons.
    // metadata is a map of additional query parameters
    // The returned ResultsIterator contains results of type *KV which is defined in fabric-protos/ledger/queryresult.
    GetStateRangeScanIteratorWithMetadata(namespace string, startKey, endKey string, metadata map[string]interface{}) (QueryResultsIterator, error)
    // ExecuteQuery executes the given query and returns an iterator that contains results of type specific to the underlying data store.
    // Only used for state databases that support query
    // For a chaincode, the namespace corresponds to the chaincodeId
    // The returned ResultsIterator contains results of type *KV which is defined in fabric-protos/ledger/queryresult.
    ExecuteQuery(namespace, query string) (commonledger.ResultsIterator, error)
    // ExecuteQueryWithMetadata executes the given query and returns an iterator that contains results of type specific to the underlying data store.
    // metadata is a map of additional query parameters
    // Only used for state databases that support query
    // For a chaincode, the namespace corresponds to the chaincodeId
    // The returned ResultsIterator contains results of type *KV which is defined in fabric-protos/ledger/queryresult.
    ExecuteQueryWithMetadata(namespace, query string, metadata map[string]interface{}) (QueryResultsIterator, error)
    // GetPrivateData gets the value of a private data item identified by a tuple <namespace, collection, key>
    GetPrivateData(namespace, collection, key string) ([]byte, error)
    // GetPrivateDataMetadata gets the metadata of a private data item identified by a tuple <namespace, collection, key>
    GetPrivateDataMetadata(namespace, collection, key string) (map[string][]byte, error)
    // GetPrivateDataMetadataByHash gets the metadata of a private data item identified by a tuple <namespace, collection, keyhash>
    GetPrivateDataMetadataByHash(namespace, collection string, keyhash []byte) (map[string][]byte, error)
    // GetPrivateDataMultipleKeys gets the values for the multiple private data items in a single call
    GetPrivateDataMultipleKeys(namespace, collection string, keys []string) ([][]byte, error)
    // GetPrivateDataRangeScanIterator returns an iterator that contains all the key-values between given key ranges.
    // startKey is included in the results and endKey is excluded. An empty startKey refers to the first available key
    // and an empty endKey refers to the last available key. For scanning all the keys, both the startKey and the endKey
    // can be supplied as empty strings. However, a full scan shuold be used judiciously for performance reasons.
    // The returned ResultsIterator contains results of type *KV which is defined in fabric-protos/ledger/queryresult.
    GetPrivateDataRangeScanIterator(namespace, collection, startKey, endKey string) (commonledger.ResultsIterator, error)
    // ExecuteQuery executes the given query and returns an iterator that contains results of type specific to the underlying data store.
    // Only used for state databases that support query
    // For a chaincode, the namespace corresponds to the chaincodeId
    // The returned ResultsIterator contains results of type *KV which is defined in fabric-protos/ledger/queryresult.
    ExecuteQueryOnPrivateData(namespace, collection, query string) (commonledger.ResultsIterator, error)
    // Done releases resources occupied by the QueryExecutor
    Done()
}

QueryExecutor executes the queries Get* methods are for supporting KV-based data model. ExecuteQuery method is for supporting a rich datamodel and query support

ExecuteQuery method in the case of a rich data model is expected to support queries on latest state, historical state and on the intersection of state and transactions

type QueryResultsIterator Uses

type QueryResultsIterator interface {
    commonledger.ResultsIterator
    // GetBookmarkAndClose returns a paging bookmark and releases resources occupied by the iterator
    GetBookmarkAndClose() string
}

QueryResultsIterator - an iterator for query result set

type ReconciledPvtdata Uses

type ReconciledPvtdata struct {
    BlockNum  uint64
    WriteSets TxPvtDataMap
}

ReconciledPvtdata contains the private data for a block for reconciliation

type RetrievedPvtdata Uses

type RetrievedPvtdata interface {
    GetBlockPvtdata() *BlockPvtdata
    Purge()
}

RetrievedPvtdata is a dependency that is implemented by coordinator/gossip for ledger to be able to purge the transactions from the block after retrieving private data

type SimpleQueryExecutor Uses

type SimpleQueryExecutor interface {
    // GetState gets the value for given namespace and key. For a chaincode, the namespace corresponds to the chaincodeId
    GetState(namespace string, key string) ([]byte, error)
    // GetStateRangeScanIterator returns an iterator that contains all the key-values between given key ranges.
    // startKey is included in the results and endKey is excluded. An empty startKey refers to the first available key
    // and an empty endKey refers to the last available key. For scanning all the keys, both the startKey and the endKey
    // can be supplied as empty strings. However, a full scan should be used judiciously for performance reasons.
    // The returned ResultsIterator contains results of type *KV which is defined in fabric-protos/ledger/queryresult.
    GetStateRangeScanIterator(namespace string, startKey string, endKey string) (commonledger.ResultsIterator, error)
    // GetPrivateDataHash gets the hash of the value of a private data item identified by a tuple <namespace, collection, key>
    // Function `GetPrivateData` is only meaningful when it is invoked on a peer that is authorized to have the private data
    // for the collection <namespace, collection>. However, the function `GetPrivateDataHash` can be invoked on any peer
    // to get the hash of the current value
    GetPrivateDataHash(namespace, collection, key string) ([]byte, error)
}

SimpleQueryExecutor encapsulates basic functions

type StateDBConfig Uses

type StateDBConfig struct {
    // StateDatabase is the database to use for storing last known state.  The
    // two supported options are "goleveldb" and "CouchDB".
    StateDatabase string
    // CouchDB is the configuration for CouchDB.  It is used when StateDatabase
    // is set to "CouchDB".
    CouchDB *couchdb.Config
}

StateDBConfig is a structure used to configure the state parameters for the ledger.

type StateListener Uses

type StateListener interface {
    Initialize(ledgerID string, qe SimpleQueryExecutor) error
    InterestedInNamespaces() []string
    HandleStateUpdates(trigger *StateUpdateTrigger) error
    StateCommitDone(channelID string)
}

StateListener allows a custom code for performing additional stuff upon state change for a particular namespace against which the listener is registered. This helps to perform custom tasks other than the state updates. A ledger implementation is expected to invoke Function `HandleStateUpdates` once per block and the `stateUpdates` parameter passed to the function captures the state changes caused by the block for the namespace. The actual data type of stateUpdates depends on the data model enabled. For instance, for KV data model, the actual type would be proto message `github.com/hyperledger/fabric-protos-go/ledger/rwset/kvrwset.KVWrite` Function `HandleStateUpdates` is expected to be invoked before block is committed and if this function returns an error, the ledger implementation is expected to halt block commit operation and result in a panic. The function Initialize is invoked only once at the time of opening the ledger.

type StateUpdateTrigger Uses

type StateUpdateTrigger struct {
    LedgerID                    string
    StateUpdates                StateUpdates
    CommittingBlockNum          uint64
    CommittedStateQueryExecutor SimpleQueryExecutor
    PostCommitQueryExecutor     SimpleQueryExecutor
}

StateUpdateTrigger encapsulates the information and helper tools that may be used by a StateListener

type StateUpdates Uses

type StateUpdates map[string]*KVStateUpdates

StateUpdates encapsulates the state updates

type TxMissingPvtDataMap Uses

type TxMissingPvtDataMap map[uint64][]*MissingPvtData

TxMissingPvtDataMap is a map from txNum to the list of missing pvtData

func (TxMissingPvtDataMap) Add Uses

func (txMissingPvtData TxMissingPvtDataMap) Add(txNum uint64, ns, coll string, isEligible bool)

Add adds a given missing private data in the MissingPrivateDataList

type TxPvtData Uses

type TxPvtData struct {
    SeqInBlock uint64
    WriteSet   *rwset.TxPvtReadWriteSet
}

TxPvtData encapsulates the transaction number and pvt write-set for a transaction

func (*TxPvtData) Has Uses

func (pvtdata *TxPvtData) Has(ns string, coll string) bool

Has returns true if the pvtdata includes the data for collection <ns,coll>

type TxPvtDataMap Uses

type TxPvtDataMap map[uint64]*TxPvtData

TxPvtDataMap is a map from txNum to the pvtData

type TxPvtdataInfo Uses

type TxPvtdataInfo struct {
    TxID                  string
    Invalid               bool
    SeqInBlock            uint64
    CollectionPvtdataInfo []*CollectionPvtdataInfo
}

TxPvtdataInfo captures information about the requested private data to be retrieved

type TxSimulationResults Uses

type TxSimulationResults struct {
    PubSimulationResults *rwset.TxReadWriteSet
    PvtSimulationResults *rwset.TxPvtReadWriteSet
}

TxSimulationResults captures the details of the simulation results

func (*TxSimulationResults) ContainsPvtWrites Uses

func (txSim *TxSimulationResults) ContainsPvtWrites() bool

ContainsPvtWrites returns true if the simulation results include the private writes

func (*TxSimulationResults) GetPubSimulationBytes Uses

func (txSim *TxSimulationResults) GetPubSimulationBytes() ([]byte, error)

GetPubSimulationBytes returns the serialized bytes of public readwrite set

func (*TxSimulationResults) GetPvtSimulationBytes Uses

func (txSim *TxSimulationResults) GetPvtSimulationBytes() ([]byte, error)

GetPvtSimulationBytes returns the serialized bytes of private readwrite set

type TxSimulator Uses

type TxSimulator interface {
    QueryExecutor
    // SetState sets the given value for the given namespace and key. For a chaincode, the namespace corresponds to the chaincodeId
    SetState(namespace string, key string, value []byte) error
    // DeleteState deletes the given namespace and key
    DeleteState(namespace string, key string) error
    // SetMultipleKeys sets the values for multiple keys in a single call
    SetStateMultipleKeys(namespace string, kvs map[string][]byte) error
    // SetStateMetadata sets the metadata associated with an existing key-tuple <namespace, key>
    SetStateMetadata(namespace, key string, metadata map[string][]byte) error
    // DeleteStateMetadata deletes the metadata (if any) associated with an existing key-tuple <namespace, key>
    DeleteStateMetadata(namespace, key string) error
    // ExecuteUpdate for supporting rich data model (see comments on QueryExecutor above)
    ExecuteUpdate(query string) error
    // SetPrivateData sets the given value to a key in the private data state represented by the tuple <namespace, collection, key>
    SetPrivateData(namespace, collection, key string, value []byte) error
    // SetPrivateDataMultipleKeys sets the values for multiple keys in the private data space in a single call
    SetPrivateDataMultipleKeys(namespace, collection string, kvs map[string][]byte) error
    // DeletePrivateData deletes the given tuple <namespace, collection, key> from private data
    DeletePrivateData(namespace, collection, key string) error
    // SetPrivateDataMetadata sets the metadata associated with an existing key-tuple <namespace, collection, key>
    SetPrivateDataMetadata(namespace, collection, key string, metadata map[string][]byte) error
    // DeletePrivateDataMetadata deletes the metadata associated with an existing key-tuple <namespace, collection, key>
    DeletePrivateDataMetadata(namespace, collection, key string) error
    // GetTxSimulationResults encapsulates the results of the transaction simulation.
    // This should contain enough detail for
    // - The update in the state that would be caused if the transaction is to be committed
    // - The environment in which the transaction is executed so as to be able to decide the validity of the environment
    //   (at a later time on a different peer) during committing the transactions
    // Different ledger implementation (or configurations of a single implementation) may want to represent the above two pieces
    // of information in different way in order to support different data-models or optimize the information representations.
    // Returned type 'TxSimulationResults' contains the simulation results for both the public data and the private data.
    // The public data simulation results are expected to be used as in V1 while the private data simulation results are expected
    // to be used by the gossip to disseminate this to the other endorsers (in phase-2 of sidedb)
    GetTxSimulationResults() (*TxSimulationResults, error)
}

TxSimulator simulates a transaction on a consistent snapshot of the 'as recent state as possible' Set* methods are for supporting KV-based data model. ExecuteUpdate method is for supporting a rich datamodel and query support

Directories

PathSynopsis
cceventmgmt
confighistory
customtx
kvledger
kvledger/bookkeeping
kvledger/history/historydb
kvledger/history/historydb/historyleveldb
kvledger/history/historydb/historyleveldb/fakesCode generated by counterfeiter.
kvledger/msgs
kvledger/tests
kvledger/txmgmt/privacyenabledstatePackage privacyenabledstate is a generated protocol buffer package.
kvledger/txmgmt/pvtstatepurgemgmt
kvledger/txmgmt/queryutil
kvledger/txmgmt/queryutil/mockCode generated by counterfeiter.
kvledger/txmgmt/rwsetutil
kvledger/txmgmt/statedb
kvledger/txmgmt/statedb/commontests
kvledger/txmgmt/statedb/mockCode generated by counterfeiter.
kvledger/txmgmt/statedb/statecouchdb
kvledger/txmgmt/statedb/statecouchdb/msgs
kvledger/txmgmt/statedb/stateleveldb
kvledger/txmgmt/statedb/stateleveldb/msgs
kvledger/txmgmt/storageutil
kvledger/txmgmt/txmgr
kvledger/txmgmt/txmgr/lockbasedtxmgr
kvledger/txmgmt/validator
kvledger/txmgmt/validator/internal
kvledger/txmgmt/validator/statebasedval
kvledger/txmgmt/validator/valimpl
kvledger/txmgmt/version
ledgerconfig
ledgermgmt
ledgermgmt/ledgermgmttest
ledgerstorage
mockCode generated by counterfeiter.
pvtdatapolicy
pvtdatapolicy/mockCode generated by counterfeiter.
pvtdatapolicy/testutil
pvtdatastorage
testutil
util
util/couchdb

Package ledger imports 11 packages (graph) and is imported by 320 packages. Updated 2019-11-14. Refresh now. Tools for package owners.