gaspersic/solana
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Blockstore test cleanup (#19656)

Browse Source 
* Use auto-deleting macro for ledger path
This commit is contained in:
steviez
2021-09-10 07:33:08 -05:00
committed by GitHub
parent 311b5789af
commit 2dee098b91
8 changed files with 3795 additions and 3954 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
ledger/src/ancestor_iterator.rs
View File

@ -79,8 +79,8 @@ mod tests {
use std::{collections::HashMap, path::Path};
use trees::tr;
fn setup_forks(blockstore_path: &Path) -> Blockstore {
let blockstore = Blockstore::open(blockstore_path).unwrap();
fn setup_forks(ledger_path: &Path) -> Blockstore {
let blockstore = Blockstore::open(ledger_path).unwrap();
/*
Build fork structure:
@ -102,9 +102,8 @@ mod tests {
#[test]
fn test_ancestor_iterator() {
let blockstore_path = get_tmp_ledger_path!();
{
let blockstore = setup_forks(&blockstore_path);
let ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = setup_forks(ledger_path.path());
// Test correctness
assert!(AncestorIterator::new(0, &blockstore).next().is_none());
@ -117,13 +116,11 @@ mod tests {
vec![2, 1, 0]
);
}
Blockstore::destroy(&blockstore_path).unwrap();
}
#[test]
fn test_ancestor_iterator_inclusive() {
let blockstore_path = get_tmp_ledger_path!();
let blockstore = Blockstore::open(&blockstore_path).unwrap();
let ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = Blockstore::open(ledger_path.path()).unwrap();
let (shreds, _) = make_slot_entries(0, 0, 42);
blockstore.insert_shreds(shreds, None, false).unwrap();
@ -151,9 +148,8 @@ mod tests {
#[test]
fn test_ancestor_iterator_with_hash() {
let blockstore_path = get_tmp_ledger_path!();
{
let blockstore = setup_forks(&blockstore_path);
let ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = setup_forks(ledger_path.path());
// Insert frozen hashes
let mut slot_to_bank_hash = HashMap::new();
@ -184,6 +180,4 @@ mod tests {
]
);
}
Blockstore::destroy(&blockstore_path).unwrap();
}
}

821
ledger/src/blockstore.rs
View File

File diff suppressed because it is too large Load Diff

61
ledger/src/blockstore/blockstore_purge.rs
View File

@ -393,7 +393,9 @@ impl Blockstore {
#[cfg(test)]
pub mod tests {
use super::*;
use crate::{blockstore::tests::make_slot_entries_with_transactions, get_tmp_ledger_path};
use crate::{
blockstore::tests::make_slot_entries_with_transactions, get_tmp_ledger_path_auto_delete,
};
use bincode::serialize;
use solana_entry::entry::next_entry_mut;
use solana_sdk::{
@ -497,8 +499,9 @@ pub mod tests {
#[test]
fn test_purge_slots() {
let blockstore_path = get_tmp_ledger_path!();
let blockstore = Blockstore::open(&blockstore_path).unwrap();
let ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = Blockstore::open(ledger_path.path()).unwrap();
let (shreds, _) = make_many_slot_entries(0, 50, 5);
blockstore.insert_shreds(shreds, None, false).unwrap();
@ -518,31 +521,25 @@ pub mod tests {
.for_each(|(_, _)| {
panic!();
});
drop(blockstore);
Blockstore::destroy(&blockstore_path).expect("Expected successful database destruction");
}
#[test]
fn test_purge_huge() {
let blockstore_path = get_tmp_ledger_path!();
let blockstore = Blockstore::open(&blockstore_path).unwrap();
let ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = Blockstore::open(ledger_path.path()).unwrap();
let (shreds, _) = make_many_slot_entries(0, 5000, 10);
blockstore.insert_shreds(shreds, None, false).unwrap();
blockstore.purge_and_compact_slots(0, 4999);
test_all_empty_or_min(&blockstore, 5000);
drop(blockstore);
Blockstore::destroy(&blockstore_path).expect("Expected successful database destruction");
}
#[test]
fn test_purge_front_of_ledger() {
let blockstore_path = get_tmp_ledger_path!();
{
let blockstore = Blockstore::open(&blockstore_path).unwrap();
let ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = Blockstore::open(ledger_path.path()).unwrap();
let max_slot = 10;
for x in 0..max_slot {
let random_bytes: Vec<u8> = (0..64).map(|_| rand::random::<u8>()).collect();
@ -585,16 +582,14 @@ pub mod tests {
let entry = status_entry_iterator.next().unwrap().0;
assert_eq!(entry.0, 0);
}
Blockstore::destroy(&blockstore_path).expect("Expected successful database destruction");
}
#[test]
#[allow(clippy::cognitive_complexity)]
fn test_purge_transaction_status() {
let blockstore_path = get_tmp_ledger_path!();
{
let blockstore = Blockstore::open(&blockstore_path).unwrap();
let transaction_status_index_cf = blockstore.db.column::<cf::TransactionStatusIndex>();
let ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = Blockstore::open(ledger_path.path()).unwrap();
let transaction_status_index_cf = &blockstore.transaction_status_index_cf;
let slot = 10;
for _ in 0..5 {
let random_bytes: Vec<u8> = (0..64).map(|_| rand::random::<u8>()).collect();
@ -641,6 +636,8 @@ pub mod tests {
frozen: true,
}
);
drop(status_entry_iterator);
drop(address_transactions_iterator);
// Low purge should not affect state
blockstore.run_purge(0, 5, PurgeType::PrimaryIndex).unwrap();
@ -675,6 +672,8 @@ pub mod tests {
frozen: true,
}
);
drop(status_entry_iterator);
drop(address_transactions_iterator);
// Test boundary conditions: < slot should not purge statuses; <= slot should
blockstore.run_purge(0, 9, PurgeType::PrimaryIndex).unwrap();
@ -709,6 +708,8 @@ pub mod tests {
frozen: true,
}
);
drop(status_entry_iterator);
drop(address_transactions_iterator);
blockstore
.run_purge(0, 10, PurgeType::PrimaryIndex)
@ -750,8 +751,6 @@ pub mod tests {
}
);
}
Blockstore::destroy(&blockstore_path).expect("Expected successful database destruction");
}
fn clear_and_repopulate_transaction_statuses(
blockstore: &mut Blockstore,
@ -860,9 +859,9 @@ pub mod tests {
#[test]
#[allow(clippy::cognitive_complexity)]
fn test_purge_transaction_status_exact() {
let blockstore_path = get_tmp_ledger_path!();
{
let mut blockstore = Blockstore::open(&blockstore_path).unwrap();
let ledger_path = get_tmp_ledger_path_auto_delete!();
let mut blockstore = Blockstore::open(ledger_path.path()).unwrap();
let index0_max_slot = 9;
let index1_max_slot = 19;
@ -1197,16 +1196,12 @@ pub mod tests {
);
let entry = status_entry_iterator.next().unwrap().0;
assert_eq!(entry.0, 2); // Buffer entry, no index 0 or index 1 entries remaining
drop(status_entry_iterator);
}
Blockstore::destroy(&blockstore_path).expect("Expected successful database destruction");
}
#[test]
fn test_purge_special_columns_exact_no_sigs() {
let blockstore_path = get_tmp_ledger_path!();
{
let blockstore = Blockstore::open(&blockstore_path).unwrap();
let ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = Blockstore::open(ledger_path.path()).unwrap();
let slot = 1;
let mut entries: Vec<Entry> = vec![];
@ -1225,6 +1220,4 @@ pub mod tests {
.purge_special_columns_exact(&mut write_batch, slot, slot + 1)
.unwrap();
}
Blockstore::destroy(&blockstore_path).expect("Expected successful database destruction");
}
}

80
ledger/src/blockstore_processor.rs
View File

@ -1522,9 +1522,8 @@ pub mod tests {
genesis_config.poh_config.hashes_per_tick = Some(hashes_per_tick);
let ticks_per_slot = genesis_config.ticks_per_slot;
let (ledger_path, blockhash) = create_new_tmp_ledger!(&genesis_config);
let blockstore =
Blockstore::open(&ledger_path).expect("Expected to successfully open database ledger");
let (ledger_path, blockhash) = create_new_tmp_ledger_auto_delete!(&genesis_config);
let blockstore = Blockstore::open(ledger_path.path()).unwrap();
let parent_slot = 0;
let slot = 1;
@ -1563,8 +1562,8 @@ pub mod tests {
let ticks_per_slot = genesis_config.ticks_per_slot;
// Create a new ledger with slot 0 full of ticks
let (ledger_path, blockhash) = create_new_tmp_ledger!(&genesis_config);
let blockstore = Blockstore::open(&ledger_path).unwrap();
let (ledger_path, blockhash) = create_new_tmp_ledger_auto_delete!(&genesis_config);
let blockstore = Blockstore::open(ledger_path.path()).unwrap();
// Write slot 1 with one tick missing
let parent_slot = 0;
@ -1626,8 +1625,8 @@ pub mod tests {
} = create_genesis_config(10_000);
let ticks_per_slot = genesis_config.ticks_per_slot;
let (ledger_path, blockhash) = create_new_tmp_ledger!(&genesis_config);
let blockstore = Blockstore::open(&ledger_path).unwrap();
let (ledger_path, blockhash) = create_new_tmp_ledger_auto_delete!(&genesis_config);
let blockstore = Blockstore::open(ledger_path.path()).unwrap();
let mut entries = create_ticks(ticks_per_slot, 0, blockhash);
let trailing_entry = {
@ -1685,11 +1684,10 @@ pub mod tests {
*/
// Create a new ledger with slot 0 full of ticks
let (ledger_path, mut blockhash) = create_new_tmp_ledger!(&genesis_config);
let (ledger_path, mut blockhash) = create_new_tmp_ledger_auto_delete!(&genesis_config);
debug!("ledger_path: {:?}", ledger_path);
let blockstore =
Blockstore::open(&ledger_path).expect("Expected to successfully open database ledger");
let blockstore = Blockstore::open(ledger_path.path()).unwrap();
// Write slot 1
// slot 1, points at slot 0. Missing one tick
@ -1759,7 +1757,7 @@ pub mod tests {
let ticks_per_slot = genesis_config.ticks_per_slot;
// Create a new ledger with slot 0 full of ticks
let (ledger_path, blockhash) = create_new_tmp_ledger!(&genesis_config);
let (ledger_path, blockhash) = create_new_tmp_ledger_auto_delete!(&genesis_config);
debug!("ledger_path: {:?}", ledger_path);
let mut last_entry_hash = blockhash;
@ -1777,8 +1775,7 @@ pub mod tests {
slot 4 <-- set_root(true)
*/
let blockstore =
Blockstore::open(&ledger_path).expect("Expected to successfully open database ledger");
let blockstore = Blockstore::open(ledger_path.path()).unwrap();
// Fork 1, ending at slot 3
let last_slot1_entry_hash =
@ -1838,7 +1835,7 @@ pub mod tests {
let ticks_per_slot = genesis_config.ticks_per_slot;
// Create a new ledger with slot 0 full of ticks
let (ledger_path, blockhash) = create_new_tmp_ledger!(&genesis_config);
let (ledger_path, blockhash) = create_new_tmp_ledger_auto_delete!(&genesis_config);
debug!("ledger_path: {:?}", ledger_path);
let mut last_entry_hash = blockhash;
@ -1856,8 +1853,7 @@ pub mod tests {
slot 4
*/
let blockstore =
Blockstore::open(&ledger_path).expect("Expected to successfully open database ledger");
let blockstore = Blockstore::open(ledger_path.path()).unwrap();
// Fork 1, ending at slot 3
let last_slot1_entry_hash =
@ -1926,7 +1922,7 @@ pub mod tests {
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(10_000);
let ticks_per_slot = genesis_config.ticks_per_slot;
let (ledger_path, blockhash) = create_new_tmp_ledger!(&genesis_config);
let (ledger_path, blockhash) = create_new_tmp_ledger_auto_delete!(&genesis_config);
debug!("ledger_path: {:?}", ledger_path);
/*
@ -1939,7 +1935,7 @@ pub mod tests {
\
slot 3
*/
let blockstore = Blockstore::open(&ledger_path).unwrap();
let blockstore = Blockstore::open(ledger_path.path()).unwrap();
let slot1_blockhash =
fill_blockstore_slot_with_ticks(&blockstore, ticks_per_slot, 1, 0, blockhash);
fill_blockstore_slot_with_ticks(&blockstore, ticks_per_slot, 2, 1, slot1_blockhash);
@ -1968,7 +1964,7 @@ pub mod tests {
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(10_000);
let ticks_per_slot = genesis_config.ticks_per_slot;
let (ledger_path, blockhash) = create_new_tmp_ledger!(&genesis_config);
let (ledger_path, blockhash) = create_new_tmp_ledger_auto_delete!(&genesis_config);
debug!("ledger_path: {:?}", ledger_path);
/*
@ -1981,7 +1977,7 @@ pub mod tests {
/ \
slot 4 (dead) slot 3
*/
let blockstore = Blockstore::open(&ledger_path).unwrap();
let blockstore = Blockstore::open(ledger_path.path()).unwrap();
let slot1_blockhash =
fill_blockstore_slot_with_ticks(&blockstore, ticks_per_slot, 1, 0, blockhash);
let slot2_blockhash =
@ -2023,7 +2019,7 @@ pub mod tests {
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(10_000);
let ticks_per_slot = genesis_config.ticks_per_slot;
let (ledger_path, blockhash) = create_new_tmp_ledger!(&genesis_config);
let (ledger_path, blockhash) = create_new_tmp_ledger_auto_delete!(&genesis_config);
debug!("ledger_path: {:?}", ledger_path);
/*
@ -2032,7 +2028,7 @@ pub mod tests {
/ \
slot 1 (dead) slot 2 (dead)
*/
let blockstore = Blockstore::open(&ledger_path).unwrap();
let blockstore = Blockstore::open(ledger_path.path()).unwrap();
fill_blockstore_slot_with_ticks(&blockstore, ticks_per_slot, 1, 0, blockhash);
fill_blockstore_slot_with_ticks(&blockstore, ticks_per_slot, 2, 0, blockhash);
blockstore.set_dead_slot(1).unwrap();
@ -2053,11 +2049,10 @@ pub mod tests {
let ticks_per_slot = genesis_config.ticks_per_slot;
// Create a new ledger with slot 0 full of ticks
let (ledger_path, blockhash) = create_new_tmp_ledger!(&genesis_config);
let (ledger_path, blockhash) = create_new_tmp_ledger_auto_delete!(&genesis_config);
let mut last_entry_hash = blockhash;
let blockstore =
Blockstore::open(&ledger_path).expect("Expected to successfully open database ledger");
let blockstore = Blockstore::open(ledger_path.path()).unwrap();
// Let `last_slot` be the number of slots in the first two epochs
let epoch_schedule = get_epoch_schedule(&genesis_config, Vec::new());
@ -2178,7 +2173,8 @@ pub mod tests {
..
} = create_genesis_config_with_leader(mint, &leader_pubkey, 50);
genesis_config.poh_config.hashes_per_tick = Some(hashes_per_tick);
let (ledger_path, mut last_entry_hash) = create_new_tmp_ledger!(&genesis_config);
let (ledger_path, mut last_entry_hash) =
create_new_tmp_ledger_auto_delete!(&genesis_config);
debug!("ledger_path: {:?}", ledger_path);
let deducted_from_mint = 3;
@ -2212,8 +2208,7 @@ pub mod tests {
));
let last_blockhash = entries.last().unwrap().hash;
let blockstore =
Blockstore::open(&ledger_path).expect("Expected to successfully open database ledger");
let blockstore = Blockstore::open(ledger_path.path()).unwrap();
blockstore
.write_entries(
1,
@ -2253,9 +2248,9 @@ pub mod tests {
mut genesis_config, ..
} = create_genesis_config(123);
genesis_config.ticks_per_slot = 1;
let (ledger_path, _blockhash) = create_new_tmp_ledger!(&genesis_config);
let (ledger_path, _blockhash) = create_new_tmp_ledger_auto_delete!(&genesis_config);
let blockstore = Blockstore::open(&ledger_path).unwrap();
let blockstore = Blockstore::open(ledger_path.path()).unwrap();
let opts = ProcessOptions {
poh_verify: true,
accounts_db_test_hash_calculation: true,
@ -2271,9 +2266,9 @@ pub mod tests {
#[test]
fn test_process_ledger_options_override_threads() {
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(123);
let (ledger_path, _blockhash) = create_new_tmp_ledger!(&genesis_config);
let (ledger_path, _blockhash) = create_new_tmp_ledger_auto_delete!(&genesis_config);
let blockstore = Blockstore::open(&ledger_path).unwrap();
let blockstore = Blockstore::open(ledger_path.path()).unwrap();
let opts = ProcessOptions {
override_num_threads: Some(1),
accounts_db_test_hash_calculation: true,
@ -2288,9 +2283,9 @@ pub mod tests {
#[test]
fn test_process_ledger_options_full_leader_cache() {
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(123);
let (ledger_path, _blockhash) = create_new_tmp_ledger!(&genesis_config);
let (ledger_path, _blockhash) = create_new_tmp_ledger_auto_delete!(&genesis_config);
let blockstore = Blockstore::open(&ledger_path).unwrap();
let blockstore = Blockstore::open(ledger_path.path()).unwrap();
let opts = ProcessOptions {
full_leader_cache: true,
accounts_db_test_hash_calculation: true,
@ -2308,9 +2303,8 @@ pub mod tests {
mint_keypair,
..
} = create_genesis_config(100);
let (ledger_path, last_entry_hash) = create_new_tmp_ledger!(&genesis_config);
let blockstore =
Blockstore::open(&ledger_path).expect("Expected to successfully open database ledger");
let (ledger_path, last_entry_hash) = create_new_tmp_ledger_auto_delete!(&genesis_config);
let blockstore = Blockstore::open(ledger_path.path()).unwrap();
let blockhash = genesis_config.hash();
let keypairs = [Keypair::new(), Keypair::new(), Keypair::new()];
@ -2988,8 +2982,8 @@ pub mod tests {
// Create roots at slots 0, 1
let forks = tr(0) / tr(1);
let ledger_path = get_tmp_ledger_path!();
let blockstore = Blockstore::open(&ledger_path).unwrap();
let ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = Blockstore::open(ledger_path.path()).unwrap();
blockstore.add_tree(
forks,
false,
@ -3021,8 +3015,8 @@ pub mod tests {
let ticks_per_slot = 1;
genesis_config.ticks_per_slot = ticks_per_slot;
let (ledger_path, blockhash) = create_new_tmp_ledger!(&genesis_config);
let blockstore = Blockstore::open(&ledger_path).unwrap();
let (ledger_path, blockhash) = create_new_tmp_ledger_auto_delete!(&genesis_config);
let blockstore = Blockstore::open(ledger_path.path()).unwrap();
/*
Build a blockstore in the ledger with the following fork structure:
@ -3615,8 +3609,8 @@ pub mod tests {
vec![100],
);
let ticks_per_slot = genesis_config.ticks_per_slot();
let ledger_path = get_tmp_ledger_path!();
let blockstore = Blockstore::open(&ledger_path).unwrap();
let ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = Blockstore::open(ledger_path.path()).unwrap();
blockstore.add_tree(forks, false, true, ticks_per_slot, genesis_config.hash());
if let Some(blockstore_root) = blockstore_root {

14
ledger/src/leader_schedule_cache.rs
View File

@ -255,7 +255,7 @@ mod tests {
bootstrap_validator_stake_lamports, create_genesis_config,
create_genesis_config_with_leader, GenesisConfigInfo,
},
get_tmp_ledger_path,
get_tmp_ledger_path_auto_delete,
staking_utils::tests::setup_vote_and_stake_accounts,
};
use solana_runtime::bank::Bank;
@ -428,12 +428,10 @@ mod tests {
let bank = Bank::new_for_tests(&genesis_config);
let cache = Arc::new(LeaderScheduleCache::new_from_bank(&bank));
let ledger_path = get_tmp_ledger_path!();
{
let blockstore = Arc::new(
Blockstore::open(&ledger_path)
.expect("Expected to be able to open database ledger"),
);
let ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = Blockstore::open(ledger_path.path())
.expect("Expected to be able to open database ledger");
assert_eq!(
cache.slot_leader_at(bank.slot(), Some(&bank)).unwrap(),
@ -496,8 +494,6 @@ mod tests {
None
);
}
Blockstore::destroy(&ledger_path).unwrap();
}
#[test]
fn test_next_leader_slot_next_epoch() {

7
ledger/src/next_slots_iterator.rs
View File

@ -41,8 +41,8 @@ mod tests {
#[test]
fn test_next_slots_iterator() {
let blockstore_path = get_tmp_ledger_path!();
let blockstore = Blockstore::open(&blockstore_path).unwrap();
let ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = Blockstore::open(ledger_path.path()).unwrap();
blockstore.set_roots(std::iter::once(&0)).unwrap();
let ticks_per_slot = 5;
/*
@ -107,8 +107,5 @@ mod tests {
.collect();
let expected = vec![4].into_iter().collect();
assert_eq!(result, expected);
drop(blockstore);
Blockstore::destroy(&blockstore_path).expect("Expected successful database destruction");
}
}

14
ledger/src/rooted_slot_iterator.rs
View File

@ -82,8 +82,8 @@ mod tests {
#[test]
fn test_rooted_slot_iterator() {
let blockstore_path = get_tmp_ledger_path!();
let blockstore = Blockstore::open(&blockstore_path).unwrap();
let ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = Blockstore::open(ledger_path.path()).unwrap();
blockstore.set_roots(std::iter::once(&0)).unwrap();
let ticks_per_slot = 5;
/*
@ -150,15 +150,12 @@ mod tests {
.collect();
let expected = vec![0, 1, 2, 3];
assert_eq!(result, expected);
drop(blockstore);
Blockstore::destroy(&blockstore_path).expect("Expected successful database destruction");
}
#[test]
fn test_skipping_rooted_slot_iterator() {
let blockstore_path = get_tmp_ledger_path!();
let blockstore = Blockstore::open(&blockstore_path).unwrap();
let ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = Blockstore::open(ledger_path.path()).unwrap();
let ticks_per_slot = 5;
/*
Build a blockstore in the ledger with the following fork structure:
@ -229,8 +226,5 @@ mod tests {
(11, true),
];
assert_eq!(result, expected);
drop(blockstore);
Blockstore::destroy(&blockstore_path).expect("Expected successful database destruction");
}
}

10
ledger/tests/blockstore.rs
View File

@ -1,7 +1,7 @@
use solana_entry::entry;
use solana_ledger::{
blockstore::{self, Blockstore},
get_tmp_ledger_path,
get_tmp_ledger_path_auto_delete,
};
use solana_sdk::hash::Hash;
use std::sync::Arc;
@ -9,8 +9,8 @@ use std::thread::Builder;
#[test]
fn test_multiple_threads_insert_shred() {
let blockstore_path = get_tmp_ledger_path!();
let blockstore = Arc::new(Blockstore::open(&blockstore_path).unwrap());
let ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = Arc::new(Blockstore::open(ledger_path.path()).unwrap());
for _ in 0..100 {
let num_threads = 10;
@ -44,8 +44,4 @@ fn test_multiple_threads_insert_shred() {
// Delete slots for next iteration
blockstore.purge_and_compact_slots(0, num_threads + 1);
}
// Cleanup
drop(blockstore);
Blockstore::destroy(&blockstore_path).expect("Expected successful database destruction");
}