use core::time::Duration;
use std::{sync::OnceLock, time::SystemTime};
use crate::{Result, os::keep, parse, sys::HardwareFacts};
pub fn name() -> Result<String> {
crate::sys::host_name()
}
pub fn uptime() -> Result<Duration> {
crate::sys::uptime()
}
pub fn boot_time() -> Result<SystemTime> {
crate::sys::boot_time()
}
#[derive(Clone, Copy, PartialEq, Eq, Debug, Default)]
#[non_exhaustive]
pub struct Processes {
pub total: u64,
pub threads: Option<u64>,
pub running: Option<u64>,
}
pub fn processes() -> Result<Processes> {
crate::sys::processes()
}
#[derive(Clone, Copy, PartialEq, Eq, Debug, Default)]
#[non_exhaustive]
pub struct OpenFiles {
pub open: Option<u64>,
pub max: Option<u64>,
}
pub fn open_files() -> Result<OpenFiles> {
crate::sys::host_open_files()
}
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct TimeZone {
pub iana: Option<String>,
pub windows: Option<String>,
pub utc_offset_seconds: i32,
pub abbreviation: Option<String>,
}
pub fn timezone() -> Result<TimeZone> {
crate::sys::timezone()
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
#[non_exhaustive]
pub struct Locale {
pub tag: &'static str,
pub raw: &'static str,
}
#[must_use]
pub fn locale() -> Option<&'static Locale> {
static FACT: OnceLock<Option<Locale>> = OnceLock::new();
FACT.get_or_init(|| {
let (tag, raw) = crate::sys::locale()?;
Some(Locale {
tag: keep(tag),
raw: keep(raw),
})
})
.as_ref()
}
#[cfg_attr(windows, allow(dead_code))]
pub(crate) fn posix_locale() -> Option<(String, String)> {
let raw = ["LC_ALL", "LC_MESSAGES", "LANG"]
.iter()
.find_map(|k| std::env::var(k).ok().filter(|v| !v.is_empty()))?;
let tag = parse::locale::tag(&raw)?;
Some((tag, raw))
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
#[non_exhaustive]
pub struct Model {
pub vendor: Option<&'static str>,
pub name: &'static str,
pub family: Option<&'static str>,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[non_exhaustive]
pub enum FirmwareKind {
Uefi,
Bios,
Unknown,
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
#[non_exhaustive]
pub struct Firmware {
pub kind: FirmwareKind,
pub vendor: Option<&'static str>,
pub version: Option<&'static str>,
pub date: Option<&'static str>,
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
#[non_exhaustive]
pub struct Board {
pub vendor: Option<&'static str>,
pub name: Option<&'static str>,
pub version: Option<&'static str>,
}
struct Hardware {
model: Option<Model>,
firmware: Option<Firmware>,
board: Option<Board>,
}
fn hardware() -> &'static Hardware {
static FACTS: OnceLock<Hardware> = OnceLock::new();
FACTS.get_or_init(|| keep_hardware(crate::sys::hardware()))
}
fn keep_hardware(f: HardwareFacts) -> Hardware {
let opt = |s: Option<String>| s.map(keep);
let model = f.model_name.map(|name| Model {
vendor: opt(f.model_vendor),
name: keep(name),
family: opt(f.model_family),
});
let known = f.firmware_kind.is_some()
|| f.firmware_vendor.is_some()
|| f.firmware_version.is_some()
|| f.firmware_date.is_some();
let firmware = known.then(|| Firmware {
kind: f.firmware_kind.unwrap_or(FirmwareKind::Unknown),
vendor: opt(f.firmware_vendor),
version: opt(f.firmware_version),
date: opt(f.firmware_date),
});
let board = (f.board_vendor.is_some() || f.board_name.is_some() || f.board_version.is_some())
.then(|| Board {
vendor: opt(f.board_vendor),
name: opt(f.board_name),
version: opt(f.board_version),
});
Hardware {
model,
firmware,
board,
}
}
#[must_use]
pub fn model() -> Option<&'static Model> {
hardware().model.as_ref()
}
#[must_use]
pub fn firmware() -> Option<&'static Firmware> {
hardware().firmware.as_ref()
}
#[must_use]
pub fn board() -> Option<&'static Board> {
hardware().board.as_ref()
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
#[non_exhaustive]
pub struct ClockSync {
pub synchronized: bool,
pub max_error: Option<Duration>,
pub estimated_error: Option<Duration>,
}
pub fn clock_sync() -> Result<Option<ClockSync>> {
crate::sys::clock_sync()
}
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct Session {
pub user: String,
pub terminal: Option<String>,
pub remote: bool,
pub since: Option<SystemTime>,
}
pub fn sessions() -> Result<Vec<Session>> {
crate::sys::sessions()
}
#[cfg(test)]
mod tests {
#[test]
fn test_host_counts_and_clocks_live() {
let up = super::uptime().unwrap();
assert!(up.as_secs() > 0);
let boot = super::boot_time().unwrap();
assert!(boot < std::time::SystemTime::now());
let p = super::processes().unwrap();
assert!(p.total >= 1);
if let Some(t) = p.threads {
assert!(t >= p.total);
}
let f = super::open_files().unwrap();
if let (Some(open), Some(max)) = (f.open, f.max) {
assert!(open <= max);
}
}
#[test]
fn test_host_name_is_not_empty() {
let name = super::name().unwrap();
assert!(!name.is_empty() && name.len() <= 255);
}
}