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
use crate::{blockstore::*, blockstore_meta::SlotMeta};
use solana_sdk::clock::Slot;
pub struct NextSlotsIterator<'a> {
pending_slots: Vec<Slot>,
blockstore: &'a Blockstore,
}
impl<'a> NextSlotsIterator<'a> {
pub fn new(start_slot: Slot, blockstore: &'a Blockstore) -> Self {
Self {
pending_slots: vec![start_slot],
blockstore,
}
}
}
impl<'a> Iterator for NextSlotsIterator<'a> {
type Item = (Slot, SlotMeta);
fn next(&mut self) -> Option<Self::Item> {
if self.pending_slots.is_empty() {
None
} else {
let slot = self.pending_slots.pop().unwrap();
if let Some(slot_meta) = self.blockstore.meta(slot).unwrap() {
self.pending_slots.extend(slot_meta.next_slots.iter());
Some((slot, slot_meta))
} else {
None
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::blockstore_processor::fill_blockstore_slot_with_ticks;
use solana_sdk::hash::Hash;
use std::collections::HashSet;
#[test]
fn test_next_slots_iterator() {
let blockstore_path = get_tmp_ledger_path!();
let blockstore = Blockstore::open(&blockstore_path).unwrap();
blockstore.set_roots(&[0]).unwrap();
let ticks_per_slot = 5;
let last_entry_hash = Hash::default();
let fork_point = 1;
let mut fork_hash = Hash::default();
for slot in 0..=3 {
let parent = {
if slot == 0 {
0
} else {
slot - 1
}
};
let last_entry_hash = fill_blockstore_slot_with_ticks(
&blockstore,
ticks_per_slot,
slot,
parent,
last_entry_hash,
);
if slot == fork_point {
fork_hash = last_entry_hash;
}
}
let _ =
fill_blockstore_slot_with_ticks(&blockstore, ticks_per_slot, 4, fork_point, fork_hash);
let result: HashSet<_> = NextSlotsIterator::new(0, &blockstore)
.map(|(slot, _)| slot)
.collect();
let expected = vec![0, 1, 2, 3, 4].into_iter().collect();
assert_eq!(result, expected);
let result: HashSet<_> = NextSlotsIterator::new(2, &blockstore)
.map(|(slot, _)| slot)
.collect();
let expected = vec![2, 3].into_iter().collect();
assert_eq!(result, expected);
let result: HashSet<_> = NextSlotsIterator::new(4, &blockstore)
.map(|(slot, _)| slot)
.collect();
let expected = vec![4].into_iter().collect();
assert_eq!(result, expected);
drop(blockstore);
Blockstore::destroy(&blockstore_path).expect("Expected successful database destruction");
}
}