Splitting snapshot type into snapshot type and snapshot archive type (#9050)

* Splitting snapshot type into snapshot type and archive type

* Improve error message for snapshot kind check

* Change name from ArchiveKind to SnapshotArchiveKind

* Encapsulating SnapshotArchiveKind into SnapshotKind

* Apply suggestion from @brooksprumo

Co-authored-by: Brooks <brooks@prumo.org>

* Apply suggestion from @brooksprumo

Co-authored-by: Brooks <brooks@prumo.org>

* Limit line length to 100 characters

* Revert "Limit line length to 100 characters"

This reverts commit 322dc31961e140cde09852aec785e6f1b41cb060.

* Limit correct comment to 100 characters

* Port Brooks:  adds cmp_snapshot_archive_kinds_by_priority

---------

Co-authored-by: Brooks <brooks@prumo.org>
Co-authored-by: brooks <brooks@anza.xyz>

core/src/snapshot_packager_service/snapshot_gossip_manager.rs

@@ -3,7 +3,7 @@ use {
         snapshot_hash::{
             FullSnapshotHash, IncrementalSnapshotHash, SnapshotHash, StartingSnapshotHashes,
         },
-        SnapshotKind,
+        SnapshotArchiveKind, SnapshotKind,
     },
     solana_clock::Slot,
     solana_gossip::cluster_info::ClusterInfo,
@@ -54,10 +54,10 @@ impl SnapshotGossipManager {
         snapshot_hash: (Slot, SnapshotHash),
     ) {
         match snapshot_kind {
-            SnapshotKind::FullSnapshot => {
+            SnapshotKind::Archive(SnapshotArchiveKind::Full) => {
                 self.push_full_snapshot_hash(FullSnapshotHash(snapshot_hash));
             }
-            SnapshotKind::IncrementalSnapshot(base_slot) => {
+            SnapshotKind::Archive(SnapshotArchiveKind::Incremental(base_slot)) => {
                 self.push_incremental_snapshot_hash(
                     IncrementalSnapshotHash(snapshot_hash),
                     base_slot,

download-utils/src/lib.rs

@@ -10,7 +10,7 @@
 pub use solana_file_download::DownloadProgressRecord;
 use {
     agave_snapshots::{
-        paths as snapshot_paths, snapshot_hash::SnapshotHash, ArchiveFormat, SnapshotKind,
+        paths as snapshot_paths, snapshot_hash::SnapshotHash, ArchiveFormat, SnapshotArchiveKind,
         ZstdConfig,
     },
     log::*,
@@ -56,7 +56,7 @@ pub fn download_snapshot_archive(
     full_snapshot_archives_dir: &Path,
     incremental_snapshot_archives_dir: &Path,
     desired_snapshot_hash: (Slot, SnapshotHash),
-    snapshot_kind: SnapshotKind,
+    snapshot_kind: SnapshotArchiveKind,
     maximum_full_snapshot_archives_to_retain: NonZeroUsize,
     maximum_incremental_snapshot_archives_to_retain: NonZeroUsize,
     use_progress_bar: bool,
@@ -71,8 +71,8 @@ pub fn download_snapshot_archive(
 
     let snapshot_archives_remote_dir =
         snapshot_paths::build_snapshot_archives_remote_dir(match snapshot_kind {
-            SnapshotKind::FullSnapshot => full_snapshot_archives_dir,
-            SnapshotKind::IncrementalSnapshot(_) => incremental_snapshot_archives_dir,
+            SnapshotArchiveKind::Full => full_snapshot_archives_dir,
+            SnapshotArchiveKind::Incremental(_) => incremental_snapshot_archives_dir,
         });
     fs::create_dir_all(&snapshot_archives_remote_dir).unwrap();
 
@@ -83,13 +83,13 @@ pub fn download_snapshot_archive(
         ArchiveFormat::TarLz4,
     ] {
         let destination_path = match snapshot_kind {
-            SnapshotKind::FullSnapshot => snapshot_paths::build_full_snapshot_archive_path(
+            SnapshotArchiveKind::Full => snapshot_paths::build_full_snapshot_archive_path(
                 &snapshot_archives_remote_dir,
                 desired_snapshot_hash.0,
                 &desired_snapshot_hash.1,
                 archive_format,
             ),
-            SnapshotKind::IncrementalSnapshot(base_slot) => {
+            SnapshotArchiveKind::Incremental(base_slot) => {
                 snapshot_paths::build_incremental_snapshot_archive_path(
                     &snapshot_archives_remote_dir,
                     base_slot,

local-cluster/tests/local_cluster.rs

@@ -2,7 +2,7 @@
 use {
     agave_snapshots::{
         paths as snapshot_paths, snapshot_archive_info::SnapshotArchiveInfoGetter,
-        snapshot_config::SnapshotConfig, SnapshotInterval, SnapshotKind,
+        snapshot_config::SnapshotConfig, SnapshotArchiveKind, SnapshotInterval,
     },
     assert_matches::assert_matches,
     crossbeam_channel::{unbounded, Receiver},
@@ -526,7 +526,7 @@ fn test_snapshot_download() {
             full_snapshot_archive_info.slot(),
             *full_snapshot_archive_info.hash(),
         ),
-        SnapshotKind::FullSnapshot,
+        SnapshotArchiveKind::Full,
         validator_snapshot_test_config
             .validator_config
             .snapshot_config
@@ -655,7 +655,7 @@ fn test_incremental_snapshot_download() {
             full_snapshot_archive_info.slot(),
             *full_snapshot_archive_info.hash(),
         ),
-        SnapshotKind::FullSnapshot,
+        SnapshotArchiveKind::Full,
         validator_snapshot_test_config
             .validator_config
             .snapshot_config
@@ -683,7 +683,7 @@ fn test_incremental_snapshot_download() {
             incremental_snapshot_archive_info.slot(),
             *incremental_snapshot_archive_info.hash(),
         ),
-        SnapshotKind::IncrementalSnapshot(incremental_snapshot_archive_info.base_slot()),
+        SnapshotArchiveKind::Incremental(incremental_snapshot_archive_info.base_slot()),
         validator_snapshot_test_config
             .validator_config
             .snapshot_config
@@ -828,7 +828,7 @@ fn test_incremental_snapshot_download_with_crossing_full_snapshot_interval_at_st
             .incremental_snapshot_archives_dir
             .path(),
         (full_snapshot_archive.slot(), *full_snapshot_archive.hash()),
-        SnapshotKind::FullSnapshot,
+        SnapshotArchiveKind::Full,
         validator_snapshot_test_config
             .validator_config
             .snapshot_config
@@ -865,7 +865,7 @@ fn test_incremental_snapshot_download_with_crossing_full_snapshot_interval_at_st
             incremental_snapshot_archive.slot(),
             *incremental_snapshot_archive.hash(),
         ),
-        SnapshotKind::IncrementalSnapshot(incremental_snapshot_archive.base_slot()),
+        SnapshotArchiveKind::Incremental(incremental_snapshot_archive.base_slot()),
         validator_snapshot_test_config
             .validator_config
             .snapshot_config

runtime/src/accounts_background_service.rs

@@ -14,7 +14,7 @@ use {
         snapshot_controller::SnapshotController,
         snapshot_package::SnapshotPackage,
     },
-    agave_snapshots::{error::SnapshotError, SnapshotKind},
+    agave_snapshots::{error::SnapshotError, SnapshotArchiveKind, SnapshotKind},
     crossbeam_channel::{Receiver, SendError, Sender},
     log::*,
     rayon::iter::{IntoParallelIterator, ParallelIterator},
@@ -645,7 +645,7 @@ impl AbsStatus {
 #[must_use]
 fn new_snapshot_kind(snapshot_request: &SnapshotRequest) -> Option<SnapshotKind> {
     match snapshot_request.request_kind {
-        SnapshotRequestKind::FullSnapshot => Some(SnapshotKind::FullSnapshot),
+        SnapshotRequestKind::FullSnapshot => Some(SnapshotKind::Archive(SnapshotArchiveKind::Full)),
         SnapshotRequestKind::IncrementalSnapshot => {
             if let Some(latest_full_snapshot_slot) = snapshot_request
                 .snapshot_root_bank
@@ -654,7 +654,9 @@ fn new_snapshot_kind(snapshot_request: &SnapshotRequest) -> Option<SnapshotKind>
                 .accounts_db
                 .latest_full_snapshot_slot()
             {
-                Some(SnapshotKind::IncrementalSnapshot(latest_full_snapshot_slot))
+                Some(SnapshotKind::Archive(SnapshotArchiveKind::Incremental(
+                    latest_full_snapshot_slot,
+                )))
             } else {
                 warn!(
                     "Ignoring IncrementalSnapshot request for slot {} because there is no latest \

runtime/src/accounts_background_service/pending_snapshot_packages.rs

@@ -1,6 +1,6 @@
 use {
     crate::snapshot_package::{cmp_snapshot_packages_by_priority, SnapshotPackage},
-    agave_snapshots::SnapshotKind,
+    agave_snapshots::{SnapshotArchiveKind, SnapshotKind},
     log::*,
     std::cmp::Ordering::Greater,
 };
@@ -21,7 +21,7 @@ impl PendingSnapshotPackages {
     /// than any currently-pending in-kind packages.
     pub fn push(&mut self, snapshot_package: SnapshotPackage) {
         match snapshot_package.snapshot_kind {
-            SnapshotKind::FullSnapshot => {
+            SnapshotKind::Archive(SnapshotArchiveKind::Full) => {
                 if let Some(pending_full_snapshot_package) = self.full.as_ref() {
                     // snapshots are monotonically increasing; only overwrite *old* packages
                     assert!(pending_full_snapshot_package
@@ -43,7 +43,7 @@ impl PendingSnapshotPackages {
                 }
                 self.full = Some(snapshot_package)
             }
-            SnapshotKind::IncrementalSnapshot(_) => {
+            SnapshotKind::Archive(SnapshotArchiveKind::Incremental(_)) => {
                 if let Some(pending_incremental_snapshot_package) = self.incremental.as_ref() {
                     // snapshots are monotonically increasing; only overwrite *old* packages
                     assert!(pending_incremental_snapshot_package
@@ -82,7 +82,7 @@ impl PendingSnapshotPackages {
                 // slots *older* than the latest full snapshot.  This is why we do not
                 // re-enqueue every incremental snapshot.
                 if let Some(pending_incremental) = pending_incremental {
-                    let SnapshotKind::IncrementalSnapshot(base_slot) =
+                    let SnapshotKind::Archive(SnapshotArchiveKind::Incremental(base_slot)) =
                         &pending_incremental.snapshot_kind
                     else {
                         panic!(
@@ -122,10 +122,13 @@ mod tests {
         }
     }
     fn new_full(slot: Slot) -> SnapshotPackage {
-        new(SnapshotKind::FullSnapshot, slot)
+        new(SnapshotKind::Archive(SnapshotArchiveKind::Full), slot)
     }
     fn new_incr(slot: Slot, base: Slot) -> SnapshotPackage {
-        new(SnapshotKind::IncrementalSnapshot(base), slot)
+        new(
+            SnapshotKind::Archive(SnapshotArchiveKind::Incremental(base)),
+            slot,
+        )
     }
 
     #[test]

runtime/src/snapshot_bank_utils.rs

@@ -39,7 +39,7 @@ use {
         },
         snapshot_config::SnapshotConfig,
         snapshot_hash::SnapshotHash,
-        ArchiveFormat, SnapshotKind, SnapshotVersion,
+        ArchiveFormat, SnapshotArchiveKind, SnapshotKind, SnapshotVersion,
     },
     log::*,
     solana_accounts_db::{
@@ -692,7 +692,7 @@ fn bank_to_full_snapshot_archive_with(
     bank.clean_accounts();
 
     let snapshot_package = SnapshotPackage::new(
-        SnapshotKind::FullSnapshot,
+        SnapshotKind::Archive(SnapshotArchiveKind::Full),
         bank,
         bank.get_snapshot_storages(None),
         bank.status_cache.read().unwrap().root_slot_deltas(),
@@ -747,7 +747,7 @@ pub fn bank_to_incremental_snapshot_archive(
     bank.clean_accounts();
 
     let snapshot_package = SnapshotPackage::new(
-        SnapshotKind::IncrementalSnapshot(full_snapshot_slot),
+        SnapshotKind::Archive(SnapshotArchiveKind::Incremental(full_snapshot_slot)),
         bank,
         bank.get_snapshot_storages(Some(full_snapshot_slot)),
         bank.status_cache.read().unwrap().root_slot_deltas(),

runtime/src/snapshot_package.rs

@@ -2,7 +2,7 @@
 use solana_hash::Hash;
 use {
     crate::bank::{Bank, BankFieldsToSerialize, BankHashStats, BankSlotDelta},
-    agave_snapshots::{snapshot_hash::SnapshotHash, SnapshotKind},
+    agave_snapshots::{snapshot_hash::SnapshotHash, SnapshotArchiveKind, SnapshotKind},
     solana_accounts_db::accounts_db::AccountStorageEntry,
     solana_clock::Slot,
     std::{
@@ -39,7 +39,10 @@ impl SnapshotPackage {
         status_cache_slot_deltas: Vec<BankSlotDelta>,
     ) -> Self {
         let slot = bank.slot();
-        if let SnapshotKind::IncrementalSnapshot(incremental_snapshot_base_slot) = snapshot_kind {
+        if let SnapshotKind::Archive(SnapshotArchiveKind::Incremental(
+            incremental_snapshot_base_slot,
+        )) = snapshot_kind
+        {
             assert!(
                 slot > incremental_snapshot_base_slot,
                 "Incremental snapshot base slot must be less than the bank being snapshotted!"
@@ -73,7 +76,7 @@ impl SnapshotPackage {
     /// Only use for tests; many of the fields are invalid!
     pub fn default_for_tests() -> Self {
         Self {
-            snapshot_kind: SnapshotKind::FullSnapshot,
+            snapshot_kind: SnapshotKind::Archive(SnapshotArchiveKind::Full),
             slot: Slot::default(),
             block_height: Slot::default(),
             hash: SnapshotHash(Hash::default()),

runtime/src/snapshot_package/compare.rs

@@ -1,26 +1,40 @@
 use {
-    super::{SnapshotKind, SnapshotPackage},
+    super::{SnapshotArchiveKind, SnapshotKind, SnapshotPackage},
     std::cmp::Ordering::{self, Equal, Greater, Less},
 };
 
-/// Compare snapshot packages by priority; first by type, then by slot
+/// Compare snapshot packages by priority; first by kind, then by slot
 #[must_use]
 pub fn cmp_snapshot_packages_by_priority(a: &SnapshotPackage, b: &SnapshotPackage) -> Ordering {
     cmp_snapshot_kinds_by_priority(&a.snapshot_kind, &b.snapshot_kind).then(a.slot.cmp(&b.slot))
 }
 
 /// Compare snapshot kinds by priority
-///
-/// Full snapshots are higher in priority than incremental snapshots.
-/// If two `IncrementalSnapshot`s are compared, their base slots are the tiebreaker.
 #[must_use]
 pub fn cmp_snapshot_kinds_by_priority(a: &SnapshotKind, b: &SnapshotKind) -> Ordering {
     use SnapshotKind as Kind;
     match (a, b) {
-        (Kind::FullSnapshot, Kind::FullSnapshot) => Equal,
-        (Kind::FullSnapshot, Kind::IncrementalSnapshot(_)) => Greater,
-        (Kind::IncrementalSnapshot(_), Kind::FullSnapshot) => Less,
-        (Kind::IncrementalSnapshot(base_slot_a), Kind::IncrementalSnapshot(base_slot_b)) => {
+        (Kind::Archive(snapshot_archive_kind_a), Kind::Archive(snapshot_archive_kind_b)) => {
+            cmp_snapshot_archive_kinds_by_priority(snapshot_archive_kind_a, snapshot_archive_kind_b)
+        }
+    }
+}
+
+/// Compare snapshot archive kinds by priority
+///
+/// Full snapshot archives are higher in priority than incremental snapshot archives.
+/// If two `Incremental`s are compared, their base slots are the tiebreaker.
+#[must_use]
+pub fn cmp_snapshot_archive_kinds_by_priority(
+    a: &SnapshotArchiveKind,
+    b: &SnapshotArchiveKind,
+) -> Ordering {
+    use SnapshotArchiveKind as Kind;
+    match (a, b) {
+        (Kind::Full, Kind::Full) => Equal,
+        (Kind::Full, Kind::Incremental(_)) => Greater,
+        (Kind::Incremental(_), Kind::Full) => Less,
+        (Kind::Incremental(base_slot_a), Kind::Incremental(base_slot_b)) => {
             base_slot_a.cmp(base_slot_b)
         }
     }
@@ -43,53 +57,92 @@ mod tests {
 
         for (snapshot_package_a, snapshot_package_b, expected_result) in [
             (
-                new(SnapshotKind::FullSnapshot, 11),
-                new(SnapshotKind::FullSnapshot, 22),
+                new(SnapshotKind::Archive(SnapshotArchiveKind::Full), 11),
+                new(SnapshotKind::Archive(SnapshotArchiveKind::Full), 22),
                 Less,
             ),
             (
-                new(SnapshotKind::FullSnapshot, 22),
-                new(SnapshotKind::FullSnapshot, 22),
+                new(SnapshotKind::Archive(SnapshotArchiveKind::Full), 22),
+                new(SnapshotKind::Archive(SnapshotArchiveKind::Full), 22),
                 Equal,
             ),
             (
-                new(SnapshotKind::FullSnapshot, 33),
-                new(SnapshotKind::FullSnapshot, 22),
+                new(SnapshotKind::Archive(SnapshotArchiveKind::Full), 33),
+                new(SnapshotKind::Archive(SnapshotArchiveKind::Full), 22),
                 Greater,
             ),
             (
-                new(SnapshotKind::FullSnapshot, 22),
-                new(SnapshotKind::IncrementalSnapshot(88), 99),
+                new(SnapshotKind::Archive(SnapshotArchiveKind::Full), 22),
+                new(
+                    SnapshotKind::Archive(SnapshotArchiveKind::Incremental(88)),
+                    99,
+                ),
                 Greater,
             ),
             (
-                new(SnapshotKind::IncrementalSnapshot(11), 55),
-                new(SnapshotKind::IncrementalSnapshot(22), 55),
+                new(
+                    SnapshotKind::Archive(SnapshotArchiveKind::Incremental(11)),
+                    55,
+                ),
+                new(
+                    SnapshotKind::Archive(SnapshotArchiveKind::Incremental(22)),
+                    55,
+                ),
                 Less,
             ),
             (
-                new(SnapshotKind::IncrementalSnapshot(22), 55),
-                new(SnapshotKind::IncrementalSnapshot(22), 55),
+                new(
+                    SnapshotKind::Archive(SnapshotArchiveKind::Incremental(22)),
+                    55,
+                ),
+                new(
+                    SnapshotKind::Archive(SnapshotArchiveKind::Incremental(22)),
+                    55,
+                ),
                 Equal,
             ),
             (
-                new(SnapshotKind::IncrementalSnapshot(33), 55),
-                new(SnapshotKind::IncrementalSnapshot(22), 55),
+                new(
+                    SnapshotKind::Archive(SnapshotArchiveKind::Incremental(33)),
+                    55,
+                ),
+                new(
+                    SnapshotKind::Archive(SnapshotArchiveKind::Incremental(22)),
+                    55,
+                ),
                 Greater,
             ),
             (
-                new(SnapshotKind::IncrementalSnapshot(22), 44),
-                new(SnapshotKind::IncrementalSnapshot(22), 55),
+                new(
+                    SnapshotKind::Archive(SnapshotArchiveKind::Incremental(22)),
+                    44,
+                ),
+                new(
+                    SnapshotKind::Archive(SnapshotArchiveKind::Incremental(22)),
+                    55,
+                ),
                 Less,
             ),
             (
-                new(SnapshotKind::IncrementalSnapshot(22), 55),
-                new(SnapshotKind::IncrementalSnapshot(22), 55),
+                new(
+                    SnapshotKind::Archive(SnapshotArchiveKind::Incremental(22)),
+                    55,
+                ),
+                new(
+                    SnapshotKind::Archive(SnapshotArchiveKind::Incremental(22)),
+                    55,
+                ),
                 Equal,
             ),
             (
-                new(SnapshotKind::IncrementalSnapshot(22), 66),
-                new(SnapshotKind::IncrementalSnapshot(22), 55),
+                new(
+                    SnapshotKind::Archive(SnapshotArchiveKind::Incremental(22)),
+                    66,
+                ),
+                new(
+                    SnapshotKind::Archive(SnapshotArchiveKind::Incremental(22)),
+                    55,
+                ),
                 Greater,
             ),
         ] {
@@ -103,33 +156,33 @@ mod tests {
     fn test_cmp_snapshot_kinds_by_priority() {
         for (snapshot_kind_a, snapshot_kind_b, expected_result) in [
             (
-                SnapshotKind::FullSnapshot,
-                SnapshotKind::FullSnapshot,
+                SnapshotKind::Archive(SnapshotArchiveKind::Full),
+                SnapshotKind::Archive(SnapshotArchiveKind::Full),
                 Equal,
             ),
             (
-                SnapshotKind::FullSnapshot,
-                SnapshotKind::IncrementalSnapshot(5),
+                SnapshotKind::Archive(SnapshotArchiveKind::Full),
+                SnapshotKind::Archive(SnapshotArchiveKind::Incremental(5)),
                 Greater,
             ),
             (
-                SnapshotKind::IncrementalSnapshot(5),
-                SnapshotKind::FullSnapshot,
+                SnapshotKind::Archive(SnapshotArchiveKind::Incremental(5)),
+                SnapshotKind::Archive(SnapshotArchiveKind::Full),
                 Less,
             ),
             (
-                SnapshotKind::IncrementalSnapshot(5),
-                SnapshotKind::IncrementalSnapshot(6),
+                SnapshotKind::Archive(SnapshotArchiveKind::Incremental(5)),
+                SnapshotKind::Archive(SnapshotArchiveKind::Incremental(6)),
                 Less,
             ),
             (
-                SnapshotKind::IncrementalSnapshot(5),
-                SnapshotKind::IncrementalSnapshot(5),
+                SnapshotKind::Archive(SnapshotArchiveKind::Incremental(5)),
+                SnapshotKind::Archive(SnapshotArchiveKind::Incremental(5)),
                 Equal,
             ),
             (
-                SnapshotKind::IncrementalSnapshot(5),
-                SnapshotKind::IncrementalSnapshot(4),
+                SnapshotKind::Archive(SnapshotArchiveKind::Incremental(5)),
+                SnapshotKind::Archive(SnapshotArchiveKind::Incremental(4)),
                 Greater,
             ),
         ] {
@@ -137,4 +190,42 @@ mod tests {
             assert_eq!(expected_result, actual_result);
         }
     }
+
+    #[test]
+    fn test_cmp_snapshot_archive_kinds_by_priority() {
+        for (snapshot_archive_kind_a, snapshot_archive_kind_b, expected_result) in [
+            (SnapshotArchiveKind::Full, SnapshotArchiveKind::Full, Equal),
+            (
+                SnapshotArchiveKind::Full,
+                SnapshotArchiveKind::Incremental(5),
+                Greater,
+            ),
+            (
+                SnapshotArchiveKind::Incremental(5),
+                SnapshotArchiveKind::Full,
+                Less,
+            ),
+            (
+                SnapshotArchiveKind::Incremental(5),
+                SnapshotArchiveKind::Incremental(6),
+                Less,
+            ),
+            (
+                SnapshotArchiveKind::Incremental(5),
+                SnapshotArchiveKind::Incremental(5),
+                Equal,
+            ),
+            (
+                SnapshotArchiveKind::Incremental(5),
+                SnapshotArchiveKind::Incremental(4),
+                Greater,
+            ),
+        ] {
+            let actual_result = cmp_snapshot_archive_kinds_by_priority(
+                &snapshot_archive_kind_a,
+                &snapshot_archive_kind_b,
+            );
+            assert_eq!(expected_result, actual_result);
+        }
+    }
 }

runtime/src/snapshot_utils.rs

@@ -26,7 +26,8 @@ use {
             SnapshotArchiveInfoGetter,
         },
         snapshot_config::SnapshotConfig,
-        streaming_unarchive_snapshot, ArchiveFormat, Result, SnapshotKind, SnapshotVersion,
+        streaming_unarchive_snapshot, ArchiveFormat, Result, SnapshotArchiveKind, SnapshotKind,
+        SnapshotVersion,
     },
     crossbeam_channel::{Receiver, Sender},
     log::*,
@@ -464,14 +465,16 @@ pub fn serialize_and_archive_snapshot_package(
         should_flush_and_hard_link_storages,
     )?;
 
-    let snapshot_archive_path = match snapshot_package.snapshot_kind {
-        SnapshotKind::FullSnapshot => snapshot_paths::build_full_snapshot_archive_path(
+    let SnapshotKind::Archive(snapshot_archive_kind) = snapshot_kind;
+
+    let snapshot_archive_path = match snapshot_archive_kind {
+        SnapshotArchiveKind::Full => snapshot_paths::build_full_snapshot_archive_path(
             &snapshot_config.full_snapshot_archives_dir,
             snapshot_package.slot,
             &snapshot_package.hash,
             snapshot_config.archive_format,
         ),
-        SnapshotKind::IncrementalSnapshot(incremental_snapshot_base_slot) => {
+        SnapshotArchiveKind::Incremental(incremental_snapshot_base_slot) => {
             // After the snapshot has been serialized, it is now safe (and required) to prune all
             // the storages that are *not* to be archived for this incremental snapshot.
             snapshot_storages.retain(|storage| storage.slot() > incremental_snapshot_base_slot);
@@ -486,7 +489,7 @@ pub fn serialize_and_archive_snapshot_package(
     };
 
     let snapshot_archive_info = archive_snapshot(
-        snapshot_kind,
+        snapshot_archive_kind,
         snapshot_slot,
         snapshot_hash,
         snapshot_storages.as_slice(),

snapshots/src/archive.rs

@@ -1,7 +1,7 @@
 use {
     crate::{
         error::ArchiveSnapshotPackageError, paths, snapshot_archive_info::SnapshotArchiveInfo,
-        snapshot_hash::SnapshotHash, ArchiveFormat, Result, SnapshotKind,
+        snapshot_hash::SnapshotHash, ArchiveFormat, Result, SnapshotArchiveKind,
     },
     log::info,
     solana_accounts_db::{
@@ -21,7 +21,7 @@ const INTERLEAVE_TAR_ENTRIES_SMALL_TO_LARGE_RATIO: (usize, usize) = (4, 1);
 
 /// Archives a snapshot into `archive_path`
 pub fn archive_snapshot(
-    snapshot_kind: SnapshotKind,
+    snapshot_archive_kind: SnapshotArchiveKind,
     snapshot_slot: Slot,
     snapshot_hash: SnapshotHash,
     snapshot_storages: &[Arc<AccountStorageEntry>],
@@ -31,7 +31,7 @@ pub fn archive_snapshot(
 ) -> Result<SnapshotArchiveInfo> {
     use ArchiveSnapshotPackageError as E;
     const ACCOUNTS_DIR: &str = "accounts";
-    info!("Generating snapshot archive for slot {snapshot_slot}, kind: {snapshot_kind:?}");
+    info!("Generating snapshot archive for slot {snapshot_slot}, kind: {snapshot_archive_kind:?}");
 
     let mut timer = Measure::start("snapshot_package-package_snapshots");
     let tar_dir = archive_path
@@ -179,7 +179,7 @@ pub fn archive_snapshot(
         ("archive_format", archive_format.to_string(), String),
         ("duration_ms", timer.as_ms(), i64),
         (
-            if snapshot_kind.is_full_snapshot() {
+            if snapshot_archive_kind == SnapshotArchiveKind::Full {
                 "full-snapshot-archive-size"
             } else {
                 "incremental-snapshot-archive-size"

snapshots/src/kind.rs

@@ -1,18 +1,28 @@
 use solana_clock::Slot;
 
-/// Snapshots come in two kinds, Full and Incremental.  The IncrementalSnapshot has a Slot field,
-/// which is the incremental snapshot base slot.
+/// All snapshots are archived at this time, but it is possible that
+/// in the future there could be other kinds of snapshots that are not archived.
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum SnapshotKind {
-    FullSnapshot,
-    IncrementalSnapshot(Slot),
+    Archive(SnapshotArchiveKind),
 }
 
 impl SnapshotKind {
     pub fn is_full_snapshot(&self) -> bool {
-        matches!(self, SnapshotKind::FullSnapshot)
+        matches!(self, SnapshotKind::Archive(SnapshotArchiveKind::Full))
     }
     pub fn is_incremental_snapshot(&self) -> bool {
-        matches!(self, SnapshotKind::IncrementalSnapshot(_))
+        matches!(
+            self,
+            SnapshotKind::Archive(SnapshotArchiveKind::Incremental(_))
+        )
     }
 }
+
+/// Snapshot archives come in two kinds, Full and Incremental. The incremental snapshot archive has
+/// a Slot field, which is the incremental snapshot base slot.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum SnapshotArchiveKind {
+    Full,
+    Incremental(Slot),
+}

snapshots/src/lib.rs

@@ -33,7 +33,7 @@ pub type Result<T> = std::result::Result<T, error::SnapshotError>;
 pub use {
     archive::archive_snapshot,
     archive_format::*,
-    kind::SnapshotKind,
+    kind::{SnapshotArchiveKind, SnapshotKind},
     snapshot_interval::SnapshotInterval,
     snapshot_version::SnapshotVersion,
     unarchive::{streaming_unarchive_snapshot, unpack_genesis_archive},

validator/src/bootstrap.rs

@@ -1,7 +1,7 @@
 use {
     agave_snapshots::{
         paths as snapshot_paths, snapshot_archive_info::SnapshotArchiveInfoGetter as _,
-        SnapshotKind,
+        SnapshotArchiveKind,
     },
     itertools::Itertools,
     log::*,
@@ -1153,7 +1153,7 @@ fn download_snapshots(
             download_abort_count,
             rpc_contact_info,
             full_snapshot_hash,
-            SnapshotKind::FullSnapshot,
+            SnapshotArchiveKind::Full,
         )?;
     }
 
@@ -1184,7 +1184,7 @@ fn download_snapshots(
                     download_abort_count,
                     rpc_contact_info,
                     incremental_snapshot_hash,
-                    SnapshotKind::IncrementalSnapshot(full_snapshot_hash.0),
+                    SnapshotArchiveKind::Incremental(full_snapshot_hash.0),
                 )?;
             }
         }
@@ -1205,7 +1205,7 @@ fn download_snapshot(
     download_abort_count: &mut u64,
     rpc_contact_info: &ContactInfo,
     desired_snapshot_hash: (Slot, Hash),
-    snapshot_kind: SnapshotKind,
+    snapshot_kind: SnapshotArchiveKind,
 ) -> Result<(), String> {
     let maximum_full_snapshot_archives_to_retain = validator_config
         .snapshot_config