nodesCoordinator

package
v1.6.11 Latest Latest
Warning

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

 Go to latest Published: Jan 10, 2024 License: GPL-3.0 Imports: 26 Imported by: 3

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var ErrEpochNodesConfigDoesNotExist = errors.New("epoch nodes configuration does not exist")

ErrEpochNodesConfigDoesNotExist signals that the epoch nodes configuration is missing

View Source 
var ErrInvalidConsensusGroupSize = errors.New("invalid consensus group size")

ErrInvalidConsensusGroupSize signals that the consensus size is invalid (e.g. value is negative)

View Source 
var ErrInvalidNumberOfShards = errors.New("the number of shards must be greater than zero")

ErrInvalidNumberOfShards signals that an invalid number of shards was passed to the sharding registry

View Source 
var ErrInvalidNumberPubKeys = errors.New("invalid number of public keys")

ErrInvalidNumberPubKeys signals that an invalid number of public keys was used

View Source 
var ErrInvalidSampleSize = errors.New("invalid sample size")

ErrInvalidSampleSize signals that an invalid sample size was provided

View Source 
var ErrInvalidShardId = errors.New("shard id must be smaller than the total number of shards")

ErrInvalidShardId signals that an invalid shard id was passed

View Source 
var ErrInvalidWeight = errors.New("invalid weight")

ErrInvalidWeight signals an invalid weight was provided

View Source 
var ErrMapSizeZero = errors.New("map size zero")

ErrMapSizeZero signals that there are no elements in the map

View Source 
var ErrNilBlockBody = errors.New("nil block body")

ErrNilBlockBody signals that block body is nil

View Source 
var ErrNilBootStorer = errors.New("nil boot storer provided")

ErrNilBootStorer signals that a nil boot storer was provided

View Source 
var ErrNilCacher = errors.New("nil cacher")

ErrNilCacher signals that a nil cacher has been provided

View Source 
var ErrNilChanceComputer = errors.New("nil chance computer")

ErrNilChanceComputer signals that a nil chance computer was provided

View Source 
var ErrNilEnableEpochsHandler = errors.New("nil enable epochs handler")

ErrNilEnableEpochsHandler signals that a nil enable epochs handler has been provided

View Source 
var ErrNilHasher = errors.New("nil hasher")

ErrNilHasher signals that a nil hasher has been provided

View Source 
var ErrNilInputNodesMap = errors.New("nil input nodes map")

ErrNilInputNodesMap signals that a nil nodes map was provided

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

ErrNilMarshalizer signals that the marshalizer is nil

View Source 
var ErrNilNodeShufflerArguments = errors.New("nil arguments for the creation of a node shuffler")

ErrNilNodeShufflerArguments signals that a nil argument pointer was provided for creating the nodes shuffler instance

View Source 
var ErrNilNodeStopChannel = errors.New("nil node stop channel")

ErrNilNodeStopChannel signals that a nil node stop channel has been provided

View Source 
var ErrNilNodeTypeProvider = errors.New("nil node type provider")

ErrNilNodeTypeProvider signals that a nil node type provider has been given

View Source 
var ErrNilNodesCoordinator = errors.New("nil nodesCoordinator")

ErrNilNodesCoordinator signals that the nodesCoordinator is nil

View Source 
var ErrNilOrEmptyDestinationForDistribute = errors.New("nil or empty destination list for distributeNodes")

ErrNilOrEmptyDestinationForDistribute signals that a nil or empty value was provided for destination of distributedNodes

View Source 
var ErrNilPreviousEpochConfig = errors.New("nil previous epoch config")

ErrNilPreviousEpochConfig signals that the previous epoch config is nil

View Source 
var ErrNilPubKey = errors.New("nil public key")

ErrNilPubKey signals that the public key is nil

View Source 
var ErrNilRandomSelector = errors.New("nil selector")

ErrNilRandomSelector signals that a nil selector was provided

View Source 
var ErrNilRandomness = errors.New("nil randomness source")

ErrNilRandomness signals that a nil randomness source has been provided

View Source 
var ErrNilShuffledOutHandler = errors.New("nil shuffled out handler")

ErrNilShuffledOutHandler signals that a nil shuffled out handler has been provided

View Source 
var ErrNilShuffler = errors.New("nil nodes shuffler provided")

ErrNilShuffler signals that a nil shuffler was provided

View Source 
var ErrNilValidatorInfoCacher = errors.New("validator info cacher is nil")

ErrNilValidatorInfoCacher signals that a nil value for the validator info cacher has been provided

View Source 
var ErrNilWeights = errors.New("nil weights")

ErrNilWeights signals that nil weights list was provided

View Source 
var ErrNotImplemented = errors.New("feature not implemented")

ErrNotImplemented signals a call of a non implemented functionality

