harmony/fleet/harmony-fleet-agent/src/config.rs

use harmony_reconciler_contracts::Id;
use serde::Deserialize;
use std::collections::BTreeMap;
use std::path::Path;

// Re-export the shared credential types so existing call sites keep
// working with `crate::config::CredentialsSection`. The struct itself
// lives in `harmony_fleet_auth` and is shared with the operator.
pub use harmony_fleet_auth::CredentialsSection;

#[derive(Debug, Clone, Deserialize)]
pub struct AgentConfig {
    pub agent: AgentSection,
    pub nats: NatsSection,
    pub credentials: CredentialsSection,
    /// Routing labels published verbatim in every DeviceInfo
    /// heartbeat. The operator reflects them into
    /// `Device.metadata.labels` so Deployment `spec.targetSelector`
    /// resolves against them (K8s-Node-analogue flow). Empty by
    /// default — a device with no labels is targetable only by its
    /// auto-published `device-id` label.
    #[serde(default)]
    pub labels: BTreeMap<String, String>,
}

#[derive(Debug, Clone, Deserialize)]
pub struct AgentSection {
    /// Cross-boundary device identity. TOML deserializes the field
    /// as a bare string thanks to `#[serde(transparent)]` on `Id`.
    pub device_id: Id,
    /// When false, skip the podman socket + reconciler loop and run
    /// only the heartbeat + command-server arms. Lets the agent run
    /// on hosts without podman (e.g. the in-cluster e2e harness on
    /// containerd-only k3d nodes). Default true so existing RPi
    /// configs are unaffected.
    #[serde(default = "default_runtime_enabled")]
    pub runtime_enabled: bool,
}

fn default_runtime_enabled() -> bool {
    true
}

#[derive(Debug, Clone, Deserialize)]
pub struct NatsSection {
    pub urls: Vec<String>,
}

pub fn load_config(path: &Path) -> anyhow::Result<AgentConfig> {
    let content = std::fs::read_to_string(path)?;
    let config: AgentConfig = toml::from_str(&content)?;
    Ok(config)
}

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

    #[test]
    fn parses_toml_shared_credentials() {
        let raw = r#"
[agent]
device_id = "pi-42"
runtime_enabled = true

[credentials]
type = "toml-shared"
nats_user = "u"
nats_pass = "p"

[nats]
urls = ["nats://nats:4222"]

[labels]
group = "site-a"
arch = "aarch64"
"#;
        let cfg: AgentConfig = toml::from_str(raw).expect("valid config");
        assert_eq!(cfg.labels.get("group"), Some(&"site-a".to_string()));
        match &cfg.credentials {
            CredentialsSection::TomlShared {
                nats_user,
                nats_pass,
            } => {
                assert_eq!(nats_user, "u");
                assert_eq!(nats_pass, "p");
            }
            _ => panic!("expected TomlShared"),
        }
    }

    #[test]
    fn labels_section_optional_defaults_empty() {
        let raw = r#"
[agent]
device_id = "pi-42"

[credentials]
type = "toml-shared"
nats_user = "u"
nats_pass = "p"

[nats]
urls = ["nats://nats:4222"]
"#;
        let cfg: AgentConfig = toml::from_str(raw).expect("valid config");
        assert!(cfg.labels.is_empty());
    }

    #[test]
    fn runtime_enabled_defaults_to_true_when_omitted() {
        // Existing RPi configs predate the runtime_enabled flag.
        // Omitting it must keep podman+reconciler turned on — anything
        // else silently downgrades a production agent.
        let raw = r#"
[agent]
device_id = "pi-42"

[credentials]
type = "toml-shared"
nats_user = "u"
nats_pass = "p"

[nats]
urls = ["nats://nats:4222"]
"#;
        let cfg: AgentConfig = toml::from_str(raw).expect("valid config");
        assert!(cfg.agent.runtime_enabled);
    }

    #[test]
    fn runtime_enabled_false_is_honored() {
        let raw = r#"
[agent]
device_id = "pi-42"
runtime_enabled = false

[credentials]
type = "toml-shared"
nats_user = "u"
nats_pass = "p"

[nats]
urls = ["nats://nats:4222"]
"#;
        let cfg: AgentConfig = toml::from_str(raw).expect("valid config");
        assert!(!cfg.agent.runtime_enabled);
    }
}