Support serialization of machine state into files

Author: Lyndeno

Cargo.lock

@@ -8,21 +8,24 @@ license = "MIT"
 
 [dependencies]
 clap = { version = "*", features = ["derive"] }
-measurements = "*"
+measurements = { version = "*", features = ["serde"] }
 nix = { version="*", features = ["feature"]}
 os-release = "*"
-procfs = "*"
+procfs = { version = "*", features = ["serde1"] }
 sys-info = "*"
 uptime_lib = "*"
 thiserror = "*"
 udev = "*"
 futures = "*"
 udisks2 = "*"
+serde = "*"
+serde_json = "*"
 
 [build-dependencies]
 clap = { version = "*", features = ["derive"] }
 clap_complete = "*"
 clap_mangen = "*"
+serde = "*"
 
 [lints.clippy]
 pedantic = {level="warn", priority = 0}

Cargo.toml

@@ -1,3 +1,5 @@
+use std::path::PathBuf;
+
 use crate::memunit::MemUnits;
 use clap::Parser;
 
@@ -16,4 +18,12 @@ pub struct Args {
     /// Number of colour lines to show
     #[arg(long, default_value = "8")]
     pub colour_length: usize,
+
+    /// Import machine state
+    #[arg(short, long)]
+    pub input: Option<PathBuf>,
+
+    /// Export machine state
+    #[arg(short, long)]
+    pub output: Option<PathBuf>,
 }

src/args.rs

@@ -3,6 +3,9 @@ use measurements::frequency::Frequency;
 use procfs::prelude::*;
 use procfs::CpuInfo;
 
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize)]
 pub struct Cpu {
     cpu: CpuInfo,
 }

src/cpu.rs

@@ -1,7 +1,9 @@
 use crate::fetcherror::FetchError;
 use measurements::Data;
+use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
+#[derive(Serialize, Deserialize)]
 pub struct Disk {
     pub capacity: Data,
 }

src/disk.rs

@@ -24,4 +24,6 @@ pub enum FetchError {
     ParseInt(#[from] ParseIntError),
     #[error("Error talking to udisks2")]
     Udisk(#[from] udisks2::Error),
+    #[error("Error with serialization")]
+    Serde(#[from] serde_json::Error),
 }

src/fetcherror.rs

@@ -1,6 +1,9 @@
 use sys_info::hostname;
 
 use crate::fetcherror::FetchError;
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize)]
 pub struct HostName(pub String);
 
 impl HostName {

src/hostname.rs

@@ -2,9 +2,11 @@ use nix::sys::utsname::{uname, UtsName};
 use std::ffi::OsStr;
 
 use crate::fetcherror::FetchError;
+use serde::{Deserialize, Serialize};
 
 type Result<T> = std::result::Result<T, FetchError>;
 
+#[derive(Serialize, Deserialize)]
 pub struct Kernel {
     release: String,
     architecture: String,

src/kernel.rs

@@ -6,6 +6,7 @@ pub mod fetcherror;
 pub mod fetchsection;
 pub mod hostname;
 pub mod kernel;
+pub mod machine;
 pub mod memory;
 pub mod memunit;
 pub mod model;

src/lib.rs

@@ -0,0 +1,127 @@
+use std::fmt::Display;
+use std::fs::File;
+use std::io::{BufReader, BufWriter, Write};
+use std::path::PathBuf;
+
+use crate::colourblocks::colourblocks;
+
+use crate::cpu::Cpu;
+use crate::disk::Disk;
+use crate::fetcherror::FetchError;
+use crate::fetchsection::{FetchArray, SEPARATOR};
+use crate::hostname::HostName;
+use crate::kernel::Kernel;
+use crate::memory::Memory;
+use crate::model::Model;
+use crate::osinfo::OsInfo;
+use crate::platform::Profile;
+use crate::shell::Shell;
+use crate::uptime::Uptime;
+
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize)]
+pub struct Machine {
+    pub kernel: Option<Kernel>,
+    pub cpu: Option<Cpu>,
+    pub memory: Option<Memory>,
+    pub os: Option<OsInfo>,
+    pub hostname: Option<HostName>,
+    pub uptime: Option<Uptime>,
+    pub model: Option<Model>,
+    pub shell: Option<Shell>,
+    pub platform: Option<Profile>,
+    pub disk: Option<Disk>,
+}
+
+impl Machine {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn from_file(path: PathBuf) -> Result<Self, FetchError> {
+        let f = File::open(path)?;
+        let r = BufReader::new(f);
+        Ok(serde_json::from_reader(r)?)
+    }
+
+    pub fn to_file(&self, path: PathBuf) -> Result<(), FetchError> {
+        let f = File::create(path)?;
+        let mut w = BufWriter::new(f);
+        serde_json::to_writer_pretty(&mut w, self)?;
+        w.flush()?;
+        Ok(())
+    }
+}
+
+impl Default for Machine {
+    fn default() -> Self {
+        Self {
+            kernel: Kernel::new().ok(),
+            cpu: Cpu::new().ok(),
+            memory: Memory::new(None).ok(),
+            os: OsInfo::new().ok(),
+            hostname: HostName::new().ok(),
+            uptime: Uptime::new().ok(),
+            model: Model::new().ok(),
+            shell: Shell::new().ok(),
+            platform: Profile::new().ok(),
+            disk: Disk::new().ok(),
+        }
+    }
+}
+
+impl Display for Machine {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let mut array = FetchArray::default();
+
+        if let Some(r) = &self.os {
+            array.set_colour(r.color.clone());
+            array.push(("OS", r));
+        }
+
+        if let Some(r) = &self.shell {
+            array.push(("Shell", r));
+        }
+
+        if let Some(r) = &self.kernel {
+            array.push(("Kernel", r));
+        }
+
+        if let Some(r) = &self.model {
+            array.push(("Model", r));
+        }
+
+        if let Some(r) = &self.hostname {
+            array.push(("Hostname", r));
+        }
+
+        if let Some(r) = &self.uptime {
+            array.push(("Uptime", r));
+        }
+
+        if let Some(r) = &self.cpu {
+            array.push(("CPU", r));
+        }
+
+        if let Some(r) = &self.memory {
+            array.push(("Memory", &r));
+            array.push(("Swap", r.display_swap()));
+        }
+
+        if let Some(r) = &self.platform {
+            array.push(("Profile", r));
+        }
+
+        if let Some(r) = &self.disk {
+            array.push(("Disk", r));
+        }
+
+        write!(
+            f,
+            "{}\n{}",
+            array,
+            colourblocks(array.get_indent() + SEPARATOR.len(), 16, 8)
+        )
+    }
+}