big changes

ClementTsang · ClementTsang · Apr 10, 2023 · Mar 9, 2023 · Mar 11, 2023 · Mar 14, 2023
commit 4d5f25027984c6f7548ad12cf23567a1800270ab
diff --git a/src/app/data_harvester.rs b/src/app/data_harvester.rs
@@ -430,9 +430,9 @@ impl DataCollector {
         if self.widgets_to_harvest.use_disk {
             #[cfg(any(target_os = "freebsd", target_os = "linux", target_os = "macos"))]
             {
-                self.data.disks =
-                    disks::get_disk_usage(&self.filters.disk_filter, &self.filters.mount_filter)
-                        .ok();
+                let disk_filter = &self.filters.disk_filter;
+                let mount_filter = &self.filters.mount_filter;
+                self.data.disks = disks::get_disk_usage(disk_filter, mount_filter).ok();
             }
 
             #[cfg(target_os = "windows")]

diff --git a/src/app/data_harvester/disks.rs b/src/app/data_harvester/disks.rs
@@ -2,14 +2,6 @@
 
 use std::collections::HashMap;
 
-cfg_if::cfg_if! {
-    if #[cfg(target_family = "unix")]
-    {
-        pub mod unix;
-        pub use self::unix::*;
-    }
-}
-
 cfg_if::cfg_if! {
     if #[cfg(target_os = "freebsd")] {
         pub mod freebsd;
@@ -18,8 +10,13 @@ cfg_if::cfg_if! {
         pub mod windows;
         pub use self::windows::*;
     } else if #[cfg(target_os = "linux")] {
-        pub(crate) mod linux;
+        pub mod unix;
+        pub use self::unix::*;
+    } else if #[cfg(target_os = "macos")] {
+        pub mod unix;
+        pub use self::unix::*;
     }
+    // TODO: Add dummy impls here for other OSes?
 }
 
 #[derive(Debug, Clone, Default)]

diff --git a/src/app/data_harvester/disks/heim.rs b/src/app/data_harvester/disks/heim.rs
diff --git a/src/app/data_harvester/disks/unix.rs b/src/app/data_harvester/disks/unix.rs
@@ -1,41 +1,121 @@
-//! Implementation based on [heim's](https://github.com/heim-rs/heim)
-//! Unix disk usage.
+//! Disk stats for Unix-like systems that aren't supported through other means.
 
-use std::path::Path;
+use crate::app::Filter;
+use crate::data_harvester::disks::{DiskHarvest, IoData, IoHarvest};
 
-use crate::app::{
-    data_harvester::disks::{DiskHarvest, IoHarvest},
-    filter::Filter,
-};
+pub fn get_io_usage() -> anyhow::Result<IoHarvest> {
+    // if !actually_get {
+    //     return Ok(None);
+    // }
 
-mod file_systems;
-pub(crate) use file_systems::FileSystem;
+    // let mut io_hash: std::collections::HashMap<String, Option<IoData>> =
+    //     std::collections::HashMap::new();
 
-cfg_if::cfg_if! {
-    if #[cfg(target_os = "linux")] {
-        use super::linux::partitions;
-    } else {
-        mod partition;
-        mod mounts;
+    // let counter_stream = heim::disk::io_counters().await?;
 
-        use partition::*;
-    }
-}
+    // while let Some(io) = counter_stream.next().await {
+    //     if let Ok(io) = io {
+    //         let mount_point = io.device_name().to_str().unwrap_or("Mount Unavailable");
+
+    //         io_hash.insert(
+    //             mount_point.to_string(),
+    //             Some(IoData {
+    //                 read_bytes: io.read_bytes().get::<heim::units::information::byte>(),
+    //                 write_bytes: io.write_bytes().get::<heim::units::information::byte>(),
+    //             }),
+    //         );
+    //     }
+    // }
 
-pub(crate) struct Usage {}
+    // Ok(Some(io_hash))
 
-fn disk_usage(path: &Path) -> anyhow::Result<Usage> {
     todo!()
 }
 
 pub fn get_disk_usage(
     disk_filter: &Option<Filter>, mount_filter: &Option<Filter>,
 ) -> anyhow::Result<Vec<DiskHarvest>> {
-    let partitions = partitions()?;
+    todo!()
+    // let mut vec_disks: Vec<DiskHarvest> = Vec::new();
+    // let partitions_stream = heim::disk::partitions_physical().await?;
 
-    Ok(vec![])
-}
+    // while let Some(part) = partitions_stream.next().await {
+    //     if let Ok(partition) = part {
+    //         let name = get_device_name(&partition);
 
