gunnar-server 2.0.0

//! **`Admin.Topology`'s facts from this server** (2026-10-04): what only
//! `gunnar-server` holds — the installer's pairing feed (`joined.toml`) with
//! the ESTATE RECORD it carries (the `estate.*` keys: every box as the kit laid
//! it), which principals run on the front, the plugin registration, this box's
//! own data volume. The assembly and every verdict are `gunnar_grpc::topology`'s; this
//! module only reads.

use std::path::Path;

use gunnar_grpc::topology::Facts;

/// The front's principals, as the pairing feed offers them, and what each one
/// is on the front. `front-certify` is the front itself (no service word of
/// its own: it signs the twin's certificate).
#[cfg(feature = "wg-client")]
fn front_principals() -> std::collections::BTreeMap<String, String> {
    crate::fed_principals::OFFERED_PRINCIPALS
        .iter()
        .map(|(offer, id, _)| {
            let service = match *offer {
                crate::fed_principals::OFFER_MONETIZE_IDENTITY => gunnar_grpc::topology::SERVICE_MONETIZE,
                crate::fed_principals::OFFER_CONSOLE_PUBKEY | crate::fed_principals::OFFER_GUEST_PUBKEY => gunnar_grpc::topology::SERVICE_CONSOLE,
                _ => gunnar_grpc::topology::ROLE_FRONT,
            };
            (id.to_string(), service.to_string())
        })
        .collect()
}

/// **The pairing feed's view of the estate**, from `joined.toml` — pure over
/// the reply, so a test hands it one.
#[cfg(feature = "wg-client")]
pub fn from_reply(reply: &nordisk_pairing::join::JoinReply) -> Facts {
    use nordisk_pairing::Role;
    let me = reply.me.name.clone();
    let address = match (reply.role, reply.primary_utility) {
        (Some(Role::Primary), Some(utility)) => utility.to_string(),
        _ => reply.me.overlay.to_string(),
    };
    let peers = reply
        .peers
        .iter()
        .filter(|p| p.name != me)
        .map(|p| {
            let mut hosts = Vec::new();
            if let Some(u) = p.utility {
                hosts.push(u.to_string());
            }
            // The primary's control plane is its utility address, which the
            // reply carries apart from the peer list.
            if p.role == Role::Primary {
                if let Some(u) = reply.primary_utility {
                    hosts.push(u.to_string());
                }
            }
            hosts.push(p.overlay.to_string());
            if let Some(e) = &p.endpoint {
                hosts.push(gunnar_grpc::topology::host_of(e));
            }
            hosts.dedup();
            gunnar_grpc::topology::Peer { name: p.name.clone(), role: p.role.as_str().to_owned(), hosts }
        })
        .collect();
    Facts {
        estate: reply.estate.clone(),
        me,
        address,
        peers,
        front_principals: front_principals(),
        // The installer's record of the estate, from the same feed; renewed by
        // every re-admission (upgrade, recharge), which rewrites joined.toml.
        record: gunnar_grpc::topology::Record::from_feed(&reply.feed),
        ..Facts::default()
    }
}

/// **Everything this server knows**, read at the moment of the call.
pub fn facts(root: &Path) -> Facts {
    #[cfg(feature = "wg-client")]
    let mut facts = crate::fed_at_rest::read(root, crate::pairing::JOINED_REL)
        .and_then(|t| nordisk_pairing::join::JoinReply::parse(&t).ok())
        .map(|reply| from_reply(&reply))
        .unwrap_or_else(|| Facts { front_principals: front_principals(), ..Facts::default() });
    #[cfg(not(feature = "wg-client"))]
    let mut facts = Facts::default();

    let fs = crate::stores::filesystem_use("data root", root);
    if fs.measured && fs.total_bytes > 0 {
        facts.disk = Some((fs.total_bytes, fs.total_bytes.saturating_sub(fs.free_bytes)));
    }
    facts
}

#[cfg(all(test, feature = "wg-client"))]
mod tests {
    use super::*;
    use nordisk_pairing::join::{Assigned, JoinReply, Peer as PairPeer};
    use nordisk_pairing::Role;
    use std::net::Ipv4Addr;

