synchronization

package
v0.33.36-atree-util Latest Latest
Warning

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

Go to latest
Published: Jun 13, 2024 License: AGPL-3.0 Imports: 28 Imported by: 9

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Config

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

func DefaultConfig

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

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)

New creates a new main chain synchronization engine.

func (*Engine) Process

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

Process processes the given event from the node with the given origin ID in a blocking manner. It returns the potential processing error when done.

type OptionFunc

type OptionFunc func(*Config)

func WithPollInterval

func WithPollInterval(interval time.Duration) OptionFunc

WithPollInterval sets a custom interval at which we scan for poll items

func WithScanInterval

func WithScanInterval(interval time.Duration) OptionFunc

WithScanInterval sets a custom interval at which we scan for pending items and batch them for requesting.

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 added in v0.23.9

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 (*RequestHandler) Process added in v0.23.9

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

Process processes the given event from the node with the given origin ID in a blocking manner. No errors are expected during normal operation.

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 added in v0.21.0

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 (*RequestHandlerEngine) Process added in v0.21.0

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 added in v0.19.0

func NewRequestHeap(limit uint) *RequestHeap

func (*RequestHeap) Get added in v0.19.0

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

Get returns pseudo-random element from request storage using go map properties.

func (*RequestHeap) Put added in v0.19.0

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

Put stores message into requests map using OriginID as key. Returns always true

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 added in v0.23.9

func NewResponseSender(con network.Conduit) *ResponseSenderImpl

func (*ResponseSenderImpl) SendResponse added in v0.23.9

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 added in v0.32.0

func NewSpamDetectionConfig() (*SpamDetectionConfig, error)

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL