gaspersic/solana
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

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

Browse Source
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] #[test]
fn nominal() { fn nominal() {
let keypair = Arc::new(Keypair::new()); 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); create_tmp_sample_ledger("test_ledger_tool_nominal", 100, 9, keypair.pubkey(), 50);
// Basic validation // Basic validation

41
src/bank.rs
View File

@ -817,25 +817,40 @@ impl Bank {
where where
I: IntoIterator<Item = Entry>, I: IntoIterator<Item = Entry>,
{ {
let mut entry_height = 0; let mut last_entry_id = self.last_id();
let mut last_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 // Ledger verification needs to be parallelized, but we can't pull the whole
// thing into memory. We therefore chunk it. // 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(); 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); warn!("Ledger proof of history failed at entry: {}", entry_height);
return Err(BankError::LedgerVerificationFailed); return Err(BankError::LedgerVerificationFailed);
} }
self.process_block(&block)?; self.process_block(&block)?;
last_id = block.last().unwrap().id; last_entry_id = block.last().unwrap().id;
entry_height += block.len() as u64; 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 /// Create, sign, and process a Transaction from `keypair` to `to` of
@ -1251,10 +1266,12 @@ mod tests {
) -> impl Iterator<Item = Entry> { ) -> impl Iterator<Item = Entry> {
let mut entries: Vec<Entry> = vec![]; 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 tick = Entry::new(&genesis_block.last_id(), 0, 1, vec![]);
let mut hash = tick.id; let mut hash = tick.id;
let mut last_id = tick.id;
entries.push(tick); entries.push(tick);
let num_hashes = 1; let num_hashes = 1;
@ -1281,10 +1298,12 @@ mod tests {
) -> impl Iterator<Item = Entry> { ) -> impl Iterator<Item = Entry> {
let mut entries = vec![]; 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 tick = Entry::new(&genesis_block.last_id(), 0, 1, vec![]);
let mut hash = tick.id; let mut hash = tick.id;
let mut last_id = tick.id;
entries.push(tick); entries.push(tick);
for i in 0..num_one_token_transfers { for i in 0..num_one_token_transfers {
@ -1351,7 +1370,7 @@ mod tests {
let (ledger_height, last_id) = bank.process_ledger(ledger).unwrap(); let (ledger_height, last_id) = bank.process_ledger(ledger).unwrap();
assert_eq!(bank.get_balance(&mint_keypair.pubkey()), 100 - 3); assert_eq!(bank.get_balance(&mint_keypair.pubkey()), 100 - 3);
assert_eq!(ledger_height, 8); assert_eq!(ledger_height, 8);
assert_eq!(bank.tick_height(), 2); assert_eq!(bank.tick_height(), 1);
assert_eq!(bank.last_id(), last_id); 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 // A placeholder slot does not contain all the ticks
false false
} else { } else {
let num_expected_ticks = { self.num_expected_ticks(blocktree) <= self.consumed_ticks
let num = self.num_expected_ticks(blocktree);
if self.slot_height == 0 {
num - 1
} else {
num
}
};
num_expected_ticks <= self.consumed_ticks
} }
} }
@ -1305,35 +1297,38 @@ pub fn get_tmp_ledger_path(name: &str) -> String {
path 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( pub fn create_tmp_sample_ledger(
name: &str, name: &str,
num_tokens: u64, num_tokens: u64,
num_extra_ticks: u64, num_extra_ticks: u64,
bootstrap_leader_id: Pubkey, bootstrap_leader_id: Pubkey,
bootstrap_leader_tokens: u64, bootstrap_leader_tokens: u64,
) -> (Keypair, String, u64, Hash) { ) -> (Keypair, String, u64, Hash, Hash) {
let (genesis_block, mint_keypair) = let (genesis_block, mint_keypair) =
GenesisBlock::new_with_leader(num_tokens, bootstrap_leader_id, bootstrap_leader_tokens); GenesisBlock::new_with_leader(num_tokens, bootstrap_leader_id, bootstrap_leader_tokens);
let ledger_path = get_tmp_ledger_path(name); 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 { 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(); let blocktree = Blocktree::open(&ledger_path).unwrap();
blocktree blocktree
.write_entries(DEFAULT_SLOT_HEIGHT, entry_height, &entries) .write_entries(DEFAULT_SLOT_HEIGHT, entry_height, &entries)
.unwrap(); .unwrap();
entry_height += entries.len() as u64; 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 { 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.next_slots, vec![i + 1]);
} }
assert_eq!(s.num_blocks, 1); assert_eq!(s.num_blocks, 1);
if i == 0 { assert_eq!(s.consumed_ticks, ticks_per_slot);
assert_eq!(s.consumed_ticks, ticks_per_slot - 1);
} else {
assert_eq!(s.consumed_ticks, ticks_per_slot);
}
assert!(s.is_trunk); assert!(s.is_trunk);
} }
} }
@ -2062,11 +2053,7 @@ mod tests {
} else { } else {
assert!(s.next_slots.is_empty()); assert!(s.next_slots.is_empty());
} }
if i == 0 { assert_eq!(s.consumed_ticks, ticks_per_slot);
assert_eq!(s.consumed_ticks, ticks_per_slot - 1);
} else {
assert_eq!(s.consumed_ticks, ticks_per_slot);
}
assert!(s.is_trunk); assert!(s.is_trunk);
} }
} }