-pub fn get_io_usage() -> anyhow::Result<IoHarvest> {
-    Ok(IoHarvest::default())
+    //         let mount_point = (partition
+    //             .mount_point()
+    //             .to_str()
+    //             .unwrap_or("Name unavailable"))
+    //         .to_string();
+
+    //         // Precedence ordering in the case where name and mount filters disagree, "allow" takes precedence over "deny".
+    //         //
+    //         // For implementation, we do this as follows:
+    //         // 1. Is the entry allowed through any filter? That is, does it match an entry in a filter where `is_list_ignored` is `false`? If so, we always keep this entry.
+    //         // 2. Is the entry denied through any filter? That is, does it match an entry in a filter where `is_list_ignored` is `true`? If so, we always deny this entry.
+    //         // 3. Anything else is allowed.
+
+    //         let filter_check_map = [(disk_filter, &name), (mount_filter, &mount_point)];
+
+    //         // This represents case 1. That is, if there is a match in an allowing list - if there is, then
+    //         // immediately allow it!
+    //         let matches_allow_list = filter_check_map.iter().any(|(filter, text)| {
+    //             if let Some(filter) = filter {
+    //                 if !filter.is_list_ignored {
+    //                     for r in &filter.list {
+    //                         if r.is_match(text) {
+    //                             return true;
+    //                         }
+    //                     }
+    //                 }
+    //             }
+    //             false
+    //         });
+
+    //         let to_keep = if matches_allow_list {
+    //             true
+    //         } else {
+    //             // If it doesn't match an allow list, then check if it is denied.
+    //             // That is, if it matches in a reject filter, then reject.  Otherwise, we always keep it.
+    //             !filter_check_map.iter().any(|(filter, text)| {
+    //                 if let Some(filter) = filter {
+    //                     if filter.is_list_ignored {
+    //                         for r in &filter.list {
+    //                             if r.is_match(text) {
+    //                                 return true;
+    //                             }
+    //                         }
+    //                     }
+    //                 }
+    //                 false
+    //             })
+    //         };
+
+    //         if to_keep {
+    //             // The usage line can fail in some cases (for example, if you use Void Linux + LUKS,
+    //             // see https://github.com/ClementTsang/bottom/issues/419 for details).  As such, check
+    //             // it like this instead.
+    //             if let Ok(usage) = heim::disk::usage(partition.mount_point()).await {
+    //                 vec_disks.push(DiskHarvest {
+    //                     free_space: Some(usage.free().get::<heim::units::information::byte>()),
+    //                     used_space: Some(usage.used().get::<heim::units::information::byte>()),
+    //                     total_space: Some(usage.total().get::<heim::units::information::byte>()),
+    //                     mount_point,
+    //                     name,
+    //                 });
+    //             } else {
+    //                 vec_disks.push(DiskHarvest {
+    //                     free_space: None,
+    //                     used_space: None,
+    //                     total_space: None,
+    //                     mount_point,
+    //                     name,
+    //                 });
+    //             }
+    //         }
+    //     }
+    // }
+
+    // Ok(Some(vec_disks))
 }
diff --git a/src/app/data_harvester/disks/linux.rs → src/app/data_harvester/disks/unix/linux.rs b/src/app/data_harvester/disks/linux.rs → src/app/data_harvester/disks/unix/linux.rs
diff --git a/...p/data_harvester/disks/linux/partition.rs → ...a_harvester/disks/unix/linux/partition.rs b/...p/data_harvester/disks/linux/partition.rs → ...a_harvester/disks/unix/linux/partition.rs
diff --git a/src/app/data_harvester/disks/unix/other.rs b/src/app/data_harvester/disks/unix/other.rs
@@ -0,0 +1,41 @@
+//! Implementation based on [heim's](https://github.com/heim-rs/heim)
+//! Unix disk usage.
+
+use std::path::Path;
+
+use crate::app::{
+    data_harvester::disks::{DiskHarvest, IoHarvest},
+    filter::Filter,
+};
+
+mod file_systems;
+pub(crate) use file_systems::FileSystem;
+
+cfg_if::cfg_if! {
+    if #[cfg(target_os = "linux")] {
+        use super::linux::partitions;
+    } else {
+        mod partition;
+        mod mounts;
+
+        use partition::*;
+    }
+}
+
+pub(crate) struct Usage {}
+
+fn disk_usage(path: &Path) -> anyhow::Result<Usage> {
+    todo!()
+}
+
+pub fn get_disk_usage(
+    disk_filter: &Option<Filter>, mount_filter: &Option<Filter>,
+) -> anyhow::Result<Vec<DiskHarvest>> {
+    let partitions = partitions()?;
+
+    Ok(vec![])
+}
+
+pub fn get_io_usage() -> anyhow::Result<IoHarvest> {
+    Ok(IoHarvest::default())
+}