Merge pull request #24 from PlexSheep/devel

cool new shit

Author: PlexSheep

Cargo.toml

@@ -29,11 +29,13 @@ zstd = { version = "0.13.2", optional = true }
 nix = { version = "0.29.0", features = ["signal", "process", "user"] }
 ping = { version = "0.5.2", optional = true }
 curl = { version = "0.4.47", optional = true, default-features = false }
-humantime = "2.1.0"
 caps = "0.5.5"
 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

@@ -29,6 +29,7 @@
 //! - Outage analysis
 //! - Store metadata (hashes, versions)
 
+use chrono::{DateTime, Local};
 use deepsize::DeepSizeOf;
 
 use crate::errors::AnalysisError;
@@ -39,6 +40,16 @@ use std::fmt::{Display, Write};
 use std::hash::Hash;
 use std::os::unix::fs::MetadataExt;
 
+/// Formatting rules for timestamps that are easily readable by humans.
+///
+/// ```rust
+/// use chrono::{DateTime, Local};
+/// # use netpulse::analyze::TIME_FORMAT_HUMANS;
+/// let datetime: DateTime<Local> = Local::now();
+/// println!("it is now: {}", datetime.format(TIME_FORMAT_HUMANS));
+/// ```
+pub const TIME_FORMAT_HUMANS: &str = "%Y-%m-%d %H:%M:%S %Z";
+
 /// Represents a period of consecutive failed checks.
 ///
 /// An outage is defined by:
@@ -86,14 +97,14 @@ impl Display for Outage<'_> {
             writeln!(
                 f,
                 "From {} To {}",
-                humantime::format_rfc3339_seconds(self.start.timestamp_parsed()),
-                humantime::format_rfc3339_seconds(self.end.unwrap().timestamp_parsed())
+                fmt_timestamp(self.start.timestamp_parsed()),
+                fmt_timestamp(self.end.unwrap().timestamp_parsed())
             )?;
         } else {
             writeln!(
                 f,
                 "From {} STILL ONGOING",
-                humantime::format_rfc3339_seconds(self.start.timestamp_parsed()),
+                fmt_timestamp(self.start.timestamp_parsed()),
             )?;
         }
         writeln!(f, "Checks: {}", self.all.len())?;
@@ -149,6 +160,28 @@ pub fn analyze(store: &Store) -> Result<String, AnalysisError> {
     Ok(f)
 }
 
+/// Formats a [SystemTime](std::time::SystemTime) as an easily readable timestamp for humans.
+///
+/// Works with [`std::time::SystemTime`] and [`chrono::DateTime<Local>`].
+///
+/// # Examples
+///
+/// ```rust
+/// # use netpulse::analyze::fmt_timestamp;
+/// use std::time::SystemTime;
+/// use chrono;
+/// let datetime: SystemTime = SystemTime::now();
+/// println!("it is now: {}", fmt_timestamp(datetime));
+/// let datetime: chrono::DateTime<chrono::Local> = chrono::Local::now();
+/// println!("it is now: {}", fmt_timestamp(datetime));
+/// let datetime: chrono::DateTime<chrono::Utc> = chrono::Utc::now();
+/// println!("it is now: {}", fmt_timestamp(datetime));
+/// ```
+pub fn fmt_timestamp(timestamp: impl Into<DateTime<Local>>) -> String {
+    let a: chrono::DateTime<chrono::Local> = timestamp.into();
+    format!("{}", a.format(TIME_FORMAT_HUMANS))
+}
+
 /// Adds a section divider to the report with a title.
 ///
 /// Creates a divider line of '=' characters with the title centered.
