dataRetriever

package
v0.0.2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 31, 2023 License: GPL-3.0 Imports: 21 Imported by: 0

Documentation

Index

Constants

View Source 
const RewardTxPoolName = "rewardTxPool"

RewardTxPoolName defines the name of the reward transactions pool

View Source 
const TxPoolNumSendersToPreemptivelyEvict = uint32(100)

TxPoolNumSendersToPreemptivelyEvict instructs tx pool eviction algorithm to remove this many senders when eviction takes place

View Source 
const TxPoolNumTxsToPreemptivelyEvict = uint32(1000)

TxPoolNumTxsToPreemptivelyEvict instructs tx pool eviction algorithm to remove this many transactions when eviction takes place

View Source 
const UnsignedTxPoolName = "uTxPool"

UnsignedTxPoolName defines the name of the unsigned transactions pool

Variables

View Source 
var (
	ErrInvalidLengthRequestData        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowRequestData          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupRequestData = fmt.Errorf("proto: unexpected end of group")
)
View Source 
var ErrBadRequest = errors.New("request should not be done as it doesn't follow the protocol")

ErrBadRequest signals that the request should not have happened

View Source 
var ErrCacheConfigInvalidEconomics = errors.New("cache-economics parameter is not valid")

ErrCacheConfigInvalidEconomics signals that an economics parameter required by the cache is invalid

View Source 
var ErrCacheConfigInvalidSharding = errors.New("cache-sharding parameter is not valid")

ErrCacheConfigInvalidSharding signals that a sharding parameter required by the cache is invalid

View Source 
var ErrCacheConfigInvalidShards = errors.New("cache parameter [shards] is not valid, it must be a positive number")

ErrCacheConfigInvalidShards signals that the cache parameter "shards" is invalid

View Source 
var ErrCacheConfigInvalidSize = errors.New("cache parameter [size] is not valid, it must be a positive number")

ErrCacheConfigInvalidSize signals that the cache parameter "size" is invalid

View Source 
var ErrCacheConfigInvalidSizeInBytes = errors.New("cache parameter [sizeInBytes] is not valid, it must be a positive, and large enough number")

ErrCacheConfigInvalidSizeInBytes signals that the cache parameter "sizeInBytes" is invalid

View Source 
var ErrContainerKeyAlreadyExists = errors.New("provided key already exists in container")

ErrContainerKeyAlreadyExists signals that an element was already set in the container's map

View Source 
var ErrEmptyString = errors.New("empty string")

ErrEmptyString signals that an empty string has been provided

View Source 
var ErrInvalidContainerKey = errors.New("element does not exist in container")

ErrInvalidContainerKey signals that an element does not exist in the container's map

View Source 
var ErrInvalidMaxTxRequest = errors.New("max tx request number is invalid")

ErrInvalidMaxTxRequest signals that max tx request is too small

View Source 
var ErrInvalidNonceByteSlice = errors.New("invalid nonce byte slice")

ErrInvalidNonceByteSlice signals that an invalid byte slice has been provided and an uint64 can not be decoded from that byte slice

View Source 
var ErrInvalidValue = errors.New("invalid value")

ErrInvalidValue signals that an invalid value has been provided

View Source 
var ErrLenMismatch = errors.New("lengths mismatch")

ErrLenMismatch signals that 2 or more slices have different lengths

View Source 
var ErrMissingData = errors.New("missing data")

ErrMissingData signals that the required data is missing

View Source 
var ErrNilAntifloodHandler = errors.New("nil antiflood handler")

ErrNilAntifloodHandler signals that a nil antiflood handler has been provided

View Source 
var ErrNilConfig = errors.New("nil config provided")

ErrNilConfig signals that a nil config has been provided

View Source 
var ErrNilContainerElement = errors.New("element cannot be nil")

ErrNilContainerElement signals when trying to add a nil element in the container

View Source 
var ErrNilCurrBlockTxs = errors.New("nil current block txs holder")

ErrNilCurrBlockTxs signals that nil current blocks txs holder was provided

View Source 
var ErrNilDataPacker = errors.New("nil data packer provided")

ErrNilDataPacker signals that a nil data packer has been provided

View Source 
var ErrNilDataPoolHolder = errors.New("nil data pool holder")

