You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

265 lines
6.3 KiB

package statesync
import (
"container/heap"
"fmt"
"sync"
"time"
"github.com/tendermint/tendermint/types"
)
type lightBlockResponse struct {
block *types.LightBlock
peer types.NodeID
}
// a block queue is used for asynchronously fetching and verifying light blocks
type blockQueue struct {
mtx sync.Mutex
// cursors to keep track of which heights need to be fetched and verified
fetchHeight int64
verifyHeight int64
// termination conditions
initialHeight int64
stopHeight int64
stopTime time.Time
terminal *types.LightBlock
// track failed heights so we know what blocks to try fetch again
failed *maxIntHeap
// also count retries to know when to give up
retries int
maxRetries int
// store inbound blocks and serve them to a verifying thread via a channel
pending map[int64]lightBlockResponse
verifyCh chan lightBlockResponse
// waiters are workers on idle until a height is required
waiters []chan int64
// this channel is closed once the verification process is complete
doneCh chan struct{}
}
func newBlockQueue(
startHeight, stopHeight, initialHeight int64,
stopTime time.Time,
maxRetries int,
) *blockQueue {
return &blockQueue{
stopHeight: stopHeight,
initialHeight: initialHeight,
stopTime: stopTime,
fetchHeight: startHeight,
verifyHeight: startHeight,
pending: make(map[int64]lightBlockResponse),
failed: &maxIntHeap{},
retries: 0,
maxRetries: maxRetries,
waiters: make([]chan int64, 0),
doneCh: make(chan struct{}),
}
}
// Add adds a block to the queue to be verified and stored
// CONTRACT: light blocks should have passed basic validation
func (q *blockQueue) add(l lightBlockResponse) {
q.mtx.Lock()
defer q.mtx.Unlock()
// return early if the process has already finished
select {
case <-q.doneCh:
return
default:
}
// sometimes more blocks are fetched then what is necessary. If we already
// have what we need then ignore this
if q.terminal != nil && l.block.Height < q.terminal.Height {
return
}
// if the block that was returned is at the verify height then the verifier
// is already waiting for this block so we send it directly to them
if l.block.Height == q.verifyHeight && q.verifyCh != nil {
q.verifyCh <- l
close(q.verifyCh)
q.verifyCh = nil
} else {
// else we add it in the pending bucket
q.pending[l.block.Height] = l
}
// Lastly, if the incoming block is past the stop time and stop height or
// is equal to the initial height then we mark it as the terminal block.
if l.block.Height <= q.stopHeight && l.block.Time.Before(q.stopTime) ||
l.block.Height == q.initialHeight {
q.terminal = l.block
}
}
// NextHeight returns the next height that needs to be retrieved.
// We assume that for every height allocated that the peer will eventually add
// the block or signal that it needs to be retried
func (q *blockQueue) nextHeight() <-chan int64 {
q.mtx.Lock()
defer q.mtx.Unlock()
ch := make(chan int64, 1)
// if a previous process failed then we pick up this one
if q.failed.Len() > 0 {
failedHeight := heap.Pop(q.failed)
ch <- failedHeight.(int64)
close(ch)
return ch
}
if q.terminal == nil && q.fetchHeight >= q.initialHeight {
// return and decrement the fetch height
ch <- q.fetchHeight
q.fetchHeight--
close(ch)
return ch
}
// at this point there is no height that we know we need so we create a
// waiter to hold out for either an outgoing request to fail or a block to
// fail verification
q.waiters = append(q.waiters, ch)
return ch
}
// Finished returns true when the block queue has has all light blocks retrieved,
// verified and stored. There is no more work left to be done
func (q *blockQueue) done() <-chan struct{} {
return q.doneCh
}
// VerifyNext pulls the next block off the pending queue and adds it to a
// channel if it's already there or creates a waiter to add it to the
// channel once it comes in. NOTE: This is assumed to
// be a single thread as light blocks need to be sequentially verified.
func (q *blockQueue) verifyNext() <-chan lightBlockResponse {
q.mtx.Lock()
defer q.mtx.Unlock()
ch := make(chan lightBlockResponse, 1)
select {
case <-q.doneCh:
return ch
default:
}
if lb, ok := q.pending[q.verifyHeight]; ok {
ch <- lb
close(ch)
delete(q.pending, q.verifyHeight)
} else {
q.verifyCh = ch
}
return ch
}
// Retry is called when a dispatcher failed to fetch a light block or the
// fetched light block failed verification. It signals to the queue to add the
// height back to the request queue
func (q *blockQueue) retry(height int64) {
q.mtx.Lock()
defer q.mtx.Unlock()
select {
case <-q.doneCh:
return
default:
}
// we don't need to retry if this is below the terminal height
if q.terminal != nil && height < q.terminal.Height {
return
}
q.retries++
if q.retries >= q.maxRetries {
q._closeChannels()
return
}
if len(q.waiters) > 0 {
q.waiters[0] <- height
close(q.waiters[0])
q.waiters = q.waiters[1:]
} else {
heap.Push(q.failed, height)
}
}
// Success is called when a light block has been successfully verified and
// processed
func (q *blockQueue) success(height int64) {
q.mtx.Lock()
defer q.mtx.Unlock()
if q.terminal != nil && q.verifyHeight == q.terminal.Height {
q._closeChannels()
}
q.verifyHeight--
}
func (q *blockQueue) error() error {
q.mtx.Lock()
defer q.mtx.Unlock()
if q.retries >= q.maxRetries {
return fmt.Errorf("max retries to fetch valid blocks exceeded (%d); "+
"target height: %d, height reached: %d", q.maxRetries, q.stopHeight, q.verifyHeight)
}
return nil
}
// close the queue and respective channels
func (q *blockQueue) close() {
q.mtx.Lock()
defer q.mtx.Unlock()
q._closeChannels()
}
// CONTRACT: must have a write lock. Use close instead
func (q *blockQueue) _closeChannels() {
close(q.doneCh)
// wait for the channel to be drained
select {
case <-q.doneCh:
return
default:
}
for _, ch := range q.waiters {
close(ch)
}
if q.verifyCh != nil {
close(q.verifyCh)
}
}
// A max-heap of ints.
type maxIntHeap []int64
func (h maxIntHeap) Len() int { return len(h) }
func (h maxIntHeap) Less(i, j int) bool { return h[i] < h[j] }
func (h maxIntHeap) Swap(i, j int) { h[i], h[j] = h[j], h[i] }
func (h *maxIntHeap) Push(x interface{}) {
*h = append(*h, x.(int64))
}
func (h *maxIntHeap) Pop() interface{} {
old := *h
n := len(old)
x := old[n-1]
*h = old[0 : n-1]
return x
}