common

package
v0.0.13 Latest Latest
Warning

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

 Go to latest Published: Sep 23, 2022 License: BSD-3-Clause Imports: 22 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	// StatusUpdateFrequency is how many containers should be processed between
	// logs
	StatusUpdateFrequency = 5000

	// MaxOutstandingGetAncestorsRequests is the maximum number of GetAncestors
	// sent but not responded to/failed
	MaxOutstandingGetAncestorsRequests = 10

	// MaxOutstandingBroadcastRequests is the maximum number of requests to have
	// outstanding when broadcasting.
	MaxOutstandingBroadcastRequests = 50
)
View Source 
const (
	WriteLock = iota
	ReadLock
	NoLock
)

List of all allowed options

Variables

This section is empty.

Functions

func SendMixedQuery 

func SendMixedQuery(
	sender Sender,
	vdrs []ids.NodeID,
	numPushTo int,
	reqID uint32,
	containerID ids.ID,
	container []byte,
)

Send a query composed partially of push queries and partially of pull queries. The validators in [vdrs] will be queried. This function sends at most [numPushTo] push queries. The rest are pull queries. If [numPushTo] > len(vdrs), len(vdrs) push queries are sent. [containerID] and [container] are the ID and body of the container being queried. [sender] is used to actually send the queries.

Types

type AcceptedFrontierHandler 

type AcceptedFrontierHandler interface {
	// Notify this engine of an accepted frontier.
	//
	// This function can be called by any validator. It is not safe to assume
	// this message is in response to a GetAcceptedFrontier message, is
	// utilizing a unique requestID, or that the containerIDs from a valid
	// frontier.
	AcceptedFrontier(
		validatorID ids.NodeID,
		requestID uint32,
		containerIDs []ids.ID,
	) error

	// Notify this engine that a get accepted frontier request it issued has
	// failed.
	//
	// This function will be called if the engine sent a GetAcceptedFrontier
	// message that is not anticipated to be responded to. This could be because
	// the recipient of the message is unknown or if the message request has
	// timed out.
	//
	// The validatorID, and requestID, are assumed to be the same as those sent
	// in the GetAcceptedFrontier message.
	GetAcceptedFrontierFailed(validatorID ids.NodeID, requestID uint32) error
}

AcceptedFrontierHandler defines how a consensus engine reacts to accepted frontier messages from other validators. Functions only return fatal errors.

func NewNoOpAcceptedFrontierHandler 

func NewNoOpAcceptedFrontierHandler(log logging.Logger) AcceptedFrontierHandler

type AcceptedHandler 

type AcceptedHandler interface {
	// Notify this engine of a set of accepted vertices.
	//
	// This function can be called by any validator. It is not safe to assume
	// this message is in response to a GetAccepted message, is utilizing a
	// unique requestID, or that the containerIDs are a subset of the
	// containerIDs from a GetAccepted message.
	Accepted(
		validatorID ids.NodeID,
		requestID uint32,
		containerIDs []ids.ID,
	) error

	// Notify this engine that a get accepted request it issued has failed.
	//
	// This function will be called if the engine sent a GetAccepted message
	// that is not anticipated to be responded to. This could be because the
	// recipient of the message is unknown or if the message request has timed
	// out.
	//
	// The validatorID, and requestID, are assumed to be the same as those sent
	// in the GetAccepted message.
	GetAcceptedFailed(validatorID ids.NodeID, requestID uint32) error
}

AcceptedHandler defines how a consensus engine reacts to accepted messages from other validators. Functions only return fatal errors.

func NewNoOpAcceptedHandler 

func NewNoOpAcceptedHandler(log logging.Logger) AcceptedHandler

type AcceptedSender 

type AcceptedSender interface {
	// SendGetAccepted requests that every node in [nodeIDs] sends an Accepted
	// message with all the IDs in [containerIDs] that the node thinks are
	// accepted.
	SendGetAccepted(
		nodeIDs ids.NodeIDSet,
		requestID uint32,
		containerIDs []ids.ID,
	)

	// SendAccepted responds to a GetAccepted message with a set of IDs of
	// containers that are accepted.
	SendAccepted(nodeID ids.NodeID, requestID uint32, containerIDs []ids.ID)
}

AcceptedSender defines how a consensus engine sends messages pertaining to accepted containers

type AcceptedStateSummaryHandler 

type AcceptedStateSummaryHandler interface {
	// Notify this engine of a set of state summaries.
	//
	// This function can be called by any validator. It is not safe to assume
	// this message is in response to a GetAcceptedStateSummary message,
	// is utilizing a unique requestID, or that the summaryIDs are a subset of the
	// state summaries requested by key from a GetAcceptedStateSummary message.
	AcceptedStateSummary(validatorID ids.NodeID, requestID uint32, summaryIDs []ids.ID) error

	// Notify this engine that a get accepted state summary request it issued has
	// failed.
	//
	// This function will be called if the engine sent a GetAcceptedStateSummary
	// message that is not anticipated to be responded to. This could be because
	// the recipient of the message is unknown or if the message request has
	// timed out.
	//
	// The validatorID, and requestID, are assumed to be the same as those sent
	// in the GetAcceptedStateSummary message.
	GetAcceptedStateSummaryFailed(validatorID ids.NodeID, requestID uint32) error
}

AcceptedStateSummaryHandler defines how a consensus engine reacts to an accepted state summary message from another validator. Functions only return fatal errors.

func NewNoOpAcceptedStateSummaryHandler 

func NewNoOpAcceptedStateSummaryHandler(log logging.Logger) AcceptedStateSummaryHandler

type AcceptedStateSummarySender 

type AcceptedStateSummarySender interface {
	// SendGetAcceptedStateSummary requests that every node in [nodeIDs] sends an
	// AcceptedStateSummary message with all the state summary IDs referenced by [heights]
	// that the node thinks are accepted.
	SendGetAcceptedStateSummary(nodeIDs ids.NodeIDSet, requestID uint32, heights []uint64)

	// SendAcceptedStateSummary responds to a AcceptedStateSummary message with a
	// set of summary ids that are accepted.
	SendAcceptedStateSummary(nodeID ids.NodeID, requestID uint32, summaryIDs []ids.ID)
}

type AllGetsServer 

type AllGetsServer interface {
	GetStateSummaryFrontierHandler
	GetAcceptedStateSummaryHandler
	GetAcceptedFrontierHandler
	GetAcceptedHandler
	GetAncestorsHandler
	GetHandler
}

type AncestorsHandler 

type AncestorsHandler interface {
	// Notify this engine of multiple containers.
	//
	// Each element of [containers] is the byte representation of a container.
	//
	// This should only be called during bootstrapping, in response to a
	// GetAncestors message to [validatorID] with request ID [requestID].
	//
	// This call should contain the container requested in that message, along
	// with ancestors. The containers should be in BFS order (ie the first
	// container must be the container requested in the GetAncestors message and
	// further back ancestors are later in [containers]
	//
	// It is not safe to assume this message is in response to a GetAncestor
	// message, that this message has a unique requestID or that any of the
	// containers in [containers] are valid.
	Ancestors(
		validatorID ids.NodeID,
		requestID uint32,
		containers [][]byte,
	) error

	// Notify this engine that a GetAncestors request it issued has failed.
	//
	// This function will be called if the engine sent a GetAncestors message
	// that is not anticipated to be responded to. This could be because the
	// recipient of the message is unknown or if the message request has timed
	// out.
	//
	// The validatorID and requestID are assumed to be the same as those sent in
	// the GetAncestors message.
	GetAncestorsFailed(validatorID ids.NodeID, requestID uint32) error
}

AncestorsHandler defines how a consensus engine reacts to bootstrapping retrieval messages from other validators. Functions only return fatal errors.

func NewNoOpAncestorsHandler 

func NewNoOpAncestorsHandler(log logging.Logger) AncestorsHandler

type AppHandler 

type AppHandler interface {
	// Notify this engine of a request for data from [nodeID].
	//
	// The meaning of [request], and what should be sent in response to it, is
	// application (VM) specific.
	//
	// It is not guaranteed that:
	// * [request] is well-formed/valid.
	//
	// This node should typically send an AppResponse to [nodeID] in response to
	// a valid message using the same request ID before the deadline. However,
	// the VM may arbitrarily choose to not send a response to this request.
	AppRequest(nodeID ids.NodeID, requestID uint32, deadline time.Time, request []byte) error

	// Notify this engine that an AppRequest message it sent to [nodeID] with
	// request ID [requestID] failed.
	//
	// This may be because the request timed out or because the message couldn't
	// be sent to [nodeID].
	//
	// It is guaranteed that:
	// * This engine sent a request to [nodeID] with ID [requestID].
	// * AppRequestFailed([nodeID], [requestID]) has not already been called.
	// * AppResponse([nodeID], [requestID]) has not already been called.
	AppRequestFailed(nodeID ids.NodeID, requestID uint32) error

	// Notify this engine of a response to the AppRequest message it sent to
	// [nodeID] with request ID [requestID].
	//
	// The meaning of [response] is application (VM) specifc.
	//
	// It is guaranteed that:
	// * This engine sent a request to [nodeID] with ID [requestID].
	// * AppRequestFailed([nodeID], [requestID]) has not already been called.
	// * AppResponse([nodeID], [requestID]) has not already been called.
	//
	// It is not guaranteed that:
	// * [response] contains the expected response
	// * [response] is well-formed/valid.
	//
	// If [response] is invalid or not the expected response, the VM chooses how
	// to react. For example, the VM may send another AppRequest, or it may give
	// up trying to get the requested information.
	AppResponse(nodeID ids.NodeID, requestID uint32, response []byte) error

	// Notify this engine of a gossip message from [nodeID].
	//
	// The meaning of [msg] is application (VM) specific, and the VM defines how
	// to react to this message.
	//
	// This message is not expected in response to any event, and it does not
	// need to be responded to.
	//
	// A node may gossip the same message multiple times. That is,
	// AppGossip([nodeID], [msg]) may be called multiple times.
	AppGossip(nodeID ids.NodeID, msg []byte) error
}

AppHandler defines how a consensus engine reacts to app specific messages. Functions only return fatal errors.

func NewNoOpAppHandler 

func NewNoOpAppHandler(log logging.Logger) AppHandler

type AppSender 

