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

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 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::Output;
use std::sync::Arc;
@ -32,15 +32,15 @@ fn bad_arguments() {
#[test]
fn nominal() {
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) =
create_tmp_sample_ledger(
"test_ledger_tool_nominal",
100,
blocktree_config.ticks_per_slot - 2,
ticks_per_slot - 2,
keypair.pubkey(),
50,
&blocktree_config,
ticks_per_slot,
);
// 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
pub struct Blocktree {
// Underlying database is automatically closed in the Drop implementation of DB
@ -380,8 +363,6 @@ impl Blocktree {
// Create the erasure column family
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;
Ok(Blocktree {
db,
@ -401,22 +382,20 @@ impl Blocktree {
Ok((blocktree, signal_receiver))
}
#[allow(clippy::trivially_copy_pass_by_ref)]
pub fn open_config(ledger_path: &str, config: &BlocktreeConfig) -> Result<Self> {
pub fn open_config(ledger_path: &str, ticks_per_slot: u64) -> Result<Self> {
let mut blocktree = Self::open(ledger_path)?;
blocktree.ticks_per_slot = config.ticks_per_slot;
blocktree.ticks_per_slot = ticks_per_slot;
Ok(blocktree)
}
#[allow(clippy::trivially_copy_pass_by_ref)]
pub fn open_with_config_signal(
ledger_path: &str,
config: &BlocktreeConfig,
ticks_per_slot: u64,
) -> Result<(Self, Receiver<bool>)> {
let mut blocktree = Self::open(ledger_path)?;
let (signal_sender, signal_receiver) = sync_channel(1);
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))
}
@ -1270,12 +1249,12 @@ pub fn create_new_ledger(
ledger_path: &str,
genesis_block: &GenesisBlock,
) -> 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)?;
genesis_block.write(&ledger_path)?;
// 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());
blocktree.write_entries(DEFAULT_SLOT_HEIGHT, 0, 0, &entries)?;
@ -1318,19 +1297,18 @@ pub fn get_tmp_ledger_path(name: &str) -> String {
path
}
#[allow(clippy::trivially_copy_pass_by_ref)]
pub fn create_tmp_sample_ledger(
name: &str,
num_tokens: u64,
num_extra_ticks: u64,
bootstrap_leader_id: Pubkey,
bootstrap_leader_tokens: u64,
config: &BlocktreeConfig,
ticks_per_slot: u64,
) -> (Keypair, String, u64, u64, Hash, Hash) {
// TODO: Pass in a genesis block instead of all its parameters.
let (mut genesis_block, mint_keypair) =
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 (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 {
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
.write_entries(DEFAULT_SLOT_HEIGHT, tick_height, entry_height, &entries)
.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, config: &BlocktreeConfig) -> String {
pub fn tmp_copy_ledger(from: &str, name: &str, ticks_per_slot: u64) -> String {
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 genesis_block = GenesisBlock::load(from).unwrap();
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();
genesis_block.write(&path).unwrap();
@ -1397,8 +1374,7 @@ pub mod tests {
let ticks_per_slot = 10;
let num_slots = 10;
let num_ticks = ticks_per_slot * num_slots;
let config = BlocktreeConfig::new(ticks_per_slot);
let ledger = Blocktree::open_config(&ledger_path, &config).unwrap();
let ledger = Blocktree::open_config(&ledger_path, ticks_per_slot).unwrap();
let ticks = create_ticks(num_ticks, Hash::default());
ledger.write_entries(0, 0, 0, ticks.clone()).unwrap();
@ -1779,8 +1755,7 @@ pub mod tests {
pub fn 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, &config).unwrap();
let blocktree = Blocktree::open_config(&blocktree_path, 32).unwrap();
let slot = 0;
let parent_slot = 0;
// Write entries

49
src/blocktree_processor.rs
View File

@ -274,22 +274,23 @@ pub fn process_blocktree(
#[cfg(test)]
mod tests {
use super::*;
use crate::blocktree::create_tmp_sample_ledger;
use crate::blocktree::tests::entries_to_blobs;
use crate::blocktree::{create_tmp_sample_ledger, BlocktreeConfig};
use crate::entry::{create_ticks, next_entry, Entry};
use solana_sdk::genesis_block::GenesisBlock;
use solana_sdk::native_program::ProgramError;
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::system_transaction::SystemTransaction;
use solana_sdk::timing::DEFAULT_TICKS_PER_SLOT;
fn fill_blocktree_slot_with_ticks(
blocktree: &Blocktree,
blocktree_config: &BlocktreeConfig,
ticks_per_slot: u64,
slot: u64,
parent_slot: u64,
last_entry_id: 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 blobs = entries_to_blobs(&entries, slot, parent_slot);
@ -303,20 +304,20 @@ mod tests {
solana_logger::setup();
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
let (_mint_keypair, ledger_path, tick_height, _entry_height, _last_id, mut last_entry_id) =
create_tmp_sample_ledger(
"blocktree_with_two_forks",
10_000,
blocktree_config.ticks_per_slot - 1,
ticks_per_slot - 1,
Keypair::new().pubkey(),
123,
&blocktree_config,
ticks_per_slot,
);
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:
@ -334,30 +335,20 @@ mod tests {
*/
let 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");
// Fork 1, ending at slot 3
let last_slot1_entry_id =
fill_blocktree_slot_with_ticks(&blocktree, &blocktree_config, 1, 0, last_entry_id);
last_entry_id = fill_blocktree_slot_with_ticks(
&blocktree,
&blocktree_config,
2,
1,
last_slot1_entry_id,
);
fill_blocktree_slot_with_ticks(&blocktree, ticks_per_slot, 1, 0, last_entry_id);
last_entry_id =
fill_blocktree_slot_with_ticks(&blocktree, ticks_per_slot, 2, 1, last_slot1_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
let last_fork2_entry_id = fill_blocktree_slot_with_ticks(
&blocktree,
&blocktree_config,
4,
1,
last_slot1_entry_id,
);
let last_fork2_entry_id =
fill_blocktree_slot_with_ticks(&blocktree, ticks_per_slot, 4, 1, last_slot1_entry_id);
info!("last_fork1_entry_id: {:?}", last_fork1_entry_id);
info!("last_fork2_entry_id: {:?}", last_fork2_entry_id);
@ -370,7 +361,7 @@ mod tests {
bank_forks_info[0],
BankForksInfo {
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,
}
);
@ -378,7 +369,7 @@ mod tests {
bank_forks_info[1],
BankForksInfo {
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,
}
);
@ -472,7 +463,7 @@ mod tests {
#[test]
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 (
@ -488,7 +479,7 @@ mod tests {
0,
Keypair::new().pubkey(),
50,
&blocktree_config,
ticks_per_slot,
);
debug!("ledger_path: {:?}", ledger_path);
let genesis_block =
@ -518,7 +509,7 @@ mod tests {
last_id = last_entry_id;
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");
blocktree

6
src/chacha.rs
View File

@ -95,7 +95,7 @@ pub fn chacha_cbc_encrypt_ledger(
#[cfg(test)]
mod tests {
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::entry::Entry;
use ring::signature::Ed25519KeyPair;
@ -145,9 +145,7 @@ mod tests {
let ledger_dir = "chacha_test_encrypt_file";
let ledger_path = get_tmp_ledger_path(ledger_dir);
let ticks_per_slot = 16;
let blocktree = Arc::new(
Blocktree::open_config(&ledger_path, &BlocktreeConfig::new(ticks_per_slot)).unwrap(),
);
let blocktree = Arc::new(Blocktree::open_config(&ledger_path, ticks_per_slot).unwrap());
let out_path = Path::new("test_chacha_encrypt_file_output.txt.enc");
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)]
mod tests {
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_cuda::chacha_cbc_encrypt_file_many_keys;
use crate::entry::make_tiny_test_entries;
@ -128,9 +128,7 @@ mod tests {
let ledger_dir = "test_encrypt_file_many_keys_single";
let ledger_path = get_tmp_ledger_path(ledger_dir);
let ticks_per_slot = 16;
let blocktree = Arc::new(
Blocktree::open_config(&ledger_path, &BlocktreeConfig::new(ticks_per_slot)).unwrap(),
);
let blocktree = Arc::new(Blocktree::open_config(&ledger_path, ticks_per_slot).unwrap());
blocktree
.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_path = get_tmp_ledger_path(ledger_dir);
let ticks_per_slot = 16;
let blocktree = Arc::new(
Blocktree::open_config(&ledger_path, &BlocktreeConfig::new(ticks_per_slot)).unwrap(),
);
let blocktree = Arc::new(Blocktree::open_config(&ledger_path, ticks_per_slot).unwrap());
blocktree
.write_entries(DEFAULT_SLOT_HEIGHT, 0, 0, &entries)
.unwrap();

44
src/fullnode.rs
View File

@ -1,7 +1,7 @@
//! The `fullnode` module hosts all the fullnode microservices.
use crate::bank_forks::BankForks;
use crate::blocktree::{Blocktree, BlocktreeConfig};
use crate::blocktree::Blocktree;
use crate::blocktree_processor::{self, BankForksInfo};
use crate::cluster_info::{ClusterInfo, Node, NodeInfo};
use crate::gossip_service::GossipService;
@ -85,10 +85,8 @@ impl Default for FullnodeConfig {
}
impl FullnodeConfig {
pub fn ledger_config(&self) -> BlocktreeConfig {
// TODO: Refactor LeaderSchedulerConfig and BlocktreeConfig to avoid the duplicated
// `ticks_per_slot` field that must be identical between the two
BlocktreeConfig::new(self.leader_scheduler_config.ticks_per_slot)
pub fn ticks_per_slot(&self) -> u64 {
self.leader_scheduler_config.ticks_per_slot
}
}
@ -125,7 +123,7 @@ impl Fullnode {
&config.leader_scheduler_config,
)));
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 entrypoint_info: {:?}", entrypoint_info_option);
@ -362,14 +360,13 @@ impl Fullnode {
}
}
#[allow(clippy::trivially_copy_pass_by_ref)]
pub fn new_banks_from_blocktree(
blocktree_path: &str,
blocktree_config: &BlocktreeConfig,
ticks_per_slot: u64,
leader_scheduler: &Arc<RwLock<LeaderScheduler>>,
) -> (BankForks, Vec<BankForksInfo>, Blocktree, Receiver<bool>) {
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");
let genesis_block =
GenesisBlock::load(blocktree_path).expect("Expected to successfully open genesis block");
@ -406,13 +403,12 @@ impl Service for Fullnode {
#[cfg(test)]
mod tests {
use super::*;
use crate::blocktree::{
create_tmp_sample_ledger, tmp_copy_ledger, BlocktreeConfig, DEFAULT_SLOT_HEIGHT,
};
use crate::blocktree::{create_tmp_sample_ledger, tmp_copy_ledger, DEFAULT_SLOT_HEIGHT};
use crate::entry::make_consecutive_blobs;
use crate::leader_scheduler::make_active_set_entries;
use crate::streamer::responder;
use solana_sdk::hash::Hash;
use solana_sdk::timing::DEFAULT_TICKS_PER_SLOT;
use std::fs::remove_dir_all;
#[test]
@ -435,7 +431,7 @@ mod tests {
0,
leader_keypair.pubkey(),
1000,
&BlocktreeConfig::default(),
DEFAULT_TICKS_PER_SLOT,
);
let validator = Fullnode::new(
@ -473,7 +469,7 @@ mod tests {
0,
leader_keypair.pubkey(),
1000,
&BlocktreeConfig::default(),
DEFAULT_TICKS_PER_SLOT,
);
ledger_paths.push(validator_ledger_path.clone());
Fullnode::new(
@ -535,7 +531,7 @@ mod tests {
1,
bootstrap_leader_keypair.pubkey(),
500,
&fullnode_config.ledger_config(),
fullnode_config.ticks_per_slot(),
);
// Start the bootstrap leader
@ -573,7 +569,7 @@ mod tests {
let slots_per_epoch = 2;
fullnode_config.leader_scheduler_config =
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
let bootstrap_leader_keypair = Arc::new(Keypair::new());
@ -587,14 +583,14 @@ mod tests {
// tick_height = 0 from the leader scheduler's active window
ticks_per_slot * slots_per_epoch,
"test_wrong_role_transition",
&blocktree_config,
ticks_per_slot,
);
let bootstrap_leader_info = bootstrap_leader_node.info.clone();
let validator_ledger_path = tmp_copy_ledger(
&bootstrap_leader_ledger_path,
"test_wrong_role_transition",
&blocktree_config,
ticks_per_slot,
);
let ledger_paths = vec![
@ -666,7 +662,7 @@ mod tests {
0,
0,
"test_validator_to_leader_transition",
&fullnode_config.ledger_config(),
fullnode_config.ticks_per_slot(),
);
let leader_id = leader_keypair.pubkey();
@ -725,7 +721,7 @@ mod tests {
let leader_scheduler = Arc::new(RwLock::new(LeaderScheduler::default()));
let (bank_forks, bank_forks_info, _, _) = new_banks_from_blocktree(
&validator_ledger_path,
&BlocktreeConfig::default(),
DEFAULT_TICKS_PER_SLOT,
&leader_scheduler,
);
let bank = bank_forks.working_bank();
@ -748,7 +744,7 @@ mod tests {
num_genesis_ticks: u64,
num_ending_ticks: u64,
test_name: &str,
blocktree_config: &BlocktreeConfig,
ticks_per_slot: u64,
) -> (Node, Node, String, u64, Hash) {
info!("validator: {}", validator_keypair.pubkey());
info!("leader: {}", leader_keypair.pubkey());
@ -756,7 +752,7 @@ mod tests {
let leader_node = Node::new_localhost_with_pubkey(leader_keypair.pubkey());
// 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) =
create_tmp_sample_ledger(
test_name,
@ -764,7 +760,7 @@ mod tests {
num_genesis_ticks,
leader_node.info.id,
500,
blocktree_config,
ticks_per_slot,
);
let validator_node = Node::new_localhost_with_pubkey(validator_keypair.pubkey());
@ -780,7 +776,7 @@ mod tests {
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 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)]
mod test {
use super::*;
use crate::blocktree::{
create_tmp_sample_ledger, Blocktree, BlocktreeConfig, DEFAULT_SLOT_HEIGHT,
};
use crate::blocktree::{create_tmp_sample_ledger, Blocktree, DEFAULT_SLOT_HEIGHT};
use crate::cluster_info::{ClusterInfo, Node};
use crate::entry::create_ticks;
use crate::entry::{next_entry_mut, Entry};
@ -395,6 +393,7 @@ mod test {
use solana_sdk::genesis_block::GenesisBlock;
use solana_sdk::hash::Hash;
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::timing::DEFAULT_TICKS_PER_SLOT;
use std::fs::remove_dir_all;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::mpsc::channel;
@ -434,7 +433,7 @@ mod test {
0,
old_leader_id,
500,
&BlocktreeConfig::new(ticks_per_slot),
ticks_per_slot,
);
info!("my_id: {:?}", my_id);
@ -468,9 +467,8 @@ mod test {
{
// Set up the bank
let blocktree_config = BlocktreeConfig::new(ticks_per_slot);
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
let (rotation_sender, rotation_receiver) = channel();
@ -563,7 +561,7 @@ mod test {
1,
leader_id,
500,
&BlocktreeConfig::default(),
DEFAULT_TICKS_PER_SLOT,
);
// Set up the cluster info
@ -578,7 +576,7 @@ mod test {
let leader_scheduler = Arc::new(RwLock::new(LeaderScheduler::default()));
let (bank_forks, bank_forks_info, blocktree, l_receiver) = new_banks_from_blocktree(
&my_ledger_path,
&BlocktreeConfig::default(),
DEFAULT_TICKS_PER_SLOT,
&leader_scheduler,
);
let bank = bank_forks.working_bank();
@ -646,7 +644,6 @@ mod test {
let leader_id = Keypair::new().pubkey();
// Create the ledger
let blocktree_config = BlocktreeConfig::new(ticks_per_slot);
let (
mint_keypair,
my_ledger_path,
@ -660,7 +657,7 @@ mod test {
1,
leader_id,
500,
&blocktree_config,
ticks_per_slot,
);
let my_keypair = Arc::new(my_keypair);
@ -678,7 +675,7 @@ mod test {
);
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
.write_entries(
DEFAULT_SLOT_HEIGHT,
@ -702,7 +699,7 @@ mod test {
let exit = Arc::new(AtomicBool::new(false));
{
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 meta = blocktree
.meta(0)

17
src/storage_stage.rs
View File

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

117
tests/multinode.rs
View File

@ -1,7 +1,7 @@
use log::*;
use solana::blob_fetch_stage::BlobFetchStage;
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::cluster_info::{Node, NodeInfo};
@ -16,7 +16,7 @@ use solana::voting_keypair::VotingKeypair;
use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::{Keypair, KeypairUtil};
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::env;
use std::fs::remove_dir_all;
@ -26,9 +26,9 @@ use std::sync::{Arc, RwLock};
use std::thread::{sleep, Builder};
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 =
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
.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 fullnode_config = FullnodeConfig::default();
info!(
"ticks_per_slot: {}",
fullnode_config.leader_scheduler_config.ticks_per_slot
);
let blocktree_config = fullnode_config.ledger_config();
let ticks_per_slot = fullnode_config.leader_scheduler_config.ticks_per_slot;
info!("ticks_per_slot: {}", ticks_per_slot);
let (
alice,
@ -65,7 +62,7 @@ fn test_multi_node_ledger_window() -> result::Result<()> {
0,
leader_data.id,
500,
&blocktree_config,
ticks_per_slot,
);
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(
&leader_ledger_path,
"multi_node_ledger_window",
&blocktree_config,
ticks_per_slot,
);
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
// 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(
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 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) =
create_tmp_sample_ledger(
"multi_node_validator_catchup_from_zero",
@ -197,21 +194,21 @@ fn test_multi_node_validator_catchup_from_zero() -> result::Result<()> {
0,
leader_data.id,
500,
&blocktree_config,
ticks_per_slot,
);
ledger_paths.push(genesis_ledger_path.clone());
let zero_ledger_path = tmp_copy_ledger(
&genesis_ledger_path,
"multi_node_validator_catchup_from_zero",
&blocktree_config,
ticks_per_slot,
);
ledger_paths.push(zero_ledger_path.clone());
let leader_ledger_path = tmp_copy_ledger(
&genesis_ledger_path,
"multi_node_validator_catchup_from_zero",
&blocktree_config,
ticks_per_slot,
);
ledger_paths.push(leader_ledger_path.clone());
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(
&genesis_ledger_path,
"multi_node_validator_catchup_from_zero_validator",
&blocktree_config,
ticks_per_slot,
);
ledger_paths.push(ledger_path.clone());
@ -384,7 +381,7 @@ fn test_multi_node_basic() {
let mut ledger_paths = Vec::new();
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) =
create_tmp_sample_ledger(
"multi_node_basic",
@ -392,12 +389,12 @@ fn test_multi_node_basic() {
0,
leader_data.id,
500,
&blocktree_config,
ticks_per_slot,
);
ledger_paths.push(genesis_ledger_path.clone());
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());
let voting_keypair = VotingKeypair::new_local(&leader_keypair);
@ -415,8 +412,7 @@ fn test_multi_node_basic() {
let keypair = Arc::new(Keypair::new());
let validator_pubkey = keypair.pubkey().clone();
let validator = Node::new_localhost_with_pubkey(keypair.pubkey());
let ledger_path =
tmp_copy_ledger(&genesis_ledger_path, "multi_node_basic", &blocktree_config);
let ledger_path = tmp_copy_ledger(&genesis_ledger_path, "multi_node_basic", ticks_per_slot);
ledger_paths.push(ledger_path.clone());
// 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 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) =
create_tmp_sample_ledger(
"boot_validator_from_file",
@ -503,14 +499,14 @@ fn test_boot_validator_from_file() -> result::Result<()> {
0,
leader_pubkey,
1000,
&blocktree_config,
ticks_per_slot,
);
ledger_paths.push(genesis_ledger_path.clone());
let leader_ledger_path = tmp_copy_ledger(
&genesis_ledger_path,
"boot_validator_from_file",
&blocktree_config,
ticks_per_slot,
);
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(
&genesis_ledger_path,
"boot_validator_from_file",
&blocktree_config,
ticks_per_slot,
);
ledger_paths.push(ledger_path.clone());
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)
solana_logger::setup();
let blocktree_config = BlocktreeConfig::default();
let ticks_per_slot = DEFAULT_TICKS_PER_SLOT;
let leader_keypair = Arc::new(Keypair::new());
let initial_leader_balance = 500;
let fullnode_config = FullnodeConfig::default();
@ -607,7 +603,7 @@ fn test_leader_restart_validator_start_from_old_ledger() -> result::Result<()> {
0,
leader_keypair.pubkey(),
initial_leader_balance,
&blocktree_config,
ticks_per_slot,
);
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(
&ledger_path,
"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 bob_pubkey = Keypair::new().pubkey();
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) =
create_tmp_sample_ledger(
"multi_node_dynamic_network",
@ -725,7 +721,7 @@ fn test_multi_node_dynamic_network() {
0,
leader_pubkey,
500,
&blocktree_config,
ticks_per_slot,
);
let mut ledger_paths = Vec::new();
@ -734,7 +730,7 @@ fn test_multi_node_dynamic_network() {
let leader_ledger_path = tmp_copy_ledger(
&genesis_ledger_path,
"multi_node_dynamic_network",
&blocktree_config,
ticks_per_slot,
);
let alice_arc = Arc::new(RwLock::new(alice));
@ -807,7 +803,7 @@ fn test_multi_node_dynamic_network() {
let ledger_path = tmp_copy_ledger(
&genesis_ledger_path,
"multi_node_dynamic_network",
&blocktree_config,
ticks_per_slot,
);
ledger_paths.push(ledger_path.clone());
Builder::new()
@ -946,7 +942,6 @@ fn test_leader_to_validator_transition() {
// height 1 will be considered.
1,
);
let blocktree_config = fullnode_config.ledger_config();
// Initialize the leader ledger. Make a mint and a genesis entry
// in the leader ledger
@ -963,7 +958,7 @@ fn test_leader_to_validator_transition() {
0,
leader_info.id,
500,
&blocktree_config,
ticks_per_slot,
);
// Write the votes entries to the ledger that will cause leader rotation
@ -978,7 +973,7 @@ fn test_leader_to_validator_transition() {
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
.write_entries(
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...");
let bank_forks = new_banks_from_blocktree(
&leader_ledger_path,
&BlocktreeConfig::default(),
DEFAULT_TICKS_PER_SLOT,
&Arc::new(RwLock::new(LeaderScheduler::default())),
)
.0;
@ -1061,7 +1056,6 @@ fn test_leader_validator_basic() {
1, // 1 slot per epoch
1,
);
let blocktree_config = fullnode_config.ledger_config();
// Make a common mint and a genesis entry for both leader + validator ledgers
let (
@ -1077,7 +1071,7 @@ fn test_leader_validator_basic() {
0,
leader_info.id,
500,
&blocktree_config,
ticks_per_slot,
);
// Add validator vote on tick height 1
@ -1091,7 +1085,7 @@ fn test_leader_validator_basic() {
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
.write_entries(
DEFAULT_SLOT_HEIGHT,
@ -1108,7 +1102,7 @@ fn test_leader_validator_basic() {
let validator_ledger_path = tmp_copy_ledger(
&leader_ledger_path,
"test_leader_validator_basic",
&blocktree_config,
ticks_per_slot,
);
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
// and that the old leader and the new leader's ledgers agree up to the point
// 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);
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();
fullnode_config.leader_scheduler_config =
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
let num_ending_ticks = 1;
@ -1229,7 +1222,7 @@ fn test_dropped_handoff_recovery() {
num_ending_ticks,
bootstrap_leader_info.id,
500,
&blocktree_config,
ticks_per_slot,
);
// Create the validator keypair that will be the next leader in line
@ -1255,7 +1248,7 @@ fn test_dropped_handoff_recovery() {
// 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
.write_entries(
DEFAULT_SLOT_HEIGHT,
@ -1269,7 +1262,7 @@ fn test_dropped_handoff_recovery() {
let next_leader_ledger_path = tmp_copy_ledger(
&genesis_ledger_path,
"test_dropped_handoff_recovery",
&blocktree_config,
ticks_per_slot,
);
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(
&genesis_ledger_path,
"test_dropped_handoff_recovery",
&blocktree_config,
ticks_per_slot,
);
ledger_paths.push(bootstrap_leader_ledger_path.clone());
@ -1303,7 +1296,7 @@ fn test_dropped_handoff_recovery() {
let validator_ledger_path = tmp_copy_ledger(
&genesis_ledger_path,
"test_dropped_handoff_recovery",
&blocktree_config,
ticks_per_slot,
);
ledger_paths.push(validator_ledger_path.clone());
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 mut node_keypairs = VecDeque::new();
let blocktree_config = BlocktreeConfig::default();
// Create the validator keypairs
for _ in 0..N {
@ -1413,7 +1405,7 @@ fn test_full_leader_validator_network() {
num_ending_ticks,
bootstrap_leader_info.id,
500,
&blocktree_config,
ticks_per_slot,
);
// 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;
{
let blocktree =
Blocktree::open_config(&bootstrap_leader_ledger_path, &blocktree_config).unwrap();
Blocktree::open_config(&bootstrap_leader_ledger_path, ticks_per_slot).unwrap();
blocktree
.write_entries(
DEFAULT_SLOT_HEIGHT,
@ -1462,7 +1454,7 @@ fn test_full_leader_validator_network() {
let validator_ledger_path = tmp_copy_ledger(
&bootstrap_leader_ledger_path,
"test_full_leader_validator_network",
&blocktree_config,
ticks_per_slot,
);
ledger_paths.push(validator_ledger_path.clone());
@ -1534,7 +1526,7 @@ fn test_full_leader_validator_network() {
let mut node_entries = vec![];
info!("Check that all the ledgers match");
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());
}
@ -1616,7 +1608,6 @@ fn test_broadcast_last_tick() {
LeaderSchedulerConfig::new(ticks_per_slot, slots_per_epoch, ticks_per_epoch);
// Create leader ledger
let blocktree_config = BlocktreeConfig::default();
let (
_mint_keypair,
bootstrap_leader_ledger_path,
@ -1630,7 +1621,7 @@ fn test_broadcast_last_tick() {
0,
bootstrap_leader_info.id,
500,
&blocktree_config,
ticks_per_slot,
);
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
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);
let expected_last_tick = &entries[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;
*/
let blocktree_config = fullnode_config.ledger_config();
fullnode_config
.leader_scheduler_config
.active_window_num_slots = std::u64::MAX;
@ -1848,7 +1838,7 @@ fn test_fullnode_rotate(
0,
leader_keypair.pubkey(),
123,
&blocktree_config,
ticks_per_slot,
);
assert_eq!(tick_height, 1);
@ -1905,7 +1895,7 @@ fn test_fullnode_rotate(
tick_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
.write_entries(start_slot, tick_height, last_entry_height, &entries)
.unwrap();
@ -1916,11 +1906,8 @@ fn test_fullnode_rotate(
let (validator_rotation_sender, validator_rotation_receiver) = channel();
if include_validator {
let validator_ledger_path = tmp_copy_ledger(
&leader_ledger_path,
"test_fullnode_rotate",
&blocktree_config,
);
let validator_ledger_path =
tmp_copy_ledger(&leader_ledger_path, "test_fullnode_rotate", ticks_per_slot);
ledger_paths.push(validator_ledger_path.clone());
let validator_fullnode = Fullnode::new(
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 mut fullnode_config = FullnodeConfig::default();
let blocktree_config = fullnode_config.ledger_config();
let ticks_per_slot = fullnode_config.ticks_per_slot();
let (
mint_keypair,
@ -55,13 +55,13 @@ fn test_replicator_startup_basic() {
0,
leader_info.id,
42,
&blocktree_config,
ticks_per_slot,
);
let validator_ledger_path = tmp_copy_ledger(
&leader_ledger_path,
"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 fullnode_config = FullnodeConfig::default();
let blocktree_config = fullnode_config.ledger_config();
let ticks_per_slot = fullnode_config.ticks_per_slot();
let (
_mint_keypair,
leader_ledger_path,
@ -309,13 +309,13 @@ fn test_replicator_startup_ledger_hang() {
0,
leader_info.id,
42,
&blocktree_config,
ticks_per_slot,
);
let validator_ledger_path = tmp_copy_ledger(
&leader_ledger_path,
"replicator_test_validator_ledger",
&blocktree_config,
ticks_per_slot,
);
{

8
tests/tvu.rs
View File

@ -1,6 +1,6 @@
use log::trace;
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::cluster_info::{ClusterInfo, Node};
use solana::entry::next_entry_mut;
@ -77,10 +77,10 @@ fn test_replay() {
);
// TODO: Fix this test so it always works with the default
// LeaderSchedulerConfig/BlocktreeConfig configuration
// LeaderSchedulerConfig configuration
let mut leader_scheduler_config = LeaderSchedulerConfig::default();
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 (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, 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");
let vote_account_keypair = Arc::new(Keypair::new());
let voting_keypair = VotingKeypair::new_local(&vote_account_keypair);