use super::task_board::TaskOffer;
use crate::policy::admit::{Request, Source, Workload};
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
}
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
}
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();
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");
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);
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);
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());
let cap = Capacity {
gpu: vec![class(None, 3)],
..Capacity::default()
};
o.min_vram_gb = Some(8);
assert!(vram_shortfall(&cap, &o).is_some());
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);
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,
));
assert_eq!(policy_refused(&state, &offer()), None);
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}");
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"
);
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}"
);
assert_eq!(policy_refused(&state, &offer()), None);
state.config.owner_user_id = Some("someone-else".into());
assert_eq!(policy_refused(&state, &o), None);
}
}