Split SystemInformation into modules, add logging

Fixes #6

Author: nightkr

src/main.rs

@@ -1,16 +1,10 @@
 mod system_information;
 
 use clap::Parser;
-use local_ip_address::list_afinet_netifas;
-use std::collections::{HashMap, HashSet};
 use std::path::PathBuf;
-use sysinfo::{Disks, System};
 
-use crate::system_information::{SystemInformation, SystemNetworkInfo};
-use hickory_resolver::system_conf::read_system_conf;
-use hickory_resolver::Resolver;
-use std::net::IpAddr;
-use std::time::{Duration, Instant};
+use crate::system_information::SystemInformation;
+use std::time::Instant;
 
 /// Collects and prints helpful debugging information about the environment that it is running in.
 #[derive(clap::Parser)]
@@ -36,161 +30,23 @@ fn main() {
 
     let mut next_run = Instant::now();
     loop {
-        std::thread::sleep(next_run.saturating_duration_since(Instant::now()));
-
-        tracing::info!("starting run");
-
-        // Please note that we use "new_all" to ensure that all list of
-        // components, network interfaces, disks and users are already
-        // filled!
-        let sys = System::new_all();
-
-        let disks = Disks::new_with_refreshed_list();
-        let disks = disks
-            .into_iter()
-            .map(system_information::Disk::from)
-            .collect();
-
-        let system_network_information = get_network_info();
-
-        let current_uid = users::get_current_uid();
-        let current_gid = users::get_current_gid();
-        let current_user = users::get_user_by_uid(current_uid).unwrap();
-
-        let system_information = SystemInformation {
-            cpu_count: sys.cpus().len(),
-            physical_core_count: sys.physical_core_count(),
-
-            total_memory: sys.total_memory(),
-            free_memory: sys.free_memory(),
-            available_memory: sys.available_memory(),
-            used_memory: sys.used_memory(),
-
-            total_swap: sys.total_swap(),
-            free_swap: sys.free_swap(),
-            used_swap: sys.used_swap(),
-
-            total_memory_cgroup: sys.cgroup_limits().map(|limit| limit.total_memory),
-            free_memory_cgroup: sys.cgroup_limits().map(|limit| limit.free_memory),
-            free_swap_cgroup: sys.cgroup_limits().map(|limit| limit.free_swap),
-
-            system_name: System::name(),
-            kernel_version: System::kernel_version(),
-            os_version: System::long_os_version(),
-            host_name: System::host_name(),
-            cpu_arch: System::cpu_arch(),
-
-            disks,
-
-            network_information: system_network_information,
+        let next_run_sleep = next_run.saturating_duration_since(Instant::now());
+        if !next_run_sleep.is_zero() {
+            tracing::info!(?next_run, "scheduling next run...");
+        }
+        std::thread::sleep(next_run_sleep);
 
-            // Adding current user, UID, and GID info
-            current_user: current_user.name().to_str().unwrap().to_string(),
-            current_uid,
-            current_gid,
-        };
+        let system_information = SystemInformation::collect();
 
         let serialized = serde_json::to_string_pretty(&system_information).unwrap();
-        println!("{}", serialized);
+        // println!("{serialized}");
         if let Some(output_path) = &opts.output {
             std::fs::write(output_path, &serialized).unwrap();
         }
 
-        // TODO:
-        //  Current time
-        //  SElinux/AppArmor
-        //  Maybe env variables (may contain secrets)
-        //  dmesg/syslog?
-        //  capabilities?
-        //  downward API
-        //  Somehow get the custom resources logged?
-
-        // Things left out for now because it doesn't seem too useful:
-        // - Running processes
-        // - Uptime/boot time
-        // - Load average
-        // - Network utilization
-        // - Users/Groups
-
         match opts.loop_interval {
-            Some(interval) => {
-                next_run += interval;
-                tracing::info!(?next_run, "run completed, scheduling next...");
-            }
+            Some(interval) => next_run += interval,
             None => break,
         }
     }
 }
