synchronization

type Config ¶

type Config struct {
	PollInterval time.Duration
	ScanInterval time.Duration
}

func DefaultConfig() *Config

type Engine ¶

type Engine struct {
	component.Component
	hotstuff.FinalizationConsumer
	// contains filtered or unexported fields
}

Engine is the synchronization engine, responsible for synchronizing chain state.

func New(
	log zerolog.Logger,
	metrics module.EngineMetrics,
	net network.EngineRegistry,
	me module.Local,
	state protocol.State,
	blocks storage.Blocks,
	comp consensus.Compliance,
	core module.SyncCore,
	participantsProvider module.IdentifierProvider,
	spamDetectionConfig *SpamDetectionConfig,
	opts ...OptionFunc,
) (*Engine, error)

func (e *Engine) Process(channel channels.Channel, originID flow.Identifier, event interface{}) error

type OptionFunc ¶

type OptionFunc func(*Config)

func WithPollInterval(interval time.Duration) OptionFunc

func WithScanInterval(interval time.Duration) OptionFunc

type RequestHandler ¶ added in v0.23.9

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

RequestHandler encapsulates message queues and processing logic for the sync engine. It logically separates request processing from active participation (sending requests), primarily to simplify nodes which bridge the public and private networks.

The RequestHandlerEngine embeds RequestHandler to create an engine which only responds to requests on the public network (does not send requests over this network). The Engine embeds RequestHandler and additionally includes logic for sending sync requests.

Although the RequestHandler defines a notifier, message queue, and processing worker logic, it is not itself a component.Component and does not manage any worker threads. The containing engine is responsible for starting the worker threads for processing requests.

func NewRequestHandler(
	log zerolog.Logger,
	metrics module.EngineMetrics,
	responseSender ResponseSender,
	me module.Local,
	finalizedHeaderCache *events.FinalizedHeaderCache,
	blocks storage.Blocks,
	core module.SyncCore,
	queueMissingHeights bool,
) *RequestHandler

func (r *RequestHandler) Process(channel channels.Channel, originID flow.Identifier, event interface{}) error

type RequestHandlerEngine ¶ added in v0.21.0

type RequestHandlerEngine struct {
	component.Component
	hotstuff.FinalizationConsumer
	// contains filtered or unexported fields
}

RequestHandlerEngine is an engine which operates only the request-handling portion of the block sync protocol. It is used by Access/Observer nodes attached to the public network, enabling them to provide block synchronization data to nodes on the public network, but not requesting any data from these nodes. (Requests are sent only on the private network.)

func NewRequestHandlerEngine(
	logger zerolog.Logger,
	metrics module.EngineMetrics,
	net network.EngineRegistry,
	me module.Local,
	state protocol.State,
	blocks storage.Blocks,
	core module.SyncCore,
) (*RequestHandlerEngine, error)

func (r *RequestHandlerEngine) Process(channel channels.Channel, originID flow.Identifier, event interface{}) error

type RequestHeap ¶ added in v0.19.0

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

RequestHeap is a special structure that implements engine.MessageStore interface and indexes requests by originator. If request will be sent by same originator then it will replace the old one. Comparing to default FIFO queue this one can contain MAX one request for origin ID. Getting value from queue as well as ejecting is pseudo-random.

func NewRequestHeap(limit uint) *RequestHeap

func (q *RequestHeap) Get() (*engine.Message, bool)

func (q *RequestHeap) Put(message *engine.Message) bool

type ResponseSender ¶ added in v0.23.9

type ResponseSender interface {
	SendResponse(interface{}, flow.Identifier) error
}

type ResponseSenderImpl ¶ added in v0.23.9

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

func NewResponseSender(con network.Conduit) *ResponseSenderImpl

func (r *ResponseSenderImpl) SendResponse(res interface{}, target flow.Identifier) error

type SpamDetectionConfig ¶ added in v0.32.0

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

SpamDetectionConfig contains configuration parameters for spam detection for different message types. The probability of creating a misbehavior report for a message of a given type is calculated differently for different message types. MisbehaviourReports are generated for two reasons:

1. A malformed message will always produce a MisbehaviourReport, to notify ALSP of *unambiguous* spam.
2. A correctly formed message may produce a MisbehaviourReport probabilistically, to notify ALSP of *ambiguous* spam. This effectively tracks the load associated with a particular sender, for this engine, and, on average, reports message load proportionally as misbehaviour to ALSP.

func NewSpamDetectionConfig() (*SpamDetectionConfig, error)