aboutsummaryrefslogtreecommitdiffstats
path: root/eth/downloader/downloader.go
blob: 206c4cc7e2dade5eddd468f7b910a9a82ed95bbe (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
package downloader

import (
    "math"
    "math/big"
    "sync"
    "sync/atomic"
    "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"
    "gopkg.in/fatih/set.v0"
)

const maxBlockFetch = 256

type hashFetcherFn func(common.Hash) error
type blockFetcherFn func([]common.Hash) error
type hashCheckFn func(common.Hash) bool
type chainInsertFn func(types.Blocks) error
type hashIterFn func() (common.Hash, error)

// XXX make threadsafe!!!!
type peers map[string]*peer

func (p peers) get(state int) []*peer {
    var peers []*peer
    for _, peer := range p {
        peer.mu.RLock()
        if peer.state == state {
            peers = append(peers, peer)
        }
        peer.mu.RUnlock()
    }

    return peers
}

func (p peers) setState(id string, state int) {
    if peer, exist := p[id]; exist {
        peer.mu.Lock()
        defer peer.mu.Unlock()
        peer.state = state
    }
}

type Downloader struct {
    queue *queue

    hasBlock    hashCheckFn
    insertChain chainInsertFn

    mu    sync.RWMutex
    peers peers

    currentPeer *peer

    fetchingHashes    int32
    downloadingBlocks int32

    newPeerCh    chan *peer
    selectPeerCh chan *peer
    HashCh       chan []common.Hash
    blockCh      chan blockPack
    quit         chan struct{}
}

type blockPack struct {
    peerId string
    blocks []*types.Block
}

func New(hasBlock hashCheckFn, insertChain chainInsertFn) *Downloader {
    downloader := &Downloader{
        queue:        newqueue(),
        peers:        make(peers),
        hasBlock:     hasBlock,
        insertChain:  insertChain,
        newPeerCh:    make(chan *peer, 1),
        selectPeerCh: make(chan *peer, 1),
        HashCh:       make(chan []common.Hash, 1),
        blockCh:      make(chan blockPack, 1),
        quit:         make(chan struct{}),
    }
    go downloader.peerHandler()
    go downloader.update()

    return downloader
}

func (d *Downloader) RegisterPeer(id string, td *big.Int, hash common.Hash, getHashes hashFetcherFn, getBlocks blockFetcherFn) error {
    d.mu.Lock()
    defer d.mu.Unlock()

    glog.V(logger.Detail).Infoln("Register peer", id)

    // Create a new peer and add it to the list of known peers
    peer := newPeer(id, td, hash, getHashes, getBlocks)
    // add peer to our peer set
    d.peers[id] = peer
    // broadcast new peer
    d.newPeerCh <- peer

    return nil
}

func (d *Downloader) UnregisterPeer(id string) {
    d.mu.Lock()
    defer d.mu.Unlock()

    glog.V(logger.Detail).Infoln("Unregister peer", id)

    delete(d.peers, id)
}

func (d *Downloader) peerHandler() {
    // Fields defined here so we can reduce the amount of locking
    // that needs to be done
    var highestTd = new(big.Int)
out:
    for {
        select {
        case newPeer := <-d.newPeerCh:
            // Check if TD of peer is higher than our current
            if newPeer.td.Cmp(highestTd) > 0 {
                glog.V(logger.Detail).Infoln("New peer with highest TD =", newPeer.td)

                highestTd.Set(newPeer.td)
                // select the peer for downloading
                d.selectPeerCh <- newPeer
            }
        case <-d.quit:
            break out
        }
    }
}

func (d *Downloader) update() {
out:
    for {
        select {
        case selectedPeer := <-d.selectPeerCh:
            // Make sure it's doing neither. Once done we can restart the
            // downloading process if the TD is higher. For now just get on
            // with whatever is going on. This prevents unecessary switching.
            if !(d.isFetchingHashes() || d.isDownloadingBlocks()) {
                glog.V(logger.Detail).Infoln("Selected new peer", selectedPeer.id)
                // Start the fetcher. This will block the update entirely
                // interupts need to be send to the appropriate channels
                // respectively.
                if err := d.startFetchingHashes(selectedPeer); err != nil {
                    // handle error
                    glog.V(logger.Debug).Infoln("Error fetching hashes:", err)
                    // Reset
                    break
                }

                // Start fetching blocks in paralel. The strategy is simple
                // take any available peers, seserve a chunk for each peer available,
                // let the peer deliver the chunkn and periodically check if a peer
                // has timedout. When done downloading, process blocks.
                if err := d.startFetchingBlocks(selectedPeer); err != nil {
                    glog.V(logger.Debug).Infoln("Error downloading blocks:", err)
                    // reset
                    break
                }

                // XXX this will move when optimised
                // Sort the blocks by number. This bit needs much improvement. Right now
                // it assumes full honesty form peers (i.e. it's not checked when the blocks
                // link). We should at least check whihc queue match. This code could move
                // to a seperate goroutine where it periodically checks for linked pieces.
                types.BlockBy(types.Number).Sort(d.queue.blocks)
                blocks := d.queue.blocks

                glog.V(logger.Debug).Infoln("Inserting chain with", len(blocks), "blocks")
                // Loop untill we're out of queue
                for len(blocks) != 0 {
                    max := int(math.Min(float64(len(blocks)), 256))
                    // TODO check for parent error. When there's a parent error we should stop
                    // processing and start requesting the `block.hash` so that it's parent and
                    // grandparents can be requested and queued.
                    d.insertChain(blocks[:max])
                    blocks = blocks[max:]
                }
            }
        case <-d.quit:
            break out
        }
    }
}

func (d *Downloader) startFetchingHashes(p *peer) error {
    glog.V(logger.Debug).Infoln("Downloading hashes")

    start := time.Now()

    // Get the first batch of hashes
    p.getHashes(p.recentHash)
    atomic.StoreInt32(&d.fetchingHashes, 1)

out:
    for {
        select {
        case hashes := <-d.HashCh:
            var done bool // determines whether we're done fetching hashes (i.e. common hash found)
            hashSet := set.New()
            for _, hash := range hashes {
                if d.hasBlock(hash) {
                    glog.V(logger.Debug).Infof("Found common hash %x\n", hash)

                    done = true
                    break
                }

                hashSet.Add(hash)
            }
            d.queue.put(hashSet)

            // Add hashes to the chunk set
            // Check if we're done fetching
            if !done {
                //fmt.Println("re-fetch. current =", d.queue.hashPool.Size())
                // Get the next set of hashes
                p.getHashes(hashes[len(hashes)-1])
                atomic.StoreInt32(&d.fetchingHashes, 1)
            } else {
                atomic.StoreInt32(&d.fetchingHashes, 0)
                break out
            }
        }
    }
    glog.V(logger.Detail).Infoln("Download hashes: done. Took", time.Since(start))

    return nil
}

func (d *Downloader) DeliverBlocks(id string, block []*types.Block) {
    d.blockCh <- blockPack{id, block}
}

func (d *Downloader) startFetchingBlocks(p *peer) error {
    glog.V(logger.Detail).Infoln("Downloading", d.queue.hashPool.Size(), "blocks")
    atomic.StoreInt32(&d.downloadingBlocks, 1)

    start := time.Now()

    // default ticker for re-fetching blocks everynow and then
    ticker := time.NewTicker(20 * time.Millisecond)
out:
    for {
        select {
        case blockPack := <-d.blockCh:
            //fmt.Println("get for", blockPack.peerId)

            d.queue.deliver(blockPack.peerId, blockPack.blocks)
            d.peers.setState(blockPack.peerId, idleState)
        case <-ticker.C:
            // If there are unrequested hashes left start fetching
            // from the available peers.
            if d.queue.hashPool.Size() > 0 {
                availablePeers := d.peers.get(idleState)
                for _, peer := range availablePeers {
                    // Get a possible chunk. If nil is returned no chunk
                    // could be returned due to no hashes available.
                    chunk := d.queue.get(peer, maxBlockFetch)
                    if chunk != nil {
                        //fmt.Println("fetching for", peer.id)
                        // Fetch the chunk and check for error. If the peer was somehow
                        // already fetching a chunk due to a bug, it will be returned to
                        // the queue
                        if err := peer.fetch(chunk); err != nil {
                            // log for tracing
                            glog.V(logger.Debug).Infof("peer %s received double work (state = %v)\n", peer.id, peer.state)
                            d.queue.put(chunk.hashes)
                        }
                    }
                }
                atomic.StoreInt32(&d.downloadingBlocks, 1)
            } else if len(d.queue.fetching) == 0 {
                // Whene there are no more queue and no more `fetching`. We can
                // safely assume we're done. Another part of the process will  check
                // for parent errors and will re-request anything that's missing
                atomic.StoreInt32(&d.downloadingBlocks, 0)
                // Break out so that we can process with processing blocks
                break out
            } else {
                // Check for bad peers. Bad peers may indicate a peer not responding
                // to a `getBlocks` message. A timeout of 5 seconds is set. Peers
                // that badly or poorly behave are removed from the peer set (not banned).
                // Bad peers are excluded from the available peer set and therefor won't be
                // reused. XXX We could re-introduce peers after X time.
                d.queue.mu.Lock()
                var badPeers []string
                for pid, chunk := range d.queue.fetching {
                    if time.Since(chunk.itime) > 5*time.Second {
                        badPeers = append(badPeers, pid)
                        // remove peer as good peer from peer list
                        d.UnregisterPeer(pid)
                    }
                }
                d.queue.mu.Unlock()

                for _, pid := range badPeers {
                    // A nil chunk is delivered so that the chunk's hashes are given
                    // back to the queue objects. When hashes are put back in the queue
                    // other (decent) peers can pick them up.
                    // XXX We could make use of a reputation system here ranking peers
                    // in their performance
                    // 1) Time for them to respond;
                    // 2) Measure their speed;
                    // 3) Amount and availability.
                    d.queue.deliver(pid, nil)
                }

            }
            //fmt.Println(d.queue.hashPool.Size(), len(d.queue.fetching))
        }
    }

    glog.V(logger.Detail).Infoln("Download blocks: done. Took", time.Since(start))

    return nil
}

func (d *Downloader) isFetchingHashes() bool {
    return atomic.LoadInt32(&d.fetchingHashes) == 1
}

func (d *Downloader) isDownloadingBlocks() bool {
    return atomic.LoadInt32(&d.downloadingBlocks) == 1
}