type AppSender interface {
	// Send an application-level request.
	// A nil return value guarantees that for each nodeID in [nodeIDs],
	// the VM corresponding to this AppSender eventually receives either:
	// * An AppResponse from nodeID with ID [requestID]
	// * An AppRequestFailed from nodeID with ID [requestID]
	// Exactly one of the above messages will eventually be received per nodeID.
	// A non-nil error should be considered fatal.
	SendAppRequest(nodeIDs ids.NodeIDSet, requestID uint32, appRequestBytes []byte) error
	// Send an application-level response to a request.
	// This response must be in response to an AppRequest that the VM corresponding
	// to this AppSender received from [nodeID] with ID [requestID].
	// A non-nil error should be considered fatal.
	SendAppResponse(nodeID ids.NodeID, requestID uint32, appResponseBytes []byte) error
	// Gossip an application-level message.
	// A non-nil error should be considered fatal.
	SendAppGossip(appGossipBytes []byte) error
	SendAppGossipSpecific(nodeIDs ids.NodeIDSet, appGossipBytes []byte) error
}

AppSender sends application (VM) level messages. See also common.AppHandler.

type Bootstrapable 

type Bootstrapable interface {
	// Force the provided containers to be accepted. Only returns fatal errors
	// if they occur.
	ForceAccepted(acceptedContainerIDs []ids.ID) error

	// Clear removes all containers to be processed upon bootstrapping
	Clear() error
}

Bootstrapable defines the functionality required to support bootstrapping

type BootstrapableEngine 

type BootstrapableEngine interface {
	Bootstrapable
	Engine
}

type BootstrapableTest 

type BootstrapableTest struct {
	T *testing.T

	CantForceAccepted, CantClear bool

	ClearF         func() error
	ForceAcceptedF func(acceptedContainerIDs []ids.ID) error
}

BootstrapableTest is a test engine that supports bootstrapping

func (*BootstrapableTest) Clear 

func (b *BootstrapableTest) Clear() error

func (*BootstrapableTest) Default 

func (b *BootstrapableTest) Default(cant bool)

Default sets the default on call handling

func (*BootstrapableTest) ForceAccepted 

func (b *BootstrapableTest) ForceAccepted(containerIDs []ids.ID) error

type Bootstrapper 

type Bootstrapper interface {
	AcceptedFrontierHandler
	AcceptedHandler
	Haltable
	Startup() error
	Restart(reset bool) error
}

func NewCommonBootstrapper 

func NewCommonBootstrapper(config Config) Bootstrapper

type BootstrapperTest 

type BootstrapperTest struct {
	BootstrapableTest
	EngineTest
}

EngineTest is a test engine

func (*BootstrapperTest) Default 

func (b *BootstrapperTest) Default(cant bool)

type ChitsHandler 

type ChitsHandler interface {
	// Notify this engine of the specified validators preferences.
	//
	// This function can be called by any validator. It is not safe to assume
	// this message is in response to a PullQuery or a PushQuery message.
	// However, the validatorID is assumed to be authenticated.
	Chits(validatorID ids.NodeID, requestID uint32, containerIDs []ids.ID) error

	// Notify this engine of the specified validators preferences.
	//
	// This function can be called by any validator. It is not safe to assume
	// this message is in response to a PullQuery or a PushQuery message.
	// However, the validatorID is assumed to be authenticated.
	//
	// The new ChitsV2 could be sent from a node that implements "ChitsV2"
	// sender with linearized DAG, while the older nodes may not have
	// implemented such, thus fallback.
	ChitsV2(validatorID ids.NodeID, requestID uint32, containerIDs []ids.ID, containerID ids.ID) error

	// Notify this engine that a query it issued has failed.
	//
	// This function will be called if the engine sent a PullQuery or PushQuery
	// message that is not anticipated to be responded to. This could be because
	// the recipient of the message is unknown or if the message request has
	// timed out.
	//
	// The validatorID and the requestID are assumed to be the same as those
	// sent in the Query message.
	QueryFailed(validatorID ids.NodeID, requestID uint32) error
}

ChitsHandler defines how a consensus engine reacts to query response messages from other validators. Functions only return fatal errors.

func NewNoOpChitsHandler 

func NewNoOpChitsHandler(log logging.Logger) ChitsHandler

type Config 

type Config struct {
	Ctx        *snow.ConsensusContext
	Validators validators.Set
	Beacons    validators.Set

	SampleK        int
	Alpha          uint64
	StartupTracker tracker.Startup
	Sender         Sender
	Bootstrapable  Bootstrapable
	Subnet         Subnet
	Timer          Timer

	// Should Bootstrap be retried
	RetryBootstrap bool

	// Max number of times to retry bootstrap before warning the node operator
	RetryBootstrapWarnFrequency int

	// Max time to spend fetching a container and its ancestors when responding
	// to a GetAncestors
	MaxTimeGetAncestors time.Duration

	// Max number of containers in an ancestors message sent by this node.
	AncestorsMaxContainersSent int

	// This node will only consider the first [AncestorsMaxContainersReceived]
	// containers in an ancestors message it receives.
	AncestorsMaxContainersReceived int

	SharedCfg *SharedConfig
}

Config wraps the common configurations that are needed by a Snow consensus engine

func DefaultConfigTest 

func DefaultConfigTest() Config

DefaultConfigTest returns a test configuration

func (*Config) Context 

func (c *Config) Context() *snow.ConsensusContext

func (*Config) IsBootstrapped 

func (c *Config) IsBootstrapped() bool

IsBootstrapped returns true iff this chain is done bootstrapping

type Engine 

type Engine interface {
	Handler

	// Return the context of the chain this engine is working on
	Context() *snow.ConsensusContext

	// Start engine operations from given request ID
	Start(startReqID uint32) error

	// Returns nil if the engine is healthy.
	// Periodically called and reported through the health API
	health.Checker

	// GetVM returns this engine's VM
	GetVM() VM
}

Engine describes the standard interface of a consensus engine

type EngineTest 

type EngineTest struct {
	T *testing.T

	CantStart,

	CantIsBootstrapped,
	CantTimeout,
	CantGossip,
	CantHalt,
	CantShutdown,

	CantContext,

	CantNotify,

	CantGetStateSummaryFrontier,
	CantGetStateSummaryFrontierFailed,
	CantStateSummaryFrontier,

	CantGetAcceptedStateSummary,
	CantGetAcceptedStateSummaryFailed,
	CantAcceptedStateSummary,

	CantGetAcceptedFrontier,
	CantGetAcceptedFrontierFailed,
	CantAcceptedFrontier,

	CantGetAccepted,
	CantGetAcceptedFailed,
	CantAccepted,

	CantGet,
	CantGetAncestors,
	CantGetFailed,
	CantGetAncestorsFailed,
	CantPut,
	CantAncestors,

	CantPushQuery,
	CantPullQuery,
	CantQueryFailed,
	CantChits,
	CantChitsV2,

	CantConnected,
	CantDisconnected,

	CantHealth,

	CantAppRequest,
	CantAppResponse,
	CantAppGossip,
	CantAppRequestFailed,

	CantGetVM bool

	StartF                                             func(startReqID uint32) error
	IsBootstrappedF                                    func() bool
	ContextF                                           func() *snow.ConsensusContext
	HaltF                                              func()
	TimeoutF, GossipF, ShutdownF                       func() error
	NotifyF                                            func(Message) error
	GetF, GetAncestorsF, PullQueryF                    func(nodeID ids.NodeID, requestID uint32, containerID ids.ID) error
	PutF, PushQueryF                                   func(nodeID ids.NodeID, requestID uint32, container []byte) error
	AncestorsF                                         func(nodeID ids.NodeID, requestID uint32, containers [][]byte) error
	AcceptedFrontierF, GetAcceptedF, AcceptedF, ChitsF func(nodeID ids.NodeID, requestID uint32, containerIDs []ids.ID) error
	ChitsV2F                                           func(nodeID ids.NodeID, requestID uint32, containerIDs []ids.ID, containerID ids.ID) error
	GetStateSummaryFrontierF, GetStateSummaryFrontierFailedF, GetAcceptedStateSummaryFailedF,
	GetAcceptedFrontierF, GetFailedF, GetAncestorsFailedF,
	QueryFailedF, GetAcceptedFrontierFailedF, GetAcceptedFailedF, AppRequestFailedF func(nodeID ids.NodeID, requestID uint32) error
	StateSummaryFrontierF     func(nodeID ids.NodeID, requestID uint32, summary []byte) error
	GetAcceptedStateSummaryF  func(nodeID ids.NodeID, requestID uint32, keys []uint64) error
	AcceptedStateSummaryF     func(nodeID ids.NodeID, requestID uint32, summaryIDs []ids.ID) error
	ConnectedF                func(nodeID ids.NodeID, nodeVersion *version.Application) error
	DisconnectedF             func(nodeID ids.NodeID) error
	HealthF                   func() (interface{}, error)
	GetVMF                    func() VM
	AppRequestF, AppResponseF func(nodeID ids.NodeID, requestID uint32, msg []byte) error
	AppGossipF                func(nodeID ids.NodeID, msg []byte) error
}

EngineTest is a test engine

func (*EngineTest) Accepted 

func (e *EngineTest) Accepted(nodeID ids.NodeID, requestID uint32, containerIDs []ids.ID) error

func (*EngineTest) AcceptedFrontier 

func (e *EngineTest) AcceptedFrontier(nodeID ids.NodeID, requestID uint32, containerIDs []ids.ID) error

func (*EngineTest) AcceptedStateSummary 

func (e *EngineTest) AcceptedStateSummary(validatorID ids.NodeID, requestID uint32, summaryIDs []ids.ID) error

func (*EngineTest) Ancestors 

func (e *EngineTest) Ancestors(nodeID ids.NodeID, requestID uint32, containers [][]byte) error

func (*EngineTest) AppGossip 

func (e *EngineTest) AppGossip(nodeID ids.NodeID, msg []byte) error

func (*EngineTest) AppRequest 

func (e *EngineTest) AppRequest(nodeID ids.NodeID, requestID uint32, deadline time.Time, request []byte) error

func (*EngineTest) AppRequestFailed 

func (e *EngineTest) AppRequestFailed(nodeID ids.NodeID, requestID uint32) error

func (*EngineTest) AppResponse 

func (e *EngineTest) AppResponse(nodeID ids.NodeID, requestID uint32, response []byte) error

func (*EngineTest) Chits 

