use core::fmt;
use super::{Anchor, Basis, Raw, Reading, read_anchor};
use crate::{os::Confidence, virt};
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct StabilityReport {
pub sources: Vec<SourceStatus>,
pub default_basis_available: bool,
pub clone_risk: Vec<CloneRisk>,
pub confidence: Confidence,
pub changes_on: Vec<ChangeEvent>,
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
#[non_exhaustive]
pub struct SourceStatus {
pub anchor: Anchor,
pub state: SourceState,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[non_exhaustive]
pub enum SourceState {
Present,
Absent,
Placeholder,
PermissionDenied,
Unsupported,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[non_exhaustive]
pub enum CloneRisk {
Container,
VirtualMachine,
MachineIdUninitialized,
SharedImageLikely,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[non_exhaustive]
pub enum ChangeEvent {
OsReinstall,
BoardReplacement,
NicReplacement,
CpuUpgrade,
VmRecreated,
ContainerRecreated,
AdminReset,
}
#[must_use]
pub fn report() -> StabilityReport {
let sources: Vec<SourceStatus> = Anchor::ALL
.into_iter()
.map(|anchor| {
let mut raw = Raw::new();
let state = match read_anchor(anchor, &mut raw) {
Reading::Value(_) => SourceState::Present,
Reading::Absent => SourceState::Absent,
Reading::Placeholder => SourceState::Placeholder,
Reading::PermissionDenied => SourceState::PermissionDenied,
Reading::Unsupported => SourceState::Unsupported,
};
SourceStatus { anchor, state }
})
.collect();
assess(sources, virt::is_container(), virt::is_vm())
}
fn install_state(sources: &[SourceStatus]) -> SourceState {
let anchor = Basis::Install.anchors()[0];
sources
.iter()
.find(|s| s.anchor == anchor)
.map_or(SourceState::Absent, |s| s.state)
}
fn assess(sources: Vec<SourceStatus>, container: bool, vm: bool) -> StabilityReport {
let state = install_state(&sources);
let available = state == SourceState::Present;
let mut clone_risk = Vec::new();
if container {
clone_risk.push(CloneRisk::Container);
}
if vm {
clone_risk.push(CloneRisk::VirtualMachine);
}
if state == SourceState::Placeholder {
clone_risk.push(CloneRisk::MachineIdUninitialized);
}
if container && available {
clone_risk.push(CloneRisk::SharedImageLikely);
}
let confidence = if !available {
Confidence::None
} else if container {
Confidence::Low
} else if vm {
Confidence::Medium
} else {
Confidence::High
};
let mut changes_on = if cfg!(any(target_os = "macos", target_os = "ios")) {
vec![ChangeEvent::BoardReplacement]
} else {
vec![ChangeEvent::OsReinstall, ChangeEvent::AdminReset]
};
if vm {
changes_on.push(ChangeEvent::VmRecreated);
}
if container {
changes_on.push(ChangeEvent::ContainerRecreated);
}
StabilityReport {
sources,
default_basis_available: available,
clone_risk,
confidence,
changes_on,
}
}
impl fmt::Display for StabilityReport {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
for s in &self.sources {
let state = match s.state {
SourceState::Present => "present",
SourceState::Absent => "absent",
SourceState::Placeholder => "placeholder",
SourceState::PermissionDenied => "permission denied",
SourceState::Unsupported => "unsupported",
};
writeln!(f, "{:<16}{state}", s.anchor.name())?;
}
writeln!(f, "{:<16}{:?}", "confidence", self.confidence)?;
write!(f, "{:<16}{:?}", "clone risk", self.clone_risk)
}
}
#[cfg(test)]
mod tests {
use super::*;
fn sources(state: SourceState) -> Vec<SourceStatus> {
Anchor::ALL
.into_iter()
.map(|anchor| SourceStatus { anchor, state })
.collect()
}
#[test]
fn test_report_bare_metal() {
let r = assess(sources(SourceState::Present), false, false);
assert!(r.default_basis_available);
assert!(r.clone_risk.is_empty());
assert_eq!(r.confidence, Confidence::High);
}
#[test]
fn test_report_clone_risks() {
let r = assess(sources(SourceState::Present), true, true);
assert_eq!(
r.clone_risk,
vec![
CloneRisk::Container,
CloneRisk::VirtualMachine,
CloneRisk::SharedImageLikely
]
);
assert_eq!(r.confidence, Confidence::Low);
assert!(r.changes_on.contains(&ChangeEvent::ContainerRecreated));
assert_eq!(
assess(sources(SourceState::Present), false, true).confidence,
Confidence::Medium
);
let r = assess(sources(SourceState::Placeholder), false, false);
assert_eq!(r.clone_risk, vec![CloneRisk::MachineIdUninitialized]);
assert!(!r.default_basis_available);
assert_eq!(r.confidence, Confidence::None);
}
#[test]
fn test_report_live_has_every_source_and_no_values() {
let r = report();
assert_eq!(r.sources.len(), Anchor::ALL.len());
let text = r.to_string();
assert!(text.contains("install id") && text.contains("confidence"));
}
}