path: root/eth/block_pool.go

package eth

import (
    "math"
    "math/big"
    "math/rand"
    "sort"
    "sync"
    "time"

    "github.com/ethereum/go-ethereum/core/types"
    "github.com/ethereum/go-ethereum/ethutil"
    ethlogger "github.com/ethereum/go-ethereum/logger"
)

var poolLogger = ethlogger.NewLogger("Blockpool")

const (
    blockHashesBatchSize       = 256
    blockBatchSize             = 64
    blocksRequestInterval      = 10 // seconds
    blocksRequestRepetition    = 1
    blockHashesRequestInterval = 10 // seconds
    blocksRequestMaxIdleRounds = 10
    cacheTimeout               = 3 // minutes
    blockTimeout               = 5 // minutes
)

type poolNode struct {
    lock        sync.RWMutex
    hash        []byte
    block       *types.Block
    child       *poolNode
    parent      *poolNode
    section     *section
    knownParent bool
    peer        string
    source      string
    complete    bool
}

type BlockPool struct {
    lock sync.RWMutex
    pool map[string]*poolNode

    peersLock sync.RWMutex
    peers     map[string]*peerInfo
    peer      *peerInfo

    quit    chan bool
    wg      sync.WaitGroup
    running bool

    // the minimal interface with blockchain
    hasBlock    func(hash []byte) bool
    insertChain func(types.Blocks) error
    verifyPoW   func(*types.Block) bool
}

type peerInfo struct {
    lock sync.RWMutex

    td           *big.Int
    currentBlock []byte
    id           string

    requestBlockHashes func([]byte) error
    requestBlocks      func([][]byte) error
    peerError          func(int, string, ...interface{})

    sections map[string]*section
    roots    []*poolNode
    quitC    chan bool
}

func NewBlockPool(hasBlock func(hash []byte) bool, insertChain func(types.Blocks) error, verifyPoW func(*types.Block) bool,
) *BlockPool {
    return &BlockPool{
        hasBlock:    hasBlock,
        insertChain: insertChain,
        verifyPoW:   verifyPoW,
    }
}

// allows restart
func (self *BlockPool) Start() {
    self.lock.Lock()
    if self.running {
        self.lock.Unlock()
        return
    }
    self.running = true
    self.quit = make(chan bool)
    self.pool = make(map[string]*poolNode)
    self.lock.Unlock()

    self.peersLock.Lock()
    self.peers = make(map[string]*peerInfo)
    self.peersLock.Unlock()

    poolLogger.Infoln("Started")

}

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.lock.Lock()
    self.peersLock.Lock()
    self.peers = nil
    self.pool = nil
    self.peer = nil
    self.wg.Wait()
    self.lock.Unlock()
    self.peersLock.Unlock()
    poolLogger.Infoln("Stopped")

}

// 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, peerError func(int, string, ...interface{})) bool {
    self.peersLock.Lock()
    defer self.peersLock.Unlock()
    if self.peers[peerId] != nil {
        panic("peer already added")
    }
    peer := &peerInfo{
        td:                 td,
        currentBlock:       currentBlock,
        id:                 peerId, //peer.Identity().Pubkey()
        requestBlockHashes: requestBlockHashes,
        requestBlocks:      requestBlocks,
        peerError:          peerError,
    }
    self.peers[peerId] = peer
    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.stop(peer)
        peer.start(self.peer)
        poolLogger.Debugf("peer %v promoted to best peer", peerId)
        self.peer = peer
        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()
    peer := self.peers[peerId]
    if peer == nil {
        return
    }
    self.peers[peerId] = nil
    poolLogger.Debugf("remove peer %v", peerId[0:4])

    // if current best peer is removed, need find a better one
    if self.peer != nil && 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.stop(peer)
        peer.start(self.peer)
        if newPeer != nil {
            poolLogger.Debugf("peer %v with td %v promoted to best peer", newPeer.id[0:4], newPeer.td)
        } else {
            poolLogger.Warnln("no peers left")
        }
    }
}

