github.com/murrekatt/go-ethereum@v1.5.8-0.20170123175102-fc52f2c007fb/eth/sync.go (about) 1 // Copyright 2015 The go-ethereum Authors 2 // This file is part of the go-ethereum library. 3 // 4 // The go-ethereum library is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU Lesser General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // The go-ethereum library is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU Lesser General Public License for more details. 13 // 14 // You should have received a copy of the GNU Lesser General Public License 15 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. 16 17 package eth 18 19 import ( 20 "math/rand" 21 "sync/atomic" 22 "time" 23 24 "github.com/ethereum/go-ethereum/common" 25 "github.com/ethereum/go-ethereum/core/types" 26 "github.com/ethereum/go-ethereum/eth/downloader" 27 "github.com/ethereum/go-ethereum/logger" 28 "github.com/ethereum/go-ethereum/logger/glog" 29 "github.com/ethereum/go-ethereum/p2p/discover" 30 ) 31 32 const ( 33 forceSyncCycle = 10 * time.Second // Time interval to force syncs, even if few peers are available 34 minDesiredPeerCount = 5 // Amount of peers desired to start syncing 35 36 // This is the target size for the packs of transactions sent by txsyncLoop. 37 // A pack can get larger than this if a single transactions exceeds this size. 38 txsyncPackSize = 100 * 1024 39 ) 40 41 type txsync struct { 42 p *peer 43 txs []*types.Transaction 44 } 45 46 // syncTransactions starts sending all currently pending transactions to the given peer. 47 func (pm *ProtocolManager) syncTransactions(p *peer) { 48 var txs types.Transactions 49 pending, _ := pm.txpool.Pending() 50 for _, batch := range pending { 51 txs = append(txs, batch...) 52 } 53 if len(txs) == 0 { 54 return 55 } 56 select { 57 case pm.txsyncCh <- &txsync{p, txs}: 58 case <-pm.quitSync: 59 } 60 } 61 62 // txsyncLoop takes care of the initial transaction sync for each new 63 // connection. When a new peer appears, we relay all currently pending 64 // transactions. In order to minimise egress bandwidth usage, we send 65 // the transactions in small packs to one peer at a time. 66 func (pm *ProtocolManager) txsyncLoop() { 67 var ( 68 pending = make(map[discover.NodeID]*txsync) 69 sending = false // whether a send is active 70 pack = new(txsync) // the pack that is being sent 71 done = make(chan error, 1) // result of the send 72 ) 73 74 // send starts a sending a pack of transactions from the sync. 75 send := func(s *txsync) { 76 // Fill pack with transactions up to the target size. 77 size := common.StorageSize(0) 78 pack.p = s.p 79 pack.txs = pack.txs[:0] 80 for i := 0; i < len(s.txs) && size < txsyncPackSize; i++ { 81 pack.txs = append(pack.txs, s.txs[i]) 82 size += s.txs[i].Size() 83 } 84 // Remove the transactions that will be sent. 85 s.txs = s.txs[:copy(s.txs, s.txs[len(pack.txs):])] 86 if len(s.txs) == 0 { 87 delete(pending, s.p.ID()) 88 } 89 // Send the pack in the background. 90 glog.V(logger.Detail).Infof("%v: sending %d transactions (%v)", s.p.Peer, len(pack.txs), size) 91 sending = true 92 go func() { done <- pack.p.SendTransactions(pack.txs) }() 93 } 94 95 // pick chooses the next pending sync. 96 pick := func() *txsync { 97 if len(pending) == 0 { 98 return nil 99 } 100 n := rand.Intn(len(pending)) + 1 101 for _, s := range pending { 102 if n--; n == 0 { 103 return s 104 } 105 } 106 return nil 107 } 108 109 for { 110 select { 111 case s := <-pm.txsyncCh: 112 pending[s.p.ID()] = s 113 if !sending { 114 send(s) 115 } 116 case err := <-done: 117 sending = false 118 // Stop tracking peers that cause send failures. 119 if err != nil { 120 glog.V(logger.Debug).Infof("%v: tx send failed: %v", pack.p.Peer, err) 121 delete(pending, pack.p.ID()) 122 } 123 // Schedule the next send. 124 if s := pick(); s != nil { 125 send(s) 126 } 127 case <-pm.quitSync: 128 return 129 } 130 } 131 } 132 133 // syncer is responsible for periodically synchronising with the network, both 134 // downloading hashes and blocks as well as handling the announcement handler. 135 func (pm *ProtocolManager) syncer() { 136 // Start and ensure cleanup of sync mechanisms 137 pm.fetcher.Start() 138 defer pm.fetcher.Stop() 139 defer pm.downloader.Terminate() 140 141 // Wait for different events to fire synchronisation operations 142 forceSync := time.Tick(forceSyncCycle) 143 for { 144 select { 145 case <-pm.newPeerCh: 146 // Make sure we have peers to select from, then sync 147 if pm.peers.Len() < minDesiredPeerCount { 148 break 149 } 150 go pm.synchronise(pm.peers.BestPeer()) 151 152 case <-forceSync: 153 // Force a sync even if not enough peers are present 154 go pm.synchronise(pm.peers.BestPeer()) 155 156 case <-pm.noMorePeers: 157 return 158 } 159 } 160 } 161 162 // synchronise tries to sync up our local block chain with a remote peer. 163 func (pm *ProtocolManager) synchronise(peer *peer) { 164 // Short circuit if no peers are available 165 if peer == nil { 166 return 167 } 168 // Make sure the peer's TD is higher than our own 169 currentBlock := pm.blockchain.CurrentBlock() 170 td := pm.blockchain.GetTd(currentBlock.Hash(), currentBlock.NumberU64()) 171 172 pHead, pTd := peer.Head() 173 if pTd.Cmp(td) <= 0 { 174 return 175 } 176 // Otherwise try to sync with the downloader 177 mode := downloader.FullSync 178 if atomic.LoadUint32(&pm.fastSync) == 1 { 179 mode = downloader.FastSync 180 } 181 if err := pm.downloader.Synchronise(peer.id, pHead, pTd, mode); err != nil { 182 return 183 } 184 pm.setSynced() // Mark initial sync done 185 186 // If fast sync was enabled, and we synced up, disable it 187 if atomic.LoadUint32(&pm.fastSync) == 1 { 188 // Disable fast sync if we indeed have something in our chain 189 if pm.blockchain.CurrentBlock().NumberU64() > 0 { 190 glog.V(logger.Info).Infof("fast sync complete, auto disabling") 191 atomic.StoreUint32(&pm.fastSync, 0) 192 } 193 } 194 } 195 196 // setSynced sets the synced flag and notifies the light server if present 197 func (pm *ProtocolManager) setSynced() { 198 if atomic.SwapUint32(&pm.synced, 1) == 0 && pm.lesServer != nil { 199 pm.lesServer.Synced() 200 } 201 }