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

consolidate tmp ledgers

This commit is contained in:
Rob Walker 2018-10-17 13:42:54 -07:00 committed by Greg Fitzgerald
parent 31e779d3f2
commit d0f43e9934
11 changed files with 88 additions and 154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/cluster_info.rs
View File

@ -1393,7 +1393,7 @@ mod tests {
};
use entry::Entry;
use hash::{hash, Hash};
use ledger::{LedgerWindow, LedgerWriter};
use ledger::{get_tmp_ledger_path, LedgerWindow, LedgerWriter};
use logger;
use packet::SharedBlob;
use result::Error;
@ -1815,11 +1815,7 @@ mod tests {
assert!(rv.is_none());
fn tmp_ledger(name: &str) -> String {
use std::env;
let out_dir = env::var("OUT_DIR").unwrap_or_else(|_| "target".to_string());
let keypair = Keypair::new();
let path = format!("{}/tmp/ledger-{}-{}", out_dir, name, keypair.pubkey());
let path = get_tmp_ledger_path(name);
let mut writer = LedgerWriter::open(&path, true).unwrap();
let zero = Hash::default();

11
src/drone.rs
View File

@ -228,6 +228,7 @@ mod tests {
use drone::{Drone, DroneRequest, REQUEST_CAP, TIME_SLICE};
use fullnode::Fullnode;
use leader_scheduler::LeaderScheduler;
use ledger::get_tmp_ledger_path;
use logger;
use mint::Mint;
use netutil::get_ip_addr;
@ -305,14 +306,6 @@ mod tests {
assert_eq!(drone.request_cap, REQUEST_CAP);
}
fn tmp_ledger_path(name: &str) -> String {
use std::env;
let out_dir = env::var("OUT_DIR").unwrap_or_else(|_| "target".to_string());
let keypair = Keypair::new();
format!("{}/tmp/ledger-{}-{}", out_dir, name, keypair.pubkey())
}
#[test]
#[ignore]
fn test_send_airdrop() {
@ -328,7 +321,7 @@ mod tests {
let bob_pubkey = Keypair::new().pubkey();
let carlos_pubkey = Keypair::new().pubkey();
let leader_data = leader.info.clone();
let ledger_path = tmp_ledger_path("send_airdrop");
let ledger_path = get_tmp_ledger_path("send_airdrop");
let server = Fullnode::new_with_bank(
leader_keypair,

11
src/fullnode.rs
View File

@ -603,7 +603,7 @@ mod tests {
use cluster_info::Node;
use fullnode::{Fullnode, NodeRole, TvuReturnType};
use leader_scheduler::{make_active_set_entries, LeaderScheduler, LeaderSchedulerConfig};
use ledger::{create_sample_ledger, genesis, LedgerWriter};
use ledger::{create_tmp_genesis, create_tmp_sample_ledger, LedgerWriter};
use packet::make_consecutive_blobs;
use service::Service;
use signature::{Keypair, KeypairUtil};
@ -618,7 +618,7 @@ mod tests {
fn validator_exit() {
let keypair = Keypair::new();
let tn = Node::new_localhost_with_pubkey(keypair.pubkey());
let (mint, validator_ledger_path) = genesis("validator_exit", 10_000);
let (mint, validator_ledger_path) = create_tmp_genesis("validator_exit", 10_000);
let bank = Bank::new(&mint);
let entry = tn.info.clone();
let genesis_entries = &mint.create_entries();
@ -648,7 +648,7 @@ mod tests {
let keypair = Keypair::new();
let tn = Node::new_localhost_with_pubkey(keypair.pubkey());
let (mint, validator_ledger_path) =
genesis(&format!("validator_parallel_exit_{}", i), 10_000);
create_tmp_genesis(&format!("validator_parallel_exit_{}", i), 10_000);
ledger_paths.push(validator_ledger_path.clone());
let bank = Bank::new(&mint);
let entry = tn.info.clone();
@ -696,7 +696,7 @@ mod tests {
// Make a common mint and a genesis entry for both leader + validator's ledgers
let (mint, bootstrap_leader_ledger_path, genesis_entries) =
create_sample_ledger("test_wrong_role_transition", 10_000);
create_tmp_sample_ledger("test_wrong_role_transition", 10_000);
let last_id = genesis_entries
.last()
@ -762,6 +762,7 @@ mod tests {
panic!("Expected node to be the leader");
}
}
let _ignored = remove_dir_all(&bootstrap_leader_ledger_path);
}
#[test]
@ -774,7 +775,7 @@ mod tests {
// Create validator identity
let (mint, validator_ledger_path, genesis_entries) =
create_sample_ledger("test_validator_to_leader_transition", 10_000);
create_tmp_sample_ledger("test_validator_to_leader_transition", 10_000);
let validator_keypair = Keypair::new();
let validator_node = Node::new_localhost_with_pubkey(validator_keypair.pubkey());
let validator_info = validator_node.info.clone();

56
src/ledger.rs
View File

@ -595,21 +595,21 @@ pub fn next_entries(
next_entries_mut(&mut id, &mut num_hashes, transactions)
}
pub fn tmp_ledger_path(name: &str) -> String {
pub fn get_tmp_ledger_path(name: &str) -> String {
use std::env;
let out_dir = env::var("OUT_DIR").unwrap_or_else(|_| "target".to_string());
let keypair = Keypair::new();
format!("{}/tmp/ledger-{}-{}", out_dir, name, keypair.pubkey())
let path = format!("{}/tmp/ledger-{}-{}", out_dir, name, keypair.pubkey());
// whack any possible collision
let _ignored = remove_dir_all(&path);
path
}
#[cfg(test)]
pub fn tmp_ledger_with_mint(name: &str, mint: &Mint) -> String {
use std::env;
let out_dir = env::var("OUT_DIR").unwrap_or_else(|_| "target".to_string());
let keypair = Keypair::new();
let path = format!("{}/tmp-ledger-{}-{}", out_dir, name, keypair.pubkey());
pub fn create_tmp_ledger_with_mint(name: &str, mint: &Mint) -> String {
let path = get_tmp_ledger_path(name);
let mut writer = LedgerWriter::open(&path, true).unwrap();
writer.write_entries(mint.create_entries()).unwrap();
@ -617,34 +617,20 @@ pub fn tmp_ledger_with_mint(name: &str, mint: &Mint) -> String {
path
}
#[cfg(test)]
pub fn genesis(name: &str, num: i64) -> (Mint, String) {
pub fn create_tmp_genesis(name: &str, num: i64) -> (Mint, String) {
let mint = Mint::new(num);
let path = tmp_ledger_path(name);
let mut writer = LedgerWriter::open(&path, true).unwrap();
writer.write_entries(mint.create_entries()).unwrap();
let path = create_tmp_ledger_with_mint(name, &mint);
(mint, path)
}
fn create_ticks(num_ticks: usize, hash: &mut Hash) -> Vec<Entry> {
let mut ticks = Vec::with_capacity(num_ticks);
let mut num_hashes = 0;
for _ in 0..num_ticks {
ticks.push(Entry::new_mut(hash, &mut num_hashes, vec![]));
}
ticks
}
pub fn create_sample_ledger(name: &str, num: i64) -> (Mint, String, Vec<Entry>) {
pub fn create_tmp_sample_ledger(name: &str, num: i64) -> (Mint, String, Vec<Entry>) {
let mint = Mint::new(num);
let path = tmp_ledger_path(name);
let path = get_tmp_ledger_path(name);
// Create the entries
let mut genesis = mint.create_entries();
let ticks = create_ticks(1, &mut mint.last_id());
genesis.extend(ticks);
genesis.extend(vec![Entry::new(&mint.last_id(), 0, vec![])]);
let mut writer = LedgerWriter::open(&path, true).unwrap();
writer.write_entries(genesis.clone()).unwrap();
@ -819,7 +805,7 @@ mod tests {
fn test_ledger_reader_writer() {
use logger;
logger::setup();
let ledger_path = tmp_ledger_path("test_ledger_reader_writer");
let ledger_path = get_tmp_ledger_path("test_ledger_reader_writer");
let entries = make_tiny_test_entries(10);
{
@ -899,7 +885,7 @@ mod tests {
logger::setup();
let entries = make_tiny_test_entries(10);
let ledger_path = tmp_ledger_path("test_recover_ledger");
let ledger_path = get_tmp_ledger_path("test_recover_ledger");
// truncate data file, tests recover inside read_ledger_check()
truncated_last_entry(&ledger_path, entries.clone());
@ -950,7 +936,7 @@ mod tests {
logger::setup();
let entries = make_tiny_test_entries(10);
let ledger_path = tmp_ledger_path("test_verify_ledger");
let ledger_path = get_tmp_ledger_path("test_verify_ledger");
{
let mut writer = LedgerWriter::open(&ledger_path, true).unwrap();
writer.write_entries(entries.clone()).unwrap();
@ -967,7 +953,7 @@ mod tests {
use logger;
logger::setup();
let entries = make_tiny_test_entries(10);
let ledger_path = tmp_ledger_path("test_raw_entries");
let ledger_path = get_tmp_ledger_path("test_raw_entries");
{
let mut writer = LedgerWriter::open(&ledger_path, true).unwrap();
writer.write_entries(entries.clone()).unwrap();
@ -1018,10 +1004,14 @@ mod tests {
let (num_entries, bytes6) = window.get_entries_bytes(9, 1, &mut buf).unwrap();
assert_eq!(num_entries, 1);
let bytes6 = bytes6 as usize;
assert_eq!(bytes6, bytes);
let entry: Entry = deserialize(&buf[size_of::<u64>()..bytes6]).unwrap();
assert_eq!(entry, entries[9]);
// Read out of range
assert!(window.get_entries_bytes(20, 2, &mut buf).is_err());
let _ignored = remove_dir_all(&ledger_path);
}
}

10
src/replicate_stage.rs
View File

@ -190,8 +190,8 @@ impl ReplicateStage {
return Some(ReplicateStageReturnType::LeaderRotation(
entry_height_,
// We should never start the TPU / this stage on an exact entry that causes leader
// rotation (Fullnode should automatically transition on startup if it detects
// are no longer a validator. Hence we can assume that some entry must have
// rotation (Fullnode should automatically transition on startup if it detects
// are no longer a validator. Hence we can assume that some entry must have
// triggered leader rotation
last_entry_id.expect("Must exist an entry that triggered rotation"),
));
@ -248,11 +248,12 @@ mod test {
use cluster_info::{ClusterInfo, Node};
use fullnode::Fullnode;
use leader_scheduler::{make_active_set_entries, LeaderScheduler, LeaderSchedulerConfig};
use ledger::{create_sample_ledger, next_entries_mut, LedgerWriter};
use ledger::{create_tmp_sample_ledger, next_entries_mut, LedgerWriter};
use logger;
use replicate_stage::{ReplicateStage, ReplicateStageReturnType};
use service::Service;
use signature::{Keypair, KeypairUtil};
use std::fs::remove_dir_all;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::mpsc::channel;
use std::sync::{Arc, RwLock};
@ -269,7 +270,7 @@ mod test {
// Create a ledger
let (mint, my_ledger_path, genesis_entries) =
create_sample_ledger("test_replicate_stage_leader_rotation_exit", 10_000);
create_tmp_sample_ledger("test_replicate_stage_leader_rotation_exit", 10_000);
let mut last_id = genesis_entries
.last()
.expect("expected at least one genesis entry")
@ -357,5 +358,6 @@ mod test {
Fullnode::new_bank_from_ledger(&my_ledger_path, &mut leader_scheduler);
assert_eq!(entry_height, bootstrap_height);
let _ignored = remove_dir_all(&my_ledger_path);
}
}

6
src/replicator.rs
View File

@ -158,7 +158,7 @@ mod tests {
use fullnode::Fullnode;
use hash::Hash;
use leader_scheduler::LeaderScheduler;
use ledger::{genesis, read_ledger, tmp_ledger_path};
use ledger::{create_tmp_genesis, get_tmp_ledger_path, read_ledger};
use logger;
use replicator::sample_file;
use replicator::Replicator;
@ -178,13 +178,13 @@ mod tests {
logger::setup();
info!("starting replicator test");
let entry_height = 0;
let replicator_ledger_path = &tmp_ledger_path("replicator_test_replicator_ledger");
let replicator_ledger_path = &get_tmp_ledger_path("replicator_test_replicator_ledger");
let exit = Arc::new(AtomicBool::new(false));
let done = Arc::new(AtomicBool::new(false));
let leader_ledger_path = "replicator_test_leader_ledger";
let (mint, leader_ledger_path) = genesis(leader_ledger_path, 100);
let (mint, leader_ledger_path) = create_tmp_genesis(leader_ledger_path, 100);
info!("starting leader node");
let leader_keypair = Keypair::new();

4
src/rpc.rs
View File

@ -285,7 +285,7 @@ mod tests {
use hash::{hash, Hash};
use jsonrpc_core::Response;
use leader_scheduler::LeaderScheduler;
use ledger::tmp_ledger_with_mint;
use ledger::create_tmp_ledger_with_mint;
use mint::Mint;
use reqwest;
use reqwest::header::CONTENT_TYPE;
@ -547,7 +547,7 @@ mod tests {
let bank = Bank::new(&alice);
let bob_pubkey = Keypair::new().pubkey();
let leader_data = leader.info.clone();
let ledger_path = tmp_ledger_with_mint("rpc_send_tx", &alice);
let ledger_path = create_tmp_ledger_with_mint("rpc_send_tx", &alice);
let last_id = bank.last_id();
let tx = Transaction::system_move(&alice.keypair(), bob_pubkey, 20, last_id, 0);

23
src/thin_client.rs
View File

@ -435,26 +435,13 @@ mod tests {
use cluster_info::Node;
use fullnode::Fullnode;
use leader_scheduler::LeaderScheduler;
use ledger::LedgerWriter;
use ledger::create_tmp_ledger_with_mint;
use logger;
use mint::Mint;
use signature::{Keypair, KeypairUtil};
use std::fs::remove_dir_all;
use system_program::SystemProgram;
fn tmp_ledger(name: &str, mint: &Mint) -> String {
use std::env;
let out_dir = env::var("OUT_DIR").unwrap_or_else(|_| "target".to_string());
let keypair = Keypair::new();
let path = format!("{}/tmp/ledger-{}-{}", out_dir, name, keypair.pubkey());
let mut writer = LedgerWriter::open(&path, true).unwrap();
writer.write_entries(mint.create_entries()).unwrap();
path
}
#[test]
#[ignore]
fn test_thin_client() {
@ -466,7 +453,7 @@ mod tests {
let alice = Mint::new(10_000);
let bank = Bank::new(&alice);
let bob_pubkey = Keypair::new().pubkey();
let ledger_path = tmp_ledger("thin_client", &alice);
let ledger_path = create_tmp_ledger_with_mint("thin_client", &alice);
let server = Fullnode::new_with_bank(
leader_keypair,
@ -513,7 +500,7 @@ mod tests {
let bank = Bank::new(&alice);
let bob_pubkey = Keypair::new().pubkey();
let leader_data = leader.info.clone();
let ledger_path = tmp_ledger("bad_sig", &alice);
let ledger_path = create_tmp_ledger_with_mint("bad_sig", &alice);
let server = Fullnode::new_with_bank(
leader_keypair,
@ -573,7 +560,7 @@ mod tests {
let bank = Bank::new(&alice);
let bob_pubkey = Keypair::new().pubkey();
let leader_data = leader.info.clone();
let ledger_path = tmp_ledger("client_check_signature", &alice);
let ledger_path = create_tmp_ledger_with_mint("client_check_signature", &alice);
let genesis_entries = &alice.create_entries();
let entry_height = genesis_entries.len() as u64;
@ -636,7 +623,7 @@ mod tests {
let bank = Bank::new(&alice);
let bob_keypair = Keypair::new();
let leader_data = leader.info.clone();
let ledger_path = tmp_ledger("zero_balance_check", &alice);
let ledger_path = create_tmp_ledger_with_mint("zero_balance_check", &alice);
let genesis_entries = &alice.create_entries();
let entry_height = genesis_entries.len() as u64;

62
src/wallet.rs
View File

@ -617,26 +617,12 @@ mod tests {
use drone::run_local_drone;
use fullnode::Fullnode;
use leader_scheduler::LeaderScheduler;
use ledger::LedgerWriter;
use mint::Mint;
use ledger::create_tmp_genesis;
use serde_json::Value;
use signature::{read_keypair, read_pkcs8, Keypair, KeypairUtil};
use std::fs::remove_dir_all;
use std::sync::mpsc::channel;
fn tmp_ledger(name: &str, mint: &Mint) -> String {
use std::env;
let out_dir = env::var("OUT_DIR").unwrap_or_else(|_| "target".to_string());
let keypair = Keypair::new();
let path = format!("{}/tmp/ledger-{}-{}", out_dir, name, keypair.pubkey());
let mut writer = LedgerWriter::open(&path, true).unwrap();
writer.write_entries(mint.create_entries()).unwrap();
path
}
#[test]
fn test_wallet_parse_command() {
let test_commands = App::new("test")
@ -929,15 +915,15 @@ mod tests {
#[test]
#[ignore]
fn test_wallet_process_command() {
let (alice, ledger_path) = create_tmp_genesis("wallet_process_command", 10_000_000);
let bank = Bank::new(&alice);
let bob_pubkey = Keypair::new().pubkey();
let leader_keypair = Keypair::new();
let leader = Node::new_localhost_with_pubkey(leader_keypair.pubkey());
let alice = Mint::new(10_000_000);
let bank = Bank::new(&alice);
let bob_pubkey = Keypair::new().pubkey();
let leader_data = leader.info.clone();
let leader_data1 = leader.info.clone();
let ledger_path = tmp_ledger("wallet_process_command", &alice);
let mut config = WalletConfig::default();
let rpc_port = 12345; // Needs to be distinct known number to not conflict with other tests
@ -1006,14 +992,13 @@ mod tests {
}
#[test]
fn test_wallet_request_airdrop() {
let leader_keypair = Keypair::new();
let leader = Node::new_localhost_with_pubkey(leader_keypair.pubkey());
let alice = Mint::new(10_000_000);
let (alice, ledger_path) = create_tmp_genesis("wallet_request_airdrop", 10_000_000);
let bank = Bank::new(&alice);
let bob_pubkey = Keypair::new().pubkey();
let leader_keypair = Keypair::new();
let leader = Node::new_localhost_with_pubkey(leader_keypair.pubkey());
let leader_data = leader.info.clone();
let ledger_path = tmp_ledger("wallet_request_airdrop", &alice);
let rpc_port = 11111; // Needs to be distinct known number to not conflict with other tests
@ -1054,6 +1039,7 @@ mod tests {
server.close().unwrap();
remove_dir_all(ledger_path).unwrap();
}
fn tmp_file_path(name: &str) -> String {
use std::env;
let out_dir = env::var("OUT_DIR").unwrap_or_else(|_| "target".to_string());
@ -1080,16 +1066,16 @@ mod tests {
#[test]
#[ignore]
fn test_wallet_timestamp_tx() {
let (alice, ledger_path) = create_tmp_genesis("wallet_timestamp_tx", 10_000_000);
let bank = Bank::new(&alice);
let bob_pubkey = Keypair::new().pubkey();
let leader_keypair = Keypair::new();
let leader = Node::new_localhost_with_pubkey(leader_keypair.pubkey());
let alice = Mint::new(10_000_000);
let bank = Bank::new(&alice);
let bob_pubkey = Keypair::new().pubkey();
let leader_data = leader.info.clone();
let leader_data1 = leader.info.clone();
let leader_data2 = leader.info.clone();
let ledger_path = tmp_ledger("wallet_timestamp_tx", &alice);
let mut config_payer = WalletConfig::default();
let mut config_witness = WalletConfig::default();
@ -1201,16 +1187,14 @@ mod tests {
#[test]
#[ignore]
fn test_wallet_witness_tx() {
let leader_keypair = Keypair::new();
let leader = Node::new_localhost_with_pubkey(leader_keypair.pubkey());
let alice = Mint::new(10_000_000);
let (alice, ledger_path) = create_tmp_genesis("wallet_witness_tx", 10_000_000);
let bank = Bank::new(&alice);
let bob_pubkey = Keypair::new().pubkey();
let leader_keypair = Keypair::new();
let leader = Node::new_localhost_with_pubkey(leader_keypair.pubkey());
let leader_data = leader.info.clone();
let leader_data1 = leader.info.clone();
let leader_data2 = leader.info.clone();
let ledger_path = tmp_ledger("wallet_witness_tx", &alice);
let mut config_payer = WalletConfig::default();
let mut config_witness = WalletConfig::default();
@ -1320,16 +1304,14 @@ mod tests {
#[test]
#[ignore]
fn test_wallet_cancel_tx() {
let leader_keypair = Keypair::new();
let leader = Node::new_localhost_with_pubkey(leader_keypair.pubkey());
let alice = Mint::new(10_000_000);
let (alice, ledger_path) = create_tmp_genesis("wallet_cancel_tx", 10_000_000);
let bank = Bank::new(&alice);
let bob_pubkey = Keypair::new().pubkey();
let leader_keypair = Keypair::new();
let leader = Node::new_localhost_with_pubkey(leader_keypair.pubkey());
let leader_data = leader.info.clone();
let leader_data1 = leader.info.clone();
let leader_data2 = leader.info.clone();
let ledger_path = tmp_ledger("wallet_cancel_tx", &alice);
let mut config_payer = WalletConfig::default();
let mut config_witness = WalletConfig::default();

4
src/write_stage.rs
View File

@ -328,7 +328,7 @@ mod tests {
use entry::Entry;
use hash::Hash;
use leader_scheduler::{set_new_leader, LeaderScheduler, LeaderSchedulerConfig};
use ledger::{genesis, next_entries_mut, read_ledger};
use ledger::{create_tmp_genesis, next_entries_mut, read_ledger};
use service::Service;
use signature::{Keypair, KeypairUtil};
use solana_program_interface::account::Account;
@ -373,7 +373,7 @@ mod tests {
let bank = Arc::new(Bank::default());
// Make a ledger
let (_, leader_ledger_path) = genesis(test_name, 10_000);
let (_, leader_ledger_path) = create_tmp_genesis(test_name, 10_000);
let (entry_height, ledger_tail) = process_ledger(&leader_ledger_path, &bank);

47
tests/multinode.rs
View File

@ -11,7 +11,9 @@ use solana::entry::Entry;
use solana::fullnode::{Fullnode, FullnodeReturnType};
use solana::hash::Hash;
use solana::leader_scheduler::{make_active_set_entries, LeaderScheduler, LeaderSchedulerConfig};
use solana::ledger::{create_sample_ledger, read_ledger, LedgerWriter};
use solana::ledger::{
create_tmp_genesis, create_tmp_sample_ledger, get_tmp_ledger_path, read_ledger, LedgerWriter,
};
use solana::logger;
use solana::mint::Mint;
use solana::ncp::Ncp;
@ -79,28 +81,8 @@ fn converge(leader: &NodeInfo, num_nodes: usize) -> Vec<NodeInfo> {
rv
}
fn tmp_ledger_path(name: &str) -> String {
use std::env;
let out_dir = env::var("OUT_DIR").unwrap_or_else(|_| "target".to_string());
let keypair = Keypair::new();
format!("{}/tmp/ledger-{}-{}", out_dir, name, keypair.pubkey())
}
fn genesis(name: &str, num: i64) -> (Mint, String, Vec<Entry>) {
let mint = Mint::new(num);
let path = tmp_ledger_path(name);
let mut writer = LedgerWriter::open(&path, true).unwrap();
let entries = mint.create_entries();
writer.write_entries(entries.clone()).unwrap();
(mint, path, entries)
}
fn tmp_copy_ledger(from: &str, name: &str) -> String {
let tostr = tmp_ledger_path(name);
let tostr = get_tmp_ledger_path(name);
{
let to = Path::new(&tostr);
@ -134,7 +116,7 @@ fn test_multi_node_ledger_window() -> result::Result<()> {
let bob_pubkey = Keypair::new().pubkey();
let mut ledger_paths = Vec::new();
let (alice, leader_ledger_path, _) = genesis("multi_node_ledger_window", 10_000);
let (alice, leader_ledger_path) = create_tmp_genesis("multi_node_ledger_window", 10_000);
ledger_paths.push(leader_ledger_path.clone());
// make a copy at zero
@ -231,7 +213,8 @@ fn test_multi_node_validator_catchup_from_zero() -> result::Result<()> {
let bob_pubkey = Keypair::new().pubkey();
let mut ledger_paths = Vec::new();
let (alice, leader_ledger_path, _) = genesis("multi_node_validator_catchup_from_zero", 10_000);
let (alice, leader_ledger_path) =
create_tmp_genesis("multi_node_validator_catchup_from_zero", 10_000);
ledger_paths.push(leader_ledger_path.clone());
let zero_ledger_path = tmp_copy_ledger(
@ -371,7 +354,7 @@ fn test_multi_node_basic() {
let bob_pubkey = Keypair::new().pubkey();
let mut ledger_paths = Vec::new();
let (alice, leader_ledger_path, _) = genesis("multi_node_basic", 10_000);
let (alice, leader_ledger_path) = create_tmp_genesis("multi_node_basic", 10_000);
ledger_paths.push(leader_ledger_path.clone());
let server = Fullnode::new(
leader,
@ -446,7 +429,7 @@ fn test_boot_validator_from_file() -> result::Result<()> {
let leader_pubkey = leader_keypair.pubkey();
let leader = Node::new_localhost_with_pubkey(leader_keypair.pubkey());
let bob_pubkey = Keypair::new().pubkey();
let (alice, leader_ledger_path, _) = genesis("boot_validator_from_file", 100_000);
let (alice, leader_ledger_path) = create_tmp_genesis("boot_validator_from_file", 100_000);
let mut ledger_paths = Vec::new();
ledger_paths.push(leader_ledger_path.clone());
@ -514,7 +497,7 @@ fn test_leader_restart_validator_start_from_old_ledger() -> result::Result<()> {
// ledger (currently up to WINDOW_SIZE entries)
logger::setup();
let (alice, ledger_path, _) = genesis(
let (alice, ledger_path) = create_tmp_genesis(
"leader_restart_validator_start_from_old_ledger",
100_000 + 500 * solana::window_service::MAX_REPAIR_BACKOFF as i64,
);
@ -607,7 +590,7 @@ fn test_multi_node_dynamic_network() {
let leader_pubkey = leader_keypair.pubkey().clone();
let leader = Node::new_localhost_with_pubkey(leader_keypair.pubkey());
let bob_pubkey = Keypair::new().pubkey();
let (alice, leader_ledger_path, _) = genesis("multi_node_dynamic_network", 10_000_000);
let (alice, leader_ledger_path) = create_tmp_genesis("multi_node_dynamic_network", 10_000_000);
let mut ledger_paths = Vec::new();
ledger_paths.push(leader_ledger_path.clone());
@ -804,7 +787,7 @@ fn test_leader_to_validator_transition() {
// Initialize the leader ledger. Make a mint and a genesis entry
// in the leader ledger
let (mint, leader_ledger_path, genesis_entries) =
create_sample_ledger("test_leader_to_validator_transition", 10_000);
create_tmp_sample_ledger("test_leader_to_validator_transition", 10_000);
let last_id = genesis_entries
.last()
@ -945,7 +928,7 @@ fn test_leader_validator_basic() {
// Make a common mint and a genesis entry for both leader + validator ledgers
let (mint, leader_ledger_path, genesis_entries) =
create_sample_ledger("test_leader_to_validator_transition", 10_000);
create_tmp_sample_ledger("test_leader_to_validator_transition", 10_000);
let validator_ledger_path = tmp_copy_ledger(&leader_ledger_path, "test_leader_validator_basic");
@ -1100,7 +1083,7 @@ fn test_dropped_handoff_recovery() {
// Make a common mint and a genesis entry for both leader + validator's ledgers
let (mint, bootstrap_leader_ledger_path, genesis_entries) =
create_sample_ledger("test_dropped_handoff_recovery", 10_000);
create_tmp_sample_ledger("test_dropped_handoff_recovery", 10_000);
let last_id = genesis_entries
.last()
@ -1245,7 +1228,7 @@ fn test_full_leader_validator_network() {
// Make a common mint and a genesis entry for both leader + validator's ledgers
let (mint, bootstrap_leader_ledger_path, genesis_entries) =
create_sample_ledger("test_full_leader_validator_network", 10_000);
create_tmp_sample_ledger("test_full_leader_validator_network", 10_000);
let last_tick_id = genesis_entries
.last()