func (e *EngineTest) Chits(nodeID ids.NodeID, requestID uint32, containerIDs []ids.ID) error

func (*EngineTest) ChitsV2 

func (e *EngineTest) ChitsV2(nodeID ids.NodeID, requestID uint32, containerIDs []ids.ID, containerID ids.ID) error

func (*EngineTest) Connected 

func (e *EngineTest) Connected(nodeID ids.NodeID, nodeVersion *version.Application) error

func (*EngineTest) Context 

func (e *EngineTest) Context() *snow.ConsensusContext

func (*EngineTest) Default 

func (e *EngineTest) Default(cant bool)

func (*EngineTest) Disconnected 

func (e *EngineTest) Disconnected(nodeID ids.NodeID) error

func (*EngineTest) Get 

func (e *EngineTest) Get(nodeID ids.NodeID, requestID uint32, containerID ids.ID) error

func (*EngineTest) GetAccepted 

func (e *EngineTest) GetAccepted(nodeID ids.NodeID, requestID uint32, containerIDs []ids.ID) error

func (*EngineTest) GetAcceptedFailed 

func (e *EngineTest) GetAcceptedFailed(nodeID ids.NodeID, requestID uint32) error

func (*EngineTest) GetAcceptedFrontier 

func (e *EngineTest) GetAcceptedFrontier(nodeID ids.NodeID, requestID uint32) error

func (*EngineTest) GetAcceptedFrontierFailed 

func (e *EngineTest) GetAcceptedFrontierFailed(nodeID ids.NodeID, requestID uint32) error

func (*EngineTest) GetAcceptedStateSummary 

func (e *EngineTest) GetAcceptedStateSummary(validatorID ids.NodeID, requestID uint32, keys []uint64) error

func (*EngineTest) GetAcceptedStateSummaryFailed 

func (e *EngineTest) GetAcceptedStateSummaryFailed(validatorID ids.NodeID, requestID uint32) error

func (*EngineTest) GetAncestors 

func (e *EngineTest) GetAncestors(nodeID ids.NodeID, requestID uint32, containerID ids.ID) error

func (*EngineTest) GetAncestorsFailed 

func (e *EngineTest) GetAncestorsFailed(nodeID ids.NodeID, requestID uint32) error

func (*EngineTest) GetFailed 

func (e *EngineTest) GetFailed(nodeID ids.NodeID, requestID uint32) error

func (*EngineTest) GetStateSummaryFrontier 

func (e *EngineTest) GetStateSummaryFrontier(validatorID ids.NodeID, requestID uint32) error

func (*EngineTest) GetStateSummaryFrontierFailed 

func (e *EngineTest) GetStateSummaryFrontierFailed(validatorID ids.NodeID, requestID uint32) error

func (*EngineTest) GetVM 

func (e *EngineTest) GetVM() VM

func (*EngineTest) Gossip 

func (e *EngineTest) Gossip() error

func (*EngineTest) Halt 

func (e *EngineTest) Halt()

func (*EngineTest) HealthCheck 

func (e *EngineTest) HealthCheck() (interface{}, error)

func (*EngineTest) Notify 

func (e *EngineTest) Notify(msg Message) error

func (*EngineTest) PullQuery 

func (e *EngineTest) PullQuery(nodeID ids.NodeID, requestID uint32, containerID ids.ID) error

func (*EngineTest) PushQuery 

func (e *EngineTest) PushQuery(nodeID ids.NodeID, requestID uint32, container []byte) error

func (*EngineTest) Put 

func (e *EngineTest) Put(nodeID ids.NodeID, requestID uint32, container []byte) error

func (*EngineTest) QueryFailed 

func (e *EngineTest) QueryFailed(nodeID ids.NodeID, requestID uint32) error

func (*EngineTest) Shutdown 

func (e *EngineTest) Shutdown() error

func (*EngineTest) Start 

func (e *EngineTest) Start(startReqID uint32) error

func (*EngineTest) StateSummaryFrontier 

func (e *EngineTest) StateSummaryFrontier(validatorID ids.NodeID, requestID uint32, summary []byte) error

func (*EngineTest) Timeout 

func (e *EngineTest) Timeout() error

type FetchSender 

type FetchSender interface {
	// Request that the specified node send the specified container to this
	// node.
	SendGet(nodeID ids.NodeID, requestID uint32, containerID ids.ID)

	// SendGetAncestors requests that node [nodeID] send container [containerID]
	// and its ancestors.
	SendGetAncestors(nodeID ids.NodeID, requestID uint32, containerID ids.ID)

	// Tell the specified node that the container whose ID is [containerID] has
	// body [container].
	SendPut(
		nodeID ids.NodeID,
		requestID uint32,
		containerID ids.ID,
		container []byte,
	)

	// Give the specified node several containers at once. Should be in response
	// to a GetAncestors message with request ID [requestID] from the node.
	SendAncestors(nodeID ids.NodeID, requestID uint32, containers [][]byte)
}

FetchSender defines how a consensus engine sends retrieval messages to other nodes.

type Fetcher 

type Fetcher struct {
	// tracks which validators were asked for which containers in which requests
	OutstandingRequests Requests

	// Called when bootstrapping is done on a specific chain
	OnFinished func(lastReqID uint32) error
}

type FrontierSender 

type FrontierSender interface {
	// SendGetAcceptedFrontier requests that every node in [nodeIDs] sends an
	// AcceptedFrontier message.
	SendGetAcceptedFrontier(nodeIDs ids.NodeIDSet, requestID uint32)

	// SendAcceptedFrontier responds to a AcceptedFrontier message with this
	// engine's current accepted frontier.
	SendAcceptedFrontier(
		nodeID ids.NodeID,
		requestID uint32,
		containerIDs []ids.ID,
	)
}

FrontierSender defines how a consensus engine sends frontier messages to other nodes.

type Fx 

type Fx struct {
	ID ids.ID
	Fx interface{}
}

Fx wraps an instance of a feature extension

type GetAcceptedFrontierHandler 

type GetAcceptedFrontierHandler interface {
	// Notify this engine of a request for the accepted frontier of vertices.
	//
	// The accepted frontier is the set of accepted vertices that do not have
	// any accepted descendants.
	//
	// This function can be called by any validator. It is not safe to assume
	// this message is utilizing a unique requestID.
	//
	// This engine should respond with an AcceptedFrontier message with the same
	// requestID, and the engine's current accepted frontier.
	GetAcceptedFrontier(validatorID ids.NodeID, requestID uint32) error
}

GetAcceptedFrontierHandler defines how a consensus engine reacts to a get accepted frontier message from another validator. Functions only return fatal errors.

type GetAcceptedHandler 

type GetAcceptedHandler interface {
	// Notify this engine of a request to filter non-accepted vertices.
	//
	// This function can be called by any validator. It is not safe to assume
	// this message is utilizing a unique requestID. However, the validatorID is
	// assumed to be authenticated.
	//
	// This engine should respond with an Accepted message with the same
	// requestID, and the subset of the containerIDs that this node has decided
	// are accepted.
	GetAccepted(
		validatorID ids.NodeID,
		requestID uint32,
		containerIDs []ids.ID,
	) error
}

GetAcceptedHandler defines how a consensus engine reacts to a get accepted message from another validator. Functions only return fatal errors.

type GetAcceptedStateSummaryHandler 

type GetAcceptedStateSummaryHandler interface {
	// Notify this engine of a request to return state summary IDs referenced by
	// the provided keys.
	//
	// This function can be called by any validator. It is not safe to assume
	// this message is utilizing a unique requestID. However, the validatorID is
	// assumed to be authenticated.
	//
	// This engine should respond with an AcceptedStateSummary message with the
	// same requestID, and the subset of the state summaries that this node has
	// locally available.
	GetAcceptedStateSummary(validatorID ids.NodeID, requestID uint32, keys []uint64) error
}

GetAcceptedStateSummaryHandler defines how a consensus engine reacts to a get accepted state summary message from another validator. Functions only return fatal errors.

type GetAncestorsHandler 

type GetAncestorsHandler interface {
	// Notify this engine of a request for a container and its ancestors.
	//
	// The request is from validator [validatorID]. The requested container is
	// [containerID].
	//
	// This function can be called by any validator. It is not safe to assume
	// this message is utilizing a unique requestID. It is also not safe to
	// assume the requested containerID exists.
	//
	// This engine should respond with an Ancestors message with the same
	// requestID, which contains [containerID] as well as its ancestors. See
	// Ancestors's documentation.
	//
	// If this engine doesn't have some ancestors, it should reply with its best
	// effort attempt at getting them. If this engine doesn't have [containerID]
	// it can ignore this message.
	GetAncestors(validatorID ids.NodeID, requestID uint32, containerID ids.ID) error
}

GetAncestorsHandler defines how a consensus engine reacts to a get ancestors message from another validator. Functions only return fatal errors.

type GetHandler 

type GetHandler interface {
	// Notify this engine of a request for a container.
	//
	// This function can be called by any validator. It is not safe to assume
	// this message is utilizing a unique requestID. It is also not safe to
	// assume the requested containerID exists.
	//
	// There should never be a situation where a virtuous node sends a Get
	// request to another virtuous node that does not have the requested
	// container.
	//
	// This engine should respond with a Put message with the same requestID if
	// the container was locally available. Otherwise, the message can be safely
	// dropped.
	Get(validatorID ids.NodeID, requestID uint32, containerID ids.ID) error
}

GetHandler defines how a consensus engine reacts to get message from another validator. Functions only return fatal errors.

type GetStateSummaryFrontierHandler 

type GetStateSummaryFrontierHandler interface {
	// Notify this engine of a request for the frontier of state summaries.
	//
	// The accepted frontier is the last state summary available locally.
	//
	// This function can be called by any validator. It is not safe to assume
	// this message is utilizing a unique requestID.
	//
	// This engine should respond with an StateSummaryFrontier message with the
	// same requestID, and the engine's current state summary frontier.
	GetStateSummaryFrontier(validatorID ids.NodeID, requestID uint32) error
}

GetStateSummaryFrontierHandler defines how a consensus engine reacts to a get state summary frontier message from another validator. Functions only return fatal errors.

type Gossiper 

type Gossiper interface {
	// Gossip the provided container throughout the network
	SendGossip(containerID ids.ID, container []byte)
}

Gossiper defines how a consensus engine gossips a container on the accepted frontier to other nodes

