feat(common): add utxo-hd in-memory ledger state snaspshot support

Author: Alenar

mithril-common/src/digesters/ledger_state_snapshot.rs

@@ -19,6 +19,20 @@ fn find_ledger_dir(path_to_walk: &Path) -> Option<PathBuf> {
         .map(|e| e.into_path())
 }
 
+fn is_ledger_state_snapshot(path: &Path) -> bool {
+    if path.is_dir() {
+        path.join(LedgerStateSnapshot::IN_MEMORY_META).exists()
+            && path.join(LedgerStateSnapshot::IN_MEMORY_STATE).exists()
+            && path.join(LedgerStateSnapshot::IN_MEMORY_TABLES).exists()
+            && path
+                .join(LedgerStateSnapshot::IN_MEMORY_TABLES)
+                .join(LedgerStateSnapshot::IN_MEMORY_TVAR)
+                .exists()
+    } else {
+        path.is_file()
+    }
+}
+
 /// Represent an ledger file in a Cardano node database directory
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub enum LedgerStateSnapshot {
@@ -31,6 +45,15 @@ pub enum LedgerStateSnapshot {
         /// The filename
         filename: OsString,
     },
+    /// Snapshot of an UTxO-HD in-memory ledger state
+    InMemory {
+        /// The path to the ledger file
+        path: PathBuf,
+        /// The ledger file slot number
+        slot_number: SlotNumber,
+        /// Name of the ledger state folder
+        folder_name: OsString,
+    },
 }
 
 /// [LedgerStateSnapshot::list_all_in_dir] related errors.
