zc2 0.0.47

P2P compute broker with yen-denominated billing, WAL, and broker mesh support
//! The broker's hooks into the node policy's one admission check
//! (`crate::policy::admit`, ADR ZC-0017 ยง5). Logic lives there; this file only
//! turns a peer offer into a [`Request`].

use super::task_board::TaskOffer;
use crate::policy::admit::{Request, Source, Workload};

/// The admission request for a peer task offer: no squad token exists yet, so
/// it is public-squad work; the price on offer is the requester's ceiling.
pub fn offer_request(offer: &TaskOffer, own_account: Option<&str>) -> Request {
    let mut r = Request::new(Source::PeerOffer, Workload::Function);
    r.own = own_account.is_some_and(|o| !o.is_empty() && o == offer.requester_user_id);
    r.cpus = offer.cpus;
    r.memory_bytes = offer.memory_bytes;
    r.gpus = offer.gpus;
    r.price_per_hour = Some(offer.max_price_per_hour);
    r
}

// The peer offer's admission (policy, then what is held and free) is
// `revenue::admit_peer_offer`, called once from `run_peer_offer`, so every
// transport (HTTP, QUIC one-shot, task feed) is covered.

/// The admission request for a guest deployment the hub placed here: an
/// Environment, public squad until workload tokens exist. A deployment that
/// carries no price (own or free) offers none to compare with the floor.
pub fn guest_request(d: &super::deploy::Desired) -> Request {
    let mut r = Request::new(Source::EnvGuest, Workload::Environment);
    if d.price_per_second > 0.0 {
        r.price_per_hour = Some(d.price_per_second * 3600.0);
    }
    r
}

/// Refuse a guest deployment the node's policy does not allow (the deploy
/// reconciler asks through `ContainerRuntime::admit_guest`).
pub fn guest_deployment(d: &super::deploy::Desired) -> Result<(), crate::policy::admit::Refusal> {
    crate::policy::Admission::process().check(&guest_request(d))
}

#[cfg(test)]
mod tests {
    use super::super::BrokerState;
    use super::*;
    use crate::policy::admit::Reason;
    use crate::policy::{Admission, MinPrice, Policy};

    fn offer() -> TaskOffer {
        serde_json::from_value(serde_json::json!({
            "task_id": "t1", "payload_b64": "", "max_price_per_hour": 12.0,
            "estimated_duration_secs": 1.0, "timeout_secs": 5.0,
            "requester_user_id": "someone-else", "source_broker": "peer"
        }))
        .unwrap()
    }

    #[test]
    fn an_offer_becomes_a_public_squad_request_with_its_size_and_price() {
        let r = offer_request(&offer(), Some("me"));
        assert_eq!(r.source, Source::PeerOffer);
        assert!(!r.own);
        assert_eq!(r.squad, None);
        assert_eq!(r.price_per_hour, Some(12.0));
        assert_eq!((r.cpus, r.memory_bytes, r.gpus), (1.0, 1 << 30, 0));
    }

    #[test]
    fn an_offer_from_the_nodes_own_account_is_not_foreign() {
        assert!(offer_request(&offer(), Some("someone-else")).own);
        assert!(!offer_request(&offer(), Some("")).own);
        assert!(!offer_request(&offer(), None).own);
    }

    #[test]
    fn the_peer_executor_refuses_by_policy_on_every_transport() {
        let mut state = BrokerState::new();
        // squads = [] : foreign work is refused before a worker is reserved.
        let mut p = Policy::default();
        p.sharing.squads = Vec::new();
        state.admission = Admission::pinned(p, None);
        let e = super::super::server::run_peer_offer(&state, &offer(), false).unwrap_err();
        assert!(e.reason.contains("policy refused (squad)"), "{}", e.reason);
        assert_eq!(e.task_id, "t1");
        // The price floor is against the requester's ceiling.
        let mut p = Policy::default();
        p.sharing.min_price = MinPrice::PerHour(50.0);
        state.admission = Admission::pinned(p, None);
        let e = super::super::server::run_peer_offer(&state, &offer(), false).unwrap_err();
        assert!(e.reason.contains("(price)"), "{}", e.reason);
        assert_eq!(state.admission.snapshot()["refused"]["price"], 1);
        // Open policy: the offer reaches the router (no worker here, so that
        // is the refusal now, not the policy's).
        state.admission = Admission::pinned(Policy::default(), None);
        let e = super::super::server::run_peer_offer(&state, &offer(), false).unwrap_err();
        assert!(!e.reason.contains("policy refused"), "{}", e.reason);
    }

    #[test]
    fn a_guest_deployment_is_an_environment_with_its_hourly_price() {
        let d: super::super::deploy::Desired = serde_json::from_value(serde_json::json!({
            "id": "d1", "version": 1, "name": "n", "image": "i",
            "price_per_second": 0.002, "desired_state": "running"
        }))
        .unwrap();
        let r = guest_request(&d);
        assert_eq!(r.workload, Workload::Environment);
        assert!((r.price_per_hour.unwrap() - 7.2).abs() < 1e-9);
        let free: super::super::deploy::Desired = serde_json::from_value(serde_json::json!({
            "id": "d1", "version": 1, "name": "n", "image": "i",
            "price_per_second": 0.0, "desired_state": "running"
        }))
        .unwrap();
        assert_eq!(guest_request(&free).price_per_hour, None);
        // Switched off: refused with the workload reason.
        let mut p = Policy::default();
        p.workloads.environments = false;
        let a = Admission::pinned(p, None);
        assert_eq!(a.check(&r).unwrap_err().reason, Reason::Workload);
    }