type HTTPHandler 

type HTTPHandler struct {
	LockOptions LockOption
	Handler     http.Handler
}

type Haltable 

type Haltable interface {
	Halt()
	Halted() bool
}

type Halter 

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

func (*Halter) Halt 

func (h *Halter) Halt()

func (*Halter) Halted 

func (h *Halter) Halted() bool

type Handler 

type Handler interface {
	AllGetsServer
	StateSummaryFrontierHandler
	AcceptedStateSummaryHandler
	AcceptedFrontierHandler
	AcceptedHandler
	AncestorsHandler
	PutHandler
	QueryHandler
	ChitsHandler
	AppHandler
	InternalHandler
}

type InternalHandler 

type InternalHandler interface {
	// Notify this engine of peer changes.
	validators.Connector

	// Notify this engine that a registered timeout has fired.
	Timeout() error

	// Gossip to the network a container on the accepted frontier
	Gossip() error

	// Halt this engine.
	//
	// This function will be called before the environment starts exiting. This
	// function is slightly special, in that it does not expect the chain's
	// context lock to be held before calling this function.
	Halt()

	// Shutdown this engine.
	//
	// This function will be called when the environment is exiting.
	Shutdown() error

	// Notify this engine of a message from the virtual machine.
	Notify(Message) error
}

InternalHandler defines how this consensus engine reacts to messages from other components of this validator. Functions only return fatal errors if they occur.

type LockOption 

type LockOption uint32

LockOption allows the vm to specify their lock option based on their endpoint

type Message 

type Message uint32

Message is an enum of the message types that vms can send to consensus 

const (
	// PendingTxs notifies a consensus engine that
	// its VM has pending transactions
	// (i.e. it would like to add a new block/vertex to consensus)
	PendingTxs Message = iota

	// StateSyncDone notifies the state syncer engine that the VM has finishing
	// syncing the requested state summary.
	StateSyncDone

	// StopVertex notifies a consensus that it has a pending stop vertex
	StopVertex
)

func (Message) String 

func (msg Message) String() string

type MockAcceptedSender 

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

MockAcceptedSender is a mock of AcceptedSender interface.

func NewMockAcceptedSender 

func NewMockAcceptedSender(ctrl *gomock.Controller) *MockAcceptedSender

NewMockAcceptedSender creates a new mock instance.

func (*MockAcceptedSender) EXPECT 

func (m *MockAcceptedSender) EXPECT() *MockAcceptedSenderMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockAcceptedSender) SendAccepted 

func (m *MockAcceptedSender) SendAccepted(nodeID ids.NodeID, requestID uint32, containerIDs []ids.ID)

SendAccepted mocks base method.

func (*MockAcceptedSender) SendGetAccepted 

func (m *MockAcceptedSender) SendGetAccepted(nodeIDs ids.NodeIDSet, requestID uint32, containerIDs []ids.ID)

SendGetAccepted mocks base method.

type MockAcceptedSenderMockRecorder 

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

MockAcceptedSenderMockRecorder is the mock recorder for MockAcceptedSender.

func (*MockAcceptedSenderMockRecorder) SendAccepted 

func (mr *MockAcceptedSenderMockRecorder) SendAccepted(nodeID, requestID, containerIDs interface{}) *gomock.Call

SendAccepted indicates an expected call of SendAccepted.

func (*MockAcceptedSenderMockRecorder) SendGetAccepted 

func (mr *MockAcceptedSenderMockRecorder) SendGetAccepted(nodeIDs, requestID, containerIDs interface{}) *gomock.Call

SendGetAccepted indicates an expected call of SendGetAccepted.

type MockAcceptedStateSummarySender 

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

MockAcceptedStateSummarySender is a mock of AcceptedStateSummarySender interface.

func NewMockAcceptedStateSummarySender 

func NewMockAcceptedStateSummarySender(ctrl *gomock.Controller) *MockAcceptedStateSummarySender

NewMockAcceptedStateSummarySender creates a new mock instance.

func (*MockAcceptedStateSummarySender) EXPECT 

func (m *MockAcceptedStateSummarySender) EXPECT() *MockAcceptedStateSummarySenderMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockAcceptedStateSummarySender) SendAcceptedStateSummary 

func (m *MockAcceptedStateSummarySender) SendAcceptedStateSummary(nodeID ids.NodeID, requestID uint32, summaryIDs []ids.ID)

SendAcceptedStateSummary mocks base method.

func (*MockAcceptedStateSummarySender) SendGetAcceptedStateSummary 

func (m *MockAcceptedStateSummarySender) SendGetAcceptedStateSummary(nodeIDs ids.NodeIDSet, requestID uint32, heights []uint64)

SendGetAcceptedStateSummary mocks base method.

type MockAcceptedStateSummarySenderMockRecorder 

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

MockAcceptedStateSummarySenderMockRecorder is the mock recorder for MockAcceptedStateSummarySender.

func (*MockAcceptedStateSummarySenderMockRecorder) SendAcceptedStateSummary 

func (mr *MockAcceptedStateSummarySenderMockRecorder) SendAcceptedStateSummary(nodeID, requestID, summaryIDs interface{}) *gomock.Call

SendAcceptedStateSummary indicates an expected call of SendAcceptedStateSummary.

func (*MockAcceptedStateSummarySenderMockRecorder) SendGetAcceptedStateSummary 

func (mr *MockAcceptedStateSummarySenderMockRecorder) SendGetAcceptedStateSummary(nodeIDs, requestID, heights interface{}) *gomock.Call

SendGetAcceptedStateSummary indicates an expected call of SendGetAcceptedStateSummary.

type MockAppSender 

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

MockAppSender is a mock of AppSender interface.

func NewMockAppSender 

func NewMockAppSender(ctrl *gomock.Controller) *MockAppSender

NewMockAppSender creates a new mock instance.

func (*MockAppSender) EXPECT 

func (m *MockAppSender) EXPECT() *MockAppSenderMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockAppSender) SendAppGossip 

func (m *MockAppSender) SendAppGossip(appGossipBytes []byte) error

SendAppGossip mocks base method.

func (*MockAppSender) SendAppGossipSpecific 

func (m *MockAppSender) SendAppGossipSpecific(nodeIDs ids.NodeIDSet, appGossipBytes []byte) error

SendAppGossipSpecific mocks base method.

func (*MockAppSender) SendAppRequest 

func (m *MockAppSender) SendAppRequest(nodeIDs ids.NodeIDSet, requestID uint32, appRequestBytes []byte) error

SendAppRequest mocks base method.

func (*MockAppSender) SendAppResponse 

func (m *MockAppSender) SendAppResponse(nodeID ids.NodeID, requestID uint32, appResponseBytes []byte) error

SendAppResponse mocks base method.

type MockAppSenderMockRecorder 

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

MockAppSenderMockRecorder is the mock recorder for MockAppSender.

func (*MockAppSenderMockRecorder) SendAppGossip 

func (mr *MockAppSenderMockRecorder) SendAppGossip(appGossipBytes interface{}) *gomock.Call

SendAppGossip indicates an expected call of SendAppGossip.

func (*MockAppSenderMockRecorder) SendAppGossipSpecific 

func (mr *MockAppSenderMockRecorder) SendAppGossipSpecific(nodeIDs, appGossipBytes interface{}) *gomock.Call

SendAppGossipSpecific indicates an expected call of SendAppGossipSpecific.

func (*MockAppSenderMockRecorder) SendAppRequest 

func (mr *MockAppSenderMockRecorder) SendAppRequest(nodeIDs, requestID, appRequestBytes interface{}) *gomock.Call

SendAppRequest indicates an expected call of SendAppRequest.

func (*MockAppSenderMockRecorder) SendAppResponse 

func (mr *MockAppSenderMockRecorder) SendAppResponse(nodeID, requestID, appResponseBytes interface{}) *gomock.Call

SendAppResponse indicates an expected call of SendAppResponse.

type MockFetchSender 

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

MockFetchSender is a mock of FetchSender interface.

func NewMockFetchSender 

func NewMockFetchSender(ctrl *gomock.Controller) *MockFetchSender

NewMockFetchSender creates a new mock instance.

func (*MockFetchSender) EXPECT 

func (m *MockFetchSender) EXPECT() *MockFetchSenderMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockFetchSender) SendAncestors 

func (m *MockFetchSender) SendAncestors(nodeID ids.NodeID, requestID uint32, containers [][]byte)

SendAncestors mocks base method.

func (*MockFetchSender) SendGet 

func (m *MockFetchSender) SendGet(nodeID ids.NodeID, requestID uint32, containerID ids.ID)

SendGet mocks base method.

func (*MockFetchSender) SendGetAncestors 

func (m *MockFetchSender) SendGetAncestors(nodeID ids.NodeID, requestID uint32, containerID ids.ID)

SendGetAncestors mocks base method.

func (*MockFetchSender) SendPut 

func (m *MockFetchSender) SendPut(nodeID ids.NodeID, requestID uint32, containerID ids.ID, container []byte)

SendPut mocks base method.

type MockFetchSenderMockRecorder 

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

MockFetchSenderMockRecorder is the mock recorder for MockFetchSender.

func (*MockFetchSenderMockRecorder) SendAncestors 

func (mr *MockFetchSenderMockRecorder) SendAncestors(nodeID, requestID, containers interface{}) *gomock.Call

SendAncestors indicates an expected call of SendAncestors.

func (*MockFetchSenderMockRecorder) SendGet 

func (mr *MockFetchSenderMockRecorder) SendGet(nodeID, requestID, containerID interface{}) *gomock.Call

SendGet indicates an expected call of SendGet.

func (*MockFetchSenderMockRecorder) SendGetAncestors 

func (mr *MockFetchSenderMockRecorder) SendGetAncestors(nodeID, requestID, containerID interface{}) *gomock.Call

SendGetAncestors indicates an expected call of SendGetAncestors.

func (*MockFetchSenderMockRecorder) SendPut 

func (mr *MockFetchSenderMockRecorder) SendPut(nodeID, requestID, containerID, container interface{}) *gomock.Call

SendPut indicates an expected call of SendPut.

type MockFrontierSender 

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

MockFrontierSender is a mock of FrontierSender interface.

func NewMockFrontierSender 

func NewMockFrontierSender(ctrl *gomock.Controller) *MockFrontierSender

NewMockFrontierSender creates a new mock instance.

