use std::sync::Arc;
use std::sync::atomic::Ordering;
use super::super::Source;
#[cfg(test)]
use super::Hook;
use super::pending::{List, STEP};
use super::{By, Cab, DepSlot, Dependency, Loads, RawCab, Registry, Slot, SlotKind};
use crate::detect::{DetectError, FileType, check_file_type, probe_container};
use crate::error::Error;
use crate::files::{BundleFile, File};
use crate::limits::{GrantScope, Limits, Meter};
use crate::once::CellError;
const PEEK: u64 = 128;
fn is_bundle_entry(b: &BundleFile, i: usize) -> Result<bool, Error> {
bundle_entry(b, i, false)
}
pub(crate) fn probe_bundle_entry(b: &BundleFile, i: usize) -> Result<bool, Error> {
bundle_entry(b, i, true)
}
fn bundle_entry(b: &BundleFile, i: usize, require_verdict: bool) -> Result<bool, Error> {
let head = match b.entry_range(i, 0..PEEK) {
Ok(head) => head,
Err(e) if require_verdict || e.is_transient() => return Err(e),
Err(_) => return Ok(false),
};
let detected = if head.starts_with(&[31, 139]) {
crate::detect::check_entry_type(&b.entry_bytes(i)?, &b.context().limits, b.meter())
} else {
check_file_type(&head, &Limits::default())
};
if require_verdict {
return Ok(probe_container(detected)?);
}
bundle_detected(detected)
}
fn bundle_detected(detected: Result<FileType, DetectError>) -> Result<bool, Error> {
match detected {
Ok(ty) => Ok(matches!(ty, FileType::BundleFile | FileType::WebFile)),
Err(e @ DetectError::Allocator(_)) => Err(e.into()),
Err(_) => Ok(false),
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum Through {
Own,
Slot,
}
pub(crate) fn entry_of(fb: &Arc<BundleFile>, slot: &Slot) -> Option<(usize, Through)> {
match &slot.kind {
SlotKind::Entry { bundle, dir_index } if Arc::ptr_eq(bundle, fb) => {
Some((*dir_index, Through::Own))
}
SlotKind::Entry { bundle, dir_index } => {
same_input(bundle, fb).then_some((*dir_index, Through::Slot))
}
SlotKind::Ready(Cab::Raw(RawCab::InBundle { bundle, dir_index }))
if Arc::ptr_eq(bundle, fb) =>
{
Some((*dir_index, Through::Own))
}
SlotKind::Dependency { dep } => {
let &[i] = slot.rank.path() else {
return None;
};
let same_handle = matches!(dep.alive(), Some(File::Bundle(b)) if Arc::ptr_eq(&b, fb));
let same_bytes = fb.parent().is_none()
&& matches!(&dep.source, Source::Bytes { data, .. }
if same_bytes(data, fb.source()));
(same_handle || same_bytes).then_some((i, Through::Own))
}
SlotKind::Ready(_) => None,
}
}
pub(super) fn stands_in(standing: &Slot, dropped: &Slot) -> bool {
if standing.rank.path() != dropped.rank.path() {
return false;
}
let (top, i) = match &dropped.kind {
SlotKind::Entry { bundle, dir_index } => (bundle.clone(), *dir_index),
SlotKind::Dependency { dep } => {
let (&[i], Some(File::Bundle(top))) = (dropped.rank.path(), dep.alive()) else {
return false;
};
(top, i)
}
SlotKind::Ready(_) => return false,
};
entry_of(&top, standing).is_some_and(|(j, _)| j == i)
}
fn same_input(one: &BundleFile, other: &BundleFile) -> bool {
one.parent().is_none() && other.parent().is_none() && same_bytes(one.source(), other.source())
}
fn same_bytes(data: &[u8], data2: &[u8]) -> bool {
data.as_ptr() == data2.as_ptr() && data.len() == data2.len()
}
enum Failed {
Read(Error),
Register(Error),
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum Reached {
Done,
Evicted,
}
enum Entry {
Container(File),
Nothing,
Evicted,
}
impl Registry {
pub(crate) fn reach(
&self,
slot: &Arc<Slot>,
nested: Option<&Arc<BundleFile>>,
) -> Result<(), Error> {
let reached = self.reach_one(slot, nested, true).map(|_| ());
self.settle().ok();
reached
}
fn reach_one(
&self,
slot: &Arc<Slot>,
nested: Option<&Arc<BundleFile>>,
reopen: bool,
) -> Result<Reached, Error> {
match &slot.kind {
SlotKind::Dependency { dep } => dep.with_room(|| self.reach_once(slot, nested, reopen)),
SlotKind::Entry { .. } | SlotKind::Ready(_) => self.reach_once(slot, nested, reopen),
}
}
fn reach_once(
&self,
slot: &Arc<Slot>,
nested: Option<&Arc<BundleFile>>,
reopen: bool,
) -> Result<Reached, Error> {
if !slot.unreached() {
return Ok(Reached::Done);
}
let parsed = match nested {
Some(_) => None,
None => match self.lazy_container(slot, reopen)? {
Entry::Container(b) => Some(b),
Entry::Nothing => None,
Entry::Evicted => return Ok(Reached::Evicted),
},
};
let supplied = nested.map(|b| File::Bundle(b.clone()));
let Some(nested) = supplied.as_ref().or(parsed.as_ref()) else {
slot.mark_reached();
return Ok(Reached::Done);
};
let mut at = slot.position();
self.register_counted(slot, nested, at)?;
while let Err(lower) = slot.close_at(at) {
at = lower;
self.register_counted(slot, nested, at)?;
}
#[cfg(test)]
self.hook(Hook::Reached);
slot.mark_reached();
Ok(Reached::Done)
}
fn lazy_container(&self, slot: &Slot, reopen: bool) -> Result<Entry, Error> {
let (bundle, i) = match &slot.kind {
SlotKind::Entry { bundle, dir_index } => (bundle.clone(), *dir_index),
SlotKind::Dependency { dep } => {
let &[i] = slot.rank.path() else {
return Ok(Entry::Nothing);
};
let top = if reopen {
dep.handle()?
} else {
let Some(top) = dep.alive() else {
return Ok(Entry::Evicted);
};
top
};
let File::Bundle(b) = top else {
return Ok(Entry::Nothing);
};
(b, i)
}
SlotKind::Ready(_) => return Ok(Entry::Nothing),
};
if !is_bundle_entry(&bundle, i)? {
return Ok(Entry::Nothing);
}
match bundle.entry(i) {
Ok(nested @ (File::Bundle(_) | File::Web(_))) => {
self.count(slot);
Ok(Entry::Container(nested))
}
Err(e) if e.is_transient() => Err(e),
Ok(_) | Err(_) => Ok(Entry::Nothing),
}
}
fn register_counted(&self, slot: &Slot, nested: &File, position: u64) -> Result<(), Error> {
let dep = match &slot.kind {
SlotKind::Dependency { dep } => Some(&**dep),
SlotKind::Entry { .. } | SlotKind::Ready(_) => None,
};
let meter = match dep {
Some(dep) => dep.meter(),
None => nested.meter().clone(),
};
if let Some(limit) = meter.work_refused() {
return Err(Error::Limit(limit));
}
let mut path = slot.rank.path().to_vec();
let loads = Loads {
value: slot.rank.load,
position,
};
let scope = GrantScope::enter(&meter);
let registered = self.register_tree(nested, dep, loads, &mut path, &meter);
let own = scope.finish(&meter);
if let Some(dep) = dep
&& let Some(cache) = dep.cache.upgrade()
{
cache.refresh(dep);
}
match registered {
Ok(()) => Ok(()),
Err(Failed::Register(e)) if e.is_meter_refusal() => {
meter.add_work(own);
Err(meter.work_refused().map_or(e, Error::Limit))
}
Err(Failed::Register(e) | Failed::Read(e)) => Err(e),
}
}
pub(crate) fn reach_web(
&self,
slot: &Arc<Slot>,
web: &Arc<crate::files::WebFile>,
) -> Result<(), Error> {
if !slot.unreached() {
return Ok(());
}
let file = File::Web(web.clone());
let mut at = slot.position();
self.register_counted(slot, &file, at)?;
while let Err(lower) = slot.close_at(at) {
at = lower;
self.register_counted(slot, &file, at)?;
}
slot.mark_reached();
self.settle().ok();
Ok(())
}
fn register_tree(
&self,
nested: &File,
dep: Option<&Arc<Dependency>>,
loads: Loads,
path: &mut Vec<usize>,
meter: &Arc<Meter>,
) -> Result<(), Failed> {
for (j, d) in nested.container_directory().iter().enumerate() {
path.push(j);
let r = self.register_tree_entry(nested, j, &d.path, dep, loads, path, meter);
path.pop();
r?;
}
Ok(())
}
#[allow(clippy::too_many_arguments)]
fn register_tree_entry(
&self,
nested: &File,
j: usize,
name: &crate::raw::RawStr,
dep: Option<&Arc<Dependency>>,
loads: Loads,
path: &mut Vec<usize>,
meter: &Arc<Meter>,
) -> Result<(), Failed> {
let inspect = match nested {
File::Bundle(b) => is_bundle_entry(b, j).map_err(Failed::Read)?,
File::Web(_) => true,
_ => false,
};
if inspect {
match nested.container_entry(j) {
Ok(inner @ (File::Bundle(_) | File::Web(_))) => {
self.parsed.fetch_add(1, Ordering::Relaxed);
return self.register_tree(&inner, dep, loads, path, meter);
}
Err(e) if e.is_transient() => return Err(Failed::Read(e)),
Ok(_) | Err(_) => {}
}
}
let kind = match dep {
Some(dep) => SlotKind::Dependency {
dep: DepSlot::new(dep),
},
None => match nested {
File::Bundle(b) => SlotKind::Entry {
bundle: b.clone(),
dir_index: j,
},
File::Web(w) => match w.entry(j).map_err(Failed::Read)? {
File::Serialized(sf) => SlotKind::Ready(Cab::Serialized(sf)),
File::Raw(raw) => SlotKind::Ready(Cab::Raw(RawCab::File(raw))),
_ => return Ok(()),
},
_ => return Ok(()),
},
};
self.insert(name, kind, loads, path, meter, By::Reach, false)
.map_err(Failed::Register)
}
fn listed_after(
&self,
list: List,
after: Option<u64>,
charge_to: Option<&Slot>,
) -> Option<(u64, Arc<Slot>)> {
let (found, steps) = self.read().pending.after(list, after);
let payer = charge_to.or(found.as_ref().map(|(_, s)| &**s));
if let Some(payer) = payer {
payer.input_meter().add_work(steps.saturating_mul(STEP));
}
found
}
pub(super) fn unlist(&self, list: List, seq: u64, slot: &Slot) {
let (taken, steps) = {
let mut inner = self.write();
let out = inner.pending.take(list, seq);
self.store_lens(&inner.pending);
out
};
drop(taken);
slot.input_meter().add_work(steps.saturating_mul(STEP));
}
fn defer(&self, seq: u64, slot: &Slot) {
let steps = {
let mut inner = self.write();
let steps = inner.pending.defer(seq);
self.store_lens(&inner.pending);
steps
};
slot.input_meter().add_work(steps.saturating_mul(STEP));
}
pub(super) fn evicted_waiting(&self) -> bool {
self.evicted_len.load(Ordering::Acquire) > 0
}
pub(crate) fn settle(&self) -> Result<(), Error> {
let mut refused = None;
if self.pending_len.load(Ordering::Acquire) > 0 {
self.settle_list(List::Listed, false, &mut refused);
}
refused.map_or(Ok(()), Err)
}
pub(crate) fn settle_for_pass(&self) -> Result<(), Error> {
let mut refused = None;
if self.pending_len.load(Ordering::Acquire) > 0 {
self.settle_list(List::Listed, true, &mut refused);
}
if self.evicted_waiting() {
self.settle_list(List::Evicted, true, &mut refused);
}
refused.map_or(Ok(()), Err)
}
fn settle_list(&self, list: List, reopen: bool, refused: &mut Option<Error>) {
let mut after = None;
let mut prev: Option<Arc<Slot>> = None;
while let Some((seq, slot)) = self.listed_after(list, after, prev.as_deref()) {
after = Some(seq);
#[cfg(test)]
self.hook(Hook::SettleTook);
match self.reach_one(&slot, None, reopen) {
Ok(Reached::Done) => self.unlist(list, seq, &slot),
Ok(Reached::Evicted) => self.defer(seq, &slot),
Err(e) if e.is_transient() => {
refused.get_or_insert(e);
}
Err(_) => {
slot.mark_reached();
self.unlist(list, seq, &slot);
}
}
prev = Some(slot);
}
}
}
#[cfg(test)]
mod detection_tests {
use super::*;
use crate::budget::{AllocError, Reservation};
#[test]
fn allocator_detection_failures_are_returned() {
let a = AllocError {
requested: 65536,
what: Reservation::Dependency,
};
assert_eq!(
bundle_detected(Err(a.into())),
Err(Error::Detect(DetectError::Allocator(a)))
);
}
#[test]
fn ordinary_detection_errors_and_non_bundles_register_nothing() {
assert_eq!(bundle_detected(Err(DetectError::Unterminated)), Ok(false));
assert_eq!(bundle_detected(Ok(FileType::ResourceFile)), Ok(false));
assert_eq!(bundle_detected(Ok(FileType::BundleFile)), Ok(true));
}
}