Enabling snapshot generation when loading from ledger tool (anza-xyz#10064)

* When creating a snapshot from the ledger tool, ensure that snapshot generation and loading is enabled

* Seperated out common code in ledger_utils

Replaced assert!(matches!()) with assert_eq()

Author: roryharr

ledger-tool/src/ledger_utils.rs

@@ -408,9 +408,19 @@ pub fn load_and_process_ledger(
     };
 
     let (snapshot_request_sender, snapshot_request_receiver) = crossbeam_channel::unbounded();
+
+    // If snapshot_slot is present, then ledger-tool is attempting to generate a snapshot. Setting
+    // new_generate_snapshots_externally ensures the accounts database retains zero lamport
+    // accounts needed to correctly generate incremental snapshots
+    let snapshot_config = if arg_matches.is_present("snapshot_slot") {
+        SnapshotConfig::new_generate_snapshots_externally()
+    } else {
+        SnapshotConfig::new_load_only()
+    };
+
     let snapshot_controller = Arc::new(SnapshotController::new(
         snapshot_request_sender,
-        SnapshotConfig::new_load_only(),
+        snapshot_config,
         bank_forks.read().unwrap().root(),
     ));
     let pending_snapshot_packages = Arc::new(Mutex::new(PendingSnapshotPackages::default()));

ledger-tool/src/main.rs

@@ -2175,6 +2175,15 @@ fn main() {
                             exit(1);
                         });
 
+                    // If we are creating an incremental snapshot, it must be based on a full snapshot
+                    if is_incremental {
+                        assert!(bank
+                            .accounts()
+                            .accounts_db
+                            .latest_full_snapshot_slot()
+                            .is_some());
+                    }
+
                     // Snapshot creation will implicitly perform AccountsDb
                     // flush and clean operations. These operations cannot be
                     // run concurrently, so ensure ABS is stopped to avoid that

snapshots/src/snapshot_config.rs

@@ -89,6 +89,18 @@ impl SnapshotConfig {
         }
     }
 
+    /// A new snapshot config used for loading at startup and generating
+    /// snapshots during runtime. Snapshot generation intervals are disabled
+    /// to indicate that snapshots will be generated externally.
+    pub fn new_generate_snapshots_externally() -> Self {
+        Self {
+            usage: SnapshotUsage::LoadAndGenerate,
+            full_snapshot_archive_interval: SnapshotInterval::Disabled,
+            incremental_snapshot_archive_interval: SnapshotInterval::Disabled,
+            ..Self::default()
+        }
+    }
+
     /// A new snapshot config used to disable snapshot generation and loading at
     /// startup
     pub fn new_disabled() -> Self {
@@ -123,3 +135,62 @@ pub enum SnapshotUsage {
     /// generate).  This enables taking snapshots.
     LoadAndGenerate,
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_new_load_only() {
+        let cfg = SnapshotConfig::new_load_only();
+
+        assert!(!cfg.should_generate_snapshots());
+        assert!(cfg.should_load_snapshots());
+
+        assert_eq!(
+            cfg.full_snapshot_archive_interval,
+            SnapshotInterval::Disabled
+        );
+        assert_eq!(
+            cfg.incremental_snapshot_archive_interval,
+            SnapshotInterval::Disabled
+        );
+    }
+
+    #[test]
+    fn test_new_disabled() {
+        let cfg = SnapshotConfig::new_disabled();
+
+        assert!(!cfg.should_generate_snapshots());
+        assert!(!cfg.should_load_snapshots());
+
+        assert_eq!(
+            cfg.full_snapshot_archive_interval,
+            SnapshotInterval::Disabled
+        );
+        assert_eq!(
+            cfg.incremental_snapshot_archive_interval,
+            SnapshotInterval::Disabled
+        );
+    }
+
+    #[test]
+    fn test_new_generate_snapshots_externally() {
+        let cfg = SnapshotConfig::new_generate_snapshots_externally();
+
+        // Even though intervals are disabled (snapshots handled externally),
+        // usage indicates load+generate semantics.
+        assert_eq!(cfg.usage, SnapshotUsage::LoadAndGenerate);
+        assert!(cfg.should_generate_snapshots());
+        assert!(cfg.should_load_snapshots());
+
+        assert_eq!(
+            cfg.full_snapshot_archive_interval,
+            SnapshotInterval::Disabled
+        );
+        assert_eq!(
+            cfg.incremental_snapshot_archive_interval,
+            SnapshotInterval::Disabled
+        );
+    }
+}