ErrNilDataPoolHolder signals that the data pool holder is nil

View Source 
var ErrNilDataToProcess = errors.New("nil data to process")

ErrNilDataToProcess signals that nil data was provided

View Source 
var ErrNilEconomicsData = errors.New("nil economics data provided")

ErrNilEconomicsData signals that a nil economics data handler has been provided

View Source 
var ErrNilEpochHandler = errors.New("nil epoch handler")

ErrNilEpochHandler signals that epoch handler is nil

View Source 
var ErrNilHeadersDataPool = errors.New("nil headers data pool")

ErrNilHeadersDataPool signals that a nil header pool has been provided

View Source 
var ErrNilHeadersNoncesStorage = errors.New("nil headers nonces storage")

ErrNilHeadersNoncesStorage signals that a nil header-nonce storage has been provided

View Source 
var ErrNilHeadersStorage = errors.New("nil headers storage")

ErrNilHeadersStorage signals that a nil header storage has been provided

View Source 
var ErrNilMarshalizer = errors.New("nil Marshalizer")

ErrNilMarshalizer signals that an operation has been attempted to or with a nil Marshalizer implementation

View Source 
var ErrNilMessage = errors.New("nil message")

ErrNilMessage signals that a nil message has been received

View Source 
var ErrNilMessenger = errors.New("nil Messenger")

ErrNilMessenger signals that a nil Messenger object was provided

View Source 
var ErrNilMiniblocksPool = errors.New("nil miniblocks pool")

ErrNilMiniblocksPool signals that a nil miniblocks pool has been provided

View Source 
var ErrNilMiniblocksStorage = errors.New("nil miniblocks storage")

ErrNilMiniblocksStorage signals that a nil miniblocks storage has been provided

View Source 
var ErrNilPeerChangeBlockDataPool = errors.New("nil peer change block data pool")

ErrNilPeerChangeBlockDataPool signals that a nil peer change pool has been provided

View Source 
var ErrNilPeerListCreator = errors.New("nil peer list creator provided")

ErrNilPeerListCreator signals that a nil peer list creator implementation has been provided

View Source 
var ErrNilRandomizer = errors.New("nil randomizer")

ErrNilRandomizer signals that a nil randomizer has been provided

View Source 
var ErrNilRequestedItemsHandler = errors.New("nil requested items handler")

ErrNilRequestedItemsHandler signals that a nil requested items handler was provided

View Source 
var ErrNilResolverContainer = errors.New("nil resolver container")

ErrNilResolverContainer signals that a nil resolver container was provided

View Source 
var ErrNilResolverDebugHandler = errors.New("nil resolver debug handler")

ErrNilResolverDebugHandler signals that a nil resolver debug handler has been provided

View Source 
var ErrNilResolverFinder = errors.New("nil resolvers finder")

ErrNilResolverFinder signals that a nil resolver finder has been provided

View Source 
var ErrNilResolverSender = errors.New("nil resolver sender")

ErrNilResolverSender signals that a nil resolver sender object has been provided

View Source 
var ErrNilRewardTransactionPool = errors.New("nil reward transaction data pool")

ErrNilRewardTransactionPool signals that a nil reward transactions pool has been provided

View Source 
var ErrNilShardCoordinator = errors.New("nil shard coordinator")

ErrNilShardCoordinator signals that an operation has been attempted to or with a nil shard coordinator

View Source 
var ErrNilStore = errors.New("nil data storage service")

ErrNilStore signals that the provided storage service is nil

View Source 
var ErrNilThrottler = errors.New("nil throttler")

ErrNilThrottler signals that a nil throttler has been provided

View Source 
var ErrNilTrieDataGetter = errors.New("nil trie data getter provided")

ErrNilTrieDataGetter signals that a nil trie data getter has been provided

View Source 
var ErrNilTrieNodesPool = errors.New("nil trie nodes data pool")

ErrNilTrieNodesPool signals that a nil trie nodes data pool was provided

View Source 
var ErrNilTxBlockDataPool = errors.New("nil tx block data pool")

ErrNilTxBlockDataPool signals that a nil tx block body pool has been provided

View Source 
var ErrNilTxDataPool = errors.New("nil transaction data pool")

ErrNilTxDataPool signals that a nil transaction pool has been provided

