monitord/

system.rs

//! # system module
//!
//! Handle systemd's overall "system" state. Basically says if we've successfully
//! booted, stated all units or have been asked to stop, be offline etc.

use std::convert::TryInto;
use std::fmt;
use std::sync::Arc;

use int_enum::IntEnum;
use serde_repr::Deserialize_repr;
use serde_repr::Serialize_repr;
use strum_macros::EnumIter;
use strum_macros::EnumString;
use thiserror::Error;
use tokio::sync::RwLock;
use tracing::error;
use tracing::Instrument;

use crate::MachineStats;

#[derive(Error, Debug)]
pub enum MonitordSystemError {
    #[error("Unable to connect to DBUS via zbus: {0:#}")]
    ZbusError(#[from] zbus::Error),
    #[error("Version parse error: {0}")]
    VersionParseError(String),
    #[error("Integer parse error: {0}")]
    IntParseError(#[from] std::num::ParseIntError),
}

/// Overall system state reported by the systemd manager (PID 1).
/// Reflects whether the system has fully booted, is shutting down, or has failures.
/// Queried via the SystemState property on org.freedesktop.systemd1.Manager.
#[allow(non_camel_case_types)]
#[derive(
    Serialize_repr,
    Deserialize_repr,
    Clone,
    Copy,
    Debug,
    Default,
    Eq,
    PartialEq,
    EnumIter,
    EnumString,
    IntEnum,
    strum_macros::Display,
)]
#[repr(u8)]
pub enum SystemdSystemState {
    /// System state could not be determined
    #[default]
    unknown = 0,
    /// systemd is loading and setting up its internal state early in the boot process
    initializing = 1,
    /// systemd is starting units as part of the boot sequence
    starting = 2,
    /// All units have been started successfully and the system is fully operational
    running = 3,
    /// System is operational but one or more units have failed
    degraded = 4,
    /// System is in rescue or emergency mode (single-user maintenance)
    maintenance = 5,
    /// System is shutting down
    stopping = 6,
    /// systemd is not running (seen on non-booted containers or during very early boot)
    offline = 7,
}

/// Parsed systemd version from the Version property on org.freedesktop.systemd1.Manager.
///
/// systemd version strings follow the [UAPI Version Format Specification][uapi]
/// (what `systemd-analyze compare-versions` implements), which standardises how
/// versions *sort* — `~` sorts below everything, `-` separates major parts, `.`
/// separates parts of a component — but not how they split into fields. So
/// there is no official parser to defer to for this: the major/minor/revision/os
/// split below is monitord's own, for the JSON output, and the separator
/// handling follows the spec's meanings. Should monitord ever need to *compare*
/// versions, use that spec (e.g. the zero-dependency `uapi-version` crate)
/// rather than these fields — today it feature-detects instead, by looking for
/// the metrics a systemd release added.
///
/// Format: "major[.minor][.revision][.os]" (e.g. "256.1.fc40",
/// "255.6-9.9.hs+fb.el9", "260~rc1-5.fc45", "262-1.fc46").
///
/// [uapi]: https://uapi-group.org/specifications/specs/version_format_specification/
#[derive(serde::Serialize, serde::Deserialize, Clone, Debug, Default, Eq, PartialEq)]
pub struct SystemdVersion {
    /// Major version number (e.g. 256)
    major: u32,
    /// Minor version string; may contain hyphens for distro-patched versions (e.g. "6-9")
    minor: String,
    /// Optional patch/revision number, present when the version string has 4+ dot-separated parts
    revision: Option<u32>,
    /// OS/distribution suffix (e.g. "fc40", "hs+fb.el9")
    os: String,
}
impl SystemdVersion {
    pub fn new(major: u32, minor: String, revision: Option<u32>, os: String) -> SystemdVersion {
        Self {
            major,
            minor,
            revision,
            os,
        }
    }
}
impl fmt::Display for SystemdVersion {
    /// Dot-joined, skipping parts this version does not have. Note the
    /// separators are normalised: "260~rc1-5.fc45" renders as
    /// "260.rc1-5.fc45", since which separator followed the major version is
    /// not kept.
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.major)?;
        if !self.minor.is_empty() {
            write!(f, ".{}", self.minor)?;
        }
        if let Some(revision) = self.revision {
            write!(f, ".{revision}")?;
        }
        if !self.os.is_empty() {
            write!(f, ".{}", self.os)?;
        }
        Ok(())
    }
}
impl TryFrom<String> for SystemdVersion {
    type Error = MonitordSystemError;