@@ -42,6 +65,15 @@ pub enum LedgerStateSnapshotListingError {
 }
 
 impl LedgerStateSnapshot {
+    /// Filename of the in-memory ledger snapshot 'meta' file
+    pub const IN_MEMORY_META: &'static str = "meta";
+    /// Filename of the in-memory ledger snapshot 'state' file
+    pub const IN_MEMORY_STATE: &'static str = "state";
+    /// Directory name of the in-memory ledger snapshot 'tables' folder
+    pub const IN_MEMORY_TABLES: &'static str = "tables";
+    /// Filename of the in-memory ledger snapshot 'tables/tvar' file
+    pub const IN_MEMORY_TVAR: &'static str = "tvar";
+
     /// `LedgerStateSnapshot::Legacy` factory
     pub fn legacy(path: PathBuf, slot_number: SlotNumber, filename: OsString) -> Self {
         Self::Legacy {
@@ -51,6 +83,15 @@ impl LedgerStateSnapshot {
         }
     }
 
+    /// `LedgerStateSnapshot::InMemory` factory
+    pub fn in_memory(path: PathBuf, slot_number: SlotNumber, folder_name: OsString) -> Self {
+        Self::InMemory {
+            path,
+            slot_number,
+            folder_name,
+        }
+    }
+
     /// Convert a path to a [LedgerStateSnapshot] if it satisfies the constraints.
     ///
     /// The constraints are:
@@ -62,11 +103,19 @@ impl LedgerStateSnapshot {
                 .to_string_lossy()
                 .parse::<u64>()
                 .map(|number| {
-                    Self::legacy(
-                        path.to_path_buf(),
-                        SlotNumber(number),
-                        filename.to_os_string(),
-                    )
+                    if path.is_dir() {
+                        Self::in_memory(
+                            path.to_path_buf(),
+                            SlotNumber(number),
+                            filename.to_os_string(),
+                        )
+                    } else {
+                        Self::legacy(
+                            path.to_path_buf(),
+                            SlotNumber(number),
+                            filename.to_os_string(),
+                        )
+                    }
                 })
                 .ok()
         })
@@ -85,7 +134,7 @@ impl LedgerStateSnapshot {
             .min_depth(1)
             .max_depth(1)
             .into_iter()
-            .filter_entry(|e| e.file_type().is_file())
+            .filter_entry(|e| is_ledger_state_snapshot(e.path()))
             .filter_map(|file| file.ok())
         {
             if let Some(ledger_file) = LedgerStateSnapshot::from_path(path.path()) {
@@ -103,13 +152,23 @@ impl LedgerStateSnapshot {
     pub fn get_files_relative_path(&self) -> Vec<PathBuf> {
         match self {
             LedgerStateSnapshot::Legacy { filename, .. } => vec![PathBuf::from(filename)],
+            LedgerStateSnapshot::InMemory { folder_name, .. } => {
+                vec![
+                    PathBuf::from(folder_name).join(Self::IN_MEMORY_META),
+                    PathBuf::from(folder_name).join(Self::IN_MEMORY_STATE),
+                    PathBuf::from(folder_name)
+                        .join(Self::IN_MEMORY_TABLES)
+                        .join(Self::IN_MEMORY_TVAR),
+                ]
+            }
         }
     }
 
     /// Return the slot number when this snapshot was taken
     pub fn slot_number(&self) -> SlotNumber {
         match self {
-            LedgerStateSnapshot::Legacy { slot_number, .. } => *slot_number,
+            LedgerStateSnapshot::Legacy { slot_number, .. }
+            | LedgerStateSnapshot::InMemory { slot_number, .. } => *slot_number,
         }
     }
 }
@@ -205,4 +264,141 @@ mod tests {
             assert_eq!(vec!["123", "124"], extract_filenames(&ledger_files));
         }
     }
+
+    // UTxO-HD in-memory rules:
+    // - a folder named after the slot number at which the snapshots are taken (same naming convention as
+    // legacy state snapshot)
+    // - contains three files, with one in a subfolder:
+    //   - "/meta"
+    //   - "/state"
+    //   - "/tables/tvar"
+    mod utxo_hd_in_memory_ledger_state {
+        use std::fs::create_dir_all;
+
+        use super::*;
+
+        #[test]
+        fn list_all_ledger_state_should_not_include_utxo_hd_folder_that_does_not_contains_meta_state_or_tvar_files(
+        ) {
+            let target_dir = temp_dir_create!();
+            let ledger_dir = create_ledger_dir(&target_dir);
+
+            let ledger_empty_dir = ledger_dir.join("000");
+            create_dir(&ledger_empty_dir).unwrap();
+
+            let ledger_with_missing_meta_files = ledger_dir.join("100");
+            create_dir_all(
+                ledger_with_missing_meta_files.join(LedgerStateSnapshot::IN_MEMORY_TABLES),
+            )
+            .unwrap();
+            create_fake_files(
+                &ledger_with_missing_meta_files,
+                &[LedgerStateSnapshot::IN_MEMORY_STATE],
+            );
+            create_fake_files(
+                &ledger_with_missing_meta_files.join(LedgerStateSnapshot::IN_MEMORY_TABLES),
+                &[LedgerStateSnapshot::IN_MEMORY_TVAR],
+            );
+
+            let ledger_with_missing_state_files = ledger_dir.join("200");
+            create_dir_all(
+                ledger_with_missing_state_files.join(LedgerStateSnapshot::IN_MEMORY_TABLES),
+            )
+            .unwrap();
+            create_fake_files(
+                &ledger_with_missing_state_files,
+                &[LedgerStateSnapshot::IN_MEMORY_META],
+            );
+            create_fake_files(
+                &ledger_with_missing_meta_files.join(LedgerStateSnapshot::IN_MEMORY_TABLES),
+                &[LedgerStateSnapshot::IN_MEMORY_TVAR],
+            );
+
+            let ledger_with_missing_tvar_files = ledger_dir.join("300");
+            create_dir_all(
+                ledger_with_missing_tvar_files.join(LedgerStateSnapshot::IN_MEMORY_TABLES),
+            )
+            .unwrap();
+            create_fake_files(
+                &ledger_with_missing_tvar_files,
+                &[
+                    LedgerStateSnapshot::IN_MEMORY_STATE,
+                    LedgerStateSnapshot::IN_MEMORY_META,
+                ],
+            );
+
+            let ledger_with_missing_table_folder = ledger_dir.join("400");
+            create_dir(&ledger_with_missing_table_folder).unwrap();
+            create_fake_files(
+                &ledger_with_missing_table_folder,
+                &[
+                    LedgerStateSnapshot::IN_MEMORY_STATE,
+                    LedgerStateSnapshot::IN_MEMORY_META,
+                ],
+            );
+
+            let result = LedgerStateSnapshot::list_all_in_dir(&target_dir).unwrap();
+
+            assert_eq!(Vec::<LedgerStateSnapshot>::new(), result);
+        }
+
+        #[test]
+        fn list_all_ledger_state_with_valid_utxo_hd_folder_structure() {
+            let target_dir = temp_dir_create!();
+            let ledger_dir = create_ledger_dir(&target_dir);
+
+            let ledger_state = ledger_dir.join("200");
+            create_dir_all(ledger_state.join(LedgerStateSnapshot::IN_MEMORY_TABLES)).unwrap();
+            create_fake_files(
+                &ledger_state,
+                &[
+                    LedgerStateSnapshot::IN_MEMORY_META,
+                    LedgerStateSnapshot::IN_MEMORY_STATE,
+                ],
+            );
+            create_fake_files(
+                &ledger_state.join(LedgerStateSnapshot::IN_MEMORY_TABLES),
+                &[LedgerStateSnapshot::IN_MEMORY_TVAR],
+            );
+
+            let result = LedgerStateSnapshot::list_all_in_dir(&target_dir).unwrap();
+
+            assert_eq!(
+                vec![LedgerStateSnapshot::in_memory(
+                    ledger_state,
+                    SlotNumber(200),
+                    "200".into()
+                )],
+                result
+            );
+        }
+
+        #[test]
+        fn get_relative_path_only_list_meta_state_and_tvar_files_even_if_there_are_other_files_in_the_folder(
+        ) {
+            let target_dir = temp_dir_create!();
+            create_dir_all(
+                target_dir
+                    .join("050")
+                    .join(LedgerStateSnapshot::IN_MEMORY_TABLES),
+            )
+            .unwrap();
+            let ledger_state = LedgerStateSnapshot::in_memory(
+                target_dir.join("050"),
+                SlotNumber(50),
+                "050".into(),
+            );
+
+            assert_eq!(
+                vec![
+                    PathBuf::from("050").join(LedgerStateSnapshot::IN_MEMORY_META),
+                    PathBuf::from("050").join(LedgerStateSnapshot::IN_MEMORY_STATE),
+                    PathBuf::from("050")
+                        .join(LedgerStateSnapshot::IN_MEMORY_TABLES)
+                        .join(LedgerStateSnapshot::IN_MEMORY_TVAR)
+                ],
+                ledger_state.get_files_relative_path(),
+            )
+        }
+    }
 }