View Source 
var ErrNilTxStorage = errors.New("nil transaction storage")

ErrNilTxStorage signals that a nil transaction storage has been provided

View Source 
var ErrNilUint64ByteSliceConverter = errors.New("nil byte slice converter")

ErrNilUint64ByteSliceConverter signals that a nil byte slice converter was provided

View Source 
var ErrNilUnsignedTransactionPool = errors.New("nil unsigned transactions data pool")

ErrNilUnsignedTransactionPool signals that a nil unsigned transactions pool has been provided

View Source 
var ErrNilValue = errors.New("nil value")

ErrNilValue signals the value is nil

View Source 
var ErrNilWhiteListHandler = errors.New("nil white list handler")

ErrNilWhiteListHandler signals that white list handler is nil

View Source 
var ErrNoSuchStorageUnit = errors.New("no such unit type")

ErrNoSuchStorageUnit defines the error for using an invalid storage unit

View Source 
var ErrRequestIntervalTooSmall = errors.New("request interval is too small")

ErrRequestIntervalTooSmall signals that request interval is too small

View Source 
var ErrRequestTypeNotImplemented = errors.New("request type is not implemented")

ErrRequestTypeNotImplemented signals that a not implemented type of request has been received

View Source 
var ErrResolveTypeUnknown = errors.New("unknown resolve type")

ErrResolveTypeUnknown signals that an unknown resolve type was provided

View Source 
var ErrSendRequest = errors.New("cannot send request: peer list is empty or errors during the sending")

ErrSendRequest signals that the connected peers list is empty or errors appeared when sending requests

View Source 
var ErrSystemBusy = errors.New("system busy")

ErrSystemBusy signals that the system is busy and can not process more requests

View Source 
var ErrTxNotFoundInBlockPool = errors.New("cannot find tx in current block pool")

ErrTxNotFoundInBlockPool signals the value is nil

View Source 
var ErrWrongTypeInContainer = errors.New("wrong type of object inside container")

ErrWrongTypeInContainer signals that a wrong type of object was found in container

View Source 
var RequestDataType_name = map[int32]string{
	0: "InvalidType",
	1: "HashType",
	2: "HashArrayType",
	3: "NonceType",
	4: "EpochType",
}
View Source 
var RequestDataType_value = map[string]int32{
	"InvalidType":   0,
	"HashType":      1,
	"HashArrayType": 2,
	"NonceType":     3,
	"EpochType":     4,
}

Functions

func SetEpochHandlerToHdrResolver 

func SetEpochHandlerToHdrResolver(
	resolversContainer ResolversContainer,
	epochHandler EpochHandler,
) error

SetEpochHandlerToHdrResolver sets the epoch handler to the metablock hdr resolver

Types

type ChainStorer 

type ChainStorer struct {
	// contains filtered or unexported fields
}

ChainStorer is a StorageService implementation that can hold multiple storages 

grouped by storage unit type

func NewChainStorer 

func NewChainStorer() *ChainStorer

NewChainStorer returns a new initialised ChainStorer

func (*ChainStorer) AddStorer 

func (bc *ChainStorer) AddStorer(key UnitType, s storage.Storer)

AddStorer will add a new storer to the chain map

func (*ChainStorer) CloseAll 

func (bc *ChainStorer) CloseAll() error

CloseAll will close all the active units

func (*ChainStorer) Destroy 

func (bc *ChainStorer) Destroy() error

Destroy removes the underlying files/resources used by the storage service

func (*ChainStorer) Get 

func (bc *ChainStorer) Get(unitType UnitType, key []byte) ([]byte, error)

Get returns the value for the given key if found in the selected storage unit, nil otherwise. It can return an error if the provided unit type is not supported or if the storage unit underlying implementation reports an error

func (*ChainStorer) GetAll 

func (bc *ChainStorer) GetAll(unitType UnitType, keys [][]byte) (map[string][]byte, error)

GetAll gets all the elements with keys in the keys array, from the selected storage unit It can report an error if the provided unit type is not supported, if there is a missing key in the unit, or if the underlying implementation of the storage unit reports an error.

func (*ChainStorer) GetStorer 

func (bc *ChainStorer) GetStorer(unitType UnitType) storage.Storer

GetStorer returns the storer from the chain map or nil if the storer was not found

func (*ChainStorer) Has 

