#[derive(Debug, Clone, PartialEq)]
pub(crate) struct BatchBill {
reserved: f64,
actuals: std::collections::BTreeMap<u32, Option<f64>>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) enum BillError {
Insufficient,
}
pub(crate) fn plan(
estimates: &[(u32, f64)],
budget: Option<f64>,
balance: f64,
) -> Result<BatchBill, BillError> {
let wanted: f64 = estimates
.iter()
.map(|(_, c)| c)
.filter(|c| c.is_finite() && **c > 0.0)
.sum();
let capped = match budget {
Some(b) if b.is_finite() && b > 0.0 => wanted.min(b),
_ => wanted,
};
let actuals = estimates.iter().map(|(id, _)| (*id, None)).collect();
if capped == 0.0 {
return Ok(BatchBill {
reserved: 0.0,
actuals,
});
}
if !balance.is_finite() || balance <= 0.0 {
return Err(BillError::Insufficient);
}
Ok(BatchBill {
reserved: capped.min(balance),
actuals,
})
}
impl BatchBill {
pub(crate) fn reserved(&self) -> f64 {
self.reserved
}
pub(crate) fn record(&mut self, id: u32, actual: f64) {
if !actual.is_finite() || actual < 0.0 {
return;
}
if let Some(slot) = self.actuals.get_mut(&id) {
*slot = Some(actual);
}
}
pub(crate) fn settle(&self) -> f64 {
let spent: f64 = self.actuals.values().flatten().sum();
spent.min(self.reserved)
}
pub(crate) fn refund(&self) -> f64 {
self.reserved - self.settle()
}
}
pub(crate) const MAX_TRUST_SAMPLES: usize = 25;
pub(crate) fn trust_metadata<'a>(
ran: impl IntoIterator<Item = (&'a [u8], f64)>,
) -> serde_json::Value {
let ran: Vec<_> = ran.into_iter().collect();
let step = ran.len().div_ceil(MAX_TRUST_SAMPLES).max(1);
let tasks: Vec<serde_json::Value> = ran
.into_iter()
.step_by(step)
.map(|(payload, ms)| {
let service_ms = if ms.is_finite() && ms > 0.0 {
ms.round() as u64
} else {
0
};
serde_json::json!({
"payload_sha256": hex::encode(ring::digest::digest(&ring::digest::SHA256, payload)),
"service_ms": service_ms,
})
})
.collect();
serde_json::json!({ "tasks": tasks })
}
#[cfg(test)]
mod tests {
use super::*;
const PLENTY: f64 = 1_000.0;
fn est(n: u32, each: f64) -> Vec<(u32, f64)> {
(0..n).map(|i| (i, each)).collect()
}
#[test]
fn a_batch_reserves_the_sum_of_its_estimates() {
let bill = plan(&est(50, 0.001), None, PLENTY).unwrap();
assert!((bill.reserved() - 0.05).abs() < 1e-9, "{}", bill.reserved());
}
#[test]
fn the_budget_caps_the_reservation() {
let bill = plan(&est(50, 0.001), Some(0.01), PLENTY).unwrap();
assert!((bill.reserved() - 0.01).abs() < 1e-9, "{}", bill.reserved());
}
#[test]
fn the_balance_caps_the_reservation() {
let bill = plan(&est(50, 0.001), None, 0.004).unwrap();
assert!(
(bill.reserved() - 0.004).abs() < 1e-9,
"{}",
bill.reserved()
);
}
#[test]
fn a_requester_with_nothing_is_refused() {
assert_eq!(
plan(&est(10, 0.001), None, 0.0),
Err(BillError::Insufficient)
);
assert_eq!(
plan(&est(10, 0.001), None, -1.0),
Err(BillError::Insufficient)
);
}
#[test]
fn an_empty_batch_reserves_nothing() {
assert_eq!(plan(&[], None, PLENTY).unwrap().reserved(), 0.0);
}
#[test]
fn the_batch_owes_what_actually_ran() {
let mut bill = plan(&est(3, 0.010), None, PLENTY).unwrap();
bill.record(0, 0.004);
bill.record(1, 0.006);
bill.record(2, 0.005);
assert!((bill.settle() - 0.015).abs() < 1e-9, "{}", bill.settle());
}
#[test]
fn a_task_that_never_finished_is_never_charged() {
let mut bill = plan(&est(3, 0.010), None, PLENTY).unwrap();
bill.record(0, 0.004);
bill.record(1, 0.006);
assert!((bill.settle() - 0.010).abs() < 1e-9, "{}", bill.settle());
}
#[test]
fn settlement_never_exceeds_what_was_reserved() {
let mut bill = plan(&est(2, 0.001), None, PLENTY).unwrap();
assert!((bill.reserved() - 0.002).abs() < 1e-9);
bill.record(0, 5.0);
bill.record(1, 5.0);
assert!((bill.settle() - 0.002).abs() < 1e-9, "{}", bill.settle());
}
#[test]
fn what_is_spent_and_what_is_returned_add_up_to_what_was_held() {
let mut bill = plan(&est(4, 0.010), None, PLENTY).unwrap();
bill.record(0, 0.004);
bill.record(2, 0.006);
assert!(
(bill.settle() + bill.refund() - bill.reserved()).abs() < 1e-9,
"spent {} + returned {} != held {}",
bill.settle(),
bill.refund(),
bill.reserved()
);
}
#[test]
fn a_result_for_an_unknown_task_is_not_charged() {
let mut bill = plan(&est(2, 0.010), None, PLENTY).unwrap();
bill.record(0, 0.004);
bill.record(999, 5.0);
assert!((bill.settle() - 0.004).abs() < 1e-9, "{}", bill.settle());
}
#[test]
fn a_repeated_result_replaces_rather_than_accumulates() {
let mut bill = plan(&est(1, 0.010), None, PLENTY).unwrap();
bill.record(0, 0.004);
bill.record(0, 0.004);
assert!((bill.settle() - 0.004).abs() < 1e-9, "{}", bill.settle());
}
#[test]
fn a_nonsense_cost_is_ignored_rather_than_believed() {
let mut bill = plan(&est(2, 0.010), None, PLENTY).unwrap();
bill.record(0, -5.0);
bill.record(1, f64::NAN);
assert_eq!(bill.settle(), 0.0);
}
#[test]
fn earn_metadata_carries_payload_hash_and_service_ms() {
let m = trust_metadata([(&b"abc"[..], 123.6), (&b"abc"[..], f64::NAN)]);
let t = m["tasks"].as_array().unwrap();
assert_eq!(
t[0]["payload_sha256"],
"ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
);
assert_eq!(t[0]["service_ms"], 124);
assert_eq!(t[1]["service_ms"], 0);
}
#[test]
fn earn_metadata_samples_at_most_25_tasks_spread_across_the_batch() {
let payloads: Vec<Vec<u8>> = (0..10_000u32).map(|i| i.to_le_bytes().to_vec()).collect();
let m = trust_metadata(payloads.iter().map(|p| (p.as_slice(), 5.0)));
let t = m["tasks"].as_array().unwrap();
assert!(
t.len() <= 25 && t.len() <= MAX_TRUST_SAMPLES && t.len() >= 13,
"{}",
t.len()
);
let distinct: std::collections::BTreeSet<_> = t
.iter()
.map(|x| x["payload_sha256"].as_str().unwrap())
.collect();
assert_eq!(distinct.len(), t.len());
let small = trust_metadata(payloads.iter().take(7).map(|p| (p.as_slice(), 5.0)));
assert_eq!(small["tasks"].as_array().unwrap().len(), 7);
}
}