use std::sync::atomic::{AtomicUsize, Ordering};
use serde::{Deserialize, Serialize};
use super::credits::CreditManager;
use super::worker::{Worker, WorkerRegistry};
#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum RoutingStrategy {
#[default]
BestPrice,
BestLatency,
BestAvailability,
RoundRobin,
Random,
WeightedCapacity,
}
impl RoutingStrategy {
pub fn as_str(&self) -> &'static str {
match self {
RoutingStrategy::BestPrice => "best_price",
RoutingStrategy::BestLatency => "best_latency",
RoutingStrategy::BestAvailability => "best_availability",
RoutingStrategy::RoundRobin => "round_robin",
RoutingStrategy::Random => "random",
RoutingStrategy::WeightedCapacity => "weighted_capacity",
}
}
pub fn description(&self) -> &'static str {
match self {
RoutingStrategy::BestPrice => "Lowest cost per compute",
RoutingStrategy::BestLatency => "Fastest response time",
RoutingStrategy::BestAvailability => "Most available resources",
RoutingStrategy::RoundRobin => "Even distribution",
RoutingStrategy::Random => "Random selection",
RoutingStrategy::WeightedCapacity => "Weighted by capacity",
}
}
}
impl std::str::FromStr for RoutingStrategy {
type Err = String;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s.to_lowercase().as_str() {
"best_price" | "price" | "cheap" | "cheapest" => Ok(RoutingStrategy::BestPrice),
"best_latency" | "latency" | "fast" | "fastest" => Ok(RoutingStrategy::BestLatency),
"best_availability" | "availability" | "available" => {
Ok(RoutingStrategy::BestAvailability)
}
"round_robin" | "robin" | "rr" => Ok(RoutingStrategy::RoundRobin),
"random" | "rand" => Ok(RoutingStrategy::Random),
"weighted_capacity" | "weighted" | "capacity" => Ok(RoutingStrategy::WeightedCapacity),
_ => Err(format!("Unknown routing strategy: {}", s)),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ResourceRequirements {
#[serde(default = "default_cpus")]
pub cpus: f64,
#[serde(default = "default_memory")]
pub memory_bytes: u64,
#[serde(default)]
pub gpus: u32,
#[serde(default)]
pub worker_type: Option<String>,
#[serde(default)]
pub tags: Vec<String>,
#[serde(default = "default_duration")]
pub estimated_duration_secs: f64,
#[serde(default)]
pub strategy: RoutingStrategy,
#[serde(default)]
pub timeout_secs: f64,
#[serde(default)]
pub remote_only: bool,
#[serde(default)]
pub budget_credits: Option<f64>,
#[serde(default)]
pub target_worker: Option<String>,
#[serde(default)]
pub target_node: Option<String>,
#[serde(default)]
pub min_vram_gb: Option<u32>,
#[serde(default)]
pub python: Option<String>,
#[serde(default)]
pub placement: Option<super::placement::Placement>,
}
fn default_cpus() -> f64 {
1.0
}
fn default_memory() -> u64 {
1024 * 1024 * 1024
} fn default_duration() -> f64 {
1.0
}
impl Default for ResourceRequirements {
fn default() -> Self {
Self {
cpus: 1.0,
memory_bytes: 1024 * 1024 * 1024,
gpus: 0,
worker_type: None,
tags: Vec::new(),
estimated_duration_secs: 1.0,
strategy: RoutingStrategy::default(),
timeout_secs: 0.0, remote_only: false,
budget_credits: None,
target_worker: None,
target_node: None,
min_vram_gb: None,
python: None,
placement: None,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RoutingDecision {
pub worker: Worker,
pub estimated_cost: f64,
pub reason: String,
pub alternatives_count: usize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RoutingError {
pub code: String,
pub message: String,
}
impl RoutingError {
pub fn no_workers() -> Self {
Self {
code: "NO_WORKERS".to_string(),
message: "No workers available".to_string(),
}
}
pub fn no_capacity(requirements: &ResourceRequirements) -> Self {
Self {
code: "NO_CAPACITY".to_string(),
message: format!(
"No worker has capacity for {} CPUs, {} bytes memory, {} GPUs",
requirements.cpus, requirements.memory_bytes, requirements.gpus
),
}
}
pub fn insufficient_credits(required: f64, available: f64) -> Self {
Self {
code: "INSUFFICIENT_CREDITS".to_string(),
message: format!(
"Insufficient credits: need {:.4}, have {:.4}",
required, available
),
}
}
pub fn rate_limited() -> Self {
Self {
code: "RATE_LIMITED".to_string(),
message: "Rate limit exceeded".to_string(),
}
}
pub fn worker_type_unavailable(worker_type: &str) -> Self {
Self {
code: "WORKER_TYPE_UNAVAILABLE".to_string(),
message: format!("No workers of type '{}' available", worker_type),
}
}
pub fn timeout_incompatible(timeout: f64) -> Self {
Self {
code: "TIMEOUT_INCOMPATIBLE".to_string(),
message: format!(
"No worker accepts timeout of {:.1}s. Reduce timeout or wait for a compatible worker.",
timeout
),
}
}
pub fn tags_unavailable(required: &[String], missing: &[&str]) -> Self {
let detail = if missing.is_empty() {
"no single worker carries them all".to_string()
} else {
format!("no worker advertises: {}", missing.join(", "))
};
Self {
code: "NO_WORKERS_WITH_TAGS".to_string(),
message: format!(
"No healthy worker carries the required tag(s) [{}] ({})",
required.join(", "),
detail
),
}
}
pub fn quota_exceeded() -> Self {
Self {
code: "QUOTA_EXCEEDED".to_string(),
message: "All workers have exceeded their request quota for this time window"
.to_string(),
}
}
}
pub struct Router {
round_robin_counter: AtomicUsize,
node_fp: Option<String>,
}
fn expected_completion_ms(w: &Worker) -> f64 {
w.avg_latency_ms * (1.0 + w.active_requests as f64)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Scope<'a> {
Any,
Local { own_ip: Option<&'a str> },
Mesh { own_ip: Option<&'a str> },
}
pub struct Adaptive<'a> {
pub rng: &'a mut crate::broker::sampler::Rng,
pub weights: &'a crate::broker::policy::Weights,
}
#[derive(Debug, Clone, Copy)]
pub struct Selection<'a> {
pub requirements: &'a ResourceRequirements,
pub scope: Scope<'a>,
pub check_capacity: bool,
pub check_labels: bool,
pub max_price_per_hour: f64,
pub billed_to: Option<f64>,
}
pub(crate) fn is_own_worker(w: &Worker, own_ip: Option<&str>) -> bool {
if w.source_node.is_some() {
return false;
}
w.uri.contains("127.0.0.1")
|| w.uri.contains("localhost")
|| own_ip.is_some_and(|ip| w.uri.contains(ip))
|| w.explicit_local
}
fn price_key(w: &Worker, duration_secs: f64) -> (u8, i64, i64, String) {
(
u8::from(w.source_node.is_some()),
(w.pricing.estimate_cost(duration_secs) * 1e9) as i64,
(w.pricing.price_per_hour * 1e9) as i64,
w.id.clone(),
)
}
fn availability_score(w: &Worker) -> f64 {
let mem_frac = match w.resources.memory_total > 0 {
true => w.resources.memory_available as f64 / w.resources.memory_total as f64,
false => 0.0,
};
w.resources.cpus_available * mem_frac - w.active_requests as f64
}
fn capacity_weight(w: &Worker) -> f64 {
availability_score(w).max(0.0) + 0.01
}
fn python_minor(v: &str) -> &str {
match v.match_indices('.').nth(1) {
Some((i, _)) => &v[..i],
None => v,
}
}
pub(crate) fn runs_payload(w: &Worker, python: Option<&str>) -> bool {
match python {
None => true,
Some(want) => w
.hardware
.python_version
.as_deref()
.is_some_and(|have| python_minor(have) == python_minor(want)),
}
}
pub fn tags_unsatisfied(workers: &[Worker], tags: &[String]) -> Option<RoutingError> {
if tags.is_empty()
|| workers
.iter()
.any(|w| tags.iter().all(|t| w.tags.contains(t)))
{
return None;
}
let missing: Vec<&str> = tags
.iter()
.filter(|t| !workers.iter().any(|w| w.tags.contains(t)))
.map(String::as_str)
.collect();
Some(RoutingError::tags_unavailable(tags, &missing))
}
pub(crate) fn meets_vram(w: &Worker, min_vram_gb: Option<u32>) -> bool {
match min_vram_gb {
None => true,
Some(min) => w.hardware.gpu_vram_gb.is_some_and(|v| v >= min),
}
}
fn ineligibility_reason(w: &Worker, req: &ResourceRequirements) -> Option<String> {
if let Some(wt) = req.worker_type.as_deref() {
if w.worker_type != wt {
return Some(format!(
"worker_type '{}' != required '{}'",
w.worker_type, wt
));
}
}
if !req.tags.is_empty() {
let missing: Vec<&str> = req
.tags
.iter()
.filter(|t| !w.tags.contains(t))
.map(String::as_str)
.collect();
if !missing.is_empty() {
return Some(format!("missing required tags: {}", missing.join(", ")));
}
}
if !w.can_handle(req.cpus, req.memory_bytes, req.gpus) {
return Some(format!(
"insufficient capacity: needs {:.2} cpus / {} bytes mem / {} gpus; has {:.2} cpus / {} bytes mem / {} gpus available (or unhealthy)",
req.cpus,
req.memory_bytes,
req.gpus,
w.resources.cpus_available,
w.resources.memory_available,
w.resources.gpus_available
));
}
if req.timeout_secs > 0.0 && w.max_timeout_secs > 0.0 && w.max_timeout_secs < req.timeout_secs {
return Some(format!(
"max_timeout_secs {:.1} < requested timeout_secs {:.1}",
w.max_timeout_secs, req.timeout_secs
));
}
if !runs_payload(w, req.python.as_deref()) {
return Some(match w.hardware.python_version.as_deref() {
Some(have) => format!(
"python {have} cannot run a payload built on {}",
req.python.as_deref().unwrap_or("")
),
None => "worker reports no python version".to_string(),
});
}
if !meets_vram(w, req.min_vram_gb) {
return Some(match (req.min_vram_gb, w.hardware.gpu_vram_gb) {
(Some(min), Some(have)) => format!("gpu_vram_gb {have} < min_vram_gb {min}"),
(Some(min), None) => format!("no advertised gpu_vram_gb < min_vram_gb {min}"),
(None, _) => unreachable!("meets_vram only fails when min_vram_gb is Some"),
});
}
None
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RouteCandidate {
pub worker: Worker,
pub estimated_cost: f64,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ExcludedWorker {
pub worker_id: String,
pub reason: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RouteDryRun {
pub strategy: RoutingStrategy,
pub chosen: Option<RouteCandidate>,
pub candidates: Vec<RouteCandidate>,
pub excluded: Vec<ExcludedWorker>,
}
impl Router {
pub fn new() -> Self {
Self {
round_robin_counter: AtomicUsize::new(0),
node_fp: None,
}
}
pub fn with_node(mut self, fp: impl AsRef<str>) -> Self {
self.node_fp = Some(super::node_identity::strip_node_arg(fp.as_ref()).to_string());
self
}
pub fn available_strategies() -> Vec<RoutingStrategy> {
vec![
RoutingStrategy::BestPrice,
RoutingStrategy::BestLatency,
RoutingStrategy::BestAvailability,
RoutingStrategy::RoundRobin,
RoutingStrategy::Random,
RoutingStrategy::WeightedCapacity,
]
}
fn pin_local(
&self,
_registry: &WorkerRegistry,
requirements: &ResourceRequirements,
) -> Option<Result<RoutingDecision, RoutingError>> {
let tn = requirements.target_node.as_deref()?;
match &self.node_fp {
Some(ours) if super::node_identity::fp_matches_node_arg(ours, tn) => None,
_ => Some(Err(RoutingError::no_workers())),
}
}
pub fn select(
&self,
registry: &WorkerRegistry,
sel: Selection<'_>,
mut adaptive: Option<Adaptive<'_>>,
) -> Result<RoutingDecision, RoutingError> {
let req = sel.requirements;
if let Some(pinned) = self.pin_local(registry, req) {
return pinned;
}
let mut candidates = registry.healthy();
if let Scope::Local { own_ip } = sel.scope {
candidates.retain(|w| is_own_worker(w, own_ip));
}
if let Scope::Mesh { own_ip } = sel.scope {
candidates.retain(|w| !is_own_worker(w, own_ip));
}
if candidates.is_empty() {
return Err(RoutingError::no_workers());
}
if sel.check_labels {
if let Some(wt) = req.worker_type.as_deref() {
candidates.retain(|w| w.worker_type == wt);
if candidates.is_empty() {
return Err(RoutingError::worker_type_unavailable(wt));
}
}
}
if !req.tags.is_empty() {
let before = candidates.clone();
candidates.retain(|w| req.tags.iter().all(|t| w.tags.contains(t)));
if candidates.is_empty() {
return Err(
tags_unsatisfied(&before, &req.tags).unwrap_or_else(RoutingError::no_workers)
);
}
}
if req.python.is_some() {
candidates.retain(|w| runs_payload(w, req.python.as_deref()));
if candidates.is_empty() {
return Err(RoutingError::no_workers());
}
}
if sel.max_price_per_hour.is_finite() {
candidates.retain(|w| w.pricing.price_per_hour <= sel.max_price_per_hour);
if candidates.is_empty() {
return Err(RoutingError::no_workers());
}
}
if sel.check_capacity {
candidates.retain(|w| w.can_handle(req.cpus, req.memory_bytes, req.gpus));
if candidates.is_empty() {
return Err(RoutingError::no_capacity(req));
}
if req.min_vram_gb.is_some() {
candidates.retain(|w| meets_vram(w, req.min_vram_gb));
if candidates.is_empty() {
return Err(RoutingError::no_capacity(req));
}
}
if req.timeout_secs > 0.0 {
candidates.retain(|w| {
w.max_timeout_secs <= 0.0 || w.max_timeout_secs >= req.timeout_secs
});
if candidates.is_empty() {
return Err(RoutingError::timeout_incompatible(req.timeout_secs));
}
}
}
let alternatives_count = candidates.len() - 1;
let mut first_choice_was_full = false;
loop {
if candidates.is_empty() {
return Err(RoutingError::quota_exceeded());
}
let (idx, mut reason) = match adaptive.as_mut() {
Some(a) => self.choose_adaptive(&candidates, a)?,
None => self.choose_by_strategy(&candidates, req),
};
if first_choice_was_full {
reason.push_str(" (first choice was full)");
}
let estimated_cost = candidates[idx]
.pricing
.estimate_cost(req.estimated_duration_secs);
if let Some(balance) = sel.billed_to {
if balance < estimated_cost {
return Err(RoutingError::insufficient_credits(estimated_cost, balance));
}
}
if registry.try_reserve_quota(&candidates[idx].id) {
return Ok(RoutingDecision {
estimated_cost: match sel.billed_to {
Some(_) => estimated_cost,
None => 0.0,
},
worker: candidates.swap_remove(idx),
reason,
alternatives_count,
});
}
candidates.swap_remove(idx);
first_choice_was_full = true;
}
}
pub fn route_dry_run(
&self,
registry: &WorkerRegistry,
requirements: &ResourceRequirements,
) -> Result<RouteDryRun, RoutingError> {
if let Some(Err(e)) = self.pin_local(registry, requirements) {
return Err(e);
}
let healthy = registry.healthy();
if healthy.is_empty() {
return Err(RoutingError::no_workers());
}
let mut eligible: Vec<Worker> = Vec::new();
let mut excluded: Vec<ExcludedWorker> = Vec::new();
for w in healthy {
match ineligibility_reason(&w, requirements) {
None => eligible.push(w),
Some(reason) => excluded.push(ExcludedWorker {
worker_id: w.id.clone(),
reason,
}),
}
}
eligible.sort_by(|a, b| match requirements.strategy {
RoutingStrategy::WeightedCapacity => capacity_weight(b)
.partial_cmp(&capacity_weight(a))
.unwrap_or(std::cmp::Ordering::Equal)
.then_with(|| a.id.cmp(&b.id)),
RoutingStrategy::RoundRobin | RoutingStrategy::Random => a.id.cmp(&b.id),
_ => {
let ka = self.strategy_key(a, requirements).unwrap_or(i64::MAX);
let kb = self.strategy_key(b, requirements).unwrap_or(i64::MAX);
ka.cmp(&kb).then_with(|| a.id.cmp(&b.id))
}
});
let candidates: Vec<RouteCandidate> = eligible
.iter()
.map(|w| RouteCandidate {
estimated_cost: w
.pricing
.estimate_cost(requirements.estimated_duration_secs),
worker: w.clone(),
})
.collect();
let chosen = candidates.first().cloned();
Ok(RouteDryRun {
strategy: requirements.strategy,
chosen,
candidates,
excluded,
})
}
fn choose_by_strategy(
&self,
workers: &[Worker],
requirements: &ResourceRequirements,
) -> (usize, String) {
let (idx, reason) = self.select_by_strategy(workers, requirements);
let n = workers.len();
let Some(winning_key) = self.strategy_key(&workers[idx], requirements) else {
return (idx, reason); };
let tied = workers
.iter()
.all(|w| self.strategy_key(w, requirements) == Some(winning_key));
if tied && n > 1 {
let slot = self.round_robin_counter.fetch_add(1, Ordering::Relaxed) % n;
return (slot, format!("{reason} (tied; spread to slot {slot})"));
}
(idx, reason)
}
fn choose_adaptive(
&self,
workers: &[Worker],
adaptive: &mut Adaptive<'_>,
) -> Result<(usize, String), RoutingError> {
use crate::broker::policy::{self, Candidate};
use crate::broker::sampler::AliasTable;
let candidates: Vec<Candidate> = workers
.iter()
.map(|w| Candidate {
stats: w.stats,
in_flight: w.active_requests,
price_per_hour: w.pricing.price_per_hour,
local: w.source_node.is_none(),
})
.collect();
let candidates = policy::with_fleet_prior(&candidates, adaptive.weights);
let table_weights: Vec<f64> = candidates
.iter()
.map(|c| policy::table_weight(c, adaptive.weights))
.collect();
let Some(table) = AliasTable::build(&table_weights) else {
return Err(RoutingError::no_workers());
};
let Some(idx) = policy::choose(
&candidates,
&table,
adaptive.rng,
adaptive.weights.candidates_per_choice,
adaptive.weights,
) else {
return Err(RoutingError::no_workers());
};
let est = candidates[idx]
.stats
.expected_service_ms()
.unwrap_or(adaptive.weights.unmeasured_ms);
Ok((idx, format!("Adaptive: expected {est:.0}ms")))
}
pub fn select_worker_no_checks(
&self,
registry: &WorkerRegistry,
requirements: &ResourceRequirements,
adaptive: Option<Adaptive<'_>>,
) -> Result<RoutingDecision, RoutingError> {
self.select_worker_no_checks_in(registry, Scope::Any, requirements, adaptive)
}
pub fn select_worker_no_checks_in(
&self,
registry: &WorkerRegistry,
scope: Scope<'_>,
requirements: &ResourceRequirements,
adaptive: Option<Adaptive<'_>>,
) -> Result<RoutingDecision, RoutingError> {
self.select(
registry,
Selection {
requirements,
scope,
check_capacity: false,
check_labels: false,
max_price_per_hour: f64::INFINITY,
billed_to: None,
},
adaptive,
)
}
fn strategy_key(&self, w: &Worker, requirements: &ResourceRequirements) -> Option<i64> {
let v = match requirements.strategy {
RoutingStrategy::BestPrice => {
let (remote, estimate, rate, _) =
price_key(w, requirements.estimated_duration_secs);
return Some(
i64::from(remote)
.wrapping_mul(1 << 62)
.wrapping_add(estimate.wrapping_mul(1 << 20))
.wrapping_add(rate),
);
}
RoutingStrategy::BestLatency => match w.total_requests > 0 {
true => expected_completion_ms(w),
false => f64::INFINITY,
},
RoutingStrategy::BestAvailability => -availability_score(w),
RoutingStrategy::RoundRobin
| RoutingStrategy::Random
| RoutingStrategy::WeightedCapacity => return None,
};
Some((v * 1e6) as i64)
}
pub fn select_local_worker(
&self,
registry: &WorkerRegistry,
own_ip: Option<&str>,
requirements: &ResourceRequirements,
adaptive: Option<Adaptive<'_>>,
) -> Result<RoutingDecision, RoutingError> {
self.select(
registry,
Selection {
requirements,
scope: Scope::Local { own_ip },
check_capacity: false,
check_labels: false,
max_price_per_hour: f64::INFINITY,
billed_to: None,
},
adaptive,
)
}
pub fn select_worker(
&self,
registry: &WorkerRegistry,
credits: &CreditManager,
user_id: &str,
balance: f64,
requirements: &ResourceRequirements,
adaptive: Option<Adaptive<'_>>,
) -> Result<RoutingDecision, RoutingError> {
self.select_worker_in(
registry,
Scope::Any,
credits,
user_id,
balance,
requirements,
adaptive,
)
}
#[allow(clippy::too_many_arguments)]
pub fn select_worker_in(
&self,
registry: &WorkerRegistry,
scope: Scope<'_>,
credits: &CreditManager,
user_id: &str,
balance: f64,
requirements: &ResourceRequirements,
adaptive: Option<Adaptive<'_>>,
) -> Result<RoutingDecision, RoutingError> {
if !credits.check_rate_limit(user_id) {
return Err(RoutingError::rate_limited());
}
self.select(
registry,
Selection {
requirements,
scope,
check_capacity: true,
check_labels: true,
max_price_per_hour: f64::INFINITY,
billed_to: Some(balance),
},
adaptive,
)
}
fn select_by_strategy(
&self,
workers: &[Worker],
requirements: &ResourceRequirements,
) -> (usize, String) {
match requirements.strategy {
RoutingStrategy::BestPrice => {
let (idx, key) = workers
.iter()
.enumerate()
.map(|(i, w)| (i, price_key(w, requirements.estimated_duration_secs)))
.min_by(|a, b| a.1.cmp(&b.1))
.expect("select_by_strategy is only called with a non-empty worker list");
let (remote, estimate, _, _) = key;
(
idx,
match remote {
0 => "Best price: this node".to_string(),
_ => format!("Best price: {:.6} credits", estimate as f64 / 1e9),
},
)
}
RoutingStrategy::BestLatency => {
let (idx, latency) = workers
.iter()
.enumerate()
.map(|(i, w)| {
let measured = w.total_requests > 0;
(i, measured, expected_completion_ms(w))
})
.min_by(|a, b| {
b.1.cmp(&a.1).then_with(|| {
a.2.partial_cmp(&b.2).unwrap_or(std::cmp::Ordering::Equal)
})
})
.map(|(i, measured, latency)| (i, measured.then_some(latency)))
.expect("select_by_strategy is only called with a non-empty worker list");
(
idx,
match latency {
Some(ms) => format!("Best latency: {:.1}ms", ms),
None => "Best latency: no measurement yet".to_string(),
},
)
}
RoutingStrategy::BestAvailability => {
let (idx, score) = workers
.iter()
.enumerate()
.map(|(i, w)| (i, availability_score(w)))
.min_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal))
.expect("select_by_strategy is only called with a non-empty worker list");
(
idx,
format!("Best availability: {:.0}% idle", score * 100.0),
)
}
RoutingStrategy::RoundRobin => {
let mut order: Vec<usize> = (0..workers.len()).collect();
order.sort_by(|&a, &b| workers[a].id.cmp(&workers[b].id));
let slot = self.round_robin_counter.fetch_add(1, Ordering::Relaxed) % order.len();
let idx = order[slot];
(idx, format!("Round-robin: slot {slot} of {}", order.len()))
}
RoutingStrategy::Random => {
use std::time::{SystemTime, UNIX_EPOCH};
let seed = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap_or_default()
.subsec_nanos() as usize;
let idx = seed % workers.len();
(idx, format!("Random: index {}", idx))
}
RoutingStrategy::WeightedCapacity => {
use std::time::{SystemTime, UNIX_EPOCH};
let weights: Vec<f64> = workers.iter().map(capacity_weight).collect();
let total_weight: f64 = weights.iter().sum();
let seed = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap_or_default()
.subsec_nanos() as f64;
let target = (seed / 1_000_000_000.0) * total_weight;
let mut cumulative = 0.0;
for (i, weight) in weights.iter().enumerate() {
cumulative += weight;
if cumulative >= target {
return (i, format!("Weighted capacity: weight {:.2}", weight));
}
}
(0, "Weighted capacity: fallback".to_string())
}
}
}
pub fn estimate_cost(
&self,
registry: &WorkerRegistry,
requirements: &ResourceRequirements,
) -> Option<(f64, f64)> {
let workers = registry.healthy();
if workers.is_empty() {
return None;
}
let capable: Vec<&Worker> = workers
.iter()
.filter(|w| {
w.can_handle(
requirements.cpus,
requirements.memory_bytes,
requirements.gpus,
) && meets_vram(w, requirements.min_vram_gb)
&& runs_payload(w, requirements.python.as_deref())
})
.collect();
if capable.is_empty() {
return None;
}
let costs: Vec<f64> = capable
.iter()
.map(|w| {
w.pricing
.estimate_cost(requirements.estimated_duration_secs)
})
.collect();
let min_cost = costs.iter().cloned().fold(f64::INFINITY, f64::min);
let max_cost = costs.iter().cloned().fold(0.0, f64::max);
Some((min_cost, max_cost))
}
pub fn list_matching(
&self,
registry: &WorkerRegistry,
requirements: &ResourceRequirements,
) -> Vec<(Worker, f64)> {
let workers = registry.healthy();
let mut matching: Vec<(Worker, f64)> = workers
.iter()
.filter(|w| {
if let Some(ref wt) = requirements.worker_type {
if &w.worker_type != wt {
return false;
}
}
w.can_handle(
requirements.cpus,
requirements.memory_bytes,
requirements.gpus,
) && meets_vram(w, requirements.min_vram_gb)
&& runs_payload(w, requirements.python.as_deref())
})
.map(|w| {
let cost = w
.pricing
.estimate_cost(requirements.estimated_duration_secs);
(w.clone(), cost)
})
.collect();
matching.sort_by(|a, b| a.1.partial_cmp(&b.1).unwrap_or(std::cmp::Ordering::Equal));
matching
}
}
impl Default for Router {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::broker::credits::CreditManager;
use crate::broker::worker::{
HardwareInfo, WorkerPricing, WorkerRegistration, WorkerRegistry, WorkerResources,
};
pub(super) fn make_reg(
name: &str,
port: usize,
cpus: f64,
memory_gib: u64,
gpus: u32,
price_per_hour: f64,
) -> WorkerRegistration {
WorkerRegistration {
name: name.to_string(),
uri: format!("http://127.0.0.1:{}", 3960 + port),
worker_type: "zakuro".to_string(),
resources: WorkerResources {
cpus_total: cpus,
cpus_available: cpus,
memory_total: memory_gib * 1024 * 1024 * 1024,
memory_available: memory_gib * 1024 * 1024 * 1024,
gpus_total: gpus,
gpus_available: gpus,
},
pricing: WorkerPricing {
price_per_hour,
min_charge: 0.001,
},
tags: vec![],
max_timeout_secs: 0.0,
hardware: HardwareInfo::default(),
wireguard_ip: None,
is_docker: None,
source_node: None,
explicit_local: false,
provider_type: Default::default(),
served_models: vec![],
price_per_mtok: 0.0,
}
}
#[test]
fn a_peer_synced_worker_is_not_ours_however_its_uri_is_spelt() {
fn peer_worker(uri: &str) -> Worker {
let mut w = Worker::new(
"id".into(),
"peer-worker".into(),
uri.into(),
"zakuro".into(),
);
w.source_node = Some("node-6188100f5daf463e".into());
w
}
assert!(
!is_own_worker(&peer_worker("http://127.0.0.1:3960"), Some("10.13.13.35")),
"a peer worker on loopback is still a peer's"
);
assert!(
!is_own_worker(&peer_worker("http://localhost:3960"), Some("10.13.13.35")),
"a peer worker on localhost is still a peer's"
);
assert!(
!is_own_worker(&peer_worker("http://10.13.13.35:3960"), Some("10.13.13.3")),
"a substring address match does not make a peer's worker ours"
);
let mut explicit = peer_worker("http://10.13.13.20:3960");
explicit.explicit_local = true;
assert!(!is_own_worker(&explicit, None));
let mut mine = Worker::new(
"id".into(),
"w0".into(),
"http://127.0.0.1:3960".into(),
"zakuro".into(),
);
mine.source_node = None;
assert!(is_own_worker(&mine, None), "our loopback worker is ours");
let mut mine_ip = Worker::new(
"id".into(),
"w1".into(),
"http://10.13.13.35:3960".into(),
"zakuro".into(),
);
mine_ip.source_node = None;
assert!(
is_own_worker(&mine_ip, Some("10.13.13.35")),
"our worker on our own address is ours"
);
}
fn credits_for(user: &str, balance: f64) -> CreditManager {
let mgr = CreditManager::new();
mgr.get_or_create(user, balance);
mgr
}
pub(super) fn req_default() -> ResourceRequirements {
ResourceRequirements::default()
}
#[test]
fn local_selection_follows_ownership_not_uri_spelling() {
let router = Router::new();
let registry = WorkerRegistry::new();
let mut reg = make_reg("worker-sidecar", 0, 4.0, 4, 0, 0.001);
reg.uri = "zc://worker-7fed13b4a701206f-3960".to_string();
reg.source_node = None; reg.explicit_local = true; registry.register(reg);
let decision = router
.select_local_worker(®istry, None, &req_default(), None)
.expect("an owned worker must be selectable as local");
assert_eq!(decision.worker.name, "worker-sidecar");
assert_eq!(decision.estimated_cost, 0.0);
}
#[test]
fn peer_synced_workers_are_never_selected_as_local() {
let router = Router::new();
let registry = WorkerRegistry::new();
let mut reg = make_reg("worker-remote", 1, 4.0, 4, 0, 0.001);
reg.uri = "zc://worker-remote-3960".to_string();
reg.explicit_local = true; reg.source_node = Some("node-i9".to_string());
registry.register(reg);
assert!(router
.select_local_worker(®istry, None, &req_default(), None)
.is_err());
}
#[test]
fn test_no_healthy_workers_returns_no_workers() {
let router = Router::new();
let registry = WorkerRegistry::new();
let credits = credits_for("alice", 1000.0);
let err = router
.select_worker(®istry, &credits, "alice", 1000.0, &req_default(), None)
.unwrap_err();
assert_eq!(err.code, "NO_WORKERS");
}
#[test]
fn test_client_target_worker_is_noop_for_routing() {
let router = Router::new();
let registry = WorkerRegistry::new();
registry.register(make_reg("worker-a", 0, 4.0, 4, 0, 0.001));
let req = ResourceRequirements {
target_worker: Some("zc://worker-ghost".to_string()),
..req_default()
};
let decision = router
.select_worker_no_checks(®istry, &req, None)
.unwrap();
assert_eq!(decision.worker.name, "worker-a");
}
#[test]
fn test_pin_target_node_other_node_rejected() {
let router = Router::new();
let registry = WorkerRegistry::new();
registry.register(make_reg("worker-a", 0, 4.0, 4, 0, 0.001));
let req = ResourceRequirements {
target_node: Some("zc://node-somewhere-else".to_string()),
..req_default()
};
let err = router
.select_worker_no_checks(®istry, &req, None)
.unwrap_err();
assert_eq!(err.code, "NO_WORKERS");
}
#[test]
fn test_pin_target_node_self_runs_here() {
let router = Router::new().with_node("fd29ea8fe9ffa2e0");
let registry = WorkerRegistry::new();
registry.register(make_reg("worker-a", 0, 4.0, 4, 0, 0.001));
for spelling in [
"zc://node-fd29ea8fe9ffa2e0",
"node-fd29ea8fe9ffa2e0",
"fd29ea8fe9ffa2e0",
] {
let req = ResourceRequirements {
target_node: Some(spelling.to_string()),
..req_default()
};
let decision = router
.select_worker_no_checks(®istry, &req, None)
.unwrap_or_else(|e| panic!("pin {spelling} rejected: {}", e.code));
assert_eq!(decision.worker.name, "worker-a", "pin {spelling}");
}
}
#[test]
fn test_pin_target_node_hostname_label_never_matches() {
let router = Router::new().with_node("fd29ea8fe9ffa2e0");
let registry = WorkerRegistry::new();
registry.register(make_reg("worker-a", 0, 4.0, 4, 0, 0.001));
let req = ResourceRequirements {
target_node: Some("zc-worker-x399-2".to_string()),
..req_default()
};
let err = router
.select_worker_no_checks(®istry, &req, None)
.unwrap_err();
assert_eq!(err.code, "NO_WORKERS");
}
#[test]
fn test_pin_target_node_without_identity_is_rejected() {
let router = Router::new();
let registry = WorkerRegistry::new();
registry.register(make_reg("worker-a", 0, 4.0, 4, 0, 0.001));
let req = ResourceRequirements {
target_node: Some("zc://node-fd29ea8fe9ffa2e0".to_string()),
..req_default()
};
let err = router
.select_worker_no_checks(®istry, &req, None)
.unwrap_err();
assert_eq!(err.code, "NO_WORKERS");
}
#[test]
fn test_no_pin_selects_normally_with_identity_set() {
let router = Router::new().with_node("fd29ea8fe9ffa2e0");
let registry = WorkerRegistry::new();
registry.register(make_reg("worker-a", 0, 4.0, 4, 0, 0.001));
let decision = router
.select_worker_no_checks(®istry, &req_default(), None)
.unwrap();
assert_eq!(decision.worker.name, "worker-a");
}
#[test]
fn test_no_capacity_returns_no_capacity() {
let router = Router::new();
let registry = WorkerRegistry::new();
registry.register(make_reg("small", 0, 1.0, 1, 0, 0.001));
let credits = credits_for("alice", 1000.0);
let req = ResourceRequirements {
cpus: 16.0,
..req_default()
};
let err = router
.select_worker(®istry, &credits, "alice", 1000.0, &req, None)
.unwrap_err();
assert_eq!(err.code, "NO_CAPACITY");
}
#[test]
fn test_insufficient_credits_returns_error() {
let router = Router::new();
let registry = WorkerRegistry::new();
registry.register(make_reg("expensive", 0, 4.0, 4, 0, 1.0));
let credits = credits_for("alice", 0.001);
let req = ResourceRequirements {
cpus: 1.0,
estimated_duration_secs: 3600.0, ..req_default()
};
let err = router
.select_worker(®istry, &credits, "alice", 0.001, &req, None)
.unwrap_err();
assert_eq!(err.code, "INSUFFICIENT_CREDITS");
}
#[test]
fn test_rate_limited_returns_error() {
let router = Router::new();
let registry = WorkerRegistry::new();
registry.register(make_reg("w", 0, 4.0, 4, 0, 0.001));
let mgr = CreditManager::new();
mgr.get_or_create("alice", 1000.0);
mgr.set_rate_limits("alice", Some(0), None, None);
let err = router
.select_worker(®istry, &mgr, "alice", 1000.0, &req_default(), None)
.unwrap_err();
assert_eq!(err.code, "RATE_LIMITED");
}
#[test]
fn test_worker_type_mismatch_returns_error() {
let router = Router::new();
let registry = WorkerRegistry::new();
let mut reg = make_reg("ray-w", 0, 4.0, 4, 0, 0.001);
reg.worker_type = "ray".to_string();
registry.register(reg);
let credits = credits_for("alice", 1000.0);
let req = ResourceRequirements {
worker_type: Some("spark".to_string()),
..req_default()
};
let err = router
.select_worker(®istry, &credits, "alice", 1000.0, &req, None)
.unwrap_err();
assert_eq!(err.code, "WORKER_TYPE_UNAVAILABLE");
}
#[test]
fn test_timeout_incompatible_returns_error() {
let router = Router::new();
let registry = WorkerRegistry::new();
let mut reg = make_reg("limited", 0, 4.0, 4, 0, 0.001);
reg.max_timeout_secs = 30.0; registry.register(reg);
let credits = credits_for("alice", 1000.0);
let req = ResourceRequirements {
timeout_secs: 60.0,
..req_default()
};
let err = router
.select_worker(®istry, &credits, "alice", 1000.0, &req, None)
.unwrap_err();
assert_eq!(err.code, "TIMEOUT_INCOMPATIBLE");
}
#[test]
fn test_timeout_unlimited_worker_accepts_any_timeout() {
let router = Router::new();
let registry = WorkerRegistry::new();
let mut reg = make_reg("unlimited", 0, 4.0, 4, 0, 0.001);
reg.max_timeout_secs = 0.0; registry.register(reg);
let credits = credits_for("alice", 1000.0);
let req = ResourceRequirements {
timeout_secs: 3600.0,
..req_default()
};
assert!(router
.select_worker(®istry, &credits, "alice", 1000.0, &req, None)
.is_ok());
}
#[test]
fn test_tag_filter_requires_all_tags() {
let router = Router::new();
let registry = WorkerRegistry::new();
let mut reg = make_reg("gpu-w", 0, 8.0, 32, 2, 0.001);
reg.tags = vec!["gpu".to_string(), "a100".to_string()];
registry.register(reg);
let credits = credits_for("alice", 1000.0);
let req_match = ResourceRequirements {
tags: vec!["gpu".to_string(), "a100".to_string()],
..req_default()
};
assert!(router
.select_worker(®istry, &credits, "alice", 1000.0, &req_match, None)
.is_ok());
let req_no_match = ResourceRequirements {
tags: vec!["gpu".to_string(), "h100".to_string()],
..req_default()
};
assert!(router
.select_worker(®istry, &credits, "alice", 1000.0, &req_no_match, None)
.is_err());
}
#[test]
fn missing_required_tag_is_a_clear_error_naming_it() {
let router = Router::new();
let registry = WorkerRegistry::new();
registry.register(make_reg("linux-gpu", 0, 8.0, 32, 2, 0.001));
let credits = credits_for("alice", 1000.0);
let req = ResourceRequirements {
tags: vec!["apple-silicon".to_string()],
..req_default()
};
let err = router
.select_worker(®istry, &credits, "alice", 1000.0, &req, None)
.unwrap_err();
assert_eq!(err.code, "NO_WORKERS_WITH_TAGS");
assert!(err.message.contains("apple-silicon"), "{}", err.message);
assert!(router
.select_worker(®istry, &credits, "alice", 1000.0, &req_default(), None)
.is_ok());
}
#[test]
fn tags_unsatisfied_names_only_tags_no_worker_has() {
let mut w = Worker::new("1".into(), "w".into(), "http://x:1".into(), "zakuro".into());
w.tags = vec!["gpu".into()];
let want = vec!["gpu".to_string(), "apple-silicon".to_string()];
let e = tags_unsatisfied(&[w.clone()], &want).unwrap();
assert!(e.message.contains("no worker advertises: apple-silicon"));
assert!(tags_unsatisfied(&[w], &["gpu".to_string()]).is_none());
assert!(tags_unsatisfied(&[], &[]).is_none());
}
#[test]
fn test_best_price_selects_cheapest_worker() {
let router = Router::new();
let registry = WorkerRegistry::new();
registry.register(make_reg("cheap", 0, 4.0, 4, 0, 0.001));
registry.register(make_reg("pricey", 1, 4.0, 4, 0, 1.0));
let credits = credits_for("alice", 10000.0);
let req = ResourceRequirements {
strategy: RoutingStrategy::BestPrice,
estimated_duration_secs: 3600.0,
..req_default()
};
let decision = router
.select_worker(®istry, &credits, "alice", 10000.0, &req, None)
.unwrap();
assert_eq!(decision.worker.name, "cheap");
}
#[test]
fn best_price_selects_cheapest_with_many_candidates() {
let router = Router::new();
let registry = WorkerRegistry::new();
registry.register(make_reg("w-a", 0, 4.0, 4, 0, 5.0));
registry.register(make_reg("w-b", 1, 4.0, 4, 0, 2.0)); registry.register(make_reg("w-c", 2, 4.0, 4, 0, 9.0));
let credits = credits_for("alice", 10000.0);
let req = ResourceRequirements {
strategy: RoutingStrategy::BestPrice,
estimated_duration_secs: 3600.0,
..req_default()
};
let decision = router
.select_worker(®istry, &credits, "alice", 10000.0, &req, None)
.unwrap();
assert_eq!(decision.worker.name, "w-b", "must pick the cheapest worker");
}
#[test]
fn test_best_latency_selects_fastest_worker() {
let router = Router::new();
let registry = WorkerRegistry::new();
let w_fast = registry.register(make_reg("fast", 0, 4.0, 4, 0, 0.001));
let w_slow = registry.register(make_reg("slow", 1, 4.0, 4, 0, 0.001));
registry.record_request(&w_fast.id, 5.0, true);
registry.record_request(&w_slow.id, 500.0, true);
let credits = credits_for("alice", 1000.0);
let req = ResourceRequirements {
strategy: RoutingStrategy::BestLatency,
..req_default()
};
let decision = router
.select_worker(®istry, &credits, "alice", 1000.0, &req, None)
.unwrap();
assert_eq!(decision.worker.name, "fast");
}
#[test]
fn best_latency_does_not_mistake_never_measured_for_instant() {
let router = Router::new();
let registry = WorkerRegistry::new();
let measured = registry.register(make_reg("measured", 0, 4.0, 4, 0, 0.001));
registry.register(make_reg("never-answered", 1, 4.0, 4, 0, 0.001));
registry.record_request(&measured.id, 50.0, true);
let credits = credits_for("alice", 1000.0);
let req = ResourceRequirements {
strategy: RoutingStrategy::BestLatency,
..req_default()
};
let decision = router
.select_worker(®istry, &credits, "alice", 1000.0, &req, None)
.unwrap();
assert_eq!(
decision.worker.name, "measured",
"a measured 5 ms beats an unknown"
);
}
#[test]
fn best_latency_still_routes_when_nothing_has_been_measured() {
let router = Router::new();
let registry = WorkerRegistry::new();
registry.register(make_reg("a", 0, 4.0, 4, 0, 0.001));
registry.register(make_reg("b", 1, 4.0, 4, 0, 0.001));
let credits = credits_for("alice", 1000.0);
let req = ResourceRequirements {
strategy: RoutingStrategy::BestLatency,
..req_default()
};
let decision = router
.select_worker(®istry, &credits, "alice", 1000.0, &req, None)
.unwrap();
assert!(
["a", "b"].contains(&decision.worker.name.as_str()),
"picked {}",
decision.worker.name
);
}
#[test]
fn the_unchecked_path_honours_the_strategy_it_was_given() {
let router = Router::new();
let registry = WorkerRegistry::new();
let fast = registry.register(make_reg("fast", 0, 4.0, 4, 0, 0.001));
let slow = registry.register(make_reg("slow", 1, 4.0, 4, 0, 0.001));
registry.record_request(&fast.id, 5.0, true);
registry.record_request(&slow.id, 900.0, true);
let req = ResourceRequirements {
strategy: RoutingStrategy::BestLatency,
..req_default()
};
for _ in 0..8 {
let d = router
.select_worker_no_checks(®istry, &req, None)
.unwrap();
assert_eq!(d.worker.name, "fast", "reason was: {}", d.reason);
}
}
#[test]
fn workers_a_strategy_cannot_separate_still_share_the_load() {
let router = Router::new();
let registry = WorkerRegistry::new();
for i in 0..4 {
registry.register(make_reg(&format!("w{i}"), i, 4.0, 4, 0, 0.0));
}
let req = ResourceRequirements {
strategy: RoutingStrategy::BestPrice,
..req_default()
};
let mut seen = std::collections::HashSet::new();
for _ in 0..16 {
seen.insert(
router
.select_worker_no_checks(®istry, &req, None)
.unwrap()
.worker
.name,
);
}
assert_eq!(seen.len(), 4, "every worker took some of it, got {seen:?}");
}
#[test]
fn best_latency_accounts_for_what_is_already_queued() {
let router = Router::new();
let registry = WorkerRegistry::new();
let busy = registry.register(make_reg("busy-fast", 0, 4.0, 4, 0, 0.001));
let idle = registry.register(make_reg("idle-slower", 1, 4.0, 4, 0, 0.001));
registry.record_request(&busy.id, 10.0, true);
registry.record_request(&idle.id, 30.0, true);
for _ in 0..4 {
registry.increment_active(&busy.id);
}
let d = router
.select_worker_no_checks(
®istry,
&ResourceRequirements {
strategy: RoutingStrategy::BestLatency,
..req_default()
},
None,
)
.unwrap();
assert_eq!(
d.worker.name, "idle-slower",
"an idle 30 ms worker beats a 10 ms one with four queued: {}",
d.reason
);
}
#[test]
fn the_decision_says_how_it_was_made() {
let router = Router::new();
let registry = WorkerRegistry::new();
let fast = registry.register(make_reg("fast", 0, 4.0, 4, 0, 0.001));
registry.register(make_reg("slow", 1, 4.0, 4, 0, 0.002));
registry.record_request(&fast.id, 5.0, true);
let latency = router
.select_worker_no_checks(
®istry,
&ResourceRequirements {
strategy: RoutingStrategy::BestLatency,
..req_default()
},
None,
)
.unwrap();
assert!(
latency.reason.to_lowercase().contains("latency"),
"{}",
latency.reason
);
}
#[test]
fn test_round_robin_cycles_through_workers() {
let router = Router::new();
let registry = WorkerRegistry::new();
registry.register(make_reg("w1", 0, 4.0, 4, 0, 0.001));
registry.register(make_reg("w2", 1, 4.0, 4, 0, 0.001));
let credits = credits_for("alice", 10000.0);
let req = ResourceRequirements {
strategy: RoutingStrategy::RoundRobin,
..req_default()
};
let d1 = router
.select_worker(®istry, &credits, "alice", 10000.0, &req, None)
.unwrap();
let d2 = router
.select_worker(®istry, &credits, "alice", 10000.0, &req, None)
.unwrap();
assert_ne!(d1.worker.id, d2.worker.id);
}
#[test]
fn test_local_mode_returns_first_worker_free() {
let router = Router::new();
let registry = WorkerRegistry::new();
registry.register(make_reg("local-w", 0, 4.0, 4, 0, 0.001));
let req = req_default();
let decision = router
.select_worker_no_checks(®istry, &req, None)
.unwrap();
assert_eq!(decision.estimated_cost, 0.0);
}
#[test]
fn test_local_mode_no_workers_returns_error() {
let router = Router::new();
let registry = WorkerRegistry::new();
let err = router
.select_worker_no_checks(®istry, &req_default(), None)
.unwrap_err();
assert_eq!(err.code, "NO_WORKERS");
}
#[test]
fn test_estimate_cost_returns_min_and_max() {
let router = Router::new();
let registry = WorkerRegistry::new();
registry.register(make_reg("cheap", 0, 4.0, 4, 0, 0.001));
registry.register(make_reg("pricey", 1, 4.0, 4, 0, 0.1));
let req = ResourceRequirements {
cpus: 1.0,
estimated_duration_secs: 3600.0,
..req_default()
};
let (min, max) = router.estimate_cost(®istry, &req).unwrap();
assert!(min < max);
assert!((min - 0.001).abs() < 0.00001);
}
#[test]
fn test_estimate_cost_no_workers_returns_none() {
let router = Router::new();
let registry = WorkerRegistry::new();
assert!(router.estimate_cost(®istry, &req_default()).is_none());
}
#[test]
fn test_worker_type_match_routes_correctly() {
let router = Router::new();
let registry = WorkerRegistry::new();
let mut reg = make_reg("ray-w", 0, 4.0, 4, 0, 0.001);
reg.worker_type = "ray".to_string();
registry.register(reg);
let credits = credits_for("alice", 1000.0);
let req = ResourceRequirements {
worker_type: Some("ray".to_string()),
..req_default()
};
let decision = router
.select_worker(®istry, &credits, "alice", 1000.0, &req, None)
.unwrap();
assert_eq!(decision.worker.worker_type, "ray");
}
#[test]
fn test_price_change_affects_routing_decision() {
let router = Router::new();
let registry = WorkerRegistry::new();
let _w1 = registry.register(make_reg("w1", 0, 4.0, 4, 0, 0.001));
let _w2 = registry.register(make_reg("w2", 1, 4.0, 4, 0, 0.01));
let credits = credits_for("alice", 10000.0);
let req = ResourceRequirements {
strategy: RoutingStrategy::BestPrice,
estimated_duration_secs: 3600.0,
..req_default()
};
let d1 = router
.select_worker(®istry, &credits, "alice", 10000.0, &req, None)
.unwrap();
assert_eq!(d1.worker.name, "w1");
let (min, _max) = router.estimate_cost(®istry, &req).unwrap();
assert!((min - 0.001).abs() < 0.00001);
}
#[test]
fn best_availability_is_not_round_robin_in_disguise() {
let router = Router::new();
let registry = WorkerRegistry::new();
registry.register(make_reg("roomy", 0, 32.0, 256, 0, 0.0));
registry.register(make_reg("cramped", 1, 1.0, 1, 0, 0.0));
let req = ResourceRequirements {
strategy: RoutingStrategy::BestAvailability,
..req_default()
};
for _ in 0..8 {
let d = router
.select_worker_no_checks(®istry, &req, None)
.unwrap();
assert_eq!(d.worker.name, "roomy", "reason was: {}", d.reason);
}
}
#[test]
fn the_local_path_honours_the_strategy_it_was_given() {
let router = Router::new();
let registry = WorkerRegistry::new();
let fast = registry.register(make_reg("fast", 0, 4.0, 4, 0, 0.001));
let slow = registry.register(make_reg("slow", 1, 4.0, 4, 0, 0.001));
registry.record_request(&fast.id, 5.0, true);
registry.record_request(&slow.id, 900.0, true);
let req = ResourceRequirements {
strategy: RoutingStrategy::BestLatency,
..req_default()
};
for _ in 0..8 {
let d = router
.select_local_worker(®istry, None, &req, None)
.unwrap();
assert_eq!(d.worker.name, "fast", "reason was: {}", d.reason);
}
}
#[test]
fn round_robin_visits_every_worker() {
let router = Router::new();
let registry = WorkerRegistry::new();
for i in 0..4 {
registry.register(make_reg(&format!("w{i}"), i, 4.0, 4, 0, 0.001));
}
let req = ResourceRequirements {
strategy: RoutingStrategy::RoundRobin,
..req_default()
};
let mut seen = std::collections::HashSet::new();
for _ in 0..8 {
seen.insert(
router
.select_worker_no_checks(®istry, &req, None)
.unwrap()
.worker
.name,
);
}
assert_eq!(seen.len(), 4, "round-robin reached {seen:?}");
}
#[test]
fn the_billed_path_spreads_what_the_strategy_cannot_separate() {
let router = Router::new();
let registry = WorkerRegistry::new();
for i in 0..4 {
registry.register(make_reg(&format!("w{i}"), i, 4.0, 4, 0, 0.5));
}
let credits = credits_for("alice", 10_000.0);
let req = ResourceRequirements {
strategy: RoutingStrategy::BestPrice,
..req_default()
};
let mut seen = std::collections::HashSet::new();
for _ in 0..16 {
seen.insert(
router
.select_worker(®istry, &credits, "alice", 10_000.0, &req, None)
.unwrap()
.worker
.name,
);
}
assert_eq!(seen.len(), 4, "every worker took some of it, got {seen:?}");
}
}
#[cfg(test)]
mod strategy_promise_tests {
use super::tests::make_reg;
use super::*;
use crate::broker::worker::WorkerRegistry;
fn worker(name: &str, port: usize, cpus: f64, gib: u64, price: f64, peer: bool) -> Worker {
let reg = WorkerRegistry::new();
let mut r = make_reg(name, port, cpus, gib, 0, price);
if peer {
r.source_node = Some("node-6188100f5daf463e".into());
}
reg.register(r)
}
fn mixed_fleet() -> Vec<Worker> {
vec![
worker("local-small", 1, 8.0, 16, 0.0, false),
worker("remote-big-a", 2, 32.0, 62, 3.6, true),
worker("remote-big-b", 3, 32.0, 62, 3.6, true),
]
}
fn req(strategy: RoutingStrategy) -> ResourceRequirements {
ResourceRequirements {
strategy,
..Default::default()
}
}
#[test]
fn best_price_picks_the_free_worker() {
let router = Router::new();
let fleet = mixed_fleet();
let (idx, _) = router.select_by_strategy(&fleet, &req(RoutingStrategy::BestPrice));
assert_eq!(
fleet[idx].name, "local-small",
"best_price must rank free work first"
);
}
#[test]
fn best_price_is_not_erased_by_the_minimum_charge() {
let router = Router::new();
let fleet = vec![
worker("dearer", 1, 8.0, 16, 3.0, true),
worker("cheaper", 2, 8.0, 16, 0.5, true),
];
let one_second = fleet[0].pricing.estimate_cost(1.0);
assert_eq!(
one_second,
fleet[1].pricing.estimate_cost(1.0),
"fixture must be one where the 1s floor hides the difference"
);
let (idx, _) = router.select_by_strategy(&fleet, &req(RoutingStrategy::BestPrice));
assert_eq!(fleet[idx].name, "cheaper");
}
#[test]
fn best_price_breaks_ties_deterministically() {
let router = Router::new();
let fleet = vec![
worker("bbb", 1, 8.0, 16, 3.6, true),
worker("aaa", 2, 8.0, 16, 3.6, true),
];
let first = router
.select_by_strategy(&fleet, &req(RoutingStrategy::BestPrice))
.0;
for _ in 0..20 {
assert_eq!(
router
.select_by_strategy(&fleet, &req(RoutingStrategy::BestPrice))
.0,
first,
"equal prices must resolve the same way every time"
);
}
}
#[test]
fn round_robin_visits_every_worker_before_repeating() {
let router = Router::new();
let fleet = mixed_fleet();
let mut seen = std::collections::HashSet::new();
for _ in 0..fleet.len() {
let (idx, _) = router.select_by_strategy(&fleet, &req(RoutingStrategy::RoundRobin));
seen.insert(fleet[idx].name.clone());
}
assert_eq!(
seen.len(),
fleet.len(),
"three consecutive picks over three workers must touch each once, got {seen:?}"
);
}
#[test]
fn an_empty_small_box_beats_a_nearly_full_big_one() {
let small_idle = worker("small-idle", 1, 8.0, 16, 0.0, false);
let mut big_busy = worker("big-busy", 2, 32.0, 62, 3.6, true);
big_busy.resources.cpus_available = 1.0;
big_busy.resources.memory_available = 2 * 1024 * 1024 * 1024;
assert!(
availability_score(&small_idle) > availability_score(&big_busy),
"an idle 8-core must beat a 32-core with one core and 2 GiB left"
);
let router = Router::new();
let fleet = vec![big_busy, small_idle];
let (idx, _) = router.select_by_strategy(&fleet, &req(RoutingStrategy::BestAvailability));
assert_eq!(fleet[idx].name, "small-idle");
}
#[test]
fn in_flight_work_can_actually_move_the_ranking() {
let idle = worker("idle", 1, 8.0, 16, 0.0, false);
let mut loaded = worker("loaded", 2, 8.0, 16, 0.0, false);
loaded.active_requests = 8;
assert!(
availability_score(&idle) > availability_score(&loaded),
"eight in-flight requests on eight cores must outweigh a tie on capacity"
);
}
#[test]
fn capacity_weight_does_not_bury_the_small_free_node() {
let fleet = mixed_fleet();
let weights: Vec<f64> = fleet.iter().map(capacity_weight).collect();
let total: f64 = weights.iter().sum();
let local_share = weights[0] / total;
assert!(
(0.09..0.14).contains(&local_share),
"an 8-core node among two 32-core nodes should carry ~11% of the \
weight, not 1.7%; got {:.1}%",
local_share * 100.0
);
}
}
#[cfg(test)]
mod adaptive_tests {
use super::tests::{make_reg, req_default};
use super::*;
use crate::broker::policy::Weights;
use crate::broker::sampler::Rng;
#[test]
fn it_prefers_the_worker_that_has_been_fastest() {
let router = Router::new();
let registry = WorkerRegistry::new();
let fast = registry.register(make_reg("fast", 0, 4.0, 4, 0, 0.001));
let slow = registry.register(make_reg("slow", 1, 4.0, 4, 0, 0.001));
for _ in 0..40 {
registry.record_request(&fast.id, 20.0, true);
registry.record_request(&slow.id, 900.0, true);
}
let mut rng = Rng::seeded(4);
let w = Weights::default();
let picks = (0..200)
.filter(|_| {
router
.select_worker_no_checks(
®istry,
&req_default(),
Some(Adaptive {
rng: &mut rng,
weights: &w,
}),
)
.map(|d| d.worker.name == "fast")
.unwrap_or(false)
})
.count();
assert!(picks > 160, "chose the fast worker {picks}/200 times");
}
#[test]
fn a_brand_new_worker_is_still_tried() {
let router = Router::new();
let registry = WorkerRegistry::new();
let known = registry.register(make_reg("known", 0, 4.0, 4, 0, 0.001));
registry.register(make_reg("brand-new", 1, 4.0, 4, 0, 0.001));
for _ in 0..40 {
registry.record_request(&known.id, 200.0, true);
}
let mut rng = Rng::seeded(9);
let w = Weights::default();
let tried = (0..200)
.filter(|_| {
router
.select_worker_no_checks(
®istry,
&req_default(),
Some(Adaptive {
rng: &mut rng,
weights: &w,
}),
)
.map(|d| d.worker.name == "brand-new")
.unwrap_or(false)
})
.count();
assert!(
(10..190).contains(&tried),
"explored but not favoured blindly: {tried}/200"
);
}
#[test]
fn it_says_adaptive_in_the_reason_and_charges_nothing() {
let router = Router::new();
let registry = WorkerRegistry::new();
let w0 = registry.register(make_reg("w0", 0, 4.0, 4, 0, 0.001));
registry.record_request(&w0.id, 15.0, true);
let mut rng = Rng::seeded(2);
let d = router
.select_worker_no_checks(
®istry,
&req_default(),
Some(Adaptive {
rng: &mut rng,
weights: &Weights::default(),
}),
)
.unwrap();
assert!(d.reason.starts_with("Adaptive:"), "{}", d.reason);
assert_eq!(d.estimated_cost, 0.0, "this path bills nothing");
}
#[test]
fn no_workers_is_an_error_not_a_panic() {
let router = Router::new();
let registry = WorkerRegistry::new();
let mut rng = Rng::seeded(1);
let err = router
.select_worker_no_checks(
®istry,
&req_default(),
Some(Adaptive {
rng: &mut rng,
weights: &Weights::default(),
}),
)
.unwrap_err();
assert_eq!(err.code, "NO_WORKERS");
}
}
#[cfg(test)]
mod route_dry_run_tests {
use super::tests::make_reg;
use super::*;
use crate::broker::credits::CreditManager;
use crate::broker::worker::{
HardwareInfo, WorkerPricing, WorkerRegistration, WorkerRegistry, WorkerResources,
};
fn credits_for(user: &str, balance: f64) -> CreditManager {
let mgr = CreditManager::new();
mgr.get_or_create(user, balance);
mgr
}
fn req(strategy: RoutingStrategy) -> ResourceRequirements {
ResourceRequirements {
strategy,
..Default::default()
}
}
#[test]
fn best_price_picks_the_cheapest_eligible_worker() {
let router = Router::new();
let registry = WorkerRegistry::new();
registry.register(make_reg("dearer", 0, 4.0, 4, 0, 5.0));
registry.register(make_reg("cheapest", 1, 4.0, 4, 0, 1.0));
registry.register(make_reg("middling", 2, 4.0, 4, 0, 3.0));
let mut r = req(RoutingStrategy::BestPrice);
r.estimated_duration_secs = 3600.0;
let result = router.route_dry_run(®istry, &r).unwrap();
assert_eq!(result.strategy, RoutingStrategy::BestPrice);
let chosen = result.chosen.expect("an eligible worker exists");
assert_eq!(chosen.worker.name, "cheapest");
assert_eq!(result.candidates[0].worker.name, "cheapest");
assert_eq!(
result
.candidates
.iter()
.map(|c| &c.worker.name)
.collect::<Vec<_>>(),
vec!["cheapest", "middling", "dearer"],
"candidates must be ranked cheapest first"
);
assert!(result.excluded.is_empty());
}
#[test]
fn best_price_breaks_ties_deterministically() {
let router = Router::new();
let registry = WorkerRegistry::new();
registry.register(make_reg("bbb", 0, 4.0, 4, 0, 3.6));
registry.register(make_reg("aaa", 1, 4.0, 4, 0, 3.6));
let r = req(RoutingStrategy::BestPrice);
let first = router.route_dry_run(®istry, &r).unwrap();
for _ in 0..10 {
let again = router.route_dry_run(®istry, &r).unwrap();
assert_eq!(
again.chosen.unwrap().worker.name,
first.chosen.as_ref().unwrap().worker.name,
"equal prices must resolve to the same worker every call"
);
}
}
#[test]
fn best_availability_picks_the_least_loaded_worker() {
let router = Router::new();
let registry = WorkerRegistry::new();
let roomy = registry.register(make_reg("roomy", 0, 32.0, 256, 0, 0.0));
let cramped = registry.register(make_reg("cramped", 1, 32.0, 256, 0, 0.0));
registry.update_resources(
&cramped.id,
WorkerResources {
cpus_total: 32.0,
cpus_available: 1.0,
memory_total: 256 * 1024 * 1024 * 1024,
memory_available: 2 * 1024 * 1024 * 1024,
gpus_total: 0,
gpus_available: 0,
},
HardwareInfo::default(),
);
for _ in 0..4 {
registry.increment_active(&roomy.id);
}
let result = router
.route_dry_run(®istry, &req(RoutingStrategy::BestAvailability))
.unwrap();
assert_eq!(
result.chosen.unwrap().worker.name,
"roomy",
"32 idle cores (minus 4 in flight) must still beat 1 idle core"
);
}
#[test]
fn min_vram_gb_excludes_small_vram_workers_with_a_reason() {
let router = Router::new();
let registry = WorkerRegistry::new();
let mut small = make_reg("small-vram", 0, 4.0, 16, 1, 1.0);
small.hardware.gpu_vram_gb = Some(8);
let mut big = make_reg("big-vram", 1, 4.0, 16, 1, 1.0);
big.hardware.gpu_vram_gb = Some(24);
let mut unknown = make_reg("no-vram-advertised", 2, 4.0, 16, 1, 1.0);
unknown.hardware.gpu_vram_gb = None;
registry.register(small);
registry.register(big);
registry.register(unknown);
let mut r = req(RoutingStrategy::BestPrice);
r.gpus = 1;
r.min_vram_gb = Some(16);
let result = router.route_dry_run(®istry, &r).unwrap();
assert_eq!(result.chosen.unwrap().worker.name, "big-vram");
assert_eq!(result.candidates.len(), 1);
assert_eq!(result.excluded.len(), 2);
let reasons: std::collections::HashMap<_, _> = result
.excluded
.iter()
.map(|e| (e.worker_id.clone(), e.reason.clone()))
.collect();
let registry_ids: std::collections::HashMap<_, _> = registry
.healthy()
.into_iter()
.map(|w| (w.name.clone(), w.id.clone()))
.collect();
assert!(
reasons[®istry_ids["small-vram"]].contains("gpu_vram_gb 8 < min_vram_gb 16"),
"{:?}",
reasons
);
assert!(
reasons[®istry_ids["no-vram-advertised"]]
.contains("no advertised gpu_vram_gb < min_vram_gb 16"),
"{:?}",
reasons
);
}
#[test]
fn nothing_eligible_reports_404_shaped_result_listing_why() {
let router = Router::new();
let registry = WorkerRegistry::new();
let mut small = make_reg("small-vram", 0, 4.0, 16, 1, 1.0);
small.hardware.gpu_vram_gb = Some(8);
registry.register(small);
let mut r = req(RoutingStrategy::BestPrice);
r.gpus = 1;
r.min_vram_gb = Some(80);
let result = router.route_dry_run(®istry, &r).unwrap();
assert!(result.chosen.is_none());
assert!(result.candidates.is_empty());
assert_eq!(result.excluded.len(), 1);
assert!(result.excluded[0].reason.contains("min_vram_gb 80"));
}
#[test]
fn route_dry_run_never_advances_the_round_robin_cursor() {
let registry = WorkerRegistry::new();
for i in 0..4 {
registry.register(make_reg(&format!("w{i}"), i, 4.0, 4, 0, 0.001));
}
let r = req(RoutingStrategy::RoundRobin);
let exercised = Router::new();
for _ in 0..25 {
exercised.route_dry_run(®istry, &r).unwrap();
}
let untouched = Router::new();
for n in 0..8 {
let a = exercised
.select_worker_no_checks(®istry, &r, None)
.unwrap();
let b = untouched
.select_worker_no_checks(®istry, &r, None)
.unwrap();
assert_eq!(
a.worker.name, b.worker.name,
"pick {n}: 25 dry runs must not have moved the real round-robin cursor"
);
}
}
#[test]
fn route_dry_run_never_touches_active_requests_or_quota() {
let router = Router::new();
let registry = WorkerRegistry::new();
let w = registry.register(make_reg("w0", 0, 4.0, 4, 0, 0.001));
let r = req(RoutingStrategy::BestPrice);
for _ in 0..10 {
router.route_dry_run(®istry, &r).unwrap();
}
let after = registry.get(&w.id).unwrap();
assert_eq!(
after.active_requests, 0,
"a dry run must never reserve/execute"
);
}
struct ParityWorker {
name: &'static str,
worker_type: &'static str,
tags: &'static [&'static str],
price_per_hour: f64,
cpus_total: f64,
memory_gib: u64,
gpus_total: u32,
gpu_vram_gb: Option<u32>,
max_timeout_secs: f64,
active_requests: u32,
latency_ms: f64,
}
fn parity_workers() -> Vec<ParityWorker> {
vec![
ParityWorker {
name: "w-std",
worker_type: "zakuro",
tags: &[],
price_per_hour: 1.0,
cpus_total: 8.0,
memory_gib: 16,
gpus_total: 1,
gpu_vram_gb: Some(24),
max_timeout_secs: 0.0,
active_requests: 0,
latency_ms: 10.0,
},
ParityWorker {
name: "w-gpu-tag",
worker_type: "zakuro",
tags: &["gpu", "a100"],
price_per_hour: 2.0,
cpus_total: 8.5,
memory_gib: 16,
gpus_total: 1,
gpu_vram_gb: Some(80),
max_timeout_secs: 0.0,
active_requests: 2,
latency_ms: 20.0,
},
ParityWorker {
name: "w-ray",
worker_type: "ray",
tags: &[],
price_per_hour: 0.5,
cpus_total: 4.0,
memory_gib: 8,
gpus_total: 0,
gpu_vram_gb: None,
max_timeout_secs: 0.0,
active_requests: 0,
latency_ms: 30.0,
},
ParityWorker {
name: "w-small-cpu",
worker_type: "zakuro",
tags: &[],
price_per_hour: 1.5,
cpus_total: 1.0,
memory_gib: 2,
gpus_total: 0,
gpu_vram_gb: None,
max_timeout_secs: 0.0,
active_requests: 0,
latency_ms: 40.0,
},
ParityWorker {
name: "w-small-vram",
worker_type: "zakuro",
tags: &["gpu"],
price_per_hour: 1.1,
cpus_total: 9.0,
memory_gib: 16,
gpus_total: 1,
gpu_vram_gb: Some(8),
max_timeout_secs: 0.0,
active_requests: 0,
latency_ms: 50.0,
},
ParityWorker {
name: "w-no-vram-data",
worker_type: "zakuro",
tags: &["gpu"],
price_per_hour: 1.2,
cpus_total: 10.0,
memory_gib: 16,
gpus_total: 1,
gpu_vram_gb: None,
max_timeout_secs: 0.0,
active_requests: 0,
latency_ms: 60.0,
},
ParityWorker {
name: "w-limited-timeout",
worker_type: "zakuro",
tags: &[],
price_per_hour: 1.3,
cpus_total: 11.0,
memory_gib: 16,
gpus_total: 0,
gpu_vram_gb: None,
max_timeout_secs: 30.0,
active_requests: 0,
latency_ms: 70.0,
},
ParityWorker {
name: "w-unlimited-timeout",
worker_type: "zakuro",
tags: &[],
price_per_hour: 3.0,
cpus_total: 12.0,
memory_gib: 16,
gpus_total: 0,
gpu_vram_gb: None,
max_timeout_secs: 0.0,
active_requests: 0,
latency_ms: 80.0,
},
ParityWorker {
name: "w-busy",
worker_type: "zakuro",
tags: &[],
price_per_hour: 2.5,
cpus_total: 16.0,
memory_gib: 32,
gpus_total: 0,
gpu_vram_gb: None,
max_timeout_secs: 0.0,
active_requests: 20,
latency_ms: 90.0,
},
ParityWorker {
name: "w-cheap-tiny",
worker_type: "zakuro",
tags: &[],
price_per_hour: 0.1,
cpus_total: 0.5,
memory_gib: 1,
gpus_total: 0,
gpu_vram_gb: None,
max_timeout_secs: 0.0,
active_requests: 0,
latency_ms: 100.0,
},
]
}
struct ParityRequirement {
label: &'static str,
cpus: f64,
memory_gib: u64,
gpus: u32,
min_vram_gb: Option<u32>,
timeout_secs: f64,
tags: &'static [&'static str],
worker_type: Option<&'static str>,
}
fn parity_requirements() -> Vec<ParityRequirement> {
vec![
ParityRequirement {
label: "default",
cpus: 1.0,
memory_gib: 1,
gpus: 0,
min_vram_gb: None,
timeout_secs: 0.0,
tags: &[],
worker_type: None,
},
ParityRequirement {
label: "needs_gpu",
cpus: 1.0,
memory_gib: 1,
gpus: 1,
min_vram_gb: None,
timeout_secs: 0.0,
tags: &[],
worker_type: None,
},
ParityRequirement {
label: "needs_gpu_min_vram_16",
cpus: 1.0,
memory_gib: 1,
gpus: 1,
min_vram_gb: Some(16),
timeout_secs: 0.0,
tags: &[],
worker_type: None,
},
ParityRequirement {
label: "needs_gpu_min_vram_80",
cpus: 1.0,
memory_gib: 1,
gpus: 1,
min_vram_gb: Some(80),
timeout_secs: 0.0,
tags: &[],
worker_type: None,
},
ParityRequirement {
label: "needs_8_cpu_16gib",
cpus: 8.0,
memory_gib: 16,
gpus: 0,
min_vram_gb: None,
timeout_secs: 0.0,
tags: &[],
worker_type: None,
},
ParityRequirement {
label: "needs_ray",
cpus: 1.0,
memory_gib: 1,
gpus: 0,
min_vram_gb: None,
timeout_secs: 0.0,
tags: &[],
worker_type: Some("ray"),
},
ParityRequirement {
label: "needs_tag_gpu",
cpus: 1.0,
memory_gib: 1,
gpus: 0,
min_vram_gb: None,
timeout_secs: 0.0,
tags: &["gpu"],
worker_type: None,
},
ParityRequirement {
label: "needs_tag_gpu_a100",
cpus: 1.0,
memory_gib: 1,
gpus: 0,
min_vram_gb: None,
timeout_secs: 0.0,
tags: &["gpu", "a100"],
worker_type: None,
},
ParityRequirement {
label: "needs_timeout_60_excludes_limited",
cpus: 1.0,
memory_gib: 1,
gpus: 0,
min_vram_gb: None,
timeout_secs: 60.0,
tags: &[],
worker_type: None,
},
ParityRequirement {
label: "needs_timeout_10_excludes_nobody",
cpus: 1.0,
memory_gib: 1,
gpus: 0,
min_vram_gb: None,
timeout_secs: 10.0,
tags: &[],
worker_type: None,
},
ParityRequirement {
label: "impossible",
cpus: 999.0,
memory_gib: 1,
gpus: 0,
min_vram_gb: None,
timeout_secs: 0.0,
tags: &[],
worker_type: None,
},
]
}
#[test]
fn route_dry_run_agrees_with_select_worker_everywhere() {
let workers = parity_workers();
let req_specs = parity_requirements();
let strategies = [
RoutingStrategy::BestPrice,
RoutingStrategy::BestAvailability,
RoutingStrategy::BestLatency,
];
let mut cases = 0;
for req_spec in &req_specs {
for strategy in strategies {
cases += 1;
let registry = WorkerRegistry::new();
for (i, w) in workers.iter().enumerate() {
let registered = registry.register(WorkerRegistration {
name: w.name.to_string(),
uri: format!("http://127.0.0.1:{}", 21000 + i),
worker_type: w.worker_type.to_string(),
resources: WorkerResources {
cpus_total: w.cpus_total,
cpus_available: w.cpus_total,
memory_total: w.memory_gib * 1024 * 1024 * 1024,
memory_available: w.memory_gib * 1024 * 1024 * 1024,
gpus_total: w.gpus_total,
gpus_available: w.gpus_total,
},
pricing: WorkerPricing {
price_per_hour: w.price_per_hour,
min_charge: 0.001,
},
tags: w.tags.iter().map(|t| t.to_string()).collect(),
max_timeout_secs: w.max_timeout_secs,
hardware: HardwareInfo {
gpu_vram_gb: w.gpu_vram_gb,
..Default::default()
},
wireguard_ip: None,
is_docker: None,
source_node: None,
explicit_local: false,
provider_type: Default::default(),
served_models: vec![],
price_per_mtok: 0.0,
});
for _ in 0..w.active_requests {
registry.increment_active(®istered.id);
}
registry.record_request(®istered.id, w.latency_ms, true);
}
let requirements = ResourceRequirements {
cpus: req_spec.cpus,
memory_bytes: req_spec.memory_gib * 1024 * 1024 * 1024,
gpus: req_spec.gpus,
worker_type: req_spec.worker_type.map(str::to_string),
tags: req_spec.tags.iter().map(|t| t.to_string()).collect(),
estimated_duration_secs: 3600.0,
strategy,
timeout_secs: req_spec.timeout_secs,
min_vram_gb: req_spec.min_vram_gb,
..Default::default()
};
let router = Router::new();
let dry = router.route_dry_run(®istry, &requirements).unwrap();
let credits = credits_for("parity-user", 1e12);
let real = router.select_worker(
®istry,
&credits,
"parity-user",
1e12,
&requirements,
None,
);
match (dry.chosen, real) {
(Some(d), Ok(r)) => assert_eq!(
d.worker.id, r.worker.id,
"requirement={} strategy={:?}: dry run chose {} but /execute's real selection chose {}",
req_spec.label, strategy, d.worker.name, r.worker.name
),
(None, Err(e)) => {
let _ = e;
}
(Some(d), Err(e)) => panic!(
"requirement={} strategy={:?}: dry run chose {} but the real selection found nothing eligible ({})",
req_spec.label, strategy, d.worker.name, e.code
),
(None, Ok(r)) => panic!(
"requirement={} strategy={:?}: dry run found nothing eligible but the real selection chose {}",
req_spec.label, strategy, r.worker.name
),
}
}
}
assert_eq!(cases, req_specs.len() * strategies.len());
assert!(workers.len() >= 10, "fixture must cover every dimension");
}
}
#[cfg(test)]
mod python_routing_tests {
use super::tests::{make_reg, req_default};
use super::*;
use crate::broker::worker::WorkerRegistration;
fn reg(name: &str, port: usize, py: Option<&str>) -> WorkerRegistration {
let mut r = make_reg(name, port, 4.0, 4, 0, 0.001);
r.hardware.python_version = py.map(str::to_string);
r
}
fn req(py: &str) -> ResourceRequirements {
ResourceRequirements {
python: Some(py.to_string()),
..req_default()
}
}
#[test]
fn a_payload_runs_only_on_the_same_python_minor() {
let w = |py: Option<&str>| {
let mut w = Worker::new(
"id".into(),
"w".into(),
"http://127.0.0.1:3960".into(),
"zakuro".into(),
);
w.hardware.python_version = py.map(str::to_string);
w
};
assert!(runs_payload(&w(Some("3.12.3")), Some("3.12")));
assert!(
runs_payload(&w(Some("3.12.12")), Some("3.12.3")),
"minor, not patch"
);
assert!(!runs_payload(&w(Some("3.14.5")), Some("3.12")));
assert!(
!runs_payload(&w(Some("3.1")), Some("3.12")),
"3.1 is not 3.12"
);
assert!(
!runs_payload(&w(None), Some("3.12")),
"unknown is not compatible"
);
assert!(runs_payload(&w(None), None), "no requirement, no filter");
}
#[test]
fn the_dry_run_rules_out_another_interpreter_and_says_why() {
let router = Router::new();
let registry = WorkerRegistry::new();
registry.register(reg("py312", 0, Some("3.12.3")));
registry.register(reg("py314", 1, Some("3.14.5")));
let run = router.route_dry_run(®istry, &req("3.12")).unwrap();
let names: Vec<&str> = run
.candidates
.iter()
.map(|c| c.worker.name.as_str())
.collect();
assert_eq!(names, vec!["py312"]);
assert!(
run.excluded
.iter()
.any(|e| e.reason.contains("python 3.14.5")),
"{:?}",
run.excluded
);
}
#[test]
fn live_selection_never_picks_another_interpreter() {
let router = Router::new();
let registry = WorkerRegistry::new();
registry.register(reg("py314", 0, Some("3.14.5")));
assert!(router
.select_local_worker(®istry, None, &req("3.12"), None)
.is_err());
registry.register(reg("py312", 1, Some("3.12.3")));
let d = router
.select_local_worker(®istry, None, &req("3.12"), None)
.unwrap();
assert_eq!(d.worker.name, "py312");
assert!(
router
.select_local_worker(®istry, None, &req_default(), None)
.is_ok(),
"no python requirement: unchanged"
);
}
}