func (bc *ChainStorer) Has(unitType UnitType, key []byte) error

Has returns true if the key is found in the selected Unit or false otherwise It can return an error if the provided unit type is not supported or if the underlying implementation of the storage unit reports an error.

func (*ChainStorer) IsInterfaceNil 

func (bc *ChainStorer) IsInterfaceNil() bool

IsInterfaceNil returns true if there is no value under the interface

func (*ChainStorer) Put 

func (bc *ChainStorer) Put(unitType UnitType, key []byte, value []byte) error

Put stores the key, value pair in the selected storage unit It can return an error if the provided unit type is not supported or if the storage unit underlying implementation reports an error

func (*ChainStorer) SetEpochForPutOperation 

func (bc *ChainStorer) SetEpochForPutOperation(epoch uint32)

SetEpochForPutOperation will set the epoch to be used in all persisters for the put operation

type DataPacker 

type DataPacker interface {
	PackDataInChunks(data [][]byte, limit int) ([][]byte, error)
	IsInterfaceNil() bool
}

DataPacker can split a large slice of byte slices in smaller packets

type EpochHandler 

type EpochHandler interface {
	MetaEpoch() uint32
	IsInterfaceNil() bool
}

EpochHandler defines the functionality to get the current epoch

type EpochProviderByNonce 

type EpochProviderByNonce interface {
	EpochForNonce(nonce uint64) (uint32, error)
	IsInterfaceNil() bool
}

EpochProviderByNonce defines the functionality needed for calculating an epoch based on nonce

type HeaderResolver 

type HeaderResolver interface {
	Resolver
	RequestDataFromNonce(nonce uint64, epoch uint32) error
	RequestDataFromEpoch(identifier []byte) error
	SetEpochHandler(epochHandler EpochHandler) error
}

HeaderResolver defines what a block header resolver should do

type HeadersPool 

type HeadersPool interface {
	Clear()
	AddHeader(headerHash []byte, header data.HeaderHandler)
	RemoveHeaderByHash(headerHash []byte)
	RemoveHeaderByNonceAndShardId(headerNonce uint64, shardId uint32)
	GetHeadersByNonceAndShardId(headerNonce uint64, shardId uint32) ([]data.HeaderHandler, [][]byte, error)
	GetHeaderByHash(hash []byte) (data.HeaderHandler, error)
	RegisterHandler(handler func(headerHandler data.HeaderHandler, headerHash []byte))
	Nonces(shardId uint32) []uint64
	Len() int
	MaxSize() int
	IsInterfaceNil() bool
	GetNumHeaders(shardId uint32) int
}

HeadersPool defines what a headers pool structure can perform

type IntRandomizer 

type IntRandomizer interface {
	Intn(n int) int
	IsInterfaceNil() bool
}

IntRandomizer interface provides functionality over generating integer numbers

type MessageHandler 

type MessageHandler interface {
	ConnectedPeersOnTopic(topic string) []core.PeerID
	SendToConnectedPeer(topic string, buff []byte, peerID core.PeerID) error
	IsInterfaceNil() bool
}

MessageHandler defines the functionality needed by structs to send data to other peers

type MiniBlocksResolver 

type MiniBlocksResolver interface {
	Resolver
	RequestDataFromHashArray(hashes [][]byte, epoch uint32) error
}

MiniBlocksResolver defines what a mini blocks resolver should do

type P2PAntifloodHandler 

type P2PAntifloodHandler interface {
	CanProcessMessage(message p2p.MessageP2P, fromConnectedPeer core.PeerID) error
	CanProcessMessagesOnTopic(peer core.PeerID, topic string, numMessages uint32, _ uint64, sequence []byte) error
	BlacklistPeer(peer core.PeerID, reason string, duration time.Duration)
	IsInterfaceNil() bool
}

P2PAntifloodHandler defines the behavior of a component able to signal that the system is too busy (or flooded) processing p2p messages

type PeerListCreator 

type PeerListCreator interface {
	PeerList() []core.PeerID
	IntraShardPeerList() []core.PeerID
	IsInterfaceNil() bool
}

PeerListCreator is used to create a peer list

type PoolsHolder 

