blockworks-foundation
/
solana-with-rpc-optimizations
mirror of https://github.com/blockworks-foundation/solana-with-rpc-optimizations.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

slot 0 now contains the same number of ticks as all subsequent slots

This commit is contained in:
Michael Vines 2019-02-10 09:38:09 -08:00
parent 4b38ecd916
commit 7dec40ff05
9 changed files with 202 additions and 153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ledger-tool/tests/basic.rs
View File

@ -32,7 +32,7 @@ fn bad_arguments() {
#[test]
fn nominal() {
let keypair = Arc::new(Keypair::new());
let (_, ledger_path, _, _) =
let (_mint_keypair, ledger_path, _last_entry_height, _last_id, _last_entry_id) =
create_tmp_sample_ledger("test_ledger_tool_nominal", 100, 9, keypair.pubkey(), 50);
// Basic validation

41
src/bank.rs
View File

@ -817,25 +817,40 @@ impl Bank {
where
I: IntoIterator<Item = Entry>,
{
let mut entry_height = 0;
let mut last_id = self.last_id();
let mut last_entry_id = self.last_id();
let mut entries_iter = entries.into_iter();
trace!("genesis last_id={}", last_entry_id);
// The first entry in the ledger is a pseudo-tick used only to ensure the number of ticks
// in slot 0 is the same as the number of ticks in all subsequent slots. It is not
// registered as a tick and thus cannot be used as a last_id
let entry0 = entries_iter
.next()
.ok_or(BankError::LedgerVerificationFailed)?;
if !(entry0.is_tick() && entry0.verify(&last_entry_id)) {
warn!("Ledger proof of history failed at entry0");
return Err(BankError::LedgerVerificationFailed);
}
last_entry_id = entry0.id;
let mut entry_height = 1;
// Ledger verification needs to be parallelized, but we can't pull the whole
// thing into memory. We therefore chunk it.
for block in &entries.into_iter().chunks(VERIFY_BLOCK_SIZE) {
for block in &entries_iter.chunks(VERIFY_BLOCK_SIZE) {
let block: Vec<_> = block.collect();
if !block.verify(&last_id) {
if !block.verify(&last_entry_id) {
warn!("Ledger proof of history failed at entry: {}", entry_height);
return Err(BankError::LedgerVerificationFailed);
}
self.process_block(&block)?;
last_id = block.last().unwrap().id;
last_entry_id = block.last().unwrap().id;
entry_height += block.len() as u64;
}
Ok((entry_height, last_id))
Ok((entry_height, last_entry_id))
}
/// Create, sign, and process a Transaction from `keypair` to `to` of
@ -1251,10 +1266,12 @@ mod tests {
) -> impl Iterator<Item = Entry> {
let mut entries: Vec<Entry> = vec![];
// Start off the ledger with a tick linked to the genesis block
let mut last_id = genesis_block.last_id();
// Start off the ledger with the psuedo-tick linked to the genesis block
// (see entry0 in `process_ledger`)
let tick = Entry::new(&genesis_block.last_id(), 0, 1, vec![]);
let mut hash = tick.id;
let mut last_id = tick.id;
entries.push(tick);
let num_hashes = 1;
@ -1281,10 +1298,12 @@ mod tests {
) -> impl Iterator<Item = Entry> {
let mut entries = vec![];
// Start off the ledger with a tick linked to the genesis block
let mut last_id = genesis_block.last_id();
// Start off the ledger with the psuedo-tick linked to the genesis block
// (see entry0 in `process_ledger`)
let tick = Entry::new(&genesis_block.last_id(), 0, 1, vec![]);
let mut hash = tick.id;
let mut last_id = tick.id;
entries.push(tick);
for i in 0..num_one_token_transfers {
@ -1351,7 +1370,7 @@ mod tests {
let (ledger_height, last_id) = bank.process_ledger(ledger).unwrap();
assert_eq!(bank.get_balance(&mint_keypair.pubkey()), 100 - 3);
assert_eq!(ledger_height, 8);
assert_eq!(bank.tick_height(), 2);
assert_eq!(bank.tick_height(), 1);
assert_eq!(bank.last_id(), last_id);
}

47
src/blocktree.rs
View File

@ -150,15 +150,7 @@ impl SlotMeta {
// A placeholder slot does not contain all the ticks
false
} else {
let num_expected_ticks = {
let num = self.num_expected_ticks(blocktree);
if self.slot_height == 0 {
num - 1
} else {
num
}
};
num_expected_ticks <= self.consumed_ticks
self.num_expected_ticks(blocktree) <= self.consumed_ticks
}
}
@ -1305,35 +1297,38 @@ pub fn get_tmp_ledger_path(name: &str) -> String {
path
}
pub fn create_tmp_ledger(name: &str, genesis_block: &GenesisBlock) -> String {
let ledger_path = get_tmp_ledger_path(name);
create_new_ledger(&ledger_path, genesis_block).unwrap();
ledger_path
}
pub fn create_tmp_sample_ledger(
name: &str,
num_tokens: u64,
num_extra_ticks: u64,
bootstrap_leader_id: Pubkey,
bootstrap_leader_tokens: u64,
) -> (Keypair, String, u64, Hash) {
) -> (Keypair, String, u64, Hash, Hash) {
let (genesis_block, mint_keypair) =
GenesisBlock::new_with_leader(num_tokens, bootstrap_leader_id, bootstrap_leader_tokens);
let ledger_path = get_tmp_ledger_path(name);
let (mut entry_height, mut last_id) = create_new_ledger(&ledger_path, &genesis_block).unwrap();
let (mut entry_height, mut last_entry_id) =
create_new_ledger(&ledger_path, &genesis_block).unwrap();
let mut last_id = genesis_block.last_id();
if num_extra_ticks > 0 {
let entries = crate::entry::create_ticks(num_extra_ticks, last_id);
let entries = crate::entry::create_ticks(num_extra_ticks, last_entry_id);
let blocktree = Blocktree::open(&ledger_path).unwrap();
blocktree
.write_entries(DEFAULT_SLOT_HEIGHT, entry_height, &entries)
.unwrap();
entry_height += entries.len() as u64;
last_id = entries.last().unwrap().id
last_id = entries.last().unwrap().id;
last_entry_id = last_id;
}
(mint_keypair, ledger_path, entry_height, last_id)
(
mint_keypair,
ledger_path,
entry_height,
last_id,
last_entry_id,
)
}
pub fn tmp_copy_ledger(from: &str, name: &str) -> String {
@ -1992,11 +1987,7 @@ mod tests {
assert_eq!(s.next_slots, vec![i + 1]);
}
assert_eq!(s.num_blocks, 1);
if i == 0 {
assert_eq!(s.consumed_ticks, ticks_per_slot - 1);
} else {
assert_eq!(s.consumed_ticks, ticks_per_slot);
}
assert_eq!(s.consumed_ticks, ticks_per_slot);
assert!(s.is_trunk);
}
}
@ -2062,11 +2053,7 @@ mod tests {
} else {
assert!(s.next_slots.is_empty());
}
if i == 0 {
assert_eq!(s.consumed_ticks, ticks_per_slot - 1);
} else {
assert_eq!(s.consumed_ticks, ticks_per_slot);
}
assert_eq!(s.consumed_ticks, ticks_per_slot);
assert!(s.is_trunk);
}
}

48
src/fullnode.rs
View File

@ -580,7 +580,7 @@ mod tests {
let validator_keypair = Keypair::new();
let validator_node = Node::new_localhost_with_pubkey(validator_keypair.pubkey());
let (_, validator_ledger_path, _, _) =
let (_mint_keypair, validator_ledger_path, _last_entry_height, _last_id, _last_entry_id) =
create_tmp_sample_ledger("validator_exit", 10_000, 0, leader_keypair.pubkey(), 1000);
let validator = Fullnode::new(
@ -605,7 +605,13 @@ mod tests {
.map(|i| {
let validator_keypair = Keypair::new();
let validator_node = Node::new_localhost_with_pubkey(validator_keypair.pubkey());
let (_, validator_ledger_path, _, _) = create_tmp_sample_ledger(
let (
_mint_keypair,
validator_ledger_path,
_last_entry_height,
_last_id,
_last_entry_id,
) = create_tmp_sample_ledger(
&format!("validator_parallel_exit_{}", i),
10_000,
0,
@ -645,14 +651,19 @@ mod tests {
let bootstrap_leader_node =
Node::new_localhost_with_pubkey(bootstrap_leader_keypair.pubkey());
let (_mint_keypair, bootstrap_leader_ledger_path, _genesis_entry_height, _last_id) =
create_tmp_sample_ledger(
"test_leader_to_leader_transition",
10_000,
1,
bootstrap_leader_keypair.pubkey(),
500,
);
let (
_mint_keypair,
bootstrap_leader_ledger_path,
_genesis_entry_height,
_last_id,
_last_entry_id,
) = create_tmp_sample_ledger(
"test_leader_to_leader_transition",
10_000,
1,
bootstrap_leader_keypair.pubkey(),
500,
);
// Once the bootstrap leader hits the second epoch, because there are no other choices in
// the active set, this leader will remain the leader in the second epoch. In the second
@ -1018,13 +1029,14 @@ mod tests {
// Create validator identity
assert!(num_genesis_ticks <= ticks_per_block);
let (mint_keypair, ledger_path, genesis_entry_height, last_id) = create_tmp_sample_ledger(
test_name,
10_000,
num_genesis_ticks,
leader_node.info.id,
500,
);
let (mint_keypair, ledger_path, genesis_entry_height, last_id, last_entry_id) =
create_tmp_sample_ledger(
test_name,
10_000,
num_genesis_ticks,
leader_node.info.id,
500,
);
let validator_node = Node::new_localhost_with_pubkey(validator_keypair.pubkey());
@ -1040,7 +1052,7 @@ mod tests {
&mint_keypair,
10,
1,
&last_id,
&last_entry_id,
&last_id,
num_ending_ticks,
);

37
src/replay_stage.rs
View File

@ -87,6 +87,7 @@ impl ReplayStage {
let mut res = Ok(());
let mut num_entries_to_write = entries.len();
let now = Instant::now();
if !entries.as_slice().verify(&last_entry_id.read().unwrap()) {
inc_new_counter_info!("replicate_stage-verify-fail", entries.len());
return Err(Error::BlobError(BlobError::VerificationFailed));
@ -411,7 +412,7 @@ mod test {
let old_leader_id = Keypair::new().pubkey();
// Create a ledger
let (mint_keypair, my_ledger_path, genesis_entry_height, mut last_id) =
let (mint_keypair, my_ledger_path, genesis_entry_height, mut last_id, last_entry_id) =
create_tmp_sample_ledger(
"test_replay_stage_leader_rotation_exit",
10_000,
@ -433,7 +434,7 @@ mod test {
&mint_keypair,
100,
ticks_per_slot, // add a vote for tick_height = ticks_per_slot
&last_id,
&last_entry_id,
&last_id,
0,
);
@ -538,13 +539,14 @@ mod test {
// Create keypair for the leader
let leader_id = Keypair::new().pubkey();
let (_, my_ledger_path, _, _) = create_tmp_sample_ledger(
"test_vote_error_replay_stage_correctness",
10_000,
1,
leader_id,
500,
);
let (_mint_keypair, my_ledger_path, _last_entry_height, _last_id, _last_entry_id) =
create_tmp_sample_ledger(
"test_vote_error_replay_stage_correctness",
10_000,
1,
leader_id,
500,
);
// Set up the cluster info
let cluster_info_me = Arc::new(RwLock::new(ClusterInfo::new(my_node.info.clone())));
@ -583,7 +585,7 @@ mod test {
let vote = VoteTransaction::new_vote(keypair, bank.tick_height(), bank.last_id(), 0);
cluster_info_me.write().unwrap().push_vote(vote);
// Send ReplayStage an entry, should see it on the ledger writer receiver
info!("Send ReplayStage an entry, should see it on the ledger writer receiver");
let next_tick = create_ticks(1, last_entry_id);
blocktree
@ -592,7 +594,7 @@ mod test {
let received_tick = ledger_writer_recv
.recv()
.expect("Expected to recieve an entry on the ledger writer receiver");
.expect("Expected to receive an entry on the ledger writer receiver");
assert_eq!(next_tick, received_tick);
@ -617,7 +619,7 @@ mod test {
let leader_id = Keypair::new().pubkey();
// Create the ledger
let (mint_keypair, my_ledger_path, genesis_entry_height, last_id) =
let (mint_keypair, my_ledger_path, genesis_entry_height, last_id, last_entry_id) =
create_tmp_sample_ledger(
"test_vote_error_replay_stage_leader_rotation",
10_000,
@ -630,8 +632,15 @@ mod test {
// Write two entries to the ledger so that the validator is in the active set:
// 1) Give the validator a nonzero number of tokens 2) A vote from the validator.
// This will cause leader rotation after the bootstrap height
let (active_set_entries, voting_keypair) =
make_active_set_entries(&my_keypair, &mint_keypair, 100, 1, &last_id, &last_id, 0);
let (active_set_entries, voting_keypair) = make_active_set_entries(
&my_keypair,
&mint_keypair,
100,
1,
&last_entry_id,
&last_id,
0,
);
let mut last_id = active_set_entries.last().unwrap().id;
let initial_tick_height = genesis_entry_height;

30
src/storage_stage.rs
View File

@ -492,13 +492,14 @@ mod tests {
let keypair = Arc::new(Keypair::new());
let exit = Arc::new(AtomicBool::new(false));
let (_mint, ledger_path, genesis_entry_height, _last_id) = create_tmp_sample_ledger(
"storage_stage_process_entries",
1000,
1,
Keypair::new().pubkey(),
1,
);
let (_mint, ledger_path, genesis_entry_height, _last_id, _last_entry_id) =
create_tmp_sample_ledger(
"storage_stage_process_entries",
1000,
1,
Keypair::new().pubkey(),
1,
);
let entries = make_tiny_test_entries(64);
let blocktree = Blocktree::open(&ledger_path).unwrap();
@ -560,13 +561,14 @@ mod tests {
let keypair = Arc::new(Keypair::new());
let exit = Arc::new(AtomicBool::new(false));
let (_mint, ledger_path, genesis_entry_height, _last_id) = create_tmp_sample_ledger(
"storage_stage_process_entries",
1000,
1,
Keypair::new().pubkey(),
1,
);
let (_mint, ledger_path, genesis_entry_height, _last_id, _last_entry_id) =
create_tmp_sample_ledger(
"storage_stage_process_entries",
1000,
1,
Keypair::new().pubkey(),
1,
);
let entries = make_tiny_test_entries(128);
let blocktree = Blocktree::open(&ledger_path).unwrap();

2
src/thin_client.rs
View File

@ -464,7 +464,7 @@ pub fn new_fullnode(ledger_name: &'static str) -> (Fullnode, NodeInfo, Keypair,
let node = Node::new_localhost_with_pubkey(node_keypair.pubkey());
let node_info = node.info.clone();
let (mint_keypair, ledger_path, _, _) =
let (mint_keypair, ledger_path, _last_entry_height, _last_id, _last_entry_id) =
create_tmp_sample_ledger(ledger_name, 10_000, 0, node_info.id, 42);
let vote_account_keypair = Arc::new(Keypair::new());

144
tests/multinode.rs
View File

@ -44,7 +44,7 @@ fn test_multi_node_ledger_window() -> result::Result<()> {
let bob_pubkey = Keypair::new().pubkey();
let mut ledger_paths = Vec::new();
let (alice, leader_ledger_path, mut last_entry_height, mut last_entry_id) =
let (alice, leader_ledger_path, mut last_entry_height, _last_id, mut last_entry_id) =
create_tmp_sample_ledger("multi_node_ledger_window", 10_000, 0, leader_data.id, 500);
ledger_paths.push(leader_ledger_path.clone());
@ -65,7 +65,7 @@ fn test_multi_node_ledger_window() -> result::Result<()> {
let blocktree = Blocktree::open(&leader_ledger_path).unwrap();
let entries = solana::entry::create_ticks(
fullnode_config.leader_scheduler_config.ticks_per_slot - last_entry_height - 2,
fullnode_config.leader_scheduler_config.ticks_per_slot - last_entry_height - 1,
last_entry_id,
);
blocktree
@ -164,13 +164,14 @@ fn test_multi_node_validator_catchup_from_zero() -> result::Result<()> {
let bob_pubkey = Keypair::new().pubkey();
let mut ledger_paths = Vec::new();
let (alice, genesis_ledger_path, _last_entry_height, _last_entry_id) = create_tmp_sample_ledger(
"multi_node_validator_catchup_from_zero",
10_000,
0,
leader_data.id,
500,
);
let (alice, genesis_ledger_path, _last_entry_height, _last_id, _last_entry_id) =
create_tmp_sample_ledger(
"multi_node_validator_catchup_from_zero",
10_000,
0,
leader_data.id,
500,
);
ledger_paths.push(genesis_ledger_path.clone());
let zero_ledger_path = tmp_copy_ledger(
@ -353,7 +354,7 @@ fn test_multi_node_basic() {
let bob_pubkey = Keypair::new().pubkey();
let mut ledger_paths = Vec::new();
let (alice, genesis_ledger_path, _last_entry_height, _last_entry_id) =
let (alice, genesis_ledger_path, _last_entry_height, _last_id, _last_entry_id) =
create_tmp_sample_ledger("multi_node_basic", 10_000, 0, leader_data.id, 500);
ledger_paths.push(genesis_ledger_path.clone());
@ -453,7 +454,7 @@ fn test_boot_validator_from_file() -> result::Result<()> {
let bob_pubkey = Keypair::new().pubkey();
let mut ledger_paths = Vec::new();
let (alice, genesis_ledger_path, _last_entry_height, _last_entry_id) =
let (alice, genesis_ledger_path, _last_entry_height, _last_id, _last_entry_id) =
create_tmp_sample_ledger("boot_validator_from_file", 100_000, 0, leader_pubkey, 1000);
ledger_paths.push(genesis_ledger_path.clone());
@ -532,13 +533,14 @@ fn test_leader_restart_validator_start_from_old_ledger() -> result::Result<()> {
let leader_keypair = Arc::new(Keypair::new());
let initial_leader_balance = 500;
let (alice, ledger_path, _last_entry_height, _last_entry_id) = create_tmp_sample_ledger(
"leader_restart_validator_start_from_old_ledger",
100_000 + 500 * solana::window_service::MAX_REPAIR_BACKOFF as u64,
0,
leader_keypair.pubkey(),
initial_leader_balance,
);
let (alice, ledger_path, _last_entry_height, _last_id, _last_entry_id) =
create_tmp_sample_ledger(
"leader_restart_validator_start_from_old_ledger",
100_000 + 500 * solana::window_service::MAX_REPAIR_BACKOFF as u64,
0,
leader_keypair.pubkey(),
initial_leader_balance,
);
let bob_pubkey = Keypair::new().pubkey();
{
@ -641,13 +643,14 @@ fn test_multi_node_dynamic_network() {
let leader_pubkey = leader_keypair.pubkey().clone();
let leader = Node::new_localhost_with_pubkey(leader_keypair.pubkey());
let bob_pubkey = Keypair::new().pubkey();
let (alice, genesis_ledger_path, _last_entry_height, _last_entry_id) = create_tmp_sample_ledger(
"multi_node_dynamic_network",
10_000_000,
0,
leader_pubkey,
500,
);
let (alice, genesis_ledger_path, _last_entry_height, _last_id, _last_entry_id) =
create_tmp_sample_ledger(
"multi_node_dynamic_network",
10_000_000,
0,
leader_pubkey,
500,
);
let mut ledger_paths = Vec::new();
ledger_paths.push(genesis_ledger_path.clone());
@ -862,7 +865,7 @@ fn test_leader_to_validator_transition() {
// Initialize the leader ledger. Make a mint and a genesis entry
// in the leader ledger
let (mint_keypair, leader_ledger_path, genesis_entry_height, last_id) =
let (mint_keypair, leader_ledger_path, genesis_entry_height, last_id, last_entry_id) =
create_tmp_sample_ledger(
"test_leader_to_validator_transition",
10_000,
@ -878,7 +881,7 @@ fn test_leader_to_validator_transition() {
&mint_keypair,
100,
ticks_per_slot,
&last_id,
&last_entry_id,
&last_id,
0,
);
@ -963,7 +966,7 @@ fn test_leader_validator_basic() {
info!("validator id: {}", validator_keypair.pubkey());
// Make a common mint and a genesis entry for both leader + validator ledgers
let (mint_keypair, leader_ledger_path, genesis_entry_height, last_id) =
let (mint_keypair, leader_ledger_path, genesis_entry_height, last_id, last_entry_id) =
create_tmp_sample_ledger(
"test_leader_validator_basic",
10_000,
@ -978,7 +981,7 @@ fn test_leader_validator_basic() {
&mint_keypair,
100,
1,
&last_id,
&last_entry_id,
&last_id,
0,
);
@ -1036,30 +1039,40 @@ fn test_leader_validator_basic() {
converge(&leader_info, 2);
info!("Waiting for slot 0 -> slot 1: bootstrap leader will remain the leader");
assert_eq!(
leader_rotation_receiver.recv().unwrap(),
(FullnodeReturnType::LeaderToLeaderRotation, ticks_per_slot,)
);
info!("Waiting for slot 1 -> slot 2: bootstrap leader becomes a validator");
info!("Waiting for slot 0 -> slot 1: bootstrap leader and the validator rotate");
assert_eq!(
leader_rotation_receiver.recv().unwrap(),
(
FullnodeReturnType::LeaderToValidatorRotation,
ticks_per_slot * 2,
ticks_per_slot,
)
);
info!("Waiting for slot 1 -> slot 2: validator becomes the leader");
assert_eq!(
validator_rotation_receiver.recv().unwrap(),
(
FullnodeReturnType::ValidatorToLeaderRotation,
ticks_per_slot,
)
);
info!("Waiting for slot 1 -> slot 2: validator remains the slot leader due to no votes");
assert_eq!(
validator_rotation_receiver.recv().unwrap(),
(
FullnodeReturnType::LeaderToLeaderRotation,
ticks_per_slot * 2,
)
);
info!("Waiting for slot 2 -> slot 3: validator remains the slot leader due to no votes");
assert_eq!(
validator_rotation_receiver.recv().unwrap(),
(
FullnodeReturnType::LeaderToLeaderRotation,
ticks_per_slot * 3,
)
);
info!("Shut down");
validator_exit();
leader_exit();
@ -1109,7 +1122,7 @@ fn test_dropped_handoff_recovery() {
// Make a common mint and a genesis entry for both leader + validator's ledgers
let num_ending_ticks = 1;
let (mint_keypair, genesis_ledger_path, genesis_entry_height, last_id) =
let (mint_keypair, genesis_ledger_path, genesis_entry_height, last_id, last_entry_id) =
create_tmp_sample_ledger(
"test_dropped_handoff_recovery",
10_000,
@ -1134,7 +1147,7 @@ fn test_dropped_handoff_recovery() {
&mint_keypair,
100,
ticks_per_slot,
&last_id,
&last_entry_id,
&last_id,
0,
);
@ -1268,17 +1281,19 @@ fn test_full_leader_validator_network() {
// Make a common mint and a genesis entry for both leader + validator's ledgers
let num_ending_ticks = 1;
let (mint_keypair, bootstrap_leader_ledger_path, genesis_entry_height, last_id) =
create_tmp_sample_ledger(
"test_full_leader_validator_network",
10_000,
num_ending_ticks,
bootstrap_leader_info.id,
500,
);
let last_tick_id = last_id;
let mut last_entry_id = last_id;
let (
mint_keypair,
bootstrap_leader_ledger_path,
genesis_entry_height,
last_id,
mut last_entry_id,
) = create_tmp_sample_ledger(
"test_full_leader_validator_network",
10_000,
num_ending_ticks,
bootstrap_leader_info.id,
500,
);
// Create a common ledger with entries in the beginnging that will add all the validators
// to the active set for leader election.
@ -1295,7 +1310,7 @@ fn test_full_leader_validator_network() {
100,
1,
&last_entry_id,
&last_tick_id,
&last_id,
0,
);
@ -1475,14 +1490,19 @@ fn test_broadcast_last_tick() {
let bootstrap_leader_info = bootstrap_leader_node.info.clone();
// Create leader ledger
let (_mint_keypair, bootstrap_leader_ledger_path, genesis_entry_height, _last_id) =
create_tmp_sample_ledger(
"test_broadcast_last_tick",
10_000,
0,
bootstrap_leader_info.id,
500,
);
let (
_mint_keypair,
bootstrap_leader_ledger_path,
genesis_entry_height,
_last_id,
_last_entry_id,
) = create_tmp_sample_ledger(
"test_broadcast_last_tick",
10_000,
0,
bootstrap_leader_info.id,
500,
);
let genesis_ledger_len = genesis_entry_height;
debug!("genesis_ledger_len: {}", genesis_ledger_len);
@ -1550,7 +1570,7 @@ fn test_broadcast_last_tick() {
bootstrap_leader_exit();
// Index of the last tick must be at least ticks_per_slot - 1
let last_tick_entry_index = ticks_per_slot as usize - 2;
let last_tick_entry_index = ticks_per_slot as usize - 1;
let entries = read_ledger(&bootstrap_leader_ledger_path);
assert!(entries.len() >= last_tick_entry_index + 1);
let expected_last_tick = &entries[last_tick_entry_index];

4
tests/replicator.rs
View File

@ -40,7 +40,7 @@ fn test_replicator_startup_basic() {
let leader_info = leader_node.info.clone();
let leader_ledger_path = "replicator_test_leader_ledger";
let (mint_keypair, leader_ledger_path, _last_entry_height, _last_entry_id) =
let (mint_keypair, leader_ledger_path, _last_entry_height, _last_id, _last_entry_id) =
create_tmp_sample_ledger(leader_ledger_path, 1_000_000_000, 0, leader_info.id, 42);
let validator_ledger_path =
@ -277,7 +277,7 @@ fn test_replicator_startup_ledger_hang() {
let leader_info = leader_node.info.clone();
let leader_ledger_path = "replicator_test_leader_ledger";
let (_mint_keypair, leader_ledger_path, _last_entry_height, _last_entry_id) =
let (_mint_keypair, leader_ledger_path, _last_entry_height, _last_id, _last_entry_id) =
create_tmp_sample_ledger(leader_ledger_path, 100, 0, leader_info.id, 42);
let validator_ledger_path =