View Source 
var ErrSmallMetachainEligibleListSize = errors.New("small metachain eligible list size")

ErrSmallMetachainEligibleListSize signals that the eligible validators list's size is less than the consensus size

View Source 
var ErrSmallShardEligibleListSize = errors.New("small shard eligible list size")

ErrSmallShardEligibleListSize signals that the eligible validators list's size is less than the consensus size

View Source 
var ErrValidatorCannotBeFullArchive = errors.New("validator cannot be a full archive node")

ErrValidatorCannotBeFullArchive signals a configuration issue because a validator cannot be a full archive node

View Source 
var ErrValidatorNotFound = errors.New("validator not found")

ErrValidatorNotFound signals that the validator has not been found

View Source 
var ErrWrongTypeAssertion = errors.New("wrong type assertion")

ErrWrongTypeAssertion signals wrong type assertion error

Functions

func NewHashValidatorsShuffler 

func NewHashValidatorsShuffler(args *NodesShufflerArgs) (*randHashShuffler, error)

NewHashValidatorsShuffler creates a validator shuffler that uses a hash between validator key and a given random number to do the shuffling

func NewIndexHashedNodesCoordinator 

func NewIndexHashedNodesCoordinator(arguments ArgNodesCoordinator) (*indexHashedNodesCoordinator, error)

NewIndexHashedNodesCoordinator creates a new index hashed group selector

func NewIndexHashedNodesCoordinatorWithRater 

func NewIndexHashedNodesCoordinatorWithRater(
	indexNodesCoordinator *indexHashedNodesCoordinator,
	chanceComputer ChanceComputer,
) (*indexHashedNodesCoordinatorWithRater, error)

NewIndexHashedNodesCoordinatorWithRater creates a new index hashed group selector

func NewSelectorExpandedList 

func NewSelectorExpandedList(weightList []uint32, hasher hashing.Hasher) (*selectorExpandedList, error)

NewSelectorExpandedList creates a new selector initializing selection set to the given lists of validators and expanding it according to each validator weight.

func NewSelectorWRS 

func NewSelectorWRS(weightList []uint32, hasher hashing.Hasher) (*selectorWRS, error)

NewSelectorWRS creates a new selector initializing selection set to the given lists of weights

func NewValidator 

func NewValidator(pubKey []byte, chances uint32, index uint32) (*validator, error)

NewValidator creates a new instance of a validator

func NodesInfoToValidators 

func NodesInfoToValidators(nodesInfo map[uint32][]GenesisNodeInfoHandler) (map[uint32][]Validator, error)

NodesInfoToValidators maps nodeInfo to validator interface

func SerializableValidatorsToValidators 

func SerializableValidatorsToValidators(nodeRegistryValidators map[string][]*SerializableValidator) (map[uint32][]Validator, error)

SerializableValidatorsToValidators creates the validator map from serializable validator map

Types

type ArgNodesCoordinator 

type ArgNodesCoordinator struct {
	ShardConsensusGroupSize int
	MetaConsensusGroupSize  int
	Marshalizer             marshal.Marshalizer
	Hasher                  hashing.Hasher
	Shuffler                NodesShuffler
	EpochStartNotifier      EpochStartEventNotifier
	BootStorer              storage.Storer
	ShardIDAsObserver       uint32
	NbShards                uint32
	EligibleNodes           map[uint32][]Validator
	WaitingNodes            map[uint32][]Validator
	SelfPublicKey           []byte
	Epoch                   uint32
	StartEpoch              uint32
	ConsensusGroupCache     Cacher
	ShuffledOutHandler      ShuffledOutHandler
	ChanStopNode            chan endProcess.ArgEndProcess
	NodeTypeProvider        NodeTypeProviderHandler
	IsFullArchive           bool
	EnableEpochsHandler     common.EnableEpochsHandler
	ValidatorInfoCacher     epochStart.ValidatorInfoCacher
}

ArgNodesCoordinator holds all dependencies required by the nodes coordinator in order to create new instances

type ArgsUpdateNodes 

type ArgsUpdateNodes struct {
	Eligible          map[uint32][]Validator
	Waiting           map[uint32][]Validator
	NewNodes          []Validator
	UnStakeLeaving    []Validator
	AdditionalLeaving []Validator
	Rand              []byte
	NbShards          uint32
	Epoch             uint32
}

ArgsUpdateNodes holds the parameters required by the shuffler to generate a new nodes configuration

type Cacher 

type Cacher interface {
	// Clear is used to completely clear the cache.
	Clear()
	// Put adds a value to the cache.  Returns true if an eviction occurred.
	Put(key []byte, value interface{}, sizeInBytes int) (evicted bool)
	// Get looks up a key's value from the cache.
	Get(key []byte) (value interface{}, ok bool)
}

Cacher provides the capabilities needed to store and retrieve information needed in the NodesCoordinator

type ChanceComputer 

