Readers never wait: one head per handle, retry on a miss, retire before deleting 767ac6cd0545

        // The head as it is now, as the operations pass reads it.

        self.forget_head();

use crate::store::{PackReport, PruneReport, RetiredReport};

    /// Packs and loose objects earlier repacks retired, deleted now that

    /// [`crate::store::RETIRED_FOR`] has passed (oxygenhub#249).

    pub retired: RetiredReport,

    /// Delete what earlier repacks retired more than

    /// [`crate::store::RETIRED_FOR`] ago, prune unreachable objects older

    /// than the grace period (`now` ignores it, but not the retired

    /// files' hour), then repack everything into one pack (spec §13.4).

    /// The packs and loose objects this repack replaces are retired in

    /// turn, for the next collection.

        // Retired files first: the readers that used them have had their

        // hour, and what replaced them is in the packs read from here on.

        let retired = self

            .store

            .expire_retired(crate::store::RETIRED_FOR, progress)?;

            retired,

        host.refresh().unwrap();

        host.refresh().unwrap();

        // the environment's `OXY_HOME` may have moved since), which reads

        // the head again to see the agent's commit.

        user.refresh().unwrap();

        host.refresh().unwrap();

    /// The operation head this handle reads (oxygenhub#249): read once, on

    /// first use, and moved only by this handle's own operations or by

    /// [`Repo::refresh`], so one command or request never mixes two heads.

    head_seen: std::cell::Cell<Option<ObjectRef>>,

            head_seen: Default::default(),

            head_seen: Default::default(),

                    head_seen: Default::default(),

                    head_seen: Default::default(),

    /// Pack automatically once many loose objects have accumulated, and

    /// delete what packing retired over [`crate::store::RETIRED_FOR`] ago

    /// (a store nobody runs `oxy gc` on would keep both copies forever).

        self.store

            .expire_retired(crate::store::RETIRED_FOR, &mut |_| {})?;

    /// The operation head this handle reads: the one it first read, or

    /// the last one it moved the head to (see [`Repo::refresh`]).

        if let Some(r) = self.head_seen.get() {

            return Ok(r);

        }

        let r = self.read_head()?.0;

        self.head_seen.set(Some(r));

        Ok(r)

    }

    /// Read the operation head again: what another process or handle

    /// recorded since this handle first read it becomes visible. A handle

    /// keeps the head it first read for the rest of its life otherwise,

    /// so whatever it reads comes from one view (oxygenhub#249); a loop

    /// that waits for others' operations, or a step that must see what

    /// another handle just recorded, refreshes. Packs written since are

    /// picked up too.

    pub fn refresh(&self) -> Result<()> {

        self.forget_head();

        self.store.refresh()?;

        Ok(())

    }

    /// Read the operation head again on next use, as [`Repo::refresh`]

    /// does, leaving the packs as they are.

    pub(crate) fn forget_head(&self) {

        self.head_seen.set(None);

            self.head_seen.set(Some(*to));

            Ok(_) => {

                self.head_seen.set(Some(*to));

                Ok(true)

            }

            // Another process may have brought the mirror level since this

            // handle read its head.

            mirror.refresh()?;

        // Updates are checked against the head as it is now, not as this

        // handle first read it (oxygenhub#249): another push may have

        // landed since.

        self.refresh()?;

    origin.refresh().unwrap();

    origin.refresh().unwrap();

    origin.refresh().unwrap();

    origin.refresh().unwrap();

    origin.refresh().unwrap();

    origin.refresh().unwrap();

    origin.refresh().unwrap();

    origin.refresh().unwrap();

    origin.refresh().unwrap();

    origin.refresh().unwrap();

    origin.refresh().unwrap();

    origin.refresh().unwrap();

    origin.refresh().unwrap();

    origin.refresh().unwrap();

    origin.refresh().unwrap();

    origin.refresh().unwrap();

    origin.refresh().unwrap();

    origin.refresh().unwrap();

    origin.refresh().unwrap();

    origin.refresh().unwrap();

    repo.refresh().unwrap();

    origin.refresh().unwrap();

    origin.refresh().unwrap();

    origin.refresh().unwrap();

    origin.refresh().unwrap();

    origin.refresh().unwrap();

    origin.refresh().unwrap();

    origin.refresh().unwrap();

    origin.refresh().unwrap();

    origin.refresh().unwrap();

    origin.refresh().unwrap();

    origin.refresh().unwrap();

        origin.refresh().unwrap();

    origin.refresh().unwrap();

    origin.refresh().unwrap();

    origin.refresh().unwrap();

    origin.refresh().unwrap();

    origin.refresh().unwrap();

    origin.refresh().unwrap();

    origin.refresh().unwrap();

    a.refresh().unwrap();

    b.refresh().unwrap();

/// oxygenhub#249: a handle reads the operation head once and keeps it,

/// so one command or request never mixes two heads; another handle's

/// operation shows only after `refresh`. Its own operations move it, and

/// one recorded from the head it kept merges with what landed since, as

/// any concurrent operation does.

#[test]

fn one_handle_keeps_one_head_until_it_refreshes() {

    hermetic();

    let dir = tempfile::tempdir().unwrap();

    let root = dir.path();

    let writer = Repo::init(root).unwrap();

    write(root, "a.txt", b"one\n");

    let h1 = writer.commit("one", &[]).unwrap();

    let reader = Repo::open(root).unwrap();

    let before = reader.view().unwrap();

    assert_eq!(reader.bookmark_heads().unwrap(), vec![h1]);

    write(root, "a.txt", b"two\n");

    let h2 = writer.commit("two", &[]).unwrap();

    assert_eq!(

        writer.bookmark_heads().unwrap(),

        vec![h2],

        "its own operation"

    );

    assert_eq!(reader.view().unwrap(), before, "the head it read first");

    assert_eq!(reader.bookmark_heads().unwrap(), vec![h1]);

    reader.refresh().unwrap();

    assert_eq!(reader.bookmark_heads().unwrap(), vec![h2]);

    // A handle recording from an older head merges with the newer one.

    let stale = Repo::open(root).unwrap();

    assert_eq!(stale.bookmark_heads().unwrap(), vec![h2]);

    write(root, "a.txt", b"three\n");

    let h3 = writer.commit("three", &[]).unwrap();

    stale.bookmark_create("feature", Some(&[h1])).unwrap();

    let view = stale.view().unwrap();

    assert!(view.bookmarks.contains_key("feature"));

    assert_eq!(

        stale.bookmark_heads().unwrap(),

        vec![h3],

        "merged, not lost"

    );

    let fresh = Repo::open(root).unwrap();

    assert_eq!(fresh.view().unwrap(), view);

}

/// oxygenhub#249 over a store (a bucket's compare-and-swap): the same.

#[test]

fn over_a_store_one_handle_keeps_one_head() {

    hermetic();

    let backend = std::sync::Arc::new(crate::strata::MemoryStore::new());

    crate::store::TEST_BACKEND.with(|t| *t.borrow_mut() = Some(backend.clone()));

    let dir = tempfile::tempdir().unwrap();

    let a = Repo::init(dir.path()).unwrap();

    let (h0, _) = a.head_op().unwrap();

    let b = Repo::open(dir.path()).unwrap();

    assert_eq!(b.head_op().unwrap().0, h0);

    let state = a.store.put_state(&StateObject::new(vec![])).unwrap();

    let mut view = a.view().unwrap();

    view.bookmarks.insert("x".into(), state);

    let r = a.record_op(&[h0], "bookmark x", view).unwrap();

    assert_eq!(a.head_op().unwrap().0, r);

    assert_eq!(b.head_op().unwrap().0, h0, "b keeps its head");

    b.refresh().unwrap();

    assert_eq!(b.head_op().unwrap().0, r);

    crate::store::TEST_BACKEND.with(|t| *t.borrow_mut() = None);

}

/// oxygenhub#249: gc retires what it repacks rather than deleting it; a

/// reader opened before reads on, then and after the next gc deletes the

/// retired files once their hour is up. Younger ones are kept.

#[test]

fn gc_retires_and_a_later_gc_deletes_after_the_hour() {

    hermetic();

    let dir = tempfile::tempdir().unwrap();

    let root = dir.path();

    let repo = Repo::init(root).unwrap();

    let mut heads = Vec::new();

    for i in 0..4 {

        write(root, &format!("f{i}.txt"), format!("{i}\n").as_bytes());

        heads.push(repo.commit(&format!("c{i}"), &[]).unwrap());

    }

    let reader = Repo::open(root).unwrap();

    assert_eq!(reader.log().unwrap().len(), 5);

    let r = repo.gc(true).unwrap();

    assert_eq!(r.retired, crate::store::RetiredReport::default());

    assert_eq!(repo.store().loose_count().unwrap(), 0);

    assert_eq!(reader.log().unwrap().len(), 5, "read on from what it had");

    // Nothing is an hour old yet: a gc keeps it all.

    let r = repo.gc(true).unwrap();

    assert_eq!((r.retired.packs, r.retired.loose), (0, 0));

    assert!(r.retired.kept > 0, "{r:?}");

    write(root, "f9.txt", b"9\n");

    heads.push(repo.commit("c9", &[]).unwrap());

    crate::store::reader_tests::age_retired(

        repo.store(),

        crate::store::RETIRED_FOR + std::time::Duration::from_secs(60),

    );

    let r = repo.gc(true).unwrap();

    assert!(r.retired.packs >= 1 && r.retired.loose > 0, "{r:?}");

    assert_eq!(r.retired.kept, 0, "{r:?}");

    let r = repo.gc(true).unwrap();

    assert_eq!((r.retired.packs, r.retired.loose), (0, 0));

    assert!(r.retired.kept > 0, "what the last gc retired is young");

    // The reader opened before all of it still reads everything, from

    // the packs it finds when what it loaded is gone.

    assert_eq!(reader.log().unwrap().len(), 5);

    for h in &heads[..4] {

        reader.store().get_change(h).unwrap();

    }

    reader.refresh().unwrap();

    assert_eq!(reader.log().unwrap().len(), 6);

    let fresh = Repo::open(root).unwrap();

    assert_eq!(

        fresh.store().pack_count(),

        1,

        "retired packs are not loaded"

    );

}

/// oxygenhub#249: a repository opens when its store's pack listing names

/// an index that is not there (deleted between the listing and the read).

#[test]

fn a_repository_opens_when_a_listed_index_is_gone() {

    hermetic();

    let backend = crate::store::reader_tests::racing(true);

    let dyn_backend: std::sync::Arc<crate::store::Backend> = backend.clone();

    crate::store::TEST_BACKEND.with(|t| *t.borrow_mut() = Some(dyn_backend));

    let dir = tempfile::tempdir().unwrap();

    let repo = Repo::init(dir.path()).unwrap();

    write(dir.path(), "a.txt", b"a\n");

    let h = repo.commit("a", &[]).unwrap();

    repo.gc(true).unwrap();

    let again = Repo::open(dir.path()).unwrap();

    assert_eq!(again.store().pack_count(), 1);

    assert_eq!(again.bookmark_heads().unwrap(), vec![h]);

    // And when one is deleted between the listing and the read: a copy of

    // the live pack, whose index goes as the store opens.

    use crate::strata::Store as _;

    let idx = backend

        .list("pack-")

        .unwrap()

        .into_iter()

        .map(|e| e.key)

        .find(|k| k.ends_with(".idx") && k != "pack-0000.idx")

        .unwrap();

    let stem = idx.trim_end_matches(".idx");

    for ext in ["pack", "idx"] {

        let bytes = backend.get(&format!("{stem}.{ext}")).unwrap();

        backend

            .put_new(&format!("pack-copy.{ext}"), &bytes)

            .unwrap();

    }

    *backend.doomed.lock().unwrap() = Some("pack-copy.idx".into());

    let again = Repo::open(dir.path()).unwrap();

    assert_eq!(again.store().pack_count(), 1);

    assert_eq!(again.bookmark_heads().unwrap(), vec![h]);

    assert!(!backend.has("pack-copy.idx").unwrap());

    crate::store::TEST_BACKEND.with(|t| *t.borrow_mut() = None);

}

        // Whoever held the lock may have moved the operation head: what

        // is done under it starts from the head as it is now (oxygenhub#249).

        self.forget_head();

//! `pack-retired` records the packs and loose objects a repack replaced,

//! which stay for readers until a collection an hour later (oxygenhub#249).

/// What reading an entry of a pack whose dictionary is gone says. A pack

/// being deleted can lose its dictionary first, so a read that meets this

/// looks at the packs again before it is believed.

const NO_DICT: &str = "packed with a dictionary the pack lacks";

/// The record of what repacks replaced (oxygenhub#249): packs and loose

/// objects whose contents a newer pack holds, kept for readers that

/// still use them until garbage collection deletes them, at least

/// [`RETIRED_FOR`] later. One line per key, `<retired at, wall ms> <key>`.

/// It is a reference record (updated by compare-and-swap, so concurrent

/// repacks and collections never lose each other's lines), named under

/// `pack-` so the pack listing every open makes shows whether it holds

/// anything.

const RETIRED_KEY: &str = "pack-retired";

/// How long a retired pack or loose object stays in the store: a reader

/// that loaded its list of packs before a repack reads on from the old

/// packs this long, and after that finds the objects in the new pack by

/// looking again (see [`Store::get`]).

pub const RETIRED_FOR: std::time::Duration = std::time::Duration::from_secs(60 * 60);

/// Compare-and-swap rounds for the retired record before giving up.

const RETIRED_TRIES: usize = 32;

/// After a look at the pack listing found nothing new, how long a missed

/// [`Store::has`] answers without looking again: a writer probing for

/// thousands of objects it is about to store would otherwise list the

/// packs for each.

const HAS_RELIST_AFTER: std::time::Duration = std::time::Duration::from_secs(1);

/// A pack listing as compared: each key with its size and time.

type Listed = Vec<(String, u64, Option<u64>)>;

/// The retired record's lines: each key with the time it was retired.

fn parse_retired(bytes: &[u8]) -> std::collections::BTreeMap<String, u64> {

    String::from_utf8_lossy(bytes)

        .lines()

        .filter_map(|l| {

            let (t, k) = l.split_once(' ')?;

            Some((k.to_string(), t.parse().ok()?))

        })

        .collect()

}

fn encode_retired(m: &std::collections::BTreeMap<String, u64>) -> Vec<u8> {

    m.iter()

        .map(|(k, t)| format!("{t} {k}\n"))

        .collect::<String>()

        .into_bytes()

}

/// What deleting retired packs and loose objects did.

#[derive(Debug, Clone, Default, PartialEq, Eq)]

pub struct RetiredReport {

    /// Retired packs deleted, each with its index and dictionary.

    pub packs: usize,

    /// Retired loose objects deleted.

    pub loose: usize,

    /// Retired entries younger than [`RETIRED_FOR`], left for the next

    /// collection.

    pub kept: usize,

}

        let dict = dict.ok_or_else(|| StoreError::Corrupt(*r, NO_DICT.into()))?;

    /// that found it (a stat of it would be a request of its own). `None`

    /// when the index is gone since the listing: the pack was deleted.

    fn load(

        backend: &Backend,

        idx_key: &str,

        pack_key: &str,

        pack_len: u64,

    ) -> Result<Option<PackIndex>> {

        let data = match backend.get(idx_key) {

            Ok(d) => d,

            Err(BackendError::NotFound(_)) => return Ok(None),

            Err(e) => return Err(backend_err(e)),

        };

        Ok(Some(PackIndex {

        }))

    packs: RefCell<Vec<Arc<PackIndex>>>,

    /// The pack listing `packs` was loaded from (key, size, time), to tell

    /// whether a look at the store would find anything new.

    packs_listed: RefCell<Listed>,

    /// When a look at the pack listing for a missed [`Store::has`] last

    /// found nothing new.

    has_relisted: std::cell::Cell<Option<std::time::Instant>>,

            packs_listed: RefCell::new(Vec::new()),

            has_relisted: std::cell::Cell::new(None),

    }

    /// Load the list of packs again, from a new listing: what other

    /// writers packed since becomes readable, and packs since retired or

    /// deleted are let go. Packs already loaded are kept, not read again.

    pub fn refresh(&self) -> Result<()> {

        self.reload_packs()

    }

    /// The pack listing, with how `packs_listed` records it.

    fn list_packs(&self) -> Result<(Vec<strata::Entry>, Listed)> {

        let listed = self.backend.list("pack-").map_err(backend_err)?;

        let sig = listed

            .iter()

            .map(|e| (e.key.clone(), e.size, e.modified_ms))

            .collect();

        Ok((listed, sig))

    /// Load every pack the listing names that is not retired. An index

    /// that is gone by the time it is read (its pack deleted after the

    /// listing) is passed over, and the store listed once more, since

    /// what replaced it may be new since the first listing.

        let (listed, sig) = self.list_packs()?;

        self.load_listed(listed, sig)

    }

    fn load_listed(&self, mut listed: Vec<strata::Entry>, mut sig: Listed) -> Result<()> {

        let had: std::collections::HashMap<String, Arc<PackIndex>> = self

            .packs

            .borrow()

            .iter()

            .map(|p| (p.key.clone(), p.clone()))

            .collect();

        let mut loaded: std::collections::HashMap<String, Arc<PackIndex>> = Default::default();

        for attempt in 0..2 {

            let retired = self.retired_in(&listed)?;

            let mut idx_keys: Vec<&str> = listed

                .iter()

                .map(|e| e.key.as_str())

                .filter(|k| k.ends_with(".idx"))

                .collect();

            idx_keys.sort();

            let mut packs = Vec::new();

            let mut vanished = false;

            for idx in idx_keys {

                let pack = format!("{}.pack", idx.trim_end_matches(".idx"));

                if retired.contains_key(&pack) {

                    continue;

                }

                let Some(p) = listed.iter().find(|e| e.key == pack) else {

                    continue;

                };

                if let Some(kept) = had.get(&pack).or_else(|| loaded.get(&pack)) {

                    packs.push(kept.clone());

                    continue;

                }

                match PackIndex::load(self.backend.as_ref(), idx, &pack, p.size)? {

                    Some(index) => {

                        let index = Arc::new(index);

                        loaded.insert(pack, index.clone());

                        packs.push(index);

                    }

                    None => vanished = true,

                }

            }

            if vanished && attempt == 0 {

                (listed, sig) = self.list_packs()?;

                continue;

            }

            *self.packs.borrow_mut() = packs;

            *self.packs_listed.borrow_mut() = sig;

            return Ok(());

        }

        unreachable!("the second round always returns")

    }

    /// Load the packs again when the pack listing differs from the one

    /// they were loaded from; whether it did. What a miss calls before it

    /// is believed (oxygenhub#249): another writer may have packed the

    /// object, or a repack moved it, since this store loaded its packs.

    fn reload_if_changed(&self) -> Result<bool> {

        let (listed, sig) = self.list_packs()?;

        if *self.packs_listed.borrow() == sig {

            return Ok(false);

        }

        self.load_listed(listed, sig)?;

        Ok(true)

    }

    /// The retired record, read when `listed` (a pack listing) shows it

    /// holds anything.

    fn retired_in(

        &self,

        listed: &[strata::Entry],

    ) -> Result<std::collections::BTreeMap<String, u64>> {

        match listed.iter().find(|e| e.key == RETIRED_KEY) {

            Some(e) if e.size > 0 => Ok(self.read_retired()?.0),

            _ => Ok(Default::default()),

        }

    }

    /// The retired record and its version (`None`: never written).

    fn read_retired(

        &self,

    ) -> Result<(

        std::collections::BTreeMap<String, u64>,

        Option<strata::Version>,

    )> {

        match self.backend.read_ref(RETIRED_KEY).map_err(backend_err)? {

            Some((bytes, v)) => Ok((parse_retired(&bytes), Some(v))),

            None => Ok((Default::default(), None)),

        }

    }

    /// Change the retired record by compare-and-swap, reading it again

    /// whenever another writer changed it first. `edit` must give the

    /// same result however often it runs.

    fn update_retired(

        &self,

        mut edit: impl FnMut(&mut std::collections::BTreeMap<String, u64>),

    ) -> Result<()> {

        for _ in 0..RETIRED_TRIES {

            let (mut m, version) = self.read_retired()?;

            let before = m.clone();

            edit(&mut m);

            if m == before && version.is_some() {

                return Ok(());

            }

            match self

                .backend

                .write_ref(RETIRED_KEY, &encode_retired(&m), version.as_ref())

            {

                Ok(_) => return Ok(()),

                Err(BackendError::Conflict(_)) => continue,

                Err(e) => return Err(backend_err(e)),

            }

        }

        Err(StoreError::Io(io::Error::other(

            "other writers kept changing the record of retired packs; run the command again",

        )))

    }

    /// Record `keys` (packs, by their `.pack` key, and loose objects) as

    /// retired now: kept for the readers still using them, and deleted by

    /// a collection at least [`RETIRED_FOR`] later. A key already retired

    /// keeps its first time.

    fn retire(&self, keys: &[String]) -> Result<()> {

        if keys.is_empty() {

            return Ok(());

        }

        let now = now_ms();

        self.update_retired(|m| {

            for k in keys {

                m.entry(k.clone()).or_insert(now);

            }

        })

    }

    /// Delete what was retired at least `older_than` ago (a collection

    /// does, with [`RETIRED_FOR`]): each pack with its index and

    /// dictionary, and each loose object a pack now holds. A retired loose

    /// object no pack holds any more (the pack that had it was pruned, and

    /// the object stored again since) is kept, as an ordinary loose object.

    pub fn expire_retired(

        &self,

        older_than: std::time::Duration,

        progress: Progress,

    ) -> Result<RetiredReport> {

        let (listed, _) = self.list_packs()?;

        let retired = self.retired_in(&listed)?;

        let mut report = RetiredReport::default();

        if retired.is_empty() {

            return Ok(report);

        }

        let now = now_ms();

        let older_than = older_than.as_millis() as u64;

        let due: Vec<(String, u64)> = retired

            .filter(|(_, t)| now.saturating_sub(**t) >= older_than)

            .map(|(k, t)| (k.clone(), *t))

        report.kept = retired.len() - due.len();

        if due.is_empty() {

            return Ok(report);

        }

        progress(&format!("deleting {} retired files", due.len()));

        // Which objects the live packs hold.

        self.reload_packs()?;

        for (key, _) in &due {

            if key.ends_with(".pack") {

                self.remove_pack(key)?;

                report.packs += 1;

            } else if let Some(r) = loose_ref(key) {

                if self.find_packed(&r).is_some() {

                    delete(self.backend.as_ref(), key)?;

                    report.loose += 1;

                }

        self.update_retired(|m| {

            for (k, t) in &due {

                if m.get(k) == Some(t) {

                    m.remove(k);

                }

            }

        })?;

        self.reload_packs()?;

        Ok(report)

    /// The loose objects retired and not yet deleted, by key.

    fn retired_loose(&self) -> Result<std::collections::HashSet<String>> {

        let (listed, _) = self.list_packs()?;

        Ok(self

            .retired_in(&listed)?

            .into_keys()

            .filter(|k| k.starts_with("loose/"))

            .collect())

    }

    /// Loose objects, with their keys and ages; not those retired, whose

    /// objects a pack holds.

        let retired = self.retired_loose()?;

        let mut out = self.loose_objects_all()?;

        out.retain(|(_, e)| !retired.contains(&e.key));

        Ok(out)

    }

    /// Every loose object, retired or not.

    fn loose_objects_all(&self) -> Result<Vec<(ObjectRef, strata::Entry)>> {

        // Loose objects. A retired one (its object packed) whose object is

        // unreachable goes with it, uncounted: the pack's copy is counted.

        let retired = self.retired_loose()?;

        let mut unretired: Vec<String> = Vec::new();

        for (r, entry) in self.loose_objects_all()? {

            if retired.contains(&entry.key) {

                if old_enough(entry.modified_ms) {

                    delete(self.backend.as_ref(), &entry.key)?;

                    unretired.push(entry.key);

                }

                continue;

            }

        }

        if !unretired.is_empty() {

            self.update_retired(|m| {

                for k in &unretired {

                    m.remove(k);

                }

            })?;

    /// Remove a pack with its index and dictionary: the index first, so

    /// a store opened meanwhile does not load a pack that is going.

        delete(self.backend.as_ref(), &format!("{stem}.idx"))?;

    /// Write `refs` into a new pack, then retire `loose_keys` and

    /// `old_packs`: they stay in the store, unused by stores opened from

    /// now on, until a collection [`RETIRED_FOR`] later deletes them, so a

    /// reader that loaded its packs before goes on reading (oxygenhub#249).

            self.retire(old_packs)?;

        let mut retired = old_packs.to_vec();

        retired.extend_from_slice(loose_keys);

        self.retire(&retired)?;

    /// Whether the store holds `r`. A miss looks at the pack listing

    /// again before it is believed, as [`Store::get`]'s does; a writer

    /// asking about many objects it is about to store looks at most once

    /// in [`HAS_RELIST_AFTER`] while nothing new turns up.

        if self.has_now(r) {

            return true;

        }

        let recent = self

            .has_relisted

            .get()

            .is_some_and(|t| t.elapsed() < HAS_RELIST_AFTER);

        if recent {

            return false;

        }

        match self.reload_if_changed() {

            Ok(true) => {

                self.has_relisted.set(None);

                self.has_now(r)

            }

            _ => {

                self.has_relisted.set(Some(std::time::Instant::now()));

                false

            }

        }

    }

    /// [`Store::has`] against the packs as loaded.

    fn has_now(&self, r: &ObjectRef) -> bool {

        self.find_packed(r).is_some()

            || self.backend.has(&loose_key(r)).unwrap_or(false)

    ///

    /// A miss is not believed at once (oxygenhub#249): when the pack it

    /// was in is gone (deleted after a repack retired it) the packs are

    /// loaded again, and when the object is nowhere the pack listing is

    /// looked at, and the packs loaded again if it changed (another

    /// writer packed it, or a repack moved it); then it is read once more.

        match self.get_now(r) {

            Err(e) if is_miss(&e) => {

                // Read from a pack this store loaded, which is gone.

                let packed_miss =

                    !matches!(e, StoreError::NotFound(_)) || self.find_packed(r).is_some();

                let changed = if packed_miss {

                    self.reload_packs()?;

                    true

                } else {

                    self.reload_if_changed()?

                };

                if changed {

                    self.get_now(r)