Implement support for FreeBSD (#766)

* WIP FreeBSD support

* Implement get_cpu_data_list for FreeBSD

* Implement disks for FreeBSD

It doesn't work though as sysinfo doesn't make the device name available.

* Use libxo to read process cpu info on FreeBSD

* Populate get_io_usage with libxo too

Actual I/O stats still aren't populated though as there's not an
easy source for them.

* Share more processes code between macos and freebsd

* Extract function for deserializing libxo output on FreeBSD

* Implement filtering of disks in FreeBSD

* Clean up memory data collection

* Update module docs

Author: wezm

Diff for: Cargo.lock

@@ -94,6 +94,9 @@ heim = { version = "0.1.0-rc.1", features = ["cpu", "disk", "memory", "net"] }
 heim = { version = "0.1.0-rc.1", features = ["cpu", "disk", "memory"] }
 winapi = "0.3.9"
 
+[target.'cfg(target_os = "freebsd")'.dependencies]
+serde_json = { version = "1.0.82" }
+
 [dev-dependencies]
 assert_cmd = "2.0.4"
 predicates = "2.1.1"

Diff for: Cargo.toml

@@ -158,6 +158,9 @@ const MAX_SIGNAL: usize = 1;
 const MAX_SIGNAL: usize = 64;
 #[cfg(target_os = "macos")]
 const MAX_SIGNAL: usize = 31;
+// https://www.freebsd.org/cgi/man.cgi?query=signal&apropos=0&sektion=3&manpath=FreeBSD+13.1-RELEASE+and+Ports&arch=default&format=html
+#[cfg(target_os = "freebsd")]
+const MAX_SIGNAL: usize = 33;
 
 impl App {
     pub fn reset(&mut self) {

Diff for: src/app.rs

@@ -161,6 +161,15 @@ impl DataCollector {
             if cfg!(target_os = "windows") && self.widgets_to_harvest.use_net {
                 self.sys.refresh_networks_list();
             }
+
+            if cfg!(target_os = "freebsd") && self.widgets_to_harvest.use_cpu {
+                self.sys.refresh_cpu();
+            }
+
+            // Refresh disk list once...
+            if cfg!(target_os = "freebsd") && self.widgets_to_harvest.use_disk {
+                self.sys.refresh_disks_list();
+            }
         }
 
         #[cfg(feature = "battery")]
@@ -215,31 +224,54 @@ impl DataCollector {
     pub async fn update_data(&mut self) {
         #[cfg(not(target_os = "linux"))]
         {
-            if self.widgets_to_harvest.use_proc {
+            if self.widgets_to_harvest.use_proc || self.widgets_to_harvest.use_cpu {
                 self.sys.refresh_cpu();
+            }
+            if self.widgets_to_harvest.use_proc {
                 self.sys.refresh_processes();
             }
             if self.widgets_to_harvest.use_temp {
                 self.sys.refresh_components();
             }
-
             if cfg!(target_os = "windows") && self.widgets_to_harvest.use_net {
                 self.sys.refresh_networks();
             }
+            if cfg!(target_os = "freebsd") && self.widgets_to_harvest.use_disk {
+                self.sys.refresh_disks();
+            }
+            if cfg!(target_os = "freebsd") && self.widgets_to_harvest.use_mem {
+                self.sys.refresh_memory();
+            }
         }
 
         let current_instant = std::time::Instant::now();
 
         // CPU
         if self.widgets_to_harvest.use_cpu {
-            if let Ok(cpu_data) = cpu::get_cpu_data_list(
-                self.show_average_cpu,
-                &mut self.previous_cpu_times,
-                &mut self.previous_average_cpu_time,
-            )
-            .await
+            #[cfg(not(target_os = "freebsd"))]
             {
-                self.data.cpu = Some(cpu_data);
+                if let Ok(cpu_data) = cpu::get_cpu_data_list(
+                    self.show_average_cpu,
+                    &mut self.previous_cpu_times,
+                    &mut self.previous_average_cpu_time,
+                )
+                .await
+                {
+                    self.data.cpu = Some(cpu_data);
+                }
+            }
+            #[cfg(target_os = "freebsd")]
+            {
+                if let Ok(cpu_data) = cpu::get_cpu_data_list(
+                    &self.sys,
+                    self.show_average_cpu,
+                    &mut self.previous_cpu_times,
+                    &mut self.previous_average_cpu_time,
+                )
+                .await
+                {
+                    self.data.cpu = Some(cpu_data);
+                }
             }
 
             #[cfg(target_family = "unix")]
@@ -304,7 +336,7 @@ impl DataCollector {
         }
 
         let network_data_fut = {
-            #[cfg(target_os = "windows")]
+            #[cfg(any(target_os = "windows", target_os = "freebsd"))]
             {
                 network::get_network_data(
                     &self.sys,
@@ -316,7 +348,7 @@ impl DataCollector {
                     &self.filters.net_filter,
                 )
             }
-            #[cfg(not(target_os = "windows"))]
+            #[cfg(not(any(target_os = "windows", target_os = "freebsd")))]
             {
                 network::get_network_data(
                     self.last_collection_time,
@@ -328,7 +360,16 @@ impl DataCollector {
                 )
             }
         };
-        let mem_data_fut = memory::get_mem_data(self.widgets_to_harvest.use_mem);
+        let mem_data_fut = {
+            #[cfg(not(target_os = "freebsd"))]
+            {
+                memory::get_mem_data(self.widgets_to_harvest.use_mem)
+            }
+            #[cfg(target_os = "freebsd")]
+            {
+                memory::get_mem_data(&self.sys, self.widgets_to_harvest.use_mem)
+            }
+        };
         let disk_data_fut = disks::get_disk_usage(
             self.widgets_to_harvest.use_disk,
             &self.filters.disk_filter,
@@ -397,3 +438,17 @@ impl DataCollector {
         self.last_collection_time = current_instant;
     }
 }
+
+#[cfg(target_os = "freebsd")]
+/// Deserialize [libxo](https://www.freebsd.org/cgi/man.cgi?query=libxo&apropos=0&sektion=0&manpath=FreeBSD+13.1-RELEASE+and+Ports&arch=default&format=html) JSON data
+fn deserialize_xo<T>(key: &str, data: &[u8]) -> Result<T, std::io::Error>
+where
+    T: serde::de::DeserializeOwned,
+{
+    let mut value: serde_json::Value = serde_json::from_slice(data)?;
+    value
+        .as_object_mut()
+        .and_then(|map| map.remove(key))
+        .ok_or_else(|| std::io::Error::new(std::io::ErrorKind::Other, "key not found"))
+        .and_then(|val| serde_json::from_value(val).map_err(|err| err.into()))
+}

Diff for: src/app/data_harvester.rs

@@ -1,14 +1,29 @@
 //! Data collection for CPU usage and load average.
 //!
-//! For CPU usage, Linux, macOS, and Windows are handled by Heim.
+//! For CPU usage, Linux, macOS, and Windows are handled by Heim, FreeBSD by sysinfo.
 //!
-//! For load average, macOS and Linux are supported through Heim.
+//! For load average, macOS and Linux are supported through Heim, FreeBSD by sysinfo.
 
 cfg_if::cfg_if! {
     if #[cfg(any(target_os = "linux", target_os = "macos", target_os = "windows"))] {
         pub mod heim;
         pub use self::heim::*;
+    } else if #[cfg(target_os = "freebsd")] {
+        pub mod sysinfo;
+        pub use self::sysinfo::*;
     }
 }
 
 pub type LoadAvgHarvest = [f32; 3];
+
+#[derive(Default, Debug, Clone)]
+pub struct CpuData {
+    pub cpu_prefix: String,
+    pub cpu_count: Option<usize>,
+    pub cpu_usage: f64,
+}
+
+pub type CpuHarvest = Vec<CpuData>;
+
+pub type PastCpuWork = f64;
+pub type PastCpuTotal = f64;

Diff for: src/app/data_harvester/cpu.rs

@@ -18,18 +18,7 @@ cfg_if::cfg_if! {
     }
 }
 
-#[derive(Default, Debug, Clone)]
-pub struct CpuData {
-    pub cpu_prefix: String,
-    pub cpu_count: Option<usize>,
-    pub cpu_usage: f64,
-}
-
-pub type CpuHarvest = Vec<CpuData>;
-
-pub type PastCpuWork = f64;
-pub type PastCpuTotal = f64;
-
+use crate::data_harvester::cpu::{CpuData, CpuHarvest, PastCpuTotal, PastCpuWork};
 use futures::StreamExt;
 use std::collections::VecDeque;
 

Diff for: src/app/data_harvester/cpu/heim.rs

@@ -0,0 +1,45 @@
+//! CPU stats through sysinfo.
+//! Supports FreeBSD.
+
+use std::collections::VecDeque;
+
+use sysinfo::{LoadAvg, ProcessorExt, System, SystemExt};
+
+use super::{CpuData, CpuHarvest, PastCpuTotal, PastCpuWork};
+use crate::app::data_harvester::cpu::LoadAvgHarvest;
+
+pub async fn get_cpu_data_list(
+    sys: &sysinfo::System, show_average_cpu: bool,
+    _previous_cpu_times: &mut Vec<(PastCpuWork, PastCpuTotal)>,
+    _previous_average_cpu_time: &mut Option<(PastCpuWork, PastCpuTotal)>,
+) -> crate::error::Result<CpuHarvest> {
+    let mut cpu_deque: VecDeque<_> = sys
+        .processors()
+        .iter()
+        .enumerate()
+        .map(|(i, cpu)| CpuData {
+            cpu_prefix: "CPU".to_string(),
+            cpu_count: Some(i),
+            cpu_usage: cpu.cpu_usage() as f64,
+        })
+        .collect();
+
+    if show_average_cpu {
+        let cpu = sys.global_processor_info();
+
+        cpu_deque.push_front(CpuData {
+            cpu_prefix: "AVG".to_string(),
+            cpu_count: None,
+            cpu_usage: cpu.cpu_usage() as f64,
+        })
+    }
+
+    Ok(Vec::from(cpu_deque))
+}
+
+pub async fn get_load_avg() -> crate::error::Result<LoadAvgHarvest> {
+    let sys = System::new();
+    let LoadAvg { one, five, fifteen } = sys.load_average();
+
+    Ok([one as f32, five as f32, fifteen as f32])
+}

Diff for: src/app/data_harvester/cpu/sysinfo.rs

@@ -1,10 +1,31 @@
 //! Data collection for disks (IO, usage, space, etc.).
 //!
-//! For Linux, macOS, and Windows, this is handled by heim.
+//! For Linux, macOS, and Windows, this is handled by heim. For FreeBSD there is a custom
+//! implementation.
 
 cfg_if::cfg_if! {
     if #[cfg(any(target_os = "linux", target_os = "macos", target_os = "windows"))] {
         pub mod heim;
         pub use self::heim::*;
+    } else if #[cfg(target_os = "freebsd")] {
+        pub mod freebsd;
+        pub use self::freebsd::*;
     }
 }
+
+#[derive(Debug, Clone, Default)]
+pub struct DiskHarvest {
+    pub name: String,
+    pub mount_point: String,
+    pub free_space: Option<u64>,
+    pub used_space: Option<u64>,
+    pub total_space: Option<u64>,
+}
+
+#[derive(Clone, Debug)]
+pub struct IoData {
+    pub read_bytes: u64,
+    pub write_bytes: u64,
+}
+
+pub type IoHarvest = std::collections::HashMap<String, Option<IoData>>;