use std::cell::Cell;
use std::sync::Arc;
use std::sync::atomic::{AtomicU32, Ordering};
use bytes::Bytes;
use super::{DepCache, open_bare, with_room};
use crate::budget::{BudgetExceeded, DecodeBuf, MemoryBudget, Permit, Reservation};
use crate::codec::{BlockCodec, Codec, Decoded, Stored, decode_block};
use crate::env::{Fetch, Source};
use crate::error::{Error, LimitKind};
use crate::limits::{Limits, Meter, pool_refusals};
use crate::options::FileContext;
use crate::raw::RawStr;
#[derive(Debug)]
struct Refuses;
impl MemoryBudget for Refuses {
fn try_reserve(&self, bytes: u64, what: Reservation) -> Result<Permit, BudgetExceeded> {
Err(BudgetExceeded {
requested: bytes,
what,
})
}
}
fn refusing() -> Arc<Meter> {
Meter::for_input(
&Limits::default(),
Arc::new(Refuses),
Reservation::Dependency,
)
}
fn refused(meter: &Arc<Meter>) -> Result<(), Error> {
meter.charge(8).map(drop).map_err(Error::from)
}
fn cache() -> DepCache {
DepCache::new(u64::MAX, true)
}
#[test]
fn a_refusal_an_inner_retry_met_is_passed_on() {
let (cache, meter) = (cache(), refusing());
let (outer, inner) = (Cell::new(0), Cell::new(0));
let r = with_room(Some(&cache), None, || {
outer.set(outer.get() + 1);
with_room(Some(&cache), None, || {
inner.set(inner.get() + 1);
refused(&meter)
})
});
assert!(matches!(r, Err(Error::Budget(_))), "{r:?}");
assert_eq!((outer.get(), inner.get()), (1, 2), "(outer, inner) runs");
}
#[test]
fn nothing_retries_inside_a_retry() {
let (cache, meter) = (cache(), refusing());
let (outer, inner) = (Cell::new(0), Cell::new(0));
let r = with_room(Some(&cache), None, || {
outer.set(outer.get() + 1);
if outer.get() == 1 {
return refused(&meter);
}
with_room(Some(&cache), None, || {
inner.set(inner.get() + 1);
refused(&meter)
})
});
assert!(matches!(r, Err(Error::Budget(_))), "{r:?}");
assert_eq!((outer.get(), inner.get()), (2, 1), "(outer, inner) runs");
}
#[test]
fn a_refusal_after_one_let_go_is_retried() {
let (cache, meter) = (cache(), refusing());
let (outer, inner) = (Cell::new(0), Cell::new(0));
let r = with_room(Some(&cache), None, || {
outer.set(outer.get() + 1);
let let_go = with_room(Some(&cache), None, || {
inner.set(inner.get() + 1);
refused(&meter)
});
assert!(let_go.is_err());
refused(&meter)
});
assert!(matches!(r, Err(Error::Budget(_))), "{r:?}");
assert_eq!(outer.get(), 2, "the outer's own refusal was not retried");
assert_eq!(inner.get(), 3, "inner runs");
}
#[test]
fn another_environments_retry_is_its_own() {
let (a, b, meter) = (cache(), cache(), refusing());
let (outer, inner) = (Cell::new(0), Cell::new(0));
let r = with_room(Some(&a), None, || {
outer.set(outer.get() + 1);
if outer.get() == 1 {
return refused(&meter);
}
with_room(Some(&b), None, || {
inner.set(inner.get() + 1);
refused(&meter)
})
});
assert!(matches!(r, Err(Error::Budget(_))), "{r:?}");
assert_eq!((outer.get(), inner.get()), (2, 2), "(outer, inner) runs");
}
#[test]
fn only_the_pools_refusal_is_retried() {
let cache = cache();
let input = Meter::for_input(&Limits::default(), Arc::new(Refuses), Reservation::Input);
let runs = Cell::new(0);
let r = with_room(Some(&cache), None, || {
runs.set(runs.get() + 1);
refused(&input)
});
assert!(matches!(r, Err(Error::Budget(_))), "{r:?}");
assert_eq!(runs.get(), 1);
}
fn uncounted() -> Error {
Error::Budget(BudgetExceeded {
requested: 8,
what: Reservation::Dependency,
})
}
fn refused_once(cache: &DepCache, refusal: impl Fn() -> Error) -> (Result<(), Error>, u32) {
let runs = Cell::new(0);
let r = with_room(Some(cache), None, || {
runs.set(runs.get() + 1);
if runs.get() == 1 {
return Err(refusal());
}
Ok(())
});
(r, runs.get())
}
#[test]
fn a_mark_an_earlier_call_left_holds_no_later_refusal() {
let (cache, meter) = (cache(), refusing());
let earlier = with_room(Some(&cache), None, || refused(&meter));
assert!(matches!(earlier, Err(Error::Budget(_))), "{earlier:?}");
let (r, runs) = refused_once(&cache, uncounted);
assert!(r.is_ok(), "{r:?}");
assert_eq!(runs, 2, "the later call's refusal was not retried");
}
#[test]
fn a_call_that_panics_leaves_no_mark() {
let (cache, meter) = (cache(), refusing());
let panicked = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
let _: Result<(), Error> = with_room(Some(&cache), None, || {
let inner = with_room(Some(&cache), None, || refused(&meter));
assert!(inner.is_err());
panic!("the call panics with the mark set");
});
}));
assert!(panicked.is_err());
let (r, runs) = refused_once(&cache, uncounted);
assert!(r.is_ok(), "{r:?}");
assert_eq!(runs, 2, "a mark outlived the call that panicked");
}
#[derive(Debug)]
struct RefusingFetch(Option<Arc<Meter>>);
impl Fetch for RefusingFetch {
fn fetch(&self) -> Result<Bytes, Error> {
match &self.0 {
Some(meter) => refused(meter).map(|()| Bytes::new()),
None => Err(uncounted()),
}
}
}
#[test]
fn a_fetchers_refusal_of_the_pool_is_counted_as_it_returns() {
let ctx = Arc::new(FileContext::unitypy());
let name = RawStr::from("f.bundle");
for (fetch, what, counted) in [
(RefusingFetch(None), "the fetcher's own", 1),
(
RefusingFetch(Some(refusing())),
"the core's, during the fetch",
2,
),
] {
let source = Source::Fetch {
name: name.clone(),
fetch: Arc::new(fetch),
};
let at = pool_refusals();
let r = open_bare(&name, &source, &refusing(), &ctx);
assert!(matches!(r, Err(Error::Budget(_))), "{what}: {r:?}");
assert_eq!(pool_refusals() - at, counted, "{what}");
}
}
#[derive(Debug)]
struct LetGoFetch {
cache: Arc<DepCache>,
meter: Arc<Meter>,
runs: AtomicU32,
}
impl Fetch for LetGoFetch {
fn fetch(&self) -> Result<Bytes, Error> {
if self.runs.fetch_add(1, Ordering::AcqRel) > 0 {
return Ok(Bytes::new());
}
let read = with_room(Some(&self.cache), None, || refused(&self.meter));
assert!(read.is_err());
Err(uncounted())
}
}
#[test]
fn a_fetchers_own_refusal_after_one_it_let_go_is_retried() {
let cache = Arc::new(cache());
let fetch = Arc::new(LetGoFetch {
cache: cache.clone(),
meter: refusing(),
runs: AtomicU32::new(0),
});
let name = RawStr::from("f.bundle");
let source = Source::Fetch {
name: name.clone(),
fetch: fetch.clone(),
};
let ctx = Arc::new(FileContext::unitypy());
let r = with_room(Some(&cache), None, || {
open_bare(&name, &source, &Meter::unlimited(), &ctx).map(drop)
});
assert!(r.is_ok(), "{r:?}");
assert_eq!(fetch.runs.load(Ordering::Acquire), 2, "the fetcher's runs");
}
#[derive(Debug)]
struct PassesOn {
cache: Arc<DepCache>,
meter: Arc<Meter>,
runs: AtomicU32,
reads: AtomicU32,
}
impl Fetch for PassesOn {
fn fetch(&self) -> Result<Bytes, Error> {
self.runs.fetch_add(1, Ordering::AcqRel);
with_room(Some(&self.cache), None, || {
self.reads.fetch_add(1, Ordering::AcqRel);
refused(&self.meter)
})
.map(|()| Bytes::new())
}
}
#[test]
fn a_refusal_a_fetcher_passes_on_costs_one_more_fetch() {
let cache = Arc::new(cache());
let fetch = Arc::new(PassesOn {
cache: cache.clone(),
meter: refusing(),
runs: AtomicU32::new(0),
reads: AtomicU32::new(0),
});
let name = RawStr::from("f.bundle");
let source = Source::Fetch {
name: name.clone(),
fetch: fetch.clone(),
};
let ctx = Arc::new(FileContext::unitypy());
let r = with_room(Some(&cache), None, || {
open_bare(&name, &source, &Meter::unlimited(), &ctx).map(drop)
});
assert!(matches!(r, Err(Error::Budget(_))), "{r:?}");
let runs = (
fetch.runs.load(Ordering::Acquire),
fetch.reads.load(Ordering::Acquire),
);
assert_eq!(runs, (2, 3), "(fetches, reads)");
}
struct RefusesOnce(AtomicU32);
impl BlockCodec for RefusesOnce {
fn decode(
&self,
input: &Bytes,
uncompressed: u32,
out: &mut DecodeBuf,
) -> Result<Decoded, Error> {
if self.0.fetch_add(1, Ordering::AcqRel) == 0 {
return Err(uncounted());
}
Stored.decode(input, uncompressed, out)
}
}
#[test]
fn a_codecs_own_refusal_after_one_let_go_is_retried() {
let (cache, meter) = (cache(), refusing());
let codec = RefusesOnce(AtomicU32::new(0));
let input = Bytes::from_static(b"stored");
let runs = Cell::new(0);
let r = with_room(Some(&cache), None, || {
runs.set(runs.get() + 1);
let let_go = with_room(Some(&cache), None, || refused(&meter));
assert!(let_go.is_err());
let unlimited = Meter::unlimited();
let mut out = DecodeBuf::new(&unlimited, 0, u64::MAX, LimitKind::InputMemory)?;
decode_block(Codec::Other(5), &codec, &input, 6, &mut out, u64::MAX).map(drop)
});
assert!(r.is_ok(), "{r:?}");
assert_eq!(runs.get(), 2, "the call's runs");
}