    fn policy_refused(state: &BrokerState, o: &TaskOffer) -> Option<String> {
        super::super::server::run_peer_offer(state, o, false)
            .err()
            .map(|e| e.reason)
            .filter(|r| r.contains("policy refused"))
    }

    fn pinned_state(budget: crate::sandbox::Limits) -> BrokerState {
        let mut state = BrokerState::new();
        state.admission = Admission::pinned(Policy::default(), Some(budget));
        state
    }

    #[test]
    fn min_vram_is_additive_on_the_wire() {
        let o = offer();
        assert_eq!(o.min_vram_gb, None);
        assert!(
            !serde_json::to_string(&o).unwrap().contains("min_vram_gb"),
            "an offer without a floor serializes as it did before the field"
        );
        let mut v = serde_json::to_value(&o).unwrap();
        v["min_vram_gb"] = serde_json::json!(24);
        let o: TaskOffer = serde_json::from_value(v).unwrap();
        assert_eq!(o.min_vram_gb, Some(24));
    }

    #[test]
    fn a_vram_floor_is_checked_against_the_free_gpus_of_the_capacity_view() {
        use crate::broker::capacity::{Capacity, GpuClass, Share};
        use crate::broker::revenue::vram_shortfall;
        let class = |vram, free| GpuClass {
            model: None,
            vram_gb: vram,
            price_per_hour: None,
            gpus: Share {
                total: 2,
                budget: 2,
                free,
            },
        };
        let cap = Capacity {
            gpu: vec![class(Some(24), 1), class(Some(11), 2), class(None, 3)],
            ..Capacity::default()
        };
        let mut o = offer();
        o.gpus = 1;
        assert_eq!(vram_shortfall(&cap, &o), None, "no floor: as before");
        o.min_vram_gb = Some(24);
        assert_eq!(vram_shortfall(&cap, &o), None, "one 24 GiB card is free");
        o.gpus = 2;
        let why = vram_shortfall(&cap, &o).expect("only one card has 24 GiB free");
        assert!(why.contains("24 GiB") && why.contains("1 free"), "{why}");
        o.gpus = 1;
        o.min_vram_gb = Some(48);
        assert!(vram_shortfall(&cap, &o).is_some());
        // A card that reports no VRAM never satisfies a floor.
        let cap = Capacity {
            gpu: vec![class(None, 3)],
            ..Capacity::default()
        };
        o.min_vram_gb = Some(8);
        assert!(vram_shortfall(&cap, &o).is_some());
        // CPU offers have no GPU to size.
        o.gpus = 0;
        assert_eq!(vram_shortfall(&cap, &o), None);
    }

    #[test]
    fn an_offer_with_a_vram_floor_no_free_gpu_meets_is_refused_as_budget() {
        let state = pinned_state(crate::sandbox::Limits::new(
            8.0,
            16.0,
            crate::sandbox::Gpus::All,
        ));
        let mut o = offer();
        o.gpus = 1;
        o.min_vram_gb = Some(24);
        let why = policy_refused(&state, &o).expect("no GPU worker is free");
        assert!(why.contains("(budget)") && why.contains("vram"), "{why}");
        assert_eq!(state.admission.snapshot()["refused"]["budget"], 1);
        // The same offer without the floor is not refused by vram.
        o.min_vram_gb = None;
        assert!(!policy_refused(&state, &o).is_some_and(|w| w.contains("vram")));
    }

    #[test]
    fn what_sandboxes_and_guests_hold_counts_against_peer_offers() {
        use crate::broker::revenue::Revenue;
        use crate::sandbox::Allocation;
        let mut state = pinned_state(crate::sandbox::Limits::new(
            4.0,
            8.0,
            crate::sandbox::Gpus::None,
        ));
        // Free: the offer reaches the router.
        assert_eq!(policy_refused(&state, &offer()), None);
        // A sandbox and a guest hold the whole budget.
        state.revenue = Revenue::new().with_workloads(std::sync::Arc::new(|| {
            vec![
                Allocation::from_label("zk-sbx-1", "3000m,4294967296").unwrap(),
                Allocation::from_label("zk-dep-a-v1", "1000m,4294967296").unwrap(),
            ]
        }));
        let why = policy_refused(&state, &offer()).expect("no budget left");
        assert!(why.contains("(budget)") && why.contains("cpu"), "{why}");
        // The capacity view the broker advertises agrees.
        let h = state.revenue.held_all();
        assert_eq!((h.cpus, h.memory_bytes), (4.0, 8 << 30));
        assert_eq!(
            state.revenue.held().cpus,
            0.0,
            "offers alone still hold none"
        );
        // A refusal for budget asks Spaces for room, at the offer's price.
        let w = state.revenue.take_room_wanted().expect("room asked for");
        assert_eq!(w.price_per_hour, 12.0);
        assert!(state.revenue.take_room_wanted().is_none(), "asked once");
    }

    #[test]
    fn budget_gpu_off_refuses_gpu_offers_unless_they_are_the_owners() {
        let mut state = pinned_state(crate::sandbox::Limits::new(
            8.0,
            16.0,
            crate::sandbox::Gpus::None,
        ));
        let mut o = offer();
        o.gpus = 1;
        let why = policy_refused(&state, &o).expect("budget.gpu is off");
        assert!(
            why.contains("(budget)") && why.contains("budget.gpu"),
            "{why}"
        );
        // A CPU offer is not affected.
        assert_eq!(policy_refused(&state, &offer()), None);
        // The node's own account is exempt.
        state.config.owner_user_id = Some("someone-else".into());
        assert_eq!(policy_refused(&state, &o), None);
    }
}