consolidate tmp ledgers

src/cluster_info.rs

@@ -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 path = get_tmp_ledger_path(name);
-            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();
             let zero = Hash::default();

src/drone.rs

@@ -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,

src/fullnode.rs

@@ -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();

src/ledger.rs

@@ -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 create_tmp_ledger_with_mint(name: &str, mint: &Mint) -> String {
-pub fn tmp_ledger_with_mint(name: &str, mint: &Mint) -> String {
+    let path = get_tmp_ledger_path(name);
-    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();
@@ -617,34 +617,20 @@ pub fn tmp_ledger_with_mint(name: &str, mint: &Mint) -> String {
     path
 }
 
-#[cfg(test)]
+pub fn create_tmp_genesis(name: &str, num: i64) -> (Mint, String) {
-pub fn genesis(name: &str, num: i64) -> (Mint, String) {
     let mint = Mint::new(num);
-    let path = tmp_ledger_path(name);
+    let path = create_tmp_ledger_with_mint(name, &mint);
-    let mut writer = LedgerWriter::open(&path, true).unwrap();
-    writer.write_entries(mint.create_entries()).unwrap();
 
     (mint, path)
 }
 
-fn create_ticks(num_ticks: usize, hash: &mut Hash) -> Vec<Entry> {
+pub fn create_tmp_sample_ledger(name: &str, num: i64) -> (Mint, String, 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>) {
     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(vec![Entry::new(&mint.last_id(), 0, vec![])]);
-    genesis.extend(ticks);
 
     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);
     }
 
 }

src/replicate_stage.rs

@@ -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 
+                            // rotation (Fullnode should automatically transition on startup if it detects
-                            // are no longer a validator. Hence we can assume that some entry must have 
+                            // 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);
     }
 }

src/replicator.rs

@@ -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();

src/rpc.rs

@@ -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);

src/thin_client.rs

@@ -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;

src/wallet.rs

@@ -617,26 +617,12 @@ mod tests {
     use drone::run_local_drone;
     use fullnode::Fullnode;
     use leader_scheduler::LeaderScheduler;
-    use ledger::LedgerWriter;
+    use ledger::create_tmp_genesis;
-    use mint::Mint;
     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 (alice, ledger_path) = create_tmp_genesis("wallet_request_airdrop", 10_000_000);
-        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_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 (alice, ledger_path) = create_tmp_genesis("wallet_witness_tx", 10_000_000);
-        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_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 (alice, ledger_path) = create_tmp_genesis("wallet_cancel_tx", 10_000_000);
-        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_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();

src/write_stage.rs

@@ -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);
 

tests/multinode.rs

@@ -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()