erigon-pulse/blockpool/section.go

package blockpool

import (
	"sync"
	"time"

	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/core/types"
	"github.com/ethereum/go-ethereum/logger"
	"github.com/ethereum/go-ethereum/logger/glog"
)

/*
  section is the worker on each chain section in the block pool
  - remove the section if there are blocks missing after an absolute time
  - remove the section if there are maxIdleRounds of idle rounds of block requests with no response
  - periodically polls the chain section for missing blocks which are then requested from peers
  - registers the process controller on the peer so that if the peer is promoted as best peer the second time (after a disconnect of a better one), all active processes are switched back on unless they removed (inserted in blockchain, invalid or expired)
  - when turned off (if peer disconnects and new peer connects with alternative chain), no blockrequests are made but absolute expiry timer is ticking
  - when turned back on it recursively calls itself on the root of the next chain section
*/
type section struct {
	lock sync.RWMutex

	parent *section // connecting section back in time towards blockchain
	child  *section // connecting section forward in time

	top    *node // the topmost node = head node = youngest node within the chain section
	bottom *node // the bottom node = root node = oldest node within the chain section
	nodes  []*node

	peer       *peer
	parentHash common.Hash

	blockHashes []common.Hash

	poolRootIndex int

	bp *BlockPool

	controlC  chan *peer     // to (de)register the current best peer
	poolRootC chan *peer     // indicate connectedness to blockchain (well, known blocks)
	offC      chan bool      // closed if process terminated
	suicideC  chan bool      // initiate suicide on the section
	quitInitC chan bool      // to signal end of initialisation
	forkC     chan chan bool // freeze section process while splitting
	switchC   chan bool      // switching
	idleC     chan bool      // channel to indicate thai food
	processC  chan *node     //
	missingC  chan *node     //

	blocksRequestTimer      <-chan time.Time
	blockHashesRequestTimer <-chan time.Time
	suicideTimer            <-chan time.Time

	blocksRequests      int
	blockHashesRequests int

	blocksRequestsComplete      bool
	blockHashesRequestsComplete bool
	ready                       bool
	same                        bool
	initialised                 bool
	active                      bool

	step        int
	idle        int
	missing     int
	lastMissing int
	depth       int
	invalid     bool
	poolRoot    bool
}

//
func (self *BlockPool) newSection(nodes []*node) *section {
	sec := &section{
		bottom:        nodes[len(nodes)-1],
		top:           nodes[0],
		nodes:         nodes,
		poolRootIndex: len(nodes),
		bp:            self,
		controlC:      make(chan *peer),
		poolRootC:     make(chan *peer),
		offC:          make(chan bool),
	}

	for i, n := range nodes {
		entry := &entry{node: n, section: sec, index: &index{i}}
		self.set(n.hash, entry)
	}

	glog.V(logger.Detail).Infof("[%s] setup section process", sectionhex(sec))

	go sec.run()
	return sec
}

