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

Replace get_tmp_ledger_path!() with self cleaning version (#33702) 

This macro is used a lot for tests to create a ledger path in order to
open a Blockstore. Files will be left on disk unless the test remembers
to call Blockstore::destroy() on the directory. So, instead of requiring
this, use the get_tmp_ledger_path_auto_delete!() macro that creates a
TempDir (which automatically deletes itself when it goes out of scope).
This commit is contained in:
steviez 2023-10-21 11:38:31 +02:00 committed by GitHub
parent 5a963529a8
commit 56ccffdaa5
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
18 changed files with 2081 additions and 2211 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
banking-bench/src/main.rs
View File

@ -14,7 +14,7 @@ use {
solana_ledger::{ solana_ledger::{
blockstore::Blockstore, blockstore::Blockstore,
genesis_utils::{create_genesis_config, GenesisConfigInfo}, genesis_utils::{create_genesis_config, GenesisConfigInfo},
get_tmp_ledger_path, get_tmp_ledger_path_auto_delete,
leader_schedule_cache::LeaderScheduleCache, leader_schedule_cache::LeaderScheduleCache,
}, },
solana_measure::measure::Measure, solana_measure::measure::Measure,
@ -410,10 +410,9 @@ fn main() {
} }
} }
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{
let blockstore = Arc::new( let blockstore = Arc::new(
Blockstore::open(&ledger_path).expect("Expected to be able to open database ledger"), Blockstore::open(ledger_path.path()).expect("Expected to be able to open database ledger"),
); );
let leader_schedule_cache = Arc::new(LeaderScheduleCache::new_from_bank(&bank)); let leader_schedule_cache = Arc::new(LeaderScheduleCache::new_from_bank(&bank));
let (exit, poh_recorder, poh_service, signal_receiver) = create_test_recorder( let (exit, poh_recorder, poh_service, signal_receiver) = create_test_recorder(
@ -431,8 +430,7 @@ fn main() {
.unwrap(); .unwrap();
let (non_vote_sender, non_vote_receiver) = banking_tracer.create_channel_non_vote(); let (non_vote_sender, non_vote_receiver) = banking_tracer.create_channel_non_vote();
let (tpu_vote_sender, tpu_vote_receiver) = banking_tracer.create_channel_tpu_vote(); let (tpu_vote_sender, tpu_vote_receiver) = banking_tracer.create_channel_tpu_vote();
let (gossip_vote_sender, gossip_vote_receiver) = let (gossip_vote_sender, gossip_vote_receiver) = banking_tracer.create_channel_gossip_vote();
banking_tracer.create_channel_gossip_vote();
let cluster_info = { let cluster_info = {
let keypair = Arc::new(Keypair::new()); let keypair = Arc::new(Keypair::new());
let node = Node::new_localhost_with_pubkey(&keypair.pubkey()); let node = Node::new_localhost_with_pubkey(&keypair.pubkey());
@ -620,6 +618,4 @@ fn main() {
if let Some(tracer_thread) = tracer_thread { if let Some(tracer_thread) = tracer_thread {
tracer_thread.join().unwrap().unwrap(); tracer_thread.join().unwrap().unwrap();
} }
}
let _unused = Blockstore::destroy(&ledger_path);
} }

6
client-test/tests/client.rs
View File

@ -2,7 +2,7 @@ use {
futures_util::StreamExt, futures_util::StreamExt,
rand::Rng, rand::Rng,
serde_json::{json, Value}, serde_json::{json, Value},
solana_ledger::{blockstore::Blockstore, get_tmp_ledger_path}, solana_ledger::{blockstore::Blockstore, get_tmp_ledger_path_auto_delete},
solana_pubsub_client::{nonblocking, pubsub_client::PubsubClient}, solana_pubsub_client::{nonblocking, pubsub_client::PubsubClient},
solana_rpc::{ solana_rpc::{
optimistically_confirmed_bank_tracker::OptimisticallyConfirmedBank, optimistically_confirmed_bank_tracker::OptimisticallyConfirmedBank,
@ -233,8 +233,8 @@ fn test_block_subscription() {
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank))); let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
// setup Blockstore // setup Blockstore
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = Blockstore::open(&ledger_path).unwrap(); let blockstore = Blockstore::open(ledger_path.path()).unwrap();
let blockstore = Arc::new(blockstore); let blockstore = Arc::new(blockstore);
// populate ledger with test txs // populate ledger with test txs

16
core/benches/banking_stage.rs
View File

@ -29,7 +29,7 @@ use {
blockstore::Blockstore, blockstore::Blockstore,
blockstore_processor::process_entries_for_tests, blockstore_processor::process_entries_for_tests,
genesis_utils::{create_genesis_config, GenesisConfigInfo}, genesis_utils::{create_genesis_config, GenesisConfigInfo},
get_tmp_ledger_path, get_tmp_ledger_path_auto_delete,
}, },
solana_perf::{ solana_perf::{
packet::{to_packet_batches, Packet}, packet::{to_packet_batches, Packet},
@ -83,10 +83,9 @@ fn check_txs(receiver: &Arc<Receiver<WorkingBankEntry>>, ref_tx_count: usize) {
fn bench_consume_buffered(bencher: &mut Bencher) { fn bench_consume_buffered(bencher: &mut Bencher) {
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(100_000); let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(100_000);
let bank = Arc::new(Bank::new_for_benches(&genesis_config)); let bank = Arc::new(Bank::new_for_benches(&genesis_config));
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{
let blockstore = Arc::new( let blockstore = Arc::new(
Blockstore::open(&ledger_path).expect("Expected to be able to open database ledger"), Blockstore::open(ledger_path.path()).expect("Expected to be able to open database ledger"),
); );
let (exit, poh_recorder, poh_service, _signal_receiver) = let (exit, poh_recorder, poh_service, _signal_receiver) =
create_test_recorder(bank, blockstore, None, None); create_test_recorder(bank, blockstore, None, None);
@ -124,8 +123,6 @@ fn bench_consume_buffered(bencher: &mut Bencher) {
exit.store(true, Ordering::Relaxed); exit.store(true, Ordering::Relaxed);
poh_service.join().unwrap(); poh_service.join().unwrap();
}
let _unused = Blockstore::destroy(&ledger_path);
} }
fn make_accounts_txs(txes: usize, mint_keypair: &Keypair, hash: Hash) -> Vec<Transaction> { fn make_accounts_txs(txes: usize, mint_keypair: &Keypair, hash: Hash) -> Vec<Transaction> {
@ -279,10 +276,9 @@ fn bench_banking(bencher: &mut Bencher, tx_type: TransactionType) {
packet_batches packet_batches
}); });
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{
let blockstore = Arc::new( let blockstore = Arc::new(
Blockstore::open(&ledger_path).expect("Expected to be able to open database ledger"), Blockstore::open(ledger_path.path()).expect("Expected to be able to open database ledger"),
); );
let (exit, poh_recorder, poh_service, signal_receiver) = let (exit, poh_recorder, poh_service, signal_receiver) =
create_test_recorder(bank.clone(), blockstore, None, None); create_test_recorder(bank.clone(), blockstore, None, None);
@ -366,8 +362,6 @@ fn bench_banking(bencher: &mut Bencher, tx_type: TransactionType) {
}); });
exit.store(true, Ordering::Relaxed); exit.store(true, Ordering::Relaxed);
poh_service.join().unwrap(); poh_service.join().unwrap();
}
let _unused = Blockstore::destroy(&ledger_path);
} }
#[bench] #[bench]

23
core/src/consensus.rs
View File

@ -1518,7 +1518,7 @@ pub mod test {
vote_simulator::VoteSimulator, vote_simulator::VoteSimulator,
}, },
itertools::Itertools, itertools::Itertools,
solana_ledger::{blockstore::make_slot_entries, get_tmp_ledger_path}, solana_ledger::{blockstore::make_slot_entries, get_tmp_ledger_path_auto_delete},
solana_runtime::bank::Bank, solana_runtime::bank::Bank,
solana_sdk::{ solana_sdk::{
account::{Account, AccountSharedData, ReadableAccount, WritableAccount}, account::{Account, AccountSharedData, ReadableAccount, WritableAccount},
@ -2928,9 +2928,8 @@ pub mod test {
#[test] #[test]
fn test_reconcile_blockstore_roots_with_tower_normal() { fn test_reconcile_blockstore_roots_with_tower_normal() {
solana_logger::setup(); solana_logger::setup();
let blockstore_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{ let blockstore = Blockstore::open(ledger_path.path()).unwrap();
let blockstore = Blockstore::open(&blockstore_path).unwrap();
let (shreds, _) = make_slot_entries(1, 0, 42, /*merkle_variant:*/ true); let (shreds, _) = make_slot_entries(1, 0, 42, /*merkle_variant:*/ true);
blockstore.insert_shreds(shreds, None, false).unwrap(); blockstore.insert_shreds(shreds, None, false).unwrap();
@ -2957,8 +2956,6 @@ pub mod test {
assert!(!blockstore.is_root(3)); assert!(!blockstore.is_root(3));
assert!(blockstore.is_root(4)); assert!(blockstore.is_root(4));
} }
Blockstore::destroy(&blockstore_path).expect("Expected successful database destruction");
}
#[test] #[test]
#[should_panic(expected = "last_blockstore_root(3) is skipped while \ #[should_panic(expected = "last_blockstore_root(3) is skipped while \
@ -2966,9 +2963,8 @@ pub mod test {
external root (Tower(4))!?")] external root (Tower(4))!?")]
fn test_reconcile_blockstore_roots_with_tower_panic_no_common_root() { fn test_reconcile_blockstore_roots_with_tower_panic_no_common_root() {
solana_logger::setup(); solana_logger::setup();
let blockstore_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{ let blockstore = Blockstore::open(ledger_path.path()).unwrap();
let blockstore = Blockstore::open(&blockstore_path).unwrap();
let (shreds, _) = make_slot_entries(1, 0, 42, /*merkle_variant:*/ true); let (shreds, _) = make_slot_entries(1, 0, 42, /*merkle_variant:*/ true);
blockstore.insert_shreds(shreds, None, false).unwrap(); blockstore.insert_shreds(shreds, None, false).unwrap();
@ -2991,15 +2987,12 @@ pub mod test {
) )
.unwrap(); .unwrap();
} }
Blockstore::destroy(&blockstore_path).expect("Expected successful database destruction");
}
#[test] #[test]
fn test_reconcile_blockstore_roots_with_tower_nop_no_parent() { fn test_reconcile_blockstore_roots_with_tower_nop_no_parent() {
solana_logger::setup(); solana_logger::setup();
let blockstore_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{ let blockstore = Blockstore::open(ledger_path.path()).unwrap();
let blockstore = Blockstore::open(&blockstore_path).unwrap();
let (shreds, _) = make_slot_entries(1, 0, 42, /*merkle_variant:*/ true); let (shreds, _) = make_slot_entries(1, 0, 42, /*merkle_variant:*/ true);
blockstore.insert_shreds(shreds, None, false).unwrap(); blockstore.insert_shreds(shreds, None, false).unwrap();
@ -3020,8 +3013,6 @@ pub mod test {
.unwrap(); .unwrap();
assert_eq!(blockstore.last_root(), 0); assert_eq!(blockstore.last_root(), 0);
} }
Blockstore::destroy(&blockstore_path).expect("Expected successful database destruction");
}
#[test] #[test]
fn test_adjust_lockouts_after_replay_future_slots() { fn test_adjust_lockouts_after_replay_future_slots() {

9
core/src/repair/ancestor_hashes_service.rs
View File

@ -918,7 +918,10 @@ mod test {
cluster_info::{ClusterInfo, Node}, cluster_info::{ClusterInfo, Node},
contact_info::{ContactInfo, Protocol}, contact_info::{ContactInfo, Protocol},
}, },
solana_ledger::{blockstore::make_many_slot_entries, get_tmp_ledger_path, shred::Nonce}, solana_ledger::{
blockstore::make_many_slot_entries, get_tmp_ledger_path,
get_tmp_ledger_path_auto_delete, shred::Nonce,
},
solana_runtime::{accounts_background_service::AbsRequestSender, bank_forks::BankForks}, solana_runtime::{accounts_background_service::AbsRequestSender, bank_forks::BankForks},
solana_sdk::{ solana_sdk::{
hash::Hash, hash::Hash,
@ -1938,8 +1941,8 @@ mod test {
.. ..
} = ManageAncestorHashesState::new(bank_forks); } = ManageAncestorHashesState::new(bank_forks);
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = Blockstore::open(&ledger_path).unwrap(); let blockstore = Blockstore::open(ledger_path.path()).unwrap();
// Create invalid packet with fewer bytes than the size of the nonce // Create invalid packet with fewer bytes than the size of the nonce
let mut packet = Packet::default(); let mut packet = Packet::default();

53
core/src/repair/repair_service.rs
View File

@ -864,7 +864,7 @@ mod test {
make_chaining_slot_entries, make_many_slot_entries, make_slot_entries, Blockstore, make_chaining_slot_entries, make_many_slot_entries, make_slot_entries, Blockstore,
}, },
genesis_utils::{create_genesis_config, GenesisConfigInfo}, genesis_utils::{create_genesis_config, GenesisConfigInfo},
get_tmp_ledger_path, get_tmp_ledger_path_auto_delete,
shred::max_ticks_per_n_shreds, shred::max_ticks_per_n_shreds,
}, },
solana_runtime::bank::Bank, solana_runtime::bank::Bank,
@ -884,9 +884,8 @@ mod test {
#[test] #[test]
pub fn test_repair_orphan() { pub fn test_repair_orphan() {
let blockstore_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{ let blockstore = Blockstore::open(ledger_path.path()).unwrap();
let blockstore = Blockstore::open(&blockstore_path).unwrap();
// Create some orphan slots // Create some orphan slots
let (mut shreds, _) = make_slot_entries(1, 0, 1, /*merkle_variant:*/ true); let (mut shreds, _) = make_slot_entries(1, 0, 1, /*merkle_variant:*/ true);
@ -913,14 +912,10 @@ mod test {
); );
} }
Blockstore::destroy(&blockstore_path).expect("Expected successful database destruction");
}
#[test] #[test]
pub fn test_repair_empty_slot() { pub fn test_repair_empty_slot() {
let blockstore_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{ let blockstore = Blockstore::open(ledger_path.path()).unwrap();
let blockstore = Blockstore::open(&blockstore_path).unwrap();
let (shreds, _) = make_slot_entries(2, 0, 1, /*merkle_variant:*/ true); let (shreds, _) = make_slot_entries(2, 0, 1, /*merkle_variant:*/ true);
@ -945,14 +940,11 @@ mod test {
vec![ShredRepairType::HighestShred(0, 0)] vec![ShredRepairType::HighestShred(0, 0)]
); );
} }
Blockstore::destroy(&blockstore_path).expect("Expected successful database destruction");
}
#[test] #[test]
pub fn test_generate_repairs() { pub fn test_generate_repairs() {
let blockstore_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{ let blockstore = Blockstore::open(ledger_path.path()).unwrap();
let blockstore = Blockstore::open(&blockstore_path).unwrap();
let nth = 3; let nth = 3;
let num_slots = 2; let num_slots = 2;
@ -1020,14 +1012,11 @@ mod test {
expected[0..expected.len() - 2] expected[0..expected.len() - 2]
); );
} }
Blockstore::destroy(&blockstore_path).expect("Expected successful database destruction");
}
#[test] #[test]
pub fn test_generate_highest_repair() { pub fn test_generate_highest_repair() {
let blockstore_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{ let blockstore = Blockstore::open(ledger_path.path()).unwrap();
let blockstore = Blockstore::open(&blockstore_path).unwrap();
let num_entries_per_slot = 100; let num_entries_per_slot = 100;
@ -1066,14 +1055,11 @@ mod test {
expected expected
); );
} }
Blockstore::destroy(&blockstore_path).expect("Expected successful database destruction");
}
#[test] #[test]
pub fn test_repair_range() { pub fn test_repair_range() {
let blockstore_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{ let blockstore = Blockstore::open(ledger_path.path()).unwrap();
let blockstore = Blockstore::open(&blockstore_path).unwrap();
let slots: Vec<u64> = vec![1, 3, 5, 7, 8]; let slots: Vec<u64> = vec![1, 3, 5, 7, 8];
let num_entries_per_slot = max_ticks_per_n_shreds(1, None) + 1; let num_entries_per_slot = max_ticks_per_n_shreds(1, None) + 1;
@ -1115,14 +1101,11 @@ mod test {
} }
} }
} }
Blockstore::destroy(&blockstore_path).expect("Expected successful database destruction");
}
#[test] #[test]
pub fn test_repair_range_highest() { pub fn test_repair_range_highest() {
let blockstore_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{ let blockstore = Blockstore::open(ledger_path.path()).unwrap();
let blockstore = Blockstore::open(&blockstore_path).unwrap();
let num_entries_per_slot = 10; let num_entries_per_slot = 10;
@ -1160,13 +1143,11 @@ mod test {
expected expected
); );
} }
Blockstore::destroy(&blockstore_path).expect("Expected successful database destruction");
}
#[test] #[test]
pub fn test_generate_duplicate_repairs_for_slot() { pub fn test_generate_duplicate_repairs_for_slot() {
let blockstore_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = Blockstore::open(&blockstore_path).unwrap(); let blockstore = Blockstore::open(ledger_path.path()).unwrap();
let dead_slot = 9; let dead_slot = 9;
// SlotMeta doesn't exist, should make no repairs // SlotMeta doesn't exist, should make no repairs
@ -1203,8 +1184,8 @@ mod test {
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(10_000); let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(10_000);
let bank = Bank::new_for_tests(&genesis_config); let bank = Bank::new_for_tests(&genesis_config);
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank))); let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
let blockstore_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = Blockstore::open(&blockstore_path).unwrap(); let blockstore = Blockstore::open(ledger_path.path()).unwrap();
let cluster_slots = ClusterSlots::default(); let cluster_slots = ClusterSlots::default();
let cluster_info = Arc::new(new_test_cluster_info()); let cluster_info = Arc::new(new_test_cluster_info());
let identity_keypair = cluster_info.keypair().clone(); let identity_keypair = cluster_info.keypair().clone();