    fn try_from(s: String) -> Result<Self, Self::Error> {
        let no_v_version = s.strip_prefix('v').unwrap_or(&s);

        // Handle versions whose major number is followed by a package release
        // rather than a dotted minor: "260~rc1-5.fc45" (pre-release) and
        // "262-1.fc46" (Fedora once the release is final). Only a separator
        // before the first '.' counts — a '-' after one belongs to a distro
        // minor such as the "6-9" in "969.6-9.9.hs+fb.el9".
        let first_dot = no_v_version.find('.').unwrap_or(no_v_version.len());
        if let Some(sep_pos) = no_v_version[..first_dot].find(['~', '-']) {
            let major = no_v_version[..sep_pos].parse::<u32>()?;
            let after_sep = &no_v_version[sep_pos + 1..];
            let mut tilde_parts = after_sep.splitn(2, '.');
            let minor = tilde_parts.next().unwrap_or("").to_string();
            let os = tilde_parts.next().unwrap_or("").to_string();
            return Ok(SystemdVersion {
                major,
                minor,
                revision: None,
                os,
            });
        }

        let mut parts = no_v_version.split('.');
        let split_count = parts.clone().count();
        let major = parts
            .next()
            .ok_or_else(|| MonitordSystemError::VersionParseError("No valid major version".into()))?
            .parse::<u32>()?;
        // A version can be just the major number ("263", as built from an
        // upstream tarball): no minor, revision or OS suffix to report.
        let minor = parts.next().unwrap_or_default().to_string();
        let mut revision = None;
        if split_count > 3 {
            revision = parts.next().and_then(|s| s.parse::<u32>().ok());
        }
        let os = parts.collect::<Vec<&str>>().join(".");
        Ok(SystemdVersion {
            major,
            minor,
            revision,
            os,
        })
    }
}

/// Map systemd's system state string to our enum.
///
/// Shared by the D-Bus `SystemState` property and the varlink
/// `io.systemd.Manager.Describe` runtime field, which use the same vocabulary.
pub fn parse_system_state(system_state: &str) -> SystemdSystemState {
    match system_state {
        "initializing" => SystemdSystemState::initializing,
        "starting" => SystemdSystemState::starting,
        "running" => SystemdSystemState::running,
        "degraded" => SystemdSystemState::degraded,
        "maintenance" => SystemdSystemState::maintenance,
        "stopping" => SystemdSystemState::stopping,
        "offline" => SystemdSystemState::offline,
        _ => SystemdSystemState::unknown,
    }
}

//pub fn get_system_state(dbus_address: &str) -> Result<SystemdSystemState, dbus::Error> {
pub async fn get_system_state(
    connection: &zbus::Connection,
) -> Result<SystemdSystemState, MonitordSystemError> {
    let p = crate::dbus::zbus_systemd::ManagerProxy::builder(connection)
        .cache_properties(zbus::proxy::CacheProperties::No)
        .build()
        .await
        .map_err(MonitordSystemError::ZbusError)?;

    let state = match p.system_state().await {
        Ok(system_state) => parse_system_state(&system_state),
        Err(err) => {
            error!("Failed to get system-state: {:?}", err);
            crate::system::SystemdSystemState::unknown
        }
    };
    Ok(state)
}

/// Async wrapper than can update system stats when passed a locked struct
///
/// The D-Bus call runs before the write lock is taken (not while holding it):
/// `locked_machine_stats` is shared by every collector, so holding it across an
/// awaited D-Bus round trip would block every other collector's own (already
/// finished) write until this one's D-Bus call completes.
pub async fn update_system_stats(
    connection: zbus::Connection,
    locked_machine_stats: Arc<RwLock<MachineStats>>,
) -> anyhow::Result<()> {
    let system_state = crate::system::get_system_state(&connection)
        .instrument(tracing::debug_span!("system_state_dbus_call"))
        .await
        .map_err(|e| anyhow::anyhow!("Error getting system state: {:?}", e))?;
    let mut machine_stats = locked_machine_stats
        .write()
        .instrument(tracing::debug_span!("system_state_acquire_write_lock"))
        .await;
    machine_stats.system_state = system_state;
    Ok(())
}