func (self *section) addSectionToBlockChain(p *peer) {
	self.bp.wg.Add(1)
	go func() {

		self.lock.Lock()
		defer self.lock.Unlock()
		defer func() {
			self.bp.wg.Done()
		}()

		var nodes []*node
		var n *node
		var keys []common.Hash
		var blocks []*types.Block
		for self.poolRootIndex > 0 {
			n = self.nodes[self.poolRootIndex-1]
			n.lock.RLock()
			block := n.block
			n.lock.RUnlock()
			if block == nil {
				break
			}
			self.poolRootIndex--
			keys = append(keys, n.hash)
			blocks = append(blocks, block)
			nodes = append(nodes, n)
		}

		if len(blocks) == 0 {
			return
		}

		self.bp.lock.Lock()
		for _, key := range keys {
			delete(self.bp.pool, key)
		}
		self.bp.lock.Unlock()

		glog.V(logger.Debug).Infof("[%s] insert %v blocks [%v/%v] into blockchain", sectionhex(self), len(blocks), hex(blocks[0].Hash()), hex(blocks[len(blocks)-1].Hash()))
		err := self.bp.insertChain(blocks)
		if err != nil {
			self.invalid = true
			self.bp.peers.peerError(n.blockBy, ErrInvalidBlock, "%v", err)
			glog.V(logger.Error).Infof("invalid block %x", n.hash)
			glog.V(logger.Error).Infof("penalise peers %v (hash), %v (block)", n.hashBy, n.blockBy)

			// or invalid block and the entire chain needs to be removed
			self.removeChain()
		} else {
			// check tds
			self.bp.wg.Add(1)
			go func() {
				self.bp.checkTD(nodes...)
				self.bp.wg.Done()
			}()
			// if all blocks inserted in this section
			// then need to try to insert blocks in child section
			if self.poolRootIndex == 0 {
				// if there is a child section, then recursively call itself:
				// also if section process is not terminated,
				// then signal blockchain connectivity with poolRootC
				if child := self.bp.getChild(self); child != nil {
					select {
					case <-child.offC:
						glog.V(logger.Detail).Infof("[%s] add complete child section [%s] to the blockchain", sectionhex(self), sectionhex(child))
					case child.poolRootC <- p:
						glog.V(logger.Detail).Infof("[%s] add incomplete child section [%s] to the blockchain", sectionhex(self), sectionhex(child))
					}
					child.addSectionToBlockChain(p)
				} else {
					glog.V(logger.Detail).Infof("[%s] no child section in pool", sectionhex(self))
				}
				glog.V(logger.Detail).Infof("[%s] section completely inserted to blockchain - remove", sectionhex(self))
				// complete sections are removed. if called from within section process,
				// this must run in its own go routine to avoid deadlock
				self.remove()
			}
		}

		self.bp.status.lock.Lock()
		if err == nil {
			headKey := blocks[0].ParentHash()
			height := self.bp.status.chain[headKey] + len(blocks)
			self.bp.status.chain[blocks[len(blocks)-1].Hash()] = height
			if height > self.bp.status.values.LongestChain {
				self.bp.status.values.LongestChain = height
			}
			delete(self.bp.status.chain, headKey)
		}
		self.bp.status.values.BlocksInChain += len(blocks)
		self.bp.status.values.BlocksInPool -= len(blocks)
		if err != nil {
			self.bp.status.badPeers[n.blockBy]++
		}
		self.bp.status.lock.Unlock()

	}()

}