type ChanceComputer interface {
	//GetChance returns the chances for the rating
	GetChance(uint32) uint32
	//IsInterfaceNil verifies if the interface is nil
	IsInterfaceNil() bool
}

ChanceComputer provides chance computation capabilities based on a rating

type CrossShardValidatorDistributor 

type CrossShardValidatorDistributor struct{}

CrossShardValidatorDistributor - distributes validators from source to destination cross shards

func (*CrossShardValidatorDistributor) DistributeValidators 

func (vd *CrossShardValidatorDistributor) DistributeValidators(
	destination map[uint32][]Validator,
	source map[uint32][]Validator,
	rand []byte,
	balanced bool,
) error

DistributeValidators will handle the moving of the nodes to the map for cross shard validator distributor

func (*CrossShardValidatorDistributor) IsInterfaceNil 

func (vd *CrossShardValidatorDistributor) IsInterfaceNil() bool

IsInterfaceNil - verifies if the interface is nil

type EpochStartActionHandler 

type EpochStartActionHandler interface {
	EpochStartAction(hdr data.HeaderHandler)
	EpochStartPrepare(metaHdr data.HeaderHandler, body data.BodyHandler)
	NotifyOrder() uint32
}

EpochStartActionHandler defines the action taken on epoch start event

type EpochStartEventNotifier 

type EpochStartEventNotifier interface {
	RegisterHandler(handler epochStart.ActionHandler)
	UnregisterHandler(handler epochStart.ActionHandler)
	IsInterfaceNil() bool
}

EpochStartEventNotifier provides Register and Unregister functionality for the end of epoch events

type EpochValidators 

type EpochValidators struct {
	EligibleValidators map[string][]*SerializableValidator `json:"eligibleValidators"`
	WaitingValidators  map[string][]*SerializableValidator `json:"waitingValidators"`
	LeavingValidators  map[string][]*SerializableValidator `json:"leavingValidators"`
}

EpochValidators holds one epoch configuration for a nodes coordinator

type EpochsConfigUpdateHandler 

type EpochsConfigUpdateHandler interface {
	NodesCoordinator
	SetNodesConfigFromValidatorsInfo(epoch uint32, randomness []byte, validatorsInfo []*state.ShardValidatorInfo) error
	IsEpochInConfig(epoch uint32) bool
}

EpochsConfigUpdateHandler specifies the behaviour needed to update nodes config epochs

type GenesisNodeInfoHandler 

type GenesisNodeInfoHandler interface {
	AssignedShard() uint32
	AddressBytes() []byte
	PubKeyBytes() []byte
	GetInitialRating() uint32
	IsInterfaceNil() bool
}

GenesisNodeInfoHandler defines the public methods for the genesis nodes info

type IntraShardValidatorDistributor 

type IntraShardValidatorDistributor struct{}

IntraShardValidatorDistributor - distributes validators from source to destination inside the same shard

func (*IntraShardValidatorDistributor) DistributeValidators 

func (vd *IntraShardValidatorDistributor) DistributeValidators(
	destination map[uint32][]Validator,
	source map[uint32][]Validator,
	_ []byte,
	_ bool,
) error

DistributeValidators will handle the moving of the nodes to the map for intra shard validator distributor

func (*IntraShardValidatorDistributor) IsInterfaceNil 

func (vd *IntraShardValidatorDistributor) IsInterfaceNil() bool

IsInterfaceNil - verifies if the interface is nil

type NodeTypeProviderHandler 

type NodeTypeProviderHandler interface {
	SetType(nodeType core.NodeType)
	GetType() core.NodeType
	IsInterfaceNil() bool
}

NodeTypeProviderHandler defines the actions needed for a component that can handle the node type

type NodesCoordinator 

type NodesCoordinator interface {
	NodesCoordinatorHelper
	PublicKeysSelector
	ComputeConsensusGroup(randomness []byte, round uint64, shardId uint32, epoch uint32) (validatorsGroup []Validator, err error)
	GetValidatorWithPublicKey(publicKey []byte) (validator Validator, shardId uint32, err error)
	LoadState(key []byte) error
	GetSavedStateKey() []byte
	ShardIdForEpoch(epoch uint32) (uint32, error)
	ShuffleOutForEpoch(_ uint32)
	GetConsensusWhitelistedNodes(epoch uint32) (map[string]struct{}, error)
	ConsensusGroupSize(uint32) int
	GetNumTotalEligible() uint64
	IsInterfaceNil() bool
}

NodesCoordinator defines the behaviour of a struct able to do validator group selection

type NodesCoordinatorHelper 

type NodesCoordinatorHelper interface {
	ValidatorsWeights(validators []Validator) ([]uint32, error)
	ComputeAdditionalLeaving(allValidators []*state.ShardValidatorInfo) (map[uint32][]Validator, error)
	GetChance(uint32) uint32
}

