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

Inline BlockConfig::ticks_per_slot

This commit is contained in:
Greg Fitzgerald 2019-02-21 19:46:04 -07:00 committed by Grimes
parent fb904e7a29
commit 778583ad08
12 changed files with 145 additions and 206 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1,7 +1,7 @@
use solana::blocktree::{create_tmp_sample_ledger, BlocktreeConfig};
use solana_sdk::signature::{Keypair, KeypairUtil};
use assert_cmd::prelude::*; use assert_cmd::prelude::*;
use solana::blocktree::create_tmp_sample_ledger;
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::timing::DEFAULT_TICKS_PER_SLOT;
use std::process::Command; use std::process::Command;
use std::process::Output; use std::process::Output;
use std::sync::Arc; use std::sync::Arc;
@ -32,15 +32,15 @@ fn bad_arguments() {
#[test] #[test]
fn nominal() { fn nominal() {
let keypair = Arc::new(Keypair::new()); let keypair = Arc::new(Keypair::new());
let blocktree_config = BlocktreeConfig::default(); let ticks_per_slot = DEFAULT_TICKS_PER_SLOT;
let (_mint_keypair, ledger_path, tick_height, _last_entry_height, _last_id, _last_entry_id) = let (_mint_keypair, ledger_path, tick_height, _last_entry_height, _last_id, _last_entry_id) =
create_tmp_sample_ledger( create_tmp_sample_ledger(
"test_ledger_tool_nominal", "test_ledger_tool_nominal",
100, 100,
blocktree_config.ticks_per_slot - 2, ticks_per_slot - 2,
keypair.pubkey(), keypair.pubkey(),
50, 50,
&blocktree_config, ticks_per_slot,
); );
// Basic validation // Basic validation

53
src/blocktree.rs
View File

@ -310,23 +310,6 @@ impl LedgerColumnFamilyRaw for ErasureCf {
} }
} }
#[derive(Serialize, Deserialize, Debug, Clone, Copy)]
pub struct BlocktreeConfig {
pub ticks_per_slot: u64,
}
impl BlocktreeConfig {
pub fn new(ticks_per_slot: u64) -> Self {
BlocktreeConfig { ticks_per_slot }
}
}
impl Default for BlocktreeConfig {
fn default() -> Self {
Self::new(DEFAULT_TICKS_PER_SLOT)
}
}
// ledger window // ledger window
pub struct Blocktree { pub struct Blocktree {
// Underlying database is automatically closed in the Drop implementation of DB // Underlying database is automatically closed in the Drop implementation of DB
@ -380,8 +363,6 @@ impl Blocktree {
// Create the erasure column family // Create the erasure column family
let erasure_cf = ErasureCf::new(db.clone()); let erasure_cf = ErasureCf::new(db.clone());
// TODO: make these constructor arguments
// Issue: https://github.com/solana-labs/solana/issues/2458
let ticks_per_slot = DEFAULT_TICKS_PER_SLOT; let ticks_per_slot = DEFAULT_TICKS_PER_SLOT;
Ok(Blocktree { Ok(Blocktree {
db, db,
@ -401,22 +382,20 @@ impl Blocktree {
Ok((blocktree, signal_receiver)) Ok((blocktree, signal_receiver))
} }
#[allow(clippy::trivially_copy_pass_by_ref)] pub fn open_config(ledger_path: &str, ticks_per_slot: u64) -> Result<Self> {
pub fn open_config(ledger_path: &str, config: &BlocktreeConfig) -> Result<Self> {
let mut blocktree = Self::open(ledger_path)?; let mut blocktree = Self::open(ledger_path)?;
blocktree.ticks_per_slot = config.ticks_per_slot; blocktree.ticks_per_slot = ticks_per_slot;
Ok(blocktree) Ok(blocktree)
} }
#[allow(clippy::trivially_copy_pass_by_ref)]
pub fn open_with_config_signal( pub fn open_with_config_signal(
ledger_path: &str, ledger_path: &str,
config: &BlocktreeConfig, ticks_per_slot: u64,
) -> Result<(Self, Receiver<bool>)> { ) -> Result<(Self, Receiver<bool>)> {
let mut blocktree = Self::open(ledger_path)?; let mut blocktree = Self::open(ledger_path)?;
let (signal_sender, signal_receiver) = sync_channel(1); let (signal_sender, signal_receiver) = sync_channel(1);
blocktree.new_blobs_signals = vec![signal_sender]; blocktree.new_blobs_signals = vec![signal_sender];
blocktree.ticks_per_slot = config.ticks_per_slot; blocktree.ticks_per_slot = ticks_per_slot;
Ok((blocktree, signal_receiver)) Ok((blocktree, signal_receiver))
} }
@ -1270,12 +1249,12 @@ pub fn create_new_ledger(
ledger_path: &str, ledger_path: &str,
genesis_block: &GenesisBlock, genesis_block: &GenesisBlock,
) -> Result<(u64, u64, Hash)> { ) -> Result<(u64, u64, Hash)> {
let config = BlocktreeConfig::new(genesis_block.ticks_per_slot); let ticks_per_slot = genesis_block.ticks_per_slot;
Blocktree::destroy(ledger_path)?; Blocktree::destroy(ledger_path)?;
genesis_block.write(&ledger_path)?; genesis_block.write(&ledger_path)?;
// Add a single tick linked back to the genesis_block to bootstrap the ledger // Add a single tick linked back to the genesis_block to bootstrap the ledger
let blocktree = Blocktree::open_config(ledger_path, &config)?; let blocktree = Blocktree::open_config(ledger_path, ticks_per_slot)?;
let entries = crate::entry::create_ticks(1, genesis_block.last_id()); let entries = crate::entry::create_ticks(1, genesis_block.last_id());
blocktree.write_entries(DEFAULT_SLOT_HEIGHT, 0, 0, &entries)?; blocktree.write_entries(DEFAULT_SLOT_HEIGHT, 0, 0, &entries)?;
@ -1318,19 +1297,18 @@ pub fn get_tmp_ledger_path(name: &str) -> String {
path path
} }
#[allow(clippy::trivially_copy_pass_by_ref)]
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,
config: &BlocktreeConfig, ticks_per_slot: u64,
) -> (Keypair, String, u64, u64, Hash, Hash) { ) -> (Keypair, String, u64, u64, Hash, Hash) {
// TODO: Pass in a genesis block instead of all its parameters. // TODO: Pass in a genesis block instead of all its parameters.
let (mut genesis_block, mint_keypair) = let (mut 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);
genesis_block.ticks_per_slot = config.ticks_per_slot; genesis_block.ticks_per_slot = ticks_per_slot;
let ledger_path = get_tmp_ledger_path(name); let ledger_path = get_tmp_ledger_path(name);
let (mut entry_height, mut tick_height, mut last_entry_id) = let (mut entry_height, mut tick_height, mut last_entry_id) =
@ -1340,7 +1318,7 @@ pub fn create_tmp_sample_ledger(
if num_extra_ticks > 0 { if num_extra_ticks > 0 {
let entries = crate::entry::create_ticks(num_extra_ticks, last_entry_id); let entries = crate::entry::create_ticks(num_extra_ticks, last_entry_id);
let blocktree = Blocktree::open_config(&ledger_path, config).unwrap(); let blocktree = Blocktree::open_config(&ledger_path, ticks_per_slot).unwrap();
blocktree blocktree
.write_entries(DEFAULT_SLOT_HEIGHT, tick_height, entry_height, &entries) .write_entries(DEFAULT_SLOT_HEIGHT, tick_height, entry_height, &entries)
.unwrap(); .unwrap();
@ -1359,16 +1337,15 @@ pub fn create_tmp_sample_ledger(
) )
} }
#[allow(clippy::trivially_copy_pass_by_ref)] pub fn tmp_copy_ledger(from: &str, name: &str, ticks_per_slot: u64) -> String {
pub fn tmp_copy_ledger(from: &str, name: &str, config: &BlocktreeConfig) -> String {
let path = get_tmp_ledger_path(name); let path = get_tmp_ledger_path(name);
let blocktree = Blocktree::open_config(from, config).unwrap(); let blocktree = Blocktree::open_config(from, ticks_per_slot).unwrap();
let blobs = blocktree.read_ledger_blobs(); let blobs = blocktree.read_ledger_blobs();
let genesis_block = GenesisBlock::load(from).unwrap(); let genesis_block = GenesisBlock::load(from).unwrap();
Blocktree::destroy(&path).expect("Expected successful database destruction"); Blocktree::destroy(&path).expect("Expected successful database destruction");
let blocktree = Blocktree::open_config(&path, config).unwrap(); let blocktree = Blocktree::open_config(&path, ticks_per_slot).unwrap();
blocktree.write_blobs(blobs).unwrap(); blocktree.write_blobs(blobs).unwrap();
genesis_block.write(&path).unwrap(); genesis_block.write(&path).unwrap();
@ -1397,8 +1374,7 @@ pub mod tests {
let ticks_per_slot = 10; let ticks_per_slot = 10;
let num_slots = 10; let num_slots = 10;
let num_ticks = ticks_per_slot * num_slots; let num_ticks = ticks_per_slot * num_slots;
let config = BlocktreeConfig::new(ticks_per_slot); let ledger = Blocktree::open_config(&ledger_path, ticks_per_slot).unwrap();
let ledger = Blocktree::open_config(&ledger_path, &config).unwrap();
let ticks = create_ticks(num_ticks, Hash::default()); let ticks = create_ticks(num_ticks, Hash::default());
ledger.write_entries(0, 0, 0, ticks.clone()).unwrap(); ledger.write_entries(0, 0, 0, ticks.clone()).unwrap();
@ -1779,8 +1755,7 @@ pub mod tests {
pub fn test_insert_data_blobs_consecutive() { pub fn test_insert_data_blobs_consecutive() {
let blocktree_path = get_tmp_ledger_path("test_insert_data_blobs_consecutive"); let blocktree_path = get_tmp_ledger_path("test_insert_data_blobs_consecutive");
{ {
let config = BlocktreeConfig::new(32); let blocktree = Blocktree::open_config(&blocktree_path, 32).unwrap();
let blocktree = Blocktree::open_config(&blocktree_path, &config).unwrap();
let slot = 0; let slot = 0;
let parent_slot = 0; let parent_slot = 0;
// Write entries // Write entries

49
src/blocktree_processor.rs
View File

@ -274,22 +274,23 @@ pub fn process_blocktree(
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
use crate::blocktree::create_tmp_sample_ledger;
use crate::blocktree::tests::entries_to_blobs; use crate::blocktree::tests::entries_to_blobs;
use crate::blocktree::{create_tmp_sample_ledger, BlocktreeConfig};
use crate::entry::{create_ticks, next_entry, Entry}; use crate::entry::{create_ticks, next_entry, Entry};
use solana_sdk::genesis_block::GenesisBlock; use solana_sdk::genesis_block::GenesisBlock;
use solana_sdk::native_program::ProgramError; use solana_sdk::native_program::ProgramError;
use solana_sdk::signature::{Keypair, KeypairUtil}; use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::system_transaction::SystemTransaction; use solana_sdk::system_transaction::SystemTransaction;
use solana_sdk::timing::DEFAULT_TICKS_PER_SLOT;
fn fill_blocktree_slot_with_ticks( fn fill_blocktree_slot_with_ticks(
blocktree: &Blocktree, blocktree: &Blocktree,
blocktree_config: &BlocktreeConfig, ticks_per_slot: u64,
slot: u64, slot: u64,
parent_slot: u64, parent_slot: u64,
last_entry_id: Hash, last_entry_id: Hash,
) -> Hash { ) -> Hash {
let entries = create_ticks(blocktree_config.ticks_per_slot, last_entry_id); let entries = create_ticks(ticks_per_slot, last_entry_id);
let last_entry_id = entries.last().unwrap().id; let last_entry_id = entries.last().unwrap().id;
let blobs = entries_to_blobs(&entries, slot, parent_slot); let blobs = entries_to_blobs(&entries, slot, parent_slot);
@ -303,20 +304,20 @@ mod tests {
solana_logger::setup(); solana_logger::setup();
let leader_scheduler = Arc::new(RwLock::new(LeaderScheduler::default())); let leader_scheduler = Arc::new(RwLock::new(LeaderScheduler::default()));
let blocktree_config = &BlocktreeConfig::default(); let ticks_per_slot = DEFAULT_TICKS_PER_SLOT;
// Create a new ledger with slot 0 full of ticks // Create a new ledger with slot 0 full of ticks
let (_mint_keypair, ledger_path, tick_height, _entry_height, _last_id, mut last_entry_id) = let (_mint_keypair, ledger_path, tick_height, _entry_height, _last_id, mut last_entry_id) =
create_tmp_sample_ledger( create_tmp_sample_ledger(
"blocktree_with_two_forks", "blocktree_with_two_forks",
10_000, 10_000,
blocktree_config.ticks_per_slot - 1, ticks_per_slot - 1,
Keypair::new().pubkey(), Keypair::new().pubkey(),
123, 123,
&blocktree_config, ticks_per_slot,
); );
debug!("ledger_path: {:?}", ledger_path); debug!("ledger_path: {:?}", ledger_path);
assert_eq!(tick_height, blocktree_config.ticks_per_slot); assert_eq!(tick_height, ticks_per_slot);
/* /*
Build a blocktree in the ledger with the following fork structure: Build a blocktree in the ledger with the following fork structure:
@ -334,30 +335,20 @@ mod tests {
*/ */
let genesis_block = let genesis_block =
GenesisBlock::load(&ledger_path).expect("Expected to successfully open genesis block"); GenesisBlock::load(&ledger_path).expect("Expected to successfully open genesis block");
let blocktree = Blocktree::open_config(&ledger_path, &blocktree_config) let blocktree = Blocktree::open_config(&ledger_path, ticks_per_slot)
.expect("Expected to successfully open database ledger"); .expect("Expected to successfully open database ledger");
// Fork 1, ending at slot 3 // Fork 1, ending at slot 3
let last_slot1_entry_id = let last_slot1_entry_id =
fill_blocktree_slot_with_ticks(&blocktree, &blocktree_config, 1, 0, last_entry_id); fill_blocktree_slot_with_ticks(&blocktree, ticks_per_slot, 1, 0, last_entry_id);
last_entry_id = fill_blocktree_slot_with_ticks( last_entry_id =
&blocktree, fill_blocktree_slot_with_ticks(&blocktree, ticks_per_slot, 2, 1, last_slot1_entry_id);
&blocktree_config,
2,
1,
last_slot1_entry_id,
);
let last_fork1_entry_id = let last_fork1_entry_id =
fill_blocktree_slot_with_ticks(&blocktree, &blocktree_config, 3, 2, last_entry_id); fill_blocktree_slot_with_ticks(&blocktree, ticks_per_slot, 3, 2, last_entry_id);
// Fork 2, ending at slot 4 // Fork 2, ending at slot 4
let last_fork2_entry_id = fill_blocktree_slot_with_ticks( let last_fork2_entry_id =
&blocktree, fill_blocktree_slot_with_ticks(&blocktree, ticks_per_slot, 4, 1, last_slot1_entry_id);
&blocktree_config,
4,
1,
last_slot1_entry_id,
);
info!("last_fork1_entry_id: {:?}", last_fork1_entry_id); info!("last_fork1_entry_id: {:?}", last_fork1_entry_id);
info!("last_fork2_entry_id: {:?}", last_fork2_entry_id); info!("last_fork2_entry_id: {:?}", last_fork2_entry_id);
@ -370,7 +361,7 @@ mod tests {
bank_forks_info[0], bank_forks_info[0],
BankForksInfo { BankForksInfo {
bank_id: 2, // Fork 1 diverged with slot 2 bank_id: 2, // Fork 1 diverged with slot 2
entry_height: blocktree_config.ticks_per_slot * 4, entry_height: ticks_per_slot * 4,
last_entry_id: last_fork1_entry_id, last_entry_id: last_fork1_entry_id,
} }
); );
@ -378,7 +369,7 @@ mod tests {
bank_forks_info[1], bank_forks_info[1],
BankForksInfo { BankForksInfo {
bank_id: 4, // Fork 2 diverged with slot 4 bank_id: 4, // Fork 2 diverged with slot 4
entry_height: blocktree_config.ticks_per_slot * 3, entry_height: ticks_per_slot * 3,
last_entry_id: last_fork2_entry_id, last_entry_id: last_fork2_entry_id,
} }
); );
@ -472,7 +463,7 @@ mod tests {
#[test] #[test]
fn test_process_ledger_simple() { fn test_process_ledger_simple() {
let blocktree_config = BlocktreeConfig::default(); let ticks_per_slot = DEFAULT_TICKS_PER_SLOT;
let leader_scheduler = Arc::new(RwLock::new(LeaderScheduler::default())); let leader_scheduler = Arc::new(RwLock::new(LeaderScheduler::default()));
let ( let (
@ -488,7 +479,7 @@ mod tests {
0, 0,
Keypair::new().pubkey(), Keypair::new().pubkey(),
50, 50,
&blocktree_config, ticks_per_slot,
); );
debug!("ledger_path: {:?}", ledger_path); debug!("ledger_path: {:?}", ledger_path);
let genesis_block = let genesis_block =
@ -518,7 +509,7 @@ mod tests {
last_id = last_entry_id; last_id = last_entry_id;
entries.push(tick); entries.push(tick);
let blocktree = Blocktree::open_config(&ledger_path, &blocktree_config) let blocktree = Blocktree::open_config(&ledger_path, ticks_per_slot)
.expect("Expected to successfully open database ledger"); .expect("Expected to successfully open database ledger");
blocktree blocktree

6
src/chacha.rs
View File

@ -95,7 +95,7 @@ pub fn chacha_cbc_encrypt_ledger(
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use crate::blocktree::get_tmp_ledger_path; use crate::blocktree::get_tmp_ledger_path;
use crate::blocktree::{Blocktree, BlocktreeConfig, DEFAULT_SLOT_HEIGHT}; use crate::blocktree::{Blocktree, DEFAULT_SLOT_HEIGHT};
use crate::chacha::chacha_cbc_encrypt_ledger; use crate::chacha::chacha_cbc_encrypt_ledger;
use crate::entry::Entry; use crate::entry::Entry;
use ring::signature::Ed25519KeyPair; use ring::signature::Ed25519KeyPair;
@ -145,9 +145,7 @@ mod tests {
let ledger_dir = "chacha_test_encrypt_file"; let ledger_dir = "chacha_test_encrypt_file";
let ledger_path = get_tmp_ledger_path(ledger_dir); let ledger_path = get_tmp_ledger_path(ledger_dir);
let ticks_per_slot = 16; let ticks_per_slot = 16;
let blocktree = Arc::new( let blocktree = Arc::new(Blocktree::open_config(&ledger_path, ticks_per_slot).unwrap());
Blocktree::open_config(&ledger_path, &BlocktreeConfig::new(ticks_per_slot)).unwrap(),
);
let out_path = Path::new("test_chacha_encrypt_file_output.txt.enc"); let out_path = Path::new("test_chacha_encrypt_file_output.txt.enc");
let entries = make_tiny_deterministic_test_entries(32); let entries = make_tiny_deterministic_test_entries(32);

10
src/chacha_cuda.rs
View File

@ -110,7 +110,7 @@ pub fn chacha_cbc_encrypt_file_many_keys(
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use crate::blocktree::get_tmp_ledger_path; use crate::blocktree::get_tmp_ledger_path;
use crate::blocktree::{Blocktree, BlocktreeConfig, DEFAULT_SLOT_HEIGHT}; use crate::blocktree::{Blocktree, DEFAULT_SLOT_HEIGHT};
use crate::chacha::chacha_cbc_encrypt_ledger; use crate::chacha::chacha_cbc_encrypt_ledger;
use crate::chacha_cuda::chacha_cbc_encrypt_file_many_keys; use crate::chacha_cuda::chacha_cbc_encrypt_file_many_keys;
use crate::entry::make_tiny_test_entries; use crate::entry::make_tiny_test_entries;
@ -128,9 +128,7 @@ mod tests {
let ledger_dir = "test_encrypt_file_many_keys_single"; let ledger_dir = "test_encrypt_file_many_keys_single";
let ledger_path = get_tmp_ledger_path(ledger_dir); let ledger_path = get_tmp_ledger_path(ledger_dir);
let ticks_per_slot = 16; let ticks_per_slot = 16;
let blocktree = Arc::new( let blocktree = Arc::new(Blocktree::open_config(&ledger_path, ticks_per_slot).unwrap());
Blocktree::open_config(&ledger_path, &BlocktreeConfig::new(ticks_per_slot)).unwrap(),
);
blocktree blocktree
.write_entries(DEFAULT_SLOT_HEIGHT, 0, 0, &entries) .write_entries(DEFAULT_SLOT_HEIGHT, 0, 0, &entries)
@ -166,9 +164,7 @@ mod tests {
let ledger_dir = "test_encrypt_file_many_keys_multiple"; let ledger_dir = "test_encrypt_file_many_keys_multiple";
let ledger_path = get_tmp_ledger_path(ledger_dir); let ledger_path = get_tmp_ledger_path(ledger_dir);
let ticks_per_slot = 16; let ticks_per_slot = 16;
let blocktree = Arc::new( let blocktree = Arc::new(Blocktree::open_config(&ledger_path, ticks_per_slot).unwrap());
Blocktree::open_config(&ledger_path, &BlocktreeConfig::new(ticks_per_slot)).unwrap(),
);
blocktree blocktree
.write_entries(DEFAULT_SLOT_HEIGHT, 0, 0, &entries) .write_entries(DEFAULT_SLOT_HEIGHT, 0, 0, &entries)
.unwrap(); .unwrap();

44
src/fullnode.rs
View File

@ -1,7 +1,7 @@
//! The `fullnode` module hosts all the fullnode microservices. //! The `fullnode` module hosts all the fullnode microservices.
use crate::bank_forks::BankForks; use crate::bank_forks::BankForks;
use crate::blocktree::{Blocktree, BlocktreeConfig}; use crate::blocktree::Blocktree;
use crate::blocktree_processor::{self, BankForksInfo}; use crate::blocktree_processor::{self, BankForksInfo};
use crate::cluster_info::{ClusterInfo, Node, NodeInfo}; use crate::cluster_info::{ClusterInfo, Node, NodeInfo};
use crate::gossip_service::GossipService; use crate::gossip_service::GossipService;
@ -85,10 +85,8 @@ impl Default for FullnodeConfig {
} }
impl FullnodeConfig { impl FullnodeConfig {
pub fn ledger_config(&self) -> BlocktreeConfig { pub fn ticks_per_slot(&self) -> u64 {
// TODO: Refactor LeaderSchedulerConfig and BlocktreeConfig to avoid the duplicated self.leader_scheduler_config.ticks_per_slot
// `ticks_per_slot` field that must be identical between the two
BlocktreeConfig::new(self.leader_scheduler_config.ticks_per_slot)
} }
} }
@ -125,7 +123,7 @@ impl Fullnode {
&config.leader_scheduler_config, &config.leader_scheduler_config,
))); )));
let (bank_forks, bank_forks_info, blocktree, ledger_signal_receiver) = let (bank_forks, bank_forks_info, blocktree, ledger_signal_receiver) =
new_banks_from_blocktree(ledger_path, &config.ledger_config(), &leader_scheduler); new_banks_from_blocktree(ledger_path, config.ticks_per_slot(), &leader_scheduler);
info!("node info: {:?}", node.info); info!("node info: {:?}", node.info);
info!("node entrypoint_info: {:?}", entrypoint_info_option); info!("node entrypoint_info: {:?}", entrypoint_info_option);
@ -362,14 +360,13 @@ impl Fullnode {
} }
} }
#[allow(clippy::trivially_copy_pass_by_ref)]
pub fn new_banks_from_blocktree( pub fn new_banks_from_blocktree(
blocktree_path: &str, blocktree_path: &str,
blocktree_config: &BlocktreeConfig, ticks_per_slot: u64,
leader_scheduler: &Arc<RwLock<LeaderScheduler>>, leader_scheduler: &Arc<RwLock<LeaderScheduler>>,
) -> (BankForks, Vec<BankForksInfo>, Blocktree, Receiver<bool>) { ) -> (BankForks, Vec<BankForksInfo>, Blocktree, Receiver<bool>) {
let (blocktree, ledger_signal_receiver) = let (blocktree, ledger_signal_receiver) =
Blocktree::open_with_config_signal(blocktree_path, blocktree_config) Blocktree::open_with_config_signal(blocktree_path, ticks_per_slot)
.expect("Expected to successfully open database ledger"); .expect("Expected to successfully open database ledger");
let genesis_block = let genesis_block =
GenesisBlock::load(blocktree_path).expect("Expected to successfully open genesis block"); GenesisBlock::load(blocktree_path).expect("Expected to successfully open genesis block");
@ -406,13 +403,12 @@ impl Service for Fullnode {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
use crate::blocktree::{ use crate::blocktree::{create_tmp_sample_ledger, tmp_copy_ledger, DEFAULT_SLOT_HEIGHT};
create_tmp_sample_ledger, tmp_copy_ledger, BlocktreeConfig, DEFAULT_SLOT_HEIGHT,
};
use crate::entry::make_consecutive_blobs; use crate::entry::make_consecutive_blobs;
use crate::leader_scheduler::make_active_set_entries; use crate::leader_scheduler::make_active_set_entries;
use crate::streamer::responder; use crate::streamer::responder;
use solana_sdk::hash::Hash; use solana_sdk::hash::Hash;
use solana_sdk::timing::DEFAULT_TICKS_PER_SLOT;
use std::fs::remove_dir_all; use std::fs::remove_dir_all;
#[test] #[test]
@ -435,7 +431,7 @@ mod tests {
0, 0,
leader_keypair.pubkey(), leader_keypair.pubkey(),
1000, 1000,
&BlocktreeConfig::default(), DEFAULT_TICKS_PER_SLOT,
); );
let validator = Fullnode::new( let validator = Fullnode::new(
@ -473,7 +469,7 @@ mod tests {
0, 0,
leader_keypair.pubkey(), leader_keypair.pubkey(),
1000, 1000,
&BlocktreeConfig::default(), DEFAULT_TICKS_PER_SLOT,
); );
ledger_paths.push(validator_ledger_path.clone()); ledger_paths.push(validator_ledger_path.clone());
Fullnode::new( Fullnode::new(
@ -535,7 +531,7 @@ mod tests {
1, 1,
bootstrap_leader_keypair.pubkey(), bootstrap_leader_keypair.pubkey(),
500, 500,
&fullnode_config.ledger_config(), fullnode_config.ticks_per_slot(),
); );
// Start the bootstrap leader // Start the bootstrap leader
@ -573,7 +569,7 @@ mod tests {
let slots_per_epoch = 2; let slots_per_epoch = 2;
fullnode_config.leader_scheduler_config = fullnode_config.leader_scheduler_config =
LeaderSchedulerConfig::new(ticks_per_slot, slots_per_epoch, slots_per_epoch); LeaderSchedulerConfig::new(ticks_per_slot, slots_per_epoch, slots_per_epoch);
let blocktree_config = &fullnode_config.ledger_config(); let ticks_per_slot = fullnode_config.ticks_per_slot();
// Create the leader and validator nodes // Create the leader and validator nodes
let bootstrap_leader_keypair = Arc::new(Keypair::new()); let bootstrap_leader_keypair = Arc::new(Keypair::new());
@ -587,14 +583,14 @@ mod tests {
// tick_height = 0 from the leader scheduler's active window // tick_height = 0 from the leader scheduler's active window
ticks_per_slot * slots_per_epoch, ticks_per_slot * slots_per_epoch,
"test_wrong_role_transition", "test_wrong_role_transition",
&blocktree_config, ticks_per_slot,
); );
let bootstrap_leader_info = bootstrap_leader_node.info.clone(); let bootstrap_leader_info = bootstrap_leader_node.info.clone();
let validator_ledger_path = tmp_copy_ledger( let validator_ledger_path = tmp_copy_ledger(
&bootstrap_leader_ledger_path, &bootstrap_leader_ledger_path,
"test_wrong_role_transition", "test_wrong_role_transition",
&blocktree_config, ticks_per_slot,
); );
let ledger_paths = vec![ let ledger_paths = vec![
@ -666,7 +662,7 @@ mod tests {
0, 0,
0, 0,
"test_validator_to_leader_transition", "test_validator_to_leader_transition",
&fullnode_config.ledger_config(), fullnode_config.ticks_per_slot(),
); );
let leader_id = leader_keypair.pubkey(); let leader_id = leader_keypair.pubkey();
@ -725,7 +721,7 @@ mod tests {
let leader_scheduler = Arc::new(RwLock::new(LeaderScheduler::default())); let leader_scheduler = Arc::new(RwLock::new(LeaderScheduler::default()));
let (bank_forks, bank_forks_info, _, _) = new_banks_from_blocktree( let (bank_forks, bank_forks_info, _, _) = new_banks_from_blocktree(
&validator_ledger_path, &validator_ledger_path,
&BlocktreeConfig::default(), DEFAULT_TICKS_PER_SLOT,
&leader_scheduler, &leader_scheduler,
); );
let bank = bank_forks.working_bank(); let bank = bank_forks.working_bank();
@ -748,7 +744,7 @@ mod tests {
num_genesis_ticks: u64, num_genesis_ticks: u64,
num_ending_ticks: u64, num_ending_ticks: u64,
test_name: &str, test_name: &str,
blocktree_config: &BlocktreeConfig, ticks_per_slot: u64,
) -> (Node, Node, String, u64, Hash) { ) -> (Node, Node, String, u64, Hash) {
info!("validator: {}", validator_keypair.pubkey()); info!("validator: {}", validator_keypair.pubkey());
info!("leader: {}", leader_keypair.pubkey()); info!("leader: {}", leader_keypair.pubkey());
@ -756,7 +752,7 @@ mod tests {
let leader_node = Node::new_localhost_with_pubkey(leader_keypair.pubkey()); let leader_node = Node::new_localhost_with_pubkey(leader_keypair.pubkey());
// Create validator identity // Create validator identity
assert!(num_genesis_ticks <= blocktree_config.ticks_per_slot); assert!(num_genesis_ticks <= ticks_per_slot);
let (mint_keypair, ledger_path, tick_height, mut entry_height, last_id, last_entry_id) = let (mint_keypair, ledger_path, tick_height, mut entry_height, last_id, last_entry_id) =
create_tmp_sample_ledger( create_tmp_sample_ledger(
test_name, test_name,
@ -764,7 +760,7 @@ mod tests {
num_genesis_ticks, num_genesis_ticks,
leader_node.info.id, leader_node.info.id,
500, 500,
blocktree_config, ticks_per_slot,
); );
let validator_node = Node::new_localhost_with_pubkey(validator_keypair.pubkey()); let validator_node = Node::new_localhost_with_pubkey(validator_keypair.pubkey());
@ -780,7 +776,7 @@ mod tests {
num_ending_ticks, num_ending_ticks,
); );
let blocktree = Blocktree::open_config(&ledger_path, blocktree_config).unwrap(); let blocktree = Blocktree::open_config(&ledger_path, ticks_per_slot).unwrap();
let active_set_entries_len = active_set_entries.len() as u64; let active_set_entries_len = active_set_entries.len() as u64;
let last_id = active_set_entries.last().unwrap().id; let last_id = active_set_entries.last().unwrap().id;

21
src/replay_stage.rs
View File

@ -380,9 +380,7 @@ impl Service for ReplayStage {
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use super::*; use super::*;
use crate::blocktree::{ use crate::blocktree::{create_tmp_sample_ledger, Blocktree, DEFAULT_SLOT_HEIGHT};
create_tmp_sample_ledger, Blocktree, BlocktreeConfig, DEFAULT_SLOT_HEIGHT,
};
use crate::cluster_info::{ClusterInfo, Node}; use crate::cluster_info::{ClusterInfo, Node};
use crate::entry::create_ticks; use crate::entry::create_ticks;
use crate::entry::{next_entry_mut, Entry}; use crate::entry::{next_entry_mut, Entry};
@ -395,6 +393,7 @@ mod test {
use solana_sdk::genesis_block::GenesisBlock; use solana_sdk::genesis_block::GenesisBlock;
use solana_sdk::hash::Hash; use solana_sdk::hash::Hash;
use solana_sdk::signature::{Keypair, KeypairUtil}; use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::timing::DEFAULT_TICKS_PER_SLOT;
use std::fs::remove_dir_all; use std::fs::remove_dir_all;
use std::sync::atomic::{AtomicBool, Ordering}; use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::mpsc::channel; use std::sync::mpsc::channel;
@ -434,7 +433,7 @@ mod test {
0, 0,
old_leader_id, old_leader_id,
500, 500,
&BlocktreeConfig::new(ticks_per_slot), ticks_per_slot,
); );
info!("my_id: {:?}", my_id); info!("my_id: {:?}", my_id);
@ -468,9 +467,8 @@ mod test {
{ {
// Set up the bank // Set up the bank
let blocktree_config = BlocktreeConfig::new(ticks_per_slot);
let (bank_forks, bank_forks_info, blocktree, ledger_signal_receiver) = let (bank_forks, bank_forks_info, blocktree, ledger_signal_receiver) =
new_banks_from_blocktree(&my_ledger_path, &blocktree_config, &leader_scheduler); new_banks_from_blocktree(&my_ledger_path, ticks_per_slot, &leader_scheduler);
// Set up the replay stage // Set up the replay stage
let (rotation_sender, rotation_receiver) = channel(); let (rotation_sender, rotation_receiver) = channel();
@ -563,7 +561,7 @@ mod test {
1, 1,
leader_id, leader_id,
500, 500,
&BlocktreeConfig::default(), DEFAULT_TICKS_PER_SLOT,
); );
// Set up the cluster info // Set up the cluster info
@ -578,7 +576,7 @@ mod test {
let leader_scheduler = Arc::new(RwLock::new(LeaderScheduler::default())); let leader_scheduler = Arc::new(RwLock::new(LeaderScheduler::default()));
let (bank_forks, bank_forks_info, blocktree, l_receiver) = new_banks_from_blocktree( let (bank_forks, bank_forks_info, blocktree, l_receiver) = new_banks_from_blocktree(
&my_ledger_path, &my_ledger_path,
&BlocktreeConfig::default(), DEFAULT_TICKS_PER_SLOT,
&leader_scheduler, &leader_scheduler,
); );
let bank = bank_forks.working_bank(); let bank = bank_forks.working_bank();
@ -646,7 +644,6 @@ mod test {
let leader_id = Keypair::new().pubkey(); let leader_id = Keypair::new().pubkey();
// Create the ledger // Create the ledger
let blocktree_config = BlocktreeConfig::new(ticks_per_slot);
let ( let (
mint_keypair, mint_keypair,
my_ledger_path, my_ledger_path,
@ -660,7 +657,7 @@ mod test {
1, 1,
leader_id, leader_id,
500, 500,
&blocktree_config, ticks_per_slot,
); );
let my_keypair = Arc::new(my_keypair); let my_keypair = Arc::new(my_keypair);
@ -678,7 +675,7 @@ mod test {
); );
let mut last_id = active_set_entries.last().unwrap().id; let mut last_id = active_set_entries.last().unwrap().id;
{ {
let blocktree = Blocktree::open_config(&my_ledger_path, &blocktree_config).unwrap(); let blocktree = Blocktree::open_config(&my_ledger_path, ticks_per_slot).unwrap();
blocktree blocktree
.write_entries( .write_entries(
DEFAULT_SLOT_HEIGHT, DEFAULT_SLOT_HEIGHT,
@ -702,7 +699,7 @@ mod test {
let exit = Arc::new(AtomicBool::new(false)); let exit = Arc::new(AtomicBool::new(false));
{ {
let (bank_forks, bank_forks_info, blocktree, l_receiver) = let (bank_forks, bank_forks_info, blocktree, l_receiver) =
new_banks_from_blocktree(&my_ledger_path, &blocktree_config, &leader_scheduler); new_banks_from_blocktree(&my_ledger_path, ticks_per_slot, &leader_scheduler);
let bank = bank_forks.working_bank(); let bank = bank_forks.working_bank();
let meta = blocktree let meta = blocktree
.meta(0) .meta(0)

17
src/storage_stage.rs
View File

@ -444,9 +444,7 @@ impl Service for StorageStage {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use crate::blocktree::{ use crate::blocktree::{create_tmp_sample_ledger, Blocktree, DEFAULT_SLOT_HEIGHT};
create_tmp_sample_ledger, Blocktree, BlocktreeConfig, DEFAULT_SLOT_HEIGHT,
};
use crate::cluster_info::{ClusterInfo, NodeInfo}; use crate::cluster_info::{ClusterInfo, NodeInfo};
use crate::entry::{make_tiny_test_entries, Entry}; use crate::entry::{make_tiny_test_entries, Entry};
use crate::service::Service; use crate::service::Service;
@ -460,6 +458,7 @@ mod tests {
use solana_sdk::hash::Hasher; use solana_sdk::hash::Hasher;
use solana_sdk::pubkey::Pubkey; use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::{Keypair, KeypairUtil}; use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::timing::DEFAULT_TICKS_PER_SLOT;
use solana_sdk::vote_transaction::VoteTransaction; use solana_sdk::vote_transaction::VoteTransaction;
use std::cmp::{max, min}; use std::cmp::{max, min};
use std::fs::remove_dir_all; use std::fs::remove_dir_all;
@ -504,7 +503,7 @@ 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 blocktree_config = BlocktreeConfig::default(); let ticks_per_slot = DEFAULT_TICKS_PER_SLOT;
let (_mint, ledger_path, tick_height, genesis_entry_height, _last_id, _last_entry_id) = let (_mint, ledger_path, tick_height, genesis_entry_height, _last_id, _last_entry_id) =
create_tmp_sample_ledger( create_tmp_sample_ledger(
"storage_stage_process_entries", "storage_stage_process_entries",
@ -512,11 +511,11 @@ mod tests {
1, 1,
Keypair::new().pubkey(), Keypair::new().pubkey(),
1, 1,
&blocktree_config, ticks_per_slot,
); );
let entries = make_tiny_test_entries(64); let entries = make_tiny_test_entries(64);
let blocktree = Blocktree::open_config(&ledger_path, &blocktree_config).unwrap(); let blocktree = Blocktree::open_config(&ledger_path, ticks_per_slot).unwrap();
blocktree blocktree
.write_entries( .write_entries(
DEFAULT_SLOT_HEIGHT, DEFAULT_SLOT_HEIGHT,
@ -580,7 +579,7 @@ 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 blocktree_config = BlocktreeConfig::default(); let ticks_per_slot = DEFAULT_TICKS_PER_SLOT;
let (_mint, ledger_path, tick_height, genesis_entry_height, _last_id, _last_entry_id) = let (_mint, ledger_path, tick_height, genesis_entry_height, _last_id, _last_entry_id) =
create_tmp_sample_ledger( create_tmp_sample_ledger(
"storage_stage_process_entries", "storage_stage_process_entries",
@ -588,11 +587,11 @@ mod tests {
1, 1,
Keypair::new().pubkey(), Keypair::new().pubkey(),
1, 1,
&blocktree_config, ticks_per_slot,
); );
let entries = make_tiny_test_entries(128); let entries = make_tiny_test_entries(128);
let blocktree = Blocktree::open_config(&ledger_path, &blocktree_config).unwrap(); let blocktree = Blocktree::open_config(&ledger_path, ticks_per_slot).unwrap();
blocktree blocktree
.write_entries( .write_entries(
DEFAULT_SLOT_HEIGHT, DEFAULT_SLOT_HEIGHT,

2
src/thin_client.rs
View File

@ -470,7 +470,7 @@ pub fn new_fullnode(ledger_name: &'static str) -> (Fullnode, NodeInfo, Keypair,
0, 0,
node_info.id, node_info.id,
42, 42,
&fullnode_config.ledger_config(), fullnode_config.ticks_per_slot(),
); );
let vote_account_keypair = Arc::new(Keypair::new()); let vote_account_keypair = Arc::new(Keypair::new());

117
tests/multinode.rs
View File

@ -1,7 +1,7 @@
use log::*; use log::*;
use solana::blob_fetch_stage::BlobFetchStage; use solana::blob_fetch_stage::BlobFetchStage;
use solana::blocktree::{ use solana::blocktree::{
create_tmp_sample_ledger, tmp_copy_ledger, Blocktree, BlocktreeConfig, DEFAULT_SLOT_HEIGHT, create_tmp_sample_ledger, tmp_copy_ledger, Blocktree, DEFAULT_SLOT_HEIGHT,
}; };
use solana::client::mk_client; use solana::client::mk_client;
use solana::cluster_info::{Node, NodeInfo}; use solana::cluster_info::{Node, NodeInfo};
@ -16,7 +16,7 @@ use solana::voting_keypair::VotingKeypair;
use solana_sdk::pubkey::Pubkey; use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::{Keypair, KeypairUtil}; use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::system_transaction::SystemTransaction; use solana_sdk::system_transaction::SystemTransaction;
use solana_sdk::timing::duration_as_s; use solana_sdk::timing::{duration_as_s, DEFAULT_TICKS_PER_SLOT};
use std::collections::{HashSet, VecDeque}; use std::collections::{HashSet, VecDeque};
use std::env; use std::env;
use std::fs::remove_dir_all; use std::fs::remove_dir_all;
@ -26,9 +26,9 @@ use std::sync::{Arc, RwLock};
use std::thread::{sleep, Builder}; use std::thread::{sleep, Builder};
use std::time::{Duration, Instant}; use std::time::{Duration, Instant};
fn read_ledger(ledger_path: &str, blocktree_config: &BlocktreeConfig) -> Vec<Entry> { fn read_ledger(ledger_path: &str, ticks_per_slot: u64) -> Vec<Entry> {
let ledger = let ledger =
Blocktree::open_config(&ledger_path, blocktree_config).expect("Unable to open ledger"); Blocktree::open_config(&ledger_path, ticks_per_slot).expect("Unable to open ledger");
ledger ledger
.read_ledger() .read_ledger()
.expect("Unable to read ledger") .expect("Unable to read ledger")
@ -46,11 +46,8 @@ fn test_multi_node_ledger_window() -> result::Result<()> {
let mut ledger_paths = Vec::new(); let mut ledger_paths = Vec::new();
let fullnode_config = FullnodeConfig::default(); let fullnode_config = FullnodeConfig::default();
info!( let ticks_per_slot = fullnode_config.leader_scheduler_config.ticks_per_slot;
"ticks_per_slot: {}", info!("ticks_per_slot: {}", ticks_per_slot);
fullnode_config.leader_scheduler_config.ticks_per_slot
);
let blocktree_config = fullnode_config.ledger_config();
let ( let (
alice, alice,
@ -65,7 +62,7 @@ fn test_multi_node_ledger_window() -> result::Result<()> {
0, 0,
leader_data.id, leader_data.id,
500, 500,
&blocktree_config, ticks_per_slot,
); );
ledger_paths.push(leader_ledger_path.clone()); ledger_paths.push(leader_ledger_path.clone());
@ -73,7 +70,7 @@ fn test_multi_node_ledger_window() -> result::Result<()> {
let zero_ledger_path = tmp_copy_ledger( let zero_ledger_path = tmp_copy_ledger(
&leader_ledger_path, &leader_ledger_path,
"multi_node_ledger_window", "multi_node_ledger_window",
&blocktree_config, ticks_per_slot,
); );
ledger_paths.push(zero_ledger_path.clone()); ledger_paths.push(zero_ledger_path.clone());
@ -81,7 +78,7 @@ fn test_multi_node_ledger_window() -> result::Result<()> {
// and force it to respond to repair from the ledger window // and force it to respond to repair from the ledger window
// TODO: write out more than slot 0 // TODO: write out more than slot 0
{ {
let blocktree = Blocktree::open_config(&leader_ledger_path, &blocktree_config).unwrap(); let blocktree = Blocktree::open_config(&leader_ledger_path, ticks_per_slot).unwrap();
let entries = solana::entry::create_ticks( let entries = solana::entry::create_ticks(
fullnode_config.leader_scheduler_config.ticks_per_slot - last_entry_height - 1, fullnode_config.leader_scheduler_config.ticks_per_slot - last_entry_height - 1,
@ -189,7 +186,7 @@ fn test_multi_node_validator_catchup_from_zero() -> result::Result<()> {
let mut ledger_paths = Vec::new(); let mut ledger_paths = Vec::new();
let fullnode_config = FullnodeConfig::default(); let fullnode_config = FullnodeConfig::default();
let blocktree_config = fullnode_config.ledger_config(); let ticks_per_slot = fullnode_config.ticks_per_slot();
let (alice, genesis_ledger_path, _tick_height, _last_entry_height, _last_id, _last_entry_id) = let (alice, genesis_ledger_path, _tick_height, _last_entry_height, _last_id, _last_entry_id) =
create_tmp_sample_ledger( create_tmp_sample_ledger(
"multi_node_validator_catchup_from_zero", "multi_node_validator_catchup_from_zero",
@ -197,21 +194,21 @@ fn test_multi_node_validator_catchup_from_zero() -> result::Result<()> {
0, 0,
leader_data.id, leader_data.id,
500, 500,
&blocktree_config, ticks_per_slot,
); );
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(
&genesis_ledger_path, &genesis_ledger_path,
"multi_node_validator_catchup_from_zero", "multi_node_validator_catchup_from_zero",
&blocktree_config, ticks_per_slot,
); );
ledger_paths.push(zero_ledger_path.clone()); ledger_paths.push(zero_ledger_path.clone());
let leader_ledger_path = tmp_copy_ledger( let leader_ledger_path = tmp_copy_ledger(
&genesis_ledger_path, &genesis_ledger_path,
"multi_node_validator_catchup_from_zero", "multi_node_validator_catchup_from_zero",
&blocktree_config, ticks_per_slot,
); );
ledger_paths.push(leader_ledger_path.clone()); ledger_paths.push(leader_ledger_path.clone());
let voting_keypair = VotingKeypair::new_local(&leader_keypair); let voting_keypair = VotingKeypair::new_local(&leader_keypair);
@ -232,7 +229,7 @@ fn test_multi_node_validator_catchup_from_zero() -> result::Result<()> {
let ledger_path = tmp_copy_ledger( let ledger_path = tmp_copy_ledger(
&genesis_ledger_path, &genesis_ledger_path,
"multi_node_validator_catchup_from_zero_validator", "multi_node_validator_catchup_from_zero_validator",
&blocktree_config, ticks_per_slot,
); );
ledger_paths.push(ledger_path.clone()); ledger_paths.push(ledger_path.clone());
@ -384,7 +381,7 @@ fn test_multi_node_basic() {
let mut ledger_paths = Vec::new(); let mut ledger_paths = Vec::new();
let fullnode_config = FullnodeConfig::default(); let fullnode_config = FullnodeConfig::default();
let blocktree_config = fullnode_config.ledger_config(); let ticks_per_slot = fullnode_config.ticks_per_slot();
let (alice, genesis_ledger_path, _tick_height, _last_entry_height, _last_id, _last_entry_id) = let (alice, genesis_ledger_path, _tick_height, _last_entry_height, _last_id, _last_entry_id) =
create_tmp_sample_ledger( create_tmp_sample_ledger(
"multi_node_basic", "multi_node_basic",
@ -392,12 +389,12 @@ fn test_multi_node_basic() {
0, 0,
leader_data.id, leader_data.id,
500, 500,
&blocktree_config, ticks_per_slot,
); );
ledger_paths.push(genesis_ledger_path.clone()); ledger_paths.push(genesis_ledger_path.clone());
let leader_ledger_path = let leader_ledger_path =
tmp_copy_ledger(&genesis_ledger_path, "multi_node_basic", &blocktree_config); tmp_copy_ledger(&genesis_ledger_path, "multi_node_basic", ticks_per_slot);
ledger_paths.push(leader_ledger_path.clone()); ledger_paths.push(leader_ledger_path.clone());
let voting_keypair = VotingKeypair::new_local(&leader_keypair); let voting_keypair = VotingKeypair::new_local(&leader_keypair);
@ -415,8 +412,7 @@ fn test_multi_node_basic() {
let keypair = Arc::new(Keypair::new()); let keypair = Arc::new(Keypair::new());
let validator_pubkey = keypair.pubkey().clone(); let validator_pubkey = keypair.pubkey().clone();
let validator = Node::new_localhost_with_pubkey(keypair.pubkey()); let validator = Node::new_localhost_with_pubkey(keypair.pubkey());
let ledger_path = let ledger_path = tmp_copy_ledger(&genesis_ledger_path, "multi_node_basic", ticks_per_slot);
tmp_copy_ledger(&genesis_ledger_path, "multi_node_basic", &blocktree_config);
ledger_paths.push(ledger_path.clone()); ledger_paths.push(ledger_path.clone());
// Send each validator some tokens to vote // Send each validator some tokens to vote
@ -495,7 +491,7 @@ fn test_boot_validator_from_file() -> result::Result<()> {
let mut ledger_paths = Vec::new(); let mut ledger_paths = Vec::new();
let fullnode_config = FullnodeConfig::default(); let fullnode_config = FullnodeConfig::default();
let blocktree_config = fullnode_config.ledger_config(); let ticks_per_slot = fullnode_config.ticks_per_slot();
let (alice, genesis_ledger_path, _tick_height, _last_entry_height, _last_id, _last_entry_id) = let (alice, genesis_ledger_path, _tick_height, _last_entry_height, _last_id, _last_entry_id) =
create_tmp_sample_ledger( create_tmp_sample_ledger(
"boot_validator_from_file", "boot_validator_from_file",
@ -503,14 +499,14 @@ fn test_boot_validator_from_file() -> result::Result<()> {
0, 0,
leader_pubkey, leader_pubkey,
1000, 1000,
&blocktree_config, ticks_per_slot,
); );
ledger_paths.push(genesis_ledger_path.clone()); ledger_paths.push(genesis_ledger_path.clone());
let leader_ledger_path = tmp_copy_ledger( let leader_ledger_path = tmp_copy_ledger(
&genesis_ledger_path, &genesis_ledger_path,
"boot_validator_from_file", "boot_validator_from_file",
&blocktree_config, ticks_per_slot,
); );
ledger_paths.push(leader_ledger_path.clone()); ledger_paths.push(leader_ledger_path.clone());
@ -541,7 +537,7 @@ fn test_boot_validator_from_file() -> result::Result<()> {
let ledger_path = tmp_copy_ledger( let ledger_path = tmp_copy_ledger(
&genesis_ledger_path, &genesis_ledger_path,
"boot_validator_from_file", "boot_validator_from_file",
&blocktree_config, ticks_per_slot,
); );
ledger_paths.push(ledger_path.clone()); ledger_paths.push(ledger_path.clone());
let voting_keypair = VotingKeypair::new_local(&keypair); let voting_keypair = VotingKeypair::new_local(&keypair);
@ -596,7 +592,7 @@ fn test_leader_restart_validator_start_from_old_ledger() -> result::Result<()> {
// ledger (currently up to WINDOW_SIZE entries) // ledger (currently up to WINDOW_SIZE entries)
solana_logger::setup(); solana_logger::setup();
let blocktree_config = BlocktreeConfig::default(); let ticks_per_slot = DEFAULT_TICKS_PER_SLOT;
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 fullnode_config = FullnodeConfig::default(); let fullnode_config = FullnodeConfig::default();
@ -607,7 +603,7 @@ fn test_leader_restart_validator_start_from_old_ledger() -> result::Result<()> {
0, 0,
leader_keypair.pubkey(), leader_keypair.pubkey(),
initial_leader_balance, initial_leader_balance,
&blocktree_config, ticks_per_slot,
); );
let bob_pubkey = Keypair::new().pubkey(); let bob_pubkey = Keypair::new().pubkey();
@ -631,7 +627,7 @@ fn test_leader_restart_validator_start_from_old_ledger() -> result::Result<()> {
let stale_ledger_path = tmp_copy_ledger( let stale_ledger_path = tmp_copy_ledger(
&ledger_path, &ledger_path,
"leader_restart_validator_start_from_old_ledger", "leader_restart_validator_start_from_old_ledger",
&blocktree_config, ticks_per_slot,
); );
{ {
@ -717,7 +713,7 @@ fn test_multi_node_dynamic_network() {
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 fullnode_config = FullnodeConfig::default(); let fullnode_config = FullnodeConfig::default();
let blocktree_config = fullnode_config.ledger_config(); let ticks_per_slot = fullnode_config.ticks_per_slot();
let (alice, genesis_ledger_path, _tick_height, _last_entry_height, _last_id, _last_entry_id) = let (alice, genesis_ledger_path, _tick_height, _last_entry_height, _last_id, _last_entry_id) =
create_tmp_sample_ledger( create_tmp_sample_ledger(
"multi_node_dynamic_network", "multi_node_dynamic_network",
@ -725,7 +721,7 @@ fn test_multi_node_dynamic_network() {
0, 0,
leader_pubkey, leader_pubkey,
500, 500,
&blocktree_config, ticks_per_slot,
); );
let mut ledger_paths = Vec::new(); let mut ledger_paths = Vec::new();
@ -734,7 +730,7 @@ fn test_multi_node_dynamic_network() {
let leader_ledger_path = tmp_copy_ledger( let leader_ledger_path = tmp_copy_ledger(
&genesis_ledger_path, &genesis_ledger_path,
"multi_node_dynamic_network", "multi_node_dynamic_network",
&blocktree_config, ticks_per_slot,
); );
let alice_arc = Arc::new(RwLock::new(alice)); let alice_arc = Arc::new(RwLock::new(alice));
@ -807,7 +803,7 @@ fn test_multi_node_dynamic_network() {
let ledger_path = tmp_copy_ledger( let ledger_path = tmp_copy_ledger(
&genesis_ledger_path, &genesis_ledger_path,
"multi_node_dynamic_network", "multi_node_dynamic_network",
&blocktree_config, ticks_per_slot,
); );
ledger_paths.push(ledger_path.clone()); ledger_paths.push(ledger_path.clone());
Builder::new() Builder::new()
@ -946,7 +942,6 @@ fn test_leader_to_validator_transition() {
// height 1 will be considered. // height 1 will be considered.
1, 1,
); );
let blocktree_config = fullnode_config.ledger_config();
// 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
@ -963,7 +958,7 @@ fn test_leader_to_validator_transition() {
0, 0,
leader_info.id, leader_info.id,
500, 500,
&blocktree_config, ticks_per_slot,
); );
// Write the votes entries to the ledger that will cause leader rotation // Write the votes entries to the ledger that will cause leader rotation
@ -978,7 +973,7 @@ fn test_leader_to_validator_transition() {
0, 0,
); );
{ {
let blocktree = Blocktree::open_config(&leader_ledger_path, &blocktree_config).unwrap(); let blocktree = Blocktree::open_config(&leader_ledger_path, ticks_per_slot).unwrap();
blocktree blocktree
.write_entries( .write_entries(
DEFAULT_SLOT_HEIGHT, DEFAULT_SLOT_HEIGHT,
@ -1024,7 +1019,7 @@ fn test_leader_to_validator_transition() {
info!("Check the ledger to make sure it's the right height..."); info!("Check the ledger to make sure it's the right height...");
let bank_forks = new_banks_from_blocktree( let bank_forks = new_banks_from_blocktree(
&leader_ledger_path, &leader_ledger_path,
&BlocktreeConfig::default(), DEFAULT_TICKS_PER_SLOT,
&Arc::new(RwLock::new(LeaderScheduler::default())), &Arc::new(RwLock::new(LeaderScheduler::default())),
) )
.0; .0;
@ -1061,7 +1056,6 @@ fn test_leader_validator_basic() {
1, // 1 slot per epoch 1, // 1 slot per epoch
1, 1,
); );
let blocktree_config = fullnode_config.ledger_config();
// 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 ( let (
@ -1077,7 +1071,7 @@ fn test_leader_validator_basic() {
0, 0,
leader_info.id, leader_info.id,
500, 500,
&blocktree_config, ticks_per_slot,
); );
// Add validator vote on tick height 1 // Add validator vote on tick height 1
@ -1091,7 +1085,7 @@ fn test_leader_validator_basic() {
0, 0,
); );
{ {
let blocktree = Blocktree::open_config(&leader_ledger_path, &blocktree_config).unwrap(); let blocktree = Blocktree::open_config(&leader_ledger_path, ticks_per_slot).unwrap();
blocktree blocktree
.write_entries( .write_entries(
DEFAULT_SLOT_HEIGHT, DEFAULT_SLOT_HEIGHT,
@ -1108,7 +1102,7 @@ fn test_leader_validator_basic() {
let validator_ledger_path = tmp_copy_ledger( let validator_ledger_path = tmp_copy_ledger(
&leader_ledger_path, &leader_ledger_path,
"test_leader_validator_basic", "test_leader_validator_basic",
&blocktree_config, ticks_per_slot,
); );
ledger_paths.push(validator_ledger_path.clone()); ledger_paths.push(validator_ledger_path.clone());
@ -1177,9 +1171,9 @@ fn test_leader_validator_basic() {
// Check the ledger of the validator to make sure the entry height is correct // Check the ledger of the validator to make sure the entry height is correct
// and that the old leader and the new leader's ledgers agree up to the point // and that the old leader and the new leader's ledgers agree up to the point
// of leader rotation // of leader rotation
let validator_entries: Vec<Entry> = read_ledger(&validator_ledger_path, &blocktree_config); let validator_entries: Vec<Entry> = read_ledger(&validator_ledger_path, ticks_per_slot);
let leader_entries = read_ledger(&leader_ledger_path, &blocktree_config); let leader_entries = read_ledger(&leader_ledger_path, ticks_per_slot);
assert!(leader_entries.len() as u64 >= ticks_per_slot); assert!(leader_entries.len() as u64 >= ticks_per_slot);
for (v, l) in validator_entries.iter().zip(leader_entries) { for (v, l) in validator_entries.iter().zip(leader_entries) {
@ -1212,7 +1206,6 @@ fn test_dropped_handoff_recovery() {
let mut fullnode_config = FullnodeConfig::default(); let mut fullnode_config = FullnodeConfig::default();
fullnode_config.leader_scheduler_config = fullnode_config.leader_scheduler_config =
LeaderSchedulerConfig::new(ticks_per_slot, slots_per_epoch, slots_per_epoch); LeaderSchedulerConfig::new(ticks_per_slot, slots_per_epoch, slots_per_epoch);
let blocktree_config = fullnode_config.ledger_config();
// 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;
@ -1229,7 +1222,7 @@ fn test_dropped_handoff_recovery() {
num_ending_ticks, num_ending_ticks,
bootstrap_leader_info.id, bootstrap_leader_info.id,
500, 500,
&blocktree_config, ticks_per_slot,
); );
// Create the validator keypair that will be the next leader in line // Create the validator keypair that will be the next leader in line
@ -1255,7 +1248,7 @@ fn test_dropped_handoff_recovery() {
// Write the entries // Write the entries
{ {
let blocktree = Blocktree::open_config(&genesis_ledger_path, &blocktree_config).unwrap(); let blocktree = Blocktree::open_config(&genesis_ledger_path, ticks_per_slot).unwrap();
blocktree blocktree
.write_entries( .write_entries(
DEFAULT_SLOT_HEIGHT, DEFAULT_SLOT_HEIGHT,
@ -1269,7 +1262,7 @@ fn test_dropped_handoff_recovery() {
let next_leader_ledger_path = tmp_copy_ledger( let next_leader_ledger_path = tmp_copy_ledger(
&genesis_ledger_path, &genesis_ledger_path,
"test_dropped_handoff_recovery", "test_dropped_handoff_recovery",
&blocktree_config, ticks_per_slot,
); );
ledger_paths.push(next_leader_ledger_path.clone()); ledger_paths.push(next_leader_ledger_path.clone());
@ -1281,7 +1274,7 @@ fn test_dropped_handoff_recovery() {
let bootstrap_leader_ledger_path = tmp_copy_ledger( let bootstrap_leader_ledger_path = tmp_copy_ledger(
&genesis_ledger_path, &genesis_ledger_path,
"test_dropped_handoff_recovery", "test_dropped_handoff_recovery",
&blocktree_config, ticks_per_slot,
); );
ledger_paths.push(bootstrap_leader_ledger_path.clone()); ledger_paths.push(bootstrap_leader_ledger_path.clone());
@ -1303,7 +1296,7 @@ fn test_dropped_handoff_recovery() {
let validator_ledger_path = tmp_copy_ledger( let validator_ledger_path = tmp_copy_ledger(
&genesis_ledger_path, &genesis_ledger_path,
"test_dropped_handoff_recovery", "test_dropped_handoff_recovery",
&blocktree_config, ticks_per_slot,
); );
ledger_paths.push(validator_ledger_path.clone()); ledger_paths.push(validator_ledger_path.clone());
let validator_id = keypair.pubkey(); let validator_id = keypair.pubkey();
@ -1390,7 +1383,6 @@ fn test_full_leader_validator_network() {
let bootstrap_leader_info = bootstrap_leader_node.info.clone(); let bootstrap_leader_info = bootstrap_leader_node.info.clone();
let mut node_keypairs = VecDeque::new(); let mut node_keypairs = VecDeque::new();
let blocktree_config = BlocktreeConfig::default();
// Create the validator keypairs // Create the validator keypairs
for _ in 0..N { for _ in 0..N {
@ -1413,7 +1405,7 @@ fn test_full_leader_validator_network() {
num_ending_ticks, num_ending_ticks,
bootstrap_leader_info.id, bootstrap_leader_info.id,
500, 500,
&blocktree_config, ticks_per_slot,
); );
// 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
@ -1441,7 +1433,7 @@ fn test_full_leader_validator_network() {
.id; .id;
{ {
let blocktree = let blocktree =
Blocktree::open_config(&bootstrap_leader_ledger_path, &blocktree_config).unwrap(); Blocktree::open_config(&bootstrap_leader_ledger_path, ticks_per_slot).unwrap();
blocktree blocktree
.write_entries( .write_entries(
DEFAULT_SLOT_HEIGHT, DEFAULT_SLOT_HEIGHT,
@ -1462,7 +1454,7 @@ fn test_full_leader_validator_network() {
let validator_ledger_path = tmp_copy_ledger( let validator_ledger_path = tmp_copy_ledger(
&bootstrap_leader_ledger_path, &bootstrap_leader_ledger_path,
"test_full_leader_validator_network", "test_full_leader_validator_network",
&blocktree_config, ticks_per_slot,
); );
ledger_paths.push(validator_ledger_path.clone()); ledger_paths.push(validator_ledger_path.clone());
@ -1534,7 +1526,7 @@ fn test_full_leader_validator_network() {
let mut node_entries = vec![]; let mut node_entries = vec![];
info!("Check that all the ledgers match"); info!("Check that all the ledgers match");
for ledger_path in ledger_paths.iter() { for ledger_path in ledger_paths.iter() {
let entries = read_ledger(ledger_path, &blocktree_config); let entries = read_ledger(ledger_path, ticks_per_slot);
node_entries.push(entries.into_iter()); node_entries.push(entries.into_iter());
} }
@ -1616,7 +1608,6 @@ fn test_broadcast_last_tick() {
LeaderSchedulerConfig::new(ticks_per_slot, slots_per_epoch, ticks_per_epoch); LeaderSchedulerConfig::new(ticks_per_slot, slots_per_epoch, ticks_per_epoch);
// Create leader ledger // Create leader ledger
let blocktree_config = BlocktreeConfig::default();
let ( let (
_mint_keypair, _mint_keypair,
bootstrap_leader_ledger_path, bootstrap_leader_ledger_path,
@ -1630,7 +1621,7 @@ fn test_broadcast_last_tick() {
0, 0,
bootstrap_leader_info.id, bootstrap_leader_info.id,
500, 500,
&blocktree_config, ticks_per_slot,
); );
let genesis_ledger_len = genesis_entry_height; let genesis_ledger_len = genesis_entry_height;
@ -1691,7 +1682,7 @@ fn test_broadcast_last_tick() {
// 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 - 1; let last_tick_entry_index = ticks_per_slot as usize - 1;
let entries = read_ledger(&bootstrap_leader_ledger_path, &blocktree_config); let entries = read_ledger(&bootstrap_leader_ledger_path, ticks_per_slot);
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];
debug!("last_tick_entry_index: {:?}", last_tick_entry_index); debug!("last_tick_entry_index: {:?}", last_tick_entry_index);
@ -1815,7 +1806,6 @@ fn test_fullnode_rotate(
fullnode_config.voting_disabled = true; fullnode_config.voting_disabled = true;
*/ */
let blocktree_config = fullnode_config.ledger_config();
fullnode_config fullnode_config
.leader_scheduler_config .leader_scheduler_config
.active_window_num_slots = std::u64::MAX; .active_window_num_slots = std::u64::MAX;
@ -1848,7 +1838,7 @@ fn test_fullnode_rotate(
0, 0,
leader_keypair.pubkey(), leader_keypair.pubkey(),
123, 123,
&blocktree_config, ticks_per_slot,
); );
assert_eq!(tick_height, 1); assert_eq!(tick_height, 1);
@ -1905,7 +1895,7 @@ fn test_fullnode_rotate(
tick_height = 0; tick_height = 0;
last_entry_height = 0; last_entry_height = 0;
} }
let blocktree = Blocktree::open_config(&leader_ledger_path, &blocktree_config).unwrap(); let blocktree = Blocktree::open_config(&leader_ledger_path, ticks_per_slot).unwrap();
blocktree blocktree
.write_entries(start_slot, tick_height, last_entry_height, &entries) .write_entries(start_slot, tick_height, last_entry_height, &entries)
.unwrap(); .unwrap();
@ -1916,11 +1906,8 @@ fn test_fullnode_rotate(
let (validator_rotation_sender, validator_rotation_receiver) = channel(); let (validator_rotation_sender, validator_rotation_receiver) = channel();
if include_validator { if include_validator {
let validator_ledger_path = tmp_copy_ledger( let validator_ledger_path =
&leader_ledger_path, tmp_copy_ledger(&leader_ledger_path, "test_fullnode_rotate", ticks_per_slot);
"test_fullnode_rotate",
&blocktree_config,
);
ledger_paths.push(validator_ledger_path.clone()); ledger_paths.push(validator_ledger_path.clone());
let validator_fullnode = Fullnode::new( let validator_fullnode = Fullnode::new(
validator, validator,

12
tests/replicator.rs
View File

@ -40,7 +40,7 @@ fn test_replicator_startup_basic() {
let leader_ledger_path = "replicator_test_leader_ledger"; let leader_ledger_path = "replicator_test_leader_ledger";
let mut fullnode_config = FullnodeConfig::default(); let mut fullnode_config = FullnodeConfig::default();
let blocktree_config = fullnode_config.ledger_config(); let ticks_per_slot = fullnode_config.ticks_per_slot();
let ( let (
mint_keypair, mint_keypair,
@ -55,13 +55,13 @@ fn test_replicator_startup_basic() {
0, 0,
leader_info.id, leader_info.id,
42, 42,
&blocktree_config, ticks_per_slot,
); );
let validator_ledger_path = tmp_copy_ledger( let validator_ledger_path = tmp_copy_ledger(
&leader_ledger_path, &leader_ledger_path,
"replicator_test_validator_ledger", "replicator_test_validator_ledger",
&blocktree_config, ticks_per_slot,
); );
{ {
@ -295,7 +295,7 @@ fn test_replicator_startup_ledger_hang() {
let leader_ledger_path = "replicator_test_leader_ledger"; let leader_ledger_path = "replicator_test_leader_ledger";
let fullnode_config = FullnodeConfig::default(); let fullnode_config = FullnodeConfig::default();
let blocktree_config = fullnode_config.ledger_config(); let ticks_per_slot = fullnode_config.ticks_per_slot();
let ( let (
_mint_keypair, _mint_keypair,
leader_ledger_path, leader_ledger_path,
@ -309,13 +309,13 @@ fn test_replicator_startup_ledger_hang() {
0, 0,
leader_info.id, leader_info.id,
42, 42,
&blocktree_config, ticks_per_slot,
); );
let validator_ledger_path = tmp_copy_ledger( let validator_ledger_path = tmp_copy_ledger(
&leader_ledger_path, &leader_ledger_path,
"replicator_test_validator_ledger", "replicator_test_validator_ledger",
&blocktree_config, ticks_per_slot,
); );
{ {

8
tests/tvu.rs
View File

@ -1,6 +1,6 @@
use log::trace; use log::trace;
use solana::bank_forks::BankForks; use solana::bank_forks::BankForks;
use solana::blocktree::{get_tmp_ledger_path, Blocktree, BlocktreeConfig}; use solana::blocktree::{get_tmp_ledger_path, Blocktree};
use solana::blocktree_processor::BankForksInfo; use solana::blocktree_processor::BankForksInfo;
use solana::cluster_info::{ClusterInfo, Node}; use solana::cluster_info::{ClusterInfo, Node};
use solana::entry::next_entry_mut; use solana::entry::next_entry_mut;
@ -77,10 +77,10 @@ fn test_replay() {
); );
// TODO: Fix this test so it always works with the default // TODO: Fix this test so it always works with the default
// LeaderSchedulerConfig/BlocktreeConfig configuration // LeaderSchedulerConfig configuration
let mut leader_scheduler_config = LeaderSchedulerConfig::default(); let mut leader_scheduler_config = LeaderSchedulerConfig::default();
leader_scheduler_config.ticks_per_slot = 64; leader_scheduler_config.ticks_per_slot = 64;
let blocktree_config = BlocktreeConfig::new(leader_scheduler_config.ticks_per_slot); let ticks_per_slot = leader_scheduler_config.ticks_per_slot;
let starting_balance = 10_000; let starting_balance = 10_000;
let (genesis_block, mint_keypair) = GenesisBlock::new(starting_balance); let (genesis_block, mint_keypair) = GenesisBlock::new(starting_balance);
@ -111,7 +111,7 @@ fn test_replay() {
let blocktree_path = get_tmp_ledger_path("test_replay"); let blocktree_path = get_tmp_ledger_path("test_replay");
let (blocktree, ledger_signal_receiver) = let (blocktree, ledger_signal_receiver) =
Blocktree::open_with_config_signal(&blocktree_path, &blocktree_config) Blocktree::open_with_config_signal(&blocktree_path, ticks_per_slot)
.expect("Expected to successfully open ledger"); .expect("Expected to successfully open ledger");
let vote_account_keypair = Arc::new(Keypair::new()); let vote_account_keypair = Arc::new(Keypair::new());
let voting_keypair = VotingKeypair::new_local(&vote_account_keypair); let voting_keypair = VotingKeypair::new_local(&vote_account_keypair);