Rename blocktree to blockstore (#7757)

automerge

local-cluster/src/cluster_tests.rs

@@ -10,7 +10,7 @@ use solana_core::{
     gossip_service::discover_cluster,
 };
 use solana_ledger::{
-    blocktree::Blocktree,
+    blockstore::Blockstore,
     entry::{Entry, EntrySlice},
 };
 use solana_sdk::{
@@ -140,7 +140,7 @@ pub fn validator_exit(entry_point_info: &ContactInfo, nodes: usize) {
 }
 
 pub fn verify_ledger_ticks(ledger_path: &Path, ticks_per_slot: usize) {
-    let ledger = Blocktree::open(ledger_path).unwrap();
+    let ledger = Blockstore::open(ledger_path).unwrap();
     let zeroth_slot = ledger.get_slot_entries(0, 0, None).unwrap();
     let last_id = zeroth_slot.last().unwrap().hash;
     let next_slots = ledger.get_slots_since(&[0]).unwrap().remove(&0).unwrap();
@@ -301,19 +301,23 @@ fn poll_all_nodes_for_signature(
     Ok(())
 }
 
-fn get_and_verify_slot_entries(blocktree: &Blocktree, slot: Slot, last_entry: &Hash) -> Vec<Entry> {
-    let entries = blocktree.get_slot_entries(slot, 0, None).unwrap();
+fn get_and_verify_slot_entries(
+    blockstore: &Blockstore,
+    slot: Slot,
+    last_entry: &Hash,
+) -> Vec<Entry> {
+    let entries = blockstore.get_slot_entries(slot, 0, None).unwrap();
     assert_eq!(entries.verify(last_entry), true);
     entries
 }
 
 fn verify_slot_ticks(
-    blocktree: &Blocktree,
+    blockstore: &Blockstore,
     slot: Slot,
     last_entry: &Hash,
     expected_num_ticks: Option<usize>,
 ) -> Hash {
-    let entries = get_and_verify_slot_entries(blocktree, slot, last_entry);
+    let entries = get_and_verify_slot_entries(blockstore, slot, last_entry);
     let num_ticks: usize = entries.iter().map(|entry| entry.is_tick() as usize).sum();
     if let Some(expected_num_ticks) = expected_num_ticks {
         assert_eq!(num_ticks, expected_num_ticks);

local-cluster/tests/archiver.rs

@@ -9,7 +9,7 @@ use solana_core::{
     storage_stage::SLOTS_PER_TURN_TEST,
     validator::ValidatorConfig,
 };
-use solana_ledger::{blocktree::Blocktree, create_new_tmp_ledger, get_tmp_ledger_path};
+use solana_ledger::{blockstore::Blockstore, create_new_tmp_ledger, get_tmp_ledger_path};
 use solana_local_cluster::local_cluster::{ClusterConfig, LocalCluster};
 use solana_sdk::{
     commitment_config::CommitmentConfig,
@@ -62,9 +62,14 @@ fn run_archiver_startup_basic(num_nodes: usize, num_archivers: usize) {
         cluster_nodes[0].clone(),
     )));
     let path = get_tmp_ledger_path!();
-    let blocktree = Arc::new(Blocktree::open(&path).unwrap());
-    Archiver::download_from_archiver(&cluster_info, &archiver_info, &blocktree, slots_per_segment)
-        .unwrap();
+    let blockstore = Arc::new(Blockstore::open(&path).unwrap());
+    Archiver::download_from_archiver(
+        &cluster_info,
+        &archiver_info,
+        &blockstore,
+        slots_per_segment,
+    )
+    .unwrap();
 }
 
 #[test]
@@ -113,8 +118,8 @@ fn test_archiver_startup_leader_hang() {
         assert!(archiver_res.is_err());
     }
 
-    let _ignored = Blocktree::destroy(&leader_ledger_path);
-    let _ignored = Blocktree::destroy(&archiver_ledger_path);
+    let _ignored = Blockstore::destroy(&leader_ledger_path);
+    let _ignored = Blockstore::destroy(&archiver_ledger_path);
     let _ignored = remove_dir_all(&leader_ledger_path);
     let _ignored = remove_dir_all(&archiver_ledger_path);
 }

local-cluster/tests/local_cluster.rs

@@ -10,7 +10,7 @@ use solana_core::{
     validator::ValidatorConfig,
 };
 use solana_ledger::{
-    bank_forks::SnapshotConfig, blocktree::Blocktree, leader_schedule::FixedSchedule,
+    bank_forks::SnapshotConfig, blockstore::Blockstore, leader_schedule::FixedSchedule,
     leader_schedule::LeaderSchedule, snapshot_utils,
 };
 use solana_local_cluster::{
@@ -67,12 +67,12 @@ fn test_ledger_cleanup_service() {
     //check everyone's ledgers and make sure only ~100 slots are stored
     for (_, info) in &cluster.validators {
         let mut slots = 0;
-        let blocktree = Blocktree::open(&info.info.ledger_path).unwrap();
-        blocktree
+        let blockstore = Blockstore::open(&info.info.ledger_path).unwrap();
+        blockstore
             .slot_meta_iterator(0)
             .unwrap()
             .for_each(|_| slots += 1);
-        // with 3 nodes upto 3 slots can be in progress and not complete so max slots in blocktree should be upto 103
+        // with 3 nodes upto 3 slots can be in progress and not complete so max slots in blockstore should be upto 103
         assert!(slots <= 103, "got {}", slots);
     }
 }
@@ -674,7 +674,7 @@ fn test_snapshot_restart_tower() {
 
 #[test]
 #[serial]
-fn test_snapshots_blocktree_floor() {
+fn test_snapshots_blockstore_floor() {
     // First set up the cluster with 1 snapshotting leader
     let snapshot_interval_slots = 10;
     let num_account_paths = 4;
@@ -747,10 +747,10 @@ fn test_snapshots_blocktree_floor() {
     // Check the validator ledger doesn't contain any slots < slot_floor
     cluster.close_preserve_ledgers();
     let validator_ledger_path = &cluster.validators[&validator_id];
-    let blocktree = Blocktree::open(&validator_ledger_path.info.ledger_path).unwrap();
+    let blockstore = Blockstore::open(&validator_ledger_path.info.ledger_path).unwrap();
 
-    // Skip the zeroth slot in blocktree that the ledger is initialized with
-    let (first_slot, _) = blocktree.slot_meta_iterator(1).unwrap().next().unwrap();
+    // Skip the zeroth slot in blockstore that the ledger is initialized with
+    let (first_slot, _) = blockstore.slot_meta_iterator(1).unwrap().next().unwrap();
 
     assert_eq!(first_slot, slot_floor);
 }
@@ -932,7 +932,7 @@ fn test_no_voting() {
     cluster.close_preserve_ledgers();
     let leader_pubkey = cluster.entry_point_info.id;
     let ledger_path = cluster.validators[&leader_pubkey].info.ledger_path.clone();
-    let ledger = Blocktree::open(&ledger_path).unwrap();
+    let ledger = Blockstore::open(&ledger_path).unwrap();
     for i in 0..2 * VOTE_THRESHOLD_DEPTH {
         let meta = ledger.meta(i as u64).unwrap().unwrap();
         let parent = meta.parent_slot;