NodesCoordinatorHelper provides polymorphism functionality for nodesCoordinator

type NodesCoordinatorRegistry 

type NodesCoordinatorRegistry struct {
	EpochsConfig map[string]*EpochValidators `json:"epochConfigs"`
	CurrentEpoch uint32                      `json:"currentEpoch"`
}

NodesCoordinatorRegistry holds the data that can be used to initialize a nodes coordinator

type NodesShuffler 

type NodesShuffler interface {
	UpdateParams(numNodesShard uint32, numNodesMeta uint32, hysteresis float32, adaptivity bool)
	UpdateNodeLists(args ArgsUpdateNodes) (*ResUpdateNodes, error)
	IsInterfaceNil() bool
}

NodesShuffler provides shuffling functionality for nodes

type NodesShufflerArgs 

type NodesShufflerArgs struct {
	NodesShard           uint32
	NodesMeta            uint32
	Hysteresis           float32
	Adaptivity           bool
	ShuffleBetweenShards bool
	MaxNodesEnableConfig []config.MaxNodesChangeConfig
	EnableEpochsHandler  common.EnableEpochsHandler
}

NodesShufflerArgs defines the arguments required to create a nodes shuffler

type PublicKeysSelector 

type PublicKeysSelector interface {
	GetValidatorsIndexes(publicKeys []string, epoch uint32) ([]uint64, error)
	GetAllEligibleValidatorsPublicKeys(epoch uint32) (map[uint32][][]byte, error)
	GetAllWaitingValidatorsPublicKeys(epoch uint32) (map[uint32][][]byte, error)
	GetAllLeavingValidatorsPublicKeys(epoch uint32) (map[uint32][][]byte, error)
	GetConsensusValidatorsPublicKeys(randomness []byte, round uint64, shardId uint32, epoch uint32) ([]string, error)
	GetOwnPublicKey() []byte
}

PublicKeysSelector allows retrieval of eligible validators public keys

type RandomSelector 

type RandomSelector interface {
	Select(randSeed []byte, sampleSize uint32) ([]uint32, error)
	IsInterfaceNil() bool
}

RandomSelector selects randomly a subset of elements from a set of data

type ResUpdateNodes 

type ResUpdateNodes struct {
	Eligible       map[uint32][]Validator
	Waiting        map[uint32][]Validator
	Leaving        []Validator
	StillRemaining []Validator
}

ResUpdateNodes holds the result of the UpdateNodes method

type SelectionBasedProvider 

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

SelectionBasedProvider will handle the returning of the consensus group by simulating a reslicing of the expanded eligible list. A comparison between a real reslicing and this can be found in common_test.go

func NewSelectionBasedProvider 

func NewSelectionBasedProvider(hasher hashing.Hasher, maxSize uint32) *SelectionBasedProvider

NewSelectionBasedProvider will return a new instance of SelectionBasedProvider

func (*SelectionBasedProvider) Get 

func (sbp *SelectionBasedProvider) Get(randomness []byte, numValidators int64, expandedEligibleList []uint32) ([]uint32, error)

Get will return the consensus group based on the randomness. After an item is chosen, it is added to the slice, so it won't be selected again so next time a new item is needed, the index is recalculated until the validator doesn't exist in that slice

type SerializableValidator 

type SerializableValidator struct {
	PubKey  []byte `json:"pubKey"`
	Chances uint32 `json:"chances"`
	Index   uint32 `json:"index"`
}

SerializableValidator holds the minimal data required for marshalling and un-marshalling a validator

func ValidatorArrayToSerializableValidatorArray 

func ValidatorArrayToSerializableValidatorArray(validators []Validator) []*SerializableValidator

ValidatorArrayToSerializableValidatorArray -

type ShuffledOutHandler 

type ShuffledOutHandler interface {
	Process(newShardID uint32) error
	RegisterHandler(handler func(newShardID uint32))
	CurrentShardID() uint32
	IsInterfaceNil() bool
}

ShuffledOutHandler defines the methods needed for the computation of a shuffled out event

type Validator 

type Validator interface {
	PubKey() []byte
	Chances() uint32
	Index() uint32
	Size() int
}

Validator defines a node that can be allocated to a shard for participation in a consensus group as validator or block proposer

func SerializableShardValidatorListToValidatorList 

func SerializableShardValidatorListToValidatorList(shardValidators []*SerializableValidator) ([]Validator, error)

SerializableShardValidatorListToValidatorList creates the validator list from serializable validator list

type ValidatorsDistributor 

type ValidatorsDistributor interface {
	DistributeValidators(destination map[uint32][]Validator, source map[uint32][]Validator, rand []byte, balanced bool) error
	IsInterfaceNil() bool
}

ValidatorsDistributor distributes validators across shards

Source Files

View all Source files

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.