use core::{fmt, time::Duration};
use crate::{cpu, host, mem, os, virt};
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct Summary {
pub os: &'static str,
pub kernel: &'static str,
pub cpu: &'static str,
pub cpu_counts: cpu::Counts,
pub memory: Option<mem::Memory>,
pub cpu_quota: Option<cpu::CpuQuota>,
pub virtualization: &'static virt::Virtualization,
pub form_factor: os::FormFactor,
pub uptime: Option<Duration>,
pub load: Option<cpu::Load>,
}
#[must_use]
pub fn summary() -> Summary {
Summary {
os: os::name(),
kernel: os::kernel(),
cpu: cpu::name(),
cpu_counts: cpu::count(),
memory: mem::snapshot().ok(),
cpu_quota: cpu::quota().ok().flatten(),
virtualization: virt::detect(),
form_factor: os::form_factor(),
uptime: host::uptime().ok(),
load: cpu::load().ok().flatten(),
}
}
impl Summary {
fn virt_name(&self) -> String {
let v = self.virtualization;
let mut parts = Vec::new();
if let Some(c) = v.container {
parts.push(format!("{c:?}").to_lowercase());
}
if let Some(h) = v.hypervisor {
parts.push(format!("{h:?}").to_lowercase());
}
if parts.is_empty() {
"none".to_owned()
} else {
parts.join("+")
}
}
fn limit_name(&self) -> Option<&'static str> {
match self.memory?.source {
mem::MemorySource::Cgroup1 => Some("cgroup1"),
mem::MemorySource::Cgroup2 => Some("cgroup2"),
mem::MemorySource::JobObject => Some("job"),
mem::MemorySource::Lxcfs => Some("lxcfs"),
_ => None,
}
}
fn pairs(&self, out: &mut dyn fmt::Write, sep: &str) -> fmt::Result {
let c = &self.cpu_counts;
write!(
out,
"os={}{sep}kernel={}",
quoted(self.os),
quoted(self.kernel)
)?;
write!(out, "{sep}cpu={}", quoted(self.cpu))?;
write!(out, "{sep}cores={}{sep}threads={}", c.physical, c.logical)?;
write!(out, "{sep}available={}", c.available)?;
if let Some(m) = &self.memory {
write!(
out,
"{sep}memory.total={}{sep}memory.used={}",
m.total, m.used
)?;
}
if let Some(limit) = self.limit_name() {
write!(out, "{sep}limit={limit}")?;
}
write!(out, "{sep}virt={}", self.virt_name())?;
write!(out, "{sep}form={}", self.form_factor.name())?;
if let Some(up) = self.uptime {
write!(out, "{sep}uptime={}s", up.as_secs())?;
}
if let Some(l) = self.load {
write!(out, "{sep}load={:.2}", l.one)?;
}
Ok(())
}
pub fn write_kv(&self, out: &mut impl fmt::Write) -> fmt::Result {
self.pairs(out, " ")
}
pub fn write_json(&self, out: &mut impl fmt::Write) -> fmt::Result {
let c = &self.cpu_counts;
write!(out, "{{\"os\":")?;
json(out, self.os)?;
write!(out, ",\"kernel\":")?;
json(out, self.kernel)?;
write!(out, ",\"cpu\":")?;
json(out, self.cpu)?;
write!(
out,
",\"cores\":{},\"threads\":{},\"packages\":{},\"available\":{},\"online\":{}",
c.physical, c.logical, c.packages, c.available, c.online
)?;
if let Some(m) = &self.memory {
write!(
out,
",\"memory\":{{\"total\":{},\"used\":{},\"free\":{}}}",
m.total.raw(),
m.used.raw(),
m.free.raw()
)?;
}
if let Some(q) = &self.cpu_quota {
write!(out, ",\"cpu_quota\":{}", q.cpus)?;
}
if let Some(limit) = self.limit_name() {
write!(out, ",\"limit\":\"{limit}\"")?;
}
write!(out, ",\"virt\":")?;
json(out, &self.virt_name())?;
write!(out, ",\"form\":\"{}\"", self.form_factor.name())?;
if let Some(up) = self.uptime {
write!(out, ",\"uptime_seconds\":{}", up.as_secs())?;
}
if let Some(l) = self.load {
write!(out, ",\"load\":[{},{},{}]", l.one, l.five, l.fifteen)?;
}
out.write_str("}")
}
}
impl fmt::Display for Summary {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
self.pairs(f, " ")
}
}
fn quoted(text: &str) -> String {
if text.is_empty() || text.chars().any(|c| c == ' ' || c == '"' || c.is_control()) {
format!("{:?}", text)
} else {
text.to_owned()
}
}
fn json(out: &mut dyn fmt::Write, text: &str) -> fmt::Result {
out.write_char('"')?;
for c in text.chars() {
match c {
'"' => out.write_str("\\\"")?,
'\\' => out.write_str("\\\\")?,
c if u32::from(c) < 0x20 => write!(out, "\\u{:04x}", u32::from(c))?,
c => out.write_char(c)?,
}
}
out.write_char('"')
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_summary_live_outputs() {
let s = summary();
let text = s.to_string();
assert!(text.starts_with("os=") && text.contains(" cpu=") && text.contains(" virt="));
let mut kv = String::new();
s.write_kv(&mut kv).unwrap();
assert_eq!(kv, text);
let mut j = String::new();
s.write_json(&mut j).unwrap();
assert!(j.starts_with("{\"os\":\"") && j.ends_with('}'));
}
#[test]
fn test_summary_t13_no_identifying_values() {
let s = summary();
let (mut kv, mut j) = (String::new(), String::new());
s.write_kv(&mut kv).unwrap();
s.write_json(&mut j).unwrap();
let debug = format!("{s:?}");
let mut secrets = Vec::new();
if let Ok(h) = host::name() {
secrets.push(h);
}
if let Ok(u) = crate::process::user() {
secrets.push(u.name);
}
for secret in secrets.iter().filter(|s| s.len() >= 4) {
if s.os.contains(secret.as_str()) || s.kernel.contains(secret.as_str()) {
continue;
}
assert!(!kv.contains(secret.as_str()), "{secret}");
assert!(!j.contains(secret.as_str()), "{secret}");
assert!(!debug.contains(secret.as_str()), "{secret}");
}
}
#[test]
fn test_summary_json_escapes() {
let mut out = String::new();
json(&mut out, "a\"b\\c\nd").unwrap();
assert_eq!(out, r#""a\"b\\c\u000ad""#);
assert_eq!(quoted("plain"), "plain");
assert_eq!(quoted("two words"), "\"two words\"");
assert_eq!(quoted(""), "\"\"");
}
}