515 lines
14 KiB
Go
515 lines
14 KiB
Go
package eth
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"math"
|
|
"math/big"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/ethereum/go-ethereum/core/types"
|
|
"github.com/ethereum/go-ethereum/ethutil"
|
|
"github.com/ethereum/go-ethereum/event"
|
|
ethlogger "github.com/ethereum/go-ethereum/logger"
|
|
)
|
|
|
|
var poolLogger = ethlogger.NewLogger("Blockpool")
|
|
|
|
const (
|
|
blockHashesBatchSize = 256
|
|
blockBatchSize = 64
|
|
blockRequestInterval = 10 // seconds
|
|
blockRequestRepetition = 1
|
|
cacheTimeout = 3 // minutes
|
|
blockTimeout = 5 // minutes
|
|
)
|
|
|
|
type poolNode struct {
|
|
hash []byte
|
|
block *types.Block
|
|
child *poolNode
|
|
parent *poolNode
|
|
root *nodePointer
|
|
knownParent bool
|
|
suicide chan bool
|
|
peer string
|
|
source string
|
|
blockRequestRoot bool
|
|
blockRequestControl *bool
|
|
blockRequestQuit *(chan bool)
|
|
}
|
|
|
|
// the minimal interface for chain manager
|
|
type chainManager interface {
|
|
KnownBlock(hash []byte) bool
|
|
AddBlock(*types.Block) error
|
|
CheckPoW(*types.Block) bool
|
|
}
|
|
|
|
type BlockPool struct {
|
|
chainManager chainManager
|
|
eventer event.TypeMux
|
|
|
|
// pool Pool
|
|
lock sync.Mutex
|
|
pool map[string]*poolNode
|
|
|
|
peersLock sync.Mutex
|
|
peers map[string]*peerInfo
|
|
peer *peerInfo
|
|
|
|
quit chan bool
|
|
wg sync.WaitGroup
|
|
running bool
|
|
}
|
|
|
|
type peerInfo struct {
|
|
td *big.Int
|
|
currentBlock []byte
|
|
id string
|
|
requestBlockHashes func([]byte) error
|
|
requestBlocks func([][]byte) error
|
|
invalidBlock func(error)
|
|
}
|
|
|
|
type nodePointer struct {
|
|
hash []byte
|
|
}
|
|
|
|
type peerChangeEvent struct {
|
|
*peerInfo
|
|
}
|
|
|
|
func NewBlockPool(chMgr chainManager) *BlockPool {
|
|
return &BlockPool{
|
|
chainManager: chMgr,
|
|
pool: make(map[string]*poolNode),
|
|
peers: make(map[string]*peerInfo),
|
|
quit: make(chan bool),
|
|
running: true,
|
|
}
|
|
}
|
|
|
|
func (self *BlockPool) Stop() {
|
|
self.lock.Lock()
|
|
if !self.running {
|
|
self.lock.Unlock()
|
|
return
|
|
}
|
|
self.running = false
|
|
self.lock.Unlock()
|
|
|
|
poolLogger.Infoln("Stopping")
|
|
|
|
close(self.quit)
|
|
self.wg.Wait()
|
|
poolLogger.Infoln("Stopped")
|
|
|
|
}
|
|
|
|
// Entry point for eth protocol to add block hashes received via BlockHashesMsg
|
|
// only hashes from the best peer is handled
|
|
// this method is always responsible to initiate further hash requests until
|
|
// a known parent is reached unless cancelled by a peerChange event
|
|
func (self *BlockPool) AddBlockHashes(next func() ([]byte, bool), peerId string) {
|
|
// subscribe to peerChangeEvent before we check for best peer
|
|
peerChange := self.eventer.Subscribe(peerChangeEvent{})
|
|
defer peerChange.Unsubscribe()
|
|
// check if this peer is the best
|
|
peer, best := self.getPeer(peerId)
|
|
if !best {
|
|
return
|
|
}
|
|
root := &nodePointer{}
|
|
// peer is still the best
|
|
hashes := make(chan []byte)
|
|
var lastPoolNode *poolNode
|
|
|
|
// using a for select loop so that peer change (new best peer) can abort the parallel thread that processes hashes of the earlier best peer
|
|
for {
|
|
hash, ok := next()
|
|
if ok {
|
|
hashes <- hash
|
|
} else {
|
|
break
|
|
}
|
|
select {
|
|
case <-self.quit:
|
|
return
|
|
case <-peerChange.Chan():
|
|
// remember where we left off with this peer
|
|
if lastPoolNode != nil {
|
|
root.hash = lastPoolNode.hash
|
|
go self.killChain(lastPoolNode)
|
|
}
|
|
case hash := <-hashes:
|
|
self.lock.Lock()
|
|
defer self.lock.Unlock()
|
|
// check if known block connecting the downloaded chain to our blockchain
|
|
if self.chainManager.KnownBlock(hash) {
|
|
poolLogger.Infof("known block (%x...)\n", hash[0:4])
|
|
if lastPoolNode != nil {
|
|
lastPoolNode.knownParent = true
|
|
go self.requestBlocksLoop(lastPoolNode)
|
|
} else {
|
|
// all hashes known if topmost one is in blockchain
|
|
}
|
|
return
|
|
}
|
|
//
|
|
var currentPoolNode *poolNode
|
|
// check if lastPoolNode has the correct parent node (hash matching),
|
|
// then just assign to currentPoolNode
|
|
if lastPoolNode != nil && lastPoolNode.parent != nil && bytes.Compare(lastPoolNode.parent.hash, hash) == 0 {
|
|
currentPoolNode = lastPoolNode.parent
|
|
} else {
|
|
// otherwise look up in pool
|
|
currentPoolNode = self.pool[string(hash)]
|
|
// if node does not exist, create it and index in the pool
|
|
if currentPoolNode == nil {
|
|
currentPoolNode = &poolNode{
|
|
hash: hash,
|
|
}
|
|
self.pool[string(hash)] = currentPoolNode
|
|
}
|
|
}
|
|
// set up parent-child nodes (doubly linked list)
|
|
self.link(currentPoolNode, lastPoolNode)
|
|
// ! we trust the node iff
|
|
// (1) node marked as by the same peer or
|
|
// (2) it has a PoW valid block retrieved
|
|
if currentPoolNode.peer == peer.id || currentPoolNode.block != nil {
|
|
// the trusted checkpoint from which we request hashes down to known head
|
|
lastPoolNode = self.pool[string(currentPoolNode.root.hash)]
|
|
break
|
|
}
|
|
currentPoolNode.peer = peer.id
|
|
currentPoolNode.root = root
|
|
lastPoolNode = currentPoolNode
|
|
}
|
|
}
|
|
// lastPoolNode is nil if and only if the node with stored root hash is already cleaned up
|
|
// after valid block insertion, therefore in this case the blockpool active chain is connected to the blockchain, so no need to request further hashes or request blocks
|
|
if lastPoolNode != nil {
|
|
root.hash = lastPoolNode.hash
|
|
peer.requestBlockHashes(lastPoolNode.hash)
|
|
go self.requestBlocksLoop(lastPoolNode)
|
|
}
|
|
return
|
|
}
|
|
|
|
func (self *BlockPool) requestBlocksLoop(node *poolNode) {
|
|
suicide := time.After(blockTimeout * time.Minute)
|
|
requestTimer := time.After(0)
|
|
var controlChan chan bool
|
|
closedChan := make(chan bool)
|
|
quit := make(chan bool)
|
|
close(closedChan)
|
|
requestBlocks := true
|
|
origNode := node
|
|
self.lock.Lock()
|
|
node.blockRequestRoot = true
|
|
b := false
|
|
control := &b
|
|
node.blockRequestControl = control
|
|
node.blockRequestQuit = &quit
|
|
self.lock.Unlock()
|
|
blocks := 0
|
|
self.wg.Add(1)
|
|
loop:
|
|
for {
|
|
if requestBlocks {
|
|
controlChan = closedChan
|
|
} else {
|
|
self.lock.Lock()
|
|
if *node.blockRequestControl {
|
|
controlChan = closedChan
|
|
*node.blockRequestControl = false
|
|
}
|
|
self.lock.Unlock()
|
|
}
|
|
select {
|
|
case <-quit:
|
|
break loop
|
|
case <-suicide:
|
|
go self.killChain(origNode)
|
|
break loop
|
|
|
|
case <-requestTimer:
|
|
requestBlocks = true
|
|
|
|
case <-controlChan:
|
|
controlChan = nil
|
|
// this iteration takes care of requesting blocks only starting from the first node with a missing block (moving target),
|
|
// max up to the next checkpoint (n.blockRequestRoot true)
|
|
nodes := []*poolNode{}
|
|
n := node
|
|
next := node
|
|
self.lock.Lock()
|
|
for n != nil && (n == node || !n.blockRequestRoot) && (requestBlocks || n.block != nil) {
|
|
if n.block != nil {
|
|
if len(nodes) == 0 {
|
|
// nil control indicates that node is not needed anymore
|
|
// block can be inserted to blockchain and deleted if knownParent
|
|
n.blockRequestControl = nil
|
|
blocks++
|
|
next = next.child
|
|
} else {
|
|
// this is needed to indicate that when a new chain forks from an existing one
|
|
// triggering a reorg will ? renew the blockTimeout period ???
|
|
// if there is a block but control == nil should start fetching blocks, see link function
|
|
n.blockRequestControl = control
|
|
}
|
|
} else {
|
|
nodes = append(nodes, n)
|
|
n.blockRequestControl = control
|
|
}
|
|
n = n.child
|
|
}
|
|
// if node is connected to the blockchain, we can immediately start inserting
|
|
// blocks to the blockchain and delete nodes
|
|
if node.knownParent {
|
|
go self.insertChainFrom(node)
|
|
}
|
|
if next.blockRequestRoot && next != node {
|
|
// no more missing blocks till the checkpoint, quitting
|
|
poolLogger.Debugf("fetched %v blocks on active chain, batch %v-%v", blocks, origNode, n)
|
|
break loop
|
|
}
|
|
self.lock.Unlock()
|
|
|
|
// reset starting node to the first descendant node with missing block
|
|
node = next
|
|
if !requestBlocks {
|
|
continue
|
|
}
|
|
go self.requestBlocks(nodes)
|
|
requestTimer = time.After(blockRequestInterval * time.Second)
|
|
}
|
|
}
|
|
self.wg.Done()
|
|
return
|
|
}
|
|
|
|
func (self *BlockPool) requestBlocks(nodes []*poolNode) {
|
|
// distribute block request among known peers
|
|
self.peersLock.Lock()
|
|
peerCount := len(self.peers)
|
|
poolLogger.Debugf("requesting %v missing blocks from %v peers", len(nodes), peerCount)
|
|
blockHashes := make([][][]byte, peerCount)
|
|
repetitions := int(math.Max(float64(peerCount)/2.0, float64(blockRequestRepetition)))
|
|
for n, node := range nodes {
|
|
for i := 0; i < repetitions; i++ {
|
|
blockHashes[n%peerCount] = append(blockHashes[n%peerCount], node.hash)
|
|
n++
|
|
}
|
|
}
|
|
i := 0
|
|
for _, peer := range self.peers {
|
|
peer.requestBlocks(blockHashes[i])
|
|
i++
|
|
}
|
|
self.peersLock.Unlock()
|
|
}
|
|
|
|
func (self *BlockPool) insertChainFrom(node *poolNode) {
|
|
self.lock.Lock()
|
|
defer self.lock.Unlock()
|
|
for node != nil && node.blockRequestControl == nil {
|
|
err := self.chainManager.AddBlock(node.block)
|
|
if err != nil {
|
|
poolLogger.Debugf("invalid block %v", node.hash)
|
|
poolLogger.Debugf("penalise peers %v (hash), %v (block)", node.peer, node.source)
|
|
// penalise peer in node.source
|
|
go self.killChain(node)
|
|
return
|
|
}
|
|
poolLogger.Debugf("insert block %v into blockchain", node.hash)
|
|
node = node.child
|
|
}
|
|
// if block insertion succeeds, mark the child as knownParent
|
|
// trigger request blocks reorg
|
|
if node != nil {
|
|
node.knownParent = true
|
|
*(node.blockRequestControl) = true
|
|
}
|
|
}
|
|
|
|
// AddPeer is called by the eth protocol instance running on the peer after
|
|
// the status message has been received with total difficulty and current block hash
|
|
// AddPeer can only be used once, RemovePeer needs to be called when the peer disconnects
|
|
func (self *BlockPool) AddPeer(td *big.Int, currentBlock []byte, peerId string, requestBlockHashes func([]byte) error, requestBlocks func([][]byte) error, invalidBlock func(error)) bool {
|
|
self.peersLock.Lock()
|
|
defer self.peersLock.Unlock()
|
|
if self.peers[peerId] != nil {
|
|
panic("peer already added")
|
|
}
|
|
info := &peerInfo{
|
|
td: td,
|
|
currentBlock: currentBlock,
|
|
id: peerId, //peer.Identity().Pubkey()
|
|
requestBlockHashes: requestBlockHashes,
|
|
requestBlocks: requestBlocks,
|
|
invalidBlock: invalidBlock,
|
|
}
|
|
self.peers[peerId] = info
|
|
poolLogger.Debugf("add new peer %v with td %v", peerId, td)
|
|
currentTD := ethutil.Big0
|
|
if self.peer != nil {
|
|
currentTD = self.peer.td
|
|
}
|
|
if td.Cmp(currentTD) > 0 {
|
|
self.peer = info
|
|
self.eventer.Post(peerChangeEvent{info})
|
|
poolLogger.Debugf("peer %v promoted to best peer", peerId)
|
|
requestBlockHashes(currentBlock)
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
// RemovePeer is called by the eth protocol when the peer disconnects
|
|
func (self *BlockPool) RemovePeer(peerId string) {
|
|
self.peersLock.Lock()
|
|
defer self.peersLock.Unlock()
|
|
if self.peers[peerId] != nil {
|
|
panic("peer already removed")
|
|
}
|
|
self.peers[peerId] = nil
|
|
poolLogger.Debugf("remove peer %v", peerId[0:4])
|
|
|
|
// if current best peer is removed, need find a better one
|
|
if peerId == self.peer.id {
|
|
var newPeer *peerInfo
|
|
max := ethutil.Big0
|
|
// peer with the highest self-acclaimed TD is chosen
|
|
for _, info := range self.peers {
|
|
if info.td.Cmp(max) > 0 {
|
|
max = info.td
|
|
newPeer = info
|
|
}
|
|
}
|
|
self.peer = newPeer
|
|
self.eventer.Post(peerChangeEvent{newPeer})
|
|
if newPeer != nil {
|
|
poolLogger.Debugf("peer %v with td %v spromoted to best peer", newPeer.id[0:4], newPeer.td)
|
|
newPeer.requestBlockHashes(newPeer.currentBlock)
|
|
} else {
|
|
poolLogger.Warnln("no peers left")
|
|
}
|
|
}
|
|
}
|
|
|
|
func (self *BlockPool) getPeer(peerId string) (*peerInfo, bool) {
|
|
self.peersLock.Lock()
|
|
defer self.peersLock.Unlock()
|
|
if self.peer.id == peerId {
|
|
return self.peer, true
|
|
}
|
|
info, ok := self.peers[peerId]
|
|
if !ok {
|
|
panic("unknown peer")
|
|
}
|
|
return info, false
|
|
}
|
|
|
|
// if same peer gave different chain before, this will overwrite it
|
|
// if currentPoolNode existed as a non-leaf node the earlier fork is delinked
|
|
// if same parent hash is found, we can abort, we do not allow the same peer to change minds about parent of same hash, if errored first time round, will get penalized.
|
|
// if lastPoolNode had a different parent the earlier parent (with entire subtree) is delinked, this situation cannot normally arise though
|
|
// just in case reset lastPoolNode as non-root (unlikely)
|
|
|
|
func (self *BlockPool) link(parent, child *poolNode) {
|
|
// reactivate node scheduled for suicide
|
|
if parent.suicide != nil {
|
|
close(parent.suicide)
|
|
parent.suicide = nil
|
|
}
|
|
if parent.child != child {
|
|
orphan := parent.child
|
|
orphan.parent = nil
|
|
go self.killChain(orphan)
|
|
parent.child = child
|
|
}
|
|
if child != nil {
|
|
if child.parent != parent {
|
|
orphan := child.parent
|
|
orphan.child = nil
|
|
go func() {
|
|
// if it is a aberrant reverse fork, zip down to bottom
|
|
for orphan.parent != nil {
|
|
orphan = orphan.parent
|
|
}
|
|
self.killChain(orphan)
|
|
}()
|
|
child.parent = parent
|
|
}
|
|
child.knownParent = false
|
|
}
|
|
}
|
|
|
|
func (self *BlockPool) killChain(node *poolNode) {
|
|
if node == nil {
|
|
return
|
|
}
|
|
poolLogger.Debugf("suicide scheduled on node %v", node)
|
|
suicide := make(chan bool)
|
|
self.lock.Lock()
|
|
node.suicide = suicide
|
|
self.lock.Unlock()
|
|
timer := time.After(cacheTimeout * time.Minute)
|
|
self.wg.Add(1)
|
|
select {
|
|
case <-self.quit:
|
|
case <-suicide:
|
|
// cancel suicide = close node.suicide to reactivate node
|
|
case <-timer:
|
|
poolLogger.Debugf("suicide on node %v", node)
|
|
self.lock.Lock()
|
|
defer self.lock.Unlock()
|
|
// proceed up via child links until another suicide root found or chain ends
|
|
// abort request blocks loops that start above
|
|
// and delete nodes from pool then quit the suicide process
|
|
okToAbort := node.blockRequestRoot
|
|
for node != nil && (node.suicide == suicide || node.suicide == nil) {
|
|
self.pool[string(node.hash)] = nil
|
|
if okToAbort && node.blockRequestQuit != nil {
|
|
quit := *(node.blockRequestQuit)
|
|
if quit != nil { // not yet closed
|
|
*(node.blockRequestQuit) = nil
|
|
close(quit)
|
|
}
|
|
} else {
|
|
okToAbort = true
|
|
}
|
|
node = node.child
|
|
}
|
|
}
|
|
self.wg.Done()
|
|
}
|
|
|
|
// AddBlock is the entry point for the eth protocol when blockmsg is received upon requests
|
|
// It has a strict interpretation of the protocol in that if the block received has not been requested, it results in an error (which can be ignored)
|
|
// block is checked for PoW
|
|
// only the first PoW-valid block for a hash is considered legit
|
|
func (self *BlockPool) AddBlock(block *types.Block, peerId string) (err error) {
|
|
hash := block.Hash()
|
|
self.lock.Lock()
|
|
defer self.lock.Unlock()
|
|
node, ok := self.pool[string(hash)]
|
|
if !ok && !self.chainManager.KnownBlock(hash) {
|
|
return fmt.Errorf("unrequested block %x", hash)
|
|
}
|
|
if node.block != nil {
|
|
return
|
|
}
|
|
// validate block for PoW
|
|
if !self.chainManager.CheckPoW(block) {
|
|
return fmt.Errorf("invalid pow on block %x", hash)
|
|
}
|
|
node.block = block
|
|
node.source = peerId
|
|
return nil
|
|
}
|