func (*MockFrontierSender) EXPECT 

func (m *MockFrontierSender) EXPECT() *MockFrontierSenderMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockFrontierSender) SendAcceptedFrontier 

func (m *MockFrontierSender) SendAcceptedFrontier(nodeID ids.NodeID, requestID uint32, containerIDs []ids.ID)

SendAcceptedFrontier mocks base method.

func (*MockFrontierSender) SendGetAcceptedFrontier 

func (m *MockFrontierSender) SendGetAcceptedFrontier(nodeIDs ids.NodeIDSet, requestID uint32)

SendGetAcceptedFrontier mocks base method.

type MockFrontierSenderMockRecorder 

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

MockFrontierSenderMockRecorder is the mock recorder for MockFrontierSender.

func (*MockFrontierSenderMockRecorder) SendAcceptedFrontier 

func (mr *MockFrontierSenderMockRecorder) SendAcceptedFrontier(nodeID, requestID, containerIDs interface{}) *gomock.Call

SendAcceptedFrontier indicates an expected call of SendAcceptedFrontier.

func (*MockFrontierSenderMockRecorder) SendGetAcceptedFrontier 

func (mr *MockFrontierSenderMockRecorder) SendGetAcceptedFrontier(nodeIDs, requestID interface{}) *gomock.Call

SendGetAcceptedFrontier indicates an expected call of SendGetAcceptedFrontier.

type MockGossiper 

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

MockGossiper is a mock of Gossiper interface.

func NewMockGossiper 

func NewMockGossiper(ctrl *gomock.Controller) *MockGossiper

NewMockGossiper creates a new mock instance.

func (*MockGossiper) EXPECT 

func (m *MockGossiper) EXPECT() *MockGossiperMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockGossiper) SendGossip 

func (m *MockGossiper) SendGossip(containerID ids.ID, container []byte)

SendGossip mocks base method.

type MockGossiperMockRecorder 

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

MockGossiperMockRecorder is the mock recorder for MockGossiper.

func (*MockGossiperMockRecorder) SendGossip 

func (mr *MockGossiperMockRecorder) SendGossip(containerID, container interface{}) *gomock.Call

SendGossip indicates an expected call of SendGossip.

type MockQuerySender 

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

MockQuerySender is a mock of QuerySender interface.

func NewMockQuerySender 

func NewMockQuerySender(ctrl *gomock.Controller) *MockQuerySender

NewMockQuerySender creates a new mock instance.

func (*MockQuerySender) EXPECT 

func (m *MockQuerySender) EXPECT() *MockQuerySenderMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockQuerySender) SendChits 

func (m *MockQuerySender) SendChits(nodeID ids.NodeID, requestID uint32, votes []ids.ID)

SendChits mocks base method.

func (*MockQuerySender) SendChitsV2 

func (m *MockQuerySender) SendChitsV2(nodeID ids.NodeID, requestID uint32, votes []ids.ID, vote ids.ID)

SendChitsV2 mocks base method.

func (*MockQuerySender) SendPullQuery 

func (m *MockQuerySender) SendPullQuery(nodeIDs ids.NodeIDSet, requestID uint32, containerID ids.ID)

SendPullQuery mocks base method.

func (*MockQuerySender) SendPushQuery 

func (m *MockQuerySender) SendPushQuery(nodeIDs ids.NodeIDSet, requestID uint32, containerID ids.ID, container []byte)

SendPushQuery mocks base method.

type MockQuerySenderMockRecorder 

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

MockQuerySenderMockRecorder is the mock recorder for MockQuerySender.

func (*MockQuerySenderMockRecorder) SendChits 

func (mr *MockQuerySenderMockRecorder) SendChits(nodeID, requestID, votes interface{}) *gomock.Call

SendChits indicates an expected call of SendChits.

func (*MockQuerySenderMockRecorder) SendChitsV2 

func (mr *MockQuerySenderMockRecorder) SendChitsV2(nodeID, requestID, votes, vote interface{}) *gomock.Call

SendChitsV2 indicates an expected call of SendChitsV2.

func (*MockQuerySenderMockRecorder) SendPullQuery 

func (mr *MockQuerySenderMockRecorder) SendPullQuery(nodeIDs, requestID, containerID interface{}) *gomock.Call

SendPullQuery indicates an expected call of SendPullQuery.

func (*MockQuerySenderMockRecorder) SendPushQuery 

func (mr *MockQuerySenderMockRecorder) SendPushQuery(nodeIDs, requestID, containerID, container interface{}) *gomock.Call

SendPushQuery indicates an expected call of SendPushQuery.

type MockSender 

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

MockSender is a mock of Sender interface.

func NewMockSender 

func NewMockSender(ctrl *gomock.Controller) *MockSender

NewMockSender creates a new mock instance.

func (*MockSender) Accept 

func (m *MockSender) Accept(ctx *snow.ConsensusContext, containerID ids.ID, container []byte) error

Accept mocks base method.

func (*MockSender) EXPECT 

func (m *MockSender) EXPECT() *MockSenderMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockSender) SendAccepted 

func (m *MockSender) SendAccepted(nodeID ids.NodeID, requestID uint32, containerIDs []ids.ID)

SendAccepted mocks base method.

func (*MockSender) SendAcceptedFrontier 

func (m *MockSender) SendAcceptedFrontier(nodeID ids.NodeID, requestID uint32, containerIDs []ids.ID)

SendAcceptedFrontier mocks base method.

func (*MockSender) SendAcceptedStateSummary 

func (m *MockSender) SendAcceptedStateSummary(nodeID ids.NodeID, requestID uint32, summaryIDs []ids.ID)

SendAcceptedStateSummary mocks base method.

func (*MockSender) SendAncestors 

func (m *MockSender) SendAncestors(nodeID ids.NodeID, requestID uint32, containers [][]byte)

SendAncestors mocks base method.

func (*MockSender) SendAppGossip 

func (m *MockSender) SendAppGossip(appGossipBytes []byte) error

SendAppGossip mocks base method.

func (*MockSender) SendAppGossipSpecific 

func (m *MockSender) SendAppGossipSpecific(nodeIDs ids.NodeIDSet, appGossipBytes []byte) error

SendAppGossipSpecific mocks base method.

func (*MockSender) SendAppRequest 

func (m *MockSender) SendAppRequest(nodeIDs ids.NodeIDSet, requestID uint32, appRequestBytes []byte) error

SendAppRequest mocks base method.

func (*MockSender) SendAppResponse 

func (m *MockSender) SendAppResponse(nodeID ids.NodeID, requestID uint32, appResponseBytes []byte) error

SendAppResponse mocks base method.

func (*MockSender) SendChits 

func (m *MockSender) SendChits(nodeID ids.NodeID, requestID uint32, votes []ids.ID)

SendChits mocks base method.

func (*MockSender) SendChitsV2 

func (m *MockSender) SendChitsV2(nodeID ids.NodeID, requestID uint32, votes []ids.ID, vote ids.ID)

SendChitsV2 mocks base method.

func (*MockSender) SendGet 

func (m *MockSender) SendGet(nodeID ids.NodeID, requestID uint32, containerID ids.ID)

SendGet mocks base method.

func (*MockSender) SendGetAccepted 

func (m *MockSender) SendGetAccepted(nodeIDs ids.NodeIDSet, requestID uint32, containerIDs []ids.ID)

SendGetAccepted mocks base method.

func (*MockSender) SendGetAcceptedFrontier 

func (m *MockSender) SendGetAcceptedFrontier(nodeIDs ids.NodeIDSet, requestID uint32)

SendGetAcceptedFrontier mocks base method.

func (*MockSender) SendGetAcceptedStateSummary 

func (m *MockSender) SendGetAcceptedStateSummary(nodeIDs ids.NodeIDSet, requestID uint32, heights []uint64)

SendGetAcceptedStateSummary mocks base method.

func (*MockSender) SendGetAncestors 

func (m *MockSender) SendGetAncestors(nodeID ids.NodeID, requestID uint32, containerID ids.ID)

SendGetAncestors mocks base method.

func (*MockSender) SendGetStateSummaryFrontier 

func (m *MockSender) SendGetStateSummaryFrontier(nodeIDs ids.NodeIDSet, requestID uint32)

SendGetStateSummaryFrontier mocks base method.

func (*MockSender) SendGossip 

func (m *MockSender) SendGossip(containerID ids.ID, container []byte)

SendGossip mocks base method.

func (*MockSender) SendPullQuery 

func (m *MockSender) SendPullQuery(nodeIDs ids.NodeIDSet, requestID uint32, containerID ids.ID)

SendPullQuery mocks base method.

func (*MockSender) SendPushQuery 

func (m *MockSender) SendPushQuery(nodeIDs ids.NodeIDSet, requestID uint32, containerID ids.ID, container []byte)

SendPushQuery mocks base method.

func (*MockSender) SendPut 

func (m *MockSender) SendPut(nodeID ids.NodeID, requestID uint32, containerID ids.ID, container []byte)

SendPut mocks base method.

func (*MockSender) SendStateSummaryFrontier 

func (m *MockSender) SendStateSummaryFrontier(nodeID ids.NodeID, requestID uint32, summary []byte)

SendStateSummaryFrontier mocks base method.

type MockSenderMockRecorder 

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

MockSenderMockRecorder is the mock recorder for MockSender.

func (*MockSenderMockRecorder) Accept 

func (mr *MockSenderMockRecorder) Accept(ctx, containerID, container interface{}) *gomock.Call

Accept indicates an expected call of Accept.

func (*MockSenderMockRecorder) SendAccepted 

func (mr *MockSenderMockRecorder) SendAccepted(nodeID, requestID, containerIDs interface{}) *gomock.Call

SendAccepted indicates an expected call of SendAccepted.

func (*MockSenderMockRecorder) SendAcceptedFrontier 

func (mr *MockSenderMockRecorder) SendAcceptedFrontier(nodeID, requestID, containerIDs interface{}) *gomock.Call

SendAcceptedFrontier indicates an expected call of SendAcceptedFrontier.

func (*MockSenderMockRecorder) SendAcceptedStateSummary 

func (mr *MockSenderMockRecorder) SendAcceptedStateSummary(nodeID, requestID, summaryIDs interface{}) *gomock.Call

SendAcceptedStateSummary indicates an expected call of SendAcceptedStateSummary.

func (*MockSenderMockRecorder) SendAncestors 