pub async fn get_version(
    connection: &zbus::Connection,
) -> Result<SystemdVersion, MonitordSystemError> {
    let p = crate::dbus::zbus_systemd::ManagerProxy::builder(connection)
        .cache_properties(zbus::proxy::CacheProperties::No)
        .build()
        .await
        .map_err(MonitordSystemError::ZbusError)?;
    let version_string = p.version().await?;
    version_string.try_into()
}

/// Async wrapper than can update system stats when passed a locked struct
///
/// See `update_system_stats` above: the D-Bus call runs before the write lock
/// is taken so it doesn't hold the shared lock for the round trip's duration.
pub async fn update_version(
    connection: zbus::Connection,
    locked_machine_stats: Arc<RwLock<MachineStats>>,
) -> anyhow::Result<()> {
    let version = crate::system::get_version(&connection)
        .instrument(tracing::debug_span!("version_dbus_call"))
        .await
        .map_err(|e| anyhow::anyhow!("Error getting systemd version: {:?}", e))?;
    let mut machine_stats = locked_machine_stats
        .write()
        .instrument(tracing::debug_span!("version_acquire_write_lock"))
        .await;
    machine_stats.version = version;
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_display_struct() {
        assert_eq!(
            format!("{}", SystemdSystemState::running),
            String::from("running"),
        )
    }

    #[test]
    fn test_parse_system_state() {
        assert_eq!(parse_system_state("running"), SystemdSystemState::running);
        assert_eq!(parse_system_state("degraded"), SystemdSystemState::degraded);
        // Anything systemd grows later reads as unknown rather than failing.
        assert_eq!(parse_system_state("brand-new"), SystemdSystemState::unknown);
    }

    #[test]
    fn test_parsing_systemd_versions() -> Result<(), MonitordSystemError> {
        let parsed: SystemdVersion = "969.1.69.fc69".to_string().try_into()?;
        assert_eq!(
            SystemdVersion::new(969, String::from("1"), Some(69), String::from("fc69")),
            parsed
        );

        // No revision
        let parsed: SystemdVersion = "969.1.fc69".to_string().try_into()?;
        assert_eq!(
            SystemdVersion::new(969, String::from("1"), None, String::from("fc69")),
            parsed
        );

        // #bigCompany strings
        let parsed: SystemdVersion = String::from("969.6-9.9.hs+fb.el9").try_into()?;
        assert_eq!(
            SystemdVersion::new(969, String::from("6-9"), Some(9), String::from("hs+fb.el9")),
            parsed
        );

        let parsed: SystemdVersion = String::from("v299.6-9.9.hs+fb.el9").try_into()?;
        assert_eq!(
            SystemdVersion::new(299, String::from("6-9"), Some(9), String::from("hs+fb.el9")),
            parsed
        );

        // RC / pre-release versions like those seen on Fedora Rawhide: "260~rc1-5.fc45"
        let parsed: SystemdVersion = String::from("260~rc1-5.fc45").try_into()?;
        assert_eq!(
            SystemdVersion::new(260, String::from("rc1-5"), None, String::from("fc45")),
            parsed
        );

        // Fedora once the release is final and the '~rc' is gone: "262-1.fc46".
        // The package release follows the major version directly, with no
        // dotted minor at all.
        let parsed: SystemdVersion = String::from("262-1.fc46").try_into()?;
        assert_eq!(
            SystemdVersion::new(262, String::from("1"), None, String::from("fc46")),
            parsed
        );

        // A release with no OS suffix still parses.
        let parsed: SystemdVersion = String::from("262-1").try_into()?;
        assert_eq!(
            SystemdVersion::new(262, String::from("1"), None, String::new()),
            parsed
        );

        // A '-' after the first dot is part of the minor, not a release
        // separator: this must keep parsing as it did before.
        let parsed: SystemdVersion = String::from("969.6-9.9.hs+fb.el9").try_into()?;
        assert_eq!(
            SystemdVersion::new(969, String::from("6-9"), Some(9), String::from("hs+fb.el9")),
            parsed
        );

        // Just the major version, as built from an upstream tarball.
        let parsed: SystemdVersion = String::from("263").try_into()?;
        assert_eq!(
            SystemdVersion::new(263, String::new(), None, String::new()),
            parsed
        );
        assert_eq!(parsed.to_string(), "263");

        // Anything that does not start with a number is still an error: a
        // version monitord cannot read must not silently become 0.
        assert!(SystemdVersion::try_from(String::from("not-a-version")).is_err());
        assert!(SystemdVersion::try_from(String::new()).is_err());

        Ok(())
    }
}