func (self *section) run() {

	// absolute time after which sub-chain is killed if not complete (some blocks are missing)
	self.suicideC = make(chan bool)
	self.forkC = make(chan chan bool)
	self.suicideTimer = time.After(self.bp.Config.BlocksTimeout)

	// node channels for the section
	// container for missing block hashes
	var checking bool
	var ping = time.NewTicker(5 * time.Second)

LOOP:
	for !self.blockHashesRequestsComplete || !self.blocksRequestsComplete {

		select {
		case <-ping.C:
			var name = "no peer"
			if self.peer != nil {
				name = self.peer.id
			}
			glog.V(logger.Detail).Infof("[%s] peer <%s> active: %v", sectionhex(self), name, self.active)

		// global quit from blockpool
		case <-self.bp.quit:
			break LOOP

		// pause for peer switching
		case <-self.switchC:
			self.switchC = nil

		case p := <-self.poolRootC:
			// signal on pool root channel indicates that the blockpool is
			// connected to the blockchain, insert the longest chain of blocks
			// ignored in idle mode to avoid inserting chain sections of non-live peers
			self.poolRoot = true
			// switch off hash requests in case they were on
			self.blockHashesRequestTimer = nil
			self.blockHashesRequestsComplete = true
			self.switchOn(p)

		// peer quit or demoted, put section in idle mode
		case <-self.idleC:
			// peer quit or demoted, put section in idle mode
			glog.V(logger.Debug).Infof("[%s] peer <%s> quit or demoted", sectionhex(self), self.peer.id)
			self.switchOff()
			self.idleC = nil

		// timebomb - if section is not complete in time, nuke the entire chain
		case <-self.suicideTimer:
			self.removeChain()
			glog.V(logger.Debug).Infof("[%s] timeout. (%v total attempts): missing %v/%v/%v...suicide", sectionhex(self), self.blocksRequests, self.missing, self.lastMissing, self.depth)
			self.suicideTimer = nil
			break LOOP

		// closing suicideC triggers section suicide: removes section nodes from pool and terminates section process
		case <-self.suicideC:
			glog.V(logger.Detail).Infof("[%s] quit", sectionhex(self))
			break LOOP

		// alarm for checking blocks in the section
		case <-self.blocksRequestTimer:
			glog.V(logger.Detail).Infof("[%s] alarm: block request time", sectionhex(self))
			self.processC = self.missingC

		// alarm for checking parent of the section or sending out hash requests
		case <-self.blockHashesRequestTimer:
			glog.V(logger.Detail).Infof("[%s] alarm: hash request time", sectionhex(self))
			self.blockHashesRequest()

		// activate this section process with a peer
		case p := <-self.controlC:
			if p == nil {
				self.switchOff()
			} else {
				self.switchOn(p)
			}
			self.bp.wg.Done()
		// blocks the process until section is split at the fork
		case waiter := <-self.forkC:
			<-waiter
			self.initialised = false
			self.quitInitC = nil

		//
		case n, ok := <-self.processC:
			// channel closed, first iteration finished
			if !ok && !self.initialised {
				glog.V(logger.Detail).Infof("[%s] section initalised: missing %v/%v/%v", sectionhex(self), self.missing, self.lastMissing, self.depth)
				self.initialised = true
				self.processC = nil
				self.checkRound()
				checking = false
				break
			}
			if !checking {
				self.step = 0
				self.missing = 0
				checking = true
			}
			self.step++

			n.lock.RLock()
			block := n.block
			n.lock.RUnlock()

			// if node has no block, request it (buffer it for batch request)
			// feed it to missingC channel for the next round
			if block == nil {
				pos := self.missing % self.bp.Config.BlockBatchSize
				if pos == 0 {
					if self.missing != 0 {
						self.bp.requestBlocks(self.blocksRequests, self.blockHashes[:])
					}
					self.blockHashes = self.bp.getHashSlice()
				}
				self.blockHashes[pos] = n.hash
				self.missing++
				self.missingC <- n
			} else {
				// checking for parent block
				if self.poolRoot {
					// if node has got block (received via async AddBlock call from protocol)
					if self.step == self.lastMissing {
						// current root of the pool
						glog.V(logger.Detail).Infof("[%s] received block for current pool root %s", sectionhex(self), hex(n.hash))
						self.addSectionToBlockChain(self.peer)
					}
				} else {
					if (self.parentHash == common.Hash{}) && n == self.bottom {
						self.parentHash = block.ParentHash()
						glog.V(logger.Detail).Infof("[%s] got parent head block hash %s...checking", sectionhex(self), hex(self.parentHash))
						self.blockHashesRequest()
					}
				}
			}
			if self.initialised && self.step == self.lastMissing {
				glog.V(logger.Detail).Infof("[%s] check if new blocks arrived (attempt %v): missing %v/%v/%v", sectionhex(self), self.blocksRequests, self.missing, self.lastMissing, self.depth)
				self.checkRound()
				checking = false
			}
		} // select
	} // for

	close(self.offC)
	if self.peer != nil {
		self.active = false
		self.bp.wg.Done()
	}

	glog.V(logger.Detail).Infof("[%s] section process terminated: %v blocks retrieved (%v attempts), hash requests complete on root (%v attempts).", sectionhex(self), self.depth, self.blocksRequests, self.blockHashesRequests)

}

func (self *section) switchOn(newpeer *peer) {

	oldpeer := self.peer
	// reset switchC/switchC to current best peer
	self.idleC = newpeer.idleC
	self.switchC = newpeer.switchC
	self.peer = newpeer

	if oldpeer != newpeer {
		oldp := "no peer"
		newp := "no peer"
		if oldpeer != nil {
			oldp = oldpeer.id
		}
		if newpeer != nil {
			newp = newpeer.id
		}

		glog.V(logger.Detail).Infof("[%s] active mode <%s> -> <%s>", sectionhex(self), oldp, newp)
	}

	// activate section with current peer
	if oldpeer == nil {
		self.bp.wg.Add(1)
		self.active = true

		if !self.blockHashesRequestsComplete {
			self.blockHashesRequestTimer = time.After(0)
		}
		if !self.blocksRequestsComplete {
			if !self.initialised {
				if self.quitInitC != nil {
					<-self.quitInitC
				}
				self.missingC = make(chan *node, self.bp.Config.BlockHashesBatchSize)
				self.processC = make(chan *node, self.bp.Config.BlockHashesBatchSize)
				self.quitInitC = make(chan bool)

				self.step = 0
				self.missing = 0
				self.depth = len(self.nodes)
				self.lastMissing = self.depth

				self.feedNodes()
			} else {
				self.blocksRequestTimer = time.After(0)
			}
		}
	}
}

// put the section to idle mode
func (self *section) switchOff() {
	// active -> idle
	if self.peer != nil {
		oldp := "no peer"
		oldpeer := self.peer
		if oldpeer != nil {
			oldp = oldpeer.id
		}
		glog.V(logger.Detail).Infof("[%s] idle mode peer <%s> -> <> (%v total attempts): missing %v/%v/%v", sectionhex(self), oldp, self.blocksRequests, self.missing, self.lastMissing, self.depth)

		self.active = false
		self.peer = nil
		// turn off timers
		self.blocksRequestTimer = nil
		self.blockHashesRequestTimer = nil

		if self.quitInitC != nil {
			<-self.quitInitC
			self.quitInitC = nil
		}
		self.processC = nil
		self.bp.wg.Done()
	}
}