func (mr *MockSenderMockRecorder) SendAncestors(nodeID, requestID, containers interface{}) *gomock.Call

SendAncestors indicates an expected call of SendAncestors.

func (*MockSenderMockRecorder) SendAppGossip 

func (mr *MockSenderMockRecorder) SendAppGossip(appGossipBytes interface{}) *gomock.Call

SendAppGossip indicates an expected call of SendAppGossip.

func (*MockSenderMockRecorder) SendAppGossipSpecific 

func (mr *MockSenderMockRecorder) SendAppGossipSpecific(nodeIDs, appGossipBytes interface{}) *gomock.Call

SendAppGossipSpecific indicates an expected call of SendAppGossipSpecific.

func (*MockSenderMockRecorder) SendAppRequest 

func (mr *MockSenderMockRecorder) SendAppRequest(nodeIDs, requestID, appRequestBytes interface{}) *gomock.Call

SendAppRequest indicates an expected call of SendAppRequest.

func (*MockSenderMockRecorder) SendAppResponse 

func (mr *MockSenderMockRecorder) SendAppResponse(nodeID, requestID, appResponseBytes interface{}) *gomock.Call

SendAppResponse indicates an expected call of SendAppResponse.

func (*MockSenderMockRecorder) SendChits 

func (mr *MockSenderMockRecorder) SendChits(nodeID, requestID, votes interface{}) *gomock.Call

SendChits indicates an expected call of SendChits.

func (*MockSenderMockRecorder) SendChitsV2 

func (mr *MockSenderMockRecorder) SendChitsV2(nodeID, requestID, votes, vote interface{}) *gomock.Call

SendChitsV2 indicates an expected call of SendChitsV2.

func (*MockSenderMockRecorder) SendGet 

func (mr *MockSenderMockRecorder) SendGet(nodeID, requestID, containerID interface{}) *gomock.Call

SendGet indicates an expected call of SendGet.

func (*MockSenderMockRecorder) SendGetAccepted 

func (mr *MockSenderMockRecorder) SendGetAccepted(nodeIDs, requestID, containerIDs interface{}) *gomock.Call

SendGetAccepted indicates an expected call of SendGetAccepted.

func (*MockSenderMockRecorder) SendGetAcceptedFrontier 

func (mr *MockSenderMockRecorder) SendGetAcceptedFrontier(nodeIDs, requestID interface{}) *gomock.Call

SendGetAcceptedFrontier indicates an expected call of SendGetAcceptedFrontier.

func (*MockSenderMockRecorder) SendGetAcceptedStateSummary 

func (mr *MockSenderMockRecorder) SendGetAcceptedStateSummary(nodeIDs, requestID, heights interface{}) *gomock.Call

SendGetAcceptedStateSummary indicates an expected call of SendGetAcceptedStateSummary.

func (*MockSenderMockRecorder) SendGetAncestors 

func (mr *MockSenderMockRecorder) SendGetAncestors(nodeID, requestID, containerID interface{}) *gomock.Call

SendGetAncestors indicates an expected call of SendGetAncestors.

func (*MockSenderMockRecorder) SendGetStateSummaryFrontier 

func (mr *MockSenderMockRecorder) SendGetStateSummaryFrontier(nodeIDs, requestID interface{}) *gomock.Call

SendGetStateSummaryFrontier indicates an expected call of SendGetStateSummaryFrontier.

func (*MockSenderMockRecorder) SendGossip 

func (mr *MockSenderMockRecorder) SendGossip(containerID, container interface{}) *gomock.Call

SendGossip indicates an expected call of SendGossip.

func (*MockSenderMockRecorder) SendPullQuery 

func (mr *MockSenderMockRecorder) SendPullQuery(nodeIDs, requestID, containerID interface{}) *gomock.Call

SendPullQuery indicates an expected call of SendPullQuery.

func (*MockSenderMockRecorder) SendPushQuery 

func (mr *MockSenderMockRecorder) SendPushQuery(nodeIDs, requestID, containerID, container interface{}) *gomock.Call

SendPushQuery indicates an expected call of SendPushQuery.

func (*MockSenderMockRecorder) SendPut 

func (mr *MockSenderMockRecorder) SendPut(nodeID, requestID, containerID, container interface{}) *gomock.Call

SendPut indicates an expected call of SendPut.

func (*MockSenderMockRecorder) SendStateSummaryFrontier 

func (mr *MockSenderMockRecorder) SendStateSummaryFrontier(nodeID, requestID, summary interface{}) *gomock.Call

SendStateSummaryFrontier indicates an expected call of SendStateSummaryFrontier.

type MockStateSummarySender 

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

MockStateSummarySender is a mock of StateSummarySender interface.

func NewMockStateSummarySender 

func NewMockStateSummarySender(ctrl *gomock.Controller) *MockStateSummarySender

NewMockStateSummarySender creates a new mock instance.

func (*MockStateSummarySender) EXPECT 

func (m *MockStateSummarySender) EXPECT() *MockStateSummarySenderMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockStateSummarySender) SendGetStateSummaryFrontier 

func (m *MockStateSummarySender) SendGetStateSummaryFrontier(nodeIDs ids.NodeIDSet, requestID uint32)

SendGetStateSummaryFrontier mocks base method.

func (*MockStateSummarySender) SendStateSummaryFrontier 

func (m *MockStateSummarySender) SendStateSummaryFrontier(nodeID ids.NodeID, requestID uint32, summary []byte)

SendStateSummaryFrontier mocks base method.

type MockStateSummarySenderMockRecorder 

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

MockStateSummarySenderMockRecorder is the mock recorder for MockStateSummarySender.

func (*MockStateSummarySenderMockRecorder) SendGetStateSummaryFrontier 

func (mr *MockStateSummarySenderMockRecorder) SendGetStateSummaryFrontier(nodeIDs, requestID interface{}) *gomock.Call

SendGetStateSummaryFrontier indicates an expected call of SendGetStateSummaryFrontier.

func (*MockStateSummarySenderMockRecorder) SendStateSummaryFrontier 

func (mr *MockStateSummarySenderMockRecorder) SendStateSummaryFrontier(nodeID, requestID, summary interface{}) *gomock.Call

SendStateSummaryFrontier indicates an expected call of SendStateSummaryFrontier.

type PutHandler 

type PutHandler interface {
	// Notify this engine of a container.
	//
	// This function can be called by any validator. It is not safe to assume
	// this message is utilizing a unique requestID.
	Put(
		validatorID ids.NodeID,
		requestID uint32,
		container []byte,
	) error

	// Notify this engine that a get request it issued has failed.
	//
	// This function will be called if the engine sent a Get message that is not
	// anticipated to be responded to. This could be because the recipient of
	// the message is unknown or if the message request has timed out.
	//
	// The validatorID and requestID are assumed to be the same as those sent in
	// the Get message.
	GetFailed(validatorID ids.NodeID, requestID uint32) error
}

PutHandler defines how a consensus engine reacts to put messages from other validators. Functions only return fatal errors.

func NewNoOpPutHandler 

func NewNoOpPutHandler(log logging.Logger) PutHandler

type QueryHandler 

type QueryHandler interface {
	// Notify this engine of a request for our preferences.
	//
	// This function can be called by any validator. It is not safe to assume
	// this message is utilizing a unique requestID. However, the validatorID is
	// assumed to be authenticated.
	//
	// If the container or its ancestry is incomplete, this engine is expected
	// to request the missing containers from the validator. Once the ancestry
	// is complete, this engine should send this validator the current
	// preferences in a Chits message. The Chits message should have the same
	// requestID that was passed in here.
	PullQuery(
		validatorID ids.NodeID,
		requestID uint32,
		containerID ids.ID,
	) error

	// Notify this engine of a request for our preferences.
	//
	// This function can be called by any validator. It is not safe to assume
	// this message is utilizing a unique requestID.
	//
	// This function is meant to behave the same way as PullQuery, except the
	// container is optimistically provided to potentially remove the need for
	// a series of Get/Put messages.
	//
	// If the ancestry of the container is incomplete, this engine is expected
	// to request the ancestry from the validator. Once the ancestry is
	// complete, this engine should send this validator the current preferences
	// in a Chits message. The Chits message should have the same requestID that
	// was passed in here.
	PushQuery(
		validatorID ids.NodeID,
		requestID uint32,
		container []byte,
	) error
}

QueryHandler defines how a consensus engine reacts to query messages from other validators. Functions only return fatal errors.

func NewNoOpQueryHandler 

func NewNoOpQueryHandler(log logging.Logger) QueryHandler

type QuerySender 

type QuerySender interface {
	// Request from the specified nodes their preferred frontier, given the
	// existence of the specified container.
	// This is the same as PullQuery, except that this message includes not only
	// the ID of the container but also its body.
	SendPushQuery(
		nodeIDs ids.NodeIDSet,
		requestID uint32,
		containerID ids.ID,
		container []byte,
	)

	// Request from the specified nodes their preferred frontier, given the
	// existence of the specified container.
	SendPullQuery(nodeIDs ids.NodeIDSet, requestID uint32, containerID ids.ID)

	// Send chits to the specified node
	SendChits(nodeID ids.NodeID, requestID uint32, votes []ids.ID)

	// Send chits v2 to the specified node
	SendChitsV2(nodeID ids.NodeID, requestID uint32, votes []ids.ID, vote ids.ID)
}

QuerySender defines how a consensus engine sends query messages to other nodes.

type Requests 

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

Requests tracks pending container messages from a peer.

func (*Requests) Add 

func (r *Requests) Add(vdr ids.NodeID, requestID uint32, containerID ids.ID)

Add a request. Assumes that requestIDs are unique. Assumes that containerIDs are only in one request at a time.

func (*Requests) Contains 

func (r *Requests) Contains(containerID ids.ID) bool

Contains returns true if there is an outstanding request for the container ID.

func (*Requests) Len 

func (r *Requests) Len() int

Len returns the total number of outstanding requests.

func (*Requests) Remove 

func (r *Requests) Remove(vdr ids.NodeID, requestID uint32) (ids.ID, bool)

Remove attempts to abandon a requestID sent to a validator. If the request is currently outstanding, the requested ID will be returned along with true. If the request isn't currently outstanding, false will be returned.

func (*Requests) RemoveAny 

func (r *Requests) RemoveAny(containerID ids.ID) bool

