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

create_tmp_sample_ledger() now returns entry_height and last_id

This commit is contained in:
Michael Vines 2019-01-29 20:57:38 -08:00
parent 883fc39c80
commit 8cc1cde0fe
6 changed files with 155 additions and 222 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 (_genesis_block, _mint, ledger_path, _genesis_entries) =
let (_, _, ledger_path, _, _) =
create_tmp_sample_ledger("test_ledger_tool_nominal", 100, 10, keypair.pubkey(), 50);
// Basic validation

24
src/db_ledger.rs
View File

@ -830,11 +830,11 @@ impl Iterator for EntryIterator {
}
}
pub fn create_empty_ledger(ledger_path: &str, genesis_block: &GenesisBlock) -> Result<()> {
pub fn create_empty_ledger(ledger_path: &str, genesis_block: &GenesisBlock) -> Result<(u64, Hash)> {
DbLedger::destroy(ledger_path)?;
DbLedger::open(ledger_path)?;
genesis_block.write(&ledger_path)?;
Ok(())
Ok((0, genesis_block.last_id()))
}
pub fn genesis<'a, I>(ledger_path: &str, keypair: &Keypair, entries: I) -> Result<()>
@ -898,19 +898,23 @@ pub fn create_tmp_sample_ledger(
num_ending_ticks: u64,
bootstrap_leader_id: Pubkey,
bootstrap_leader_tokens: u64,
) -> (GenesisBlock, Keypair, String, Vec<Entry>) {
) -> (GenesisBlock, Keypair, String, u64, Hash) {
let (genesis_block, mint_keypair) =
GenesisBlock::new_with_leader(num_tokens, bootstrap_leader_id, bootstrap_leader_tokens);
let path = get_tmp_ledger_path(name);
create_empty_ledger(&path, &genesis_block).unwrap();
let (mut entry_height, mut last_id) = create_empty_ledger(&path, &genesis_block).unwrap();
let entries = crate::entry::create_ticks(num_ending_ticks, genesis_block.last_id());
if num_ending_ticks > 0 {
let entries = crate::entry::create_ticks(num_ending_ticks, last_id);
let db_ledger = DbLedger::open(&path).unwrap();
db_ledger
.write_entries(DEFAULT_SLOT_HEIGHT, 0, &entries)
.unwrap();
(genesis_block, mint_keypair, path, entries)
let db_ledger = DbLedger::open(&path).unwrap();
db_ledger
.write_entries(DEFAULT_SLOT_HEIGHT, entry_height, &entries)
.unwrap();
entry_height += entries.len() as u64;
last_id = entries.last().unwrap().id
}
(genesis_block, mint_keypair, path, entry_height, last_id)
}
pub fn tmp_copy_ledger(from: &str, name: &str) -> String {

116
src/fullnode.rs
View File

@ -531,19 +531,19 @@ mod tests {
let bootstrap_leader_info = bootstrap_leader_node.info.clone();
// Make a mint and a genesis entries for leader ledger
let num_ending_ticks = 1;
let (_genesis_block, _mint_keypair, bootstrap_leader_ledger_path, genesis_entries) =
create_tmp_sample_ledger(
"test_leader_to_leader_transition",
10_000,
num_ending_ticks,
bootstrap_leader_keypair.pubkey(),
500,
);
let initial_tick_height = genesis_entries
.iter()
.fold(0, |tick_count, entry| tick_count + entry.is_tick() as u64);
let (
_genesis_block,
_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,
);
// Create the common leader scheduling configuration
let num_slots_per_epoch = 3;
@ -556,9 +556,8 @@ mod tests {
// choices in the active set, this leader will remain the leader in the next
// epoch. In the next epoch, check that the same leader knows to shut down and
// restart as a leader again.
let bootstrap_height = initial_tick_height + 1;
let leader_scheduler_config = LeaderSchedulerConfig::new(
bootstrap_height as u64,
2,
leader_rotation_interval,
seed_rotation_interval,
active_window_length,
@ -591,6 +590,8 @@ mod tests {
#[test]
fn test_wrong_role_transition() {
solana_logger::setup();
// Create the leader node information
let bootstrap_leader_keypair = Arc::new(Keypair::new());
let bootstrap_leader_node =
@ -602,43 +603,32 @@ mod tests {
let validator_node = Node::new_localhost_with_pubkey(validator_keypair.pubkey());
// Make a common mint and a genesis entry for both leader + validator's ledgers
let num_ending_ticks = 3;
let (_genesis_block, mint_keypair, bootstrap_leader_ledger_path, genesis_entries) =
create_tmp_sample_ledger(
"test_wrong_role_transition",
10_000,
num_ending_ticks,
bootstrap_leader_keypair.pubkey(),
500,
);
let last_id = genesis_entries
.last()
.expect("expected at least one genesis entry")
.id;
let (
_genesis_block,
mint_keypair,
bootstrap_leader_ledger_path,
genesis_entry_height,
last_id,
) = create_tmp_sample_ledger(
"test_wrong_role_transition",
10_000,
0,
bootstrap_leader_keypair.pubkey(),
500,
);
// Write the entries to the ledger that will cause leader rotation
// after the bootstrap height
let validator_keypair = Arc::new(validator_keypair);
let (active_set_entries, validator_vote_account_id) = make_active_set_entries(
&validator_keypair,
&mint_keypair,
&last_id,
&last_id,
num_ending_ticks,
);
let genesis_tick_height = genesis_entries
.iter()
.fold(0, |tick_count, entry| tick_count + entry.is_tick() as u64)
+ num_ending_ticks as u64;
let (active_set_entries, _) =
make_active_set_entries(&validator_keypair, &mint_keypair, &last_id, &last_id, 10);
{
let db_ledger = DbLedger::open(&bootstrap_leader_ledger_path).unwrap();
db_ledger
.write_entries(
DEFAULT_SLOT_HEIGHT,
genesis_entries.len() as u64,
genesis_entry_height,
&active_set_entries,
)
.unwrap();
@ -652,30 +642,26 @@ mod tests {
];
// Create the common leader scheduling configuration
let num_slots_per_epoch = 3;
let leader_rotation_interval = 5;
let seed_rotation_interval = num_slots_per_epoch * leader_rotation_interval;
let leader_rotation_interval = 3;
// Set the bootstrap height exactly the current tick height, so that we can
// test if the bootstrap leader knows to immediately transition to a validator
// after parsing the ledger during startup
let bootstrap_height = genesis_tick_height;
let leader_scheduler_config = LeaderSchedulerConfig::new(
bootstrap_height,
1,
leader_rotation_interval,
seed_rotation_interval,
genesis_tick_height,
leader_rotation_interval,
leader_rotation_interval * 10,
);
{
// Test that a node knows to transition to a validator based on parsing the ledger
let vote_signer = VoteSignerProxy::new_local(&bootstrap_leader_keypair);
let bootstrap_leader = Fullnode::new(
bootstrap_leader_node,
bootstrap_leader_keypair,
&bootstrap_leader_ledger_path,
Arc::new(RwLock::new(LeaderScheduler::new(&leader_scheduler_config))),
Some(Arc::new(vote_signer)),
None,
Some(&bootstrap_leader_info),
Default::default(),
);
@ -688,7 +674,7 @@ mod tests {
validator_keypair,
&validator_ledger_path,
Arc::new(RwLock::new(LeaderScheduler::new(&leader_scheduler_config))),
Some(Arc::new(validator_vote_account_id)),
None,
Some(&bootstrap_leader_info),
Default::default(),
);
@ -714,12 +700,11 @@ mod tests {
let leader_id = leader_node.info.id;
// Create validator identity
let num_ending_ticks = 1;
let (_genesis_block, mint_keypair, validator_ledger_path, genesis_entries) =
let (_genesis_block, mint_keypair, validator_ledger_path, genesis_entry_height, last_id) =
create_tmp_sample_ledger(
"test_validator_to_leader_transition",
10_000,
num_ending_ticks,
1,
leader_id,
500,
);
@ -728,11 +713,6 @@ mod tests {
let validator_node = Node::new_localhost_with_pubkey(validator_keypair.pubkey());
let validator_info = validator_node.info.clone();
let mut last_id = genesis_entries
.last()
.expect("expected at least one genesis entry")
.id;
let validator_keypair = Arc::new(validator_keypair);
// Write two entries so that the validator is in the active set:
//
@ -741,27 +721,23 @@ mod tests {
// after the bootstrap height
//
// 2) A vote from the validator
let (active_set_entries, _validator_vote_account_id) =
let (active_set_entries, _) =
make_active_set_entries(&validator_keypair, &mint_keypair, &last_id, &last_id, 0);
let initial_tick_height = genesis_entries
.iter()
.fold(0, |tick_count, entry| tick_count + entry.is_tick() as u64);
let initial_non_tick_height = genesis_entries.len() as u64 - initial_tick_height;
let active_set_entries_len = active_set_entries.len() as u64;
last_id = active_set_entries.last().unwrap().id;
let last_id = active_set_entries.last().unwrap().id;
{
let db_ledger = DbLedger::open(&validator_ledger_path).unwrap();
db_ledger
.write_entries(
DEFAULT_SLOT_HEIGHT,
genesis_entries.len() as u64,
genesis_entry_height,
&active_set_entries,
)
.unwrap();
}
let ledger_initial_len = genesis_entries.len() as u64 + active_set_entries_len;
let ledger_initial_len = genesis_entry_height + active_set_entries_len;
// Set the leader scheduler for the validator
let leader_rotation_interval = 16;
@ -850,9 +826,7 @@ mod tests {
assert!(bank.tick_height() >= bootstrap_height);
// Only the first genesis entry has num_hashes = 0, every other entry
// had num_hashes = 1
assert!(
entry_height >= bootstrap_height + active_set_entries_len + initial_non_tick_height
);
assert!(entry_height >= bootstrap_height + active_set_entries_len);
// Shut down
t_responder.join().expect("responder thread join");

117
src/replay_stage.rs
View File

@ -64,7 +64,7 @@ impl ReplayStage {
cluster_info: &Arc<RwLock<ClusterInfo>>,
window_receiver: &EntryReceiver,
keypair: &Arc<Keypair>,
vote_signer: Option<&Arc<VoteSignerProxy>>,
vote_signer_proxy: Option<&Arc<VoteSignerProxy>>,
vote_blob_sender: Option<&BlobSender>,
ledger_entry_sender: &EntrySender,
entry_height: &Arc<RwLock<u64>>,
@ -146,7 +146,7 @@ impl ReplayStage {
}
if 0 == num_ticks_to_next_vote {
if let Some(signer) = vote_signer {
if let Some(signer) = vote_signer_proxy {
if let Some(sender) = vote_blob_sender {
signer
.send_validator_vote(bank, &cluster_info, sender)
@ -206,7 +206,7 @@ impl ReplayStage {
#[allow(clippy::new_ret_no_self, clippy::too_many_arguments)]
pub fn new(
keypair: Arc<Keypair>,
vote_signer: Option<Arc<VoteSignerProxy>>,
vote_signer_proxy: Option<Arc<VoteSignerProxy>>,
bank: Arc<Bank>,
cluster_info: Arc<RwLock<ClusterInfo>>,
window_receiver: EntryReceiver,
@ -252,7 +252,7 @@ impl ReplayStage {
&cluster_info,
&window_receiver,
&keypair,
vote_signer.as_ref(),
vote_signer_proxy.as_ref(),
Some(&vote_blob_sender),
&ledger_entry_sender,
&entry_height_.clone(),
@ -328,38 +328,33 @@ mod test {
// Create a ledger
let num_ending_ticks = 3;
let (_, mint_keypair, my_ledger_path, genesis_entries) = create_tmp_sample_ledger(
"test_replay_stage_leader_rotation_exit",
10_000,
num_ending_ticks,
old_leader_id,
500,
);
let mut last_id = genesis_entries
.last()
.expect("expected at least one genesis entry")
.id;
let (_, mint_keypair, my_ledger_path, genesis_entry_height, mut last_id) =
create_tmp_sample_ledger(
"test_replay_stage_leader_rotation_exit",
10_000,
num_ending_ticks,
old_leader_id,
500,
);
let my_keypair = Arc::new(my_keypair);
// 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, vote_account_id) =
let (active_set_entries, vote_signer_proxy) =
make_active_set_entries(&my_keypair, &mint_keypair, &last_id, &last_id, 0);
last_id = active_set_entries.last().unwrap().id;
let initial_tick_height = genesis_entries
.iter()
.fold(0, |tick_count, entry| tick_count + entry.is_tick() as u64);
let initial_tick_height = genesis_entry_height;
let active_set_entries_len = active_set_entries.len() as u64;
let initial_non_tick_height = genesis_entries.len() as u64 - initial_tick_height;
let initial_entry_len = genesis_entries.len() as u64 + active_set_entries_len;
let initial_non_tick_height = genesis_entry_height - initial_tick_height;
let initial_entry_len = genesis_entry_height + active_set_entries_len;
{
let db_ledger = DbLedger::open(&my_ledger_path).unwrap();
db_ledger
.write_entries(
DEFAULT_SLOT_HEIGHT,
genesis_entries.len() as u64,
genesis_entry_height,
&active_set_entries,
)
.unwrap();
@ -390,7 +385,7 @@ mod test {
let exit = Arc::new(AtomicBool::new(false));
let (_replay_stage, ledger_writer_recv) = ReplayStage::new(
my_keypair,
Some(Arc::new(vote_account_id)),
Some(Arc::new(vote_signer_proxy)),
Arc::new(bank),
Arc::new(RwLock::new(cluster_info_me)),
entry_receiver,
@ -466,19 +461,16 @@ mod test {
let leader_scheduler = Arc::new(RwLock::new(LeaderScheduler::default()));
let num_ending_ticks = 1;
let (_genesis_block, _mint_keypair, my_ledger_path, genesis_entries) =
create_tmp_sample_ledger(
"test_vote_error_replay_stage_correctness",
10_000,
num_ending_ticks,
leader_id,
500,
);
let initial_entry_len = genesis_entries.len();
let (_, _, my_ledger_path, _, _) = create_tmp_sample_ledger(
"test_vote_error_replay_stage_correctness",
10_000,
num_ending_ticks,
leader_id,
500,
);
// Set up the bank
let (bank, _, last_entry_id) =
let (bank, entry_height, last_id) =
Fullnode::new_bank_from_ledger(&my_ledger_path, leader_scheduler);
// Set up the cluster info
@ -489,17 +481,17 @@ mod test {
let (entry_sender, entry_receiver) = channel();
let exit = Arc::new(AtomicBool::new(false));
let my_keypair = Arc::new(my_keypair);
let vote_signer = Arc::new(VoteSignerProxy::new_local(&my_keypair));
let vote_signer_proxy = Arc::new(VoteSignerProxy::new_local(&my_keypair));
let (to_leader_sender, _) = channel();
let (replay_stage, ledger_writer_recv) = ReplayStage::new(
my_keypair.clone(),
Some(vote_signer.clone()),
Some(vote_signer_proxy.clone()),
bank.clone(),
cluster_info_me.clone(),
entry_receiver,
exit.clone(),
Arc::new(RwLock::new(initial_entry_len as u64)),
Arc::new(RwLock::new(last_entry_id)),
Arc::new(RwLock::new(entry_height)),
Arc::new(RwLock::new(last_id)),
to_leader_sender,
None,
);
@ -507,16 +499,11 @@ mod test {
// Vote sender should error because no leader contact info is found in the
// ClusterInfo
let (mock_sender, _mock_receiver) = channel();
let _vote_err = vote_signer.send_validator_vote(&bank, &cluster_info_me, &mock_sender);
let _vote_err =
vote_signer_proxy.send_validator_vote(&bank, &cluster_info_me, &mock_sender);
// Send ReplayStage an entry, should see it on the ledger writer receiver
let next_tick = create_ticks(
1,
genesis_entries
.last()
.expect("Expected nonzero number of entries in genesis")
.id,
);
let next_tick = create_ticks(1, last_id);
entry_sender
.send(next_tick.clone())
.expect("Error sending entry to ReplayStage");
@ -543,7 +530,7 @@ mod test {
let leader_id = Keypair::new().pubkey();
// Create the ledger
let (_genesis_block, mint_keypair, my_ledger_path, genesis_entries) =
let (_genesis_block, mint_keypair, my_ledger_path, genesis_entry_height, last_id) =
create_tmp_sample_ledger(
"test_vote_error_replay_stage_leader_rotation",
10_000,
@ -552,31 +539,24 @@ mod test {
500,
);
let mut last_id = genesis_entries
.last()
.expect("expected at least one genesis entry")
.id;
let my_keypair = Arc::new(my_keypair);
// 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, vote_account_id) =
let (active_set_entries, vote_signer_proxy) =
make_active_set_entries(&my_keypair, &mint_keypair, &last_id, &last_id, 0);
last_id = active_set_entries.last().unwrap().id;
let initial_tick_height = genesis_entries
.iter()
.fold(0, |tick_count, entry| tick_count + entry.is_tick() as u64);
let mut last_id = active_set_entries.last().unwrap().id;
let initial_tick_height = genesis_entry_height;
let active_set_entries_len = active_set_entries.len() as u64;
let initial_non_tick_height = genesis_entries.len() as u64 - initial_tick_height;
let initial_entry_len = genesis_entries.len() as u64 + active_set_entries_len;
let initial_non_tick_height = genesis_entry_height - initial_tick_height;
let initial_entry_len = genesis_entry_height + active_set_entries_len;
{
let db_ledger = DbLedger::open(&my_ledger_path).unwrap();
db_ledger
.write_entries(
DEFAULT_SLOT_HEIGHT,
genesis_entries.len() as u64,
genesis_entry_height,
&active_set_entries,
)
.unwrap();
@ -605,14 +585,14 @@ mod test {
let cluster_info_me = Arc::new(RwLock::new(ClusterInfo::new(my_node.info.clone())));
// Set up the replay stage
let signer_proxy = Arc::new(vote_account_id);
let vote_signer_proxy = Arc::new(vote_signer_proxy);
let bank = Arc::new(bank);
let (entry_sender, entry_receiver) = channel();
let (rotation_tx, rotation_rx) = channel();
let exit = Arc::new(AtomicBool::new(false));
let (_replay_stage, ledger_writer_recv) = ReplayStage::new(
my_keypair.clone(),
Some(signer_proxy.clone()),
Some(vote_signer_proxy.clone()),
bank.clone(),
cluster_info_me.clone(),
entry_receiver,
@ -626,7 +606,8 @@ mod test {
// Vote sender should error because no leader contact info is found in the
// ClusterInfo
let (mock_sender, _mock_receiver) = channel();
let _vote_err = signer_proxy.send_validator_vote(&bank, &cluster_info_me, &mock_sender);
let _vote_err =
vote_signer_proxy.send_validator_vote(&bank, &cluster_info_me, &mock_sender);
// Send enough ticks to trigger leader rotation
let total_entries_to_send = (bootstrap_height - initial_tick_height) as usize;
@ -705,13 +686,13 @@ mod test {
.expect("Expected to err out");
let my_keypair = Arc::new(my_keypair);
let vote_signer = Arc::new(VoteSignerProxy::new_local(&my_keypair));
let vote_signer_proxy = Arc::new(VoteSignerProxy::new_local(&my_keypair));
let res = ReplayStage::process_entries(
&Arc::new(Bank::default()),
&cluster_info_me,
&entry_receiver,
&my_keypair,
Some(&vote_signer),
Some(&vote_signer_proxy),
None,
&ledger_entry_sender,
&Arc::new(RwLock::new(entry_height)),
@ -738,7 +719,7 @@ mod test {
&cluster_info_me,
&entry_receiver,
&Arc::new(Keypair::new()),
Some(&vote_signer),
Some(&vote_signer_proxy),
None,
&ledger_entry_sender,
&Arc::new(RwLock::new(entry_height)),
@ -787,13 +768,13 @@ mod test {
.expect("Expected to err out");
let my_keypair = Arc::new(my_keypair);
let vote_signer = Arc::new(VoteSignerProxy::new_local(&my_keypair));
let vote_signer_proxy = Arc::new(VoteSignerProxy::new_local(&my_keypair));
ReplayStage::process_entries(
&Arc::new(Bank::default()),
&cluster_info_me,
&entry_receiver,
&my_keypair,
Some(&vote_signer),
Some(&vote_signer_proxy),
None,
&ledger_entry_sender,
&Arc::new(RwLock::new(entry_height)),

34
src/storage_stage.rs
View File

@ -498,18 +498,19 @@ mod tests {
let keypair = Arc::new(Keypair::new());
let exit = Arc::new(AtomicBool::new(false));
let (_genesis_block, _mint, ledger_path, genesis_entries) = create_tmp_sample_ledger(
"storage_stage_process_entries",
1000,
1,
Keypair::new().pubkey(),
1,
);
let (_genesis_block, _mint, ledger_path, genesis_entry_height, _last_id) =
create_tmp_sample_ledger(
"storage_stage_process_entries",
1000,
1,
Keypair::new().pubkey(),
1,
);
let entries = make_tiny_test_entries(64);
let db_ledger = DbLedger::open(&ledger_path).unwrap();
db_ledger
.write_entries(DEFAULT_SLOT_HEIGHT, genesis_entries.len() as u64, &entries)
.write_entries(DEFAULT_SLOT_HEIGHT, genesis_entry_height, &entries)
.unwrap();
let cluster_info = test_cluster_info(keypair.pubkey());
@ -566,18 +567,19 @@ mod tests {
let keypair = Arc::new(Keypair::new());
let exit = Arc::new(AtomicBool::new(false));
let (_genesis_block, _mint, ledger_path, genesis_entries) = create_tmp_sample_ledger(
"storage_stage_process_entries",
1000,
1,
Keypair::new().pubkey(),
1,
);
let (_genesis_block, _mint, ledger_path, genesis_entry_height, _last_id) =
create_tmp_sample_ledger(
"storage_stage_process_entries",
1000,
1,
Keypair::new().pubkey(),
1,
);
let entries = make_tiny_test_entries(128);
let db_ledger = DbLedger::open(&ledger_path).unwrap();
db_ledger
.write_entries(DEFAULT_SLOT_HEIGHT, genesis_entries.len() as u64, &entries)
.write_entries(DEFAULT_SLOT_HEIGHT, genesis_entry_height, &entries)
.unwrap();
let cluster_info = test_cluster_info(keypair.pubkey());

84
tests/multinode.rs
View File

@ -965,7 +965,7 @@ fn test_leader_to_validator_transition() {
// Initialize the leader ledger. Make a mint and a genesis entry
// in the leader ledger
let num_ending_ticks = 1;
let (_genesis_block, mint_keypair, leader_ledger_path, genesis_entries) =
let (_genesis_block, mint_keypair, leader_ledger_path, genesis_entry_height, last_id) =
create_tmp_sample_ledger(
"test_leader_to_validator_transition",
10_000,
@ -974,11 +974,6 @@ fn test_leader_to_validator_transition() {
500,
);
let last_id = genesis_entries
.last()
.expect("expected at least one genesis entry")
.id;
// Write the bootstrap entries to the ledger that will cause leader rotation
// after the bootstrap height
let (bootstrap_entries, _) =
@ -988,7 +983,7 @@ fn test_leader_to_validator_transition() {
db_ledger
.write_entries(
DEFAULT_SLOT_HEIGHT,
genesis_entries.len() as u64,
genesis_entry_height,
&bootstrap_entries,
)
.unwrap();
@ -1110,7 +1105,7 @@ fn test_leader_validator_basic() {
// Make a common mint and a genesis entry for both leader + validator ledgers
let num_ending_ticks = 1;
let (_genesis_block, mint_keypair, leader_ledger_path, genesis_entries) =
let (_genesis_block, mint_keypair, leader_ledger_path, genesis_entry_height, last_id) =
create_tmp_sample_ledger(
"test_leader_validator_basic",
10_000,
@ -1121,11 +1116,6 @@ fn test_leader_validator_basic() {
let validator_ledger_path = tmp_copy_ledger(&leader_ledger_path, "test_leader_validator_basic");
let last_id = genesis_entries
.last()
.expect("expected at least one genesis entry")
.id;
// Initialize both leader + validator ledger
let mut ledger_paths = Vec::new();
ledger_paths.push(leader_ledger_path.clone());
@ -1133,14 +1123,14 @@ fn test_leader_validator_basic() {
// Write the bootstrap entries to the ledger that will cause leader rotation
// after the bootstrap height
let (active_set_entries, _vote_account_keypair) =
let (active_set_entries, _) =
make_active_set_entries(&validator_keypair, &mint_keypair, &last_id, &last_id, 0);
{
let db_ledger = DbLedger::open(&leader_ledger_path).unwrap();
db_ledger
.write_entries(
DEFAULT_SLOT_HEIGHT,
genesis_entries.len() as u64,
genesis_entry_height,
&active_set_entries,
)
.unwrap();
@ -1298,7 +1288,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 (_genesis_block, mint_keypair, genesis_ledger_path, genesis_entries) =
let (_genesis_block, mint_keypair, genesis_ledger_path, genesis_entry_height, last_id) =
create_tmp_sample_ledger(
"test_dropped_handoff_recovery",
10_000,
@ -1307,11 +1297,6 @@ fn test_dropped_handoff_recovery() {
500,
);
let last_id = genesis_entries
.last()
.expect("expected at least one genesis entry")
.id;
// Create the validator keypair that will be the next leader in line
let next_leader_keypair = Arc::new(Keypair::new());
@ -1323,7 +1308,7 @@ fn test_dropped_handoff_recovery() {
// Make the entries to give the next_leader validator some stake so that they will be in
// leader election active set
let (active_set_entries, _vote_account_keypair) =
let (active_set_entries, _) =
make_active_set_entries(&next_leader_keypair, &mint_keypair, &last_id, &last_id, 0);
// Write the entries
@ -1332,7 +1317,7 @@ fn test_dropped_handoff_recovery() {
db_ledger
.write_entries(
DEFAULT_SLOT_HEIGHT,
genesis_entries.len() as u64,
genesis_entry_height,
&active_set_entries,
)
.unwrap();
@ -1343,9 +1328,7 @@ fn test_dropped_handoff_recovery() {
ledger_paths.push(next_leader_ledger_path.clone());
// Create the common leader scheduling configuration
let initial_tick_height = genesis_entries
.iter()
.fold(0, |tick_count, entry| tick_count + entry.is_tick() as u64);
let initial_tick_height = genesis_entry_height;
let num_slots_per_epoch = (N + 1) as u64;
let leader_rotation_interval = 5;
let seed_rotation_interval = num_slots_per_epoch * leader_rotation_interval;
@ -1466,7 +1449,7 @@ 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 (_genesis_block, mint_keypair, bootstrap_leader_ledger_path, genesis_entries) =
let (_genesis_block, mint_keypair, bootstrap_leader_ledger_path, genesis_entry_height, last_id) =
create_tmp_sample_ledger(
"test_full_leader_validator_network",
10_000,
@ -1475,15 +1458,8 @@ fn test_full_leader_validator_network() {
500,
);
let last_tick_id = genesis_entries
.last()
.expect("expected at least one genesis entry")
.id;
let mut last_entry_id = genesis_entries
.last()
.expect("expected at least one genesis entry")
.id;
let last_tick_id = last_id;
let mut last_entry_id = last_id;
// Create a common ledger with entries in the beginnging that will add all the validators
// to the active set for leader election. TODO: Leader rotation does not support dynamic
@ -1493,12 +1469,11 @@ fn test_full_leader_validator_network() {
let mut ledger_paths = Vec::new();
ledger_paths.push(bootstrap_leader_ledger_path.clone());
let mut vote_account_keypairs = VecDeque::new();
let mut index = genesis_entries.len() as u64;
let mut index = genesis_entry_height;
for node_keypair in node_keypairs.iter() {
// Make entries to give each node some stake so that they will be in the
// leader election active set
let (bootstrap_entries, vote_account_keypair) = make_active_set_entries(
let (bootstrap_entries, _) = make_active_set_entries(
node_keypair,
&mint_keypair,
&last_entry_id,
@ -1506,8 +1481,6 @@ fn test_full_leader_validator_network() {
0,
);
vote_account_keypairs.push_back(vote_account_keypair);
// Write the entries
last_entry_id = bootstrap_entries
.last()
@ -1543,7 +1516,6 @@ fn test_full_leader_validator_network() {
// 2) Modifying the leader ledger which validators are going to be copying
// during startup
let leader_keypair = node_keypairs.pop_front().unwrap();
let _leader_vote_keypair = vote_account_keypairs.pop_front().unwrap();
let mut schedules: Vec<Arc<RwLock<LeaderScheduler>>> = vec![];
let mut t_nodes = vec![];
@ -1708,21 +1680,21 @@ fn test_broadcast_last_tick() {
let bootstrap_leader_info = bootstrap_leader_node.info.clone();
// Create leader ledger
let (_genesis_block, _mint_keypair, bootstrap_leader_ledger_path, genesis_entries) =
create_tmp_sample_ledger(
"test_broadcast_last_tick",
10_000,
1,
bootstrap_leader_info.id,
500,
);
let (
_genesis_block,
_mint_keypair,
bootstrap_leader_ledger_path,
genesis_entry_height,
_last_id,
) = create_tmp_sample_ledger(
"test_broadcast_last_tick",
10_000,
1,
bootstrap_leader_info.id,
500,
);
let num_ending_ticks = genesis_entries
.iter()
.fold(0, |tick_count, entry| tick_count + entry.is_tick() as u64);
let genesis_ledger_len = genesis_entries.len() as u64 - num_ending_ticks;
debug!("num_ending_ticks: {}", num_ending_ticks);
let genesis_ledger_len = genesis_entry_height;
debug!("genesis_ledger_len: {}", genesis_ledger_len);
let blob_receiver_exit = Arc::new(AtomicBool::new(false));