fxcp_core/

stratis.rs

// SPDX-License-Identifier: GPL-2.0-or-later
// Copyright (C) 2025 Joel Wirāmu Pauling <aenertia@aenertia.net>
//! Stratis D-Bus integration for pool-aware replication.
//!
//! Queries stratisd via the system D-Bus to resolve pool/filesystem metadata,
//! monitor pool capacity, create/prune filesystem snapshots, and provide
//! rich storage telemetry for the Governor and metrics subsystem.
//!
//! stratisd D-Bus API: `org.storage.stratis3` on the system bus.
//! Reference: <https://stratis-storage.github.io/DBusAPIReference.pdf>

#![allow(clippy::expect_used)]
use std::collections::HashMap;
use tracing::{debug, info, warn};

/// Stratis-related errors.
#[derive(Debug, thiserror::Error)]
pub enum StratisError {
    #[error("D-Bus error: {0}")]
    DBus(#[from] zbus::Error),
    #[error("D-Bus fdo error: {0}")]
    Fdo(#[from] zbus::fdo::Error),
    #[error("stratisd not available on D-Bus")]
    NotAvailable,
    #[error("pool not found: {0}")]
    PoolNotFound(String),
    #[error("filesystem not found: {0}")]
    FilesystemNotFound(String),
    #[error("API error from stratisd: {0}")]
    Api(String),
    #[error("parse error: {0}")]
    Parse(String),
}

/// Rich Stratis pool metadata resolved from D-Bus.
#[derive(Debug, Clone)]
pub struct StratisPoolInfo {
    pub pool_name: String,
    pub pool_uuid: String,
    pub pool_object_path: String,
    pub filesystem_name: String,
    pub filesystem_uuid: String,
    pub filesystem_object_path: String,
    pub total_physical_size: u64,
    pub total_physical_used: Option<u64>,
    pub no_alloc_space: bool,
    pub encrypted: bool,
    pub has_cache: bool,
    pub overprovisioning: bool,
    pub fs_size: u64,
    pub fs_used: Option<u64>,
    pub fs_devnode: String,
    pub origin: Option<String>,
}

/// A Stratis filesystem snapshot entry.
#[derive(Debug, Clone)]
pub struct StratisSnapshot {
    pub name: String,
    pub object_path: String,
    pub created: String,
    pub origin_path: Option<String>,
    pub size: u64,
    pub used: Option<u64>,
}

/// Pool capacity summary.
#[derive(Debug, Clone)]
pub struct PoolCapacity {
    pub total_bytes: u64,
    pub used_bytes: u64,
    pub free_pct: f64,
    pub no_alloc_space: bool,
}

/// Check if stratisd is available on the system D-Bus.
pub async fn is_stratisd_available() -> bool {
    match zbus::Connection::system().await {
        Ok(conn) => {
            let proxy = zbus::fdo::DBusProxy::new(&conn).await;
            match proxy {
                Ok(p) => {
                    #[allow(clippy::unwrap_used)]
                    let bus_name: zbus::names::BusName = "org.storage.stratis3".try_into().unwrap();
                    p.name_has_owner(bus_name).await.unwrap_or(false)
                }
                Err(_) => false,
            }
        }
        Err(_) => false,
    }
}

/// Resolve a mount path or devnode to its Stratis pool and filesystem via D-Bus.
///
/// Accepts either a devnode path (e.g., `/dev/stratis/pool/fs`) or a mount path
/// (e.g., `/mnt/target-stratis`). For mount paths, resolves the backing device
/// via `/proc/self/mountinfo` first.
///
/// Returns error if stratisd is not running or the path is not on Stratis.
pub async fn resolve_stratis_target(
    conn: &zbus::Connection,
    path_or_devnode: &str,
) -> Result<StratisPoolInfo, StratisError> {
    // If the input is a mount path (not a /dev/ path), resolve to devnode
    let resolved_devnode = if path_or_devnode.starts_with("/dev/") {
        path_or_devnode.to_string()
    } else {
        // Try to resolve mount path -> backing device via /proc/self/mountinfo
        resolve_mount_to_devnode(path_or_devnode).unwrap_or_else(|| path_or_devnode.to_string())
    };

    let proxy = zbus::fdo::ObjectManagerProxy::builder(conn)
        .destination("org.storage.stratis3")?
        .path("/org/storage/stratis3")?
        .build()
        .await?;

    let objects = proxy.get_managed_objects().await?;

    // First pass: find the filesystem matching our devnode (try both resolved and original)
    let mut fs_path = None;
    let mut fs_props: Option<HashMap<String, zvariant::OwnedValue>> = None;

    for (path, interfaces) in &objects {
        for (iface_name, props) in interfaces {
            if !iface_name.as_str().starts_with("org.storage.stratis3.filesystem") {
                continue;
            }
            if let Some(dn) = props.get("Devnode") {
                let dn_str: &str = dn.downcast_ref::<&str>().unwrap_or("");
                // Match against resolved devnode, original path, or symlink target
                if dn_str == resolved_devnode
                    || dn_str == path_or_devnode
                    || resolve_symlink(dn_str) == resolve_symlink(&resolved_devnode)
                {
                    fs_path = Some(path.to_string());
                    fs_props = Some(props.iter().map(|(k, v)| {
                        (k.to_string(), v.clone())
                    }).collect());
                    break;
                }
            }
        }
        if fs_path.is_some() { break; }
    }

    let fs_obj_path = fs_path.ok_or_else(|| {
        StratisError::FilesystemNotFound(path_or_devnode.to_string())
    })?;
    let props = fs_props.ok_or_else(|| {
        StratisError::FilesystemNotFound(path_or_devnode.to_string())
    })?;

    // Extract filesystem properties
    let fs_name = extract_string(&props, "Name").unwrap_or_default();
    let fs_uuid = extract_string(&props, "Uuid").unwrap_or_default();
    let fs_size = extract_size_string(&props, "Size").unwrap_or(0);
    let fs_used = extract_optional_size(&props, "Used");
    let fs_devnode_val = extract_string(&props, "Devnode").unwrap_or_default();

    // Get the pool object path from the filesystem's Pool property
    let pool_obj_path = extract_object_path(&props, "Pool")
        .ok_or_else(|| StratisError::Parse("Missing Pool property".to_string()))?;

    // Get origin (if this filesystem is a snapshot)
    let origin = extract_optional_string(&props, "Origin");

    // Second pass: find the pool and extract its properties
    let mut pool_name = String::new();
    let mut pool_uuid = String::new();
    let mut total_physical_size: u64 = 0;
    let mut total_physical_used: Option<u64> = None;
    let mut no_alloc_space = false;
    let mut encrypted = false;
    let mut has_cache = false;
    let mut overprovisioning = false;

    for (path, interfaces) in &objects {
        if path.as_str() != pool_obj_path {
            continue;
        }
        for (iface_name, props) in interfaces {
            if !iface_name.as_str().starts_with("org.storage.stratis3.pool") {
                continue;
            }
            let pmap: HashMap<String, zvariant::OwnedValue> = props.iter()
                .map(|(k, v)| (k.to_string(), v.clone()))
                .collect();

            pool_name = extract_string(&pmap, "Name").unwrap_or_default();
            pool_uuid = extract_string(&pmap, "Uuid").unwrap_or_default();
            total_physical_size = extract_size_string(&pmap, "TotalPhysicalSize").unwrap_or(0);
            total_physical_used = extract_optional_size(&pmap, "TotalPhysicalUsed");
            no_alloc_space = extract_bool(&pmap, "NoAllocSpace").unwrap_or(false);
            encrypted = extract_bool(&pmap, "Encrypted").unwrap_or(false);
            has_cache = extract_bool(&pmap, "HasCache").unwrap_or(false);
            overprovisioning = extract_bool(&pmap, "Overprovisioning").unwrap_or(false);
            break;
        }
    }

    if pool_name.is_empty() {
        return Err(StratisError::PoolNotFound(pool_obj_path));
    }

    info!(
        "Resolved Stratis target: pool={} fs={} encrypted={} cache={} physical_used={:?}",
        pool_name, fs_name, encrypted, has_cache, total_physical_used
    );

    Ok(StratisPoolInfo {
        pool_name,
        pool_uuid,
        pool_object_path: pool_obj_path,
        filesystem_name: fs_name,
        filesystem_uuid: fs_uuid,
        filesystem_object_path: fs_obj_path,
        total_physical_size,
        total_physical_used,
        no_alloc_space,
        encrypted,
        has_cache,
        overprovisioning,
        fs_size,
        fs_used,
        fs_devnode: fs_devnode_val,
        origin,
    })
}

/// Query pool physical capacity.
pub async fn query_pool_capacity(
    conn: &zbus::Connection,
    pool_object_path: &str,
) -> Result<PoolCapacity, StratisError> {
    let proxy = zbus::fdo::PropertiesProxy::builder(conn)
        .destination("org.storage.stratis3")?
        .path(pool_object_path)?
        .build()
        .await?;

    // Use the latest pool interface revision available
    let iface: zbus::names::InterfaceName = "org.storage.stratis3.pool.r8"
        .try_into()
        .map_err(|_| StratisError::Parse("Invalid interface name".to_string()))?;

    let total_val = proxy.get(iface.clone(), "TotalPhysicalSize").await?;
    let total: u64 = total_val.downcast_ref::<&str>()
        .unwrap_or("0")
        .parse()
        .map_err(|e| StratisError::Parse(format!("TotalPhysicalSize: {}", e)))?;

    // TotalPhysicalUsed is (bool, string) on D-Bus
    let used_val = proxy.get(iface.clone(), "TotalPhysicalUsed").await?;
    let used = parse_optional_size_tuple(&used_val).unwrap_or(0);

    let no_alloc_val = proxy.get(iface, "NoAllocSpace").await?;
    let no_alloc = no_alloc_val.downcast_ref::<bool>().unwrap_or(false);

    let free_pct = if total > 0 {
        ((total.saturating_sub(used)) as f64 / total as f64) * 100.0
    } else {
        0.0
    };

    Ok(PoolCapacity {
        total_bytes: total,
        used_bytes: used,
        free_pct,
        no_alloc_space: no_alloc,
    })
}

/// Create a Stratis filesystem snapshot via D-Bus.
pub async fn create_stratis_snapshot(
    conn: &zbus::Connection,
    pool_object_path: &str,
    filesystem_object_path: &str,
    snapshot_name: &str,
) -> Result<String, StratisError> {
    // Call SnapshotFilesystem on the pool object
    let proxy = zbus::Proxy::new(
        conn,
        "org.storage.stratis3",
        pool_object_path,
        "org.storage.stratis3.pool.r8",
    ).await?;

    // SnapshotFilesystem(filesystem_object_path: o, snapshot_name: s)
    // Returns: ((b, o), (q, s))  --  (success+path, return_code+message)
    let reply: ((bool, zvariant::OwnedObjectPath), (u16, String)) = proxy
        .call("SnapshotFilesystem", &(filesystem_object_path, snapshot_name))
        .await?;

    let ((success, snap_path), (return_code, message)) = reply;

    if return_code != 0 || !success {
        return Err(StratisError::Api(format!(
            "SnapshotFilesystem failed (code {}): {}", return_code, message
        )));
    }

    info!("Stratis snapshot created: {} -> {}", snapshot_name, snap_path.as_str());
    Ok(snap_path.to_string())
}

/// Enumerate all Stratis filesystem snapshots in a pool.
pub async fn enumerate_stratis_snapshots(
    conn: &zbus::Connection,
    pool_object_path: &str,
) -> Result<Vec<StratisSnapshot>, StratisError> {
    let proxy = zbus::fdo::ObjectManagerProxy::builder(conn)
        .destination("org.storage.stratis3")?
        .path("/org/storage/stratis3")?
        .build()
        .await?;

    let objects = proxy.get_managed_objects().await?;
    let mut snapshots = Vec::new();

    for (path, interfaces) in &objects {
        for (iface_name, props) in interfaces {
            if !iface_name.as_str().starts_with("org.storage.stratis3.filesystem") {
                continue;
            }

            let pmap: HashMap<String, zvariant::OwnedValue> = props.iter()
                .map(|(k, v)| (k.to_string(), v.clone()))
                .collect();

            // Check if this filesystem belongs to our pool
            let fs_pool = extract_object_path(&pmap, "Pool").unwrap_or_default();
            if fs_pool != pool_object_path {
                continue;
            }

            // Check if this is a snapshot (has Origin property set)
            let origin = extract_optional_string(&pmap, "Origin");
            if origin.is_none() {
                continue; // Not a snapshot
            }

            snapshots.push(StratisSnapshot {
                name: extract_string(&pmap, "Name").unwrap_or_default(),
                object_path: path.to_string(),
                created: extract_string(&pmap, "Created").unwrap_or_default(),
                origin_path: origin,
                size: extract_size_string(&pmap, "Size").unwrap_or(0),
                used: extract_optional_size(&pmap, "Used"),
            });
        }
    }

    // Sort by creation time
    snapshots.sort_by(|a, b| a.created.cmp(&b.created));

    Ok(snapshots)
}

/// Prune old foxing-created Stratis snapshots, keeping the N most recent.
/// Only prunes snapshots whose name starts with `prefix`.
/// Tagged snapshots (name contains user-defined tags) are never pruned.
pub async fn prune_stratis_snapshots(
    conn: &zbus::Connection,
    pool_object_path: &str,
    prefix: &str,
    keep: usize,
) -> Result<usize, StratisError> {
    let snapshots = enumerate_stratis_snapshots(conn, pool_object_path).await?;

    // Filter to foxing-managed snapshots
    let foxing_snaps: Vec<&StratisSnapshot> = snapshots.iter()
        .filter(|s| s.name.starts_with(prefix))
        .collect();

    let to_delete = if foxing_snaps.len() > keep {
        foxing_snaps.len() - keep
    } else {
        return Ok(0);
    };

    // Delete oldest (list is sorted by creation time)
    let delete_paths: Vec<&str> = foxing_snaps[..to_delete]
        .iter()
        .map(|s| s.object_path.as_str())
        .collect();

    if delete_paths.is_empty() {
        return Ok(0);
    }

    let proxy = zbus::Proxy::new(
        conn,
        "org.storage.stratis3",
        pool_object_path,
        "org.storage.stratis3.pool.r8",
    ).await?;

    // DestroyFilesystems([object_path, ...])
    let reply: ((bool, Vec<zvariant::OwnedObjectPath>), (u16, String)) = proxy
        .call("DestroyFilesystems", &(&delete_paths,))
        .await?;

    let ((_, _destroyed), (return_code, message)) = reply;

    if return_code != 0 {
        warn!("Stratis snapshot pruning warning (code {}): {}", return_code, message);
    }

    info!("Pruned {} Stratis snapshots (kept {})", to_delete, keep);
    Ok(to_delete)
}

// --- Helper functions for D-Bus property extraction (zvariant v5 API) ---
// zvariant v5: downcast_ref<T>() returns Result<T, Error> where T: TryFrom<&Value>

fn extract_string(props: &HashMap<String, zvariant::OwnedValue>, key: &str) -> Option<String> {
    props.get(key).and_then(|v| {
        // downcast_ref::<&str>() returns Result<&str, Error>
        v.downcast_ref::<&str>().ok().map(|s| s.to_string())
    })
}

fn extract_optional_string(props: &HashMap<String, zvariant::OwnedValue>, key: &str) -> Option<String> {
    // D-Bus type (bs)  --  (bool, string). Stratis uses this for optional values.
    // In zvariant v5, access via Structure fields.
    props.get(key).and_then(|v| {
        if let Ok(structure) = v.downcast_ref::<zvariant::Structure<'_>>() {
            let fields = structure.fields();
            if fields.len() == 2 {
                let valid = fields[0].downcast_ref::<bool>().unwrap_or(false);
                if valid {
                    return fields[1].downcast_ref::<&str>().ok().map(|s| s.to_string());
                }
            }
        }
        None
    })
}

fn extract_bool(props: &HashMap<String, zvariant::OwnedValue>, key: &str) -> Option<bool> {
    props.get(key).and_then(|v| v.downcast_ref::<bool>().ok())
}

fn extract_object_path(props: &HashMap<String, zvariant::OwnedValue>, key: &str) -> Option<String> {
    props.get(key).and_then(|v| {
        v.downcast_ref::<zvariant::ObjectPath<'_>>()
            .ok()
            .map(|p| p.to_string())
    })
}

fn extract_size_string(props: &HashMap<String, zvariant::OwnedValue>, key: &str) -> Option<u64> {
    extract_string(props, key).and_then(|s| s.parse().ok())
}

fn extract_optional_size(props: &HashMap<String, zvariant::OwnedValue>, key: &str) -> Option<u64> {
    extract_optional_string(props, key).and_then(|s| s.parse().ok())
}

fn resolve_mount_to_devnode(mount_path: &str) -> Option<String> {
    let path = std::path::Path::new(mount_path);
    let entry = crate::mount_info::find_mount_for_path(path)?;
    if entry.source.is_empty() || entry.source == "none" {
        return None;
    }
    debug!("resolve_mount_to_devnode: {} -> {}", mount_path, entry.source);
    Some(entry.source)
}

/// Resolve a symlink to its target (for comparing /dev/stratis/pool/fs with /dev/dm-N).
fn resolve_symlink(path: &str) -> String {
    std::fs::canonicalize(path)
        .map(|p| p.to_string_lossy().into_owned())
        .unwrap_or_else(|_| path.to_string())
}

fn parse_optional_size_tuple(val: &zvariant::OwnedValue) -> Option<u64> {
    if let Ok(structure) = val.downcast_ref::<zvariant::Structure<'_>>() {
        let fields = structure.fields();
        if fields.len() == 2 {
            let valid = fields[0].downcast_ref::<bool>().unwrap_or(false);
            if valid {
                return fields[1].downcast_ref::<&str>().ok().and_then(|s| s.parse().ok());
            }
        }
    }
    None
}

#[cfg(test)]
mod tests {
    #![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
    use super::*;

    #[tokio::test]
    async fn test_stratisd_availability_check() {
        // This test works regardless of whether stratisd is running
        let available = is_stratisd_available().await;
        // Just verify it doesn't panic
        println!("stratisd available: {}", available);
    }

    #[test]
    fn test_snapshot_name_generation() {
        let name = format!(
            "foxing-snap-{}",
            chrono::Utc::now().format("%Y%m%dT%H%M%S")
        );
        assert!(name.starts_with("foxing-snap-"));
        assert!(name.len() > 20);
    }

    #[test]
    fn test_pool_capacity_free_pct() {
        let cap = PoolCapacity {
            total_bytes: 1_000_000_000,
            used_bytes: 700_000_000,
            free_pct: 30.0,
            no_alloc_space: false,
        };
        assert!((cap.free_pct - 30.0).abs() < 0.01);
    }
}