Merge branch 'feat/hash' into devel

Author: PlexSheep

Cargo.toml

@@ -34,6 +34,8 @@ deepsize = "0.2.0"
 tracing = "0.1.40"
 tracing-subscriber = { version = "0.3.18", optional = true }
 chrono = { version = "0.4.38", optional = false }
+blake3 = "1.5.4"
+serde_repr = "0.1.19"
 
 [[bin]] # client
 name = "netpulse"

src/analyze.rs

@@ -375,11 +375,10 @@ fn store_meta(store: &Store, f: &mut String) -> Result<(), AnalysisError> {
     let store_size_mem = store.deep_size_of();
     let store_size_fs = std::fs::metadata(Store::path())?.size();
 
-    key_value_write(f, "Hash Datastructure", store.display_hash())?;
-    key_value_write(f, "Hash Store File", store.display_hash_of_file()?)?;
+    key_value_write(f, "Hash mem blake3", store.get_hash())?;
+    key_value_write(f, "Hash file sha256", store.get_hash_of_file()?)?;
     key_value_write(f, "Store Version (mem)", store.version())?;
-    // TODO: find a way to get the version just from file without deserializing it
-    key_value_write(f, "Store Version (file)", "<TODO>")?;
+    key_value_write(f, "Store Version (file)", Store::peek_file_version()?)?;
     key_value_write(f, "Store Size (mem)", store_size_mem)?;
     key_value_write(f, "Store Size (file)", store_size_fs)?;
     key_value_write(

src/bins/netpulse.rs

@@ -17,6 +17,7 @@ use netpulse::common::{init_logging, print_usage};
 use netpulse::errors::RunError;
 use netpulse::records::{display_group, Check};
 use netpulse::store::Store;
+use tracing::error;
 
 fn main() {
     init_logging(tracing::Level::INFO);
@@ -28,6 +29,11 @@ fn main() {
     opts.optflag("V", "version", "print the version");
     opts.optflag("t", "test", "test run all checks");
     opts.optflag("d", "dump", "print out all checks");
+    opts.optflag(
+        "r",
+        "rewrite",
+        "load store and immediately save to rewrite the file",
+    );
     opts.optflag("f", "failed", "only consider failed checks for dumping");
     let matches = match opts.parse(&args[1..]) {
         Ok(m) => m,
@@ -50,7 +56,12 @@ fn main() {
         dump(failed_only);
     } else if matches.opt_present("test") {
         if let Err(e) = test_checks() {
-            eprintln!("{e}");
+            error!("{e}");
+            std::process::exit(1)
+        }
+    } else if matches.opt_present("rewrite") {
+        if let Err(e) = rewrite() {
+            error!("{e}");
             std::process::exit(1)
         }
     } else {
@@ -93,6 +104,12 @@ fn dump(failed_only: bool) {
     println!("{buf}")
 }
 
+fn rewrite() -> Result<(), RunError> {
+    let s = Store::load()?;
+    s.save()?;
+    Ok(())
+}
+
 fn analysis() {
     let store = store_load();
     match analyze::analyze(&store) {

src/errors.rs

@@ -53,7 +53,7 @@ pub enum StoreError {
     /// Failed to load store data from file.
     ///
     /// This typically indicates corruption or an incompatible / outdated store format.
-    #[error("Could not load the store from file: {source}")]
+    #[error("Could not deserialize the store from the loaded data: {source}")]
     Load {
         /// Underlying error
         #[from]
@@ -92,6 +92,9 @@ pub enum StoreError {
     /// is not defined. Only known [Versions][crate::store::Version] are valid.
     #[error("Tried to load a store version that does not exist: {0}")]
     BadStoreVersion(u8),
+    /// A store can be loaded as readonly if it's corrupted or there is a version mismatch
+    #[error("Tried to save a readonly store")]
+    IsReadonly,
 }
 
 /// Errors that can occur during network checks.

src/records.rs

@@ -39,7 +39,7 @@
 //! ```
 
 use std::fmt::{Display, Write};
-use std::hash::{Hash, Hasher};
+use std::hash::Hash;
 use std::net::IpAddr;
 
 use chrono::{DateTime, Local, TimeZone, Utc};
@@ -249,14 +249,27 @@ impl DeepSizeOf for Check {
 }
 
 impl Check {
-    /// Generates a hash of the in-memory [Check] data.
-    ///
-    /// Uses [DefaultHasher](std::hash::DefaultHasher) to create a 16-character hexadecimal hash
-    /// of the [Check] that can be used to identify this [Check]. Useful for detecting changes.
-    pub fn get_hash(&self) -> String {
-        let mut hasher = std::hash::DefaultHasher::default();
-        self.hash(&mut hasher);
-        format!("{:016X}", hasher.finish())
+    /// Generates a cryptographic hash of the [Check] data.
+    ///
+    /// Uses [blake3] for consistent hashing across Rust versions and platforms.
+    /// The hash remains stable as long as the check's contents don't change,
+    /// making it suitable for persistent identification of checks.
+    ///
+    /// # Implementation Details
+    ///
+    /// - Uses [bincode] for serialization of check data
+    /// - Uses [blake3] for cryptographic hashing
+    /// - Produces a 32-byte (256-bit) hash
+    ///
+    /// # Panics
+    ///
+    /// May panic if serialization fails, which can happen in extreme cases:
+    /// - System is out of memory
+    /// - System is in a severely degraded state
+    ///
+    /// Normal [Check] data will always serialize successfully.
+    pub fn get_hash(&self) -> blake3::Hash {
+        blake3::hash(&bincode::serialize(&self).expect("serialization of a check failed"))
     }
 
     /// Creates a new check result with the specified properties.

src/store.rs

@@ -17,7 +17,7 @@
 
 use std::fmt::Display;
 use std::fs::{self};
-use std::hash::{Hash, Hasher};
+use std::hash::Hash;
 use std::io::{ErrorKind, Write};
 use std::os::unix::fs::OpenOptionsExt;
 use std::path::PathBuf;
@@ -60,6 +60,14 @@ pub const ZSTD_COMPRESSION_LEVEL: i32 = 4;
 /// Primarily intended for development and testing.
 pub const ENV_PATH: &str = "NETPULSE_STORE_PATH";
 
+/// How long to wait between running workloads for the daemon
+pub const DEFAULT_PERIOD: i64 = 60;
+/// Environment variable name for the time period after which the daemon wakes up.
+///
+/// If set, its value will be used instead of [DEFAULT_PERIOD].
+/// Primarily intended for development and testing.
+pub const ENV_PERIOD: &str = "NETPULSE_PERIOD";
+
 /// Version information for the store format.
 ///
 /// The [Store] definition might change over time as netpulse is developed. To work with older or
@@ -71,9 +79,20 @@ pub const ENV_PATH: &str = "NETPULSE_STORE_PATH";
 ///
 /// This only describes the version of the [Store], not of [Netpulse](crate) itself.
 #[derive(
-    Debug, PartialEq, Eq, Hash, Deserialize, Serialize, Copy, Clone, DeepSizeOf, PartialOrd, Ord,
+    Debug,
+    PartialEq,
+    Eq,
+    Hash,
+    Copy,
+    Clone,
+    DeepSizeOf,
+    PartialOrd,
+    Ord,
+    serde_repr::Serialize_repr,
+    serde_repr::Deserialize_repr,
 )]
 #[allow(missing_docs)] // It's just versions man
+#[repr(u8)]
 pub enum Version {
     V0 = 0,
     V1 = 1,
@@ -91,6 +110,9 @@ pub struct Store {
     version: Version,
     /// Collection of all recorded checks
     checks: Vec<Check>,
+    // if true, this store will never be saved
+    #[serde(skip)]
+    readonly: bool,
 }
 
 impl Display for Version {
@@ -193,6 +215,7 @@ impl Store {
         Self {
             version: Version::CURRENT,
             checks: Vec::new(),
+            readonly: false,
         }
     }
 
@@ -395,13 +418,17 @@ impl Store {
 
         let mut store: Store = bincode::deserialize_from(reader)?;
 
-        // TODO: somehow account for old versions that are not compatible with the store struct
         if store.version != Version::CURRENT {
             warn!("The store that was loaded is not of the current version: store has {} but the current version is {}", store.version, Version::CURRENT);
             if Version::SUPPROTED.contains(&store.version) {
-                warn!("The old store version is still supported, migrating to newer version");
+                warn!("The different store version is still supported, migrating to newer version");
                 warn!("Temp migration in memory, can be made permanent by saving");
 
+                if store.version > Version::CURRENT {
+                    warn!("The store version is newer than this version of netpulse can normally handle! Trying to ignore potential differences and loading as READONLY!");
+                    store.readonly = true;
+                }
+
                 while store.version < Version::CURRENT {
                     for check in store.checks_mut().iter_mut() {
                         if let Err(e) = check.migrate(Version::V0) {
@@ -437,8 +464,12 @@ impl Store {
     /// - File doesn't exist
     /// - Write fails
     /// - Serialization fails
+    /// - Trying to save a readonly [Store]
     pub fn save(&self) -> Result<(), StoreError> {
         info!("Saving the store");
+        if self.readonly {
+            return Err(StoreError::IsReadonly);
+        }
         let file = match fs::File::options()
             .read(false)
             .write(true)
@@ -478,19 +509,45 @@ impl Store {
     /// Returns the check interval in seconds.
     ///
     /// This determines how frequently the daemon performs checks.
-    /// Currently fixed at 60 seconds.
-    pub const fn period_seconds(&self) -> i64 {
-        60
+    /// Default is [DEFAULT_PERIOD], but this value can be overridden by setting [ENV_PERIOD] as
+    /// environment variable.
+    pub fn period_seconds(&self) -> i64 {
+        if let Ok(v) = std::env::var(ENV_PERIOD) {
+            v.parse().unwrap_or(DEFAULT_PERIOD)
+        } else {
+            DEFAULT_PERIOD
+        }
     }
 
-    /// Generates a hash of the in-memory store data.
+    /// Generates a cryptographic hash of the entire [Store].
+    ///
+    /// Uses [blake3] for consistent hashing across Rust versions and platforms.
+    /// The hash changes when any check (or other field) in the store is modified,
+    /// added, or removed.
+    ///
+    /// # Implementation Details
     ///
-    /// Uses [DefaultHasher](std::hash::DefaultHasher) to create a 16-character hexadecimal hash
-    /// of the entire store contents. Useful for detecting changes.
-    pub fn display_hash(&self) -> String {
-        let mut hasher = std::hash::DefaultHasher::default();
-        self.hash(&mut hasher);
-        format!("{:016X}", hasher.finish())
+    /// - Uses [bincode] for serialization of store data
+    /// - Uses [blake3] for cryptographic hashing
+    /// - Produces a 32-byte (256-bit) hash
+    /// - Performance scales linearly with store size
+    ///
+    /// # Memory Usage
+    ///
+    /// For a netpulsed running continuously:
+    /// - ~34 bytes per check
+    /// - ~50MB per year at 1 check/minute
+    /// - Serialization and hashing remain efficient
+    ///
+    /// # Panics
+    ///
+    /// May panic if serialization fails, which can happen in extreme cases:
+    /// - System is out of memory
+    /// - System is in a severely degraded state
+    ///
+    /// Normal [Store] data (checks, version info) will always serialize successfully.
+    pub fn get_hash(&self) -> blake3::Hash {
+        blake3::hash(&bincode::serialize(&self).expect("serialization of the store failed"))
     }
 
     /// Generates SHA-256 hash of the store file on disk.
@@ -506,7 +563,7 @@ impl Store {
     /// Returns [StoreError] if:
     /// - sha256sum command fails
     /// - Output parsing fails
-    pub fn display_hash_of_file(&self) -> Result<String, StoreError> {
+    pub fn get_hash_of_file(&self) -> Result<String, StoreError> {
         let out = Command::new("sha256sum").arg(Self::path()).output()?;
 
         if !out.status.success() {
@@ -577,6 +634,61 @@ impl Store {
     pub fn checks_mut(&mut self) -> &mut Vec<Check> {
         &mut self.checks
     }
+
+    /// Reads only the [Version] from a store file without loading the entire [Store].
+    ///
+    /// This function efficiently checks the store version by:
+    /// 1. Opening the store file (decompressing it if enabled)
+    /// 2. Deserializing only the version field
+    /// 3. Skipping the rest of the data
+    ///
+    /// This is more efficient than loading the full store when only version
+    /// information is needed, such as during version compatibility checks. It may also keep
+    /// working if the format/version of the store is incompatible with what this version of
+    /// netpulse uses.
+    ///
+    /// # Feature Flags
+    ///
+    /// If the "compression" feature is enabled, this function will decompress
+    /// the store file using [zstd] before reading the version.
+    ///
+    /// # Errors
+    ///
+    /// Returns [StoreError] if:
+    /// - Store file doesn't exist ([`StoreError::DoesNotExist`])
+    /// - Store file is corrupt or truncated ([`StoreError::Load`])
+    /// - File permissions prevent reading ([`StoreError::Io`])
+    /// - Decompression fails (with "compression" feature) ([`StoreError::Io`])
+    ///
+    /// # Examples
+    ///
+    /// ```rust,no_run
+    /// use netpulse::store::Store;
+    /// use netpulse::errors::StoreError;
+    ///
+    /// match Store::peek_file_version() {
+    ///     Ok(version) => println!("Store version in file: {}", version),
+    ///     Err(StoreError::DoesNotExist) => println!("No store file found"),
+    ///     Err(e) => eprintln!("Error reading store version: {}", e),
+    /// }
+    /// ```
+    pub fn peek_file_version() -> Result<Version, StoreError> {
+        #[derive(Deserialize)]
+        struct VersionOnly {
+            version: Version,
+            #[serde(skip)]
+            _rest: serde::de::IgnoredAny,
+        }
+
+        let file = std::fs::File::open(Self::path())?;
+        #[cfg(feature = "compression")]
+        let reader = zstd::Decoder::new(file)?;
+        #[cfg(not(feature = "compression"))]
+        let reader = file;
+
+        let version_only: VersionOnly = bincode::deserialize_from(reader)?;
+        Ok(version_only.version)
+    }
 }
 
 fn has_cap_net_raw() -> bool {