RemoveAny outstanding requests for the container ID. True is returned if the container ID had an outstanding request.

func (Requests) String 

func (r Requests) String() string

type Sender 

type Sender interface {
	snow.Acceptor

	StateSummarySender
	AcceptedStateSummarySender
	FrontierSender
	AcceptedSender
	FetchSender
	QuerySender
	Gossiper
	AppSender
}

Sender defines how a consensus engine sends messages and requests to other validators

type SenderTest 

type SenderTest struct {
	T *testing.T

	CantAccept,
	CantSendGetStateSummaryFrontier, CantSendStateSummaryFrontier,
	CantSendGetAcceptedStateSummary, CantSendAcceptedStateSummary,
	CantSendGetAcceptedFrontier, CantSendAcceptedFrontier,
	CantSendGetAccepted, CantSendAccepted,
	CantSendGet, CantSendGetAncestors, CantSendPut, CantSendAncestors,
	CantSendPullQuery, CantSendPushQuery, CantSendChits, CantSendChitsV2,
	CantSendGossip,
	CantSendAppRequest, CantSendAppResponse, CantSendAppGossip, CantSendAppGossipSpecific bool

	AcceptF                      func(*snow.ConsensusContext, ids.ID, []byte) error
	SendGetStateSummaryFrontierF func(ids.NodeIDSet, uint32)
	SendStateSummaryFrontierF    func(ids.NodeID, uint32, []byte)
	SendGetAcceptedStateSummaryF func(ids.NodeIDSet, uint32, []uint64)
	SendAcceptedStateSummaryF    func(ids.NodeID, uint32, []ids.ID)
	SendGetAcceptedFrontierF     func(ids.NodeIDSet, uint32)
	SendAcceptedFrontierF        func(ids.NodeID, uint32, []ids.ID)
	SendGetAcceptedF             func(ids.NodeIDSet, uint32, []ids.ID)
	SendAcceptedF                func(ids.NodeID, uint32, []ids.ID)
	SendGetF                     func(ids.NodeID, uint32, ids.ID)
	SendGetAncestorsF            func(ids.NodeID, uint32, ids.ID)
	SendPutF                     func(ids.NodeID, uint32, ids.ID, []byte)
	SendAncestorsF               func(ids.NodeID, uint32, [][]byte)
	SendPushQueryF               func(ids.NodeIDSet, uint32, ids.ID, []byte)
	SendPullQueryF               func(ids.NodeIDSet, uint32, ids.ID)
	SendChitsF                   func(ids.NodeID, uint32, []ids.ID)
	SendChitsV2F                 func(ids.NodeID, uint32, []ids.ID, ids.ID)
	SendGossipF                  func(ids.ID, []byte)
	SendAppRequestF              func(ids.NodeIDSet, uint32, []byte) error
	SendAppResponseF             func(ids.NodeID, uint32, []byte) error
	SendAppGossipF               func([]byte) error
	SendAppGossipSpecificF       func(ids.NodeIDSet, []byte) error
}

SenderTest is a test sender

func (*SenderTest) Accept 

func (s *SenderTest) Accept(ctx *snow.ConsensusContext, containerID ids.ID, container []byte) error

SendGetStateSummaryFrontier calls SendGetStateSummaryFrontierF if it was initialized. If it wasn't initialized and this function shouldn't be called and testing was initialized, then testing will fail.

func (*SenderTest) Default 

func (s *SenderTest) Default(cant bool)

Default set the default callable value to [cant]

func (*SenderTest) SendAccepted 

func (s *SenderTest) SendAccepted(validatorID ids.NodeID, requestID uint32, containerIDs []ids.ID)

SendAccepted calls SendAcceptedF if it was initialized. If it wasn't initialized and this function shouldn't be called and testing was initialized, then testing will fail.

func (*SenderTest) SendAcceptedFrontier 

func (s *SenderTest) SendAcceptedFrontier(validatorID ids.NodeID, requestID uint32, containerIDs []ids.ID)

SendAcceptedFrontier calls SendAcceptedFrontierF if it was initialized. If it wasn't initialized and this function shouldn't be called and testing was initialized, then testing will fail.

func (*SenderTest) SendAcceptedStateSummary 

func (s *SenderTest) SendAcceptedStateSummary(validatorID ids.NodeID, requestID uint32, summaryIDs []ids.ID)

SendAcceptedStateSummary calls SendAcceptedStateSummaryF if it was initialized. If it wasn't initialized and this function shouldn't be called and testing was initialized, then testing will fail.

func (*SenderTest) SendAncestors 

func (s *SenderTest) SendAncestors(vdr ids.NodeID, requestID uint32, vtxs [][]byte)

SendAncestors calls SendAncestorsF if it was initialized. If it wasn't initialized and this function shouldn't be called and testing was initialized, then testing will fail.

func (*SenderTest) SendAppGossip 

func (s *SenderTest) SendAppGossip(appGossipBytes []byte) error

SendAppGossip calls SendAppGossipF if it was initialized. If it wasn't initialized and this function shouldn't be called and testing was initialized, then testing will fail.

func (*SenderTest) SendAppGossipSpecific 

func (s *SenderTest) SendAppGossipSpecific(nodeIDs ids.NodeIDSet, appGossipBytes []byte) error

SendAppGossipSpecific calls SendAppGossipSpecificF if it was initialized. If it wasn't initialized and this function shouldn't be called and testing was initialized, then testing will fail.

func (*SenderTest) SendAppRequest 

func (s *SenderTest) SendAppRequest(nodeIDs ids.NodeIDSet, requestID uint32, appRequestBytes []byte) error

SendAppRequest calls SendAppRequestF if it was initialized. If it wasn't initialized and this function shouldn't be called and testing was initialized, then testing will fail.

func (*SenderTest) SendAppResponse 

func (s *SenderTest) SendAppResponse(nodeID ids.NodeID, requestID uint32, appResponseBytes []byte) error

SendAppResponse calls SendAppResponseF if it was initialized. If it wasn't initialized and this function shouldn't be called and testing was initialized, then testing will fail.

func (*SenderTest) SendChits 

func (s *SenderTest) SendChits(vdr ids.NodeID, requestID uint32, votes []ids.ID)

SendChits calls SendChitsF if it was initialized. If it wasn't initialized and this function shouldn't be called and testing was initialized, then testing will fail.

func (*SenderTest) SendChitsV2 

func (s *SenderTest) SendChitsV2(vdr ids.NodeID, requestID uint32, votes []ids.ID, vote ids.ID)

SendChitsV2 calls SendChitsV2F if it was initialized. If it wasn't initialized and this function shouldn't be called and testing was initialized, then testing will fail.

func (*SenderTest) SendGet 

func (s *SenderTest) SendGet(vdr ids.NodeID, requestID uint32, vtxID ids.ID)

SendGet calls SendGetF if it was initialized. If it wasn't initialized and this function shouldn't be called and testing was initialized, then testing will fail.

func (*SenderTest) SendGetAccepted 

func (s *SenderTest) SendGetAccepted(nodeIDs ids.NodeIDSet, requestID uint32, containerIDs []ids.ID)

SendGetAccepted calls SendGetAcceptedF if it was initialized. If it wasn't initialized and this function shouldn't be called and testing was initialized, then testing will fail.

func (*SenderTest) SendGetAcceptedFrontier 

func (s *SenderTest) SendGetAcceptedFrontier(validatorIDs ids.NodeIDSet, requestID uint32)

SendGetAcceptedFrontier calls SendGetAcceptedFrontierF if it was initialized. If it wasn't initialized and this function shouldn't be called and testing was initialized, then testing will fail.

func (*SenderTest) SendGetAcceptedStateSummary 

func (s *SenderTest) SendGetAcceptedStateSummary(nodeIDs ids.NodeIDSet, requestID uint32, heights []uint64)

SendGetAcceptedStateSummary calls SendGetAcceptedStateSummaryF if it was initialized. If it wasn't initialized and this function shouldn't be called and testing was initialized, then testing will fail.

func (*SenderTest) SendGetAncestors 

func (s *SenderTest) SendGetAncestors(validatorID ids.NodeID, requestID uint32, vtxID ids.ID)

SendGetAncestors calls SendGetAncestorsF if it was initialized. If it wasn't initialized and this function shouldn't be called and testing was initialized, then testing will fail.

func (*SenderTest) SendGetStateSummaryFrontier 

func (s *SenderTest) SendGetStateSummaryFrontier(validatorIDs ids.NodeIDSet, requestID uint32)

SendGetStateSummaryFrontier calls SendGetStateSummaryFrontierF if it was initialized. If it wasn't initialized and this function shouldn't be called and testing was initialized, then testing will fail.

func (*SenderTest) SendGossip 

func (s *SenderTest) SendGossip(containerID ids.ID, container []byte)

SendGossip calls SendGossipF if it was initialized. If it wasn't initialized and this function shouldn't be called and testing was initialized, then testing will fail.

func (*SenderTest) SendPullQuery 

func (s *SenderTest) SendPullQuery(vdrs ids.NodeIDSet, requestID uint32, vtxID ids.ID)

SendPullQuery calls SendPullQueryF if it was initialized. If it wasn't initialized and this function shouldn't be called and testing was initialized, then testing will fail.

func (*SenderTest) SendPushQuery 

func (s *SenderTest) SendPushQuery(vdrs ids.NodeIDSet, requestID uint32, vtxID ids.ID, vtx []byte)

SendPushQuery calls SendPushQueryF if it was initialized. If it wasn't initialized and this function shouldn't be called and testing was initialized, then testing will fail.

func (*SenderTest) SendPut 

func (s *SenderTest) SendPut(vdr ids.NodeID, requestID uint32, vtxID ids.ID, vtx []byte)

SendPut calls SendPutF if it was initialized. If it wasn't initialized and this function shouldn't be called and testing was initialized, then testing will fail.

func (*SenderTest) SendStateSummaryFrontier 

func (s *SenderTest) SendStateSummaryFrontier(validatorID ids.NodeID, requestID uint32, summary []byte)

SendAcceptedFrontier calls SendAcceptedFrontierF if it was initialized. If it wasn't initialized and this function shouldn't be called and testing was initialized, then testing will fail.

type SharedConfig 

type SharedConfig struct {
	// Tracks the last requestID that was used in a request
	RequestID uint32

	// True if RestartBootstrap has been called at least once
	Restarted bool
}

