feat(reader): add check tester

Author: PlexSheep

src/bins/daemon.rs

@@ -35,7 +35,6 @@ pub(crate) fn daemon() {
                 eprintln!("error in the wakeup turn: {err}");
             }
         }
-        println!("done! sleeping...");
         std::thread::sleep(Duration::from_secs(1));
     }
 }
@@ -48,6 +47,8 @@ fn wakeup(store: &mut Store) -> Result<(), StoreError> {
     if let Err(err) = store.save() {
         eprintln!("error while saving to file: {err:}");
     }
+
+    println!("done!");
     Ok(())
 }
 

src/bins/netpulse.rs

@@ -1,10 +1,45 @@
-use netpulse::records::Check;
+use getopts::Options;
+use netpulse::records::{Check, CheckType};
 use netpulse::store::Store;
 
 fn main() {
+    let args: Vec<String> = std::env::args().collect();
+    let program = &args[0];
+    let mut opts = Options::new();
+    opts.optflag("h", "help", "print this help menu");
+    opts.optflag("t", "test", "test run all checks");
+    let matches = match opts.parse(&args[1..]) {
+        Ok(m) => m,
+        Err(f) => {
+            panic!("{}", f.to_string())
+        }
+    };
+
+    if matches.opt_present("help") {
+        print_usage(program, opts);
+    } else if matches.opt_present("test") {
+        test_checks();
+    } else {
+        analyze();
+    }
+}
+
+fn print_usage(program: &str, opts: Options) {
+    let brief = format!("Usage: {} [options]", program);
+    print!("{}", opts.usage(&brief));
+}
+
+fn test_checks() {
+    for check_type in CheckType::all() {
+        let check = check_type.make();
+        println!("{check}");
+    }
+}
+
+fn analyze() {
     let store = Store::load().expect("store file not found");
     let checks = store.checks();
-    let successes: Vec<&Check> = checks.iter().filter(|c| c.is_ok()).collect();
+    let successes: Vec<&Check> = checks.iter().filter(|c| c.is_success()).collect();
     println!("store contains {:09} checks.", checks.len());
     println!("store contains {:09} successful checks.", successes.len());
     println!(

src/records.rs

@@ -1,3 +1,4 @@
+use std::fmt::Display;
 use std::net::IpAddr;
 use std::str::FromStr;
 use std::time;
@@ -39,6 +40,7 @@ pub enum CheckType {
     Http,
     IcmpV4,
     IcmpV6,
+    Unknown,
 }
 impl CheckType {
     /// Make a new [Check] of this type.
@@ -100,14 +102,19 @@ impl CheckType {
     }
 }
 
-impl From<CheckType> for CheckFlag {
-    fn from(value: CheckType) -> Self {
-        match value {
-            CheckType::Dns => CheckFlag::TypeDns,
-            CheckType::Http => CheckFlag::TypeHTTP,
-            CheckType::IcmpV4 => CheckFlag::TypeIcmp,
-            CheckType::IcmpV6 => CheckFlag::TypeIcmp,
-        }
+impl Display for CheckType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                Self::Dns => "DNS",
+                Self::Http => "HTTP(S)",
+                Self::IcmpV4 => "ICMPv4",
+                Self::IcmpV6 => "ICMPv6",
+                Self::Unknown => "Unknown",
+            }
+        )
     }
 }
 
@@ -149,13 +156,13 @@ impl Check {
     ///
     /// Ok means, it's a [Success](CheckFlag::Success), and has no weird anomalies (that this
     /// checks for).
-    pub fn is_ok(&self) -> bool {
+    pub fn is_success(&self) -> bool {
         self.flags.contains(CheckFlag::Success)
     }
 
     /// Returns the latency of this [`Check`].
     pub fn latency(&self) -> Option<u16> {
-        if !self.is_ok() {
+        if !self.is_success() {
             None
         } else {
             self.latency
@@ -181,6 +188,38 @@ impl Check {
     pub fn add_flag(&mut self, flag: CheckFlag) {
         self.flags |= flag
     }
+
+    /// Check the flags and infer the [CheckType]
+    pub fn calc_type(&self) -> CheckType {
+        if self.flags.contains(CheckFlag::TypeHTTP) {
+            CheckType::Http
+        } else if self.flags.contains(CheckFlag::TypeDns) {
+            CheckType::Dns
+        } else if self.flags.contains(CheckFlag::TypeIcmp) {
+            if self.flags.contains(CheckFlag::IPv4) {
+                CheckType::IcmpV4
+            } else if self.flags.contains(CheckFlag::IPv6) {
+                CheckType::IcmpV6
+            } else {
+                eprintln!("flag for ICMP is set, but not if ipv4 or ipv6 was used");
+                CheckType::Unknown
+            }
+        } else {
+            CheckType::Unknown
+        }
+    }
+}
+
+impl Display for Check {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        writeln!(f, "Type: {}\nOk: {}", self.calc_type(), self.is_success())?;
+        writeln!(f, "Latency: {}", {
+            match self.latency() {
+                Some(l) => format!("{l} ms"),
+                None => "(Error)".to_string(),
+            }
+        })
+    }
 }
 
 #[cfg(test)]