use std::cell::Cell;
use std::ops::Deref;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::{Arc, Mutex, Weak};
use super::{DepCache, lock};
use crate::budget::Reservation;
use crate::counters::LoadId;
use crate::detect::check_file_type_with_reader;
use crate::env::{DerefError, Fetch, Source, within_input_bytes};
use crate::error::Error;
use crate::files::{BundleFile, File, RawFile, SerializedFile, parse_file_with_reader};
use crate::limits::{ChargeError, Meter, pool_refusals, refusal};
use crate::options::FileContext;
use crate::raw::RawStr;
use crate::stream::ReaderKind;
use crate::typetree::TreeError;
use crate::walk::{ParseError, ReadDetail};
#[derive(Debug)]
pub(crate) struct Dependency {
pub(crate) name: RawStr,
pub(crate) source: Source,
pub(crate) open: Mutex<Open>,
pub(crate) ctx: Arc<FileContext>,
pub(crate) cache: Weak<DepCache>,
pub(crate) slots: AtomicUsize,
#[cfg(feature = "test-counters")]
pub(crate) load_id: LoadId,
}
#[derive(Debug)]
pub(crate) struct Open {
pub(crate) file: Option<WeakFile>,
pub(crate) meter: Arc<Meter>,
}
impl Open {
pub(crate) fn of(file: &File, meter: Arc<Meter>) -> Self {
Self {
file: Some(WeakFile::of(file)),
meter,
}
}
fn alive(&self) -> Option<File> {
self.file.as_ref().and_then(WeakFile::upgrade)
}
}
#[derive(Debug)]
pub(crate) struct DepSlot(Arc<Dependency>);
impl DepSlot {
pub(crate) fn new(dep: &Arc<Dependency>) -> Self {
dep.slots.fetch_add(1, Ordering::AcqRel);
Self(dep.clone())
}
}
impl Deref for DepSlot {
type Target = Arc<Dependency>;
fn deref(&self) -> &Arc<Dependency> {
&self.0
}
}
impl Drop for DepSlot {
fn drop(&mut self) {
let last = self.0.slots.fetch_sub(1, Ordering::AcqRel) == 1;
if let Some(cache) = self.0.cache.upgrade() {
#[cfg(test)]
cache.hook(super::Hook::SlotReleased);
if last {
cache.forget(&self.0);
}
}
}
}
impl Dependency {
pub(crate) fn unreachable(&self) -> bool {
self.slots.load(Ordering::Acquire) == 0
}
}
#[cfg(test)]
mod batch_view_inventory {
use super::Dependency;
use crate::limits::{Meter, heap_cost};
#[test]
fn uncharged_dependency_owners_fit_the_bounded_view_share() {
let owner = heap_cost((size_of::<Dependency>() + 2 * size_of::<usize>()) as u64);
let paths = 2 * heap_cost(128);
let basename = heap_cost(16) + heap_cost(32);
let total = owner + Meter::OWN_HEAP + paths + basename;
println!(
"view dependency owner {owner}, meter {}, paths {paths}, name {basename}, total {total}",
Meter::OWN_HEAP
);
assert!(total <= 1024 - 128);
}
}
#[derive(Debug)]
pub(crate) enum WeakFile {
Serialized(Weak<SerializedFile>),
Bundle(Weak<BundleFile>),
Raw(Weak<RawFile>),
Web(Weak<crate::files::WebFile>),
}
impl WeakFile {
pub(crate) fn of(file: &File) -> Self {
match file {
File::Serialized(f) => Self::Serialized(Arc::downgrade(f)),
File::Bundle(f) => Self::Bundle(Arc::downgrade(f)),
File::Raw(f) => Self::Raw(Arc::downgrade(f)),
File::Web(f) => Self::Web(Arc::downgrade(f)),
}
}
fn upgrade(&self) -> Option<File> {
match self {
Self::Serialized(w) => w.upgrade().map(File::Serialized),
Self::Bundle(w) => w.upgrade().map(File::Bundle),
Self::Raw(w) => w.upgrade().map(File::Raw),
Self::Web(w) => w.upgrade().map(File::Web),
}
}
}
#[cfg_attr(not(feature = "test-counters"), allow(unused_variables))]
pub(crate) fn open_source(
name: &RawStr,
source: &Source,
meter: &Arc<Meter>,
ctx: &Arc<FileContext>,
load: LoadId,
) -> Result<File, Error> {
let (data, reader) = read_source(source, meter, ctx)?;
let ty = check_file_type_with_reader(&data, &ctx.limits, reader)?;
let file = parse_file_with_reader(name.clone(), data, ty, None, meter, ctx, reader);
if let Ok(file) = &file
&& meter.reservation() == Reservation::Dependency
{
file.mark_dependency_root();
}
#[cfg(feature = "test-counters")]
crate::testing::adopt(&file, || crate::testing::Key::load(load));
file
}
pub(crate) fn read_source(
source: &Source,
meter: &Arc<Meter>,
ctx: &FileContext,
) -> Result<(bytes::Bytes, ReaderKind), Error> {
let (data, reader) = match source {
Source::Bytes { data, .. } => (data.clone(), ReaderKind::Memory),
Source::Path(p) => crate::env::split::read_source_path(p, None, &ctx.limits, meter)?,
Source::ConfinedPath { path, root } => {
crate::env::split::read_source_path(path, Some(root), &ctx.limits, meter)?
}
Source::Fetch { fetch, .. } => {
if let Some(stated) = fetch.size_hint() {
within_input_bytes(stated, &ctx.limits)?;
}
fetched(fetch.as_ref())?
}
};
within_input_bytes(data.len() as u64, &ctx.limits)?;
Ok((data, reader))
}
#[cfg(test)]
pub(crate) fn open_bare(
name: &RawStr,
source: &Source,
meter: &Arc<Meter>,
ctx: &Arc<FileContext>,
) -> Result<File, Error> {
open_source(name, source, meter, ctx, LoadId::BARE)
}
fn fetched(fetch: &dyn Fetch) -> Result<(bytes::Bytes, ReaderKind), Error> {
from_callers(fetch.fetch_with_reader())
}
pub(crate) fn from_callers<T>(returned: Result<T, Error>) -> Result<T, Error> {
returned.inspect_err(|e| {
if pool_refused(e) {
let _counted = refusal(0, Reservation::Dependency);
}
})
}
thread_local! {
static RETRYING: Cell<Option<usize>> = const { Cell::new(None) };
static RETRIED: Cell<Option<(usize, u64)>> = const { Cell::new(None) };
static RUNNING: Cell<usize> = const { Cell::new(0) };
}
struct Retrying(Option<usize>);
impl Retrying {
fn enter(at: usize) -> Self {
Self(RETRYING.replace(Some(at)))
}
}
impl Drop for Retrying {
fn drop(&mut self) {
RETRYING.set(self.0);
}
}
struct Running;
impl Running {
fn enter() -> Self {
RUNNING.set(RUNNING.get().saturating_add(1));
Self
}
}
impl Drop for Running {
fn drop(&mut self) {
let left = RUNNING.get().saturating_sub(1);
RUNNING.set(left);
if left == 0 {
RETRIED.set(None);
}
}
}
pub(crate) fn with_room<T, E: PoolRefusal>(
cache: Option<&DepCache>,
keep: Option<&Arc<Dependency>>,
mut f: impl FnMut() -> Result<T, E>,
) -> Result<T, E> {
let at = cache.map_or(0, |c| std::ptr::from_ref(c).addr());
let _running = Running::enter();
let first = f();
let Err(e) = &first else {
return first;
};
if !e.pool_refused() {
return first;
}
if RETRYING.get() == Some(at) || RETRIED.get() == Some((at, pool_refusals())) {
RETRIED.set(Some((at, pool_refusals())));
return first;
}
drop(first);
if let Some(cache) = cache {
cache.evict_others(keep);
}
let second = {
let _retrying = Retrying::enter(at);
f()
};
if matches!(&second, Err(e) if e.pool_refused()) {
RETRIED.set(Some((at, pool_refusals())));
}
second
}
pub(crate) trait PoolRefusal {
fn pool_refused(&self) -> bool;
}
impl PoolRefusal for Error {
fn pool_refused(&self) -> bool {
pool_refused(self)
}
}
impl PoolRefusal for DerefError {
fn pool_refused(&self) -> bool {
deref_refused(self)
}
}
impl PoolRefusal for ParseError {
fn pool_refused(&self) -> bool {
parse_refused(self)
}
}
pub(crate) fn pool_refused(e: &Error) -> bool {
match e {
Error::Budget(b) => b.what == Reservation::Dependency,
Error::Entry { source, .. } => pool_refused(source),
Error::Tree(t) => tree_refused(t),
Error::AssetBundle(p) => parse_refused(p),
Error::Deref(d) => deref_refused(d),
_ => false,
}
}
fn charge_refused(c: &ChargeError) -> bool {
matches!(c, ChargeError::Budget(b) if b.what == Reservation::Dependency)
}
fn tree_refused(t: &TreeError) -> bool {
matches!(t, TreeError::Charge(c) if charge_refused(c))
}
fn deref_refused(d: &DerefError) -> bool {
matches!(d, DerefError::Load(e) if pool_refused(e))
}
fn parse_refused(p: &ParseError) -> bool {
match p {
ParseError::Read(r) => match &r.detail {
ReadDetail::Charge(c) => charge_refused(c),
ReadDetail::Tree(t) => tree_refused(t),
_ => false,
},
ParseError::Tree(t) => tree_refused(t),
ParseError::Deref(d) => deref_refused(d),
_ => false,
}
}
impl Dependency {
pub(crate) fn with_room<T, E: PoolRefusal>(
self: &Arc<Self>,
f: impl FnMut() -> Result<T, E>,
) -> Result<T, E> {
with_room(self.cache.upgrade().as_deref(), Some(self), f)
}
pub(crate) fn handle(self: &Arc<Self>) -> Result<File, Error> {
let (alive, meter) = {
let open = lock(&self.open);
(open.alive(), open.meter.clone())
};
if let Some(f) = alive {
if let Some(cache) = self.cache.upgrade() {
cache.touch(self, &f)?;
}
return Ok(f);
}
let meter = meter.reopen();
#[cfg(feature = "test-counters")]
let load = self.load_id;
#[cfg(not(feature = "test-counters"))]
let load = LoadId::BARE;
let file = open_source(&self.name, &self.source, &meter, &self.ctx, load)?;
let (file, _replaced) = {
let mut open = lock(&self.open);
if let Some(theirs) = open.alive() {
(theirs, None)
} else {
let mine = Open::of(&file, meter);
(file, Some(std::mem::replace(&mut *open, mine)))
}
};
if let Some(cache) = self.cache.upgrade() {
cache.touch(self, &file)?;
}
Ok(file)
}
pub(crate) fn alive(&self) -> Option<File> {
lock(&self.open).alive()
}
pub(crate) fn meter(&self) -> Arc<Meter> {
lock(&self.open).meter.clone()
}
}