Cleanup ledger macros (#6916)

automerge

banking-bench/src/main.rs

@@ -1,7 +1,3 @@
-#[macro_use]
-extern crate solana_ledger;
-extern crate crossbeam_channel;
-
 use crossbeam_channel::unbounded;
 use log::*;
 use rand::{thread_rng, Rng};
@@ -15,7 +11,7 @@ use solana_core::poh_recorder::PohRecorder;
 use solana_core::poh_recorder::WorkingBankEntry;
 use solana_core::service::Service;
 use solana_ledger::bank_forks::BankForks;
-use solana_ledger::blocktree::{get_tmp_ledger_path, Blocktree};
+use solana_ledger::{blocktree::Blocktree, get_tmp_ledger_path};
 use solana_measure::measure::Measure;
 use solana_runtime::bank::Bank;
 use solana_sdk::hash::Hash;

core/benches/banking_stage.rs

@@ -15,9 +15,9 @@ use solana_core::genesis_utils::{create_genesis_config, GenesisConfigInfo};
 use solana_core::packet::to_packets_chunked;
 use solana_core::poh_recorder::WorkingBankEntry;
 use solana_core::service::Service;
-use solana_ledger::blocktree::{get_tmp_ledger_path, Blocktree};
 use solana_ledger::blocktree_processor::process_entries;
 use solana_ledger::entry::{next_hash, Entry};
+use solana_ledger::{blocktree::Blocktree, get_tmp_ledger_path};
 use solana_perf::test_tx::test_tx;
 use solana_runtime::bank::Bank;
 use solana_sdk::genesis_config::GenesisConfig;

core/benches/blocktree.rs

@@ -8,8 +8,9 @@ extern crate solana_ledger;
 
 use rand::Rng;
 use solana_ledger::{
-    blocktree::{entries_to_test_shreds, get_tmp_ledger_path, Blocktree},
+    blocktree::{entries_to_test_shreds, Blocktree},
     entry::{create_ticks, Entry},
+    get_tmp_ledger_path,
 };
 use solana_sdk::{clock::Slot, hash::Hash};
 use std::path::Path;

core/src/banking_stage.rs

@@ -978,8 +978,8 @@ mod tests {
     use crate::poh_recorder::WorkingBank;
     use crossbeam_channel::unbounded;
     use itertools::Itertools;
-    use solana_ledger::blocktree::get_tmp_ledger_path;
     use solana_ledger::entry::{Entry, EntrySlice};
+    use solana_ledger::get_tmp_ledger_path;
     use solana_sdk::instruction::InstructionError;
     use solana_sdk::signature::{Keypair, KeypairUtil};
     use solana_sdk::system_transaction;

core/src/blockstream_service.rs

@@ -105,7 +105,7 @@ mod test {
     use bincode::{deserialize, serialize};
     use chrono::{DateTime, FixedOffset};
     use serde_json::Value;
-    use solana_ledger::blocktree::create_new_tmp_ledger;
+    use solana_ledger::create_new_tmp_ledger;
     use solana_ledger::entry::{create_ticks, Entry};
     use solana_sdk::hash::Hash;
     use solana_sdk::signature::{Keypair, KeypairUtil};

core/src/broadcast_stage.rs

@@ -194,8 +194,8 @@ mod test {
     use crate::cluster_info::{ClusterInfo, Node};
     use crate::genesis_utils::{create_genesis_config, GenesisConfigInfo};
     use crate::service::Service;
-    use solana_ledger::blocktree::{get_tmp_ledger_path, Blocktree};
     use solana_ledger::entry::create_ticks;
+    use solana_ledger::{blocktree::Blocktree, get_tmp_ledger_path};
     use solana_runtime::bank::Bank;
     use solana_sdk::hash::Hash;
     use solana_sdk::pubkey::Pubkey;
@@ -259,7 +259,7 @@ mod test {
     #[test]
     fn test_broadcast_ledger() {
         solana_logger::setup();
-        let ledger_path = get_tmp_ledger_path("test_broadcast_ledger");
+        let ledger_path = get_tmp_ledger_path!();
 
         {
             // Create the leader scheduler

core/src/broadcast_stage/standard_broadcast_run.rs

@@ -300,8 +300,7 @@ mod test {
     use crate::cluster_info::{ClusterInfo, Node};
     use crate::genesis_utils::create_genesis_config;
     use solana_ledger::{
-        blocktree::{get_tmp_ledger_path, Blocktree},
-        entry::create_ticks,
+        blocktree::Blocktree, entry::create_ticks, get_tmp_ledger_path,
         shred::max_ticks_per_n_shreds,
     };
     use solana_runtime::bank::Bank;

core/src/chacha.rs

@@ -75,9 +75,9 @@ pub fn chacha_cbc_encrypt_ledger(
 mod tests {
     use crate::chacha::chacha_cbc_encrypt_ledger;
     use crate::gen_keys::GenKeys;
-    use solana_ledger::blocktree::get_tmp_ledger_path;
     use solana_ledger::blocktree::Blocktree;
     use solana_ledger::entry::Entry;
+    use solana_ledger::get_tmp_ledger_path;
     use solana_sdk::hash::{hash, Hash, Hasher};
     use solana_sdk::pubkey::Pubkey;
     use solana_sdk::signature::KeypairUtil;
@@ -128,8 +128,7 @@ mod tests {
     #[test]
     fn test_encrypt_ledger() {
         solana_logger::setup();
-        let ledger_dir = "chacha_test_encrypt_file";
-        let ledger_path = get_tmp_ledger_path(ledger_dir);
+        let ledger_path = get_tmp_ledger_path!();
         let ticks_per_slot = 16;
         let slots_per_segment = 32;
         let blocktree = Arc::new(Blocktree::open(&ledger_path).unwrap());

core/src/chacha_cuda.rs

@@ -115,8 +115,8 @@ mod tests {
     use super::*;
     use crate::archiver::sample_file;
     use crate::chacha::chacha_cbc_encrypt_ledger;
-    use solana_ledger::blocktree::get_tmp_ledger_path;
     use solana_ledger::entry::create_ticks;
+    use solana_ledger::get_tmp_ledger_path;
     use solana_sdk::clock::DEFAULT_SLOTS_PER_SEGMENT;
     use solana_sdk::signature::{Keypair, KeypairUtil};
     use std::fs::{remove_dir_all, remove_file};
@@ -132,8 +132,7 @@ mod tests {
 
         let slots_per_segment = 32;
         let entries = create_ticks(slots_per_segment, 0, Hash::default());
-        let ledger_dir = "test_encrypt_file_many_keys_single";
-        let ledger_path = get_tmp_ledger_path(ledger_dir);
+        let ledger_path = get_tmp_ledger_path!();
         let ticks_per_slot = 16;
         let blocktree = Arc::new(Blocktree::open(&ledger_path).unwrap());
 
@@ -193,8 +192,7 @@ mod tests {
             return;
         }
 
-        let ledger_dir = "test_encrypt_file_many_keys_multiple";
-        let ledger_path = get_tmp_ledger_path(ledger_dir);
+        let ledger_path = get_tmp_ledger_path!();
         let ticks_per_slot = 90;
         let entries = create_ticks(2 * ticks_per_slot, 0, Hash::default());
         let blocktree = Arc::new(Blocktree::open(&ledger_path).unwrap());
@@ -265,8 +263,7 @@ mod tests {
         }
 
         let mut keys = hex!("abc123");
-        let ledger_dir = "test_encrypt_file_many_keys_bad_key_length";
-        let ledger_path = get_tmp_ledger_path(ledger_dir);
+        let ledger_path = get_tmp_ledger_path!();
         let samples = [0];
         let blocktree = Arc::new(Blocktree::open(&ledger_path).unwrap());
         assert!(chacha_cbc_encrypt_file_many_keys(

core/src/cluster_info.rs

@@ -1812,10 +1812,10 @@ mod tests {
     use crate::repair_service::RepairType;
     use crate::result::Error;
     use rayon::prelude::*;
-    use solana_ledger::blocktree::get_tmp_ledger_path;
     use solana_ledger::blocktree::make_many_slot_entries;
     use solana_ledger::blocktree::Blocktree;
     use solana_ledger::blocktree_processor::fill_blocktree_slot_with_ticks;
+    use solana_ledger::get_tmp_ledger_path;
     use solana_ledger::shred::{
         max_ticks_per_n_shreds, CodingShredHeader, DataShredHeader, Shred, ShredCommonHeader,
     };

core/src/cluster_info_repair_listener.rs

@@ -534,8 +534,8 @@ mod tests {
     use crate::blob::{Blob, SharedBlob};
     use crate::cluster_info::Node;
     use crate::streamer;
-    use solana_ledger::blocktree::get_tmp_ledger_path;
     use solana_ledger::blocktree::make_many_slot_entries;
+    use solana_ledger::get_tmp_ledger_path;
     use std::collections::BTreeSet;
     use std::sync::atomic::{AtomicBool, Ordering};
     use std::sync::mpsc::channel;

core/src/ledger_cleanup_service.rs

@@ -75,8 +75,8 @@ impl Service for LedgerCleanupService {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use solana_ledger::blocktree::get_tmp_ledger_path;
     use solana_ledger::blocktree::make_many_slot_entries;
+    use solana_ledger::get_tmp_ledger_path;
     use std::sync::mpsc::channel;
 
     #[test]

core/src/lib.rs

@@ -101,6 +101,3 @@ extern crate solana_metrics;
 #[cfg(test)]
 #[macro_use]
 extern crate matches;
-
-#[macro_use]
-extern crate solana_ledger;

core/src/poh_recorder.rs

@@ -469,7 +469,7 @@ impl PohRecorder {
 mod tests {
     use super::*;
     use crate::genesis_utils::{create_genesis_config, GenesisConfigInfo};
-    use solana_ledger::blocktree::{get_tmp_ledger_path, Blocktree};
+    use solana_ledger::{blocktree::Blocktree, get_tmp_ledger_path};
     use solana_perf::test_tx::test_tx;
     use solana_sdk::clock::DEFAULT_TICKS_PER_SLOT;
     use solana_sdk::hash::hash;

core/src/poh_service.rs

@@ -112,8 +112,8 @@ mod tests {
     use crate::genesis_utils::{create_genesis_config, GenesisConfigInfo};
     use crate::poh_recorder::WorkingBank;
     use crate::result::Result;
-    use solana_ledger::blocktree::{get_tmp_ledger_path, Blocktree};
     use solana_ledger::leader_schedule_cache::LeaderScheduleCache;
+    use solana_ledger::{blocktree::Blocktree, get_tmp_ledger_path};
     use solana_perf::test_tx::test_tx;
     use solana_runtime::bank::Bank;
     use solana_sdk::hash::hash;

core/src/repair_service.rs

@@ -397,11 +397,11 @@ mod test {
     use itertools::Itertools;
     use rand::seq::SliceRandom;
     use rand::{thread_rng, Rng};
-    use solana_ledger::blocktree::{get_tmp_ledger_path, Blocktree};
     use solana_ledger::blocktree::{
         make_chaining_slot_entries, make_many_slot_entries, make_slot_entries,
     };
     use solana_ledger::shred::max_ticks_per_n_shreds;
+    use solana_ledger::{blocktree::Blocktree, get_tmp_ledger_path};
     use std::sync::mpsc::channel;
     use std::thread::Builder;
 

core/src/replay_stage.rs

@@ -943,12 +943,15 @@ mod test {
     use crate::genesis_utils::{create_genesis_config, create_genesis_config_with_leader};
     use crate::replay_stage::ReplayStage;
     use solana_ledger::blocktree::make_slot_entries;
-    use solana_ledger::blocktree::{entries_to_test_shreds, get_tmp_ledger_path, BlocktreeError};
     use solana_ledger::entry;
     use solana_ledger::shred::{
         CodingShredHeader, DataShredHeader, Shred, ShredCommonHeader, DATA_COMPLETE_SHRED,
         SIZE_OF_COMMON_SHRED_HEADER, SIZE_OF_DATA_SHRED_HEADER, SIZE_OF_DATA_SHRED_PAYLOAD,
     };
+    use solana_ledger::{
+        blocktree::{entries_to_test_shreds, BlocktreeError},
+        get_tmp_ledger_path,
+    };
     use solana_runtime::genesis_utils::GenesisConfigInfo;
     use solana_sdk::hash::{hash, Hash};
     use solana_sdk::packet::PACKET_DATA_SIZE;

core/src/retransmit_stage.rs

@@ -276,8 +276,8 @@ mod tests {
     use crate::contact_info::ContactInfo;
     use crate::genesis_utils::{create_genesis_config, GenesisConfigInfo};
     use crate::packet::{self, Meta, Packet, Packets};
-    use solana_ledger::blocktree::create_new_tmp_ledger;
     use solana_ledger::blocktree_processor::{process_blocktree, ProcessOptions};
+    use solana_ledger::create_new_tmp_ledger;
     use solana_net_utils::find_available_port_in_range;
     use solana_sdk::pubkey::Pubkey;
 

core/src/rpc.rs

@@ -1030,7 +1030,7 @@ pub mod tests {
         genesis_utils::{create_genesis_config, GenesisConfigInfo},
     };
     use jsonrpc_core::{MetaIoHandler, Output, Response, Value};
-    use solana_ledger::blocktree::get_tmp_ledger_path;
+    use solana_ledger::get_tmp_ledger_path;
     use solana_sdk::{
         fee_calculator::DEFAULT_BURN_PERCENT,
         hash::{hash, Hash},

core/src/rpc_service.rs

@@ -181,7 +181,7 @@ mod tests {
         genesis_utils::{create_genesis_config, GenesisConfigInfo},
         rpc::tests::create_validator_exit,
     };
-    use solana_ledger::blocktree::get_tmp_ledger_path;
+    use solana_ledger::get_tmp_ledger_path;
     use solana_runtime::bank::Bank;
     use solana_sdk::signature::KeypairUtil;
     use std::net::{IpAddr, Ipv4Addr, SocketAddr};

core/src/tvu.rs

@@ -236,7 +236,7 @@ pub mod tests {
     use crate::banking_stage::create_test_recorder;
     use crate::cluster_info::{ClusterInfo, Node};
     use crate::genesis_utils::{create_genesis_config, GenesisConfigInfo};
-    use solana_ledger::blocktree::create_new_tmp_ledger;
+    use solana_ledger::create_new_tmp_ledger;
     use solana_runtime::bank::Bank;
     use std::sync::atomic::Ordering;
 

core/src/validator.rs

@@ -23,6 +23,7 @@ use solana_ledger::{
     bank_forks_utils,
     blocktree::{Blocktree, CompletedSlotsReceiver},
     blocktree_processor::{self, BankForksInfo},
+    create_new_tmp_ledger,
     leader_schedule_cache::LeaderScheduleCache,
 };
 use solana_metrics::datapoint_info;
@@ -503,7 +504,6 @@ impl Service for Validator {
 
 pub fn new_validator_for_tests() -> (Validator, ContactInfo, Keypair, PathBuf) {
     use crate::genesis_utils::{create_genesis_config_with_leader, GenesisConfigInfo};
-    use solana_ledger::blocktree::create_new_tmp_ledger;
 
     let node_keypair = Arc::new(Keypair::new());
     let node = Node::new_localhost_with_pubkey(&node_keypair.pubkey());
@@ -544,7 +544,6 @@ pub fn new_validator_for_tests() -> (Validator, ContactInfo, Keypair, PathBuf) {
 mod tests {
     use super::*;
     use crate::genesis_utils::create_genesis_config_with_leader;
-    use solana_ledger::blocktree::create_new_tmp_ledger;
     use std::fs::remove_dir_all;
 
     #[test]

core/src/window_service.rs

@@ -288,8 +288,9 @@ mod test {
     use rand::thread_rng;
     use solana_ledger::shred::DataShredHeader;
     use solana_ledger::{
-        blocktree::{get_tmp_ledger_path, make_many_slot_entries, Blocktree},
+        blocktree::{make_many_slot_entries, Blocktree},
         entry::{create_ticks, Entry},
+        get_tmp_ledger_path,
         shred::Shredder,
     };
     use solana_sdk::{

core/tests/storage_stage.rs

@@ -1,8 +1,5 @@
 // Long-running storage_stage tests
 
-#[macro_use]
-extern crate solana_ledger;
-
 #[cfg(test)]
 mod tests {
     use log::*;
@@ -11,9 +8,9 @@ mod tests {
     use solana_core::storage_stage::{test_cluster_info, SLOTS_PER_TURN_TEST};
     use solana_core::storage_stage::{StorageStage, StorageState};
     use solana_ledger::bank_forks::BankForks;
-    use solana_ledger::blocktree::{create_new_tmp_ledger, Blocktree};
     use solana_ledger::blocktree_processor;
     use solana_ledger::entry;
+    use solana_ledger::{blocktree::Blocktree, create_new_tmp_ledger};
     use solana_runtime::bank::Bank;
     use solana_sdk::clock::DEFAULT_TICKS_PER_SLOT;
     use solana_sdk::hash::Hash;

ledger-tool/tests/basic.rs

@@ -1,8 +1,5 @@
-#[macro_use]
-extern crate solana_ledger;
-
 use assert_cmd::prelude::*;
-use solana_ledger::blocktree::create_new_tmp_ledger;
+use solana_ledger::create_new_tmp_ledger;
 use solana_ledger::genesis_utils::create_genesis_config;
 use std::process::Command;
 use std::process::Output;

ledger/src/blocktree.rs

@@ -1776,11 +1776,11 @@ macro_rules! tmp_ledger_name {
 #[macro_export]
 macro_rules! get_tmp_ledger_path {
     () => {
-        get_tmp_ledger_path(tmp_ledger_name!())
+        $crate::blocktree::get_ledger_path_from_name($crate::tmp_ledger_name!())
     };
 }
 
-pub fn get_tmp_ledger_path(name: &str) -> PathBuf {
+pub fn get_ledger_path_from_name(name: &str) -> PathBuf {
     use std::env;
     let out_dir = env::var("FARF_DIR").unwrap_or_else(|_| "farf".to_string());
     let keypair = Keypair::new();
@@ -1802,7 +1802,7 @@ pub fn get_tmp_ledger_path(name: &str) -> PathBuf {
 #[macro_export]
 macro_rules! create_new_tmp_ledger {
     ($genesis_config:expr) => {
-        create_new_tmp_ledger(tmp_ledger_name!(), $genesis_config)
+        $crate::blocktree::create_new_ledger_from_name($crate::tmp_ledger_name!(), $genesis_config)
     };
 }
 
@@ -1828,8 +1828,8 @@ pub fn verify_shred_slots(slot: Slot, parent_slot: Slot, last_root: u64) -> bool
 //
 // Note: like `create_new_ledger` the returned ledger will have slot 0 full of ticks (and only
 // ticks)
-pub fn create_new_tmp_ledger(name: &str, genesis_config: &GenesisConfig) -> (PathBuf, Hash) {
-    let ledger_path = get_tmp_ledger_path(name);
+pub fn create_new_ledger_from_name(name: &str, genesis_config: &GenesisConfig) -> (PathBuf, Hash) {
+    let ledger_path = get_ledger_path_from_name(name);
     let blockhash = create_new_ledger(&ledger_path, genesis_config).unwrap();
     (ledger_path, blockhash)
 }
@@ -1976,7 +1976,7 @@ pub mod tests {
 
         let (mut shreds, _) = make_slot_entries(0, 0, num_entries);
 
-        let ledger_path = get_tmp_ledger_path("test_insert_data_shreds_basic");
+        let ledger_path = get_tmp_ledger_path!();
         let ledger = Blocktree::open(&ledger_path).unwrap();
 
         // Insert last shred, test we can retrieve it
@@ -2099,7 +2099,7 @@ pub mod tests {
 
     #[test]
     fn test_put_get_simple() {
-        let ledger_path = get_tmp_ledger_path("test_put_get_simple");
+        let ledger_path = get_tmp_ledger_path!();
         let ledger = Blocktree::open(&ledger_path).unwrap();
 
         // Test meta column family
@@ -2154,7 +2154,7 @@ pub mod tests {
         let num_shreds = shreds.len() as u64;
         let shred_bufs: Vec<_> = shreds.iter().map(|shred| shred.payload.clone()).collect();
 
-        let ledger_path = get_tmp_ledger_path("test_read_shreds_bytes");
+        let ledger_path = get_tmp_ledger_path!();
         let ledger = Blocktree::open(&ledger_path).unwrap();
         ledger.insert_shreds(shreds, None).unwrap();
 
@@ -2216,7 +2216,7 @@ pub mod tests {
         let (mut shreds, entries) = make_slot_entries(0, 0, num_entries);
         let num_shreds = shreds.len() as u64;
 
-        let ledger_path = get_tmp_ledger_path("test_insert_data_shreds_basic");
+        let ledger_path = get_tmp_ledger_path!();
         let ledger = Blocktree::open(&ledger_path).unwrap();
 
         // Insert last shred, we're missing the other shreds, so no consecutive
@@ -2261,7 +2261,7 @@ pub mod tests {
         let (mut shreds, entries) = make_slot_entries(0, 0, num_entries);
         let num_shreds = shreds.len() as u64;
 
-        let ledger_path = get_tmp_ledger_path("test_insert_data_shreds_reverse");
+        let ledger_path = get_tmp_ledger_path!();
         let ledger = Blocktree::open(&ledger_path).unwrap();
 
         // Insert shreds in reverse, check for consecutive returned shreds
@@ -2300,7 +2300,7 @@ pub mod tests {
         #[test]
         pub fn test_iteration_order() {
             let slot = 0;
-            let blocktree_path = get_tmp_ledger_path("test_iteration_order");
+            let blocktree_path = get_tmp_ledger_path!();
             {
                 let blocktree = Blocktree::open(&blocktree_path).unwrap();
 
@@ -2339,7 +2339,7 @@ pub mod tests {
 
     #[test]
     pub fn test_get_slot_entries1() {
-        let blocktree_path = get_tmp_ledger_path("test_get_slot_entries1");
+        let blocktree_path = get_tmp_ledger_path!();
         {
             let blocktree = Blocktree::open(&blocktree_path).unwrap();
             let entries = create_ticks(8, 0, Hash::default());
@@ -2369,7 +2369,7 @@ pub mod tests {
     #[test]
     #[ignore]
     pub fn test_get_slot_entries2() {
-        let blocktree_path = get_tmp_ledger_path("test_get_slot_entries2");
+        let blocktree_path = get_tmp_ledger_path!();
         {
             let blocktree = Blocktree::open(&blocktree_path).unwrap();
 
@@ -2403,7 +2403,7 @@ pub mod tests {
     #[test]
     pub fn test_get_slot_entries3() {
         // Test inserting/fetching shreds which contain multiple entries per shred
-        let blocktree_path = get_tmp_ledger_path("test_get_slot_entries3");
+        let blocktree_path = get_tmp_ledger_path!();
         {
             let blocktree = Blocktree::open(&blocktree_path).unwrap();
             let num_slots = 5 as u64;
@@ -2430,7 +2430,7 @@ pub mod tests {
 
     #[test]
     pub fn test_insert_data_shreds_consecutive() {
-        let blocktree_path = get_tmp_ledger_path("test_insert_data_shreds_consecutive");
+        let blocktree_path = get_tmp_ledger_path!();
         {
             let blocktree = Blocktree::open(&blocktree_path).unwrap();
             // Create enough entries to ensure there are at least two shreds created
@@ -2494,7 +2494,7 @@ pub mod tests {
     #[test]
     pub fn test_insert_data_shreds_duplicate() {
         // Create RocksDb ledger
-        let blocktree_path = get_tmp_ledger_path("test_insert_data_shreds_duplicate");
+        let blocktree_path = get_tmp_ledger_path!();
         {
             let blocktree = Blocktree::open(&blocktree_path).unwrap();
 
@@ -2531,7 +2531,7 @@ pub mod tests {
     #[test]
     pub fn test_new_shreds_signal() {
         // Initialize ledger
-        let ledger_path = get_tmp_ledger_path("test_new_shreds_signal");
+        let ledger_path = get_tmp_ledger_path!();
         let (ledger, recvr, _) = Blocktree::open_with_signal(&ledger_path).unwrap();
         let ledger = Arc::new(ledger);
 
@@ -2607,7 +2607,7 @@ pub mod tests {
     #[test]
     pub fn test_completed_shreds_signal() {
         // Initialize ledger
-        let ledger_path = get_tmp_ledger_path("test_completed_shreds_signal");
+        let ledger_path = get_tmp_ledger_path!();
         let (ledger, _, recvr) = Blocktree::open_with_signal(&ledger_path).unwrap();
         let ledger = Arc::new(ledger);
 
@@ -2629,7 +2629,7 @@ pub mod tests {
     #[test]
     pub fn test_completed_shreds_signal_orphans() {
         // Initialize ledger
-        let ledger_path = get_tmp_ledger_path("test_completed_shreds_signal_orphans");
+        let ledger_path = get_tmp_ledger_path!();
         let (ledger, _, recvr) = Blocktree::open_with_signal(&ledger_path).unwrap();
         let ledger = Arc::new(ledger);
 
@@ -2665,7 +2665,7 @@ pub mod tests {
     #[test]
     pub fn test_completed_shreds_signal_many() {
         // Initialize ledger
-        let ledger_path = get_tmp_ledger_path("test_completed_shreds_signal_many");
+        let ledger_path = get_tmp_ledger_path!();
         let (ledger, _, recvr) = Blocktree::open_with_signal(&ledger_path).unwrap();
         let ledger = Arc::new(ledger);
 
@@ -2695,7 +2695,7 @@ pub mod tests {
 
     #[test]
     pub fn test_handle_chaining_basic() {
-        let blocktree_path = get_tmp_ledger_path("test_handle_chaining_basic");
+        let blocktree_path = get_tmp_ledger_path!();
         {
             let entries_per_slot = 5;
             let num_slots = 3;
@@ -2760,7 +2760,7 @@ pub mod tests {
 
     #[test]
     pub fn test_handle_chaining_missing_slots() {
-        let blocktree_path = get_tmp_ledger_path("test_handle_chaining_missing_slots");
+        let blocktree_path = get_tmp_ledger_path!();
         {
             let blocktree = Blocktree::open(&blocktree_path).unwrap();
             let num_slots = 30;
@@ -2842,7 +2842,7 @@ pub mod tests {
 
     #[test]
     pub fn test_forward_chaining_is_connected() {
-        let blocktree_path = get_tmp_ledger_path("test_forward_chaining_is_connected");
+        let blocktree_path = get_tmp_ledger_path!();
         {
             let blocktree = Blocktree::open(&blocktree_path).unwrap();
             let num_slots = 15;
@@ -2929,7 +2929,7 @@ pub mod tests {
     /*
         #[test]
         pub fn test_chaining_tree() {
-            let blocktree_path = get_tmp_ledger_path("test_chaining_tree");
+            let blocktree_path = get_tmp_ledger_path!();
             {
                 let blocktree = Blocktree::open(&blocktree_path).unwrap();
                 let num_tree_levels = 6;
@@ -3030,7 +3030,7 @@ pub mod tests {
     */
     #[test]
     pub fn test_get_slots_since() {
-        let blocktree_path = get_tmp_ledger_path("test_get_slots_since");
+        let blocktree_path = get_tmp_ledger_path!();
 
         {
             let blocktree = Blocktree::open(&blocktree_path).unwrap();
@@ -3067,7 +3067,7 @@ pub mod tests {
 
     #[test]
     fn test_orphans() {
-        let blocktree_path = get_tmp_ledger_path("test_orphans");
+        let blocktree_path = get_tmp_ledger_path!();
         {
             let blocktree = Blocktree::open(&blocktree_path).unwrap();
 
@@ -3127,7 +3127,7 @@ pub mod tests {
     }
 
     fn test_insert_data_shreds_slots(name: &str, should_bulk_write: bool) {
-        let blocktree_path = get_tmp_ledger_path(name);
+        let blocktree_path = get_ledger_path_from_name(name);
         {
             let blocktree = Blocktree::open(&blocktree_path).unwrap();
 
@@ -3871,8 +3871,7 @@ pub mod tests {
 
     #[test]
     fn test_get_slot_entries_with_shred_count_corruption() {
-        let blocktree_path =
-            get_tmp_ledger_path("test_get_slot_entries_with_shred_count_corruption");
+        let blocktree_path = get_tmp_ledger_path!();
         {
             let blocktree = Blocktree::open(&blocktree_path).unwrap();
             let num_ticks = 8;

ledger/src/blocktree_processor.rs

@@ -542,7 +542,6 @@ pub fn fill_blocktree_slot_with_ticks(
 #[cfg(test)]
 pub mod tests {
     use super::*;
-    use crate::blocktree::create_new_tmp_ledger;
     use crate::entry::{create_ticks, next_entry, next_entry_mut};
     use crate::genesis_utils::{
         create_genesis_config, create_genesis_config_with_leader, GenesisConfigInfo,

ledger/src/leader_schedule_cache.rs

@@ -235,11 +235,12 @@ impl LeaderScheduleCache {
 mod tests {
     use super::*;
     use crate::{
-        blocktree::{get_tmp_ledger_path, make_slot_entries},
+        blocktree::make_slot_entries,
         genesis_utils::{
             create_genesis_config, create_genesis_config_with_leader, GenesisConfigInfo,
             BOOTSTRAP_LEADER_LAMPORTS,
         },
+        get_tmp_ledger_path,
         staking_utils::tests::setup_vote_and_stake_accounts,
     };
     use solana_runtime::bank::Bank;

ledger/src/rooted_slot_iterator.rs

@@ -59,7 +59,7 @@ mod tests {
 
     #[test]
     fn test_rooted_slot_iterator() {
-        let blocktree_path = get_tmp_ledger_path("test_rooted_slot_iterator");
+        let blocktree_path = get_tmp_ledger_path!();
         let blocktree = Blocktree::open(&blocktree_path).unwrap();
         blocktree.set_roots(&[0]).unwrap();
         let ticks_per_slot = 5;

ledger/tests/blocktree.rs

@@ -1,8 +1,8 @@
-#[macro_use]
-extern crate solana_ledger;
-
-use solana_ledger::blocktree::{self, get_tmp_ledger_path, Blocktree};
 use solana_ledger::entry;
+use solana_ledger::{
+    blocktree::{self, Blocktree},
+    get_tmp_ledger_path,
+};
 use solana_sdk::hash::Hash;
 use std::sync::Arc;
 use std::thread::Builder;

local-cluster/src/lib.rs

@@ -2,8 +2,5 @@ pub mod cluster;
 pub mod cluster_tests;
 pub mod local_cluster;
 
-#[macro_use]
-extern crate solana_ledger;
-
 #[macro_use]
 extern crate solana_storage_program;

local-cluster/src/local_cluster.rs

@@ -10,7 +10,7 @@ use solana_core::{
     service::Service,
     validator::{Validator, ValidatorConfig},
 };
-use solana_ledger::blocktree::create_new_tmp_ledger;
+use solana_ledger::create_new_tmp_ledger;
 use solana_sdk::{
     client::SyncClient,
     clock::{DEFAULT_SLOTS_PER_EPOCH, DEFAULT_SLOTS_PER_SEGMENT, DEFAULT_TICKS_PER_SLOT},

local-cluster/tests/archiver.rs

@@ -1,6 +1,3 @@
-#[macro_use]
-extern crate solana_ledger;
-
 use log::*;
 use serial_test_derive::serial;
 use solana_client::thin_client::create_client;
@@ -12,7 +9,7 @@ use solana_core::{
     storage_stage::SLOTS_PER_TURN_TEST,
     validator::ValidatorConfig,
 };
-use solana_ledger::blocktree::{create_new_tmp_ledger, get_tmp_ledger_path, Blocktree};
+use solana_ledger::{blocktree::Blocktree, create_new_tmp_ledger, get_tmp_ledger_path};
 use solana_local_cluster::local_cluster::{ClusterConfig, LocalCluster};
 use solana_sdk::{
     commitment_config::CommitmentConfig,
@@ -64,7 +61,7 @@ fn run_archiver_startup_basic(num_nodes: usize, num_archivers: usize) {
     let cluster_info = Arc::new(RwLock::new(ClusterInfo::new_with_invalid_keypair(
         cluster_nodes[0].clone(),
     )));
-    let path = get_tmp_ledger_path("test");
+    let path = get_tmp_ledger_path!();
     let blocktree = Arc::new(Blocktree::open(&path).unwrap());
     Archiver::download_from_archiver(&cluster_info, &archiver_info, &blocktree, slots_per_segment)
         .unwrap();