use std::collections::HashMap;
use std::fmt;
use std::mem::size_of;
use std::sync::Arc;
use std::sync::atomic::Ordering;
use super::deref::Reached;
use super::registry::{Rank, SlotKind, load_keys_here};
use super::revisit::Pending;
use super::watch::{FILES, Flag, REGISTRY, Walk};
use super::{Cab, DerefError, Environment, Found, LoadMode, PPtr, never_evicts, pptr};
use crate::budget::Reservation;
use crate::container::{Container, ContainerPath, ContainerRow};
use crate::error::{Error, Unsupported};
use crate::files::{BundleFile, File, SerializedFile};
use crate::limits::{Charge, GrantScope, HASH_TABLE_SHARES, Meter, MeteredVec};
use crate::object::ObjectRef;
use crate::once::CellError;
use crate::pystr::{clean_external_path, py_lower, simplify_name};
use crate::raw::RawStr;
use crate::walk::STEP_WORK;
pub struct ContainerItems<'a> {
env: &'a Environment,
after: Option<Rank>,
current: Option<(Arc<SerializedFile>, usize)>,
}
const _: () = crate::send_sync::<ContainerItems<'static>>();
impl Iterator for ContainerItems<'_> {
type Item = Result<ContainerItem, Error>;
fn next(&mut self) -> Option<Self::Item> {
loop {
if let Some((sf, k)) = self.current.take() {
match sf.container() {
Ok(c) => {
if let Some(row) = c.rows().get(k) {
let row = row.clone();
self.current = Some((sf.clone(), k + 1));
return Some(Ok(ContainerItem { row, file: sf }));
}
}
Err(e) => return Some(Err(e)),
}
}
let (rank, slot) = self.env.registry().slot_after(self.after.as_ref())?;
self.after = Some(rank);
if slot.is_dependency() {
continue;
}
match self.env.registry().resolve(&slot) {
Ok(Some(Cab::Serialized(sf))) => self.current = Some((sf, 0)),
Ok(_) => {}
Err(e) => return Some(Err(e)),
}
}
}
}
impl fmt::Debug for ContainerItems<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("ContainerItems").finish_non_exhaustive()
}
}
#[derive(Clone, Debug)]
pub struct ContainerItem {
pub row: ContainerRow,
pub file: Arc<SerializedFile>,
}
const _: () = crate::send_sync::<ContainerItem>();
#[derive(Default)]
pub(super) struct Siblings {
bundles: HashMap<usize, SiblingNames>,
}
struct SiblingNames {
_bundle: Arc<BundleFile>,
names: HashMap<RawStr, usize>,
_charge: Charge,
}
impl Siblings {
pub(super) fn find(
&mut self,
bundle: &Arc<BundleFile>,
clean: &RawStr,
) -> Result<Option<usize>, Error> {
let key = Arc::as_ptr(bundle).addr();
let entry = match self.bundles.entry(key) {
std::collections::hash_map::Entry::Occupied(o) => o.into_mut(),
std::collections::hash_map::Entry::Vacant(v) => {
let meter = bundle.meter();
let slots = bundle.files();
let n = u64::try_from(slots.len()).unwrap_or(u64::MAX);
let charge = meter.charge(
HASH_TABLE_SHARES
.saturating_mul((size_of::<RawStr>() + size_of::<usize>() + 1) as u64)
.saturating_mul(n.saturating_add(1)),
)?;
let mut names = HashMap::with_capacity(slots.len());
for s in slots {
names
.entry(py_lower(&s.name, meter)?)
.or_insert(s.dir_index);
}
v.insert(SiblingNames {
_bundle: bundle.clone(),
names,
_charge: charge,
})
}
};
Ok(entry.names.get(clean.as_bytes()).copied())
}
}
const TARGET_SHARE: u64 = HASH_TABLE_SHARES * (size_of::<i32>() + size_of::<Known>() + 1) as u64;
const NONE: usize = usize::MAX;
struct Targets<'a> {
known: HashMap<i32, Known>,
answers: MeteredVec<Answer>,
next: Option<MeteredVec<usize>>,
walk: Walk<'a>,
charge: Charge,
}
struct Known {
found: Option<Found>,
kept: bool,
flag: Option<Arc<Flag>>,
}
struct Answer {
head: usize,
}
fn reopen_work(pending: &Pending) -> u64 {
STEP_WORK.saturating_mul(1 + u64::try_from(pending.levels()).unwrap_or(u64::MAX))
}
impl Targets<'_> {
fn kept(&self, file_id: i32) -> Option<&Known> {
self.known
.get(&file_id)
.filter(|k| k.kept && k.flag.as_ref().is_none_or(|f| !f.changed()))
}
fn keep(
&mut self,
file_id: i32,
found: Option<Found>,
kept: bool,
flag: Option<Arc<Flag>>,
) -> Result<(), Error> {
if !self.known.contains_key(&file_id) {
self.charge.grow(TARGET_SHARE)?;
}
self.known.insert(file_id, Known { found, kept, flag });
Ok(())
}
fn link(&mut self, i: usize, id: usize, len: usize, meter: &Arc<Meter>) -> Result<(), Error> {
if self.next.is_none() {
let mut n = MeteredVec::with_capacity(meter, len)?;
for _ in 0..len {
n.push(NONE)?;
}
self.next = Some(n);
}
if let (Some(answer), Some(slot)) = (
self.answers.as_mut_slice().get_mut(id),
self.next.as_mut().and_then(|n| n.as_mut_slice().get_mut(i)),
) {
*slot = answer.head;
answer.head = i;
}
Ok(())
}
fn reopen(&mut self, pending: &mut Pending, meter: &Meter) -> Result<(), Error> {
let Self {
walk,
answers,
next,
..
} = self;
let links = next.as_ref().map(MeteredVec::as_slice);
for id in walk.fired() {
let Some(answer) = answers.as_mut_slice().get_mut(id) else {
continue;
};
let mut i = std::mem::replace(&mut answer.head, NONE);
while i != NONE {
meter.count_work(reopen_work(pending))?;
pending.insert(i);
i = links.and_then(|l| l.get(i)).copied().unwrap_or(NONE);
}
}
Ok(())
}
}
fn deref_error(e: DerefError) -> Error {
match e {
DerefError::Load(e) => e,
other => Error::Deref(Arc::new(other)),
}
}
impl Environment {
pub fn container(&self) -> Result<ContainerItems<'_>, Error> {
self.build_container_index()?;
Ok(ContainerItems {
env: self,
after: None,
current: None,
})
}
pub fn container_path(&self, obj: &ObjectRef) -> Result<Option<ContainerPath>, Error> {
let sf = obj.file();
if self.may_reopen(sf) {
return Err(Error::Unsupported(Unsupported::EvictableContainerPath));
}
self.build_container_index()?;
sf.container()?.path_of(obj.path_id(), sf.meter())
}
fn may_reopen(&self, sf: &SerializedFile) -> bool {
!never_evicts(&self.inner.options) && sf.meter().reservation() == Reservation::Dependency
}
fn build_container_index(&self) -> Result<(), Error> {
let reg = &self.inner.registry;
reg.settle().ok();
let generation = reg.generation();
if reg.built(generation) {
return Ok(());
}
let result = self.container_pass(generation);
if result.as_ref().err().is_none_or(|e| !e.is_transient()) {
reg.publish_built(generation);
}
result
}
fn walk_counted(
&self,
sf: &Arc<SerializedFile>,
container: &Container,
at: (u64, &Rank),
siblings: &mut Siblings,
) -> Result<(), Error> {
let meter = sf.meter();
let scope = GrantScope::enter(meter);
let walked = self.preload(sf, container, at, siblings);
let own = scope.finish(meter);
match walked {
Err(e) if e.is_meter_refusal() => {
meter.add_work(own);
Err(meter.work_refused().map_or(e, Error::Limit))
}
other => other,
}
}
fn container_pass(&self, generation: u64) -> Result<(), Error> {
let reg = &self.inner.registry;
let changed = || Error::Malformed {
what: "container",
detail: "dictionary changed size during iteration".into(),
};
if self.inner.options.load == LoadMode::Lazy {
let mut after: Option<Rank> = None;
while let Some((rank, slot)) = reg.slot_after(after.as_ref()) {
reg.reach(&slot, None)?;
after = Some(rank);
}
reg.settle_for_pass()?;
}
let mut siblings = Siblings::default();
let mut after: Option<Rank> = None;
let mut grew = false;
while let Some((rank, slot)) = reg.slot_after(after.as_ref()) {
if grew {
return Err(changed());
}
let Some(held) = reg.resolve_held(&slot)? else {
after = Some(rank);
continue;
};
let Cab::Serialized(sf) = &held.cab else {
after = Some(rank);
continue;
};
if !slot.walked() {
let before = load_keys_here();
let mut walk = || {
let container = sf.container()?;
self.walk_counted(sf, container, (generation, &rank), &mut siblings)
};
match &slot.kind {
SlotKind::Dependency { dep } => dep.with_room(walk)?,
SlotKind::Entry { .. } | SlotKind::Ready(_) => walk()?,
}
slot.set_walked();
grew = load_keys_here() != before;
}
after = Some(rank);
drop(held);
}
if grew {
return Err(changed());
}
Ok(())
}
fn preload(
&self,
sf: &Arc<SerializedFile>,
container: &Container,
at: (u64, &Rank),
siblings: &mut Siblings,
) -> Result<(), Error> {
if matches!(container.preload_table(), Ok(None)) {
return Ok(());
}
let malformed = |detail: &'static str| Error::Malformed {
what: "container",
detail: detail.into(),
};
let meter = sf.meter();
let mut pending: Option<Pending> = None;
let mut targets = Targets {
known: HashMap::new(),
answers: MeteredVec::new(meter),
next: None,
walk: self
.inner
.registry
.watches()
.start(meter, [&self.inner.registry, &self.inner.files]),
charge: Charge::zero(meter),
};
for (r, row) in container.rows().iter().enumerate() {
let (Some(start), Some(size)) = (row.preload_index, row.preload_size) else {
return Err(malformed("an AssetInfo index is not an int"));
};
if start < 0 || size <= 0 {
continue;
}
let table = container.preload_table()?.unwrap_or_default();
if start + size > i128::try_from(table.len()).unwrap_or(i128::MAX) {
continue;
}
let (Ok(s), Ok(e)) = (usize::try_from(start), usize::try_from(start + size)) else {
continue;
};
let pending = match &mut pending {
Some(u) => u,
None => pending.insert(Pending::full(table.len(), meter)?),
};
let mut path: Option<Option<RawStr>> = None;
let mut from = s;
loop {
#[cfg(test)]
self.inner.registry.hook(super::registry::Hook::Search {
row: r,
index: from,
});
targets.reopen(pending, meter)?;
let Some(j) = pending.first_from(from).filter(|&j| j < e) else {
break;
};
pending.remove(j);
from = j.saturating_add(1);
#[cfg(test)]
self.inner
.registry
.hook(super::registry::Hook::Step { row: r, index: j });
let Some(p) = table.get(j).copied().flatten() else {
return Err(malformed("a preload table element is not a pointer"));
};
if !p.is_set() {
continue;
}
self.inner.preload_derefs.fetch_add(1, Ordering::Relaxed);
let (target, answer) = self.preload_target(sf, p, &mut targets, siblings)?;
if let Some(id) = answer {
targets.link(j, id, table.len(), meter)?;
}
if let Some(target) = target
&& !self.may_reopen(target.file())
{
let tf = target.file();
let path = match &path {
Some(p) => p.clone(),
None => path
.insert(
row.path
.as_ref()
.map(|p| RawStr::charged(p.as_bytes(), meter))
.transpose()?,
)
.clone(),
};
let stamp = (
at.0,
at.1.clone(),
u32::try_from(r).unwrap_or(u32::MAX),
u32::try_from(j).unwrap_or(u32::MAX),
);
tf.container()?
.set_default(p.path_id, path.as_ref(), &stamp, tf.meter())?;
}
}
}
Ok(())
}
fn preload_target(
&self,
sf: &Arc<SerializedFile>,
p: PPtr,
targets: &mut Targets,
siblings: &mut Siblings,
) -> Result<(Option<ObjectRef>, Option<usize>), Error> {
let (found, answer) = if p.file_id == 0 {
(Some(Found::File(File::Serialized(sf.clone()))), None)
} else if let Some(k) = targets.kept(p.file_id) {
(k.found.clone(), k.flag.as_ref().map(|f| f.id()))
} else {
if targets.known.contains_key(&p.file_id) {
let bytes = Self::external_path(sf, p.file_id).map_or(0, <[u8]>::len);
sf.meter().count_work(
STEP_WORK.saturating_add(u64::try_from(bytes).unwrap_or(u64::MAX)),
)?;
}
self.inner.preload_lookups.fetch_add(1, Ordering::Relaxed);
let keys = Self::lookup_keys(sf, p.file_id, &targets.walk)?;
targets.answers.reserve(1)?;
let flag = targets.walk.watch(&keys)?;
let id = flag.id();
targets.answers.push(Answer { head: NONE })?;
#[cfg(test)]
self.inner.registry.hook(super::registry::Hook::Watched);
let (found, kept, flag) = match self.external(sf, p.file_id, Some(siblings), None) {
Ok((t, Reached::Sibling)) => (Some(t), true, None),
Ok((t, Reached::Lookup)) => (Some(t), true, Some(flag)),
Ok((t, Reached::Load)) => (Some(t), false, Some(flag)),
Err(DerefError::FileIdPastEnd { .. }) => (None, true, None),
Err(DerefError::NotFound { .. }) => (None, true, Some(flag)),
Err(e) => return Err(deref_error(e)),
};
let answer = flag.is_some().then_some(id);
targets.keep(p.file_id, found.clone(), kept, flag)?;
(found, answer)
};
let Some(found) = found else {
return Ok((None, answer));
};
match Self::object_of(&found, p.path_id) {
Ok(o) => Ok((Some(o), answer)),
Err(DerefError::MissingObject { .. }) => Ok((None, answer)),
Err(e) => Err(deref_error(e)),
}
}
fn external_path(sf: &SerializedFile, file_id: i32) -> Option<&[u8]> {
let externals = sf.externals();
pptr::external_index(file_id, externals.len())
.ok()
.and_then(|i| externals.get(i))
.map(|e| e.path.as_bytes())
}
fn lookup_keys(
sf: &SerializedFile,
file_id: i32,
walk: &Walk,
) -> Result<Vec<(usize, u64)>, Error> {
let externals = sf.externals();
let Some(external) = pptr::external_index(file_id, externals.len())
.ok()
.and_then(|i| externals.get(i))
else {
return Ok(Vec::new());
};
let meter = sf.meter();
let clean = clean_external_path(&external.path, meter)?;
let simple = simplify_name(&simplify_name(&clean, meter)?, meter)?;
let mut keys = vec![(REGISTRY, walk.hash(simple.as_bytes()))];
if sf.parent().is_none() {
keys.push((FILES, walk.hash(clean.as_bytes())));
}
Ok(keys)
}
}
#[cfg(test)]
mod drop_tests;