type PoolsHolder interface {
	Transactions() ShardedDataCacherNotifier
	UnsignedTransactions() ShardedDataCacherNotifier
	RewardTransactions() ShardedDataCacherNotifier
	Headers() HeadersPool
	MiniBlocks() storage.Cacher
	PeerChangesBlocks() storage.Cacher
	TrieNodes() storage.Cacher
	CurrentBlockTxs() TransactionCacher
	IsInterfaceNil() bool
}

PoolsHolder defines getters for data pools

type RequestData 

type RequestData struct {
	Value []byte          `protobuf:"bytes,2,opt,name=Value,proto3" json:"value"`
	Type  RequestDataType `protobuf:"varint,1,opt,name=Type,proto3,enum=proto.RequestDataType" json:"type"`
	Epoch uint32          `protobuf:"varint,3,opt,name=Epoch,proto3" json:"epoch"`
}

RequestData holds the requested data This struct will be serialized and sent to the other peers

func (*RequestData) Descriptor 

func (*RequestData) Descriptor() ([]byte, []int)

func (*RequestData) Equal 

func (this *RequestData) Equal(that interface{}) bool

func (*RequestData) GetEpoch 

func (m *RequestData) GetEpoch() uint32

func (*RequestData) GetType 

func (m *RequestData) GetType() RequestDataType

func (*RequestData) GetValue 

func (m *RequestData) GetValue() []byte

func (*RequestData) GoString 

func (this *RequestData) GoString() string

func (*RequestData) Marshal 

func (m *RequestData) Marshal() (dAtA []byte, err error)

func (*RequestData) MarshalTo 

func (m *RequestData) MarshalTo(dAtA []byte) (int, error)

func (*RequestData) MarshalToSizedBuffer 

func (m *RequestData) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*RequestData) ProtoMessage 

func (*RequestData) ProtoMessage()

func (*RequestData) Reset 

func (m *RequestData) Reset()

func (*RequestData) Size 

func (m *RequestData) Size() (n int)

func (*RequestData) String 

func (this *RequestData) String() string

func (*RequestData) Unmarshal 

func (m *RequestData) Unmarshal(dAtA []byte) error

func (*RequestData) UnmarshalWith 

func (rd *RequestData) UnmarshalWith(marshalizer marshal.Marshalizer, message p2p.MessageP2P) error

UnmarshalWith sets the fields according to p2p.MessageP2P.Data() contents Errors if something went wrong

func (*RequestData) XXX_DiscardUnknown 

func (m *RequestData) XXX_DiscardUnknown()

func (*RequestData) XXX_Marshal 

func (m *RequestData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*RequestData) XXX_Merge 

func (m *RequestData) XXX_Merge(src proto.Message)

func (*RequestData) XXX_Size 

func (m *RequestData) XXX_Size() int

func (*RequestData) XXX_Unmarshal 

func (m *RequestData) XXX_Unmarshal(b []byte) error

type RequestDataType 

type RequestDataType int32

RequestDataType represents the data type for the requested data 

const (
	// Invalid
	InvalidType RequestDataType = 0
	// HashType indicates that the request data object is of type hash
	HashType RequestDataType = 1
	// HashArrayType that the request data object contains a serialised array of hashes
	HashArrayType RequestDataType = 2
	// NonceType indicates that the request data object is of type nonce (uint64)
	NonceType RequestDataType = 3
	// EpochType indicates that the request data object is of type epoch
	EpochType RequestDataType = 4
)

func (RequestDataType) EnumDescriptor 

func (RequestDataType) EnumDescriptor() ([]byte, []int)

func (RequestDataType) String 

func (x RequestDataType) String() string

type RequestedItemsHandler 

type RequestedItemsHandler interface {
	Add(key string) error
	Has(key string) bool
	Sweep()
	IsInterfaceNil() bool
}

RequestedItemsHandler can determine if a certain key has or not been requested

type Resolver 

type Resolver interface {
	RequestDataFromHash(hash []byte, epoch uint32) error
	ProcessReceivedMessage(message p2p.MessageP2P, fromConnectedPeer core.PeerID) error
	SetResolverDebugHandler(handler ResolverDebugHandler) error
	SetNumPeersToQuery(intra int, cross int)
	NumPeersToQuery() (int, int)
	IsInterfaceNil() bool
}

Resolver defines what a data resolver should do

type ResolverDebugHandler 

