From 338a034073bfa1adcc07509dac07552591a3f963 Mon Sep 17 00:00:00 2001
From: Keagan McClelland <keagan.mcclelland@gmail.com>
Date: Tue, 5 Oct 2021 16:25:23 -0600
Subject: [PATCH] Bugfix/disk usage zfs (#587)

* fixes disk usage gets

* fix whitespace issues
---
 appmgr/src/system.rs | 81 ++++++++++++++++++++++++++++++--------------
 1 file changed, 56 insertions(+), 25 deletions(-)

diff --git a/appmgr/src/system.rs b/appmgr/src/system.rs
index 319a50966..f86c8f490 100644
--- a/appmgr/src/system.rs
+++ b/appmgr/src/system.rs
@@ -1,5 +1,6 @@
 use std::fmt;
 
+use futures::future::try_join_all;
 use rpc_toolkit::command;
 use serde::ser::SerializeStruct;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
@@ -572,36 +573,66 @@ async fn get_mem_info() -> Result<MetricsMemory, Error> {
 }
 
 async fn get_disk_info() -> Result<MetricsDisk, Error> {
-    tokio::task::spawn_blocking(move || {
-        let fs_res = nix::sys::statfs::statfs("/").map_err(|e| {
+    use crate::util::Invoke;
+    let mut size_cmd = tokio::process::Command::new("zpool");
+    let size_task = size_cmd
+        .arg("list")
+        .arg("-Hp")
+        .arg("-o")
+        .arg("size")
+        .arg("embassy-data")
+        .invoke(ErrorKind::ParseSysInfo);
+    let mut alloc_cmd = tokio::process::Command::new("zpool");
+    let alloc_task = alloc_cmd
+        .arg("list")
+        .arg("-Hp")
+        .arg("-o")
+        .arg("allocated")
+        .arg("embassy-data")
+        .invoke(ErrorKind::ParseSysInfo);
+    let mut free_cmd = tokio::process::Command::new("zpool");
+    let free_task = free_cmd
+        .arg("list")
+        .arg("-Hp")
+        .arg("-o")
+        .arg("free")
+        .arg("embassy-data")
+        .invoke(ErrorKind::ParseSysInfo);
+    let (size_bytes, alloc_bytes, free_bytes) =
+        futures::try_join!(size_task, alloc_task, free_task)?;
+    let size = String::from_utf8(size_bytes)?
+        .trim()
+        .parse::<f64>()
+        .map_err(|e| {
             Error::new(
-                anyhow::anyhow!("statfs panicked: {}", e),
+                anyhow::anyhow!("Could not parse disk size: {}", e),
                 ErrorKind::ParseSysInfo,
             )
         })?;
-        let block_size = fs_res.block_size() as u64;
-        let blocks = fs_res.blocks();
-        let blocks_available = fs_res.blocks_available();
-        fn to_gigs(n: u64) -> GigaBytes {
-            GigaBytes(n as f64 / (1u64 << 30) as f64)
-        }
-        let size = to_gigs(blocks * block_size);
-        let used = to_gigs(block_size * (blocks - blocks_available));
-        let available = to_gigs(block_size * blocks_available);
-        let used_percentage = Percentage(used.0 / size.0 * 100.0);
-        Ok(MetricsDisk {
-            size,
-            used,
-            available,
-            used_percentage,
-        })
+    let alloc = String::from_utf8(alloc_bytes)?
+        .trim()
+        .parse::<f64>()
+        .map_err(|e| {
+            Error::new(
+                anyhow::anyhow!("Could not parse disk alloc: {}", e),
+                ErrorKind::ParseSysInfo,
+            )
+        })?;
+    let free = String::from_utf8(free_bytes)?
+        .trim()
+        .parse::<f64>()
+        .map_err(|e| {
+            Error::new(
+                anyhow::anyhow!("Could not parse disk alloc: {}", e),
+                ErrorKind::ParseSysInfo,
+            )
+        })?;
+    Ok(MetricsDisk {
+        size: GigaBytes(size / 1_000_000_000.0),
+        used: GigaBytes(alloc / 1_000_000_000.0),
+        available: GigaBytes(free / 1_000_000_000.0),
+        used_percentage: Percentage(alloc / size * 100.0),
     })
-    .await
-    .map_err(|e| Error {
-        source: anyhow::anyhow!("statfs panicked: {}", e),
-        kind: ErrorKind::ParseSysInfo,
-        revision: None,
-    })?
 }
 
 #[command(subcommands(share_stats))]