43
core/src/repair/serve_repair.rs
View File

@ -1423,7 +1423,7 @@ mod tests {
blockstore::make_many_slot_entries, blockstore::make_many_slot_entries,
blockstore_processor::fill_blockstore_slot_with_ticks, blockstore_processor::fill_blockstore_slot_with_ticks,
genesis_utils::{create_genesis_config, GenesisConfigInfo}, genesis_utils::{create_genesis_config, GenesisConfigInfo},
get_tmp_ledger_path, get_tmp_ledger_path_auto_delete,
shred::{max_ticks_per_n_shreds, Shred, ShredFlags}, shred::{max_ticks_per_n_shreds, Shred, ShredFlags},
}, },
solana_perf::packet::{deserialize_from_with_limit, Packet}, solana_perf::packet::{deserialize_from_with_limit, Packet},
@ -1853,9 +1853,8 @@ mod tests {
fn run_highest_window_request(slot: Slot, num_slots: u64, nonce: Nonce) { fn run_highest_window_request(slot: Slot, num_slots: u64, nonce: Nonce) {
let recycler = PacketBatchRecycler::default(); let recycler = PacketBatchRecycler::default();
solana_logger::setup(); solana_logger::setup();
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{ let blockstore = Arc::new(Blockstore::open(ledger_path.path()).unwrap());
let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
let rv = ServeRepair::run_highest_window_request( let rv = ServeRepair::run_highest_window_request(
&recycler, &recycler,
&socketaddr_any!(), &socketaddr_any!(),
@ -1910,9 +1909,6 @@ mod tests {
assert!(rv.is_none()); assert!(rv.is_none());
} }
Blockstore::destroy(&ledger_path).expect("Expected successful database destruction");
}
#[test] #[test]
fn test_run_window_request() { fn test_run_window_request() {
run_window_request(2, 9); run_window_request(2, 9);
@ -1922,9 +1918,8 @@ mod tests {
fn run_window_request(slot: Slot, nonce: Nonce) { fn run_window_request(slot: Slot, nonce: Nonce) {
let recycler = PacketBatchRecycler::default(); let recycler = PacketBatchRecycler::default();
solana_logger::setup(); solana_logger::setup();
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{ let blockstore = Arc::new(Blockstore::open(ledger_path.path()).unwrap());
let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
let rv = ServeRepair::run_window_request( let rv = ServeRepair::run_window_request(
&recycler, &recycler,
&socketaddr_any!(), &socketaddr_any!(),
@ -1963,9 +1958,6 @@ mod tests {
assert_eq!(rv[0].slot(), slot); assert_eq!(rv[0].slot(), slot);
} }
Blockstore::destroy(&ledger_path).expect("Expected successful database destruction");
}
fn new_test_cluster_info() -> ClusterInfo { fn new_test_cluster_info() -> ClusterInfo {
let keypair = Arc::new(Keypair::new()); let keypair = Arc::new(Keypair::new());
let contact_info = ContactInfo::new_localhost(&keypair.pubkey(), timestamp()); let contact_info = ContactInfo::new_localhost(&keypair.pubkey(), timestamp());
@ -2095,9 +2087,8 @@ mod tests {
fn run_orphan(slot: Slot, num_slots: u64, nonce: Nonce) { fn run_orphan(slot: Slot, num_slots: u64, nonce: Nonce) {
solana_logger::setup(); solana_logger::setup();
let recycler = PacketBatchRecycler::default(); let recycler = PacketBatchRecycler::default();
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{ let blockstore = Arc::new(Blockstore::open(ledger_path.path()).unwrap());
let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
let rv = let rv =
ServeRepair::run_orphan(&recycler, &socketaddr_any!(), &blockstore, slot, 0, nonce); ServeRepair::run_orphan(&recycler, &socketaddr_any!(), &blockstore, slot, 0, nonce);
assert!(rv.is_none()); assert!(rv.is_none());
@ -2155,16 +2146,12 @@ mod tests {
assert_eq!(rv, expected); assert_eq!(rv, expected);
} }
Blockstore::destroy(&ledger_path).expect("Expected successful database destruction");
}
#[test] #[test]
fn run_orphan_corrupted_shred_size() { fn run_orphan_corrupted_shred_size() {
solana_logger::setup(); solana_logger::setup();
let recycler = PacketBatchRecycler::default(); let recycler = PacketBatchRecycler::default();
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{ let blockstore = Arc::new(Blockstore::open(ledger_path.path()).unwrap());
let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap());
// Create slots [1, 2] with 1 shred apiece // Create slots [1, 2] with 1 shred apiece
let (mut shreds, _) = make_many_slot_entries(1, 2, 1); let (mut shreds, _) = make_many_slot_entries(1, 2, 1);
@ -2210,9 +2197,6 @@ mod tests {
assert_eq!(rv, expected); assert_eq!(rv, expected);
} }
Blockstore::destroy(&ledger_path).expect("Expected successful database destruction");
}
#[test] #[test]
fn test_run_ancestor_hashes() { fn test_run_ancestor_hashes() {
fn deserialize_ancestor_hashes_response(packet: &Packet) -> AncestorHashesResponse { fn deserialize_ancestor_hashes_response(packet: &Packet) -> AncestorHashesResponse {
@ -2223,13 +2207,13 @@ mod tests {
solana_logger::setup(); solana_logger::setup();
let recycler = PacketBatchRecycler::default(); let recycler = PacketBatchRecycler::default();
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{
let slot = 0; let slot = 0;
let num_slots = MAX_ANCESTOR_RESPONSES as u64; let num_slots = MAX_ANCESTOR_RESPONSES as u64;
let nonce = 10; let nonce = 10;
let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap()); let blockstore = Arc::new(Blockstore::open(ledger_path.path()).unwrap());
// Create slots [slot, slot + num_slots) with 5 shreds apiece // Create slots [slot, slot + num_slots) with 5 shreds apiece
let (shreds, _) = make_many_slot_entries(slot, num_slots, 5); let (shreds, _) = make_many_slot_entries(slot, num_slots, 5);
@ -2311,9 +2295,6 @@ mod tests {
} }
} }
Blockstore::destroy(&ledger_path).expect("Expected successful database destruction");
}
#[test] #[test]
fn test_repair_with_repair_validators() { fn test_repair_with_repair_validators() {
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(10_000); let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(10_000);

12
core/src/replay_stage.rs
View File

@ -4078,7 +4078,7 @@ pub(crate) mod tests {
blockstore::{entries_to_test_shreds, make_slot_entries, BlockstoreError}, blockstore::{entries_to_test_shreds, make_slot_entries, BlockstoreError},
create_new_tmp_ledger, create_new_tmp_ledger,
genesis_utils::{create_genesis_config, create_genesis_config_with_leader}, genesis_utils::{create_genesis_config, create_genesis_config_with_leader},
get_tmp_ledger_path, get_tmp_ledger_path, get_tmp_ledger_path_auto_delete,
shred::{Shred, ShredFlags, LEGACY_SHRED_DATA_CAPACITY}, shred::{Shred, ShredFlags, LEGACY_SHRED_DATA_CAPACITY},
}, },
solana_rpc::{ solana_rpc::{
@ -6405,9 +6405,10 @@ pub(crate) mod tests {
let mut vote_simulator = VoteSimulator::new(1); let mut vote_simulator = VoteSimulator::new(1);
vote_simulator.fill_bank_forks(forks, &HashMap::<Pubkey, Vec<u64>>::new(), true); vote_simulator.fill_bank_forks(forks, &HashMap::<Pubkey, Vec<u64>>::new(), true);
let (bank_forks, mut progress) = (vote_simulator.bank_forks, vote_simulator.progress); let (bank_forks, mut progress) = (vote_simulator.bank_forks, vote_simulator.progress);
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = Arc::new( let blockstore = Arc::new(
Blockstore::open(&ledger_path).expect("Expected to be able to open database ledger"), Blockstore::open(ledger_path.path())
.expect("Expected to be able to open database ledger"),
); );
let mut tower = Tower::new_for_tests(8, 2.0 / 3.0); let mut tower = Tower::new_for_tests(8, 2.0 / 3.0);
@ -6552,9 +6553,10 @@ pub(crate) mod tests {
vote_simulator.fill_bank_forks(forks, &validator_votes, true); vote_simulator.fill_bank_forks(forks, &validator_votes, true);
let (bank_forks, mut progress) = (vote_simulator.bank_forks, vote_simulator.progress); let (bank_forks, mut progress) = (vote_simulator.bank_forks, vote_simulator.progress);
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = Arc::new( let blockstore = Arc::new(
Blockstore::open(&ledger_path).expect("Expected to be able to open database ledger"), Blockstore::open(ledger_path.path())
.expect("Expected to be able to open database ledger"),
); );
let mut tower = Tower::new_for_tests(8, 0.67); let mut tower = Tower::new_for_tests(8, 0.67);

34
ledger/benches/blockstore.rs
View File

@ -8,7 +8,7 @@ use {
solana_entry::entry::{create_ticks, Entry}, solana_entry::entry::{create_ticks, Entry},
solana_ledger::{ solana_ledger::{
blockstore::{entries_to_test_shreds, Blockstore}, blockstore::{entries_to_test_shreds, Blockstore},
get_tmp_ledger_path, get_tmp_ledger_path_auto_delete,
}, },
solana_sdk::{clock::Slot, hash::Hash}, solana_sdk::{clock::Slot, hash::Hash},
std::path::Path, std::path::Path,
@ -23,8 +23,6 @@ fn bench_write_shreds(bench: &mut Bencher, entries: Vec<Entry>, ledger_path: &Pa
let shreds = entries_to_test_shreds(&entries, 0, 0, true, 0, /*merkle_variant:*/ true); let shreds = entries_to_test_shreds(&entries, 0, 0, true, 0, /*merkle_variant:*/ true);
blockstore.insert_shreds(shreds, None, false).unwrap(); blockstore.insert_shreds(shreds, None, false).unwrap();
}); });
Blockstore::destroy(ledger_path).expect("Expected successful database destruction");
} }
// Insert some shreds into the ledger in preparation for read benchmarks // Insert some shreds into the ledger in preparation for read benchmarks
@ -59,28 +57,28 @@ fn setup_read_bench(
#[bench] #[bench]
#[ignore] #[ignore]
fn bench_write_small(bench: &mut Bencher) { fn bench_write_small(bench: &mut Bencher) {
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
let num_entries = 32 * 1024; let num_entries = 32 * 1024;
let entries = create_ticks(num_entries, 0, Hash::default()); let entries = create_ticks(num_entries, 0, Hash::default());
bench_write_shreds(bench, entries, &ledger_path); bench_write_shreds(bench, entries, ledger_path.path());
} }
// Write big shreds to the ledger // Write big shreds to the ledger
#[bench] #[bench]
#[ignore] #[ignore]
fn bench_write_big(bench: &mut Bencher) { fn bench_write_big(bench: &mut Bencher) {
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
let num_entries = 32 * 1024; let num_entries = 32 * 1024;
let entries = create_ticks(num_entries, 0, Hash::default()); let entries = create_ticks(num_entries, 0, Hash::default());
bench_write_shreds(bench, entries, &ledger_path); bench_write_shreds(bench, entries, ledger_path.path());
} }
#[bench] #[bench]
#[ignore] #[ignore]
fn bench_read_sequential(bench: &mut Bencher) { fn bench_read_sequential(bench: &mut Bencher) {
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = let blockstore =
Blockstore::open(&ledger_path).expect("Expected to be able to open database ledger"); Blockstore::open(ledger_path.path()).expect("Expected to be able to open database ledger");
// Insert some big and small shreds into the ledger // Insert some big and small shreds into the ledger
let num_small_shreds = 32 * 1024; let num_small_shreds = 32 * 1024;
@ -98,16 +96,14 @@ fn bench_read_sequential(bench: &mut Bencher) {
let _ = blockstore.get_data_shred(slot, i % total_shreds); let _ = blockstore.get_data_shred(slot, i % total_shreds);
} }
}); });
Blockstore::destroy(&ledger_path).expect("Expected successful database destruction");
} }
#[bench] #[bench]
#[ignore] #[ignore]
fn bench_read_random(bench: &mut Bencher) { fn bench_read_random(bench: &mut Bencher) {
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = let blockstore =
Blockstore::open(&ledger_path).expect("Expected to be able to open database ledger"); Blockstore::open(ledger_path.path()).expect("Expected to be able to open database ledger");
// Insert some big and small shreds into the ledger // Insert some big and small shreds into the ledger
let num_small_shreds = 32 * 1024; let num_small_shreds = 32 * 1024;
@ -129,36 +125,32 @@ fn bench_read_random(bench: &mut Bencher) {
let _ = blockstore.get_data_shred(slot, *i as u64); let _ = blockstore.get_data_shred(slot, *i as u64);
} }
}); });
Blockstore::destroy(&ledger_path).expect("Expected successful database destruction");
} }
#[bench] #[bench]
#[ignore] #[ignore]
fn bench_insert_data_shred_small(bench: &mut Bencher) { fn bench_insert_data_shred_small(bench: &mut Bencher) {
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = let blockstore =
Blockstore::open(&ledger_path).expect("Expected to be able to open database ledger"); Blockstore::open(ledger_path.path()).expect("Expected to be able to open database ledger");
let num_entries = 32 * 1024; let num_entries = 32 * 1024;
let entries = create_ticks(num_entries, 0, Hash::default()); let entries = create_ticks(num_entries, 0, Hash::default());
bench.iter(move || { bench.iter(move || {
let shreds = entries_to_test_shreds(&entries, 0, 0, true, 0, /*merkle_variant:*/ true); let shreds = entries_to_test_shreds(&entries, 0, 0, true, 0, /*merkle_variant:*/ true);
blockstore.insert_shreds(shreds, None, false).unwrap(); blockstore.insert_shreds(shreds, None, false).unwrap();
}); });
Blockstore::destroy(&ledger_path).expect("Expected successful database destruction");
} }
#[bench] #[bench]
#[ignore] #[ignore]
fn bench_insert_data_shred_big(bench: &mut Bencher) { fn bench_insert_data_shred_big(bench: &mut Bencher) {
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = let blockstore =
Blockstore::open(&ledger_path).expect("Expected to be able to open database ledger"); Blockstore::open(ledger_path.path()).expect("Expected to be able to open database ledger");
let num_entries = 32 * 1024; let num_entries = 32 * 1024;
let entries = create_ticks(num_entries, 0, Hash::default()); let entries = create_ticks(num_entries, 0, Hash::default());
bench.iter(move || { bench.iter(move || {
let shreds = entries_to_test_shreds(&entries, 0, 0, true, 0, /*merkle_variant:*/ true); let shreds = entries_to_test_shreds(&entries, 0, 0, true, 0, /*merkle_variant:*/ true);
blockstore.insert_shreds(shreds, None, false).unwrap(); blockstore.insert_shreds(shreds, None, false).unwrap();
}); });
Blockstore::destroy(&ledger_path).expect("Expected successful database destruction");
} }

18
ledger/benches/protobuf.rs
View File

@ -7,7 +7,7 @@ use {
solana_ledger::{ solana_ledger::{
blockstore::Blockstore, blockstore::Blockstore,
blockstore_db::{columns as cf, LedgerColumn}, blockstore_db::{columns as cf, LedgerColumn},
get_tmp_ledger_path, get_tmp_ledger_path_auto_delete,
}, },
solana_runtime::bank::RewardType, solana_runtime::bank::RewardType,
solana_sdk::{clock::Slot, pubkey}, solana_sdk::{clock::Slot, pubkey},
@ -86,22 +86,22 @@ fn bench_read_rewards<F, G>(
#[bench] #[bench]
fn bench_serialize_write_bincode(bencher: &mut Bencher) { fn bench_serialize_write_bincode(bencher: &mut Bencher) {
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
bench_write_rewards(bencher, &ledger_path, write_bincode_rewards); bench_write_rewards(bencher, ledger_path.path(), write_bincode_rewards);
} }
#[bench] #[bench]
fn bench_serialize_write_protobuf(bencher: &mut Bencher) { fn bench_serialize_write_protobuf(bencher: &mut Bencher) {
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
bench_write_rewards(bencher, &ledger_path, write_protobuf_rewards); bench_write_rewards(bencher, ledger_path.path(), write_protobuf_rewards);
} }
#[bench] #[bench]
fn bench_read_bincode(bencher: &mut Bencher) { fn bench_read_bincode(bencher: &mut Bencher) {
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
bench_read_rewards( bench_read_rewards(
bencher, bencher,
&ledger_path, ledger_path.path(),
write_bincode_rewards, write_bincode_rewards,
read_bincode_rewards, read_bincode_rewards,
); );
@ -109,10 +109,10 @@ fn bench_read_bincode(bencher: &mut Bencher) {
#[bench] #[bench]
fn bench_read_protobuf(bencher: &mut Bencher) { fn bench_read_protobuf(bencher: &mut Bencher) {
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
bench_read_rewards( bench_read_rewards(
bencher, bencher,
&ledger_path, ledger_path.path(),
write_protobuf_rewards, write_protobuf_rewards,
read_protobuf_rewards, read_protobuf_rewards,
); );

158
poh/src/poh_recorder.rs
View File

@ -1112,7 +1112,9 @@ mod tests {
super::*, super::*,
bincode::serialize, bincode::serialize,
crossbeam_channel::bounded, crossbeam_channel::bounded,
solana_ledger::{blockstore::Blockstore, blockstore_meta::SlotMeta, get_tmp_ledger_path}, solana_ledger::{
blockstore::Blockstore, blockstore_meta::SlotMeta, get_tmp_ledger_path_auto_delete,
},
solana_perf::test_tx::test_tx, solana_perf::test_tx::test_tx,
solana_sdk::{clock::DEFAULT_TICKS_PER_SLOT, hash::hash}, solana_sdk::{clock::DEFAULT_TICKS_PER_SLOT, hash::hash},
}; };
@ -1120,9 +1122,8 @@ mod tests {
#[test] #[test]
fn test_poh_recorder_no_zero_tick() { fn test_poh_recorder_no_zero_tick() {
let prev_hash = Hash::default(); let prev_hash = Hash::default();
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{ let blockstore = Blockstore::open(ledger_path.path())
let blockstore = Blockstore::open(&ledger_path)
.expect("Expected to be able to open database ledger"); .expect("Expected to be able to open database ledger");
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2); let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2);
@ -1144,15 +1145,12 @@ mod tests {
assert_eq!(poh_recorder.tick_cache[0].1, 1); assert_eq!(poh_recorder.tick_cache[0].1, 1);
assert_eq!(poh_recorder.tick_height, 1); assert_eq!(poh_recorder.tick_height, 1);
} }
Blockstore::destroy(&ledger_path).unwrap();
}
#[test] #[test]
fn test_poh_recorder_tick_height_is_last_tick() { fn test_poh_recorder_tick_height_is_last_tick() {
let prev_hash = Hash::default(); let prev_hash = Hash::default();
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{ let blockstore = Blockstore::open(ledger_path.path())
let blockstore = Blockstore::open(&ledger_path)
.expect("Expected to be able to open database ledger"); .expect("Expected to be able to open database ledger");
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2); let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2);
@ -1175,14 +1173,11 @@ mod tests {
assert_eq!(poh_recorder.tick_cache[1].1, 2); assert_eq!(poh_recorder.tick_cache[1].1, 2);
assert_eq!(poh_recorder.tick_height, 2); assert_eq!(poh_recorder.tick_height, 2);
} }
Blockstore::destroy(&ledger_path).unwrap();
}
#[test] #[test]
fn test_poh_recorder_reset_clears_cache() { fn test_poh_recorder_reset_clears_cache() {
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{ let blockstore = Blockstore::open(ledger_path.path())
let blockstore = Blockstore::open(&ledger_path)
.expect("Expected to be able to open database ledger"); .expect("Expected to be able to open database ledger");
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2); let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2);
let bank0 = Arc::new(Bank::new_for_tests(&genesis_config)); let bank0 = Arc::new(Bank::new_for_tests(&genesis_config));
@ -1203,14 +1198,11 @@ mod tests {
poh_recorder.reset(bank0, Some((4, 4))); poh_recorder.reset(bank0, Some((4, 4)));
assert_eq!(poh_recorder.tick_cache.len(), 0); assert_eq!(poh_recorder.tick_cache.len(), 0);
} }
Blockstore::destroy(&ledger_path).unwrap();
}
#[test] #[test]
fn test_poh_recorder_clear() { fn test_poh_recorder_clear() {
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{ let blockstore = Blockstore::open(ledger_path.path())
let blockstore = Blockstore::open(&ledger_path)
.expect("Expected to be able to open database ledger"); .expect("Expected to be able to open database ledger");
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2); let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2);
let bank = Arc::new(Bank::new_for_tests(&genesis_config)); let bank = Arc::new(Bank::new_for_tests(&genesis_config));
@ -1233,14 +1225,11 @@ mod tests {
poh_recorder.clear_bank(); poh_recorder.clear_bank();
assert!(poh_recorder.working_bank.is_none()); assert!(poh_recorder.working_bank.is_none());
} }
Blockstore::destroy(&ledger_path).unwrap();
}
#[test] #[test]
fn test_poh_recorder_tick_sent_after_min() { fn test_poh_recorder_tick_sent_after_min() {
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{ let blockstore = Blockstore::open(ledger_path.path())
let blockstore = Blockstore::open(&ledger_path)
.expect("Expected to be able to open database ledger"); .expect("Expected to be able to open database ledger");
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2); let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2);
let bank0 = Arc::new(Bank::new_for_tests(&genesis_config)); let bank0 = Arc::new(Bank::new_for_tests(&genesis_config));
@ -1296,14 +1285,11 @@ mod tests {
// All the cached ticks, plus the new tick above should have been flushed // All the cached ticks, plus the new tick above should have been flushed
assert_eq!(num_entries, num_new_ticks + 1); assert_eq!(num_entries, num_new_ticks + 1);
} }
Blockstore::destroy(&ledger_path).unwrap();
}
#[test] #[test]
fn test_poh_recorder_tick_sent_upto_and_including_max() { fn test_poh_recorder_tick_sent_upto_and_including_max() {
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{ let blockstore = Blockstore::open(ledger_path.path())
let blockstore = Blockstore::open(&ledger_path)
.expect("Expected to be able to open database ledger"); .expect("Expected to be able to open database ledger");
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2); let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2);
let bank = Arc::new(Bank::new_for_tests(&genesis_config)); let bank = Arc::new(Bank::new_for_tests(&genesis_config));
@ -1345,14 +1331,11 @@ mod tests {
// having many more entries // having many more entries
assert_eq!(num_entries, bank.max_tick_height()); assert_eq!(num_entries, bank.max_tick_height());
} }
Blockstore::destroy(&ledger_path).unwrap();
}
#[test] #[test]
fn test_poh_recorder_record_to_early() { fn test_poh_recorder_record_to_early() {
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{ let blockstore = Blockstore::open(ledger_path.path())
let blockstore = Blockstore::open(&ledger_path)
.expect("Expected to be able to open database ledger"); .expect("Expected to be able to open database ledger");
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2); let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2);
let bank0 = Arc::new(Bank::new_for_tests(&genesis_config)); let bank0 = Arc::new(Bank::new_for_tests(&genesis_config));
@ -1388,14 +1371,11 @@ mod tests {
); );
assert!(entry_receiver.try_recv().is_err()); assert!(entry_receiver.try_recv().is_err());
} }
Blockstore::destroy(&ledger_path).unwrap();
}
#[test] #[test]
fn test_poh_recorder_record_bad_slot() { fn test_poh_recorder_record_bad_slot() {
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{ let blockstore = Blockstore::open(ledger_path.path())
let blockstore = Blockstore::open(&ledger_path)
.expect("Expected to be able to open database ledger"); .expect("Expected to be able to open database ledger");
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2); let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2);
let bank = Arc::new(Bank::new_for_tests(&genesis_config)); let bank = Arc::new(Bank::new_for_tests(&genesis_config));
@ -1430,14 +1410,11 @@ mod tests {
Err(PohRecorderError::MaxHeightReached) Err(PohRecorderError::MaxHeightReached)
); );
} }
Blockstore::destroy(&ledger_path).unwrap();
}
#[test] #[test]
fn test_poh_recorder_record_at_min_passes() { fn test_poh_recorder_record_at_min_passes() {
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{ let blockstore = Blockstore::open(ledger_path.path())
let blockstore = Blockstore::open(&ledger_path)
.expect("Expected to be able to open database ledger"); .expect("Expected to be able to open database ledger");
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2); let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2);
let bank0 = Arc::new(Bank::new_for_tests(&genesis_config)); let bank0 = Arc::new(Bank::new_for_tests(&genesis_config));
@ -1486,14 +1463,11 @@ mod tests {
let (_bank, (e, _tick_height)) = entry_receiver.recv().unwrap(); let (_bank, (e, _tick_height)) = entry_receiver.recv().unwrap();
assert!(!e.is_tick()); assert!(!e.is_tick());
} }
Blockstore::destroy(&ledger_path).unwrap();
}
#[test] #[test]
fn test_poh_recorder_record_at_max_fails() { fn test_poh_recorder_record_at_max_fails() {
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{ let blockstore = Blockstore::open(ledger_path.path())
let blockstore = Blockstore::open(&ledger_path)
.expect("Expected to be able to open database ledger"); .expect("Expected to be able to open database ledger");
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2); let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2);
let bank = Arc::new(Bank::new_for_tests(&genesis_config)); let bank = Arc::new(Bank::new_for_tests(&genesis_config));
@ -1526,14 +1500,11 @@ mod tests {
assert!(entry.is_tick()); assert!(entry.is_tick());
} }
} }
Blockstore::destroy(&ledger_path).unwrap();
}
#[test] #[test]
fn test_poh_recorder_record_transaction_index() { fn test_poh_recorder_record_transaction_index() {
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{ let blockstore = Blockstore::open(ledger_path.path())
let blockstore = Blockstore::open(&ledger_path)
.expect("Expected to be able to open database ledger"); .expect("Expected to be able to open database ledger");
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2); let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2);
let bank = Arc::new(Bank::new_for_tests(&genesis_config)); let bank = Arc::new(Bank::new_for_tests(&genesis_config));
@ -1598,14 +1569,11 @@ mod tests {
3 3
); );
} }
Blockstore::destroy(&ledger_path).unwrap();
}
#[test] #[test]
fn test_poh_cache_on_disconnect() { fn test_poh_cache_on_disconnect() {
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{ let blockstore = Blockstore::open(ledger_path.path())
let blockstore = Blockstore::open(&ledger_path)
.expect("Expected to be able to open database ledger"); .expect("Expected to be able to open database ledger");
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2); let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2);
let bank0 = Arc::new(Bank::new_for_tests(&genesis_config)); let bank0 = Arc::new(Bank::new_for_tests(&genesis_config));
@ -1628,8 +1596,7 @@ mod tests {
poh_recorder.set_bank_for_test(bank1); poh_recorder.set_bank_for_test(bank1);
// Check we can make two ticks without hitting min_tick_height // Check we can make two ticks without hitting min_tick_height
let remaining_ticks_to_min = let remaining_ticks_to_min = poh_recorder.working_bank.as_ref().unwrap().min_tick_height
poh_recorder.working_bank.as_ref().unwrap().min_tick_height
- poh_recorder.tick_height(); - poh_recorder.tick_height();
for _ in 0..remaining_ticks_to_min { for _ in 0..remaining_ticks_to_min {
poh_recorder.tick(); poh_recorder.tick();
@ -1655,14 +1622,11 @@ mod tests {
remaining_ticks_to_min as usize + 1 remaining_ticks_to_min as usize + 1
); );
} }
Blockstore::destroy(&ledger_path).unwrap();
}
#[test] #[test]
fn test_reset_current() { fn test_reset_current() {
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{ let blockstore = Blockstore::open(ledger_path.path())
let blockstore = Blockstore::open(&ledger_path)
.expect("Expected to be able to open database ledger"); .expect("Expected to be able to open database ledger");
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2); let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2);
let bank = Arc::new(Bank::new_for_tests(&genesis_config)); let bank = Arc::new(Bank::new_for_tests(&genesis_config));
@ -1684,14 +1648,11 @@ mod tests {
poh_recorder.reset(bank, Some((4, 4))); poh_recorder.reset(bank, Some((4, 4)));
assert_eq!(poh_recorder.tick_cache.len(), 0); assert_eq!(poh_recorder.tick_cache.len(), 0);
} }
Blockstore::destroy(&ledger_path).unwrap();
}
#[test] #[test]
fn test_reset_with_cached() { fn test_reset_with_cached() {
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{ let blockstore = Blockstore::open(ledger_path.path())
let blockstore = Blockstore::open(&ledger_path)
.expect("Expected to be able to open database ledger"); .expect("Expected to be able to open database ledger");
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2); let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2);
let bank = Arc::new(Bank::new_for_tests(&genesis_config)); let bank = Arc::new(Bank::new_for_tests(&genesis_config));
@ -1713,16 +1674,13 @@ mod tests {
poh_recorder.reset(bank, Some((4, 4))); poh_recorder.reset(bank, Some((4, 4)));
assert_eq!(poh_recorder.tick_cache.len(), 0); assert_eq!(poh_recorder.tick_cache.len(), 0);
} }
Blockstore::destroy(&ledger_path).unwrap();
}
#[test] #[test]
fn test_reset_to_new_value() { fn test_reset_to_new_value() {
solana_logger::setup(); solana_logger::setup();
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{ let blockstore = Blockstore::open(ledger_path.path())
let blockstore = Blockstore::open(&ledger_path)
.expect("Expected to be able to open database ledger"); .expect("Expected to be able to open database ledger");
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2); let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2);
let bank = Arc::new(Bank::new_for_tests(&genesis_config)); let bank = Arc::new(Bank::new_for_tests(&genesis_config));
@ -1749,14 +1707,11 @@ mod tests {
poh_recorder.tick(); poh_recorder.tick();
assert_eq!(poh_recorder.tick_height, DEFAULT_TICKS_PER_SLOT + 1); assert_eq!(poh_recorder.tick_height, DEFAULT_TICKS_PER_SLOT + 1);
} }
Blockstore::destroy(&ledger_path).unwrap();
}
#[test] #[test]
fn test_reset_clear_bank() { fn test_reset_clear_bank() {
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{ let blockstore = Blockstore::open(ledger_path.path())
let blockstore = Blockstore::open(&ledger_path)
.expect("Expected to be able to open database ledger"); .expect("Expected to be able to open database ledger");
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2); let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2);
let bank = Arc::new(Bank::new_for_tests(&genesis_config)); let bank = Arc::new(Bank::new_for_tests(&genesis_config));
@ -1778,14 +1733,11 @@ mod tests {
poh_recorder.reset(bank, Some((4, 4))); poh_recorder.reset(bank, Some((4, 4)));
assert!(poh_recorder.working_bank.is_none()); assert!(poh_recorder.working_bank.is_none());
} }
Blockstore::destroy(&ledger_path).unwrap();
}
#[test] #[test]
pub fn test_clear_signal() { pub fn test_clear_signal() {
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{ let blockstore = Blockstore::open(ledger_path.path())
let blockstore = Blockstore::open(&ledger_path)
.expect("Expected to be able to open database ledger"); .expect("Expected to be able to open database ledger");
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2); let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2);
let bank = Arc::new(Bank::new_for_tests(&genesis_config)); let bank = Arc::new(Bank::new_for_tests(&genesis_config));
@ -1809,15 +1761,12 @@ mod tests {
poh_recorder.clear_bank(); poh_recorder.clear_bank();
assert!(receiver.try_recv().is_ok()); assert!(receiver.try_recv().is_ok());
} }
Blockstore::destroy(&ledger_path).unwrap();
}
#[test] #[test]
fn test_poh_recorder_record_sets_start_slot() { fn test_poh_recorder_record_sets_start_slot() {
solana_logger::setup(); solana_logger::setup();
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{ let blockstore = Blockstore::open(ledger_path.path())
let blockstore = Blockstore::open(&ledger_path)
.expect("Expected to be able to open database ledger"); .expect("Expected to be able to open database ledger");
let ticks_per_slot = 5; let ticks_per_slot = 5;
let GenesisConfigInfo { let GenesisConfigInfo {
@ -1860,16 +1809,13 @@ mod tests {
// the earlier call to `poh_recorder.set_bank()` // the earlier call to `poh_recorder.set_bank()`
assert_eq!(poh_recorder.start_slot(), bank.slot()); assert_eq!(poh_recorder.start_slot(), bank.slot());
} }
Blockstore::destroy(&ledger_path).unwrap();
}
#[test] #[test]
fn test_reached_leader_tick() { fn test_reached_leader_tick() {
solana_logger::setup(); solana_logger::setup();
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{ let blockstore = Blockstore::open(ledger_path.path())
let blockstore = Blockstore::open(&ledger_path)
.expect("Expected to be able to open database ledger"); .expect("Expected to be able to open database ledger");
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2); let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2);
let bank = Arc::new(Bank::new_for_tests(&genesis_config)); let bank = Arc::new(Bank::new_for_tests(&genesis_config));
@ -1925,15 +1871,13 @@ mod tests {
poh_recorder.id = bootstrap_validator_id; poh_recorder.id = bootstrap_validator_id;
assert!(poh_recorder.reached_leader_tick(new_tick_height + grace_ticks)); assert!(poh_recorder.reached_leader_tick(new_tick_height + grace_ticks));
} }
}
#[test] #[test]
fn test_reached_leader_slot() { fn test_reached_leader_slot() {
solana_logger::setup(); solana_logger::setup();
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{ let blockstore = Blockstore::open(ledger_path.path())
let blockstore = Blockstore::open(&ledger_path)
.expect("Expected to be able to open database ledger"); .expect("Expected to be able to open database ledger");
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2); let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2);
let bank0 = Arc::new(Bank::new_for_tests(&genesis_config)); let bank0 = Arc::new(Bank::new_for_tests(&genesis_config));
@ -2087,14 +2031,11 @@ mod tests {
} }
); );
} }
Blockstore::destroy(&ledger_path).unwrap();
}
#[test] #[test]
fn test_would_be_leader_soon() { fn test_would_be_leader_soon() {
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{ let blockstore = Blockstore::open(ledger_path.path())
let blockstore = Blockstore::open(&ledger_path)
.expect("Expected to be able to open database ledger"); .expect("Expected to be able to open database ledger");
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2); let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2);
let bank = Arc::new(Bank::new_for_tests(&genesis_config)); let bank = Arc::new(Bank::new_for_tests(&genesis_config));
@ -2138,14 +2079,12 @@ mod tests {
poh_recorder.set_bank_for_test(bank.clone()); poh_recorder.set_bank_for_test(bank.clone());
assert!(poh_recorder.would_be_leader(2 * bank.ticks_per_slot())); assert!(poh_recorder.would_be_leader(2 * bank.ticks_per_slot()));
} }
}
#[test] #[test]
fn test_flush_virtual_ticks() { fn test_flush_virtual_ticks() {
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{
// test that virtual ticks are flushed into a newly set bank asap // test that virtual ticks are flushed into a newly set bank asap
let blockstore = Blockstore::open(&ledger_path) let blockstore = Blockstore::open(ledger_path.path())
.expect("Expected to be able to open database ledger"); .expect("Expected to be able to open database ledger");
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2); let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2);
let bank = Arc::new(Bank::new_for_tests(&genesis_config)); let bank = Arc::new(Bank::new_for_tests(&genesis_config));
@ -2173,7 +2112,6 @@ mod tests {
assert!(!bank.is_hash_valid_for_age(&genesis_hash, 0)); assert!(!bank.is_hash_valid_for_age(&genesis_hash, 0));
assert!(bank.is_hash_valid_for_age(&genesis_hash, 1)); assert!(bank.is_hash_valid_for_age(&genesis_hash, 1));
} }
}
#[test] #[test]
fn test_compute_leader_slot_tick_heights() { fn test_compute_leader_slot_tick_heights() {

19
poh/src/poh_service.rs
View File

@ -385,7 +385,7 @@ mod tests {
solana_ledger::{ solana_ledger::{
blockstore::Blockstore, blockstore::Blockstore,
genesis_utils::{create_genesis_config, GenesisConfigInfo}, genesis_utils::{create_genesis_config, GenesisConfigInfo},
get_tmp_ledger_path, get_tmp_ledger_path_auto_delete,
leader_schedule_cache::LeaderScheduleCache, leader_schedule_cache::LeaderScheduleCache,
}, },
solana_measure::measure::Measure, solana_measure::measure::Measure,
@ -404,9 +404,8 @@ mod tests {
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2); let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(2);
let bank = Arc::new(Bank::new_no_wallclock_throttle_for_tests(&genesis_config)); let bank = Arc::new(Bank::new_no_wallclock_throttle_for_tests(&genesis_config));
let prev_hash = bank.last_blockhash(); let prev_hash = bank.last_blockhash();
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{ let blockstore = Blockstore::open(ledger_path.path())
let blockstore = Blockstore::open(&ledger_path)
.expect("Expected to be able to open database ledger"); .expect("Expected to be able to open database ledger");
let default_target_tick_duration = let default_target_tick_duration =
@ -460,11 +459,11 @@ mod tests {
loop { loop {
// send some data // send some data
let mut time = Measure::start("record"); let mut time = Measure::start("record");
let _ = poh_recorder.write().unwrap().record( let _ =
bank_slot, poh_recorder
h1, .write()
vec![tx.clone()], .unwrap()
); .record(bank_slot, h1, vec![tx.clone()]);
time.stop(); time.stop();
total_us += time.as_us(); total_us += time.as_us();
total_times += 1; total_times += 1;
@ -569,6 +568,4 @@ mod tests {
poh_service.join().unwrap(); poh_service.join().unwrap();
entry_producer.join().unwrap(); entry_producer.join().unwrap();
} }
Blockstore::destroy(&ledger_path).unwrap();
}
} }

10
rpc/src/cluster_tpu_info.rs
View File

@ -108,7 +108,8 @@ mod test {
super::*, super::*,
solana_gossip::contact_info::ContactInfo, solana_gossip::contact_info::ContactInfo,
solana_ledger::{ solana_ledger::{
blockstore::Blockstore, get_tmp_ledger_path, leader_schedule_cache::LeaderScheduleCache, blockstore::Blockstore, get_tmp_ledger_path_auto_delete,
leader_schedule_cache::LeaderScheduleCache,
}, },
solana_runtime::{ solana_runtime::{
bank::Bank, bank::Bank,
@ -128,9 +129,8 @@ mod test {
#[test] #[test]
fn test_get_leader_tpus() { fn test_get_leader_tpus() {
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{ let blockstore = Blockstore::open(ledger_path.path()).unwrap();
let blockstore = Blockstore::open(&ledger_path).unwrap();
let validator_vote_keypairs0 = ValidatorVoteKeypairs::new_rand(); let validator_vote_keypairs0 = ValidatorVoteKeypairs::new_rand();
let validator_vote_keypairs1 = ValidatorVoteKeypairs::new_rand(); let validator_vote_keypairs1 = ValidatorVoteKeypairs::new_rand();
@ -245,6 +245,4 @@ mod test {
assert!(leader_info.get_leader_tpus(x, Protocol::UDP).len() <= recent_peers.len()); assert!(leader_info.get_leader_tpus(x, Protocol::UDP).len() <= recent_peers.len());
} }
} }
Blockstore::destroy(&ledger_path).unwrap();
}
} }

25
rpc/src/rpc_service.rs
View File

@ -586,7 +586,7 @@ mod tests {
crate::rpc::{create_validator_exit, tests::new_test_cluster_info}, crate::rpc::{create_validator_exit, tests::new_test_cluster_info},
solana_ledger::{ solana_ledger::{
genesis_utils::{create_genesis_config, GenesisConfigInfo}, genesis_utils::{create_genesis_config, GenesisConfigInfo},
get_tmp_ledger_path, get_tmp_ledger_path_auto_delete,
}, },
solana_rpc_client_api::config::RpcContextConfig, solana_rpc_client_api::config::RpcContextConfig,
solana_runtime::bank::Bank, solana_runtime::bank::Bank,
@ -618,8 +618,8 @@ mod tests {
solana_net_utils::find_available_port_in_range(ip_addr, (10000, 65535)).unwrap(), solana_net_utils::find_available_port_in_range(ip_addr, (10000, 65535)).unwrap(),
); );
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank))); let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap()); let blockstore = Arc::new(Blockstore::open(ledger_path.path()).unwrap());
let block_commitment_cache = Arc::new(RwLock::new(BlockCommitmentCache::default())); let block_commitment_cache = Arc::new(RwLock::new(BlockCommitmentCache::default()));
let optimistically_confirmed_bank = let optimistically_confirmed_bank =
OptimisticallyConfirmedBank::locked_from_bank_forks_root(&bank_forks); OptimisticallyConfirmedBank::locked_from_bank_forks_root(&bank_forks);
@ -719,8 +719,8 @@ mod tests {
#[test] #[test]
fn test_is_file_get_path() { fn test_is_file_get_path() {
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap()); let blockstore = Arc::new(Blockstore::open(ledger_path.path()).unwrap());
let bank_forks = create_bank_forks(); let bank_forks = create_bank_forks();
let optimistically_confirmed_bank = let optimistically_confirmed_bank =
OptimisticallyConfirmedBank::locked_from_bank_forks_root(&bank_forks); OptimisticallyConfirmedBank::locked_from_bank_forks_root(&bank_forks);
@ -728,13 +728,13 @@ mod tests {
let bank_forks = create_bank_forks(); let bank_forks = create_bank_forks();
let rrm = RpcRequestMiddleware::new( let rrm = RpcRequestMiddleware::new(
ledger_path.clone(), ledger_path.path().to_path_buf(),
None, None,
bank_forks.clone(), bank_forks.clone(),
health.clone(), health.clone(),
); );
let rrm_with_snapshot_config = RpcRequestMiddleware::new( let rrm_with_snapshot_config = RpcRequestMiddleware::new(
ledger_path.clone(), ledger_path.path().to_path_buf(),
Some(SnapshotConfig::default()), Some(SnapshotConfig::default()),
bank_forks, bank_forks,
health, health,
@ -829,15 +829,14 @@ mod tests {
fn test_process_file_get() { fn test_process_file_get() {
let runtime = Runtime::new().unwrap(); let runtime = Runtime::new().unwrap();
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap()); let blockstore = Arc::new(Blockstore::open(ledger_path.path()).unwrap());
let genesis_path = ledger_path.join(DEFAULT_GENESIS_ARCHIVE); let genesis_path = ledger_path.path().join(DEFAULT_GENESIS_ARCHIVE);
let bank_forks = create_bank_forks(); let bank_forks = create_bank_forks();
let optimistically_confirmed_bank = let optimistically_confirmed_bank =
OptimisticallyConfirmedBank::locked_from_bank_forks_root(&bank_forks); OptimisticallyConfirmedBank::locked_from_bank_forks_root(&bank_forks);
let rrm = RpcRequestMiddleware::new( let rrm = RpcRequestMiddleware::new(
ledger_path.clone(), ledger_path.path().to_path_buf(),
None, None,
bank_forks, bank_forks,
RpcHealth::stub(optimistically_confirmed_bank, blockstore), RpcHealth::stub(optimistically_confirmed_bank, blockstore),
@ -872,7 +871,7 @@ mod tests {
{ {
std::fs::remove_file(&genesis_path).unwrap(); std::fs::remove_file(&genesis_path).unwrap();
{ {
let mut file = std::fs::File::create(ledger_path.join("wrong")).unwrap(); let mut file = std::fs::File::create(ledger_path.path().join("wrong")).unwrap();
file.write_all(b"wrong file").unwrap(); file.write_all(b"wrong file").unwrap();
} }
symlink::symlink_file("wrong", &genesis_path).unwrap(); symlink::symlink_file("wrong", &genesis_path).unwrap();

13
rpc/src/rpc_subscriptions.rs
View File

@ -1259,6 +1259,7 @@ pub(crate) mod tests {
rpc_pubsub_service, rpc_pubsub_service,
}, },
serial_test::serial, serial_test::serial,
solana_ledger::get_tmp_ledger_path_auto_delete,
solana_rpc_client_api::config::{ solana_rpc_client_api::config::{
RpcAccountInfoConfig, RpcBlockSubscribeConfig, RpcBlockSubscribeFilter, RpcAccountInfoConfig, RpcBlockSubscribeConfig, RpcBlockSubscribeFilter,
RpcProgramAccountsConfig, RpcSignatureSubscribeConfig, RpcTransactionLogsConfig, RpcProgramAccountsConfig, RpcSignatureSubscribeConfig, RpcTransactionLogsConfig,
@ -1473,8 +1474,8 @@ pub(crate) mod tests {
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank))); let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
let optimistically_confirmed_bank = let optimistically_confirmed_bank =
OptimisticallyConfirmedBank::locked_from_bank_forks_root(&bank_forks); OptimisticallyConfirmedBank::locked_from_bank_forks_root(&bank_forks);
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = Blockstore::open(&ledger_path).unwrap(); let blockstore = Blockstore::open(ledger_path.path()).unwrap();
let blockstore = Arc::new(blockstore); let blockstore = Arc::new(blockstore);
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default()); let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
let max_complete_rewards_slot = Arc::new(AtomicU64::default()); let max_complete_rewards_slot = Arc::new(AtomicU64::default());
@ -1593,8 +1594,8 @@ pub(crate) mod tests {
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank))); let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
let optimistically_confirmed_bank = let optimistically_confirmed_bank =
OptimisticallyConfirmedBank::locked_from_bank_forks_root(&bank_forks); OptimisticallyConfirmedBank::locked_from_bank_forks_root(&bank_forks);
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = Blockstore::open(&ledger_path).unwrap(); let blockstore = Blockstore::open(ledger_path.path()).unwrap();
let blockstore = Arc::new(blockstore); let blockstore = Arc::new(blockstore);
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default()); let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
let max_complete_rewards_slot = Arc::new(AtomicU64::default()); let max_complete_rewards_slot = Arc::new(AtomicU64::default());
@ -1711,8 +1712,8 @@ pub(crate) mod tests {
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank))); let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
let optimistically_confirmed_bank = let optimistically_confirmed_bank =
OptimisticallyConfirmedBank::locked_from_bank_forks_root(&bank_forks); OptimisticallyConfirmedBank::locked_from_bank_forks_root(&bank_forks);
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = Blockstore::open(&ledger_path).unwrap(); let blockstore = Blockstore::open(ledger_path.path()).unwrap();
let blockstore = Arc::new(blockstore); let blockstore = Arc::new(blockstore);
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default()); let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
let max_complete_rewards_slot = Arc::new(AtomicU64::default()); let max_complete_rewards_slot = Arc::new(AtomicU64::default());

8
rpc/src/transaction_status_service.rs
View File

@ -230,7 +230,7 @@ pub(crate) mod tests {
nonce_info::{NonceFull, NoncePartial}, nonce_info::{NonceFull, NoncePartial},
rent_debits::RentDebits, rent_debits::RentDebits,
}, },
solana_ledger::{genesis_utils::create_genesis_config, get_tmp_ledger_path}, solana_ledger::{genesis_utils::create_genesis_config, get_tmp_ledger_path_auto_delete},
solana_runtime::bank::{Bank, TransactionBalancesSet}, solana_runtime::bank::{Bank, TransactionBalancesSet},
solana_sdk::{ solana_sdk::{
account_utils::StateMut, account_utils::StateMut,
@ -339,9 +339,9 @@ pub(crate) mod tests {
let bank = Arc::new(Bank::new_no_wallclock_throttle_for_tests(&genesis_config)); let bank = Arc::new(Bank::new_no_wallclock_throttle_for_tests(&genesis_config));
let (transaction_status_sender, transaction_status_receiver) = unbounded(); let (transaction_status_sender, transaction_status_receiver) = unbounded();
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = let blockstore = Blockstore::open(ledger_path.path())
Blockstore::open(&ledger_path).expect("Expected to be able to open database ledger"); .expect("Expected to be able to open database ledger");
let blockstore = Arc::new(blockstore); let blockstore = Arc::new(blockstore);
let transaction = build_test_transaction_legacy(); let transaction = build_test_transaction_legacy();

14
turbine/src/broadcast_stage.rs
View File

@ -505,7 +505,7 @@ pub mod test {
solana_ledger::{ solana_ledger::{
blockstore::Blockstore, blockstore::Blockstore,
genesis_utils::{create_genesis_config, GenesisConfigInfo}, genesis_utils::{create_genesis_config, GenesisConfigInfo},
get_tmp_ledger_path, get_tmp_ledger_path_auto_delete,
shred::{max_ticks_per_n_shreds, ProcessShredsStats, ReedSolomonCache, Shredder}, shred::{max_ticks_per_n_shreds, ProcessShredsStats, ReedSolomonCache, Shredder},
}, },
solana_runtime::bank::Bank, solana_runtime::bank::Bank,
@ -590,8 +590,8 @@ pub mod test {
#[test] #[test]
fn test_duplicate_retransmit_signal() { fn test_duplicate_retransmit_signal() {
// Setup // Setup
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = Arc::new(Blockstore::open(&ledger_path).unwrap()); let blockstore = Arc::new(Blockstore::open(ledger_path.path()).unwrap());
let (transmit_sender, transmit_receiver) = unbounded(); let (transmit_sender, transmit_receiver) = unbounded();
let (retransmit_slots_sender, retransmit_slots_receiver) = unbounded(); let (retransmit_slots_sender, retransmit_slots_receiver) = unbounded();
@ -694,9 +694,8 @@ pub mod test {
#[test] #[test]
fn test_broadcast_ledger() { fn test_broadcast_ledger() {
solana_logger::setup(); solana_logger::setup();
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
{
// Create the leader scheduler // Create the leader scheduler
let leader_keypair = Arc::new(Keypair::new()); let leader_keypair = Arc::new(Keypair::new());
@ -704,7 +703,7 @@ pub mod test {
let (retransmit_slots_sender, retransmit_slots_receiver) = unbounded(); let (retransmit_slots_sender, retransmit_slots_receiver) = unbounded();
let broadcast_service = setup_dummy_broadcast_service( let broadcast_service = setup_dummy_broadcast_service(
leader_keypair, leader_keypair,
&ledger_path, ledger_path.path(),
entry_receiver, entry_receiver,
retransmit_slots_receiver, retransmit_slots_receiver,
); );
@ -753,7 +752,4 @@ pub mod test {
.join() .join()
.expect("Expect successful join of broadcast service"); .expect("Expect successful join of broadcast service");
} }
Blockstore::destroy(&ledger_path).expect("Expected successful database destruction");
}
} }

7
turbine/src/broadcast_stage/standard_broadcast_run.rs
View File

@ -503,7 +503,7 @@ mod test {
solana_gossip::cluster_info::{ClusterInfo, Node}, solana_gossip::cluster_info::{ClusterInfo, Node},
solana_ledger::{ solana_ledger::{
blockstore::Blockstore, genesis_utils::create_genesis_config, get_tmp_ledger_path, blockstore::Blockstore, genesis_utils::create_genesis_config, get_tmp_ledger_path,
shred::max_ticks_per_n_shreds, get_tmp_ledger_path_auto_delete, shred::max_ticks_per_n_shreds,
}, },
solana_runtime::bank::Bank, solana_runtime::bank::Bank,
solana_sdk::{ solana_sdk::{
@ -815,9 +815,10 @@ mod test {
bs.current_slot_and_parent = Some((1, 0)); bs.current_slot_and_parent = Some((1, 0));
let entries = create_ticks(10_000, 1, solana_sdk::hash::Hash::default()); let entries = create_ticks(10_000, 1, solana_sdk::hash::Hash::default());
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = Arc::new( let blockstore = Arc::new(
Blockstore::open(&ledger_path).expect("Expected to be able to open database ledger"), Blockstore::open(ledger_path.path())
.expect("Expected to be able to open database ledger"),
); );
let mut stats = ProcessShredsStats::default(); let mut stats = ProcessShredsStats::default();