2015-02-25 04:34:12 -08:00
package blockpool
import (
"math/big"
"math/rand"
"sort"
"sync"
"time"
2015-03-19 16:33:52 -07:00
"github.com/ethereum/go-ethereum/common"
2015-02-25 04:34:12 -08:00
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/errs"
)
2015-03-19 16:14:08 -07:00
// the blockpool's model of a peer
2015-02-25 04:34:12 -08:00
type peer struct {
lock sync . RWMutex
// last known blockchain status
td * big . Int
2015-03-16 15:10:26 -07:00
currentBlockHash common . Hash
2015-02-25 04:34:12 -08:00
currentBlock * types . Block
2015-03-16 15:10:26 -07:00
parentHash common . Hash
2015-02-25 04:34:12 -08:00
headSection * section
id string
// peer callbacks
2015-03-16 15:10:26 -07:00
requestBlockHashes func ( common . Hash ) error
requestBlocks func ( [ ] common . Hash ) error
2015-02-25 04:34:12 -08:00
peerError func ( * errs . Error )
errors * errs . Errors
2015-03-16 15:10:26 -07:00
sections [ ] common . Hash
2015-02-25 04:34:12 -08:00
// channels to push new head block and head section for peer a
currentBlockC chan * types . Block
headSectionC chan * section
2015-03-03 11:06:15 -08:00
// channels to signal peer switch and peer quit to section processes
2015-02-25 04:34:12 -08:00
idleC chan bool
switchC chan bool
2015-03-05 10:33:57 -08:00
bp * BlockPool
2015-02-25 04:34:12 -08:00
// timers for head section process
blockHashesRequestTimer <- chan time . Time
blocksRequestTimer <- chan time . Time
2015-03-20 13:52:29 -07:00
headInfoTimer <- chan time . Time
bestIdleTimer <- chan time . Time
2015-02-25 04:34:12 -08:00
2015-03-19 15:46:54 -07:00
addToBlacklist func ( id string )
2015-02-25 04:34:12 -08:00
idle bool
}
// peers is the component keeping a record of peers in a hashmap
//
type peers struct {
lock sync . RWMutex
2015-03-19 15:46:54 -07:00
bp * BlockPool
errors * errs . Errors
peers map [ string ] * peer
best * peer
status * status
blacklist map [ string ] time . Time
2015-02-25 04:34:12 -08:00
}
// peer constructor
func ( self * peers ) newPeer (
td * big . Int ,
2015-03-16 15:10:26 -07:00
currentBlockHash common . Hash ,
2015-02-25 04:34:12 -08:00
id string ,
2015-03-16 15:10:26 -07:00
requestBlockHashes func ( common . Hash ) error ,
requestBlocks func ( [ ] common . Hash ) error ,
2015-02-25 04:34:12 -08:00
peerError func ( * errs . Error ) ,
) ( p * peer ) {
p = & peer {
errors : self . errors ,
td : td ,
currentBlockHash : currentBlockHash ,
id : id ,
requestBlockHashes : requestBlockHashes ,
requestBlocks : requestBlocks ,
peerError : peerError ,
currentBlockC : make ( chan * types . Block ) ,
headSectionC : make ( chan * section ) ,
bp : self . bp ,
idle : true ,
2015-03-19 15:46:54 -07:00
addToBlacklist : self . addToBlacklist ,
2015-02-25 04:34:12 -08:00
}
// at creation the peer is recorded in the peer pool
self . peers [ id ] = p
return
}
2015-03-19 15:46:54 -07:00
// dispatches an error to a peer if still connected, adds it to the blacklist
2015-02-25 04:34:12 -08:00
func ( self * peers ) peerError ( id string , code int , format string , params ... interface { } ) {
self . lock . RLock ( )
peer , ok := self . peers [ id ]
2015-03-19 15:46:54 -07:00
self . lock . RUnlock ( )
2015-02-25 04:34:12 -08:00
if ok {
peer . addError ( code , format , params )
}
2015-03-19 15:46:54 -07:00
self . addToBlacklist ( id )
}
2015-03-19 16:14:08 -07:00
// record time of offence in blacklist to implement suspension for PeerSuspensionInterval
2015-03-19 15:46:54 -07:00
func ( self * peers ) addToBlacklist ( id string ) {
self . lock . Lock ( )
defer self . lock . Unlock ( )
self . blacklist [ id ] = time . Now ( )
}
2015-03-19 16:14:08 -07:00
// suspended checks if peer is still suspended
2015-03-19 15:46:54 -07:00
func ( self * peers ) suspended ( id string ) ( s bool ) {
self . lock . Lock ( )
defer self . lock . Unlock ( )
if suspendedAt , ok := self . blacklist [ id ] ; ok {
if s = suspendedAt . Add ( self . bp . Config . PeerSuspensionInterval ) . After ( time . Now ( ) ) ; ! s {
// no longer suspended, delete entry
delete ( self . blacklist , id )
}
}
return
2015-02-25 04:34:12 -08:00
}
func ( self * peer ) addError ( code int , format string , params ... interface { } ) {
err := self . errors . New ( code , format , params ... )
self . peerError ( err )
2015-03-19 15:46:54 -07:00
self . addToBlacklist ( self . id )
2015-02-25 04:34:12 -08:00
}
2015-04-02 08:30:48 -07:00
// caller must hold peer lock
2015-03-16 15:10:26 -07:00
func ( self * peer ) setChainInfo ( td * big . Int , c common . Hash ) {
2015-02-25 04:34:12 -08:00
self . td = td
self . currentBlockHash = c
self . currentBlock = nil
2015-03-16 15:10:26 -07:00
self . parentHash = common . Hash { }
2015-02-25 04:34:12 -08:00
self . headSection = nil
}
func ( self * peer ) setChainInfoFromBlock ( block * types . Block ) {
self . lock . Lock ( )
defer self . lock . Unlock ( )
// use the optional TD to update peer td, this helps second best peer selection
// in case best peer is lost
if block . Td != nil && block . Td . Cmp ( self . td ) > 0 {
plog . DebugDetailf ( "setChainInfoFromBlock: update <%s> - head: %v->%v - TD: %v->%v" , self . id , hex ( self . currentBlockHash ) , hex ( block . Hash ( ) ) , self . td , block . Td )
self . td = block . Td
self . currentBlockHash = block . Hash ( )
self . parentHash = block . ParentHash ( )
self . currentBlock = block
self . headSection = nil
}
self . bp . wg . Add ( 1 )
go func ( ) {
self . currentBlockC <- block
self . bp . wg . Done ( )
} ( )
}
2015-03-19 16:14:08 -07:00
// distribute block request among known peers
2015-03-16 15:10:26 -07:00
func ( self * peers ) requestBlocks ( attempts int , hashes [ ] common . Hash ) {
2015-02-25 04:34:12 -08:00
self . lock . RLock ( )
defer self . lock . RUnlock ( )
peerCount := len ( self . peers )
// on first attempt use the best peer
2015-04-02 08:30:48 -07:00
if attempts == 0 && self . best != nil {
2015-02-25 04:34:12 -08:00
plog . DebugDetailf ( "request %v missing blocks from best peer <%s>" , len ( hashes ) , self . best . id )
self . best . requestBlocks ( hashes )
return
}
repetitions := self . bp . Config . BlocksRequestRepetition
if repetitions > peerCount {
repetitions = peerCount
}
i := 0
indexes := rand . Perm ( peerCount ) [ 0 : repetitions ]
sort . Ints ( indexes )
plog . DebugDetailf ( "request %v missing blocks from %v/%v peers" , len ( hashes ) , repetitions , peerCount )
for _ , peer := range self . peers {
if i == indexes [ 0 ] {
plog . DebugDetailf ( "request length: %v" , len ( hashes ) )
plog . DebugDetailf ( "request %v missing blocks [%x/%x] from peer <%s>" , len ( hashes ) , hashes [ 0 ] [ : 4 ] , hashes [ len ( hashes ) - 1 ] [ : 4 ] , peer . id )
peer . requestBlocks ( hashes )
indexes = indexes [ 1 : ]
if len ( indexes ) == 0 {
break
}
}
i ++
}
self . bp . putHashSlice ( hashes )
}
// addPeer implements the logic for blockpool.AddPeer
2015-03-19 16:14:08 -07:00
// returns 2 bool values
// 1. true iff peer is promoted as best peer in the pool
// 2. true iff peer is still suspended
2015-02-25 04:34:12 -08:00
func ( self * peers ) addPeer (
td * big . Int ,
2015-03-16 15:10:26 -07:00
currentBlockHash common . Hash ,
2015-02-25 04:34:12 -08:00
id string ,
2015-03-16 15:10:26 -07:00
requestBlockHashes func ( common . Hash ) error ,
requestBlocks func ( [ ] common . Hash ) error ,
2015-02-25 04:34:12 -08:00
peerError func ( * errs . Error ) ,
2015-03-19 15:46:54 -07:00
) ( best bool , suspended bool ) {
2015-02-25 04:34:12 -08:00
2015-03-16 15:10:26 -07:00
var previousBlockHash common . Hash
2015-03-19 15:46:54 -07:00
if self . suspended ( id ) {
suspended = true
return
}
2015-02-25 04:34:12 -08:00
self . lock . Lock ( )
2015-04-02 07:32:41 -07:00
defer self . lock . Unlock ( )
2015-02-25 04:34:12 -08:00
p , found := self . peers [ id ]
if found {
2015-03-19 16:14:08 -07:00
// when called on an already connected peer, it means a newBlockMsg is received
// peer head info is updated
2015-04-02 08:30:48 -07:00
p . lock . Lock ( )
2015-03-16 15:10:26 -07:00
if p . currentBlockHash != currentBlockHash {
2015-02-25 04:34:12 -08:00
previousBlockHash = p . currentBlockHash
plog . Debugf ( "addPeer: Update peer <%s> with td %v and current block %s (was %v)" , id , td , hex ( currentBlockHash ) , hex ( previousBlockHash ) )
p . setChainInfo ( td , currentBlockHash )
2015-03-19 16:14:08 -07:00
2015-02-25 04:34:12 -08:00
self . status . lock . Lock ( )
self . status . values . NewBlocks ++
self . status . lock . Unlock ( )
}
2015-04-02 08:30:48 -07:00
p . lock . Unlock ( )
2015-02-25 04:34:12 -08:00
} else {
p = self . newPeer ( td , currentBlockHash , id , requestBlockHashes , requestBlocks , peerError )
self . status . lock . Lock ( )
self . status . peers [ id ] ++
self . status . values . NewBlocks ++
self . status . lock . Unlock ( )
plog . Debugf ( "addPeer: add new peer <%v> with td %v and current block %s" , id , td , hex ( currentBlockHash ) )
}
2015-03-19 16:14:08 -07:00
// check if peer's current head block is known
2015-02-25 04:34:12 -08:00
if self . bp . hasBlock ( currentBlockHash ) {
// peer not ahead
2015-03-02 12:39:21 -08:00
plog . Debugf ( "addPeer: peer <%v> with td %v and current block %s is behind" , id , td , hex ( currentBlockHash ) )
2015-03-19 15:46:54 -07:00
return false , false
2015-02-25 04:34:12 -08:00
}
if self . best == p {
// new block update for active current best peer -> request hashes
plog . Debugf ( "addPeer: <%s> already the best peer. Request new head section info from %s" , id , hex ( currentBlockHash ) )
2015-03-16 15:10:26 -07:00
if ( previousBlockHash != common . Hash { } ) {
2015-03-20 13:52:29 -07:00
plog . DebugDetailf ( "addPeer: <%s> head changed: %s -> %s " , id , hex ( previousBlockHash ) , hex ( currentBlockHash ) )
p . headSectionC <- nil
2015-02-25 04:34:12 -08:00
if entry := self . bp . get ( previousBlockHash ) ; entry != nil {
2015-03-20 13:52:29 -07:00
plog . DebugDetailf ( "addPeer: <%s> previous head : %v found in pool, activate" , id , hex ( previousBlockHash ) )
2015-02-25 04:34:12 -08:00
self . bp . activateChain ( entry . section , p , nil )
p . sections = append ( p . sections , previousBlockHash )
}
}
best = true
} else {
2015-03-19 16:14:08 -07:00
// baseline is our own TD
2015-03-19 15:53:15 -07:00
currentTD := self . bp . getTD ( )
2015-04-02 07:32:41 -07:00
bestpeer := self . best
if bestpeer != nil {
bestpeer . lock . Lock ( )
defer bestpeer . lock . Unlock ( )
2015-02-25 04:34:12 -08:00
currentTD = self . best . td
}
if td . Cmp ( currentTD ) > 0 {
self . status . lock . Lock ( )
self . status . bestPeers [ p . id ] ++
self . status . lock . Unlock ( )
2015-03-19 15:53:15 -07:00
plog . Debugf ( "addPeer: peer <%v> (td: %v > current td %v) promoted best peer" , id , td , currentTD )
2015-04-02 07:32:41 -07:00
self . bp . switchPeer ( bestpeer , p )
2015-02-25 04:34:12 -08:00
self . best = p
best = true
}
}
2015-04-02 07:32:41 -07:00
2015-02-25 04:34:12 -08:00
return
}
// removePeer is called (via RemovePeer) by the eth protocol when the peer disconnects
func ( self * peers ) removePeer ( id string ) {
self . lock . Lock ( )
defer self . lock . Unlock ( )
p , found := self . peers [ id ]
if ! found {
return
}
delete ( self . peers , id )
2015-03-19 15:53:15 -07:00
plog . Debugf ( "addPeer: remove peer <%v> (td: %v)" , id , p . td )
2015-02-25 04:34:12 -08:00
// if current best peer is removed, need to find a better one
if self . best == p {
var newp * peer
2015-03-19 15:53:15 -07:00
// only peers that are ahead of us are considered
max := self . bp . getTD ( )
2015-02-25 04:34:12 -08:00
// peer with the highest self-acclaimed TD is chosen
for _ , pp := range self . peers {
if pp . td . Cmp ( max ) > 0 {
max = pp . td
newp = pp
}
}
if newp != nil {
self . status . lock . Lock ( )
self . status . bestPeers [ p . id ] ++
self . status . lock . Unlock ( )
2015-03-19 15:53:15 -07:00
plog . Debugf ( "addPeer: peer <%v> (td: %v) promoted best peer" , newp . id , newp . td )
2015-02-25 04:34:12 -08:00
} else {
plog . Warnln ( "addPeer: no suitable peers found" )
}
self . best = newp
self . bp . switchPeer ( p , newp )
}
}
2015-03-03 11:06:15 -08:00
// switchPeer launches section processes
2015-02-25 04:34:12 -08:00
func ( self * BlockPool ) switchPeer ( oldp , newp * peer ) {
// first quit AddBlockHashes, requestHeadSection and activateChain
2015-03-19 16:14:08 -07:00
// by closing the old peer's switchC channel
2015-02-25 04:34:12 -08:00
if oldp != nil {
plog . DebugDetailf ( "<%s> quit peer processes" , oldp . id )
close ( oldp . switchC )
}
if newp != nil {
newp . idleC = make ( chan bool )
newp . switchC = make ( chan bool )
// if new best peer has no head section yet, create it and run it
// otherwise head section is an element of peer.sections
if newp . headSection == nil {
plog . DebugDetailf ( "[%s] head section for [%s] not created, requesting info" , newp . id , hex ( newp . currentBlockHash ) )
if newp . idle {
self . wg . Add ( 1 )
newp . idle = false
self . syncing ( )
}
go func ( ) {
newp . run ( )
if ! newp . idle {
self . wg . Done ( )
newp . idle = true
}
} ( )
}
2015-03-25 04:09:50 -07:00
var connected = make ( map [ common . Hash ] * section )
2015-03-16 15:10:26 -07:00
var sections [ ] common . Hash
2015-02-25 04:34:12 -08:00
for _ , hash := range newp . sections {
plog . DebugDetailf ( "activate chain starting from section [%s]" , hex ( hash ) )
// if section not connected (ie, top of a contiguous sequence of sections)
2015-03-25 04:09:50 -07:00
if connected [ hash ] == nil {
2015-02-25 04:34:12 -08:00
// if not deleted, then reread from pool (it can be orphaned top half of a split section)
if entry := self . get ( hash ) ; entry != nil {
self . activateChain ( entry . section , newp , connected )
2015-03-25 04:09:50 -07:00
connected [ hash ] = entry . section
2015-02-25 04:34:12 -08:00
sections = append ( sections , hash )
}
}
}
plog . DebugDetailf ( "<%s> section processes (%v non-contiguous sequences, was %v before)" , newp . id , len ( sections ) , len ( newp . sections ) )
// need to lock now that newp is exposed to section processes
newp . lock . Lock ( )
newp . sections = sections
newp . lock . Unlock ( )
}
// finally deactivate section process for sections where newp didnt activate
// newp activating section process changes the quit channel for this reason
if oldp != nil {
plog . DebugDetailf ( "<%s> quit section processes" , oldp . id )
close ( oldp . idleC )
}
}
2015-03-19 16:14:08 -07:00
// getPeer looks up peer by id, returns peer and a bool value
// that is true iff peer is current best peer
2015-02-25 04:34:12 -08:00
func ( self * peers ) getPeer ( id string ) ( p * peer , best bool ) {
self . lock . RLock ( )
defer self . lock . RUnlock ( )
if self . best != nil && self . best . id == id {
return self . best , true
}
p = self . peers [ id ]
return
}
2015-03-19 16:14:08 -07:00
// head section process
2015-02-25 04:34:12 -08:00
func ( self * peer ) handleSection ( sec * section ) {
self . lock . Lock ( )
defer self . lock . Unlock ( )
2015-03-05 10:33:57 -08:00
plog . DebugDetailf ( "HeadSection: <%s> (head: %s) head section received [%s]-[%s]" , self . id , hex ( self . currentBlockHash ) , sectionhex ( self . headSection ) , sectionhex ( sec ) )
2015-02-25 04:34:12 -08:00
self . headSection = sec
self . blockHashesRequestTimer = nil
if sec == nil {
if self . idle {
self . idle = false
self . bp . wg . Add ( 1 )
self . bp . syncing ( )
}
2015-03-20 13:52:29 -07:00
self . headInfoTimer = time . After ( self . bp . Config . BlockHashesTimeout )
self . bestIdleTimer = nil
2015-02-25 04:34:12 -08:00
plog . DebugDetailf ( "HeadSection: <%s> head block hash changed (mined block received). New head %s" , self . id , hex ( self . currentBlockHash ) )
} else {
if ! self . idle {
self . idle = true
self . bp . wg . Done ( )
}
2015-03-20 13:52:29 -07:00
self . headInfoTimer = nil
self . bestIdleTimer = time . After ( self . bp . Config . IdleBestPeerTimeout )
plog . DebugDetailf ( "HeadSection: <%s> (head: %s) head section [%s] created. Idle..." , self . id , hex ( self . currentBlockHash ) , sectionhex ( sec ) )
2015-02-25 04:34:12 -08:00
}
}
func ( self * peer ) getCurrentBlock ( currentBlock * types . Block ) {
// called by update or after AddBlock signals that head block of current peer is received
if currentBlock == nil {
if entry := self . bp . get ( self . currentBlockHash ) ; entry != nil {
entry . node . lock . Lock ( )
currentBlock = entry . node . block
entry . node . lock . Unlock ( )
}
if currentBlock != nil {
plog . DebugDetailf ( "HeadSection: <%s> head block %s found in blockpool" , self . id , hex ( self . currentBlockHash ) )
} else {
plog . DebugDetailf ( "HeadSection: <%s> head block %s not found... requesting it" , self . id , hex ( self . currentBlockHash ) )
2015-03-16 15:10:26 -07:00
self . requestBlocks ( [ ] common . Hash { self . currentBlockHash } )
2015-02-25 04:34:12 -08:00
self . blocksRequestTimer = time . After ( self . bp . Config . BlocksRequestInterval )
return
}
} else {
plog . DebugDetailf ( "HeadSection: <%s> head block %s received (parent: %s)" , self . id , hex ( self . currentBlockHash ) , hex ( currentBlock . ParentHash ( ) ) )
}
self . lock . Lock ( )
defer self . lock . Unlock ( )
self . currentBlock = currentBlock
self . parentHash = currentBlock . ParentHash ( )
2015-03-05 10:33:57 -08:00
plog . DebugDetailf ( "HeadSection: <%s> head block %s found (parent: %s)... requesting hashes" , self . id , hex ( self . currentBlockHash ) , hex ( self . parentHash ) )
2015-02-25 04:34:12 -08:00
self . blockHashesRequestTimer = time . After ( 0 )
self . blocksRequestTimer = nil
}
2015-03-20 13:52:29 -07:00
func ( self * peer ) getBlockHashes ( ) bool {
2015-02-25 04:34:12 -08:00
//if connecting parent is found
if self . bp . hasBlock ( self . parentHash ) {
plog . DebugDetailf ( "HeadSection: <%s> parent block %s found in blockchain" , self . id , hex ( self . parentHash ) )
err := self . bp . insertChain ( types . Blocks ( [ ] * types . Block { self . currentBlock } ) )
2015-03-05 10:33:57 -08:00
self . bp . status . lock . Lock ( )
self . bp . status . values . BlocksInChain ++
self . bp . status . values . BlocksInPool --
2015-02-25 04:34:12 -08:00
if err != nil {
self . addError ( ErrInvalidBlock , "%v" , err )
self . bp . status . badPeers [ self . id ] ++
2015-03-05 10:33:57 -08:00
} else {
2015-03-23 10:27:05 -07:00
// XXX added currentBlock check (?)
if self . currentBlock != nil && self . currentBlock . Td != nil {
2015-03-19 16:00:19 -07:00
if self . td . Cmp ( self . currentBlock . Td ) != 0 {
self . addError ( ErrIncorrectTD , "on block %x" , self . currentBlockHash )
2015-03-20 13:52:29 -07:00
self . bp . status . badPeers [ self . id ] ++
2015-03-19 16:00:19 -07:00
}
}
2015-03-20 13:52:29 -07:00
headKey := self . parentHash
2015-03-19 16:33:52 -07:00
height := self . bp . status . chain [ headKey ] + 1
2015-03-20 13:52:29 -07:00
self . bp . status . chain [ self . currentBlockHash ] = height
2015-03-05 10:33:57 -08:00
if height > self . bp . status . values . LongestChain {
self . bp . status . values . LongestChain = height
}
delete ( self . bp . status . chain , headKey )
2015-02-25 04:34:12 -08:00
}
2015-03-05 10:33:57 -08:00
self . bp . status . lock . Unlock ( )
2015-02-25 04:34:12 -08:00
} else {
if parent := self . bp . get ( self . parentHash ) ; parent != nil {
if self . bp . get ( self . currentBlockHash ) == nil {
plog . DebugDetailf ( "HeadSection: <%s> connecting parent %s found in pool... creating singleton section" , self . id , hex ( self . parentHash ) )
n := & node {
hash : self . currentBlockHash ,
block : self . currentBlock ,
hashBy : self . id ,
blockBy : self . id ,
2015-03-19 16:00:19 -07:00
td : self . td ,
2015-02-25 04:34:12 -08:00
}
self . bp . newSection ( [ ] * node { n } ) . activate ( self )
} else {
plog . DebugDetailf ( "HeadSection: <%s> connecting parent %s found in pool...head section [%s] exists...not requesting hashes" , self . id , hex ( self . parentHash ) , sectionhex ( parent . section ) )
self . bp . activateChain ( parent . section , self , nil )
}
} else {
plog . DebugDetailf ( "HeadSection: <%s> section [%s] requestBlockHashes" , self . id , sectionhex ( self . headSection ) )
self . requestBlockHashes ( self . currentBlockHash )
self . blockHashesRequestTimer = time . After ( self . bp . Config . BlockHashesRequestInterval )
2015-03-20 13:52:29 -07:00
return false
2015-02-25 04:34:12 -08:00
}
}
self . blockHashesRequestTimer = nil
if ! self . idle {
self . idle = true
2015-03-20 13:52:29 -07:00
self . headInfoTimer = nil
self . bestIdleTimer = time . After ( self . bp . Config . IdleBestPeerTimeout )
2015-02-25 04:34:12 -08:00
self . bp . wg . Done ( )
}
2015-03-20 13:52:29 -07:00
return true
2015-02-25 04:34:12 -08:00
}
// main loop for head section process
func ( self * peer ) run ( ) {
self . lock . RLock ( )
switchC := self . switchC
self . lock . RUnlock ( )
self . blockHashesRequestTimer = nil
self . blocksRequestTimer = time . After ( 0 )
2015-03-20 13:52:29 -07:00
self . headInfoTimer = time . After ( self . bp . Config . BlockHashesTimeout )
2015-03-25 04:09:50 -07:00
self . bestIdleTimer = nil
2015-02-25 04:34:12 -08:00
var ping = time . NewTicker ( 5 * time . Second )
LOOP :
for {
select {
2015-03-19 16:14:08 -07:00
// to minitor section process behaviour
2015-02-25 04:34:12 -08:00
case <- ping . C :
plog . Debugf ( "HeadSection: <%s> section with head %s, idle: %v" , self . id , hex ( self . currentBlockHash ) , self . idle )
// signal from AddBlockHashes that head section for current best peer is created
// if sec == nil, it signals that chain info has updated (new block message)
case sec := <- self . headSectionC :
self . handleSection ( sec )
// periodic check for block hashes or parent block/section
case <- self . blockHashesRequestTimer :
self . getBlockHashes ( )
// signal from AddBlock that head block of current best peer has been received
case currentBlock := <- self . currentBlockC :
self . getCurrentBlock ( currentBlock )
// keep requesting until found or timed out
case <- self . blocksRequestTimer :
self . getCurrentBlock ( nil )
// quitting on timeout
2015-03-20 13:52:29 -07:00
case <- self . headInfoTimer :
2015-03-05 10:33:57 -08:00
self . peerError ( self . bp . peers . errors . New ( ErrInsufficientChainInfo , "timed out without providing block hashes or head block (td: %v, head: %s)" , self . td , hex ( self . currentBlockHash ) ) )
2015-02-25 04:34:12 -08:00
self . bp . status . lock . Lock ( )
self . bp . status . badPeers [ self . id ] ++
self . bp . status . lock . Unlock ( )
// there is no persistence here, so GC will just take care of cleaning up
break LOOP
// signal for peer switch, quit
case <- switchC :
var complete = "incomplete "
if self . idle {
complete = "complete"
}
plog . Debugf ( "HeadSection: <%s> section with head %s %s... quit request loop due to peer switch" , self . id , hex ( self . currentBlockHash ) , complete )
break LOOP
// global quit for blockpool
case <- self . bp . quit :
break LOOP
2015-03-25 04:09:50 -07:00
// best
2015-03-20 13:52:29 -07:00
case <- self . bestIdleTimer :
2015-03-18 13:30:34 -07:00
self . peerError ( self . bp . peers . errors . New ( ErrIdleTooLong , "timed out without providing new blocks (td: %v, head: %s)...quitting" , self . td , hex ( self . currentBlockHash ) ) )
2015-03-05 10:33:57 -08:00
self . bp . status . lock . Lock ( )
self . bp . status . badPeers [ self . id ] ++
self . bp . status . lock . Unlock ( )
plog . Debugf ( "HeadSection: <%s> (headsection [%s]) quit channel closed : timed out without providing new blocks...quitting" , self . id , sectionhex ( self . headSection ) )
2015-02-25 04:34:12 -08:00
break LOOP
}
}
if ! self . idle {
self . idle = true
self . bp . wg . Done ( )
}
}