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

//! A channel which holds a list of recent syncer response lengths.

use tokio::sync::watch;

#[cfg(test)]
mod tests;

/// A helper type which holds a list of recent syncer response lengths.
/// These sync lengths can be used to work out if Zebra has reached the end of the chain.
///
/// New lengths are added to the front of the list.
/// Old lengths are dropped if the list is longer than `MAX_RECENT_LENGTHS`.
//
// TODO: disable the mempool if obtain or extend tips return errors?
#[derive(Debug)]
pub struct RecentSyncLengths {
    /// A sender for an array of recent sync lengths.
    sender: watch::Sender<Vec<usize>>,

    /// A local copy of the contents of `sender`.
    // TODO: Replace with calls to `watch::Sender::borrow` once Tokio is updated to 1.0.0 (#2573)
    recent_lengths: Vec<usize>,
}

impl RecentSyncLengths {
    /// The maximum number of lengths sent by `RecentSyncLengths`.
    ///
    /// Older lengths are dropped.
    ///
    /// This length was chosen as a tradeoff between:
    /// * clearing temporary errors and temporary syncs quickly
    /// * distinguishing between temporary and sustained syncs/errors
    /// * activating the syncer shortly after reaching the chain tip
    pub const MAX_RECENT_LENGTHS: usize = 3;

    /// Create a new instance of [`RecentSyncLengths`]
    /// and a [`watch::Receiver`] endpoint for receiving recent sync lengths.
    pub fn new() -> (Self, watch::Receiver<Vec<usize>>) {
        let (sender, receiver) = watch::channel(Vec::new());

        (
            RecentSyncLengths {
                sender,
                recent_lengths: Vec::with_capacity(Self::MAX_RECENT_LENGTHS),
            },
            receiver,
        )
    }

    // We skip the genesis block download, because it just uses the genesis hash directly,
    // rather than asking peers for the next blocks in the chain.
    // (And if genesis downloads kept failing, we could accidentally activate the mempool.)

    /// Insert a sync length from [`ChainSync::obtain_tips`] at the front of the
    /// list.
    ///
    /// [`ChainSync::obtain_tips`]: super::ChainSync::obtain_tips
    #[instrument(skip(self), fields(self.recent_lengths))]
    pub fn push_obtain_tips_length(&mut self, sync_length: usize) {
        // currently, we treat lengths from obtain and extend tips exactly the same,
        // but we might want to ignore some obtain tips lengths
        //
        // See "Response Lengths During Sync -> Details" in:
        // https://github.com/ZcashFoundation/zebra/issues/2592#issuecomment-897304684
        self.update(sync_length)
    }

    /// Insert a sync length from [`ChainSync::extend_tips`] at the front of the
    /// list.
    ///
    /// [`ChainSync::extend_tips`]: super::ChainSync::extend_tips
    #[instrument(skip(self), fields(self.recent_lengths))]
    pub fn push_extend_tips_length(&mut self, sync_length: usize) {
        self.update(sync_length)
    }

    /// Sends a list update to listeners.
    ///
    /// Prunes recent lengths, if the list is longer than `MAX_RECENT_LENGTHS`.
    fn update(&mut self, sync_length: usize) {
        self.recent_lengths.insert(0, sync_length);

        self.recent_lengths.truncate(Self::MAX_RECENT_LENGTHS);

        debug!(
            recent_lengths = ?self.recent_lengths,
            "sending recent sync lengths"
        );

        // ignore dropped receivers
        let _ = self.sender.send(self.recent_lengths.clone());
    }
}