// 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
// this process also launches all request processes on each chain section
// this function needs to run asynchronously for one peer since the message is discarded???
func (self *BlockPool) AddBlockHashes(next func() ([]byte, bool), peerId string) {

    // check if this peer is the best
    peer, best := self.getPeer(peerId)
    if !best {
        return
    }
    // peer is still the best

    var child *poolNode
    var depth int

    // iterate using next (rlp stream lazy decoder) feeding hashesC
    self.wg.Add(1)
    go func() {
        for {
            select {
            case <-self.quit:
                return
            case <-peer.quitC:
                // if the peer is demoted, no more hashes taken
                break
            default:
                hash, ok := next()
                if !ok {
                    // message consumed chain skeleton built
                    break
                }
                // check if known block connecting the downloaded chain to our blockchain
                if self.hasBlock(hash) {
                    poolLogger.Infof("known block (%x...)\n", hash[0:4])
                    if child != nil {
                        child.Lock()
                        // mark child as absolute pool root with parent known to blockchain
                        child.knownParent = true
                        child.Unlock()
                    }
                    break
                }
                //
                var parent *poolNode
                // look up node in pool
                parent = self.get(hash)
                if parent != nil {
                    // reached a known chain in the pool
                    // request blocks on the newly added part of the chain
                    if child != nil {
                        self.link(parent, child)

                        // activate the current chain
                        self.activateChain(parent, peer, true)
                        poolLogger.Debugf("potential chain of %v blocks added, reached blockpool, activate chain", depth)
                        break
                    }
                    // if this is the first hash, we expect to find it
                    parent.RLock()
                    grandParent := parent.parent
                    parent.RUnlock()
                    if grandParent != nil {
                        // activate the current chain
                        self.activateChain(parent, peer, true)
                        poolLogger.Debugf("block hash found, activate chain")
                        break
                    }
                    // the first node is the root of a chain in the pool, rejoice and continue
                }
                // if node does not exist, create it and index in the pool
                section := &section{}
                if child == nil {
                    section.top = parent
                }
                parent = &poolNode{
                    hash:    hash,
                    child:   child,
                    section: section,
                    peer:    peerId,
                }
                self.set(hash, parent)
                poolLogger.Debugf("create potential block for %x...", hash[0:4])

                depth++
                child = parent
            }
        }
        if child != nil {
            poolLogger.Debugf("chain of %v hashes added", depth)
            // start a processSection on the last node, but switch off asking
            // hashes and blocks until next peer confirms this chain
            section := self.processSection(child)
            peer.addSection(child.hash, section)
            section.start()
        }
    }()
}

// 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) {
    hash := block.Hash()
    node := self.get(hash)
    node.RLock()
    b := node.block
    node.RUnlock()
    if b != nil {
        return
    }
    if node == nil && !self.hasBlock(hash) {
        self.peerError(peerId, ErrUnrequestedBlock, "%x", hash)
        return
    }
    // validate block for PoW
    if !self.verifyPoW(block) {
        self.peerError(peerId, ErrInvalidPoW, "%x", hash)
    }
    node.Lock()
    node.block = block
    node.source = peerId
    node.Unlock()
}

// iterates down a known poolchain and activates fetching processes
// on each chain section for the peer
// stops if the peer is demoted
// registers last section root as root for the peer (in case peer is promoted a second time, to remember)
func (self *BlockPool) activateChain(node *poolNode, peer *peerInfo, on bool) {
    self.wg.Add(1)
    go func() {
        for {
            node.sectionRLock()
            bottom := node.section.bottom
            if bottom == nil { // the chain section is being created or killed
                break
            }
            // register this section with the peer
            if peer != nil {
                peer.addSection(bottom.hash, bottom.section)
                if on {
                    bottom.section.start()
                } else {
                    bottom.section.start()
                }
            }
            if bottom.parent == nil {
                node = bottom
                break
            }
            // if peer demoted stop activation
            select {
            case <-peer.quitC:
                break
            default:
            }

            node = bottom.parent
            bottom.sectionRUnlock()
        }
        // remember root for this peer
        peer.addRoot(node)
        self.wg.Done()
    }()
}