@@ -288,12 +321,12 @@ fn analyze_check_type_set(
     key_value_write(
         f,
         "first check at",
-        humantime::format_rfc3339_seconds(all.first().unwrap().timestamp_parsed()),
+        fmt_timestamp(all.first().unwrap().timestamp_parsed()),
     )?;
     key_value_write(
         f,
         "last check at",
-        humantime::format_rfc3339_seconds(all.last().unwrap().timestamp_parsed()),
+        fmt_timestamp(all.last().unwrap().timestamp_parsed()),
     )?;
     writeln!(f)?;
     Ok(())
@@ -374,11 +407,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/daemon.rs

@@ -19,7 +19,6 @@
 //! 3. Logs any cleanup errors
 
 use std::sync::atomic::AtomicBool;
-use std::time::{self, Duration, UNIX_EPOCH};
 
 use netpulse::errors::RunError;
 use netpulse::records::display_group;
@@ -59,19 +58,12 @@ pub(crate) fn daemon() {
             info!("restarting the daemon");
             store = load_store();
         }
-        let time = time::SystemTime::now();
-        if time
-            .duration_since(UNIX_EPOCH)
-            .expect("time is before the UNIX_EPOCH")
-            .as_secs()
-            % store.period_seconds()
-            == 0
-        {
+        if chrono::Utc::now().timestamp() % store.period_seconds() == 0 {
             if let Err(err) = wakeup(&mut store) {
                 error!("error in the wakeup turn: {err}");
             }
         }
-        std::thread::sleep(Duration::from_secs(1));
+        std::thread::sleep(std::time::Duration::from_secs(1));
     }
 }
 
