mirror of https://github.com/ethereum/go-ethereum
consensus, cmd, core, eth: remove support for non-merge mode of operation (#29169)
* eth: drop support for forward sync triggers and head block packets * consensus, eth: enforce always merged network * eth: fix tx looper startup and shutdown * cmd, core: fix some tests * core: remove notion of future blocks * core, eth: drop unused methods and typespull/29172/head
Péter Szilágyi
9 months ago
committed by
GitHub
parent
9a0fa8093c
commit
f4d53133f6
@ -1,110 +0,0 @@ |
||||
// Copyright 2021 The go-ethereum Authors
|
||||
// This file is part of the go-ethereum library.
|
||||
//
|
||||
// The go-ethereum library is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// The go-ethereum library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
package consensus |
||||
|
||||
import ( |
||||
"fmt" |
||||
"sync" |
||||
|
||||
"github.com/ethereum/go-ethereum/core/rawdb" |
||||
"github.com/ethereum/go-ethereum/ethdb" |
||||
"github.com/ethereum/go-ethereum/log" |
||||
"github.com/ethereum/go-ethereum/rlp" |
||||
) |
||||
|
||||
// transitionStatus describes the status of eth1/2 transition. This switch
|
||||
// between modes is a one-way action which is triggered by corresponding
|
||||
// consensus-layer message.
|
||||
type transitionStatus struct { |
||||
LeftPoW bool // The flag is set when the first NewHead message received
|
||||
EnteredPoS bool // The flag is set when the first FinalisedBlock message received
|
||||
} |
||||
|
||||
// Merger is an internal help structure used to track the eth1/2 transition status.
|
||||
// It's a common structure can be used in both full node and light client.
|
||||
type Merger struct { |
||||
db ethdb.KeyValueStore |
||||
status transitionStatus |
||||
mu sync.RWMutex |
||||
} |
||||
|
||||
// NewMerger creates a new Merger which stores its transition status in the provided db.
|
||||
func NewMerger(db ethdb.KeyValueStore) *Merger { |
||||
var status transitionStatus |
||||
blob := rawdb.ReadTransitionStatus(db) |
||||
if len(blob) != 0 { |
||||
if err := rlp.DecodeBytes(blob, &status); err != nil { |
||||
log.Crit("Failed to decode the transition status", "err", err) |
||||
} |
||||
} |
||||
return &Merger{ |
||||
db: db, |
||||
status: status, |
||||
} |
||||
} |
||||
|
||||
// ReachTTD is called whenever the first NewHead message received
|
||||
// from the consensus-layer.
|
||||
func (m *Merger) ReachTTD() { |
||||
m.mu.Lock() |
||||
defer m.mu.Unlock() |
||||
|
||||
if m.status.LeftPoW { |
||||
return |
||||
} |
||||
m.status = transitionStatus{LeftPoW: true} |
||||
blob, err := rlp.EncodeToBytes(m.status) |
||||
if err != nil { |
||||
panic(fmt.Sprintf("Failed to encode the transition status: %v", err)) |
||||
} |
||||
rawdb.WriteTransitionStatus(m.db, blob) |
||||
log.Info("Left PoW stage") |
||||
} |
||||
|
||||
// FinalizePoS is called whenever the first FinalisedBlock message received
|
||||
// from the consensus-layer.
|
||||
func (m *Merger) FinalizePoS() { |
||||
m.mu.Lock() |
||||
defer m.mu.Unlock() |
||||
|
||||
if m.status.EnteredPoS { |
||||
return |
||||
} |
||||
m.status = transitionStatus{LeftPoW: true, EnteredPoS: true} |
||||
blob, err := rlp.EncodeToBytes(m.status) |
||||
if err != nil { |
||||
panic(fmt.Sprintf("Failed to encode the transition status: %v", err)) |
||||
} |
||||
rawdb.WriteTransitionStatus(m.db, blob) |
||||
log.Info("Entered PoS stage") |
||||
} |
||||
|
||||
// TDDReached reports whether the chain has left the PoW stage.
|
||||
func (m *Merger) TDDReached() bool { |
||||
m.mu.RLock() |
||||
defer m.mu.RUnlock() |
||||
|
||||
return m.status.LeftPoW |
||||
} |
||||
|
||||
// PoSFinalized reports whether the chain has entered the PoS stage.
|
||||
func (m *Merger) PoSFinalized() bool { |
||||
m.mu.RLock() |
||||
defer m.mu.RUnlock() |
||||
|
||||
return m.status.EnteredPoS |
||||
} |
||||
@ -1,939 +0,0 @@ |
||||
// Copyright 2015 The go-ethereum Authors
|
||||
// This file is part of the go-ethereum library.
|
||||
//
|
||||
// The go-ethereum library is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// The go-ethereum library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
// Package fetcher contains the announcement based header, blocks or transaction synchronisation.
|
||||
package fetcher |
||||
|
||||
import ( |
||||
"errors" |
||||
"math/rand" |
||||
"time" |
||||
|
||||
"github.com/ethereum/go-ethereum/common" |
||||
"github.com/ethereum/go-ethereum/common/prque" |
||||
"github.com/ethereum/go-ethereum/consensus" |
||||
"github.com/ethereum/go-ethereum/core/types" |
||||
"github.com/ethereum/go-ethereum/eth/protocols/eth" |
||||
"github.com/ethereum/go-ethereum/log" |
||||
"github.com/ethereum/go-ethereum/metrics" |
||||
"github.com/ethereum/go-ethereum/trie" |
||||
) |
||||
|
||||
const ( |
||||
lightTimeout = time.Millisecond // Time allowance before an announced header is explicitly requested
|
||||
arriveTimeout = 500 * time.Millisecond // Time allowance before an announced block/transaction is explicitly requested
|
||||
gatherSlack = 100 * time.Millisecond // Interval used to collate almost-expired announces with fetches
|
||||
fetchTimeout = 5 * time.Second // Maximum allotted time to return an explicitly requested block/transaction
|
||||
) |
||||
|
||||
const ( |
||||
maxUncleDist = 7 // Maximum allowed backward distance from the chain head
|
||||
maxQueueDist = 32 // Maximum allowed distance from the chain head to queue
|
||||
hashLimit = 256 // Maximum number of unique blocks or headers a peer may have announced
|
||||
blockLimit = 64 // Maximum number of unique blocks a peer may have delivered
|
||||
) |
||||
|
||||
var ( |
||||
blockAnnounceInMeter = metrics.NewRegisteredMeter("eth/fetcher/block/announces/in", nil) |
||||
blockAnnounceOutTimer = metrics.NewRegisteredTimer("eth/fetcher/block/announces/out", nil) |
||||
blockAnnounceDropMeter = metrics.NewRegisteredMeter("eth/fetcher/block/announces/drop", nil) |
||||
blockAnnounceDOSMeter = metrics.NewRegisteredMeter("eth/fetcher/block/announces/dos", nil) |
||||
|
||||
blockBroadcastInMeter = metrics.NewRegisteredMeter("eth/fetcher/block/broadcasts/in", nil) |
||||
blockBroadcastOutTimer = metrics.NewRegisteredTimer("eth/fetcher/block/broadcasts/out", nil) |
||||
blockBroadcastDropMeter = metrics.NewRegisteredMeter("eth/fetcher/block/broadcasts/drop", nil) |
||||
blockBroadcastDOSMeter = metrics.NewRegisteredMeter("eth/fetcher/block/broadcasts/dos", nil) |
||||
|
||||
headerFetchMeter = metrics.NewRegisteredMeter("eth/fetcher/block/headers", nil) |
||||
bodyFetchMeter = metrics.NewRegisteredMeter("eth/fetcher/block/bodies", nil) |
||||
|
||||
headerFilterInMeter = metrics.NewRegisteredMeter("eth/fetcher/block/filter/headers/in", nil) |
||||
headerFilterOutMeter = metrics.NewRegisteredMeter("eth/fetcher/block/filter/headers/out", nil) |
||||
bodyFilterInMeter = metrics.NewRegisteredMeter("eth/fetcher/block/filter/bodies/in", nil) |
||||
bodyFilterOutMeter = metrics.NewRegisteredMeter("eth/fetcher/block/filter/bodies/out", nil) |
||||
) |
||||
|
||||
var errTerminated = errors.New("terminated") |
||||
|
||||
// HeaderRetrievalFn is a callback type for retrieving a header from the local chain.
|
||||
type HeaderRetrievalFn func(common.Hash) *types.Header |
||||
|
||||
// blockRetrievalFn is a callback type for retrieving a block from the local chain.
|
||||
type blockRetrievalFn func(common.Hash) *types.Block |
||||
|
||||
// headerRequesterFn is a callback type for sending a header retrieval request.
|
||||
type headerRequesterFn func(common.Hash, chan *eth.Response) (*eth.Request, error) |
||||
|
||||
// bodyRequesterFn is a callback type for sending a body retrieval request.
|
||||
type bodyRequesterFn func([]common.Hash, chan *eth.Response) (*eth.Request, error) |
||||
|
||||
// headerVerifierFn is a callback type to verify a block's header for fast propagation.
|
||||
type headerVerifierFn func(header *types.Header) error |
||||
|
||||
// blockBroadcasterFn is a callback type for broadcasting a block to connected peers.
|
||||
type blockBroadcasterFn func(block *types.Block, propagate bool) |
||||
|
||||
// chainHeightFn is a callback type to retrieve the current chain height.
|
||||
type chainHeightFn func() uint64 |
||||
|
||||
// headersInsertFn is a callback type to insert a batch of headers into the local chain.
|
||||
type headersInsertFn func(headers []*types.Header) (int, error) |
||||
|
||||
// chainInsertFn is a callback type to insert a batch of blocks into the local chain.
|
||||
type chainInsertFn func(types.Blocks) (int, error) |
||||
|
||||
// peerDropFn is a callback type for dropping a peer detected as malicious.
|
||||
type peerDropFn func(id string) |
||||
|
||||
// blockAnnounce is the hash notification of the availability of a new block in the
|
||||
// network.
|
||||
type blockAnnounce struct { |
||||
hash common.Hash // Hash of the block being announced
|
||||
number uint64 // Number of the block being announced (0 = unknown | old protocol)
|
||||
header *types.Header // Header of the block partially reassembled (new protocol)
|
||||
time time.Time // Timestamp of the announcement
|
||||
|
||||
origin string // Identifier of the peer originating the notification
|
||||
|
||||
fetchHeader headerRequesterFn // Fetcher function to retrieve the header of an announced block
|
||||
fetchBodies bodyRequesterFn // Fetcher function to retrieve the body of an announced block
|
||||
} |
||||
|
||||
// headerFilterTask represents a batch of headers needing fetcher filtering.
|
||||
type headerFilterTask struct { |
||||
peer string // The source peer of block headers
|
||||
headers []*types.Header // Collection of headers to filter
|
||||
time time.Time // Arrival time of the headers
|
||||
} |
||||
|
||||
// bodyFilterTask represents a batch of block bodies (transactions and uncles)
|
||||
// needing fetcher filtering.
|
||||
type bodyFilterTask struct { |
||||
peer string // The source peer of block bodies
|
||||
transactions [][]*types.Transaction // Collection of transactions per block bodies
|
||||
uncles [][]*types.Header // Collection of uncles per block bodies
|
||||
time time.Time // Arrival time of the blocks' contents
|
||||
} |
||||
|
||||
// blockOrHeaderInject represents a schedules import operation.
|
||||
type blockOrHeaderInject struct { |
||||
origin string |
||||
|
||||
header *types.Header // Used for light mode fetcher which only cares about header.
|
||||
block *types.Block // Used for normal mode fetcher which imports full block.
|
||||
} |
||||
|
||||
// number returns the block number of the injected object.
|
||||
func (inject *blockOrHeaderInject) number() uint64 { |
||||
if inject.header != nil { |
||||
return inject.header.Number.Uint64() |
||||
} |
||||
return inject.block.NumberU64() |
||||
} |
||||
|
||||
// number returns the block hash of the injected object.
|
||||
func (inject *blockOrHeaderInject) hash() common.Hash { |
||||
if inject.header != nil { |
||||
return inject.header.Hash() |
||||
} |
||||
return inject.block.Hash() |
||||
} |
||||
|
||||
// BlockFetcher is responsible for accumulating block announcements from various peers
|
||||
// and scheduling them for retrieval.
|
||||
type BlockFetcher struct { |
||||
light bool // The indicator whether it's a light fetcher or normal one.
|
||||
|
||||
// Various event channels
|
||||
notify chan *blockAnnounce |
||||
inject chan *blockOrHeaderInject |
||||
|
||||
headerFilter chan chan *headerFilterTask |
||||
bodyFilter chan chan *bodyFilterTask |
||||
|
||||
done chan common.Hash |
||||
quit chan struct{} |
||||
|
||||
// Announce states
|
||||
announces map[string]int // Per peer blockAnnounce counts to prevent memory exhaustion
|
||||
announced map[common.Hash][]*blockAnnounce // Announced blocks, scheduled for fetching
|
||||
fetching map[common.Hash]*blockAnnounce // Announced blocks, currently fetching
|
||||
fetched map[common.Hash][]*blockAnnounce // Blocks with headers fetched, scheduled for body retrieval
|
||||
completing map[common.Hash]*blockAnnounce // Blocks with headers, currently body-completing
|
||||
|
||||
// Block cache
|
||||
queue *prque.Prque[int64, *blockOrHeaderInject] // Queue containing the import operations (block number sorted)
|
||||
queues map[string]int // Per peer block counts to prevent memory exhaustion
|
||||
queued map[common.Hash]*blockOrHeaderInject // Set of already queued blocks (to dedup imports)
|
||||
|
||||
// Callbacks
|
||||
getHeader HeaderRetrievalFn // Retrieves a header from the local chain
|
||||
getBlock blockRetrievalFn // Retrieves a block from the local chain
|
||||
verifyHeader headerVerifierFn // Checks if a block's headers have a valid proof of work
|
||||
broadcastBlock blockBroadcasterFn // Broadcasts a block to connected peers
|
||||
chainHeight chainHeightFn // Retrieves the current chain's height
|
||||
insertHeaders headersInsertFn // Injects a batch of headers into the chain
|
||||
insertChain chainInsertFn // Injects a batch of blocks into the chain
|
||||
dropPeer peerDropFn // Drops a peer for misbehaving
|
||||
|
||||
// Testing hooks
|
||||
announceChangeHook func(common.Hash, bool) // Method to call upon adding or deleting a hash from the blockAnnounce list
|
||||
queueChangeHook func(common.Hash, bool) // Method to call upon adding or deleting a block from the import queue
|
||||
fetchingHook func([]common.Hash) // Method to call upon starting a block (eth/61) or header (eth/62) fetch
|
||||
completingHook func([]common.Hash) // Method to call upon starting a block body fetch (eth/62)
|
||||
importedHook func(*types.Header, *types.Block) // Method to call upon successful header or block import (both eth/61 and eth/62)
|
||||
} |
||||
|
||||
// NewBlockFetcher creates a block fetcher to retrieve blocks based on hash announcements.
|
||||
func NewBlockFetcher(light bool, getHeader HeaderRetrievalFn, getBlock blockRetrievalFn, verifyHeader headerVerifierFn, broadcastBlock blockBroadcasterFn, chainHeight chainHeightFn, insertHeaders headersInsertFn, insertChain chainInsertFn, dropPeer peerDropFn) *BlockFetcher { |
||||
return &BlockFetcher{ |
||||
light: light, |
||||
notify: make(chan *blockAnnounce), |
||||
inject: make(chan *blockOrHeaderInject), |
||||
headerFilter: make(chan chan *headerFilterTask), |
||||
bodyFilter: make(chan chan *bodyFilterTask), |
||||
done: make(chan common.Hash), |
||||
quit: make(chan struct{}), |
||||
announces: make(map[string]int), |
||||
announced: make(map[common.Hash][]*blockAnnounce), |
||||
fetching: make(map[common.Hash]*blockAnnounce), |
||||
fetched: make(map[common.Hash][]*blockAnnounce), |
||||
completing: make(map[common.Hash]*blockAnnounce), |
||||
queue: prque.New[int64, *blockOrHeaderInject](nil), |
||||
queues: make(map[string]int), |
||||
queued: make(map[common.Hash]*blockOrHeaderInject), |
||||
getHeader: getHeader, |
||||
getBlock: getBlock, |
||||
verifyHeader: verifyHeader, |
||||
broadcastBlock: broadcastBlock, |
||||
chainHeight: chainHeight, |
||||
insertHeaders: insertHeaders, |
||||
insertChain: insertChain, |
||||
dropPeer: dropPeer, |
||||
} |
||||
} |
||||
|
||||
// Start boots up the announcement based synchroniser, accepting and processing
|
||||
// hash notifications and block fetches until termination requested.
|
||||
func (f *BlockFetcher) Start() { |
||||
go f.loop() |
||||
} |
||||
|
||||
// Stop terminates the announcement based synchroniser, canceling all pending
|
||||
// operations.
|
||||
func (f *BlockFetcher) Stop() { |
||||
close(f.quit) |
||||
} |
||||
|
||||
// Notify announces the fetcher of the potential availability of a new block in
|
||||
// the network.
|
||||
func (f *BlockFetcher) Notify(peer string, hash common.Hash, number uint64, time time.Time, |
||||
headerFetcher headerRequesterFn, bodyFetcher bodyRequesterFn) error { |
||||
block := &blockAnnounce{ |
||||
hash: hash, |
||||
number: number, |
||||
time: time, |
||||
origin: peer, |
||||
fetchHeader: headerFetcher, |
||||
fetchBodies: bodyFetcher, |
||||
} |
||||
select { |
||||
case f.notify <- block: |
||||
return nil |
||||
case <-f.quit: |
||||
return errTerminated |
||||
} |
||||
} |
||||
|
||||
// Enqueue tries to fill gaps the fetcher's future import queue.
|
||||
func (f *BlockFetcher) Enqueue(peer string, block *types.Block) error { |
||||
op := &blockOrHeaderInject{ |
||||
origin: peer, |
||||
block: block, |
||||
} |
||||
select { |
||||
case f.inject <- op: |
||||
return nil |
||||
case <-f.quit: |
||||
return errTerminated |
||||
} |
||||
} |
||||
|
||||
// FilterHeaders extracts all the headers that were explicitly requested by the fetcher,
|
||||
// returning those that should be handled differently.
|
||||
func (f *BlockFetcher) FilterHeaders(peer string, headers []*types.Header, time time.Time) []*types.Header { |
||||
log.Trace("Filtering headers", "peer", peer, "headers", len(headers)) |
||||
|
||||
// Send the filter channel to the fetcher
|
||||
filter := make(chan *headerFilterTask) |
||||
|
||||
select { |
||||
case f.headerFilter <- filter: |
||||
case <-f.quit: |
||||
return nil |
||||
} |
||||
// Request the filtering of the header list
|
||||
select { |
||||
case filter <- &headerFilterTask{peer: peer, headers: headers, time: time}: |
||||
case <-f.quit: |
||||
return nil |
||||
} |
||||
// Retrieve the headers remaining after filtering
|
||||
select { |
||||
case task := <-filter: |
||||
return task.headers |
||||
case <-f.quit: |
||||
return nil |
||||
} |
||||
} |
||||
|
||||
// FilterBodies extracts all the block bodies that were explicitly requested by
|
||||
// the fetcher, returning those that should be handled differently.
|
||||
func (f *BlockFetcher) FilterBodies(peer string, transactions [][]*types.Transaction, uncles [][]*types.Header, time time.Time) ([][]*types.Transaction, [][]*types.Header) { |
||||
log.Trace("Filtering bodies", "peer", peer, "txs", len(transactions), "uncles", len(uncles)) |
||||
|
||||
// Send the filter channel to the fetcher
|
||||
filter := make(chan *bodyFilterTask) |
||||
|
||||
select { |
||||
case f.bodyFilter <- filter: |
||||
case <-f.quit: |
||||
return nil, nil |
||||
} |
||||
// Request the filtering of the body list
|
||||
select { |
||||
case filter <- &bodyFilterTask{peer: peer, transactions: transactions, uncles: uncles, time: time}: |
||||
case <-f.quit: |
||||
return nil, nil |
||||
} |
||||
// Retrieve the bodies remaining after filtering
|
||||
select { |
||||
case task := <-filter: |
||||
return task.transactions, task.uncles |
||||
case <-f.quit: |
||||
return nil, nil |
||||
} |
||||
} |
||||
|
||||
// Loop is the main fetcher loop, checking and processing various notification
|
||||
// events.
|
||||
func (f *BlockFetcher) loop() { |
||||
// Iterate the block fetching until a quit is requested
|
||||
var ( |
||||
fetchTimer = time.NewTimer(0) |
||||
completeTimer = time.NewTimer(0) |
||||
) |
||||
<-fetchTimer.C // clear out the channel
|
||||
<-completeTimer.C |
||||
defer fetchTimer.Stop() |
||||
defer completeTimer.Stop() |
||||
|
||||
for { |
||||
// Clean up any expired block fetches
|
||||
for hash, announce := range f.fetching { |
||||
if time.Since(announce.time) > fetchTimeout { |
||||
f.forgetHash(hash) |
||||
} |
||||
} |
||||
// Import any queued blocks that could potentially fit
|
||||
height := f.chainHeight() |
||||
for !f.queue.Empty() { |
||||
op := f.queue.PopItem() |
||||
hash := op.hash() |
||||
if f.queueChangeHook != nil { |
||||
f.queueChangeHook(hash, false) |
||||
} |
||||
// If too high up the chain or phase, continue later
|
||||
number := op.number() |
||||
if number > height+1 { |
||||
f.queue.Push(op, -int64(number)) |
||||
if f.queueChangeHook != nil { |
||||
f.queueChangeHook(hash, true) |
||||
} |
||||
break |
||||
} |
||||
// Otherwise if fresh and still unknown, try and import
|
||||
if (number+maxUncleDist < height) || (f.light && f.getHeader(hash) != nil) || (!f.light && f.getBlock(hash) != nil) { |
||||
f.forgetBlock(hash) |
||||
continue |
||||
} |
||||
if f.light { |
||||
f.importHeaders(op.origin, op.header) |
||||
} else { |
||||
f.importBlocks(op.origin, op.block) |
||||
} |
||||
} |
||||
// Wait for an outside event to occur
|
||||
select { |
||||
case <-f.quit: |
||||
// BlockFetcher terminating, abort all operations
|
||||
return |
||||
|
||||
case notification := <-f.notify: |
||||
// A block was announced, make sure the peer isn't DOSing us
|
||||
blockAnnounceInMeter.Mark(1) |
||||
|
||||
count := f.announces[notification.origin] + 1 |
||||
if count > hashLimit { |
||||
log.Debug("Peer exceeded outstanding announces", "peer", notification.origin, "limit", hashLimit) |
||||
blockAnnounceDOSMeter.Mark(1) |
||||
break |
||||
} |
||||
if notification.number == 0 { |
||||
break |
||||
} |
||||
// If we have a valid block number, check that it's potentially useful
|
||||
if dist := int64(notification.number) - int64(f.chainHeight()); dist < -maxUncleDist || dist > maxQueueDist { |
||||
log.Debug("Peer discarded announcement", "peer", notification.origin, "number", notification.number, "hash", notification.hash, "distance", dist) |
||||
blockAnnounceDropMeter.Mark(1) |
||||
break |
||||
} |
||||
// All is well, schedule the announce if block's not yet downloading
|
||||
if _, ok := f.fetching[notification.hash]; ok { |
||||
break |
||||
} |
||||
if _, ok := f.completing[notification.hash]; ok { |
||||
break |
||||
} |
||||
f.announces[notification.origin] = count |
||||
f.announced[notification.hash] = append(f.announced[notification.hash], notification) |
||||
if f.announceChangeHook != nil && len(f.announced[notification.hash]) == 1 { |
||||
f.announceChangeHook(notification.hash, true) |
||||
} |
||||
if len(f.announced) == 1 { |
||||
f.rescheduleFetch(fetchTimer) |
||||
} |
||||
|
||||
case op := <-f.inject: |
||||
// A direct block insertion was requested, try and fill any pending gaps
|
||||
blockBroadcastInMeter.Mark(1) |
||||
|
||||
// Now only direct block injection is allowed, drop the header injection
|
||||
// here silently if we receive.
|
||||
if f.light { |
||||
continue |
||||
} |
||||
f.enqueue(op.origin, nil, op.block) |
||||
|
||||
case hash := <-f.done: |
||||
// A pending import finished, remove all traces of the notification
|
||||
f.forgetHash(hash) |
||||
f.forgetBlock(hash) |
||||
|
||||
case <-fetchTimer.C: |
||||
// At least one block's timer ran out, check for needing retrieval
|
||||
request := make(map[string][]common.Hash) |
||||
|
||||
for hash, announces := range f.announced { |
||||
// In current LES protocol(les2/les3), only header announce is
|
||||
// available, no need to wait too much time for header broadcast.
|
||||
timeout := arriveTimeout - gatherSlack |
||||
if f.light { |
||||
timeout = 0 |
||||
} |
||||
if time.Since(announces[0].time) > timeout { |
||||
// Pick a random peer to retrieve from, reset all others
|
||||
announce := announces[rand.Intn(len(announces))] |
||||
f.forgetHash(hash) |
||||
|
||||
// If the block still didn't arrive, queue for fetching
|
||||
if (f.light && f.getHeader(hash) == nil) || (!f.light && f.getBlock(hash) == nil) { |
||||
request[announce.origin] = append(request[announce.origin], hash) |
||||
f.fetching[hash] = announce |
||||
} |
||||
} |
||||
} |
||||
// Send out all block header requests
|
||||
for peer, hashes := range request { |
||||
log.Trace("Fetching scheduled headers", "peer", peer, "list", hashes) |
||||
|
||||
// Create a closure of the fetch and schedule in on a new thread
|
||||
fetchHeader, hashes := f.fetching[hashes[0]].fetchHeader, hashes |
||||
go func(peer string) { |
||||
if f.fetchingHook != nil { |
||||
f.fetchingHook(hashes) |
||||
} |
||||
for _, hash := range hashes { |
||||
headerFetchMeter.Mark(1) |
||||
go func(hash common.Hash) { |
||||
resCh := make(chan *eth.Response) |
||||
|
||||
req, err := fetchHeader(hash, resCh) |
||||
if err != nil { |
||||
return // Legacy code, yolo
|
||||
} |
||||
defer req.Close() |
||||
|
||||
timeout := time.NewTimer(2 * fetchTimeout) // 2x leeway before dropping the peer
|
||||
defer timeout.Stop() |
||||
|
||||
select { |
||||
case res := <-resCh: |
||||
res.Done <- nil |
||||
f.FilterHeaders(peer, *res.Res.(*eth.BlockHeadersRequest), time.Now()) |
||||
|
||||
case <-timeout.C: |
||||
// The peer didn't respond in time. The request
|
||||
// was already rescheduled at this point, we were
|
||||
// waiting for a catchup. With an unresponsive
|
||||
// peer however, it's a protocol violation.
|
||||
f.dropPeer(peer) |
||||
} |
||||
}(hash) |
||||
} |
||||
}(peer) |
||||
} |
||||
// Schedule the next fetch if blocks are still pending
|
||||
f.rescheduleFetch(fetchTimer) |
||||
|
||||
case <-completeTimer.C: |
||||
// At least one header's timer ran out, retrieve everything
|
||||
request := make(map[string][]common.Hash) |
||||
|
||||
for hash, announces := range f.fetched { |
||||
// Pick a random peer to retrieve from, reset all others
|
||||
announce := announces[rand.Intn(len(announces))] |
||||
f.forgetHash(hash) |
||||
|
||||
// If the block still didn't arrive, queue for completion
|
||||
if f.getBlock(hash) == nil { |
||||
request[announce.origin] = append(request[announce.origin], hash) |
||||
f.completing[hash] = announce |
||||
} |
||||
} |
||||
// Send out all block body requests
|
||||
for peer, hashes := range request { |
||||
log.Trace("Fetching scheduled bodies", "peer", peer, "list", hashes) |
||||
|
||||
// Create a closure of the fetch and schedule in on a new thread
|
||||
if f.completingHook != nil { |
||||
f.completingHook(hashes) |
||||
} |
||||
fetchBodies := f.completing[hashes[0]].fetchBodies |
||||
bodyFetchMeter.Mark(int64(len(hashes))) |
||||
|
||||
go func(peer string, hashes []common.Hash) { |
||||
resCh := make(chan *eth.Response) |
||||
|
||||
req, err := fetchBodies(hashes, resCh) |
||||
if err != nil { |
||||
return // Legacy code, yolo
|
||||
} |
||||
defer req.Close() |
||||
|
||||
timeout := time.NewTimer(2 * fetchTimeout) // 2x leeway before dropping the peer
|
||||
defer timeout.Stop() |
||||
|
||||
select { |
||||
case res := <-resCh: |
||||
res.Done <- nil |
||||
// Ignoring withdrawals here, since the block fetcher is not used post-merge.
|
||||
txs, uncles, _ := res.Res.(*eth.BlockBodiesResponse).Unpack() |
||||
f.FilterBodies(peer, txs, uncles, time.Now()) |
||||
|
||||
case <-timeout.C: |
||||
// The peer didn't respond in time. The request
|
||||
// was already rescheduled at this point, we were
|
||||
// waiting for a catchup. With an unresponsive
|
||||
// peer however, it's a protocol violation.
|
||||
f.dropPeer(peer) |
||||
} |
||||
}(peer, hashes) |
||||
} |
||||
// Schedule the next fetch if blocks are still pending
|
||||
f.rescheduleComplete(completeTimer) |
||||
|
||||
case filter := <-f.headerFilter: |
||||
// Headers arrived from a remote peer. Extract those that were explicitly
|
||||
// requested by the fetcher, and return everything else so it's delivered
|
||||
// to other parts of the system.
|
||||
var task *headerFilterTask |
||||
select { |
||||
case task = <-filter: |
||||
case <-f.quit: |
||||
return |
||||
} |
||||
headerFilterInMeter.Mark(int64(len(task.headers))) |
||||
|
||||
// Split the batch of headers into unknown ones (to return to the caller),
|
||||
// known incomplete ones (requiring body retrievals) and completed blocks.
|
||||
unknown, incomplete, complete, lightHeaders := []*types.Header{}, []*blockAnnounce{}, []*types.Block{}, []*blockAnnounce{} |
||||
for _, header := range task.headers { |
||||
hash := header.Hash() |
||||
|
||||
// Filter fetcher-requested headers from other synchronisation algorithms
|
||||
if announce := f.fetching[hash]; announce != nil && announce.origin == task.peer && f.fetched[hash] == nil && f.completing[hash] == nil && f.queued[hash] == nil { |
||||
// If the delivered header does not match the promised number, drop the announcer
|
||||
if header.Number.Uint64() != announce.number { |
||||
log.Trace("Invalid block number fetched", "peer", announce.origin, "hash", header.Hash(), "announced", announce.number, "provided", header.Number) |
||||
f.dropPeer(announce.origin) |
||||
f.forgetHash(hash) |
||||
continue |
||||
} |
||||
// Collect all headers only if we are running in light
|
||||
// mode and the headers are not imported by other means.
|
||||
if f.light { |
||||
if f.getHeader(hash) == nil { |
||||
announce.header = header |
||||
lightHeaders = append(lightHeaders, announce) |
||||
} |
||||
f.forgetHash(hash) |
||||
continue |
||||
} |
||||
// Only keep if not imported by other means
|
||||
if f.getBlock(hash) == nil { |
||||
announce.header = header |
||||
announce.time = task.time |
||||
|
||||
// If the block is empty (header only), short circuit into the final import queue
|
||||
if header.TxHash == types.EmptyTxsHash && header.UncleHash == types.EmptyUncleHash { |
||||
log.Trace("Block empty, skipping body retrieval", "peer", announce.origin, "number", header.Number, "hash", header.Hash()) |
||||
|
||||
block := types.NewBlockWithHeader(header) |
||||
block.ReceivedAt = task.time |
||||
|
||||
complete = append(complete, block) |
||||
f.completing[hash] = announce |
||||
continue |
||||
} |
||||
// Otherwise add to the list of blocks needing completion
|
||||
incomplete = append(incomplete, announce) |
||||
} else { |
||||
log.Trace("Block already imported, discarding header", "peer", announce.origin, "number", header.Number, "hash", header.Hash()) |
||||
f.forgetHash(hash) |
||||
} |
||||
} else { |
||||
// BlockFetcher doesn't know about it, add to the return list
|
||||
unknown = append(unknown, header) |
||||
} |
||||
} |
||||
headerFilterOutMeter.Mark(int64(len(unknown))) |
||||
select { |
||||
case filter <- &headerFilterTask{headers: unknown, time: task.time}: |
||||
case <-f.quit: |
||||
return |
||||
} |
||||
// Schedule the retrieved headers for body completion
|
||||
for _, announce := range incomplete { |
||||
hash := announce.header.Hash() |
||||
if _, ok := f.completing[hash]; ok { |
||||
continue |
||||
} |
||||
f.fetched[hash] = append(f.fetched[hash], announce) |
||||
if len(f.fetched) == 1 { |
||||
f.rescheduleComplete(completeTimer) |
||||
} |
||||
} |
||||
// Schedule the header for light fetcher import
|
||||
for _, announce := range lightHeaders { |
||||
f.enqueue(announce.origin, announce.header, nil) |
||||
} |
||||
// Schedule the header-only blocks for import
|
||||
for _, block := range complete { |
||||
if announce := f.completing[block.Hash()]; announce != nil { |
||||
f.enqueue(announce.origin, nil, block) |
||||
} |
||||
} |
||||
|
||||
case filter := <-f.bodyFilter: |
||||
// Block bodies arrived, extract any explicitly requested blocks, return the rest
|
||||
var task *bodyFilterTask |
||||
select { |
||||
case task = <-filter: |
||||
case <-f.quit: |
||||
return |
||||
} |
||||
bodyFilterInMeter.Mark(int64(len(task.transactions))) |
||||
blocks := []*types.Block{} |
||||
// abort early if there's nothing explicitly requested
|
||||
if len(f.completing) > 0 { |
||||
for i := 0; i < len(task.transactions) && i < len(task.uncles); i++ { |
||||
// Match up a body to any possible completion request
|
||||
var ( |
||||
matched = false |
||||
uncleHash common.Hash // calculated lazily and reused
|
||||
txnHash common.Hash // calculated lazily and reused
|
||||
) |
||||
for hash, announce := range f.completing { |
||||
if f.queued[hash] != nil || announce.origin != task.peer { |
||||
continue |
||||
} |
||||
if uncleHash == (common.Hash{}) { |
||||
uncleHash = types.CalcUncleHash(task.uncles[i]) |
||||
} |
||||
if uncleHash != announce.header.UncleHash { |
||||
continue |
||||
} |
||||
if txnHash == (common.Hash{}) { |
||||
txnHash = types.DeriveSha(types.Transactions(task.transactions[i]), trie.NewStackTrie(nil)) |
||||
} |
||||
if txnHash != announce.header.TxHash { |
||||
continue |
||||
} |
||||
// Mark the body matched, reassemble if still unknown
|
||||
matched = true |
||||
if f.getBlock(hash) == nil { |
||||
block := types.NewBlockWithHeader(announce.header).WithBody(task.transactions[i], task.uncles[i]) |
||||
block.ReceivedAt = task.time |
||||
blocks = append(blocks, block) |
||||
} else { |
||||
f.forgetHash(hash) |
||||
} |
||||
} |
||||
if matched { |
||||
task.transactions = append(task.transactions[:i], task.transactions[i+1:]...) |
||||
task.uncles = append(task.uncles[:i], task.uncles[i+1:]...) |
||||
i-- |
||||
continue |
||||
} |
||||
} |
||||
} |
||||
bodyFilterOutMeter.Mark(int64(len(task.transactions))) |
||||
select { |
||||
case filter <- task: |
||||
case <-f.quit: |
||||
return |
||||
} |
||||
// Schedule the retrieved blocks for ordered import
|
||||
for _, block := range blocks { |
||||
if announce := f.completing[block.Hash()]; announce != nil { |
||||
f.enqueue(announce.origin, nil, block) |
||||
} |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
// rescheduleFetch resets the specified fetch timer to the next blockAnnounce timeout.
|
||||
func (f *BlockFetcher) rescheduleFetch(fetch *time.Timer) { |
||||
// Short circuit if no blocks are announced
|
||||
if len(f.announced) == 0 { |
||||
return |
||||
} |
||||
// Schedule announcement retrieval quickly for light mode
|
||||
// since server won't send any headers to client.
|
||||
if f.light { |
||||
fetch.Reset(lightTimeout) |
||||
return |
||||
} |
||||
// Otherwise find the earliest expiring announcement
|
||||
earliest := time.Now() |
||||
for _, announces := range f.announced { |
||||
if earliest.After(announces[0].time) { |
||||
earliest = announces[0].time |
||||
} |
||||
} |
||||
fetch.Reset(arriveTimeout - time.Since(earliest)) |
||||
} |
||||
|
||||
// rescheduleComplete resets the specified completion timer to the next fetch timeout.
|
||||
func (f *BlockFetcher) rescheduleComplete(complete *time.Timer) { |
||||
// Short circuit if no headers are fetched
|
||||
if len(f.fetched) == 0 { |
||||
return |
||||
} |
||||
// Otherwise find the earliest expiring announcement
|
||||
earliest := time.Now() |
||||
for _, announces := range f.fetched { |
||||
if earliest.After(announces[0].time) { |
||||
earliest = announces[0].time |
||||
} |
||||
} |
||||
complete.Reset(gatherSlack - time.Since(earliest)) |
||||
} |
||||
|
||||
// enqueue schedules a new header or block import operation, if the component
|
||||
// to be imported has not yet been seen.
|
||||
func (f *BlockFetcher) enqueue(peer string, header *types.Header, block *types.Block) { |
||||
var ( |
||||
hash common.Hash |
||||
number uint64 |
||||
) |
||||
if header != nil { |
||||
hash, number = header.Hash(), header.Number.Uint64() |
||||
} else { |
||||
hash, number = block.Hash(), block.NumberU64() |
||||
} |
||||
// Ensure the peer isn't DOSing us
|
||||
count := f.queues[peer] + 1 |
||||
if count > blockLimit { |
||||
log.Debug("Discarded delivered header or block, exceeded allowance", "peer", peer, "number", number, "hash", hash, "limit", blockLimit) |
||||
blockBroadcastDOSMeter.Mark(1) |
||||
f.forgetHash(hash) |
||||
return |
||||
} |
||||
// Discard any past or too distant blocks
|
||||
if dist := int64(number) - int64(f.chainHeight()); dist < -maxUncleDist || dist > maxQueueDist { |
||||
log.Debug("Discarded delivered header or block, too far away", "peer", peer, "number", number, "hash", hash, "distance", dist) |
||||
blockBroadcastDropMeter.Mark(1) |
||||
f.forgetHash(hash) |
||||
return |
||||
} |
||||
// Schedule the block for future importing
|
||||
if _, ok := f.queued[hash]; !ok { |
||||
op := &blockOrHeaderInject{origin: peer} |
||||
if header != nil { |
||||
op.header = header |
||||
} else { |
||||
op.block = block |
||||
} |
||||
f.queues[peer] = count |
||||
f.queued[hash] = op |
||||
f.queue.Push(op, -int64(number)) |
||||
if f.queueChangeHook != nil { |
||||
f.queueChangeHook(hash, true) |
||||
} |
||||
log.Debug("Queued delivered header or block", "peer", peer, "number", number, "hash", hash, "queued", f.queue.Size()) |
||||
} |
||||
} |
||||
|
||||
// importHeaders spawns a new goroutine to run a header insertion into the chain.
|
||||
// If the header's number is at the same height as the current import phase, it
|
||||
// updates the phase states accordingly.
|
||||
func (f *BlockFetcher) importHeaders(peer string, header *types.Header) { |
||||
hash := header.Hash() |
||||
log.Debug("Importing propagated header", "peer", peer, "number", header.Number, "hash", hash) |
||||
|
||||
go func() { |
||||
defer func() { f.done <- hash }() |
||||
// If the parent's unknown, abort insertion
|
||||
parent := f.getHeader(header.ParentHash) |
||||
if parent == nil { |
||||
log.Debug("Unknown parent of propagated header", "peer", peer, "number", header.Number, "hash", hash, "parent", header.ParentHash) |
||||
return |
||||
} |
||||
// Validate the header and if something went wrong, drop the peer
|
||||
if err := f.verifyHeader(header); err != nil && err != consensus.ErrFutureBlock { |
||||
log.Debug("Propagated header verification failed", "peer", peer, "number", header.Number, "hash", hash, "err", err) |
||||
f.dropPeer(peer) |
||||
return |
||||
} |
||||
// Run the actual import and log any issues
|
||||
if _, err := f.insertHeaders([]*types.Header{header}); err != nil { |
||||
log.Debug("Propagated header import failed", "peer", peer, "number", header.Number, "hash", hash, "err", err) |
||||
return |
||||
} |
||||
// Invoke the testing hook if needed
|
||||
if f.importedHook != nil { |
||||
f.importedHook(header, nil) |
||||
} |
||||
}() |
||||
} |
||||
|
||||
// importBlocks spawns a new goroutine to run a block insertion into the chain. If the
|
||||
// block's number is at the same height as the current import phase, it updates
|
||||
// the phase states accordingly.
|
||||
func (f *BlockFetcher) importBlocks(peer string, block *types.Block) { |
||||
hash := block.Hash() |
||||
|
||||
// Run the import on a new thread
|
||||
log.Debug("Importing propagated block", "peer", peer, "number", block.Number(), "hash", hash) |
||||
go func() { |
||||
defer func() { f.done <- hash }() |
||||
|
||||
// If the parent's unknown, abort insertion
|
||||
parent := f.getBlock(block.ParentHash()) |
||||
if parent == nil { |
||||
log.Debug("Unknown parent of propagated block", "peer", peer, "number", block.Number(), "hash", hash, "parent", block.ParentHash()) |
||||
return |
||||
} |
||||
// Quickly validate the header and propagate the block if it passes
|
||||
switch err := f.verifyHeader(block.Header()); err { |
||||
case nil: |
||||
// All ok, quickly propagate to our peers
|
||||
blockBroadcastOutTimer.UpdateSince(block.ReceivedAt) |
||||
go f.broadcastBlock(block, true) |
||||
|
||||
case consensus.ErrFutureBlock: |
||||
// Weird future block, don't fail, but neither propagate
|
||||
|
||||
default: |
||||
// Something went very wrong, drop the peer
|
||||
log.Debug("Propagated block verification failed", "peer", peer, "number", block.Number(), "hash", hash, "err", err) |
||||
f.dropPeer(peer) |
||||
return |
||||
} |
||||
// Run the actual import and log any issues
|
||||
if _, err := f.insertChain(types.Blocks{block}); err != nil { |
||||
log.Debug("Propagated block import failed", "peer", peer, "number", block.Number(), "hash", hash, "err", err) |
||||
return |
||||
} |
||||
// If import succeeded, broadcast the block
|
||||
blockAnnounceOutTimer.UpdateSince(block.ReceivedAt) |
||||
go f.broadcastBlock(block, false) |
||||
|
||||
// Invoke the testing hook if needed
|
||||
if f.importedHook != nil { |
||||
f.importedHook(nil, block) |
||||
} |
||||
}() |
||||
} |
||||
|
||||
// forgetHash removes all traces of a block announcement from the fetcher's
|
||||
// internal state.
|
||||
func (f *BlockFetcher) forgetHash(hash common.Hash) { |
||||
// Remove all pending announces and decrement DOS counters
|
||||
if announceMap, ok := f.announced[hash]; ok { |
||||
for _, announce := range announceMap { |
||||
f.announces[announce.origin]-- |
||||
if f.announces[announce.origin] <= 0 { |
||||
delete(f.announces, announce.origin) |
||||
} |
||||
} |
||||
delete(f.announced, hash) |
||||
if f.announceChangeHook != nil { |
||||
f.announceChangeHook(hash, false) |
||||
} |
||||
} |
||||
// Remove any pending fetches and decrement the DOS counters
|
||||
if announce := f.fetching[hash]; announce != nil { |
||||
f.announces[announce.origin]-- |
||||
if f.announces[announce.origin] <= 0 { |
||||
delete(f.announces, announce.origin) |
||||
} |
||||
delete(f.fetching, hash) |
||||
} |
||||
|
||||
// Remove any pending completion requests and decrement the DOS counters
|
||||
for _, announce := range f.fetched[hash] { |
||||
f.announces[announce.origin]-- |
||||
if f.announces[announce.origin] <= 0 { |
||||
delete(f.announces, announce.origin) |
||||
} |
||||
} |
||||
delete(f.fetched, hash) |
||||
|
||||
// Remove any pending completions and decrement the DOS counters
|
||||
if announce := f.completing[hash]; announce != nil { |
||||
f.announces[announce.origin]-- |
||||
if f.announces[announce.origin] <= 0 { |
||||
delete(f.announces, announce.origin) |
||||
} |
||||
delete(f.completing, hash) |
||||
} |
||||
} |
||||
|
||||
// forgetBlock removes all traces of a queued block from the fetcher's internal
|
||||
// state.
|
||||
func (f *BlockFetcher) forgetBlock(hash common.Hash) { |
||||
if insert := f.queued[hash]; insert != nil { |
||||
f.queues[insert.origin]-- |
||||
if f.queues[insert.origin] == 0 { |
||||
delete(f.queues, insert.origin) |
||||
} |
||||
delete(f.queued, hash) |
||||
} |
||||
} |
||||
@ -1,949 +0,0 @@ |
||||
// Copyright 2015 The go-ethereum Authors
|
||||
// This file is part of the go-ethereum library.
|
||||
//
|
||||
// The go-ethereum library is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// The go-ethereum library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
package fetcher |
||||
|
||||
import ( |
||||
"errors" |
||||
"math/big" |
||||
"sync" |
||||
"sync/atomic" |
||||
"testing" |
||||
"time" |
||||
|
||||
"github.com/ethereum/go-ethereum/common" |
||||
"github.com/ethereum/go-ethereum/consensus/ethash" |
||||
"github.com/ethereum/go-ethereum/core" |
||||
"github.com/ethereum/go-ethereum/core/rawdb" |
||||
"github.com/ethereum/go-ethereum/core/types" |
||||
"github.com/ethereum/go-ethereum/crypto" |
||||
"github.com/ethereum/go-ethereum/eth/protocols/eth" |
||||
"github.com/ethereum/go-ethereum/params" |
||||
"github.com/ethereum/go-ethereum/trie" |
||||
"github.com/ethereum/go-ethereum/triedb" |
||||
) |
||||
|
||||
var ( |
||||
testdb = rawdb.NewMemoryDatabase() |
||||
testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") |
||||
testAddress = crypto.PubkeyToAddress(testKey.PublicKey) |
||||
gspec = &core.Genesis{ |
||||
Config: params.TestChainConfig, |
||||
Alloc: types.GenesisAlloc{testAddress: {Balance: big.NewInt(1000000000000000)}}, |
||||
BaseFee: big.NewInt(params.InitialBaseFee), |
||||
} |
||||
genesis = gspec.MustCommit(testdb, triedb.NewDatabase(testdb, triedb.HashDefaults)) |
||||
unknownBlock = types.NewBlock(&types.Header{Root: types.EmptyRootHash, GasLimit: params.GenesisGasLimit, BaseFee: big.NewInt(params.InitialBaseFee)}, nil, nil, nil, trie.NewStackTrie(nil)) |
||||
) |
||||
|
||||
// makeChain creates a chain of n blocks starting at and including parent.
|
||||
// the returned hash chain is ordered head->parent. In addition, every 3rd block
|
||||
// contains a transaction and every 5th an uncle to allow testing correct block
|
||||
// reassembly.
|
||||
func makeChain(n int, seed byte, parent *types.Block) ([]common.Hash, map[common.Hash]*types.Block) { |
||||
blocks, _ := core.GenerateChain(gspec.Config, parent, ethash.NewFaker(), testdb, n, func(i int, block *core.BlockGen) { |
||||
block.SetCoinbase(common.Address{seed}) |
||||
|
||||
// If the block number is multiple of 3, send a bonus transaction to the miner
|
||||
if parent == genesis && i%3 == 0 { |
||||
signer := types.MakeSigner(params.TestChainConfig, block.Number(), block.Timestamp()) |
||||
tx, err := types.SignTx(types.NewTransaction(block.TxNonce(testAddress), common.Address{seed}, big.NewInt(1000), params.TxGas, block.BaseFee(), nil), signer, testKey) |
||||
if err != nil { |
||||
panic(err) |
||||
} |
||||
block.AddTx(tx) |
||||
} |
||||
// If the block number is a multiple of 5, add a bonus uncle to the block
|
||||
if i > 0 && i%5 == 0 { |
||||
block.AddUncle(&types.Header{ParentHash: block.PrevBlock(i - 2).Hash(), Number: big.NewInt(int64(i - 1))}) |
||||
} |
||||
}) |
||||
hashes := make([]common.Hash, n+1) |
||||
hashes[len(hashes)-1] = parent.Hash() |
||||
blockm := make(map[common.Hash]*types.Block, n+1) |
||||
blockm[parent.Hash()] = parent |
||||
for i, b := range blocks { |
||||
hashes[len(hashes)-i-2] = b.Hash() |
||||
blockm[b.Hash()] = b |
||||
} |
||||
return hashes, blockm |
||||
} |
||||
|
||||
// fetcherTester is a test simulator for mocking out local block chain.
|
||||
type fetcherTester struct { |
||||
fetcher *BlockFetcher |
||||
|
||||
hashes []common.Hash // Hash chain belonging to the tester
|
||||
headers map[common.Hash]*types.Header // Headers belonging to the tester
|
||||
blocks map[common.Hash]*types.Block // Blocks belonging to the tester
|
||||
drops map[string]bool // Map of peers dropped by the fetcher
|
||||
|
||||
lock sync.RWMutex |
||||
} |
||||
|
||||
// newTester creates a new fetcher test mocker.
|
||||
func newTester(light bool) *fetcherTester { |
||||
tester := &fetcherTester{ |
||||
hashes: []common.Hash{genesis.Hash()}, |
||||
headers: map[common.Hash]*types.Header{genesis.Hash(): genesis.Header()}, |
||||
blocks: map[common.Hash]*types.Block{genesis.Hash(): genesis}, |
||||
drops: make(map[string]bool), |
||||
} |
||||
tester.fetcher = NewBlockFetcher(light, tester.getHeader, tester.getBlock, tester.verifyHeader, tester.broadcastBlock, tester.chainHeight, tester.insertHeaders, tester.insertChain, tester.dropPeer) |
||||
tester.fetcher.Start() |
||||
|
||||
return tester |
||||
} |
||||
|
||||
// getHeader retrieves a header from the tester's block chain.
|
||||
func (f *fetcherTester) getHeader(hash common.Hash) *types.Header { |
||||
f.lock.RLock() |
||||
defer f.lock.RUnlock() |
||||
|
||||
return f.headers[hash] |
||||
} |
||||
|
||||
// getBlock retrieves a block from the tester's block chain.
|
||||
func (f *fetcherTester) getBlock(hash common.Hash) *types.Block { |
||||
f.lock.RLock() |
||||
defer f.lock.RUnlock() |
||||
|
||||
return f.blocks[hash] |
||||
} |
||||
|
||||
// verifyHeader is a nop placeholder for the block header verification.
|
||||
func (f *fetcherTester) verifyHeader(header *types.Header) error { |
||||
return nil |
||||
} |
||||
|
||||
// broadcastBlock is a nop placeholder for the block broadcasting.
|
||||
func (f *fetcherTester) broadcastBlock(block *types.Block, propagate bool) { |
||||
} |
||||
|
||||
// chainHeight retrieves the current height (block number) of the chain.
|
||||
func (f *fetcherTester) chainHeight() uint64 { |
||||
f.lock.RLock() |
||||
defer f.lock.RUnlock() |
||||
|
||||
if f.fetcher.light { |
||||
return f.headers[f.hashes[len(f.hashes)-1]].Number.Uint64() |
||||
} |
||||
return f.blocks[f.hashes[len(f.hashes)-1]].NumberU64() |
||||
} |
||||
|
||||
// insertChain injects a new headers into the simulated chain.
|
||||
func (f *fetcherTester) insertHeaders(headers []*types.Header) (int, error) { |
||||
f.lock.Lock() |
||||
defer f.lock.Unlock() |
||||
|
||||
for i, header := range headers { |
||||
// Make sure the parent in known
|
||||
if _, ok := f.headers[header.ParentHash]; !ok { |
||||
return i, errors.New("unknown parent") |
||||
} |
||||
// Discard any new blocks if the same height already exists
|
||||
if header.Number.Uint64() <= f.headers[f.hashes[len(f.hashes)-1]].Number.Uint64() { |
||||
return i, nil |
||||
} |
||||
// Otherwise build our current chain
|
||||
f.hashes = append(f.hashes, header.Hash()) |
||||
f.headers[header.Hash()] = header |
||||
} |
||||
return 0, nil |
||||
} |
||||
|
||||
// insertChain injects a new blocks into the simulated chain.
|
||||
func (f *fetcherTester) insertChain(blocks types.Blocks) (int, error) { |
||||
f.lock.Lock() |
||||
defer f.lock.Unlock() |
||||
|
||||
for i, block := range blocks { |
||||
// Make sure the parent in known
|
||||
if _, ok := f.blocks[block.ParentHash()]; !ok { |
||||
return i, errors.New("unknown parent") |
||||
} |
||||
// Discard any new blocks if the same height already exists
|
||||
if block.NumberU64() <= f.blocks[f.hashes[len(f.hashes)-1]].NumberU64() { |
||||
return i, nil |
||||
} |
||||
// Otherwise build our current chain
|
||||
f.hashes = append(f.hashes, block.Hash()) |
||||
f.blocks[block.Hash()] = block |
||||
} |
||||
return 0, nil |
||||
} |
||||
|
||||
// dropPeer is an emulator for the peer removal, simply accumulating the various
|
||||
// peers dropped by the fetcher.
|
||||
func (f *fetcherTester) dropPeer(peer string) { |
||||
f.lock.Lock() |
||||
defer f.lock.Unlock() |
||||
|
||||
f.drops[peer] = true |
||||
} |
||||
|
||||
// makeHeaderFetcher retrieves a block header fetcher associated with a simulated peer.
|
||||
func (f *fetcherTester) makeHeaderFetcher(peer string, blocks map[common.Hash]*types.Block, drift time.Duration) headerRequesterFn { |
||||
closure := make(map[common.Hash]*types.Block) |
||||
for hash, block := range blocks { |
||||
closure[hash] = block |
||||
} |
||||
// Create a function that return a header from the closure
|
||||
return func(hash common.Hash, sink chan *eth.Response) (*eth.Request, error) { |
||||
// Gather the blocks to return
|
||||
headers := make([]*types.Header, 0, 1) |
||||
if block, ok := closure[hash]; ok { |
||||
headers = append(headers, block.Header()) |
||||
} |
||||
// Return on a new thread
|
||||
req := ð.Request{ |
||||
Peer: peer, |
||||
} |
||||
res := ð.Response{ |
||||
Req: req, |
||||
Res: (*eth.BlockHeadersRequest)(&headers), |
||||
Time: drift, |
||||
Done: make(chan error, 1), // Ignore the returned status
|
||||
} |
||||
go func() { |
||||
sink <- res |
||||
}() |
||||
return req, nil |
||||
} |
||||
} |
||||
|
||||
// makeBodyFetcher retrieves a block body fetcher associated with a simulated peer.
|
||||
func (f *fetcherTester) makeBodyFetcher(peer string, blocks map[common.Hash]*types.Block, drift time.Duration) bodyRequesterFn { |
||||
closure := make(map[common.Hash]*types.Block) |
||||
for hash, block := range blocks { |
||||
closure[hash] = block |
||||
} |
||||
// Create a function that returns blocks from the closure
|
||||
return func(hashes []common.Hash, sink chan *eth.Response) (*eth.Request, error) { |
||||
// Gather the block bodies to return
|
||||
transactions := make([][]*types.Transaction, 0, len(hashes)) |
||||
uncles := make([][]*types.Header, 0, len(hashes)) |
||||
|
||||
for _, hash := range hashes { |
||||
if block, ok := closure[hash]; ok { |
||||
transactions = append(transactions, block.Transactions()) |
||||
uncles = append(uncles, block.Uncles()) |
||||
} |
||||
} |
||||
// Return on a new thread
|
||||
bodies := make([]*eth.BlockBody, len(transactions)) |
||||
for i, txs := range transactions { |
||||
bodies[i] = ð.BlockBody{ |
||||
Transactions: txs, |
||||
Uncles: uncles[i], |
||||
} |
||||
} |
||||
req := ð.Request{ |
||||
Peer: peer, |
||||
} |
||||
res := ð.Response{ |
||||
Req: req, |
||||
Res: (*eth.BlockBodiesResponse)(&bodies), |
||||
Time: drift, |
||||
Done: make(chan error, 1), // Ignore the returned status
|
||||
} |
||||
go func() { |
||||
sink <- res |
||||
}() |
||||
return req, nil |
||||
} |
||||
} |
||||
|
||||
// verifyFetchingEvent verifies that one single event arrive on a fetching channel.
|
||||
func verifyFetchingEvent(t *testing.T, fetching chan []common.Hash, arrive bool) { |
||||
t.Helper() |
||||
|
||||
if arrive { |
||||
select { |
||||
case <-fetching: |
||||
case <-time.After(time.Second): |
||||
t.Fatalf("fetching timeout") |
||||
} |
||||
} else { |
||||
select { |
||||
case <-fetching: |
||||
t.Fatalf("fetching invoked") |
||||
case <-time.After(10 * time.Millisecond): |
||||
} |
||||
} |
||||
} |
||||
|
||||
// verifyCompletingEvent verifies that one single event arrive on an completing channel.
|
||||
func verifyCompletingEvent(t *testing.T, completing chan []common.Hash, arrive bool) { |
||||
t.Helper() |
||||
|
||||
if arrive { |
||||
select { |
||||
case <-completing: |
||||
case <-time.After(time.Second): |
||||
t.Fatalf("completing timeout") |
||||
} |
||||
} else { |
||||
select { |
||||
case <-completing: |
||||
t.Fatalf("completing invoked") |
||||
case <-time.After(10 * time.Millisecond): |
||||
} |
||||
} |
||||
} |
||||
|
||||
// verifyImportEvent verifies that one single event arrive on an import channel.
|
||||
func verifyImportEvent(t *testing.T, imported chan interface{}, arrive bool) { |
||||
t.Helper() |
||||
|
||||
if arrive { |
||||
select { |
||||
case <-imported: |
||||
case <-time.After(time.Second): |
||||
t.Fatalf("import timeout") |
||||
} |
||||
} else { |
||||
select { |
||||
case <-imported: |
||||
t.Fatalf("import invoked") |
||||
case <-time.After(20 * time.Millisecond): |
||||
} |
||||
} |
||||
} |
||||
|
||||
// verifyImportCount verifies that exactly count number of events arrive on an
|
||||
// import hook channel.
|
||||
func verifyImportCount(t *testing.T, imported chan interface{}, count int) { |
||||
t.Helper() |
||||
|
||||
for i := 0; i < count; i++ { |
||||
select { |
||||
case <-imported: |
||||
case <-time.After(time.Second): |
||||
t.Fatalf("block %d: import timeout", i+1) |
||||
} |
||||
} |
||||
verifyImportDone(t, imported) |
||||
} |
||||
|
||||
// verifyImportDone verifies that no more events are arriving on an import channel.
|
||||
func verifyImportDone(t *testing.T, imported chan interface{}) { |
||||
t.Helper() |
||||
|
||||
select { |
||||
case <-imported: |
||||
t.Fatalf("extra block imported") |
||||
case <-time.After(50 * time.Millisecond): |
||||
} |
||||
} |
||||
|
||||
// verifyChainHeight verifies the chain height is as expected.
|
||||
func verifyChainHeight(t *testing.T, fetcher *fetcherTester, height uint64) { |
||||
t.Helper() |
||||
|
||||
if fetcher.chainHeight() != height { |
||||
t.Fatalf("chain height mismatch, got %d, want %d", fetcher.chainHeight(), height) |
||||
} |
||||
} |
||||
|
||||
// Tests that a fetcher accepts block/header announcements and initiates retrievals
|
||||
// for them, successfully importing into the local chain.
|
||||
func TestFullSequentialAnnouncements(t *testing.T) { testSequentialAnnouncements(t, false) } |
||||
func TestLightSequentialAnnouncements(t *testing.T) { testSequentialAnnouncements(t, true) } |
||||
|
||||
func testSequentialAnnouncements(t *testing.T, light bool) { |
||||
// Create a chain of blocks to import
|
||||
targetBlocks := 4 * hashLimit |
||||
hashes, blocks := makeChain(targetBlocks, 0, genesis) |
||||
|
||||
tester := newTester(light) |
||||
defer tester.fetcher.Stop() |
||||
headerFetcher := tester.makeHeaderFetcher("valid", blocks, -gatherSlack) |
||||
bodyFetcher := tester.makeBodyFetcher("valid", blocks, 0) |
||||
|
||||
// Iteratively announce blocks until all are imported
|
||||
imported := make(chan interface{}) |
||||
tester.fetcher.importedHook = func(header *types.Header, block *types.Block) { |
||||
if light { |
||||
if header == nil { |
||||
t.Fatalf("Fetcher try to import empty header") |
||||
} |
||||
imported <- header |
||||
} else { |
||||
if block == nil { |
||||
t.Fatalf("Fetcher try to import empty block") |
||||
} |
||||
imported <- block |
||||
} |
||||
} |
||||
for i := len(hashes) - 2; i >= 0; i-- { |
||||
tester.fetcher.Notify("valid", hashes[i], uint64(len(hashes)-i-1), time.Now().Add(-arriveTimeout), headerFetcher, bodyFetcher) |
||||
verifyImportEvent(t, imported, true) |
||||
} |
||||
verifyImportDone(t, imported) |
||||
verifyChainHeight(t, tester, uint64(len(hashes)-1)) |
||||
} |
||||
|
||||
// Tests that if blocks are announced by multiple peers (or even the same buggy
|
||||
// peer), they will only get downloaded at most once.
|
||||
func TestFullConcurrentAnnouncements(t *testing.T) { testConcurrentAnnouncements(t, false) } |
||||
func TestLightConcurrentAnnouncements(t *testing.T) { testConcurrentAnnouncements(t, true) } |
||||
|
||||
func testConcurrentAnnouncements(t *testing.T, light bool) { |
||||
// Create a chain of blocks to import
|
||||
targetBlocks := 4 * hashLimit |
||||
hashes, blocks := makeChain(targetBlocks, 0, genesis) |
||||
|
||||
// Assemble a tester with a built in counter for the requests
|
||||
tester := newTester(light) |
||||
firstHeaderFetcher := tester.makeHeaderFetcher("first", blocks, -gatherSlack) |
||||
firstBodyFetcher := tester.makeBodyFetcher("first", blocks, 0) |
||||
secondHeaderFetcher := tester.makeHeaderFetcher("second", blocks, -gatherSlack) |
||||
secondBodyFetcher := tester.makeBodyFetcher("second", blocks, 0) |
||||
|
||||
var counter atomic.Uint32 |
||||
firstHeaderWrapper := func(hash common.Hash, sink chan *eth.Response) (*eth.Request, error) { |
||||
counter.Add(1) |
||||
return firstHeaderFetcher(hash, sink) |
||||
} |
||||
secondHeaderWrapper := func(hash common.Hash, sink chan *eth.Response) (*eth.Request, error) { |
||||
counter.Add(1) |
||||
return secondHeaderFetcher(hash, sink) |
||||
} |
||||
// Iteratively announce blocks until all are imported
|
||||
imported := make(chan interface{}) |
||||
tester.fetcher.importedHook = func(header *types.Header, block *types.Block) { |
||||
if light { |
||||
if header == nil { |
||||
t.Fatalf("Fetcher try to import empty header") |
||||
} |
||||
imported <- header |
||||
} else { |
||||
if block == nil { |
||||
t.Fatalf("Fetcher try to import empty block") |
||||
} |
||||
imported <- block |
||||
} |
||||
} |
||||
for i := len(hashes) - 2; i >= 0; i-- { |
||||
tester.fetcher.Notify("first", hashes[i], uint64(len(hashes)-i-1), time.Now().Add(-arriveTimeout), firstHeaderWrapper, firstBodyFetcher) |
||||
tester.fetcher.Notify("second", hashes[i], uint64(len(hashes)-i-1), time.Now().Add(-arriveTimeout+time.Millisecond), secondHeaderWrapper, secondBodyFetcher) |
||||
tester.fetcher.Notify("second", hashes[i], uint64(len(hashes)-i-1), time.Now().Add(-arriveTimeout-time.Millisecond), secondHeaderWrapper, secondBodyFetcher) |
||||
verifyImportEvent(t, imported, true) |
||||
} |
||||
verifyImportDone(t, imported) |
||||
|
||||
// Make sure no blocks were retrieved twice
|
||||
if c := int(counter.Load()); c != targetBlocks { |
||||
t.Fatalf("retrieval count mismatch: have %v, want %v", c, targetBlocks) |
||||
} |
||||
verifyChainHeight(t, tester, uint64(len(hashes)-1)) |
||||
} |
||||
|
||||
// Tests that announcements arriving while a previous is being fetched still
|
||||
// results in a valid import.
|
||||
func TestFullOverlappingAnnouncements(t *testing.T) { testOverlappingAnnouncements(t, false) } |
||||
func TestLightOverlappingAnnouncements(t *testing.T) { testOverlappingAnnouncements(t, true) } |
||||
|
||||
func testOverlappingAnnouncements(t *testing.T, light bool) { |
||||
// Create a chain of blocks to import
|
||||
targetBlocks := 4 * hashLimit |
||||
hashes, blocks := makeChain(targetBlocks, 0, genesis) |
||||
|
||||
tester := newTester(light) |
||||
headerFetcher := tester.makeHeaderFetcher("valid", blocks, -gatherSlack) |
||||
bodyFetcher := tester.makeBodyFetcher("valid", blocks, 0) |
||||
|
||||
// Iteratively announce blocks, but overlap them continuously
|
||||
overlap := 16 |
||||
imported := make(chan interface{}, len(hashes)-1) |
||||
for i := 0; i < overlap; i++ { |
||||
imported <- nil |
||||
} |
||||
tester.fetcher.importedHook = func(header *types.Header, block *types.Block) { |
||||
if light { |
||||
if header == nil { |
||||
t.Fatalf("Fetcher try to import empty header") |
||||
} |
||||
imported <- header |
||||
} else { |
||||
if block == nil { |
||||
t.Fatalf("Fetcher try to import empty block") |
||||
} |
||||
imported <- block |
||||
} |
||||
} |
||||
|
||||
for i := len(hashes) - 2; i >= 0; i-- { |
||||
tester.fetcher.Notify("valid", hashes[i], uint64(len(hashes)-i-1), time.Now().Add(-arriveTimeout), headerFetcher, bodyFetcher) |
||||
select { |
||||
case <-imported: |
||||
case <-time.After(time.Second): |
||||
t.Fatalf("block %d: import timeout", len(hashes)-i) |
||||
} |
||||
} |
||||
// Wait for all the imports to complete and check count
|
||||
verifyImportCount(t, imported, overlap) |
||||
verifyChainHeight(t, tester, uint64(len(hashes)-1)) |
||||
} |
||||
|
||||
// Tests that announces already being retrieved will not be duplicated.
|
||||
func TestFullPendingDeduplication(t *testing.T) { testPendingDeduplication(t, false) } |
||||
func TestLightPendingDeduplication(t *testing.T) { testPendingDeduplication(t, true) } |
||||
|
||||
func testPendingDeduplication(t *testing.T, light bool) { |
||||
// Create a hash and corresponding block
|
||||
hashes, blocks := makeChain(1, 0, genesis) |
||||
|
||||
// Assemble a tester with a built in counter and delayed fetcher
|
||||
tester := newTester(light) |
||||
headerFetcher := tester.makeHeaderFetcher("repeater", blocks, -gatherSlack) |
||||
bodyFetcher := tester.makeBodyFetcher("repeater", blocks, 0) |
||||
|
||||
delay := 50 * time.Millisecond |
||||
var counter atomic.Uint32 |
||||
headerWrapper := func(hash common.Hash, sink chan *eth.Response) (*eth.Request, error) { |
||||
counter.Add(1) |
||||
|
||||
// Simulate a long running fetch
|
||||
resink := make(chan *eth.Response) |
||||
req, err := headerFetcher(hash, resink) |
||||
if err == nil { |
||||
go func() { |
||||
res := <-resink |
||||
time.Sleep(delay) |
||||
sink <- res |
||||
}() |
||||
} |
||||
return req, err |
||||
} |
||||
checkNonExist := func() bool { |
||||
return tester.getBlock(hashes[0]) == nil |
||||
} |
||||
if light { |
||||
checkNonExist = func() bool { |
||||
return tester.getHeader(hashes[0]) == nil |
||||
} |
||||
} |
||||
// Announce the same block many times until it's fetched (wait for any pending ops)
|
||||
for checkNonExist() { |
||||
tester.fetcher.Notify("repeater", hashes[0], 1, time.Now().Add(-arriveTimeout), headerWrapper, bodyFetcher) |
||||
time.Sleep(time.Millisecond) |
||||
} |
||||
time.Sleep(delay) |
||||
|
||||
// Check that all blocks were imported and none fetched twice
|
||||
if c := counter.Load(); c != 1 { |
||||
t.Fatalf("retrieval count mismatch: have %v, want %v", c, 1) |
||||
} |
||||
verifyChainHeight(t, tester, 1) |
||||
} |
||||
|
||||
// Tests that announcements retrieved in a random order are cached and eventually
|
||||
// imported when all the gaps are filled in.
|
||||
func TestFullRandomArrivalImport(t *testing.T) { testRandomArrivalImport(t, false) } |
||||
func TestLightRandomArrivalImport(t *testing.T) { testRandomArrivalImport(t, true) } |
||||
|
||||
func testRandomArrivalImport(t *testing.T, light bool) { |
||||
// Create a chain of blocks to import, and choose one to delay
|
||||
targetBlocks := maxQueueDist |
||||
hashes, blocks := makeChain(targetBlocks, 0, genesis) |
||||
skip := targetBlocks / 2 |
||||
|
||||
tester := newTester(light) |
||||
headerFetcher := tester.makeHeaderFetcher("valid", blocks, -gatherSlack) |
||||
bodyFetcher := tester.makeBodyFetcher("valid", blocks, 0) |
||||
|
||||
// Iteratively announce blocks, skipping one entry
|
||||
imported := make(chan interface{}, len(hashes)-1) |
||||
tester.fetcher.importedHook = func(header *types.Header, block *types.Block) { |
||||
if light { |
||||
if header == nil { |
||||
t.Fatalf("Fetcher try to import empty header") |
||||
} |
||||
imported <- header |
||||
} else { |
||||
if block == nil { |
||||
t.Fatalf("Fetcher try to import empty block") |
||||
} |
||||
imported <- block |
||||
} |
||||
} |
||||
for i := len(hashes) - 1; i >= 0; i-- { |
||||
if i != skip { |
||||
tester.fetcher.Notify("valid", hashes[i], uint64(len(hashes)-i-1), time.Now().Add(-arriveTimeout), headerFetcher, bodyFetcher) |
||||
time.Sleep(time.Millisecond) |
||||
} |
||||
} |
||||
// Finally announce the skipped entry and check full import
|
||||
tester.fetcher.Notify("valid", hashes[skip], uint64(len(hashes)-skip-1), time.Now().Add(-arriveTimeout), headerFetcher, bodyFetcher) |
||||
verifyImportCount(t, imported, len(hashes)-1) |
||||
verifyChainHeight(t, tester, uint64(len(hashes)-1)) |
||||
} |
||||
|
||||
// Tests that direct block enqueues (due to block propagation vs. hash announce)
|
||||
// are correctly schedule, filling and import queue gaps.
|
||||
func TestQueueGapFill(t *testing.T) { |
||||
// Create a chain of blocks to import, and choose one to not announce at all
|
||||
targetBlocks := maxQueueDist |
||||
hashes, blocks := makeChain(targetBlocks, 0, genesis) |
||||
skip := targetBlocks / 2 |
||||
|
||||
tester := newTester(false) |
||||
headerFetcher := tester.makeHeaderFetcher("valid", blocks, -gatherSlack) |
||||
bodyFetcher := tester.makeBodyFetcher("valid", blocks, 0) |
||||
|
||||
// Iteratively announce blocks, skipping one entry
|
||||
imported := make(chan interface{}, len(hashes)-1) |
||||
tester.fetcher.importedHook = func(header *types.Header, block *types.Block) { imported <- block } |
||||
|
||||
for i := len(hashes) - 1; i >= 0; i-- { |
||||
if i != skip { |
||||
tester.fetcher.Notify("valid", hashes[i], uint64(len(hashes)-i-1), time.Now().Add(-arriveTimeout), headerFetcher, bodyFetcher) |
||||
time.Sleep(time.Millisecond) |
||||
} |
||||
} |
||||
// Fill the missing block directly as if propagated
|
||||
tester.fetcher.Enqueue("valid", blocks[hashes[skip]]) |
||||
verifyImportCount(t, imported, len(hashes)-1) |
||||
verifyChainHeight(t, tester, uint64(len(hashes)-1)) |
||||
} |
||||
|
||||
// Tests that blocks arriving from various sources (multiple propagations, hash
|
||||
// announces, etc) do not get scheduled for import multiple times.
|
||||
func TestImportDeduplication(t *testing.T) { |
||||
// Create two blocks to import (one for duplication, the other for stalling)
|
||||
hashes, blocks := makeChain(2, 0, genesis) |
||||
|
||||
// Create the tester and wrap the importer with a counter
|
||||
tester := newTester(false) |
||||
headerFetcher := tester.makeHeaderFetcher("valid", blocks, -gatherSlack) |
||||
bodyFetcher := tester.makeBodyFetcher("valid", blocks, 0) |
||||
|
||||
var counter atomic.Uint32 |
||||
tester.fetcher.insertChain = func(blocks types.Blocks) (int, error) { |
||||
counter.Add(uint32(len(blocks))) |
||||
return tester.insertChain(blocks) |
||||
} |
||||
// Instrument the fetching and imported events
|
||||
fetching := make(chan []common.Hash) |
||||
imported := make(chan interface{}, len(hashes)-1) |
||||
tester.fetcher.fetchingHook = func(hashes []common.Hash) { fetching <- hashes } |
||||
tester.fetcher.importedHook = func(header *types.Header, block *types.Block) { imported <- block } |
||||
|
||||
// Announce the duplicating block, wait for retrieval, and also propagate directly
|
||||
tester.fetcher.Notify("valid", hashes[0], 1, time.Now().Add(-arriveTimeout), headerFetcher, bodyFetcher) |
||||
<-fetching |
||||
|
||||
tester.fetcher.Enqueue("valid", blocks[hashes[0]]) |
||||
tester.fetcher.Enqueue("valid", blocks[hashes[0]]) |
||||
tester.fetcher.Enqueue("valid", blocks[hashes[0]]) |
||||
|
||||
// Fill the missing block directly as if propagated, and check import uniqueness
|
||||
tester.fetcher.Enqueue("valid", blocks[hashes[1]]) |
||||
verifyImportCount(t, imported, 2) |
||||
|
||||
if c := counter.Load(); c != 2 { |
||||
t.Fatalf("import invocation count mismatch: have %v, want %v", c, 2) |
||||
} |
||||
} |
||||
|
||||
// Tests that blocks with numbers much lower or higher than out current head get
|
||||
// discarded to prevent wasting resources on useless blocks from faulty peers.
|
||||
func TestDistantPropagationDiscarding(t *testing.T) { |
||||
// Create a long chain to import and define the discard boundaries
|
||||
hashes, blocks := makeChain(3*maxQueueDist, 0, genesis) |
||||
head := hashes[len(hashes)/2] |
||||
|
||||
low, high := len(hashes)/2+maxUncleDist+1, len(hashes)/2-maxQueueDist-1 |
||||
|
||||
// Create a tester and simulate a head block being the middle of the above chain
|
||||
tester := newTester(false) |
||||
|
||||
tester.lock.Lock() |
||||
tester.hashes = []common.Hash{head} |
||||
tester.blocks = map[common.Hash]*types.Block{head: blocks[head]} |
||||
tester.lock.Unlock() |
||||
|
||||
// Ensure that a block with a lower number than the threshold is discarded
|
||||
tester.fetcher.Enqueue("lower", blocks[hashes[low]]) |
||||
time.Sleep(10 * time.Millisecond) |
||||
if !tester.fetcher.queue.Empty() { |
||||
t.Fatalf("fetcher queued stale block") |
||||
} |
||||
// Ensure that a block with a higher number than the threshold is discarded
|
||||
tester.fetcher.Enqueue("higher", blocks[hashes[high]]) |
||||
time.Sleep(10 * time.Millisecond) |
||||
if !tester.fetcher.queue.Empty() { |
||||
t.Fatalf("fetcher queued future block") |
||||
} |
||||
} |
||||
|
||||
// Tests that announcements with numbers much lower or higher than out current
|
||||
// head get discarded to prevent wasting resources on useless blocks from faulty
|
||||
// peers.
|
||||
func TestFullDistantAnnouncementDiscarding(t *testing.T) { testDistantAnnouncementDiscarding(t, false) } |
||||
func TestLightDistantAnnouncementDiscarding(t *testing.T) { testDistantAnnouncementDiscarding(t, true) } |
||||
|
||||
func testDistantAnnouncementDiscarding(t *testing.T, light bool) { |
||||
// Create a long chain to import and define the discard boundaries
|
||||
hashes, blocks := makeChain(3*maxQueueDist, 0, genesis) |
||||
head := hashes[len(hashes)/2] |
||||
|
||||
low, high := len(hashes)/2+maxUncleDist+1, len(hashes)/2-maxQueueDist-1 |
||||
|
||||
// Create a tester and simulate a head block being the middle of the above chain
|
||||
tester := newTester(light) |
||||
|
||||
tester.lock.Lock() |
||||
tester.hashes = []common.Hash{head} |
||||
tester.headers = map[common.Hash]*types.Header{head: blocks[head].Header()} |
||||
tester.blocks = map[common.Hash]*types.Block{head: blocks[head]} |
||||
tester.lock.Unlock() |
||||
|
||||
headerFetcher := tester.makeHeaderFetcher("lower", blocks, -gatherSlack) |
||||
bodyFetcher := tester.makeBodyFetcher("lower", blocks, 0) |
||||
|
||||
fetching := make(chan struct{}, 2) |
||||
tester.fetcher.fetchingHook = func(hashes []common.Hash) { fetching <- struct{}{} } |
||||
|
||||
// Ensure that a block with a lower number than the threshold is discarded
|
||||
tester.fetcher.Notify("lower", hashes[low], blocks[hashes[low]].NumberU64(), time.Now().Add(-arriveTimeout), headerFetcher, bodyFetcher) |
||||
select { |
||||
case <-time.After(50 * time.Millisecond): |
||||
case <-fetching: |
||||
t.Fatalf("fetcher requested stale header") |
||||
} |
||||
// Ensure that a block with a higher number than the threshold is discarded
|
||||
tester.fetcher.Notify("higher", hashes[high], blocks[hashes[high]].NumberU64(), time.Now().Add(-arriveTimeout), headerFetcher, bodyFetcher) |
||||
select { |
||||
case <-time.After(50 * time.Millisecond): |
||||
case <-fetching: |
||||
t.Fatalf("fetcher requested future header") |
||||
} |
||||
} |
||||
|
||||
// Tests that peers announcing blocks with invalid numbers (i.e. not matching
|
||||
// the headers provided afterwards) get dropped as malicious.
|
||||
func TestFullInvalidNumberAnnouncement(t *testing.T) { testInvalidNumberAnnouncement(t, false) } |
||||
func TestLightInvalidNumberAnnouncement(t *testing.T) { testInvalidNumberAnnouncement(t, true) } |
||||
|
||||
func testInvalidNumberAnnouncement(t *testing.T, light bool) { |
||||
// Create a single block to import and check numbers against
|
||||
hashes, blocks := makeChain(1, 0, genesis) |
||||
|
||||
tester := newTester(light) |
||||
badHeaderFetcher := tester.makeHeaderFetcher("bad", blocks, -gatherSlack) |
||||
badBodyFetcher := tester.makeBodyFetcher("bad", blocks, 0) |
||||
|
||||
imported := make(chan interface{}) |
||||
announced := make(chan interface{}, 2) |
||||
tester.fetcher.importedHook = func(header *types.Header, block *types.Block) { |
||||
if light { |
||||
if header == nil { |
||||
t.Fatalf("Fetcher try to import empty header") |
||||
} |
||||
imported <- header |
||||
} else { |
||||
if block == nil { |
||||
t.Fatalf("Fetcher try to import empty block") |
||||
} |
||||
imported <- block |
||||
} |
||||
} |
||||
// Announce a block with a bad number, check for immediate drop
|
||||
tester.fetcher.announceChangeHook = func(hash common.Hash, b bool) { |
||||
announced <- nil |
||||
} |
||||
tester.fetcher.Notify("bad", hashes[0], 2, time.Now().Add(-arriveTimeout), badHeaderFetcher, badBodyFetcher) |
||||
verifyAnnounce := func() { |
||||
for i := 0; i < 2; i++ { |
||||
select { |
||||
case <-announced: |
||||
continue |
||||
case <-time.After(1 * time.Second): |
||||
t.Fatal("announce timeout") |
||||
return |
||||
} |
||||
} |
||||
} |
||||
verifyAnnounce() |
||||
verifyImportEvent(t, imported, false) |
||||
tester.lock.RLock() |
||||
dropped := tester.drops["bad"] |
||||
tester.lock.RUnlock() |
||||
|
||||
if !dropped { |
||||
t.Fatalf("peer with invalid numbered announcement not dropped") |
||||
} |
||||
goodHeaderFetcher := tester.makeHeaderFetcher("good", blocks, -gatherSlack) |
||||
goodBodyFetcher := tester.makeBodyFetcher("good", blocks, 0) |
||||
// Make sure a good announcement passes without a drop
|
||||
tester.fetcher.Notify("good", hashes[0], 1, time.Now().Add(-arriveTimeout), goodHeaderFetcher, goodBodyFetcher) |
||||
verifyAnnounce() |
||||
verifyImportEvent(t, imported, true) |
||||
|
||||
tester.lock.RLock() |
||||
dropped = tester.drops["good"] |
||||
tester.lock.RUnlock() |
||||
|
||||
if dropped { |
||||
t.Fatalf("peer with valid numbered announcement dropped") |
||||
} |
||||
verifyImportDone(t, imported) |
||||
} |
||||
|
||||
// Tests that if a block is empty (i.e. header only), no body request should be
|
||||
// made, and instead the header should be assembled into a whole block in itself.
|
||||
func TestEmptyBlockShortCircuit(t *testing.T) { |
||||
// Create a chain of blocks to import
|
||||
hashes, blocks := makeChain(32, 0, genesis) |
||||
|
||||
tester := newTester(false) |
||||
defer tester.fetcher.Stop() |
||||
headerFetcher := tester.makeHeaderFetcher("valid", blocks, -gatherSlack) |
||||
bodyFetcher := tester.makeBodyFetcher("valid", blocks, 0) |
||||
|
||||
// Add a monitoring hook for all internal events
|
||||
fetching := make(chan []common.Hash) |
||||
tester.fetcher.fetchingHook = func(hashes []common.Hash) { fetching <- hashes } |
||||
|
||||
completing := make(chan []common.Hash) |
||||
tester.fetcher.completingHook = func(hashes []common.Hash) { completing <- hashes } |
||||
|
||||
imported := make(chan interface{}) |
||||
tester.fetcher.importedHook = func(header *types.Header, block *types.Block) { |
||||
if block == nil { |
||||
t.Fatalf("Fetcher try to import empty block") |
||||
} |
||||
imported <- block |
||||
} |
||||
// Iteratively announce blocks until all are imported
|
||||
for i := len(hashes) - 2; i >= 0; i-- { |
||||
tester.fetcher.Notify("valid", hashes[i], uint64(len(hashes)-i-1), time.Now().Add(-arriveTimeout), headerFetcher, bodyFetcher) |
||||
|
||||
// All announces should fetch the header
|
||||
verifyFetchingEvent(t, fetching, true) |
||||
|
||||
// Only blocks with data contents should request bodies
|
||||
verifyCompletingEvent(t, completing, len(blocks[hashes[i]].Transactions()) > 0 || len(blocks[hashes[i]].Uncles()) > 0) |
||||
|
||||
// Irrelevant of the construct, import should succeed
|
||||
verifyImportEvent(t, imported, true) |
||||
} |
||||
verifyImportDone(t, imported) |
||||
} |
||||
|
||||
// Tests that a peer is unable to use unbounded memory with sending infinite
|
||||
// block announcements to a node, but that even in the face of such an attack,
|
||||
// the fetcher remains operational.
|
||||
func TestHashMemoryExhaustionAttack(t *testing.T) { |
||||
// Create a tester with instrumented import hooks
|
||||
tester := newTester(false) |
||||
|
||||
imported, announces := make(chan interface{}), atomic.Int32{} |
||||
tester.fetcher.importedHook = func(header *types.Header, block *types.Block) { imported <- block } |
||||
tester.fetcher.announceChangeHook = func(hash common.Hash, added bool) { |
||||
if added { |
||||
announces.Add(1) |
||||
} else { |
||||
announces.Add(-1) |
||||
} |
||||
} |
||||
// Create a valid chain and an infinite junk chain
|
||||
targetBlocks := hashLimit + 2*maxQueueDist |
||||
hashes, blocks := makeChain(targetBlocks, 0, genesis) |
||||
validHeaderFetcher := tester.makeHeaderFetcher("valid", blocks, -gatherSlack) |
||||
validBodyFetcher := tester.makeBodyFetcher("valid", blocks, 0) |
||||
|
||||
attack, _ := makeChain(targetBlocks, 0, unknownBlock) |
||||
attackerHeaderFetcher := tester.makeHeaderFetcher("attacker", nil, -gatherSlack) |
||||
attackerBodyFetcher := tester.makeBodyFetcher("attacker", nil, 0) |
||||
|
||||
// Feed the tester a huge hashset from the attacker, and a limited from the valid peer
|
||||
for i := 0; i < len(attack); i++ { |
||||
if i < maxQueueDist { |
||||
tester.fetcher.Notify("valid", hashes[len(hashes)-2-i], uint64(i+1), time.Now(), validHeaderFetcher, validBodyFetcher) |
||||
} |
||||
tester.fetcher.Notify("attacker", attack[i], 1 /* don't distance drop */, time.Now(), attackerHeaderFetcher, attackerBodyFetcher) |
||||
} |
||||
if count := announces.Load(); count != hashLimit+maxQueueDist { |
||||
t.Fatalf("queued announce count mismatch: have %d, want %d", count, hashLimit+maxQueueDist) |
||||
} |
||||
// Wait for fetches to complete
|
||||
verifyImportCount(t, imported, maxQueueDist) |
||||
|
||||
// Feed the remaining valid hashes to ensure DOS protection state remains clean
|
||||
for i := len(hashes) - maxQueueDist - 2; i >= 0; i-- { |
||||
tester.fetcher.Notify("valid", hashes[i], uint64(len(hashes)-i-1), time.Now().Add(-arriveTimeout), validHeaderFetcher, validBodyFetcher) |
||||
verifyImportEvent(t, imported, true) |
||||
} |
||||
verifyImportDone(t, imported) |
||||
} |
||||
|
||||
// Tests that blocks sent to the fetcher (either through propagation or via hash
|
||||
// announces and retrievals) don't pile up indefinitely, exhausting available
|
||||
// system memory.
|
||||
func TestBlockMemoryExhaustionAttack(t *testing.T) { |
||||
// Create a tester with instrumented import hooks
|
||||
tester := newTester(false) |
||||
|
||||
imported, enqueued := make(chan interface{}), atomic.Int32{} |
||||
tester.fetcher.importedHook = func(header *types.Header, block *types.Block) { imported <- block } |
||||
tester.fetcher.queueChangeHook = func(hash common.Hash, added bool) { |
||||
if added { |
||||
enqueued.Add(1) |
||||
} else { |
||||
enqueued.Add(-1) |
||||
} |
||||
} |
||||
// Create a valid chain and a batch of dangling (but in range) blocks
|
||||
targetBlocks := hashLimit + 2*maxQueueDist |
||||
hashes, blocks := makeChain(targetBlocks, 0, genesis) |
||||
attack := make(map[common.Hash]*types.Block) |
||||
for i := byte(0); len(attack) < blockLimit+2*maxQueueDist; i++ { |
||||
hashes, blocks := makeChain(maxQueueDist-1, i, unknownBlock) |
||||
for _, hash := range hashes[:maxQueueDist-2] { |
||||
attack[hash] = blocks[hash] |
||||
} |
||||
} |
||||
// Try to feed all the attacker blocks make sure only a limited batch is accepted
|
||||
for _, block := range attack { |
||||
tester.fetcher.Enqueue("attacker", block) |
||||
} |
||||
time.Sleep(200 * time.Millisecond) |
||||
if queued := enqueued.Load(); queued != blockLimit { |
||||
t.Fatalf("queued block count mismatch: have %d, want %d", queued, blockLimit) |
||||
} |
||||
// Queue up a batch of valid blocks, and check that a new peer is allowed to do so
|
||||
for i := 0; i < maxQueueDist-1; i++ { |
||||
tester.fetcher.Enqueue("valid", blocks[hashes[len(hashes)-3-i]]) |
||||
} |
||||
time.Sleep(100 * time.Millisecond) |
||||
if queued := enqueued.Load(); queued != blockLimit+maxQueueDist-1 { |
||||
t.Fatalf("queued block count mismatch: have %d, want %d", queued, blockLimit+maxQueueDist-1) |
||||
} |
||||
// Insert the missing piece (and sanity check the import)
|
||||
tester.fetcher.Enqueue("valid", blocks[hashes[len(hashes)-2]]) |
||||
verifyImportCount(t, imported, maxQueueDist) |
||||
|
||||
// Insert the remaining blocks in chunks to ensure clean DOS protection
|
||||
for i := maxQueueDist; i < len(hashes)-1; i++ { |
||||
tester.fetcher.Enqueue("valid", blocks[hashes[len(hashes)-2-i]]) |
||||
verifyImportEvent(t, imported, true) |
||||
} |
||||
verifyImportDone(t, imported) |
||||
} |
||||
Loading…
Reference in new issue