// main worker thread on each section in the poolchain
// - kills the section if there are blocks missing after an absolute time
// - kills 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 expire and killed ()
// - 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
// - when exits, signals to
func (self *BlockPool) processSection(node *poolNode) *section {
    // absolute time after which sub-chain is killed if not complete (some blocks are missing)
    suicideTimer := time.After(blockTimeout * time.Minute)
    var blocksRequestTimer, blockHashesRequestTimer <-chan time.Time
    var nodeC, missingC, processC chan *poolNode
    controlC := make(chan bool)
    resetC := make(chan bool)
    var hashes [][]byte
    var i, total, missing, lastMissing, depth int
    var blockHashesRequests, blocksRequests int
    var idle int
    var init, alarm, done, same, running, once bool
    orignode := node
    hash := node.hash

    node.sectionLock()
    defer node.sectionUnlock()
    section := &section{controlC: controlC, resetC: resetC}
    node.section = section

    go func() {
        self.wg.Add(1)
        for {
            node.sectionRLock()
            controlC = node.section.controlC
            node.sectionRUnlock()

            if init {
                // missing blocks read from nodeC
                // initialized section
                if depth == 0 {
                    break
                }
                // enable select case to read missing block when ready
                processC = missingC
                missingC = make(chan *poolNode, lastMissing)
                nodeC = nil
                // only do once
                init = false
            } else {
                if !once {
                    missingC = nil
                    processC = nil
                    i = 0
                    total = 0
                    lastMissing = 0
                }
            }

            // went through all blocks in section
            if i != 0 && i == lastMissing {
                if len(hashes) > 0 {
                    // send block requests to peers
                    self.requestBlocks(blocksRequests, hashes)
                }
                blocksRequests++
                poolLogger.Debugf("[%x] block request attempt %v: missing %v/%v/%v", hash[0:4], blocksRequests, missing, total, depth)
                if missing == lastMissing {
                    // idle round
                    if same {
                        // more than once
                        idle++
                        // too many idle rounds
                        if idle > blocksRequestMaxIdleRounds {
                            poolLogger.Debugf("[%x] block requests had %v idle rounds (%v total attempts): missing %v/%v/%v\ngiving up...", hash[0:4], idle, blocksRequests, missing, total, depth)
                            self.killChain(node, nil)
                            break
                        }
                    } else {
                        idle = 0
                    }
                    same = true
                } else {
                    if missing == 0 {
                        // no missing nodes
                        poolLogger.Debugf("block request process complete on section %x... (%v total blocksRequests): missing %v/%v/%v", hash[0:4], blockHashesRequests, blocksRequests, missing, total, depth)
                        node.Lock()
                        orignode.complete = true
                        node.Unlock()
                        blocksRequestTimer = nil
                        if blockHashesRequestTimer == nil {
                            // not waiting for hashes any more
                            poolLogger.Debugf("hash request on root %x... successful (%v total attempts)\nquitting...", hash[0:4], blockHashesRequests)
                            break
                        } // otherwise suicide if no hashes coming
                    }
                    same = false
                }
                lastMissing = missing
                i = 0
                missing = 0
                // ready for next round
                done = true
            }
            if done && alarm {
                poolLogger.Debugf("start checking if new blocks arrived (attempt %v): missing %v/%v/%v", blocksRequests, missing, total, depth)
                blocksRequestTimer = time.After(blocksRequestInterval * time.Second)
                alarm = false
                done = false
                // processC supposed to be empty and never closed so just swap,  no need to allocate
                tempC := processC
                processC = missingC
                missingC = tempC
            }
            select {
            case <-self.quit:
                break
            case <-suicideTimer:
                self.killChain(node, nil)
                poolLogger.Warnf("[%x] timeout. (%v total attempts): missing %v/%v/%v", hash[0:4], blocksRequests, missing, total, depth)
                break
            case <-blocksRequestTimer:
                alarm = true
            case <-blockHashesRequestTimer:
                orignode.RLock()
                parent := orignode.parent
                orignode.RUnlock()
                if parent != nil {
                    // if not root of chain, switch off
                    poolLogger.Debugf("[%x] parent found, hash requests deactivated (after %v total attempts)\n", hash[0:4], blockHashesRequests)
                    blockHashesRequestTimer = nil
                } else {
                    blockHashesRequests++
                    poolLogger.Debugf("[%x] hash request on root (%v total attempts)\n", hash[0:4], blockHashesRequests)
                    self.requestBlockHashes(parent.hash)
                    blockHashesRequestTimer = time.After(blockHashesRequestInterval * time.Second)
                }
            case r, ok := <-controlC:
                if !ok {
                    break
                }
                if running && !r {
                    poolLogger.Debugf("process on section %x... (%v total attempts): missing %v/%v/%v", hash[0:4], blocksRequests, missing, total, depth)

                    alarm = false
                    blocksRequestTimer = nil
                    blockHashesRequestTimer = nil
                    processC = nil
                }
                if !running && r {
                    poolLogger.Debugf("[%x] on", hash[0:4])

                    orignode.RLock()
                    parent := orignode.parent
                    complete := orignode.complete
                    knownParent := orignode.knownParent
                    orignode.RUnlock()
                    if !complete {
                        poolLogger.Debugf("[%x] activate block requests", hash[0:4])
                        blocksRequestTimer = time.After(0)
                    }
                    if parent == nil && !knownParent {
                        // if no parent but not connected to blockchain
                        poolLogger.Debugf("[%x] activate block hashes requests", hash[0:4])
                        blockHashesRequestTimer = time.After(0)
                    } else {
                        blockHashesRequestTimer = nil
                    }
                    alarm = true
                    processC = missingC
                    if !once {
                        // if not run at least once fully, launch iterator
                        processC = make(chan *poolNode)
                        missingC = make(chan *poolNode)
                        self.foldUp(orignode, processC)
                        once = true
                    }
                }
                total = lastMissing
            case <-resetC:
                once = false
                init = false
                done = false
            case node, ok := <-processC:
                if !ok {
                    // channel closed, first iteration finished
                    init = true
                    once = true
                    continue
                }
                i++
                // if node has no block
                node.RLock()
                block := node.block
                nhash := node.hash
                knownParent := node.knownParent
                node.RUnlock()
                if !init {
                    depth++
                }
                if block == nil {
                    missing++
                    if !init {
                        total++
                    }
                    hashes = append(hashes, nhash)
                    if len(hashes) == blockBatchSize {
                        self.requestBlocks(blocksRequests, hashes)
                        hashes = nil
                    }
                    missingC <- node
                } else {
                    // block is found
                    if knownParent {
                        // connected to the blockchain, insert the longest chain of blocks
                        var blocks types.Blocks
                        child := node
                        parent := node
                        node.sectionRLock()
                        for child != nil && child.block != nil {
                            parent = child
                            blocks = append(blocks, parent.block)
                            child = parent.child
                        }
                        node.sectionRUnlock()
                        poolLogger.Debugf("[%x] insert %v blocks into blockchain", hash[0:4], len(blocks))
                        if err := self.insertChain(blocks); err != nil {
                            // TODO: not clear which peer we need to address
                            // peerError should dispatch to peer if still connected and disconnect
                            self.peerError(node.source, ErrInvalidBlock, "%v", err)
                            poolLogger.Debugf("invalid block %v", node.hash)
                            poolLogger.Debugf("penalise peers %v (hash), %v (block)", node.peer, node.source)
                            // penalise peer in node.source
                            self.killChain(node, nil)
                            // self.disconnect()
                            break
                        }
                        // if suceeded mark the next one (no block yet) as connected to blockchain
                        if child != nil {
                            child.Lock()
                            child.knownParent = true
                            child.Unlock()
                        }
                        // reset starting node to first node with missing block
                        orignode = child
                        // pop the inserted ancestors off the channel
                        for i := 1; i < len(blocks); i++ {
                            <-processC
                        }
                        // delink inserted chain section
                        self.killChain(node, parent)
                    }
                }
            }
        }
        poolLogger.Debugf("[%x] quit after\n%v block hashes requests\n%v block requests: missing %v/%v/%v", hash[0:4], blockHashesRequests, blocksRequests, missing, total, depth)

        self.wg.Done()
        node.sectionLock()
        node.section.controlC = nil
        node.sectionUnlock()
        // this signals that controller not available
    }()
    return section

}

