refactor: Simplify data harvesting (#335)

Refactors the data harvesting system function names.

5 files changed, 25 insertions, 45 deletions

diff --git a/src/app/data_harvester.rs b/src/app/data_harvester.rs
index 2e46559a..0f59b54f 100644
--- a/src/app/data_harvester.rs
+++ b/src/app/data_harvester.rs
@@ -236,13 +236,10 @@ impl DataCollector {
         }
 
         if self.widgets_to_harvest.use_proc {
-            // Processes.  This is the longest part of the harvesting process... changing this might be
-            // good in the future.  What was tried already:
-            // * Splitting the internal part into multiple scoped threads (dropped by ~.01 seconds, but upped usage)
-            if let Ok(process_list) = if cfg!(target_os = "linux") {
+            if let Ok(process_list) = {
                 #[cfg(target_os = "linux")]
                 {
-                    processes::linux_processes(
+                    processes::get_process_data(
                         &mut self.prev_idle,
                         &mut self.prev_non_idle,
                         &mut self.pid_mapping,
@@ -256,21 +253,12 @@ impl DataCollector {
                 }
                 #[cfg(not(target_os = "linux"))]
                 {
-                    Ok(Vec::new())
-                }
-            } else {
-                #[cfg(not(target_os = "linux"))]
-                {
-                    processes::windows_macos_processes(
+                    processes::get_process_data(
                         &self.sys,
                         self.use_current_cpu_total,
                         self.mem_total_kb,
                     )
                 }
-                #[cfg(target_os = "linux")]
-                {
-                    Ok(Vec::new())
-                }
             } {
                 self.data.list_of_processes = Some(process_list);
             }
@@ -288,7 +276,7 @@ impl DataCollector {
         let network_data_fut = {
             #[cfg(any(target_os = "windows", target_arch = "aarch64", target_arch = "arm"))]
             {
-                network::arm_or_windows_network_data(
+                network::get_network_data(
                     &self.sys,
                     self.last_collection_time,
                     &mut self.total_rx,
@@ -299,7 +287,7 @@ impl DataCollector {
             }
             #[cfg(not(any(target_os = "windows", target_arch = "aarch64", target_arch = "arm")))]
             {
-                network::non_arm_or_windows_network_data(
+                network::get_network_data(
                     self.last_collection_time,
                     &mut self.total_rx,
                     &mut self.total_tx,
@@ -311,45 +299,45 @@ impl DataCollector {
         let mem_data_fut = {
             #[cfg(any(target_arch = "aarch64", target_arch = "arm"))]
             {
-                mem::arm_mem_data(&self.sys, self.widgets_to_harvest.use_mem)
+                mem::get_mem_data(&self.sys, self.widgets_to_harvest.use_mem)
             }
 
             #[cfg(not(any(target_arch = "aarch64", target_arch = "arm")))]
             {
-                mem::non_arm_mem_data(self.widgets_to_harvest.use_mem)
+                mem::get_mem_data(self.widgets_to_harvest.use_mem)
             }
         };
         let swap_data_fut = {
             #[cfg(any(target_arch = "aarch64", target_arch = "arm"))]
             {
-                mem::arm_swap_data(&self.sys, self.widgets_to_harvest.use_mem)
+                mem::get_swap_data(&self.sys, self.widgets_to_harvest.use_mem)
             }
 
             #[cfg(not(any(target_arch = "aarch64", target_arch = "arm")))]
             {
-                mem::non_arm_swap_data(self.widgets_to_harvest.use_mem)
+                mem::get_swap_data(self.widgets_to_harvest.use_mem)
             }
         };
         let disk_data_fut = {
             #[cfg(any(target_arch = "aarch64", target_arch = "arm"))]
             {
-                disks::arm_disk_usage(&self.sys, self.widgets_to_harvest.use_disk)
+                disks::get_disk_usage(&self.sys, self.widgets_to_harvest.use_disk)
             }
 
             #[cfg(not(any(target_arch = "aarch64", target_arch = "arm")))]
             {
-                disks::non_arm_disk_usage(self.widgets_to_harvest.use_disk)
+                disks::get_disk_usage(self.widgets_to_harvest.use_disk)
             }
         };
         let disk_io_usage_fut = {
             #[cfg(any(target_arch = "aarch64", target_arch = "arm"))]
             {
-                disks::arm_io_usage(&self.sys, self.widgets_to_harvest.use_disk)
+                disks::get_io_usage(&self.sys, self.widgets_to_harvest.use_disk)
             }
 
             #[cfg(not(any(target_arch = "aarch64", target_arch = "arm")))]
             {
-                disks::non_arm_io_usage(false, self.widgets_to_harvest.use_disk)
+                disks::get_io_usage(false, self.widgets_to_harvest.use_disk)
             }
         };
         let temp_data_fut = {
diff --git a/src/app/data_harvester/disks.rs b/src/app/data_harvester/disks.rs
index 59e9d13c..cb7ca0f4 100644
--- a/src/app/data_harvester/disks.rs
+++ b/src/app/data_harvester/disks.rs
@@ -18,9 +18,8 @@ pub struct IOData {
 
 pub type IOHarvest = std::collections::HashMap<String, Option<IOData>>;
 
-/// Meant for ARM use.
 #[cfg(any(target_arch = "aarch64", target_arch = "arm"))]
-pub async fn arm_io_usage(
+pub async fn get_io_usage(
     _sys: &sysinfo::System, _actually_get: bool,
 ) -> crate::utils::error::Result<Option<IOHarvest>> {
     let io_hash: std::collections::HashMap<String, Option<IOData>> =
@@ -32,9 +31,8 @@ pub async fn arm_io_usage(
     // work.  See https://github.com/GuillaumeGomez/sysinfo/issues/304.
 }
 
-/// Meant for ARM use.
 #[cfg(any(target_arch = "aarch64", target_arch = "arm"))]
-pub async fn arm_disk_usage(
+pub async fn get_disk_usage(
     sys: &sysinfo::System, actually_get: bool,
 ) -> crate::utils::error::Result<Option<Vec<DiskHarvest>>> {
     use sysinfo::{DiskExt, SystemExt};
@@ -61,7 +59,7 @@ pub async fn arm_disk_usage(
 }
 
 #[cfg(not(any(target_arch = "aarch64", target_arch = "arm")))]
-pub async fn non_arm_io_usage(
+pub async fn get_io_usage(
     get_physical: bool, actually_get: bool,
 ) -> crate::utils::error::Result<Option<IOHarvest>> {
     if !actually_get {
@@ -104,7 +102,7 @@ pub async fn non_arm_io_usage(
 }
 
 #[cfg(not(any(target_arch = "aarch64", target_arch = "arm")))]
-pub async fn non_arm_disk_usage(
+pub async fn get_disk_usage(
     actually_get: bool,
 ) -> crate::utils::error::Result<Option<Vec<DiskHarvest>>> {
     if !actually_get {
diff --git a/src/app/data_harvester/mem.rs b/src/app/data_harvester/mem.rs
index e108e867..5f91b40e 100644
--- a/src/app/data_harvester/mem.rs
+++ b/src/app/data_harvester/mem.rs
@@ -13,9 +13,8 @@ impl Default for MemHarvest {
     }
 }
 
-/// Meant for ARM use.
 #[cfg(any(target_arch = "aarch64", target_arch = "arm"))]
-pub async fn arm_mem_data(
+pub async fn get_mem_data(
     sys: &sysinfo::System, actually_get: bool,
 ) -> crate::utils::error::Result<Option<MemHarvest>> {
     use sysinfo::SystemExt;
@@ -29,9 +28,8 @@ pub async fn arm_mem_data(
     }))
 }
 
-/// Meant for ARM use.
 #[cfg(any(target_arch = "aarch64", target_arch = "arm"))]
-pub async fn arm_swap_data(
+pub async fn get_swap_data(
     sys: &sysinfo::System, actually_get: bool,
 ) -> crate::utils::error::Result<Option<MemHarvest>> {
     use sysinfo::SystemExt;
@@ -46,9 +44,7 @@ pub async fn arm_swap_data(
 }
 
 #[cfg(not(any(target_arch = "aarch64", target_arch = "arm")))]
-pub async fn non_arm_mem_data(
-    actually_get: bool,
-) -> crate::utils::error::Result<Option<MemHarvest>> {
+pub async fn get_mem_data(actually_get: bool) -> crate::utils::error::Result<Option<MemHarvest>> {
     if !actually_get {
         return Ok(None);
     }
@@ -65,9 +61,7 @@ pub async fn non_arm_mem_data(
 }
 
 #[cfg(not(any(target_arch = "aarch64", target_arch = "arm")))]
-pub async fn non_arm_swap_data(
-    actually_get: bool,
-) -> crate::utils::error::Result<Option<MemHarvest>> {
+pub async fn get_swap_data(actually_get: bool) -> crate::utils::error::Result<Option<MemHarvest>> {
     if !actually_get {
         return Ok(None);
     }
diff --git a/src/app/data_harvester/network.rs b/src/app/data_harvester/network.rs
index 95e15476..9b37fc7a 100644
--- a/src/app/data_harvester/network.rs
+++ b/src/app/data_harvester/network.rs
@@ -17,7 +17,7 @@ impl NetworkHarvest {
 
 /// Meant for Windows and ARM use.
 #[cfg(any(target_os = "windows", target_arch = "aarch64", target_arch = "arm"))]
-pub async fn arm_or_windows_network_data(
+pub async fn get_network_data(
     sys: &sysinfo::System, prev_net_access_time: Instant, prev_net_rx: &mut u64,
     prev_net_tx: &mut u64, curr_time: Instant, actually_get: bool,
 ) -> Option<NetworkHarvest> {
@@ -58,7 +58,7 @@ pub async fn arm_or_windows_network_data(
 }
 
 #[cfg(not(any(target_os = "windows", target_arch = "aarch64", target_arch = "arm")))]
-pub async fn non_arm_or_windows_network_data(
+pub async fn get_network_data(
     prev_net_access_time: Instant, prev_net_rx: &mut u64, prev_net_tx: &mut u64,
     curr_time: Instant, actually_get: bool,
 ) -> Option<NetworkHarvest> {
diff --git a/src/app/data_harvester/processes.rs b/src/app/data_harvester/processes.rs
index a182db23..a79f8585 100644
--- a/src/app/data_harvester/processes.rs
+++ b/src/app/data_harvester/processes.rs
@@ -369,7 +369,7 @@ fn read_proc<S: core::hash::BuildHasher>(
 }
 
 #[cfg(target_os = "linux")]
-pub fn linux_processes(
+pub fn get_process_data(
     prev_idle: &mut f64, prev_non_idle: &mut f64,
     pid_mapping: &mut HashMap<Pid, PrevProcDetails, RandomState>, use_current_cpu_total: bool,
     time_difference_in_secs: u64, mem_total_kb: u64, page_file_kb: u64,
@@ -409,7 +409,7 @@ pub fn linux_processes(
 }
 
 #[cfg(not(target_os = "linux"))]
-pub fn windows_macos_processes(
+pub fn get_process_data(
     sys: &System, use_current_cpu_total: bool, mem_total_kb: u64,
 ) -> crate::utils::error::Result<Vec<ProcessHarvest>> {
     let mut process_vector: Vec<ProcessHarvest> = Vec::new();