Merge pull request #22 from PlexSheep/devel

Refactor: remove ipv4/v6 flags

Author: PlexSheep

src/analyze.rs

@@ -30,10 +30,9 @@
 //! - Store metadata (hashes, versions)
 
 use deepsize::DeepSizeOf;
-use tracing::error;
 
 use crate::errors::AnalysisError;
-use crate::records::{Check, CheckFlag, CheckType};
+use crate::records::{Check, CheckType, IpType};
 use crate::store::Store;
 
 use std::fmt::{Display, Write};
@@ -139,9 +138,9 @@ pub fn analyze(store: &Store) -> Result<String, AnalysisError> {
     barrier(&mut f, "ICMP")?;
     generic_type_analyze(store, &mut f, CheckType::Icmp)?;
     barrier(&mut f, "IPv4")?;
-    gereric_ip_analyze(store, &mut f, CheckFlag::IPv4)?;
+    gereric_ip_analyze(store, &mut f, IpType::V4)?;
     barrier(&mut f, "IPv6")?;
-    gereric_ip_analyze(store, &mut f, CheckFlag::IPv6)?;
+    gereric_ip_analyze(store, &mut f, IpType::V6)?;
     barrier(&mut f, "Outages")?;
     outages(store, &mut f)?;
     barrier(&mut f, "Store Metadata")?;
@@ -337,25 +336,11 @@ fn generalized(store: &Store, f: &mut String) -> Result<(), AnalysisError> {
 /// Prints warning to stderr if:
 /// - Check has both IPv4 and IPv6 flags set
 /// - Check has no IP version flags set
-fn gereric_ip_analyze(
-    store: &Store,
-    f: &mut String,
-    ip_check_flag: CheckFlag,
-) -> Result<(), AnalysisError> {
-    if ![CheckFlag::IPv4, CheckFlag::IPv6].contains(&ip_check_flag) {
-        panic!("check flag is not IPv4 or IPv6: {ip_check_flag:?}");
-    }
+fn gereric_ip_analyze(store: &Store, f: &mut String, ip_type: IpType) -> Result<(), AnalysisError> {
     let all: Vec<&Check> = store
         .checks()
         .iter()
-        .filter(|c| match c.ip_type() {
-            Ok(ip) => ip,
-            Err(err) => {
-                error!("check '{}' has bad flags: {err}", c.get_hash());
-                return false;
-            }
-        } == ip_check_flag
-        )
+        .filter(|c| c.ip_type() == ip_type)
         .collect();
     let successes: Vec<&Check> = all.clone().into_iter().filter(|c| c.is_success()).collect();
     analyze_check_type_set(f, &all, &successes)?;

src/bins/daemon.rs

@@ -103,7 +103,7 @@ fn wakeup(store: &mut Store) -> Result<(), RunError> {
 
     let mut buf = String::new();
     display_group(&store.make_checks(), &mut buf)?;
-    info!("{buf}");
+    info!("Made checks\n{buf}");
 
     if let Err(err) = store.save() {
         error!("error while saving to file: {err:}");

src/records.rs

@@ -50,6 +50,17 @@ use tracing::error;
 
 use crate::errors::StoreError;
 
+/// Type of [IpAddr]
+///
+/// This enum can be used to work with just abstract IP versions, not whole [Ip Addresses](IpAddr).
+#[derive(Debug, PartialEq, Eq, Hash, Deserialize, Serialize, Clone, Copy, DeepSizeOf)]
+pub enum IpType {
+    /// Type is IPv4
+    V4,
+    /// Type is IPv6
+    V6,
+}
+
 /// List of target IP addresses used for connectivity checks.
 ///
 /// # Warning
@@ -63,8 +74,7 @@ flags! {
     ///
     /// Uses a bitflag system to efficiently store multiple properties:
     /// - Result flags (bits 0-7): Success, failure reasons
-    /// - Protocol flags (bits 8-11): IPv4/IPv6
-    /// - Type flags (bits 12-15): Check type (HTTP, ICMP, DNS)
+    /// - Type flags (bits 8-15): Check type (HTTP, ICMP, DNS)
     #[derive(Hash, Deserialize, Serialize)]
     pub enum CheckFlag: u16 {
         /// If this is not set, the check will be considered failed
@@ -74,11 +84,6 @@ flags! {
         /// Failure because the destination is unreachable
         Unreachable =   0b0000_0000_0000_0100,
 
-        /// The Check used IPv4
-        IPv4        =   0b0000_0001_0000_0000,
-        /// The Check used IPv6
-        IPv6        =   0b0000_0010_0000_0000,
-
         /// The Check used HTTP/HTTPS
         TypeHTTP    =   0b0001_0000_0000_0000,
         /// Check type was ICMP (ping)
@@ -136,11 +141,6 @@ impl CheckType {
             remote,
         );
 
-        match remote {
-            IpAddr::V4(_) => check.add_flag(CheckFlag::IPv4),
-            IpAddr::V6(_) => check.add_flag(CheckFlag::IPv6),
-        }
-
         match self {
             #[cfg(feature = "http")]
             Self::Http => {
@@ -365,57 +365,13 @@ impl Check {
 
     /// Determines whether the check used IPv4 or IPv6.
     ///
-    /// Examines the check's flags to determine which IP version was used.
-    /// A check should have either IPv4 or IPv6 flag set, but not both.
+    /// Examines the [check's](Check) [target](Check::target) to determine which IP version was used.
     ///
     /// # Returns
     ///
-    /// * `CheckFlag::IPv4` - Check used IPv4
-    /// * `CheckFlag::IPv6` - Check used IPv6
-    ///
-    /// # Errors
-    ///
-    /// * Returns [`StoreError::AmbiguousFlags`] if both IPv4 and IPv6 flags are set,
-    ///   as this represents an invalid state that should never occur.
-    ///
-    /// * Returns [`StoreError::MissingFlag`] if neither IPv4 or IPv6 flags are set,
-    ///   as this represents an invalid state that should never occur.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use netpulse::records::{Check, CheckFlag};
-    /// use flagset::FlagSet;
-    ///
-    /// let mut check = Check::new(std::time::SystemTime::now(), FlagSet::default(), None, "1.1.1.1".parse().unwrap());
-    ///
-    /// assert!(check.ip_type().is_err()); // we haven't set the IP flags! We need to set either IPv4 or IPv6
-    ///
-    /// check.add_flag(CheckFlag::IPv4);
-    ///
-    /// match check.ip_type().unwrap() {
-    ///     CheckFlag::IPv4 => println!("IPv4 check"),
-    ///     CheckFlag::IPv6 => println!("IPv6 check"),
-    ///     _ => unreachable!()
-    /// }
-    ///
-    /// check.add_flag(CheckFlag::IPv6); // But what if we now also add IPv6?
-    ///
-    /// assert!(check.ip_type().is_err()); // Oh no! Now it's ambiguos
-    /// ```
-    pub fn ip_type(&self) -> Result<CheckFlag, StoreError> {
-        let flags = self.flags();
-        if flags.contains(CheckFlag::IPv4) && flags.contains(CheckFlag::IPv6) {
-            Err(StoreError::AmbiguousFlags(
-                CheckFlag::IPv4 | CheckFlag::IPv6,
-            ))
-        } else if flags.contains(CheckFlag::IPv4) {
-            Ok(CheckFlag::IPv4)
-        } else if flags.contains(CheckFlag::IPv6) {
-            Ok(CheckFlag::IPv6)
-        } else {
-            Err(StoreError::MissingFlag(CheckFlag::IPv4 | CheckFlag::IPv6))
-        }
+    /// The [IpType] that was used
+    pub fn ip_type(&self) -> IpType {
+        IpType::from(self.target)
     }
 }
 
@@ -437,6 +393,15 @@ impl Display for Check {
     }
 }
 
+impl From<IpAddr> for IpType {
+    fn from(value: IpAddr) -> Self {
+        match value {
+            IpAddr::V4(_) => Self::V4,
+            IpAddr::V6(_) => Self::V6,
+        }
+    }
+}
+
 /// Display a formatted list of checks.
 ///
 /// Each check is formatted with:

src/store.rs

@@ -26,7 +26,7 @@ use std::str::FromStr;
 
 use deepsize::DeepSizeOf;
 use serde::{Deserialize, Serialize};
-use tracing::{error, trace, warn};
+use tracing::{error, info, trace, warn};
 
 use crate::errors::StoreError;
 use crate::records::{Check, CheckType, TARGETS};
@@ -109,12 +109,12 @@ impl From<Version> for u8 {
 
 impl Version {
     /// Current version of the store format
-    pub const CURRENT: Self = Version::new(0);
+    pub const CURRENT: Self = Version::new(1);
 
     /// List of supported store format versions
     ///
     /// Used for compatibility checking when loading stores.
-    pub const SUPPROTED: &[Self] = &[Version::new(0)];
+    pub const SUPPROTED: &[Self] = &[Version::new(0), Version::new(1)];
 
     /// Creates a new Version with the given raw version number
     pub(crate) const fn new(raw: u8) -> Self {
@@ -358,9 +358,9 @@ impl Store {
 
         // TODO: somehow account for old versions that are not compatible with the store struct
         if store.version != Version::CURRENT {
-            error!("The store that was loaded is not of the current version:\nstore has {} but the current version is {}", store.version, Version::CURRENT);
+            warn!("The store that was loaded is not of the current version:\nstore has {} but the current version is {}", store.version, Version::CURRENT);
             if Version::SUPPROTED.contains(&store.version) {
-                error!("The old store version is still supported, migrating to newer version");
+                warn!("The old store version is still supported, migrating to newer version (in memory, can be made permanent by saving)");
                 store.version = Version::CURRENT;
             } else {
                 error!("The store version is not supported");
@@ -385,6 +385,7 @@ impl Store {
     /// - Write fails
     /// - Serialization fails
     pub fn save(&self) -> Result<(), StoreError> {
+        info!("Saving the store");
         let file = match fs::File::options()
             .read(false)
             .write(true)