func (self *BlockPool) peerError(peerId string, code int, format string, params ...interface{}) {
    self.peersLock.RLock()
    defer self.peersLock.RUnlock()
    peer, ok := self.peers[peerId]
    if ok {
        peer.peerError(code, format, params...)
    }
}

func (self *BlockPool) requestBlockHashes(hash []byte) {
    self.peersLock.Lock()
    defer self.peersLock.Unlock()
    if self.peer != nil {
        self.peer.requestBlockHashes(hash)
    }
}

func (self *BlockPool) requestBlocks(attempts int, hashes [][]byte) {
    // distribute block request among known peers
    self.peersLock.Lock()
    defer self.peersLock.Unlock()
    peerCount := len(self.peers)
    // on first attempt use the best peer
    if attempts == 0 {
        self.peer.requestBlocks(hashes)
        return
    }
    repetitions := int(math.Min(float64(peerCount), float64(blocksRequestRepetition)))
    poolLogger.Debugf("request %v missing blocks from %v/%v peers", len(hashes), repetitions, peerCount)
    i := 0
    indexes := rand.Perm(peerCount)[0:(repetitions - 1)]
    sort.Ints(indexes)
    for _, peer := range self.peers {
        if i == indexes[0] {
            peer.requestBlocks(hashes)
            indexes = indexes[1:]
            if len(indexes) == 0 {
                break
            }
        }
        i++
    }
}