    fn peer(name: &str, role: Role, overlay: [u8; 4], utility: Option<[u8; 4]>, endpoint: Option<&str>) -> PairPeer {
        PairPeer {
            name: name.into(),
            role,
            tunnel_pubkey: String::new(),
            overlay: Ipv4Addr::from(overlay),
            endpoint: endpoint.map(str::to_owned),
            utility: utility.map(Ipv4Addr::from),
        }
    }

    /// ★ **The pairing feed names the estate**: this box by its name and
    /// utility address, every OTHER peer with every address it can be
    /// matched on, and the front's offered principals with what each is.
    #[test]
    fn the_feed_names_this_box_and_its_peers() {
        let reply = JoinReply {
            estate: "test2.gunnar.rs".into(),
            me: Assigned { name: "vm2".into(), overlay: Ipv4Addr::new(10, 99, 0, 2) },
            cert_pem: None,
            role: Some(Role::Primary),
            primary_overlay: Some(Ipv4Addr::new(10, 99, 0, 2)),
            primary_utility: Some(Ipv4Addr::new(10, 13, 8, 121)),
            peers: vec![
                peer("front", Role::Front, [10, 99, 0, 1], None, Some("95.111.211.189:51820")),
                peer("vm2", Role::Primary, [10, 99, 0, 2], None, None),
                peer("vm3", Role::Twin, [10, 99, 0, 3], Some([10, 13, 8, 122]), None),
            ],
            feed: Default::default(),
        };
        let f = from_reply(&reply);
        assert_eq!((f.estate.as_str(), f.me.as_str(), f.address.as_str()), ("test2.gunnar.rs", "vm2", "10.13.8.121"));
        assert_eq!(f.record, None, "a feed with no estate record is no record");
        let names: Vec<_> = f.peers.iter().map(|p| (p.name.as_str(), p.role.as_str())).collect();
        assert_eq!(names, [("front", "front"), ("vm3", "twin")], "this box is not its own peer");
        assert_eq!(f.peers[0].hosts, ["10.99.0.1", "95.111.211.189"]);
        assert_eq!(f.peers[1].hosts, ["10.13.8.122", "10.99.0.3"]);
        assert_eq!(f.front_principals.get("gunnar-ui").map(String::as_str), Some("console"));
        assert_eq!(f.front_principals.get("monetize").map(String::as_str), Some("monetize"));
    }

    /// Unpaired (a solo gunnar, the uitest rig): no estate, no peers — and
    /// the data volume is still measured.
    #[test]
    fn an_unpaired_box_knows_itself_and_its_disk() {
        let dir = tempfile::tempdir().unwrap();
        let f = facts(dir.path());
        assert!(f.estate.is_empty() && f.peers.is_empty());
        assert!(f.disk.is_some_and(|(total, _)| total > 0));
    }

    /// ★ **The installer's record rides the feed the pairing persisted**: a
    /// box fed `estate.*` keys reads back every laid box, as the kit wrote it.
    #[test]
    fn the_feed_carries_the_installers_estate_record() {
        use gunnar_grpc::topology::{Record, RecordBox};
        let record = Record {
            variant: "gunnar-twin".into(),
            versions: vec![("gunnar".into(), "abc".into())],
            boxes: ["front", "main", "twin"]
                .iter()
                .map(|n| RecordBox { name: n.to_string(), laid_as: n.to_string(), utility: format!("10.0.0.{}", n.len()), ..Default::default() })
                .collect(),
        };
        let reply = JoinReply {
            estate: "e".into(),
            me: Assigned { name: "main".into(), overlay: Ipv4Addr::new(10, 99, 0, 2) },
            cert_pem: None,
            role: Some(Role::Primary),
            primary_overlay: None,
            primary_utility: None,
            peers: vec![],
            feed: record.to_feed(),
        };
        // Through the persisted text, as the server reads it at each call.
        let reply = JoinReply::parse(&reply.render().unwrap()).unwrap();
        assert_eq!(from_reply(&reply).record, Some(record));
    }
}