use std::sync::Arc;
use unityrs_core::RawStr;
use unityrs_core::env::Environment;
use unityrs_core::files::BundleFile;
use unityrs_core::limits::{Charge, Meter};
use super::classify::{Class, Reason};
use super::keys::{KeyTable, Template, TemplateKind};
use super::{Failure, Output};
pub trait Hooks {
fn stopped(&self) -> bool {
false
}
fn refusals(&self) -> Option<u64> {
None
}
fn allocator_refusals(&self) -> u64 {
0
}
fn export_work_remaining(&self) -> u64 {
u64::MAX
}
fn export_work(&self, bytes: u64) -> Result<(), Reason> {
let _ = bytes;
Ok(())
}
#[cfg(feature = "test-hooks")]
fn skipped(&self, _exporting: bool) {}
#[cfg(feature = "test-hooks")]
fn decoder_fault(&self) {}
#[cfg(feature = "test-hooks")]
fn environment_fault(&self, _env: &Environment) -> Option<unityrs_core::Error> {
None
}
fn meter(&self, _meter: &Meter) {}
fn environment(&self, _env: &Environment) {}
fn sprite_group(&self, group: usize, file: &RawStr, path_id: i64) {
let _ = (group, file, path_id);
}
}
#[derive(Clone, Copy, Debug, Default)]
pub struct NoHooks;
impl Hooks for NoHooks {}
#[derive(Clone, Debug)]
pub struct MemberTemplate {
pub archive: usize,
pub kind: TemplateKind,
pub path: Template,
}
pub struct Registered {
pub env: Environment,
pub own: Arc<BundleFile>,
pub(super) _held: Option<Charge>,
}
pub struct Context<'a> {
pub registered: &'a Registered,
pub meter: &'a Arc<Meter>,
pub input: &'a str,
pub hooks: &'a dyn Hooks,
pub max_evictions: u64,
pub prefix: &'a str,
pub members: &'a [MemberTemplate],
pub keys: &'a mut KeyTable,
pub sink: &'a mut dyn FnMut(Output) -> Result<(), Failure>,
}
#[derive(Clone, Copy)]
pub(super) struct Seam<'a> {
pub registered: &'a Registered,
pub meter: &'a Arc<Meter>,
pub hooks: &'a dyn Hooks,
pub max_evictions: u64,
pub prefix: &'a str,
pub members: &'a [MemberTemplate],
}
impl<'a> Seam<'a> {
pub fn env(&self) -> &'a Environment {
&self.registered.env
}
pub fn stop(&self) -> Result<(), Failure> {
allocator_check(self.hooks).map_err(Failure::from)?;
if self.hooks.stopped() {
Err(Failure::Stopped)
} else {
Ok(())
}
}
pub fn evictions(&self) -> Result<(), Class> {
evictions(self.env(), self.max_evictions)
}
pub fn probe<T>(&self, f: impl FnOnce() -> Result<T, Class>) -> Result<T, Class> {
probe(self.hooks, f)
}
pub fn env_call<T>(&self, f: impl FnOnce() -> Result<T, Class>) -> Result<T, Class> {
let out = self.probe(f);
self.hooks.environment(self.env());
if let Err(Class::Run(_)) = &out {
return out;
}
self.evictions()?;
out
}
pub fn work(&self, bytes: u64) -> Result<(), Class> {
self.hooks.export_work(bytes).map_err(Class::Input)
}
}
pub(super) fn evictions(env: &Environment, max: u64) -> Result<(), Class> {
if env.stats().dependencies_evicted > max {
let reason = format!("limit(attempt_evictions, {max})");
return Err(Class::Input(Reason::plain(reason)));
}
Ok(())
}
pub(super) fn probe<T>(
hooks: &dyn Hooks,
f: impl FnOnce() -> Result<T, Class>,
) -> Result<T, Class> {
allocator_check(hooks)?;
let before = hooks.refusals();
let out = f();
allocator_check(hooks)?;
out.map_err(|c| probed(hooks, before, c))
}
pub(super) fn allocator_check(hooks: &dyn Hooks) -> Result<(), Class> {
if hooks.allocator_refusals() != 0 {
Err(Class::Run(Reason::plain("host_memory")))
} else {
Ok(())
}
}
pub(super) fn probed(hooks: &dyn Hooks, before: Option<u64>, c: Class) -> Class {
if let Err(c) = allocator_check(hooks) {
return c;
}
if let Some(before) = before
&& is_refusal(&c)
&& hooks.refusals() == Some(before)
{
return Class::Run(Reason::plain("host_memory"));
}
c
}
fn is_refusal(c: &Class) -> bool {
let (Class::Skip(r) | Class::Input(r) | Class::Run(r)) = c;
r.reason.starts_with("budget(")
}
#[cfg(test)]
mod allocator_tests {
use super::*;
use std::cell::Cell;
#[derive(Default)]
struct Audit {
allocator: Cell<u64>,
budget: Cell<u64>,
}
impl Hooks for Audit {
fn refusals(&self) -> Option<u64> {
Some(self.budget.get())
}
fn allocator_refusals(&self) -> u64 {
self.allocator.get()
}
}
#[test]
fn absorbed_allocator_refusal_wins_even_after_a_budget_refusal() {
let hooks = Audit::default();
let result = probe(&hooks, || {
hooks.budget.set(1);
hooks.allocator.set(1);
Ok(())
});
assert!(matches!(result, Err(Class::Run(r)) if r.reason == "host_memory"));
let mut called = false;
let _ = probe(&hooks, || {
called = true;
Ok(())
});
assert!(!called, "a poisoned attempt must make no further call");
}
#[test]
fn an_absorbed_budget_refusal_alone_can_still_succeed() {
let hooks = Audit::default();
assert!(
probe(&hooks, || {
hooks.budget.set(1);
Ok(())
})
.is_ok()
);
}
}