func (self *BlockPool) getPeer(peerId string) (*peerInfo, bool) {
    self.peersLock.RLock()
    defer self.peersLock.RUnlock()
    if self.peer != nil && self.peer.id == peerId {
        return self.peer, true
    }
    info, ok := self.peers[peerId]
    if !ok {
        panic("unknown peer")
    }
    return info, false
}

func (self *peerInfo) addSection(hash []byte, section *section) {
    self.lock.Lock()
    defer self.lock.Unlock()
    self.sections[string(hash)] = section
}

func (self *peerInfo) addRoot(node *poolNode) {
    self.lock.Lock()
    defer self.lock.Unlock()
    self.roots = append(self.roots, node)
}

// (re)starts processes registered for this peer (self)
func (self *peerInfo) start(peer *peerInfo) {
    self.lock.Lock()
    defer self.lock.Unlock()
    self.quitC = make(chan bool)
    for _, root := range self.roots {
        root.sectionRLock()
        if root.section.bottom != nil {
            if root.parent == nil {
                self.requestBlockHashes(root.hash)
            }
        }
        root.sectionRUnlock()
    }
    self.roots = nil
    self.controlSections(peer, true)
}

//  (re)starts process without requests, only suicide timer
func (self *peerInfo) stop(peer *peerInfo) {
    self.lock.RLock()
    defer self.lock.RUnlock()
    close(self.quitC)
    self.controlSections(peer, false)
}

func (self *peerInfo) controlSections(peer *peerInfo, on bool) {
    if peer != nil {
        peer.lock.RLock()
        defer peer.lock.RUnlock()
    }
    for hash, section := range peer.sections {
        if section.done() {
            delete(self.sections, hash)
        }
        _, exists := peer.sections[hash]
        if on || peer == nil || exists {
            if on {
                // self is best peer
                section.start()
            } else {
                //  (re)starts process without requests, only suicide timer
                section.stop()
            }
        }
    }
}

// called when parent is found in pool
// parent and child are guaranteed to be on different sections
func (self *BlockPool) link(parent, child *poolNode) {
    var top bool
    parent.sectionLock()
    if child != nil {
        child.sectionLock()
    }
    if parent == parent.section.top && parent.section.top != nil {
        top = true
    }
    var bottom bool

    if child == child.section.bottom {
        bottom = true
    }
    if parent.child != child {
        orphan := parent.child
        if orphan != nil {
            // got a fork in the chain
            if top {
                orphan.lock.Lock()
                // make old child orphan
                orphan.parent = nil
                orphan.lock.Unlock()
            } else { // we are under section lock
                // make old child orphan
                orphan.parent = nil
                // reset section objects above the fork
                nchild := orphan.child
                node := orphan
                section := &section{bottom: orphan}
                for node.section == nchild.section {
                    node = nchild
                    node.section = section
                    nchild = node.child
                }
                section.top = node
                // set up a suicide
                self.processSection(orphan).stop()
            }
        } else {
            // child is on top of a chain need to close section
            child.section.bottom = child
        }
        // adopt new child
        parent.child = child
        if !top {
            parent.section.top = parent
            // restart section process so that shorter section is scanned for blocks
            parent.section.reset()
        }
    }

    if child != nil {
        if child.parent != parent {
            stepParent := child.parent
            if stepParent != nil {
                if bottom {
                    stepParent.Lock()
                    stepParent.child = nil
                    stepParent.Unlock()
                } else {
                    // we are on the same section
                    // if it is a aberrant reverse fork,
                    stepParent.child = nil
                    node := stepParent
                    nparent := stepParent.child
                    section := &section{top: stepParent}
                    for node.section == nparent.section {
                        node = nparent
                        node.section = section
                        node = node.parent
                    }
                }
            } else {
                // linking to a root node, ie. parent is under the root of a chain
                parent.section.top = parent
            }
        }
        child.parent = parent
        child.section.bottom = child
    }
    // this needed if someone lied about the parent before
    child.knownParent = false

    parent.sectionUnlock()
    if child != nil {
        child.sectionUnlock()
    }
}