// iterates through nodes of a section to feed processC
// used to initialise chain section
func (self *section) feedNodes() {
	// if not run at least once fully, launch iterator
	self.bp.wg.Add(1)
	go func() {
		self.lock.Lock()
		defer self.lock.Unlock()
		defer func() {
			self.bp.wg.Done()
		}()
		var n *node
	INIT:
		for _, n = range self.nodes {
			select {
			case self.processC <- n:
			case <-self.bp.quit:
				break INIT
			}
		}
		close(self.processC)
		close(self.quitInitC)
	}()
}

func (self *section) blockHashesRequest() {

	if self.switchC != nil {
		self.bp.chainLock.Lock()
		parentSection := self.parent

		if parentSection == nil {

			// only link to new parent if not switching peers
			if (self.parentHash != common.Hash{}) {
				if parent := self.bp.get(self.parentHash); parent != nil {
					parentSection = parent.section
					glog.V(logger.Detail).Infof("[%s] blockHashesRequest: parent section [%s] linked\n", sectionhex(self), sectionhex(parentSection))
					link(parentSection, self)
				} else {
					if self.bp.hasBlock(self.parentHash) {
						self.poolRoot = true
						glog.V(logger.Detail).Infof("[%s] blockHashesRequest: parentHash known ... inserting section in blockchain", sectionhex(self))
						self.addSectionToBlockChain(self.peer)
						self.blockHashesRequestTimer = nil
						self.blockHashesRequestsComplete = true
					}
				}
			}
		}
		self.bp.chainLock.Unlock()

		if !self.poolRoot {
			if parentSection != nil {
				//  activate parent section with this peer
				// but only if not during switch mode
				glog.V(logger.Detail).Infof("[%s] parent section [%s] activated\n", sectionhex(self), sectionhex(parentSection))
				self.bp.activateChain(parentSection, self.peer, self.peer.switchC, nil)
				// if not root of chain, switch off
				glog.V(logger.Detail).Infof("[%s] parent found, hash requests deactivated (after %v total attempts)\n", sectionhex(self), self.blockHashesRequests)
				self.blockHashesRequestTimer = nil
				self.blockHashesRequestsComplete = true
			} else {
				self.blockHashesRequests++
				glog.V(logger.Detail).Infof("[%s] hash request on root (%v total attempts)\n", sectionhex(self), self.blockHashesRequests)
				self.peer.requestBlockHashes(self.bottom.hash)
				self.blockHashesRequestTimer = time.After(self.bp.Config.BlockHashesRequestInterval)
			}
		}
	}
}

// checks number of missing blocks after each round of request and acts accordingly
func (self *section) checkRound() {
	if self.missing == 0 {
		// no missing blocks
		glog.V(logger.Detail).Infof("[%s] section checked: got all blocks. process complete (%v total blocksRequests): missing %v/%v/%v", sectionhex(self), self.blocksRequests, self.missing, self.lastMissing, self.depth)
		self.blocksRequestsComplete = true
		self.blocksRequestTimer = nil
	} else {
		// some missing blocks
		glog.V(logger.Detail).Infof("[%s] section checked: missing %v/%v/%v", sectionhex(self), self.missing, self.lastMissing, self.depth)
		self.blocksRequests++
		pos := self.missing % self.bp.Config.BlockBatchSize
		if pos == 0 {
			pos = self.bp.Config.BlockBatchSize
		}
		self.bp.requestBlocks(self.blocksRequests, self.blockHashes[:pos])

		// handle idle rounds
		if self.missing == self.lastMissing {
			// idle round
			if self.same {
				// more than once
				self.idle++
				// too many idle rounds
				if self.idle >= self.bp.Config.BlocksRequestMaxIdleRounds {
					glog.V(logger.Detail).Infof("[%s] block requests had %v idle rounds (%v total attempts): missing %v/%v/%v\ngiving up...", sectionhex(self), self.idle, self.blocksRequests, self.missing, self.lastMissing, self.depth)
					self.removeChain()
				}
			} else {
				self.idle = 0
			}
			self.same = true
		} else {
			self.same = false
		}
		self.lastMissing = self.missing
		// put processC offline
		self.processC = nil
		self.blocksRequestTimer = time.After(self.bp.Config.BlocksRequestInterval)
	}
}