@@ -97,7 +89,7 @@ fn load_store() -> Store {
 ///
 /// # Errors
 ///
-/// Returns [DaemonError] if store operations fail.
+/// Returns [RunError] if store operations fail.
 fn wakeup(store: &mut Store) -> Result<(), RunError> {
     info!("waking up!");
 
@@ -128,7 +120,7 @@ fn signal_hook() {
 ///
 /// # Errors
 ///
-/// Returns [DaemonError] if cleanup operations fail.
+/// Returns [RunError] if cleanup operations fail.
 fn cleanup(store: &Store) -> Result<(), RunError> {
     if let Err(err) = store.save() {
         error!("error while saving to file: {err:#?}");

src/bins/netpulse.rs

@@ -13,12 +13,14 @@
 
 use getopts::Options;
 use netpulse::analyze;
-use netpulse::common::{init_logging, print_usage};
+use netpulse::common::{init_logging, print_usage, setup_panic_handler};
 use netpulse::errors::RunError;
 use netpulse::records::{display_group, Check};
 use netpulse::store::Store;
+use tracing::error;
 
 fn main() {
+    setup_panic_handler();
     init_logging(tracing::Level::INFO);
     let args: Vec<String> = std::env::args().collect();
     let program = &args[0];
@@ -28,6 +30,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 +57,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 +105,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/bins/netpulsed.rs

@@ -31,6 +31,7 @@ use daemonize::Daemonize;
 use getopts::Options;
 use netpulse::common::{
     confirm, exec_cmd_for_user, getpid, getpid_running, init_logging, print_usage, root_guard,
+    setup_panic_handler,
 };
 use netpulse::errors::RunError;
 use netpulse::store::Store;
@@ -53,6 +54,7 @@ const SYSTEMD_SERVICE_PATH: &str = "/etc/systemd/system/netpulsed.service";
 static USES_DAEMON_SYSTEM: AtomicBool = AtomicBool::new(false);
 
 fn main() -> Result<(), RunError> {
+    setup_panic_handler();
     init_logging(tracing::Level::DEBUG);
     let args: Vec<String> = std::env::args().collect();
     let program = &args[0];

src/common.rs

@@ -33,12 +33,12 @@
 //!     println!("Daemon running with PID: {}", pid);
 //! }
 //! ```
-
 use std::io::{self, Write};
 use std::process::Command;
 use std::str::FromStr;
 
 use crate::DAEMON_PID_FILE;
+
 use getopts::Options;
 use tracing::{error, info, trace};
 use tracing_subscriber::FmtSubscriber;
@@ -261,3 +261,82 @@ pub fn getpid() -> Option<i32> {
         Some(pid)
     }
 }
+
+/// Sets up a custom panic handler for user-friendly error reporting.
+///
+/// Should be called early in the program startup, ideally before any other operations.
+/// In debug builds, uses the default panic handler for detailed debugging output.
+/// In release builds, provides a user-friendly error message with reporting instructions.
+///
+/// # Example Output
+///
+/// ```text
+/// Well, this is embarrassing.
+///
+/// netpulse had a problem and crashed. This is a bug and should be reported!
+///
+/// Technical details:
+/// Version:     0.1.0
+/// OS:          linux x86_64
+/// Command:     netpulse --check
+/// Error:       called `Option::unwrap()` on a `None` value
+/// Location:    src/store.rs:142
+///
+/// Please create a new issue at https://github.com/PlexSheep/netpulse/issues
+/// with the above technical details and what you were doing when this happened.
+/// ```
+pub fn setup_panic_handler() {
+    if !cfg!(debug_assertions) {
+        // Only override in release builds
+        std::panic::set_hook(Box::new(|panic_info| {
+            let mut message = String::new();
+            message.push_str("\nWell, this is embarrassing.\n\n");
+            message.push_str(&format!(
+                "{} had a problem and crashed. This is a bug and should be reported!\n\n",
+                env!("CARGO_PKG_NAME")
+            ));
+
+            message.push_str("Technical details:\n");
+            message.push_str(&format!("Version:     {}\n", env!("CARGO_PKG_VERSION")));
+
+            // Get OS info
+            #[cfg(target_os = "linux")]
+            let os = "linux";
+            #[cfg(target_os = "macos")]
+            let os = "macos";
+            #[cfg(target_os = "windows")]
+            let os = "windows";
+
+            message.push_str(&format!("OS:          {} {}\n", os, std::env::consts::ARCH));
+
+            // Get command line
+            let args: Vec<_> = std::env::args().collect();
+            message.push_str(&format!("Command:     {}\n", args.join(" ")));
+
+            // Extract error message and location
+            if let Some(msg) = panic_info.payload().downcast_ref::<&str>() {
+                message.push_str(&format!("Error:       {}\n", msg));
+            } else if let Some(msg) = panic_info.payload().downcast_ref::<String>() {
+                message.push_str(&format!("Error:       {}\n", msg));
+            }
+
+            if let Some(location) = panic_info.location() {
+                message.push_str(&format!(
+                    "Location:    {}:{}\n",
+                    location.file(),
+                    location.line()
+                ));
+            }
+
+            message.push_str(
+                "\nPlease create a new issue at https://github.com/PlexSheep/netpulse/issues\n",
+            );
+            message.push_str(
+                "with the above technical details and what you were doing when this happened.\n",
+            );
+
+            eprintln!("{}", message);
+            std::process::exit(1);
+        }));
+    }
+}

src/errors.rs

@@ -3,7 +3,7 @@
 //! This module provides specialized error types for different components of netpulse:
 //! - [`StoreError`] - Errors related to store operations (loading, saving, versioning)
 //! - [`CheckError`] - Errors that occur during network checks (HTTP, ICMP)
-//! - [`DaemonError`] - Errors specific to daemon operations
+//! - [`RunError`] - Errors specific to executable operations
 //! - [`AnalysisError`] - Errors that occur during analysis and report generation
 //!
 //! All error types implement the standard Error trait and provide detailed error information.
@@ -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]
@@ -86,14 +86,15 @@ pub enum StoreError {
     ///
     /// This variant contains a [FlagSet] with only the flags [CheckFlags](CheckFlag) set that
     /// would make it a valid state. Exactly one of these flags must be set.
-    ///
-    /// # Example
-    ///
-    /// Every check should have either [CheckFlag::IPv4] or [CheckFlag::IPv6] set. If none of these
-    /// are set, this error will be returned with a [FlagSet] that has both flags set, to indicate
-    /// that one of these should be set.
     #[error("Check is missing at least one of these flags: {0:?}")]
     MissingFlag(FlagSet<CheckFlag>),
+    /// Occurs when trying to convert an arbitrary [u8] to a [Version](crate::store::Version) that
+    /// 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.