-
-fn get_network_info() -> SystemNetworkInfo {
-    /*
-    let resolver = Resolver::from_system_conf()
-        .map_err(|e| e.to_string())
-        .unwrap();
-     */
-    let (resolver_config, mut resolver_opts) = read_system_conf().unwrap();
-    resolver_opts.timeout = Duration::from_secs(5);
-    let resolver = Resolver::new(resolver_config, resolver_opts).unwrap();
-
-    let interfaces = match list_afinet_netifas() {
-        Ok(netifs) => {
-            let mut interface_map = std::collections::HashMap::new();
-
-            // Iterate over the network interfaces and group them by name
-            // An interface may appear multiple times if it has multiple IP addresses (e.g. IPv4 and IPv6)
-            for (name, ip_addr) in netifs {
-                interface_map
-                    .entry(name)
-                    .or_insert_with(Vec::new)
-                    .push(ip_addr);
-            }
-            interface_map
-        }
-        Err(_) => HashMap::new(),
-    };
-
-    let mut ip_set: HashSet<IpAddr> = HashSet::new();
-    for (_, ip_addrs) in interfaces.iter() {
-        for ip_addr in ip_addrs {
-            ip_set.insert(*ip_addr);
-        }
-    }
-
-    let mut reverse_lookups = HashMap::new();
-    for ip in ip_set {
-        if let Ok(result) = resolver.reverse_lookup(ip) {
-            for ptr_record in result {
-                let hostname = ptr_record.to_utf8();
-                reverse_lookups
-                    .entry(ip)
-                    .or_insert_with(Vec::new)
-                    .push(hostname);
-            }
-        }
-    }
-
-    let mut hostname_set: HashSet<String> = HashSet::new();
-    for (_, hostnames) in reverse_lookups.iter() {
-        for hostname in hostnames {
-            hostname_set.insert(hostname.clone());
-        }
-    }
-
-    let mut forward_lookups = HashMap::new();
-    for hostname in hostname_set {
-        if let Ok(result) = resolver.lookup_ip(hostname.clone()) {
-            for ip_addr in result {
-                forward_lookups
-                    .entry(hostname.clone())
-                    .or_insert_with(Vec::new)
-                    .push(ip_addr);
-            }
-        }
-    }
-
-    SystemNetworkInfo {
-        network_interfaces: interfaces,
-        reverse_lookups,
-        forward_lookups,
-    }
-}

src/system_information.rs

@@ -0,0 +1,39 @@
+use serde::Serialize;
+
+#[derive(Debug, Serialize)]
+pub struct Disk {
+    pub name: String,
+    pub mount_point: String,
+    pub total_space: u64,
+    pub available_space: u64,
+}
+
+impl Disk {
+    #[tracing::instrument(name = "Disk::collect_all")]
+    pub fn collect_all() -> Vec<Self> {
+        let disks = sysinfo::Disks::new_with_refreshed_list();
+        if disks.into_iter().next().is_none() {
+            tracing::info!("no disks found");
+        }
+        disks.into_iter().map(Self::from).collect()
+    }
+}
+
+impl From<&sysinfo::Disk> for Disk {
+    fn from(sysinfo_disk: &sysinfo::Disk) -> Self {
+        let disk = Disk {
+            name: sysinfo_disk.name().to_string_lossy().into_owned(),
+            mount_point: sysinfo_disk.mount_point().to_string_lossy().into_owned(),
+            total_space: sysinfo_disk.total_space(),
+            available_space: sysinfo_disk.available_space(),
+        };
+        tracing::info!(
+            disk.mount_point,
+            disk.name,
+            disk.space.total = disk.total_space,
+            disk.space.available = disk.available_space,
+            "found disk"
+        );
+        disk
+    }
+}

src/system_information/disk.rs

@@ -0,0 +1,47 @@
+use serde::Serialize;
+
+pub mod disk;
+pub mod network;
+pub mod os;
+pub mod resources;
+pub mod user;
+
+#[derive(Debug, Serialize)]
+pub struct SystemInformation {
+    pub resources: resources::Resources,
+    pub os: os::OperatingSystem,
+    pub current_user: user::User,
+    pub disks: Vec<disk::Disk>,
+    pub network: network::SystemNetworkInfo,
+    // TODO:
+    //  Current time
+    //  SElinux/AppArmor
+    //  Maybe env variables (may contain secrets)
+    //  dmesg/syslog?
+    //  capabilities?
+    //  downward API
+    //  Somehow get the custom resources logged?
+
+    // Things left out for now because it doesn't seem too useful:
+    // - Running processes
+    // - Uptime/boot time
+    // - Load average
+    // - Network utilization
+    // - Users/Groups
+}
+
+impl SystemInformation {
+    #[tracing::instrument(name = "SystemInformation::collect")]
+    pub fn collect() -> Self {
+        tracing::info!("Starting data collection");
+        let info = Self {
+            resources: resources::Resources::collect(),
+            os: os::OperatingSystem::collect(),
+            current_user: user::User::collect_current(),
+            disks: disk::Disk::collect_all(),
+            network: network::SystemNetworkInfo::collect(),
+        };
+        tracing::info!("Data collection finished");
+        info
+    }
+}