type ResolverDebugHandler interface {
	LogRequestedData(topic string, hashes [][]byte, numReqIntra int, numReqCross int)
	LogFailedToResolveData(topic string, hash []byte, err error)
	LogSucceededToResolveData(topic string, hash []byte)
	IsInterfaceNil() bool
}

ResolverDebugHandler defines an interface for debugging the reqested-resolved data

type ResolverThrottler 

type ResolverThrottler interface {
	CanProcess() bool
	StartProcessing()
	EndProcessing()
	IsInterfaceNil() bool
}

ResolverThrottler can monitor the number of the currently running resolver go routines

type ResolversContainer 

type ResolversContainer interface {
	Get(key string) (Resolver, error)
	Add(key string, val Resolver) error
	AddMultiple(keys []string, resolvers []Resolver) error
	Replace(key string, val Resolver) error
	Remove(key string)
	Len() int
	ResolverKeys() string
	Iterate(handler func(key string, resolver Resolver) bool)
	IsInterfaceNil() bool
}

ResolversContainer defines a resolvers holder data type with basic functionality

type ResolversContainerFactory 

type ResolversContainerFactory interface {
	Create() (ResolversContainer, error)
	IsInterfaceNil() bool
}

ResolversContainerFactory defines the functionality to create a resolvers container

type ResolversFinder 

type ResolversFinder interface {
	ResolversContainer
	IntraShardResolver(baseTopic string) (Resolver, error)
	MetaChainResolver(baseTopic string) (Resolver, error)
	CrossShardResolver(baseTopic string, crossShard uint32) (Resolver, error)
	MetaCrossShardResolver(baseTopic string, crossShard uint32) (Resolver, error)
}

ResolversFinder extends a container resolver and have 2 additional functionality

type ShardIdHashMap 

type ShardIdHashMap interface {
	Load(shardId uint32) ([]byte, bool)
	Store(shardId uint32, hash []byte)
	Range(f func(shardId uint32, hash []byte) bool)
	Delete(shardId uint32)
	IsInterfaceNil() bool
}

ShardIdHashMap represents a map for shardId and hash

type ShardedDataCacherNotifier 

type ShardedDataCacherNotifier interface {
	RegisterOnAdded(func(key []byte, value interface{}))
	ShardDataStore(cacheId string) (c storage.Cacher)
	AddData(key []byte, data interface{}, sizeInBytes int, cacheId string)
	SearchFirstData(key []byte) (value interface{}, ok bool)
	RemoveData(key []byte, cacheId string)
	RemoveSetOfDataFromPool(keys [][]byte, cacheId string)
	ImmunizeSetOfDataAgainstEviction(keys [][]byte, cacheId string)
	RemoveDataFromAllShards(key []byte)
	MergeShardStores(sourceCacheID, destCacheID string)
	Clear()
	ClearShardStore(cacheId string)
	GetCounts() counting.CountsWithSize
	IsInterfaceNil() bool
}

ShardedDataCacherNotifier defines what a sharded-data structure can perform

type StorageService 

type StorageService interface {
	// GetStorer returns the storer from the chain map
	GetStorer(unitType UnitType) storage.Storer
	// AddStorer will add a new storer to the chain map
	AddStorer(key UnitType, s storage.Storer)
	// Has returns true if the key is found in the selected Unit or false otherwise
	Has(unitType UnitType, key []byte) error
	// Get returns the value for the given key if found in the selected storage unit, nil otherwise
	Get(unitType UnitType, key []byte) ([]byte, error)
	// Put stores the key, value pair in the selected storage unit
	Put(unitType UnitType, key []byte, value []byte) error
	// SetEpochForPutOperation will set the epoch which will be used for the put operation
	SetEpochForPutOperation(epoch uint32)
	// GetAll gets all the elements with keys in the keys array, from the selected storage unit
	// If there is a missing key in the unit, it returns an error
	GetAll(unitType UnitType, keys [][]byte) (map[string][]byte, error)
	// Destroy removes the underlying files/resources used by the storage service
	Destroy() error
	//CloseAll will close all the units
	CloseAll() error
	// IsInterfaceNil returns true if there is no value under the interface
	IsInterfaceNil() bool
}

StorageService is the interface for data storage unit provided services

type StorageType 

type StorageType uint8