/*
 link connects two sections via parent/child fields
 creating a doubly linked list
 caller must hold BlockPool chainLock
*/
func link(parent *section, child *section) {
	if parent != nil {
		exChild := parent.child
		parent.child = child
		if exChild != nil && exChild != child {
			if child != nil {
				// if child is nil it is not a real fork
				glog.V(logger.Detail).Infof("[%s] chain fork [%s] -> [%s]", sectionhex(parent), sectionhex(exChild), sectionhex(child))
			}
			exChild.parent = nil
		}
	}
	if child != nil {
		exParent := child.parent
		if exParent != nil && exParent != parent {
			if parent != nil {
				// if parent is nil it is not a real fork, but suicide delinking section
				glog.V(logger.Detail).Infof("[%s] chain reverse fork [%s] -> [%s]", sectionhex(child), sectionhex(exParent), sectionhex(parent))
			}
			exParent.child = nil
		}
		child.parent = parent
	}
}

/*
  handle forks where connecting node is mid-section
  by splitting section at fork
  no splitting needed if connecting node is head of a section
  caller must hold chain lock
*/
func (self *BlockPool) splitSection(parent *section, entry *entry) {
	glog.V(logger.Detail).Infof("[%s] split section at fork", sectionhex(parent))
	parent.deactivate()
	waiter := make(chan bool)
	parent.wait(waiter)
	chain := parent.nodes
	parent.nodes = chain[entry.index.int:]
	parent.top = parent.nodes[0]
	parent.poolRootIndex -= entry.index.int
	orphan := self.newSection(chain[0:entry.index.int])
	link(orphan, parent.child)
	close(waiter)
	orphan.deactivate()
}

func (self *section) wait(waiter chan bool) {
	self.forkC <- waiter
}

func (self *BlockPool) linkSections(nodes []*node, parent, child *section) (sec *section) {
	// if new section is created, link it to parent/child sections
	// and launch section process fetching block and further hashes
	if len(nodes) > 0 {
		sec = self.newSection(nodes)
		glog.V(logger.Debug).Infof("[%s]->[%s](%v)->[%s] new chain section", sectionhex(parent), sectionhex(sec), len(nodes), sectionhex(child))
		link(parent, sec)
		link(sec, child)
	} else {
		if parent != nil && child != nil {
			// now this can only happen if we allow response to hash request to include <from> hash
			// in this case we just link parent and child (without needing root block of child section)
			glog.V(logger.Debug).Infof("[%s]->[%s] connecting known sections", sectionhex(parent), sectionhex(child))
			link(parent, child)
		}
	}
	return
}

func (self *section) activate(p *peer) {
	self.bp.wg.Add(1)
	select {
	case <-self.offC:
		glog.V(logger.Detail).Infof("[%s] completed section process. cannot activate for peer <%s>", sectionhex(self), p.id)
		self.bp.wg.Done()
	case self.controlC <- p:
		glog.V(logger.Detail).Infof("[%s] activate section process for peer <%s>", sectionhex(self), p.id)
	}
}

func (self *section) deactivate() {
	self.bp.wg.Add(1)
	self.controlC <- nil
}

// removes this section exacly
func (self *section) remove() {
	select {
	case <-self.offC:
		close(self.suicideC)
		glog.V(logger.Detail).Infof("[%s] remove: suicide", sectionhex(self))
	case <-self.suicideC:
		glog.V(logger.Detail).Infof("[%s] remove: suicided already", sectionhex(self))
	default:
		glog.V(logger.Detail).Infof("[%s] remove: suicide", sectionhex(self))
		close(self.suicideC)
	}
	self.unlink()
	self.bp.remove(self)
	glog.V(logger.Detail).Infof("[%s] removed section.", sectionhex(self))

}

// remove a section and all its descendents from the pool
func (self *section) removeChain() {
	// need to get the child before removeSection delinks the section
	self.bp.chainLock.RLock()
	child := self.child
	self.bp.chainLock.RUnlock()

	glog.V(logger.Detail).Infof("[%s] remove chain", sectionhex(self))
	self.remove()
	if child != nil {
		child.removeChain()
	}
}

// unlink a section from its parent/child
func (self *section) unlink() {
	// first delink from child and parent under chainlock
	self.bp.chainLock.Lock()
	link(nil, self)
	link(self, nil)
	self.bp.chainLock.Unlock()
}