use bytesize

Author: valpackett

Cargo.toml

@@ -13,3 +13,4 @@ repository = "https://github.com/myfreeweb/systemstat"
 libc = "0.2"
 chrono = "0.2"
 lazy_static = "0.1"
+bytesize = "0.1"

examples/info.rs

@@ -10,8 +10,8 @@ fn main() {
     let mounts = sys.mounts().unwrap();
     println!("\nMounts:");
     for mount in mounts.iter() {
-        println!("{} ---{}---> {} (available {} of {} bytes)",
-                 mount.fs_mounted_from, mount.fs_type, mount.fs_mounted_on, mount.avail_bytes, mount.total_bytes);
+        println!("{} ---{}---> {} (available {} of {})",
+                 mount.fs_mounted_from, mount.fs_type, mount.fs_mounted_on, mount.avail, mount.total);
     }
 
     let netifs = sys.networks().unwrap();
@@ -21,8 +21,8 @@ fn main() {
     }
 
     let mem = sys.memory().unwrap();
-    println!("\nMemory: {} KiB active, {} KiB inact, {} KiB wired, {} KiB cache, {} KiB free",
-             mem.active_kb, mem.inactive_kb, mem.wired_kb, mem.cache_kb, mem.free_kb);
+    println!("\nMemory: {} active, {} inact, {} wired, {} cache, {} free",
+             mem.active, mem.inactive, mem.wired, mem.cache, mem.free);
 
     let loadavg = sys.load_average().unwrap();
     println!("\nLoad average: {} {} {}", loadavg.one, loadavg.five, loadavg.fifteen);

src/data.rs

@@ -4,6 +4,7 @@
 
 use std::io;
 use std::net::{Ipv4Addr, Ipv6Addr};
+pub use bytesize::ByteSize;
 
 /// A wrapper for a measurement that takes time.
 ///
@@ -52,20 +53,20 @@ pub struct LoadAverage {
 
 #[derive(Debug, Clone)]
 pub struct Memory {
-    pub active_kb: usize,
-    pub inactive_kb: usize,
-    pub wired_kb: usize,
-    pub cache_kb: usize,
-    pub free_kb: usize,
+    pub active: ByteSize,
+    pub inactive: ByteSize,
+    pub wired: ByteSize,
+    pub cache: ByteSize,
+    pub free: ByteSize,
 }
 
 #[derive(Debug, Clone)]
 pub struct Filesystem {
-    pub files: u64,
-    pub free_bytes: u64,
-    pub avail_bytes: u64,
-    pub total_bytes: u64,
-    pub name_max: u64,
+    pub files: usize,
+    pub free: ByteSize,
+    pub avail: ByteSize,
+    pub total: ByteSize,
+    pub name_max: usize,
     pub fs_type: String,
     pub fs_mounted_from: String,
     pub fs_mounted_on: String,

src/lib.rs

@@ -2,6 +2,7 @@
 //! network interfaces, etc.
 
 extern crate libc;
+extern crate bytesize;
 #[macro_use] extern crate lazy_static;
 
 pub mod platform;

src/platform/freebsd.rs

@@ -96,11 +96,11 @@ impl Platform for PlatformImpl {
         let mut cache: usize = 0; sysctl!(V_CACHE_COUNT, &mut cache, mem::size_of::<usize>());
         let mut free: usize = 0; sysctl!(V_FREE_COUNT, &mut free, mem::size_of::<usize>());
         Ok(Memory {
-            active_kb: active << *PAGESHIFT,
-            inactive_kb: inactive << *PAGESHIFT,
-            wired_kb: wired << *PAGESHIFT,
-            cache_kb: cache << *PAGESHIFT,
-            free_kb: free << *PAGESHIFT,
+            active: ByteSize::kib(active << *PAGESHIFT),
+            inactive: ByteSize::kib(inactive << *PAGESHIFT),
+            wired: ByteSize::kib(wired << *PAGESHIFT),
+            cache: ByteSize::kib(cache << *PAGESHIFT),
+            free: ByteSize::kib(free << *PAGESHIFT),
         })
     }
 
@@ -252,11 +252,11 @@ struct statfs {
 impl statfs {
     fn to_fs(&self) -> Filesystem {
         Filesystem {
-            files: self.f_files - self.f_ffree as u64,
-            free_bytes: self.f_bfree as u64 * self.f_bsize,
-            avail_bytes: self.f_bavail as u64 * self.f_bsize,
-            total_bytes: self.f_blocks as u64 * self.f_bsize,
-            name_max: self.f_namemax as u64,
+            files: self.f_files as usize - self.f_ffree as usize,
+            free: ByteSize::b(self.f_bfree as usize * self.f_bsize as usize),
+            avail: ByteSize::b(self.f_bavail as usize * self.f_bsize as usize),
+            total: ByteSize::b(self.f_blocks as usize * self.f_bsize as usize),
+            name_max: self.f_namemax as usize,
             fs_type: unsafe { ffi::CStr::from_ptr(&self.f_fstypename[0]).to_string_lossy().into_owned() },
             fs_mounted_from: unsafe { ffi::CStr::from_ptr(&self.f_mntfromname[0]).to_string_lossy().into_owned() },
             fs_mounted_on: unsafe { ffi::CStr::from_ptr(&self.f_mntonname[0]).to_string_lossy().into_owned() },

src/platform/mod.rs

@@ -43,7 +43,7 @@ mod tests {
     #[test]
     fn test_memory() {
         let mem = PlatformImpl::new().memory().unwrap();
-        assert!(mem.free_kb > 100 && mem.active_kb > 100);
+        assert!(mem.free.as_usize() > 1024 && mem.active.as_usize() > 1024);
     }
 
     #[test]