StorageType defines the storage levels on a node

type TopicHandler 

type TopicHandler interface {
	HasTopic(name string) bool
	CreateTopic(name string, createChannelForTopic bool) error
	RegisterMessageProcessor(topic string, handler p2p.MessageProcessor) error
}

TopicHandler defines the functionality needed by structs to manage topics and message processors

type TopicMessageHandler 

type TopicMessageHandler interface {
	MessageHandler
	TopicHandler
}

TopicMessageHandler defines the functionality needed by structs to manage topics, message processors and to send data to other peers

type TopicResolverSender 

type TopicResolverSender interface {
	SendOnRequestTopic(rd *RequestData, originalHashes [][]byte) error
	Send(buff []byte, peer core.PeerID) error
	RequestTopic() string
	TargetShardID() uint32
	SetNumPeersToQuery(intra int, cross int)
	SetResolverDebugHandler(handler ResolverDebugHandler) error
	ResolverDebugHandler() ResolverDebugHandler
	NumPeersToQuery() (int, int)
	IsInterfaceNil() bool
}

TopicResolverSender defines what sending operations are allowed for a topic resolver

type TransactionCacher 

type TransactionCacher interface {
	Clean()
	GetTx(txHash []byte) (data.TransactionHandler, error)
	AddTx(txHash []byte, tx data.TransactionHandler)
	IsInterfaceNil() bool
}

TransactionCacher defines the methods for the local cacher, info for current round

type TrieDataGetter 

type TrieDataGetter interface {
	GetSerializedNodes([]byte, uint64) ([][]byte, uint64, error)
	IsInterfaceNil() bool
}

TrieDataGetter returns requested data from the trie

type TrieNodesResolver 

type TrieNodesResolver interface {
	Resolver
	RequestDataFromHashArray(hashes [][]byte, epoch uint32) error
}

TrieNodesResolver defines what a trie nodes resolver should do

type UnitType 

type UnitType uint8

UnitType is the type for Storage unit identifiers 

const (
	// TransactionUnit is the transactions storage unit identifier
	TransactionUnit UnitType = 0
	// MiniBlockUnit is the transaction block body storage unit identifier
	MiniBlockUnit UnitType = 1
	// PeerChangesUnit is the peer change block body storage unit identifier
	PeerChangesUnit UnitType = 2
	// BlockHeaderUnit is the Block Headers Storage unit identifier
	BlockHeaderUnit UnitType = 3
	// MetaBlockUnit is the metachain blocks storage unit identifier
	MetaBlockUnit UnitType = 4
	// UnsignedTransactionUnit is the unsigned transaction unit identifier
	UnsignedTransactionUnit UnitType = 5
	// RewardTransactionUnit is the reward transaction unit identifier
	RewardTransactionUnit UnitType = 6
	// MetaHdrNonceHashDataUnit is the meta header nonce-hash pair data unit identifier
	MetaHdrNonceHashDataUnit UnitType = 7
	// HeartbeatUnit is the heartbeat storage unit identifier
	HeartbeatUnit UnitType = 8
	// BootstrapUnit is the bootstrap storage unit identifier
	BootstrapUnit UnitType = 9
	//StatusMetricsUnit is the status metrics storage unit identifier
	StatusMetricsUnit UnitType = 10
	// TxLogsUnit is the transactions logs storage unit identifier
	TxLogsUnit UnitType = 11
	// TransactionHistoryUnit is the transactions history storage unit identifier
	TransactionHistoryUnit UnitType = 12
	// EpochByHashUnit is the epoch by hash storage unit identifier
	EpochByHashUnit UnitType = 13

	// ShardHdrNonceHashDataUnit is the header nonce-hash pair data unit identifier
	//TODO: Add only unit types lower than 100
	ShardHdrNonceHashDataUnit UnitType = 100
)

func (UnitType) String 

func (ut UnitType) String() string

String returns the friendly name of the unit

type WhiteListHandler 

type WhiteListHandler interface {
	Remove(keys [][]byte)
	Add(keys [][]byte)
	IsInterfaceNil() bool
}

WhiteListHandler is the interface needed to add whitelisted data

Source Files

View all Source files

Directories

Path Synopsis
headersCache
containers
resolverscontainer
epochproviders
topicResolverSender

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.