use crate::budget::{Budget, Exceeded, Kind};
use crate::cancel::CancelToken;
use crate::codes;
use crate::diag::{Diagnostic, Diagnostics};
#[derive(Debug)]
pub struct Cx<'a> {
pub budget: &'a mut Budget,
pub diag: &'a mut Diagnostics,
pub cancel: &'a CancelToken,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Stop {
Exceeded(Exceeded),
Cancelled,
TimedOut,
}
impl Stop {
pub fn to_diagnostic(&self) -> Diagnostic {
match self {
Stop::Exceeded(exceeded) => exceeded.to_diagnostic(),
Stop::Cancelled => Diagnostic::new(codes::CALL_REQUEST_CANCELLED),
Stop::TimedOut => Diagnostic::new(codes::BUDGET_TIME_EXCEEDED),
}
}
}
impl From<Exceeded> for Stop {
fn from(exceeded: Exceeded) -> Self {
Stop::Exceeded(exceeded)
}
}
impl<'a> Cx<'a> {
pub fn new(budget: &'a mut Budget, diag: &'a mut Diagnostics, cancel: &'a CancelToken) -> Self {
Self {
budget,
diag,
cancel,
}
}
pub fn check(&mut self, kind: Kind, amount: u64) -> Result<(), Stop> {
if let Some(stop) = self.diag.record_order_stop() {
return Err(stop);
}
if let Some(stop) = self.cancel.stop() {
return Err(stop);
}
self.budget.spend(kind, amount).map_err(Stop::from)
}
pub fn enter(&mut self) -> Result<(), Stop> {
self.check(Kind::Depth, 1)
}
pub fn leave(&mut self) {
self.budget.leave(1);
}
pub fn report(&mut self, diagnostic: Diagnostic) {
if self.diag.record_order_stop().is_some() {
return;
}
if let Some(amount) = self.diag.record_order_work(&diagnostic)
&& let Err(stop) = self.check(Kind::Work, amount)
{
self.diag.stop_record_order(stop, diagnostic);
return;
}
self.diag.report(diagnostic);
}
pub fn with_diagnostics_in_record_order<T, E: From<Stop>>(
&mut self,
operation: impl FnOnce(&mut Cx<'_>) -> Result<T, E>,
) -> Result<T, E> {
if let Some(stop) = self.diag.record_order_stop() {
return Err(stop.into());
}
if self.diag.is_collecting_in_record_order() {
let result = operation(self);
return match self.diag.record_order_stop() {
Some(stop) => Err(stop.into()),
None => result,
};
}
let mut diagnostics = Diagnostics::in_record_order(self.diag.max_places());
let result = operation(&mut Cx::new(self.budget, &mut diagnostics, self.cancel));
let stop = diagnostics.record_order_stop();
for diagnostic in diagnostics.into_vec() {
self.report(diagnostic);
}
match stop {
Some(stop) => Err(stop.into()),
None => result,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::budget::{Limit, Limits};
#[test]
fn checks_the_signal_before_the_budget() {
let mut budget = Budget::default();
let mut diag = Diagnostics::new();
let cancel = CancelToken::new();
let mut cx = Cx::new(&mut budget, &mut diag, &cancel);
assert_eq!(cx.check(Kind::Records, 1), Ok(()));
cancel.cancel();
assert_eq!(cx.check(Kind::Records, 1), Err(Stop::Cancelled));
assert_eq!(budget.used(Kind::Records), 1);
}
#[test]
fn nesting_stops_at_the_depth_limit() {
let mut budget = Budget::new(Limits::default().with(Kind::Depth, Limit::Finite(1)));
let mut diag = Diagnostics::new();
let cancel = CancelToken::new();
let mut cx = Cx::new(&mut budget, &mut diag, &cancel);
assert_eq!(cx.enter(), Ok(()));
let stop = cx.enter().unwrap_err();
cx.report(stop.to_diagnostic());
cx.leave();
assert_eq!(
diag.iter().next().map(Diagnostic::code),
Some(codes::BUDGET_DEPTH_EXCEEDED)
);
}
#[test]
fn each_stop_has_its_code() {
assert_eq!(
Stop::Cancelled.to_diagnostic().code(),
codes::CALL_REQUEST_CANCELLED
);
assert_eq!(
Stop::TimedOut.to_diagnostic().code(),
codes::BUDGET_TIME_EXCEEDED
);
}
#[test]
fn record_order_keeps_first_places_values_and_stable_ties_even_without_places() {
for max_places in [0, 1, 2, 16] {
let mut budget = Budget::default();
let mut diag = Diagnostics::with_max_places(max_places);
let cancel = CancelToken::new();
Cx::new(&mut budget, &mut diag, &cancel)
.with_diagnostics_in_record_order(|cx| {
cx.report(
Diagnostic::new(codes::ZIP_PATH_UNSAFE)
.with("name", "late")
.at(crate::Ref::at_record(9)),
);
cx.report(
Diagnostic::new(codes::SXF_P21_INSTANCE_DROPPED)
.with("id", 2_u64)
.at(crate::Ref::at_record(4)),
);
cx.report(
Diagnostic::new(codes::ZIP_PATH_UNSAFE)
.with("name", "first")
.at(crate::Ref::at_record(4)),
);
cx.report(
Diagnostic::new(codes::SXF_P21_INSTANCE_DROPPED)
.with("id", 1_u64)
.at(crate::Ref::at_record(4)),
);
cx.report(
Diagnostic::new(codes::ZIP_PATH_UNSAFE)
.with("name", "middle")
.at(crate::Ref::at_record(7)),
);
assert!(cx.diag.iter().all(|d| d.places().len() <= max_places));
Ok::<(), Stop>(())
})
.unwrap();
let diagnostics = diag.into_vec();
assert_eq!(diagnostics.len(), 3);
assert_eq!(diagnostics[0].param("id"), Some(&crate::Value::UInt(2)));
assert_eq!(diagnostics[2].param("id"), Some(&crate::Value::UInt(1)));
let merged = &diagnostics[1];
assert_eq!(merged.code(), codes::ZIP_PATH_UNSAFE);
assert_eq!(merged.count(), 3);
assert_eq!(merged.param("name"), Some(&crate::Value::from("first")));
assert_eq!(
merged.places(),
&[
crate::Ref::at_record(4),
crate::Ref::at_record(7),
crate::Ref::at_record(9)
][..max_places.min(3)]
);
}
}
#[test]
fn record_order_stops_before_collecting_and_flushes_already_paid_diagnostics() {
for cancelled in [false, true] {
let mut budget = Budget::new(Limits::default().with(Kind::Work, Limit::Finite(5)));
let mut diag = Diagnostics::with_max_places(1);
let cancel = CancelToken::new();
let result =
Cx::new(&mut budget, &mut diag, &cancel).with_diagnostics_in_record_order(|cx| {
cx.report(Diagnostic::new(codes::ZIP_PATH_UNSAFE).at(crate::Ref::at_record(9)));
if cancelled {
cancel.cancel();
}
cx.report(Diagnostic::new(codes::ZIP_PATH_UNSAFE).at(crate::Ref::at_record(3)));
let stop = cx.check(Kind::Work, 0).unwrap_err();
cx.report(stop.to_diagnostic());
Ok::<(), Stop>(())
});
let stop = result.unwrap_err();
assert_eq!(cancelled, stop == Stop::Cancelled);
assert_eq!(budget.used(Kind::Work), 5);
let diagnostics = diag.into_vec();
assert_eq!(diagnostics.len(), 2);
assert_eq!(diagnostics[0].code(), stop.to_diagnostic().code());
assert_eq!(diagnostics[0].places(), [crate::Ref::at_record(3)]);
assert_eq!(diagnostics[1].count(), 1);
assert_eq!(diagnostics[1].places(), [crate::Ref::at_record(9)]);
}
}
#[test]
fn ordinary_reporting_neither_reorders_nor_spends_work() {
let mut budget = Budget::new(Limits::default().with(Kind::Work, Limit::Finite(0)));
let mut diag = Diagnostics::with_max_places(1);
let cancel = CancelToken::new();
let mut cx = Cx::new(&mut budget, &mut diag, &cancel);
for record in [9, 3] {
cx.report(Diagnostic::new(codes::ZIP_PATH_UNSAFE).at(crate::Ref::at_record(record)));
}
assert_eq!(budget.used(Kind::Work), 0);
assert_eq!(
diag.iter().next().unwrap().places(),
[crate::Ref::at_record(9)]
);
assert_eq!(diag.iter().next().unwrap().count(), 2);
}
#[test]
fn repeated_reports_keep_bounded_storage() {
for max_places in [0, 1] {
let mut budget = Budget::default();
let mut diag = Diagnostics::with_max_places(max_places);
let cancel = CancelToken::new();
Cx::new(&mut budget, &mut diag, &cancel)
.with_diagnostics_in_record_order(|cx| {
for record in (0..1000).rev() {
cx.report(
Diagnostic::new(codes::ZIP_PATH_UNSAFE)
.at(crate::Ref::at_record(record)),
);
assert_eq!(cx.diag.len(), 1);
assert_eq!(cx.diag.iter().next().unwrap().places().len(), max_places);
}
Ok::<(), Stop>(())
})
.unwrap();
let diagnostics = diag.into_vec();
assert_eq!(diagnostics[0].count(), 1000);
assert_eq!(
diagnostics[0].places(),
&[crate::Ref::at_record(0)][..max_places]
);
assert_eq!(budget.used(Kind::Work), 1000 * (4 + max_places as u64));
}
}
#[test]
fn record_order_preserves_tied_places_and_puts_unlocated_reports_last() {
let mut budget = Budget::new(Limits::default().with(Kind::Work, Limit::Finite(22)));
let mut diag = Diagnostics::with_max_places(2);
let cancel = CancelToken::new();
Cx::new(&mut budget, &mut diag, &cancel)
.with_diagnostics_in_record_order(|cx| {
cx.report(Diagnostic::new(codes::SXF_P21_SHEET_MISSING));
cx.report(
Diagnostic::new(codes::ZIP_PATH_UNSAFE)
.at(crate::Ref::at_record(5))
.at(crate::Ref::at_record(2).with_id("first"))
.at(crate::Ref::at_record(2).with_id("second")),
);
cx.report(
Diagnostic::new(codes::ZIP_PATH_UNSAFE)
.at(crate::Ref::at_record(2).with_id("third")),
);
Ok::<(), Stop>(())
})
.unwrap();
assert_eq!(budget.used(Kind::Work), 22);
let diagnostics = diag.into_vec();
assert_eq!(diagnostics[0].count(), 2);
assert_eq!(
diagnostics[0].places(),
[
crate::Ref::at_record(2).with_id("first"),
crate::Ref::at_record(2).with_id("second")
]
);
assert_eq!(diagnostics[1].code(), codes::SXF_P21_SHEET_MISSING);
assert!(diagnostics[1].places().is_empty());
}
#[test]
fn nested_record_order_keeps_positions_values_and_one_work_charge() {
for max_places in [0, 1] {
let work = 5 * (4 + max_places as u64);
let mut budget = Budget::new(Limits::default().with(Kind::Work, Limit::Finite(work)));
let mut diag = Diagnostics::with_max_places(max_places);
let cancel = CancelToken::new();
Cx::new(&mut budget, &mut diag, &cancel)
.with_diagnostics_in_record_order(|cx| {
cx.report(
Diagnostic::new(codes::ZIP_PATH_UNSAFE)
.with("name", "late")
.at(crate::Ref::at_record(9)),
);
cx.with_diagnostics_in_record_order(|cx| {
cx.report(
Diagnostic::new(codes::SXF_P21_INSTANCE_DROPPED)
.with("id", 2_u64)
.at(crate::Ref::at_record(4)),
);
cx.with_diagnostics_in_record_order(|cx| {
cx.report(
Diagnostic::new(codes::ZIP_PATH_UNSAFE)
.with("name", "first")
.at(crate::Ref::at_record(1)),
);
Ok::<(), Stop>(())
})?;
cx.report(
Diagnostic::new(codes::SXF_P21_INSTANCE_DROPPED)
.with("id", 3_u64)
.at(crate::Ref::at_record(4)),
);
Ok::<(), Stop>(())
})?;
cx.report(
Diagnostic::new(codes::SXF_P21_SHEET_DROPPED)
.with("id", 80_u64)
.at(crate::Ref::at_record(2)),
);
Ok::<(), Stop>(())
})
.unwrap();
assert_eq!(budget.used(Kind::Work), work);
let diagnostics = diag.into_vec();
assert_eq!(diagnostics.len(), 4);
assert_eq!(diagnostics[0].code(), codes::ZIP_PATH_UNSAFE);
assert_eq!(diagnostics[0].count(), 2);
assert_eq!(
diagnostics[0].param("name"),
Some(&crate::Value::from("first"))
);
assert_eq!(diagnostics[1].code(), codes::SXF_P21_SHEET_DROPPED);
assert_eq!(diagnostics[2].param("id"), Some(&crate::Value::UInt(2)));
assert_eq!(diagnostics[3].param("id"), Some(&crate::Value::UInt(3)));
for (diagnostic, record) in diagnostics.iter().zip([1, 2, 4, 4]) {
assert_eq!(
diagnostic.places(),
&[crate::Ref::at_record(record)][..max_places]
);
}
}
}
#[test]
fn nested_record_order_returns_the_inner_stop_and_keeps_collected_reports() {
for (max_places, cancelled) in [(0, false), (1, false), (0, true), (1, true)] {
let work = 2 * (4 + max_places as u64);
let mut budget = Budget::new(Limits::default().with(Kind::Work, Limit::Finite(work)));
let mut diag = Diagnostics::with_max_places(max_places);
let cancel = CancelToken::new();
let mut inner_stop = None;
let result =
Cx::new(&mut budget, &mut diag, &cancel).with_diagnostics_in_record_order(|cx| {
cx.report(Diagnostic::new(codes::ZIP_PATH_UNSAFE).at(crate::Ref::at_record(9)));
let result = cx.with_diagnostics_in_record_order(|cx| {
cx.report(
Diagnostic::new(codes::SXF_P21_INSTANCE_DROPPED)
.with("id", 2_u64)
.at(crate::Ref::at_record(3)),
);
if cancelled {
cancel.cancel();
}
cx.report(
Diagnostic::new(codes::SXF_P21_INSTANCE_DROPPED)
.with("id", 3_u64)
.at(crate::Ref::at_record(5)),
);
Ok::<(), Stop>(())
});
let stop = result.unwrap_err();
inner_stop = Some(stop);
assert_eq!(cx.check(Kind::Work, 0), Err(stop));
let mut entered = false;
let after_stop = cx.with_diagnostics_in_record_order(|_| {
entered = true;
Ok::<(), Stop>(())
});
assert_eq!(after_stop, Err(stop));
assert!(!entered);
Ok::<(), Stop>(())
});
let stop = result.unwrap_err();
assert_eq!(inner_stop, Some(stop));
assert_eq!(cancelled, stop == Stop::Cancelled);
assert_eq!(budget.used(Kind::Work), work);
let diagnostics = diag.into_vec();
assert_eq!(diagnostics.len(), 3);
assert_eq!(diagnostics[0].code(), codes::SXF_P21_INSTANCE_DROPPED);
assert_eq!(diagnostics[0].param("id"), Some(&crate::Value::UInt(2)));
assert_eq!(diagnostics[1].code(), stop.to_diagnostic().code());
assert_eq!(diagnostics[2].code(), codes::ZIP_PATH_UNSAFE);
for (diagnostic, record) in diagnostics.iter().zip([3, 5, 9]) {
assert_eq!(diagnostic.count(), 1);
assert_eq!(
diagnostic.places(),
&[crate::Ref::at_record(record)][..max_places]
);
}
}
}
}