Version: v1.7.0 Latest Latest

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

Go to latest
Published: Oct 19, 2021 License: GPL-3.0 Imports: 24 Imported by: 18



Package downloader contains the manual full chain synchronisation.

How downloader works

The downloader is responsible for synchronizing up-to-date status from the peers connected to it. To do this, it downloads "headers", "bodies", and "receipts" in parallel, merges them through the pipeline, and reflects them in the state trie.

Source Files

Downloader related functions and variables are defined in the files listed below.

- api.go              : Console APIs to get synchronization information.
- downloader.go       : Functions and variables to sync peer and block. And modules for QoS(Quality of Service).
- downloader_test.go  : Functions for testing the downloader package.
- events.go           : Definitions of event types.
- metrics.go          : Metric variables for packet transmissions and receptions.
- modes.go            : A definition of type for SyncMode including "FullSync", "FastSync", and "LightSync".
- peer.go             : Functions that request a packet to a peer, check, and set the network status of a peer.
- queue.go            : Functions for managing and scheduling received headers, bodies, and receipts.
- types.go            : Definitions of the types for downloaded packets.



This section is empty.


View Source
var (
	MaxHashFetch    = 512 // Amount of hashes to be fetched per retrieval request
	MaxBlockFetch   = 128 // Amount of blocks to be fetched per retrieval request
	MaxHeaderFetch  = 192 // Amount of block headers to be fetched per retrieval request
	MaxSkeletonSize = 128 // Number of header fetches to need for a skeleton assembly
	MaxBodyFetch    = 128 // Amount of block bodies to be fetched per retrieval request
	MaxReceiptFetch = 256 // Amount of transaction receipts to allow fetching per request
	MaxStateFetch   = 384 // Amount of node state values to allow fetching per request

	MaxForkAncestry = 3 * params.EpochDuration // Maximum chain reorganisation



This section is empty.


type BlockChain

type BlockChain interface {

	// HasBlock verifies a block's presence in the local chain.
	HasBlock(common.Hash, uint64) bool

	// GetBlockByHash retrieves a block from the local chain.
	GetBlockByHash(common.Hash) *types.Block

	// CurrentBlock retrieves the head block from the local chain.
	CurrentBlock() *types.Block

	// CurrentFastBlock retrieves the head fast block from the local chain.
	CurrentFastBlock() *types.Block

	// FastSyncCommitHead directly commits the head block to a certain entity.
	FastSyncCommitHead(common.Hash) error

	// InsertChain inserts a batch of blocks into the local chain.
	InsertChain(types.Blocks) (int, error)

	// InsertReceiptChain inserts a batch of receipts into the local chain.
	InsertReceiptChain(types.Blocks, []types.Receipts) (int, error)

BlockChain encapsulates functions required to sync a (full or fast) blockchain.

type DoneEvent

type DoneEvent struct{}

type Downloader

type Downloader struct {
	// contains filtered or unexported fields

func New

func New(mode SyncMode, stateDB database.DBManager, stateBloom *statedb.SyncBloom, mux *event.TypeMux, chain BlockChain, lightchain LightChain, dropPeer peerDropFn) *Downloader

New creates a new downloader to fetch hashes and blocks from remote peers.

func (*Downloader) Cancel

func (d *Downloader) Cancel()

Cancel aborts all of the operations and waits for all download goroutines to finish before returning.

func (*Downloader) DeliverBodies

func (d *Downloader) DeliverBodies(id string, transactions [][]*types.Transaction) (err error)

DeliverBodies injects a new batch of block bodies received from a remote node.

func (*Downloader) DeliverHeaders

func (d *Downloader) DeliverHeaders(id string, headers []*types.Header) (err error)

DeliverHeaders injects a new batch of block headers received from a remote node into the download schedule.

func (*Downloader) DeliverNodeData

func (d *Downloader) DeliverNodeData(id string, data [][]byte) (err error)

DeliverNodeData injects a new batch of node state data received from a remote node.

func (*Downloader) DeliverReceipts

func (d *Downloader) DeliverReceipts(id string, receipts [][]*types.Receipt) (err error)

DeliverReceipts injects a new batch of receipts received from a remote node.

func (*Downloader) Progress

func (d *Downloader) Progress() klaytn.SyncProgress

Progress retrieves the synchronisation boundaries, specifically the origin block where synchronisation started at (may have failed/suspended); the block or header sync is currently at; and the latest known block which the sync targets.

In addition, during the state download phase of fast synchronisation the number of processed and the total number of known states are also returned. Otherwise these are zero.

func (*Downloader) RegisterLightPeer

func (d *Downloader) RegisterLightPeer(id string, version int, peer LightPeer) error

RegisterLightPeer injects a light client peer, wrapping it so it appears as a regular peer.

func (*Downloader) RegisterPeer

func (d *Downloader) RegisterPeer(id string, version int, peer Peer) error

RegisterPeer injects a new download peer into the set of block source to be used for fetching hashes and blocks from.

func (*Downloader) Synchronise

func (d *Downloader) Synchronise(id string, head common.Hash, td *big.Int, mode SyncMode) error

Synchronise tries to sync up our local block chain with a remote peer, both adding various sanity checks as well as wrapping it with various logger entries.

func (*Downloader) Synchronising

func (d *Downloader) Synchronising() bool

Synchronising returns whether the downloader is currently retrieving blocks.

func (*Downloader) Terminate

func (d *Downloader) Terminate()

Terminate interrupts the downloader, canceling all pending operations. The downloader cannot be reused after calling Terminate.

func (*Downloader) UnregisterPeer

func (d *Downloader) UnregisterPeer(id string) error

UnregisterPeer remove a peer from the known list, preventing any action from the specified peer. An effort is also made to return any pending fetches into the queue.

type FailedEvent

type FailedEvent struct{ Err error }

type FakeDownloader added in v1.5.3

type FakeDownloader struct{}

fakeDownloader do nothing

func NewFakeDownloader added in v1.5.3

func NewFakeDownloader() *FakeDownloader

func (*FakeDownloader) DeliverBodies added in v1.5.3

func (*FakeDownloader) DeliverBodies(id string, transactions [][]*types.Transaction) error

func (*FakeDownloader) DeliverHeaders added in v1.5.3

func (*FakeDownloader) DeliverHeaders(id string, headers []*types.Header) error

func (*FakeDownloader) DeliverNodeData added in v1.5.3

func (*FakeDownloader) DeliverNodeData(id string, data [][]byte) error

func (*FakeDownloader) DeliverReceipts added in v1.5.3

func (*FakeDownloader) DeliverReceipts(id string, receipts [][]*types.Receipt) error

func (*FakeDownloader) Progress added in v1.5.3

func (*FakeDownloader) Progress() klaytn.SyncProgress

func (*FakeDownloader) RegisterPeer added in v1.5.3

func (*FakeDownloader) RegisterPeer(id string, version int, peer Peer) error

func (*FakeDownloader) Synchronise added in v1.5.3

func (*FakeDownloader) Synchronise(id string, head common.Hash, td *big.Int, mode SyncMode) error

func (*FakeDownloader) Terminate added in v1.5.3

func (*FakeDownloader) Terminate()

func (*FakeDownloader) UnregisterPeer added in v1.5.3

func (*FakeDownloader) UnregisterPeer(id string) error

type LightChain

type LightChain interface {
	// HasHeader verifies a header's presence in the local chain.
	HasHeader(common.Hash, uint64) bool

	// GetHeaderByHash retrieves a header from the local chain.
	GetHeaderByHash(common.Hash) *types.Header

	// CurrentHeader retrieves the head header from the local chain.
	CurrentHeader() *types.Header

	// GetTd returns the total blockscore of a local block.
	GetTd(common.Hash, uint64) *big.Int

	// InsertHeaderChain inserts a batch of headers into the local chain.
	InsertHeaderChain([]*types.Header, int) (int, error)

	// Rollback removes a few recently added elements from the local chain.

LightChain encapsulates functions required to synchronise a light chain.

type LightPeer

type LightPeer interface {
	Head() (common.Hash, *big.Int)
	RequestHeadersByHash(common.Hash, int, int, bool) error
	RequestHeadersByNumber(uint64, int, int, bool) error

LightPeer encapsulates the methods required to synchronise with a remote light peer.

type Peer

type Peer interface {
	RequestBodies([]common.Hash) error
	RequestReceipts([]common.Hash) error
	RequestNodeData([]common.Hash) error

Peer encapsulates the methods required to synchronise with a remote full peer.

type PublicDownloaderAPI

type PublicDownloaderAPI struct {
	// contains filtered or unexported fields

PublicDownloaderAPI provides an API which gives information about the current synchronisation status. It offers only methods that operates on data that can be available to anyone without security risks.

func NewPublicDownloaderAPI

func NewPublicDownloaderAPI(d downloadProgress, m *event.TypeMux) *PublicDownloaderAPI

NewPublicDownloaderAPI creates a new PublicDownloaderAPI. The API has an internal event loop that listens for events from the downloader through the global event mux. In case it receives one of these events it broadcasts it to all syncing subscriptions that are installed through the installSyncSubscription channel.

func (*PublicDownloaderAPI) SubscribeSyncStatus

func (api *PublicDownloaderAPI) SubscribeSyncStatus(status chan interface{}) *SyncStatusSubscription

SubscribeSyncStatus creates a subscription that will broadcast new synchronisation updates. The given channel must receive interface values, the result can either

func (*PublicDownloaderAPI) Syncing

func (api *PublicDownloaderAPI) Syncing(ctx context.Context) (*rpc.Subscription, error)

Syncing provides information when this nodes starts synchronising with the Klaytn network and when it's finished.

type StartEvent

type StartEvent struct{}

type SyncMode

type SyncMode uint32

SyncMode represents the synchronisation mode of the downloader. It is a uint32 as it is used with atomic operations.

const (
	FullSync  SyncMode = iota // Synchronise the entire blockchain history from full blocks
	FastSync                  // Quickly download the headers, full sync only at the chain head
	LightSync                 // Download only the headers and terminate afterwards

func (SyncMode) IsValid

func (mode SyncMode) IsValid() bool

func (SyncMode) MarshalText

func (mode SyncMode) MarshalText() ([]byte, error)

func (SyncMode) String

func (mode SyncMode) String() string

String implements the stringer interface.

func (*SyncMode) UnmarshalText

func (mode *SyncMode) UnmarshalText(text []byte) error

type SyncStatusSubscription

type SyncStatusSubscription struct {
	// contains filtered or unexported fields

SyncStatusSubscription represents a syncing subscription.

func (*SyncStatusSubscription) Unsubscribe

func (s *SyncStatusSubscription) Unsubscribe()

Unsubscribe uninstalls the subscription from the DownloadAPI event loop. The status channel that was passed to subscribeSyncStatus isn't used anymore after this method returns.

type SyncingResult

type SyncingResult struct {
	Syncing bool                `json:"syncing"`
	Status  klaytn.SyncProgress `json:"status"`

SyncingResult provides information about the current synchronisation status for this node.

Jump to

Keyboard shortcuts

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