Shared among common.bootstrapper and snowman/avalanche bootstrapper

type StateSummaryFrontierHandler 

type StateSummaryFrontierHandler interface {
	// Notify this engine of a state summary frontier.
	//
	// This function can be called by any validator. It is not safe to assume
	// this message is in response to a GetStateSummaryFrontier message, is
	// utilizing a unique requestID, or that the summary bytes are from a valid
	// state summary.
	StateSummaryFrontier(validatorID ids.NodeID, requestID uint32, summary []byte) error

	// Notify this engine that a get state summary frontier request it issued
	// has failed.
	//
	// This function will be called if the engine sent a GetStateSummaryFrontier
	// message that is not anticipated to be responded to. This could be because
	// the recipient of the message is unknown or if the message request has
	// timed out.
	//
	// The validatorID, and requestID, are assumed to be the same as those sent
	// in the GetStateSummaryFrontier message.
	GetStateSummaryFrontierFailed(validatorID ids.NodeID, requestID uint32) error
}

StateSummaryFrontierHandler defines how a consensus engine reacts to a state summary frontier message from other validators. Functions only return fatal errors.

func NewNoOpStateSummaryFrontierHandler 

func NewNoOpStateSummaryFrontierHandler(log logging.Logger) StateSummaryFrontierHandler

type StateSummarySender 

type StateSummarySender interface {
	// SendGetStateSummaryFrontier requests that every node in [nodeIDs] sends a
	// StateSummaryFrontier message.
	SendGetStateSummaryFrontier(nodeIDs ids.NodeIDSet, requestID uint32)

	// SendStateSummaryFrontier responds to a StateSummaryFrontier message with this
	// engine's current state summary frontier.
	SendStateSummaryFrontier(nodeID ids.NodeID, requestID uint32, summary []byte)
}

StateSummarySender defines how a consensus engine sends state sync messages to other nodes.

type StateSyncer 

type StateSyncer interface {
	Engine

	// IsEnabled returns true if the underlying VM wants to perform state sync.
	// Any returned error will be considered fatal.
	IsEnabled() (bool, error)
}

StateSyncer controls the selection and verification of state summaries to drive VM state syncing. It collects the latest state summaries and elicit votes on them, making sure that a qualified majority of nodes support the selected state summary.

type Subnet 

type Subnet interface {
	// Returns true iff the subnet is done bootstrapping
	IsBootstrapped() bool

	// Bootstrapped marks the named chain as being bootstrapped
	Bootstrapped(chainID ids.ID)
}

Subnet describes the standard interface of a subnet description

type SubnetTest 

type SubnetTest struct {
	T *testing.T

	CantIsBootstrapped, CantBootstrapped bool

	IsBootstrappedF func() bool
	BootstrappedF   func(ids.ID)
}

SubnetTest is a test subnet

func (*SubnetTest) Bootstrapped 

func (s *SubnetTest) Bootstrapped(chainID ids.ID)

Bootstrapped calls BootstrappedF if it was initialized. If it wasn't initialized and this function shouldn't be called and testing was initialized, then testing will fail.

func (*SubnetTest) Default 

func (s *SubnetTest) Default(cant bool)

Default set the default callable value to [cant]

func (*SubnetTest) IsBootstrapped 

func (s *SubnetTest) IsBootstrapped() bool

IsBootstrapped calls IsBootstrappedF if it was initialized. If it wasn't initialized and this function shouldn't be called and testing was initialized, then testing will fail. Defaults to returning false.

type SubnetTracker 

type SubnetTracker interface {
	// TracksSubnet returns true if [nodeID] tracks [subnetID]
	TracksSubnet(nodeID ids.NodeID, subnetID ids.ID) bool
}

SubnetTracker describes the interface for checking if a node is tracking a subnet

type TestVM 

type TestVM struct {
	T *testing.T

	CantInitialize, CantSetState,
	CantShutdown, CantCreateHandlers, CantCreateStaticHandlers,
	CantHealthCheck, CantConnected, CantDisconnected, CantVersion,
	CantAppRequest, CantAppResponse, CantAppGossip, CantAppRequestFailed bool

	InitializeF           func(*snow.Context, manager.Manager, []byte, []byte, []byte, chan<- Message, []*Fx, AppSender) error
	SetStateF             func(snow.State) error
	ShutdownF             func() error
	CreateHandlersF       func() (map[string]*HTTPHandler, error)
	CreateStaticHandlersF func() (map[string]*HTTPHandler, error)
	ConnectedF            func(nodeID ids.NodeID, nodeVersion *version.Application) error
	DisconnectedF         func(nodeID ids.NodeID) error
	HealthCheckF          func() (interface{}, error)
	AppRequestF           func(nodeID ids.NodeID, requestID uint32, deadline time.Time, msg []byte) error
	AppResponseF          func(nodeID ids.NodeID, requestID uint32, msg []byte) error
	AppGossipF            func(nodeID ids.NodeID, msg []byte) error
	AppRequestFailedF     func(nodeID ids.NodeID, requestID uint32) error
	VersionF              func() (string, error)
}

TestVM is a test vm

func (*TestVM) AppGossip 

func (vm *TestVM) AppGossip(nodeID ids.NodeID, msg []byte) error

func (*TestVM) AppRequest 

func (vm *TestVM) AppRequest(nodeID ids.NodeID, requestID uint32, deadline time.Time, request []byte) error

func (*TestVM) AppRequestFailed 

func (vm *TestVM) AppRequestFailed(nodeID ids.NodeID, requestID uint32) error

func (*TestVM) AppResponse 

func (vm *TestVM) AppResponse(nodeID ids.NodeID, requestID uint32, response []byte) error

func (*TestVM) Connected 

func (vm *TestVM) Connected(id ids.NodeID, nodeVersion *version.Application) error

func (*TestVM) CreateHandlers 

func (vm *TestVM) CreateHandlers() (map[string]*HTTPHandler, error)

func (*TestVM) CreateStaticHandlers 

func (vm *TestVM) CreateStaticHandlers() (map[string]*HTTPHandler, error)

func (*TestVM) Default 

func (vm *TestVM) Default(cant bool)

func (*TestVM) Disconnected 

func (vm *TestVM) Disconnected(id ids.NodeID) error

func (*TestVM) HealthCheck 

func (vm *TestVM) HealthCheck() (interface{}, error)

func (*TestVM) Initialize 

func (vm *TestVM) Initialize(ctx *snow.Context, db manager.Manager, genesisBytes, upgradeBytes, configBytes []byte, msgChan chan<- Message, fxs []*Fx, appSender AppSender) error

func (*TestVM) SetState 

func (vm *TestVM) SetState(state snow.State) error

func (*TestVM) Shutdown 

func (vm *TestVM) Shutdown() error

func (*TestVM) Version 

func (vm *TestVM) Version() (string, error)

type Timer 

type Timer interface {
	// RegisterTimeout specifies how much time to delay the next timeout message
	// by. If the subnet has been bootstrapped, the timeout will fire
	// immediately.
	RegisterTimeout(time.Duration)
}

Timer describes the standard interface for specifying a timeout

type TimerTest 

type TimerTest struct {
	T *testing.T

	CantRegisterTimout bool

	RegisterTimeoutF func(time.Duration)
}

TimerTest is a test timer

func (*TimerTest) Default 

func (t *TimerTest) Default(cant bool)

Default set the default callable value to [cant]

func (*TimerTest) RegisterTimeout 

func (t *TimerTest) RegisterTimeout(delay time.Duration)

type VM 

type VM interface {
	AppHandler

	// Returns nil if the VM is healthy.
	// Periodically called and reported via the node's Health API.
	health.Checker

	// Connector represents a handler that is called on connection connect/disconnect
	validators.Connector

	// Initialize this VM.
	// [ctx]: Metadata about this VM.
	//     [ctx.networkID]: The ID of the network this VM's chain is running on.
	//     [ctx.chainID]: The unique ID of the chain this VM is running on.
	//     [ctx.Log]: Used to log messages
	//     [ctx.NodeID]: The unique staker ID of this node.
	//     [ctx.Lock]: A Read/Write lock shared by this VM and the consensus
	//                 engine that manages this VM. The write lock is held
	//                 whenever code in the consensus engine calls the VM.
	// [dbManager]: The manager of the database this VM will persist data to.
	// [genesisBytes]: The byte-encoding of the genesis information of this
	//                 VM. The VM uses it to initialize its state. For
	//                 example, if this VM were an account-based payments
	//                 system, `genesisBytes` would probably contain a genesis
	//                 transaction that gives coins to some accounts, and this
	//                 transaction would be in the genesis block.
	// [toEngine]: The channel used to send messages to the consensus engine.
	// [fxs]: Feature extensions that attach to this VM.
	Initialize(
		ctx *snow.Context,
		dbManager manager.Manager,
		genesisBytes []byte,
		upgradeBytes []byte,
		configBytes []byte,
		toEngine chan<- Message,
		fxs []*Fx,
		appSender AppSender,
	) error

	// SetState communicates to VM its next state it starts
	SetState(state snow.State) error

	// Shutdown is called when the node is shutting down.
	Shutdown() error

	// Version returns the version of the VM this node is running.
	Version() (string, error)

	// Creates the HTTP handlers for custom VM network calls.
	//
	// This exposes handlers that the outside world can use to communicate with
	// a static reference to the VM. Each handler has the path:
	// [Address of node]/ext/VM/[VM ID]/[extension]
	//
	// Returns a mapping from [extension]s to HTTP handlers.
	//
	// Each extension can specify how locking is managed for convenience.
	//
	// For example, it might make sense to have an extension for creating
	// genesis bytes this VM can interpret.
	CreateStaticHandlers() (map[string]*HTTPHandler, error)

	// Creates the HTTP handlers for custom chain network calls.
	//
	// This exposes handlers that the outside world can use to communicate with
	// the chain. Each handler has the path:
	// [Address of node]/ext/bc/[chain ID]/[extension]
	//
	// Returns a mapping from [extension]s to HTTP handlers.
	//
	// Each extension can specify how locking is managed for convenience.
	//
	// For example, if this VM implements an account-based payments system,
	// it have an extension called `accounts`, where clients could get
	// information about their accounts.
	CreateHandlers() (map[string]*HTTPHandler, error)
}

VM describes the interface that all consensus VMs must implement

Source Files

View all Source files

Directories

Path Synopsis

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.