Add SnapshotArchiveInfo and refactor functions in snapshot_utils

core/src/snapshot_packager_service.rs

@@ -156,9 +156,10 @@ mod tests {
         }
 
         // Create a packageable snapshot
-        let output_tar_path = snapshot_utils::get_snapshot_archive_path(
+        let output_tar_path = snapshot_utils::build_snapshot_archive_path(
             snapshot_package_output_path,
-            &(42, Hash::default()),
+            42,
+            &Hash::default(),
             ArchiveFormat::TarBzip2,
         );
         let snapshot_package = AccountsPackage::new(

core/tests/snapshots.rs

@@ -148,17 +148,18 @@ mod tests {
         let old_last_bank = old_bank_forks.get(old_last_slot).unwrap();
 
         let check_hash_calculation = false;
-        let (deserialized_bank, _timing) = snapshot_utils::bank_from_archive(
+        let (deserialized_bank, _timing) = snapshot_utils::bank_from_snapshot_archive(
             account_paths,
             &[],
             &old_bank_forks
                 .snapshot_config
                 .as_ref()
                 .unwrap()
                 .snapshot_path,
-            snapshot_utils::get_snapshot_archive_path(
+            snapshot_utils::build_snapshot_archive_path(
                 snapshot_package_output_path.to_path_buf(),
-                &(old_last_bank.slot(), old_last_bank.get_accounts_hash()),
+                old_last_bank.slot(),
+                &old_last_bank.get_accounts_hash(),
                 ArchiveFormat::TarBzip2,
             ),
             ArchiveFormat::TarBzip2,
@@ -418,9 +419,10 @@ mod tests {
                 let options = CopyOptions::new();
                 fs_extra::dir::copy(&last_snapshot_path, &saved_snapshots_dir, &options).unwrap();
 
-                saved_archive_path = Some(snapshot_utils::get_snapshot_archive_path(
+                saved_archive_path = Some(snapshot_utils::build_snapshot_archive_path(
                     snapshot_package_output_path.to_path_buf(),
-                    &(slot, accounts_hash),
+                    slot,
+                    &accounts_hash,
                     ArchiveFormat::TarBzip2,
                 ));
             }

download-utils/src/lib.rs

@@ -259,9 +259,10 @@ pub fn download_snapshot<'a, 'b>(
         ArchiveFormat::TarGzip,
         ArchiveFormat::TarBzip2,
     ] {
-        let desired_snapshot_package = snapshot_utils::get_snapshot_archive_path(
+        let desired_snapshot_package = snapshot_utils::build_snapshot_archive_path(
             snapshot_output_dir.to_path_buf(),
-            &desired_snapshot_hash,
+            desired_snapshot_hash.0,
+            &desired_snapshot_hash.1,
             *compression,
         );
 

ledger/src/bank_forks_utils.rs

@@ -11,7 +11,7 @@ use log::*;
 use solana_runtime::{
     bank_forks::BankForks,
     snapshot_config::SnapshotConfig,
-    snapshot_utils::{self, ArchiveFormat},
+    snapshot_utils::{self, SnapshotArchiveInfo},
 };
 use solana_sdk::{clock::Slot, genesis_config::GenesisConfig, hash::Hash};
 use std::{fs, path::PathBuf, process, result};
@@ -53,11 +53,9 @@ pub fn load(
         fs::create_dir_all(&snapshot_config.snapshot_path)
             .expect("Couldn't create snapshot directory");
 
-        if let Some((archive_filename, (archive_slot, archive_hash, archive_format))) =
-            snapshot_utils::get_highest_snapshot_archive_path(
-                &snapshot_config.snapshot_package_output_path,
-            )
-        {
+        if let Some(snapshot_archive_info) = snapshot_utils::get_highest_snapshot_archive_info(
+            &snapshot_config.snapshot_package_output_path,
+        ) {
             return load_from_snapshot(
                 genesis_config,
                 blockstore,
@@ -67,10 +65,7 @@ pub fn load(
                 process_options,
                 transaction_status_sender,
                 cache_block_meta_sender,
-                archive_filename,
-                archive_slot,
-                archive_hash,
-                archive_format,
+                &snapshot_archive_info,
             );
         } else {
             info!("No snapshot package available; will load from genesis");
@@ -118,25 +113,25 @@ fn load_from_snapshot(
     process_options: ProcessOptions,
     transaction_status_sender: Option<&TransactionStatusSender>,
     cache_block_meta_sender: Option<&CacheBlockMetaSender>,
-    archive_filename: PathBuf,
-    archive_slot: Slot,
-    archive_hash: Hash,
-    archive_format: ArchiveFormat,
+    snapshot_archive_info: &SnapshotArchiveInfo,
 ) -> LoadResult {
-    info!("Loading snapshot package: {:?}", archive_filename);
+    info!(
+        "Loading snapshot package: {:?}",
+        &snapshot_archive_info.path
+    );
 
     // Fail hard here if snapshot fails to load, don't silently continue
     if account_paths.is_empty() {
         error!("Account paths not present when booting from snapshot");
         process::exit(1);
     }
 
-    let (deserialized_bank, timings) = snapshot_utils::bank_from_archive(
+    let (deserialized_bank, timings) = snapshot_utils::bank_from_snapshot_archive(
         &account_paths,
         &process_options.frozen_accounts,
         &snapshot_config.snapshot_path,
-        &archive_filename,
-        archive_format,
+        &snapshot_archive_info.path,
+        snapshot_archive_info.archive_format,
         genesis_config,
         process_options.debug_keys.clone(),
         Some(&crate::builtins::get(process_options.bpf_jit)),
@@ -156,10 +151,11 @@ fn load_from_snapshot(
         deserialized_bank.get_accounts_hash(),
     );
 
-    if deserialized_bank_slot_and_hash != (archive_slot, archive_hash) {
+    if deserialized_bank_slot_and_hash != (snapshot_archive_info.slot, snapshot_archive_info.hash) {
         error!(
             "Snapshot has mismatch:\narchive: {:?}\ndeserialized: {:?}",
-            archive_hash, deserialized_bank_slot_and_hash
+            (snapshot_archive_info.slot, snapshot_archive_info.hash),
+            deserialized_bank_slot_and_hash
         );
         process::exit(1);
     }

local-cluster/tests/local_cluster.rs

@@ -1671,12 +1671,13 @@ fn test_snapshot_download() {
         wait_for_next_snapshot(&cluster, snapshot_package_output_path);
 
     trace!("found: {:?}", archive_filename);
-    let validator_archive_path = snapshot_utils::get_snapshot_archive_path(
+    let validator_archive_path = snapshot_utils::build_snapshot_archive_path(
         validator_snapshot_test_config
             .snapshot_output_path
             .path()
             .to_path_buf(),
-        &archive_snapshot_hash,
+        archive_snapshot_hash.0,
+        &archive_snapshot_hash.1,
         ArchiveFormat::TarBzip2,
     );
 
@@ -1746,12 +1747,13 @@ fn test_snapshot_restart_tower() {
         wait_for_next_snapshot(&cluster, snapshot_package_output_path);
 
     // Copy archive to validator's snapshot output directory
-    let validator_archive_path = snapshot_utils::get_snapshot_archive_path(
+    let validator_archive_path = snapshot_utils::build_snapshot_archive_path(
         validator_snapshot_test_config
             .snapshot_output_path
             .path()
             .to_path_buf(),
-        &archive_snapshot_hash,
+        archive_snapshot_hash.0,
+        &archive_snapshot_hash.1,
         ArchiveFormat::TarBzip2,
     );
     fs::hard_link(archive_filename, &validator_archive_path).unwrap();
@@ -1806,9 +1808,9 @@ fn test_snapshots_blockstore_floor() {
 
     trace!("Waiting for snapshot tar to be generated with slot",);
 
-    let (archive_filename, (archive_slot, archive_hash, _)) = loop {
+    let archive_info = loop {
         let archive =
-            snapshot_utils::get_highest_snapshot_archive_path(&snapshot_package_output_path);
+            snapshot_utils::get_highest_snapshot_archive_info(&snapshot_package_output_path);
         if archive.is_some() {
             trace!("snapshot exists");
             break archive.unwrap();
@@ -1817,16 +1819,17 @@ fn test_snapshots_blockstore_floor() {
     };
 
     // Copy archive to validator's snapshot output directory
-    let validator_archive_path = snapshot_utils::get_snapshot_archive_path(
+    let validator_archive_path = snapshot_utils::build_snapshot_archive_path(
         validator_snapshot_test_config
             .snapshot_output_path
             .path()
             .to_path_buf(),
-        &(archive_slot, archive_hash),
+        archive_info.slot,
+        &archive_info.hash,
         ArchiveFormat::TarBzip2,
     );
-    fs::hard_link(archive_filename, &validator_archive_path).unwrap();
-    let slot_floor = archive_slot;
+    fs::hard_link(archive_info.path, &validator_archive_path).unwrap();
+    let slot_floor = archive_info.slot;
 
     // Start up a new node from a snapshot
     let validator_stake = 5;
@@ -3122,14 +3125,21 @@ fn wait_for_next_snapshot(
         last_slot
     );
     loop {
-        if let Some((filename, (slot, hash, _))) =
-            snapshot_utils::get_highest_snapshot_archive_path(snapshot_package_output_path)
+        if let Some(snapshot_archive_info) =
+            snapshot_utils::get_highest_snapshot_archive_info(snapshot_package_output_path)
         {
-            trace!("snapshot for slot {} exists", slot);
-            if slot >= last_slot {
-                return (filename, (slot, hash));
+            trace!("snapshot for slot {} exists", snapshot_archive_info.slot);
+            if snapshot_archive_info.slot >= last_slot {
+                return (
+                    snapshot_archive_info.path,
+                    (snapshot_archive_info.slot, snapshot_archive_info.hash),
+                );
             }
-            trace!("snapshot slot {} < last_slot {}", slot, last_slot);
+            trace!(
+                "snapshot slot {} < last_slot {}",
+                snapshot_archive_info.slot,
+                last_slot
+            );
         }
         sleep(Duration::from_millis(5000));
     }

rpc/src/rpc.rs

@@ -49,7 +49,7 @@ use {
         inline_spl_token_v2_0::{SPL_TOKEN_ACCOUNT_MINT_OFFSET, SPL_TOKEN_ACCOUNT_OWNER_OFFSET},
         non_circulating_supply::calculate_non_circulating_supply,
         snapshot_config::SnapshotConfig,
-        snapshot_utils::get_highest_snapshot_archive_path,
+        snapshot_utils,
     },
     solana_sdk::{
         account::{AccountSharedData, ReadableAccount},
@@ -2255,8 +2255,9 @@ pub mod rpc_minimal {
 
             meta.snapshot_config
                 .and_then(|snapshot_config| {
-                    get_highest_snapshot_archive_path(&snapshot_config.snapshot_package_output_path)
-                        .map(|(_, (slot, _, _))| slot)
+                    snapshot_utils::get_highest_snapshot_archive_slot(
+                        &snapshot_config.snapshot_package_output_path,
+                    )
                 })
                 .ok_or_else(|| RpcCustomError::NoSnapshot.into())
         }

rpc/src/rpc_service.rs

@@ -198,13 +198,14 @@ impl RequestMiddleware for RpcRequestMiddleware {
         if let Some(ref snapshot_config) = self.snapshot_config {
             if request.uri().path() == "/snapshot.tar.bz2" {
                 // Convenience redirect to the latest snapshot
-                return if let Some((snapshot_archive, _)) =
-                    snapshot_utils::get_highest_snapshot_archive_path(
+                return if let Some(snapshot_archive_info) =
+                    snapshot_utils::get_highest_snapshot_archive_info(
                         &snapshot_config.snapshot_package_output_path,
                     ) {
                     RpcRequestMiddleware::redirect(&format!(
                         "/{}",
-                        snapshot_archive
+                        snapshot_archive_info
+                            .path
                             .file_name()
                             .unwrap_or_else(|| std::ffi::OsStr::new(""))
                             .to_str()