48
src/fullnode.rs
View File

@ -580,7 +580,7 @@ mod tests {
let validator_keypair = Keypair::new(); let validator_keypair = Keypair::new();
let validator_node = Node::new_localhost_with_pubkey(validator_keypair.pubkey()); 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); create_tmp_sample_ledger("validator_exit", 10_000, 0, leader_keypair.pubkey(), 1000);
let validator = Fullnode::new( let validator = Fullnode::new(
@ -605,7 +605,13 @@ mod tests {
.map(|i| { .map(|i| {
let validator_keypair = Keypair::new(); let validator_keypair = Keypair::new();
let validator_node = Node::new_localhost_with_pubkey(validator_keypair.pubkey()); 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), &format!("validator_parallel_exit_{}", i),
10_000, 10_000,
0, 0,
@ -645,14 +651,19 @@ mod tests {
let bootstrap_leader_node = let bootstrap_leader_node =
Node::new_localhost_with_pubkey(bootstrap_leader_keypair.pubkey()); Node::new_localhost_with_pubkey(bootstrap_leader_keypair.pubkey());
let (_mint_keypair, bootstrap_leader_ledger_path, _genesis_entry_height, _last_id) = let (
create_tmp_sample_ledger( _mint_keypair,
"test_leader_to_leader_transition", bootstrap_leader_ledger_path,
10_000, _genesis_entry_height,
1, _last_id,
bootstrap_leader_keypair.pubkey(), _last_entry_id,
500, ) = 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 // 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 // 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 // Create validator identity
assert!(num_genesis_ticks <= ticks_per_block); assert!(num_genesis_ticks <= ticks_per_block);
let (mint_keypair, ledger_path, genesis_entry_height, last_id) = create_tmp_sample_ledger( let (mint_keypair, ledger_path, genesis_entry_height, last_id, last_entry_id) =
test_name, create_tmp_sample_ledger(
10_000, test_name,
num_genesis_ticks, 10_000,
leader_node.info.id, num_genesis_ticks,
500, leader_node.info.id,
); 500,
);
let validator_node = Node::new_localhost_with_pubkey(validator_keypair.pubkey()); let validator_node = Node::new_localhost_with_pubkey(validator_keypair.pubkey());
@ -1040,7 +1052,7 @@ mod tests {
&mint_keypair, &mint_keypair,
10, 10,
1, 1,
&last_id, &last_entry_id,
&last_id, &last_id,
num_ending_ticks, num_ending_ticks,
); );

37
src/replay_stage.rs
View File

@ -87,6 +87,7 @@ impl ReplayStage {
let mut res = Ok(()); let mut res = Ok(());
let mut num_entries_to_write = entries.len(); let mut num_entries_to_write = entries.len();
let now = Instant::now(); let now = Instant::now();
if !entries.as_slice().verify(&last_entry_id.read().unwrap()) { if !entries.as_slice().verify(&last_entry_id.read().unwrap()) {
inc_new_counter_info!("replicate_stage-verify-fail", entries.len()); inc_new_counter_info!("replicate_stage-verify-fail", entries.len());
return Err(Error::BlobError(BlobError::VerificationFailed)); return Err(Error::BlobError(BlobError::VerificationFailed));
@ -411,7 +412,7 @@ mod test {
let old_leader_id = Keypair::new().pubkey(); let old_leader_id = Keypair::new().pubkey();
// Create a ledger // 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( create_tmp_sample_ledger(
"test_replay_stage_leader_rotation_exit", "test_replay_stage_leader_rotation_exit",
10_000, 10_000,
@ -433,7 +434,7 @@ mod test {
&mint_keypair, &mint_keypair,
100, 100,
ticks_per_slot, // add a vote for tick_height = ticks_per_slot ticks_per_slot, // add a vote for tick_height = ticks_per_slot
&last_id, &last_entry_id,
&last_id, &last_id,
0, 0,
); );
@ -538,13 +539,14 @@ mod test {
// Create keypair for the leader // Create keypair for the leader
let leader_id = Keypair::new().pubkey(); let leader_id = Keypair::new().pubkey();
let (_, my_ledger_path, _, _) = create_tmp_sample_ledger( let (_mint_keypair, my_ledger_path, _last_entry_height, _last_id, _last_entry_id) =
"test_vote_error_replay_stage_correctness", create_tmp_sample_ledger(
10_000, "test_vote_error_replay_stage_correctness",
1, 10_000,
leader_id, 1,
500, leader_id,
); 500,
);
// Set up the cluster info // Set up the cluster info
let cluster_info_me = Arc::new(RwLock::new(ClusterInfo::new(my_node.info.clone()))); 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); let vote = VoteTransaction::new_vote(keypair, bank.tick_height(), bank.last_id(), 0);
cluster_info_me.write().unwrap().push_vote(vote); 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); let next_tick = create_ticks(1, last_entry_id);
blocktree blocktree
@ -592,7 +594,7 @@ mod test {
let received_tick = ledger_writer_recv let received_tick = ledger_writer_recv
.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); assert_eq!(next_tick, received_tick);
@ -617,7 +619,7 @@ mod test {
let leader_id = Keypair::new().pubkey(); let leader_id = Keypair::new().pubkey();
// Create the ledger // 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( create_tmp_sample_ledger(
"test_vote_error_replay_stage_leader_rotation", "test_vote_error_replay_stage_leader_rotation",
10_000, 10_000,
@ -630,8 +632,15 @@ mod test {
// Write two entries to the ledger so that the validator is in the active set: // 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. // 1) Give the validator a nonzero number of tokens 2) A vote from the validator.
// This will cause leader rotation after the bootstrap height // This will cause leader rotation after the bootstrap height
let (active_set_entries, voting_keypair) = let (active_set_entries, voting_keypair) = make_active_set_entries(
make_active_set_entries(&my_keypair, &mint_keypair, 100, 1, &last_id, &last_id, 0); &my_keypair,
&mint_keypair,
100,
1,
&last_entry_id,
&last_id,
0,
);
let mut last_id = active_set_entries.last().unwrap().id; let mut last_id = active_set_entries.last().unwrap().id;
let initial_tick_height = genesis_entry_height; 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 keypair = Arc::new(Keypair::new());
let exit = Arc::new(AtomicBool::new(false)); let exit = Arc::new(AtomicBool::new(false));
let (_mint, ledger_path, genesis_entry_height, _last_id) = create_tmp_sample_ledger( let (_mint, ledger_path, genesis_entry_height, _last_id, _last_entry_id) =
"storage_stage_process_entries", create_tmp_sample_ledger(
1000, "storage_stage_process_entries",
1, 1000,
Keypair::new().pubkey(), 1,
1, Keypair::new().pubkey(),
); 1,
);
let entries = make_tiny_test_entries(64); let entries = make_tiny_test_entries(64);
let blocktree = Blocktree::open(&ledger_path).unwrap(); let blocktree = Blocktree::open(&ledger_path).unwrap();
@ -560,13 +561,14 @@ mod tests {
let keypair = Arc::new(Keypair::new()); let keypair = Arc::new(Keypair::new());
let exit = Arc::new(AtomicBool::new(false)); let exit = Arc::new(AtomicBool::new(false));
let (_mint, ledger_path, genesis_entry_height, _last_id) = create_tmp_sample_ledger( let (_mint, ledger_path, genesis_entry_height, _last_id, _last_entry_id) =
"storage_stage_process_entries", create_tmp_sample_ledger(
1000, "storage_stage_process_entries",
1, 1000,
Keypair::new().pubkey(), 1,
1, Keypair::new().pubkey(),
); 1,
);
let entries = make_tiny_test_entries(128); let entries = make_tiny_test_entries(128);
let blocktree = Blocktree::open(&ledger_path).unwrap(); 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 = Node::new_localhost_with_pubkey(node_keypair.pubkey());
let node_info = node.info.clone(); 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); create_tmp_sample_ledger(ledger_name, 10_000, 0, node_info.id, 42);
let vote_account_keypair = Arc::new(Keypair::new()); 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 bob_pubkey = Keypair::new().pubkey();
let mut ledger_paths = Vec::new(); 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); create_tmp_sample_ledger("multi_node_ledger_window", 10_000, 0, leader_data.id, 500);
ledger_paths.push(leader_ledger_path.clone()); 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 blocktree = Blocktree::open(&leader_ledger_path).unwrap();
let entries = solana::entry::create_ticks( 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, last_entry_id,
); );
blocktree blocktree
@ -164,13 +164,14 @@ fn test_multi_node_validator_catchup_from_zero() -> result::Result<()> {
let bob_pubkey = Keypair::new().pubkey(); let bob_pubkey = Keypair::new().pubkey();
let mut ledger_paths = Vec::new(); let mut ledger_paths = Vec::new();
let (alice, genesis_ledger_path, _last_entry_height, _last_entry_id) = create_tmp_sample_ledger( let (alice, genesis_ledger_path, _last_entry_height, _last_id, _last_entry_id) =
"multi_node_validator_catchup_from_zero", create_tmp_sample_ledger(
10_000, "multi_node_validator_catchup_from_zero",
0, 10_000,
leader_data.id, 0,
500, leader_data.id,
); 500,
);
ledger_paths.push(genesis_ledger_path.clone()); ledger_paths.push(genesis_ledger_path.clone());
let zero_ledger_path = tmp_copy_ledger( let zero_ledger_path = tmp_copy_ledger(
@ -353,7 +354,7 @@ fn test_multi_node_basic() {
let bob_pubkey = Keypair::new().pubkey(); let bob_pubkey = Keypair::new().pubkey();
let mut ledger_paths = Vec::new(); 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); create_tmp_sample_ledger("multi_node_basic", 10_000, 0, leader_data.id, 500);
ledger_paths.push(genesis_ledger_path.clone()); 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 bob_pubkey = Keypair::new().pubkey();
let mut ledger_paths = Vec::new(); 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); create_tmp_sample_ledger("boot_validator_from_file", 100_000, 0, leader_pubkey, 1000);
ledger_paths.push(genesis_ledger_path.clone()); 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 leader_keypair = Arc::new(Keypair::new());
let initial_leader_balance = 500; let initial_leader_balance = 500;
let (alice, ledger_path, _last_entry_height, _last_entry_id) = create_tmp_sample_ledger( let (alice, ledger_path, _last_entry_height, _last_id, _last_entry_id) =
"leader_restart_validator_start_from_old_ledger", create_tmp_sample_ledger(
100_000 + 500 * solana::window_service::MAX_REPAIR_BACKOFF as u64, "leader_restart_validator_start_from_old_ledger",
0, 100_000 + 500 * solana::window_service::MAX_REPAIR_BACKOFF as u64,
leader_keypair.pubkey(), 0,
initial_leader_balance, leader_keypair.pubkey(),
); initial_leader_balance,
);
let bob_pubkey = Keypair::new().pubkey(); 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_pubkey = leader_keypair.pubkey().clone();
let leader = Node::new_localhost_with_pubkey(leader_keypair.pubkey()); let leader = Node::new_localhost_with_pubkey(leader_keypair.pubkey());
let bob_pubkey = Keypair::new().pubkey(); let bob_pubkey = Keypair::new().pubkey();
let (alice, genesis_ledger_path, _last_entry_height, _last_entry_id) = create_tmp_sample_ledger( let (alice, genesis_ledger_path, _last_entry_height, _last_id, _last_entry_id) =
"multi_node_dynamic_network", create_tmp_sample_ledger(
10_000_000, "multi_node_dynamic_network",
0, 10_000_000,
leader_pubkey, 0,
500, leader_pubkey,
); 500,
);
let mut ledger_paths = Vec::new(); let mut ledger_paths = Vec::new();
ledger_paths.push(genesis_ledger_path.clone()); 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 // Initialize the leader ledger. Make a mint and a genesis entry
// in the leader ledger // 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( create_tmp_sample_ledger(
"test_leader_to_validator_transition", "test_leader_to_validator_transition",
10_000, 10_000,
@ -878,7 +881,7 @@ fn test_leader_to_validator_transition() {
&mint_keypair, &mint_keypair,
100, 100,
ticks_per_slot, ticks_per_slot,
&last_id, &last_entry_id,
&last_id, &last_id,
0, 0,
); );
@ -963,7 +966,7 @@ fn test_leader_validator_basic() {
info!("validator id: {}", validator_keypair.pubkey()); info!("validator id: {}", validator_keypair.pubkey());
// Make a common mint and a genesis entry for both leader + validator ledgers // 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( create_tmp_sample_ledger(
"test_leader_validator_basic", "test_leader_validator_basic",
10_000, 10_000,
@ -978,7 +981,7 @@ fn test_leader_validator_basic() {
&mint_keypair, &mint_keypair,
100, 100,
1, 1,
&last_id, &last_entry_id,
&last_id, &last_id,
0, 0,
); );
@ -1036,30 +1039,40 @@ fn test_leader_validator_basic() {
converge(&leader_info, 2); converge(&leader_info, 2);
info!("Waiting for slot 0 -> slot 1: bootstrap leader will remain the leader"); info!("Waiting for slot 0 -> slot 1: bootstrap leader and the validator rotate");
assert_eq!(
leader_rotation_receiver.recv().unwrap(),
(FullnodeReturnType::LeaderToLeaderRotation, ticks_per_slot,)
);
info!("Waiting for slot 1 -> slot 2: bootstrap leader becomes a validator");
assert_eq!( assert_eq!(
leader_rotation_receiver.recv().unwrap(), leader_rotation_receiver.recv().unwrap(),
( (
FullnodeReturnType::LeaderToValidatorRotation, FullnodeReturnType::LeaderToValidatorRotation,
ticks_per_slot * 2, ticks_per_slot,
) )
); );
info!("Waiting for slot 1 -> slot 2: validator becomes the leader");
assert_eq!( assert_eq!(
validator_rotation_receiver.recv().unwrap(), validator_rotation_receiver.recv().unwrap(),
( (
FullnodeReturnType::ValidatorToLeaderRotation, 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, 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"); info!("Shut down");
validator_exit(); validator_exit();
leader_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 // Make a common mint and a genesis entry for both leader + validator's ledgers
let num_ending_ticks = 1; 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( create_tmp_sample_ledger(
"test_dropped_handoff_recovery", "test_dropped_handoff_recovery",
10_000, 10_000,
@ -1134,7 +1147,7 @@ fn test_dropped_handoff_recovery() {
&mint_keypair, &mint_keypair,
100, 100,
ticks_per_slot, ticks_per_slot,
&last_id, &last_entry_id,
&last_id, &last_id,
0, 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 // Make a common mint and a genesis entry for both leader + validator's ledgers
let num_ending_ticks = 1; let num_ending_ticks = 1;
let (mint_keypair, bootstrap_leader_ledger_path, genesis_entry_height, last_id) = let (
create_tmp_sample_ledger( mint_keypair,
"test_full_leader_validator_network", bootstrap_leader_ledger_path,
10_000, genesis_entry_height,
num_ending_ticks, last_id,
bootstrap_leader_info.id, mut last_entry_id,
500, ) = create_tmp_sample_ledger(
); "test_full_leader_validator_network",
10_000,
let last_tick_id = last_id; num_ending_ticks,
let mut last_entry_id = last_id; bootstrap_leader_info.id,
500,
);
// Create a common ledger with entries in the beginnging that will add all the validators // Create a common ledger with entries in the beginnging that will add all the validators
// to the active set for leader election. // to the active set for leader election.
@ -1295,7 +1310,7 @@ fn test_full_leader_validator_network() {
100, 100,
1, 1,
&last_entry_id, &last_entry_id,
&last_tick_id, &last_id,
0, 0,
); );
@ -1475,14 +1490,19 @@ fn test_broadcast_last_tick() {
let bootstrap_leader_info = bootstrap_leader_node.info.clone(); let bootstrap_leader_info = bootstrap_leader_node.info.clone();
// Create leader ledger // Create leader ledger
let (_mint_keypair, bootstrap_leader_ledger_path, genesis_entry_height, _last_id) = let (
create_tmp_sample_ledger( _mint_keypair,
"test_broadcast_last_tick", bootstrap_leader_ledger_path,
10_000, genesis_entry_height,
0, _last_id,
bootstrap_leader_info.id, _last_entry_id,
500, ) = create_tmp_sample_ledger(
); "test_broadcast_last_tick",
10_000,
0,
bootstrap_leader_info.id,
500,
);
let genesis_ledger_len = genesis_entry_height; let genesis_ledger_len = genesis_entry_height;
debug!("genesis_ledger_len: {}", genesis_ledger_len); debug!("genesis_ledger_len: {}", genesis_ledger_len);
@ -1550,7 +1570,7 @@ fn test_broadcast_last_tick() {
bootstrap_leader_exit(); bootstrap_leader_exit();
// Index of the last tick must be at least ticks_per_slot - 1 // 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); let entries = read_ledger(&bootstrap_leader_ledger_path);
assert!(entries.len() >= last_tick_entry_index + 1); assert!(entries.len() >= last_tick_entry_index + 1);
let expected_last_tick = &entries[last_tick_entry_index]; 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_info = leader_node.info.clone();
let leader_ledger_path = "replicator_test_leader_ledger"; 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); create_tmp_sample_ledger(leader_ledger_path, 1_000_000_000, 0, leader_info.id, 42);
let validator_ledger_path = let validator_ledger_path =
@ -277,7 +277,7 @@ fn test_replicator_startup_ledger_hang() {
let leader_info = leader_node.info.clone(); let leader_info = leader_node.info.clone();
let leader_ledger_path = "replicator_test_leader_ledger"; 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); create_tmp_sample_ledger(leader_ledger_path, 100, 0, leader_info.id, 42);
let validator_ledger_path = let validator_ledger_path =