// this immediately kills the chain from node to end (inclusive) section by section
func (self *BlockPool) killChain(node *poolNode, end *poolNode) {
    poolLogger.Debugf("kill chain section with root node %v", node)

    node.sectionLock()
    node.section.abort()
    self.set(node.hash, nil)
    child := node.child
    top := node.section.top
    i := 1
    self.wg.Add(1)
    go func() {
        var quit bool
        for node != top && node != end && child != nil {
            node = child
            select {
            case <-self.quit:
                quit = true
                break
            default:
            }
            self.set(node.hash, nil)
            child = node.child
        }
        poolLogger.Debugf("killed chain section of %v blocks with root node %v", i, node)
        if !quit {
            if node == top {
                if node != end && child != nil && end != nil {
                    //
                    self.killChain(child, end)
                }
            } else {
                if child != nil {
                    // delink rest of this section if ended midsection
                    child.section.bottom = child
                    child.parent = nil
                }
            }
        }
        node.section.bottom = nil
        node.sectionUnlock()
        self.wg.Done()
    }()
}

// structure to store long range links on chain to skip along
type section struct {
    lock     sync.RWMutex
    bottom   *poolNode
    top      *poolNode
    controlC chan bool
    resetC   chan bool
}

func (self *section) start() {
    self.lock.RLock()
    defer self.lock.RUnlock()
    if self.controlC != nil {
        self.controlC <- true
    }
}

func (self *section) stop() {
    self.lock.RLock()
    defer self.lock.RUnlock()
    if self.controlC != nil {
        self.controlC <- false
    }
}

func (self *section) reset() {
    self.lock.RLock()
    defer self.lock.RUnlock()
    if self.controlC != nil {
        self.resetC <- true
        self.controlC <- false
    }
}

func (self *section) abort() {
    self.lock.Lock()
    defer self.lock.Unlock()
    if self.controlC != nil {
        close(self.controlC)
        self.controlC = nil
    }
}

func (self *section) done() bool {
    self.lock.Lock()
    defer self.lock.Unlock()
    if self.controlC != nil {
        return true
    }
    return false
}

func (self *BlockPool) get(hash []byte) (node *poolNode) {
    self.lock.Lock()
    defer self.lock.Unlock()
    return self.pool[string(hash)]
}

func (self *BlockPool) set(hash []byte, node *poolNode) {
    self.lock.Lock()
    defer self.lock.Unlock()
    self.pool[string(hash)] = node
}

// first time for block request, this iteration retrieves nodes of the chain
// from node up to top (all the way if nil) via child links
// copies the controller
// and feeds nodeC channel
// this is performed under section readlock to prevent top from going away
// when
func (self *BlockPool) foldUp(node *poolNode, nodeC chan *poolNode) {
    self.wg.Add(1)
    go func() {
        node.sectionRLock()
        defer node.sectionRUnlock()
        for node != nil {
            select {
            case <-self.quit:
                break
            case nodeC <- node:
                if node == node.section.top {
                    break
                }
                node = node.child
            }
        }
        close(nodeC)
        self.wg.Done()
    }()
}

func (self *poolNode) Lock() {
    self.sectionLock()
    self.lock.Lock()
}

func (self *poolNode) Unlock() {
    self.lock.Unlock()
    self.sectionUnlock()
}

func (self *poolNode) RLock() {
    self.lock.RLock()
}

func (self *poolNode) RUnlock() {
    self.lock.RUnlock()
}

func (self *poolNode) sectionLock() {
    self.lock.RLock()
    defer self.lock.RUnlock()
    self.section.lock.Lock()
}

func (self *poolNode) sectionUnlock() {
    self.lock.RLock()
    defer self.lock.RUnlock()
    self.section.lock.Unlock()
}

func (self *poolNode) sectionRLock() {
    self.lock.RLock()
    defer self.lock.RUnlock()
    self.section.lock.RLock()
}

func (self *poolNode) sectionRUnlock() {
    self.lock.RLock()
    defer self.lock.RUnlock()
    self.section.lock.RUnlock()
}