Store: a cache of change metadata (refs #41) ce14f0d68b15

#[test]

fn the_metadata_cache_survives_a_torn_tail() {

    hermetic();

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

    let root = dir.path();

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

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

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

    let meta = repo.store().get_change_meta(&h).unwrap();

    let cache = repo.store().dir().join("metas");

    let len = fs::metadata(&cache).unwrap().len();

    assert!(len > 0, "a change read is cached");

    // A torn record at the end: the cache reads up to it and cuts it off.

    fs::OpenOptions::new()

        .append(true)

        .open(&cache)

        .unwrap()

        .write_all(&[7; 20])

        .unwrap();

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

    assert_eq!(again.store().get_change_meta(&h).unwrap(), meta);

    assert_eq!(fs::metadata(&cache).unwrap().len(), len);

}

    /// In the flat layout of local indexes and caches ([`crate::flat`]).

    pub(crate) fn write_flat(&self, w: &mut crate::flat::Writer) {

        w.fixed(&self.change_id.0);

        w.count(self.deps.len());

        for d in &self.deps {

            w.object(d);

        }

        w.object(&self.author);

        w.u64(self.hlc.wall_ms);

        w.u32(self.hlc.logical);

        w.bytes(self.message.as_bytes());

        w.u8(self.kind.tag() as u8);

    }

    pub(crate) fn read_flat(r: &mut crate::flat::Reader) -> Result<ChangeMeta, ObjectError> {

        let change_id = crate::ids::ChangeId(r.fixed::<16>()?);

        let mut deps = Vec::new();

        for _ in 0..r.count()? {

            deps.push(r.object()?);

        }

        Ok(ChangeMeta {

            change_id,

            deps,

            author: r.object()?,

            hlc: Hlc {

                wall_ms: r.u64()?,

                logical: r.u32()?,

            },

            message: r.text()?,

            kind: ChangeKind::from_tag(r.u8()? as u64)?,

        })

    }

            m.write_flat(&mut w);

            changes.insert(h, Arc::new(ChangeMeta::read_flat(&mut r)?));

    /// Change metadata already read, from the `metas` cache file.

    metas: RefCell<Option<crate::fasthash::FastMap<ObjectRef, crate::state::ChangeMeta>>>,

            metas: RefCell::new(None),

    ///

    /// Served from the `metas` cache when this store read it before (a

    /// change object can be as large as the tree it adds), as long as the

    /// store still has the change.

        if self.metas.borrow().is_none() {

            *self.metas.borrow_mut() = Some(self.read_metas_cache());

        }

        let cached = self.metas.borrow().as_ref().and_then(|m| m.get(r).cloned());

        if let Some(meta) = cached {

            if self.has(r) {

                #[cfg(test)]

                assert_eq!(

                    meta,

                    Change::decode_meta(&self.get_typed(r, ObjectType::Change)?).unwrap(),

                    "the metadata cache holds a change's metadata"

                );

                return Ok(meta);

            }

        }

        let meta =

            Change::decode_meta(&bytes).map_err(|e| StoreError::Corrupt(*r, e.to_string()))?;

        self.remember_meta(r, &meta);

        Ok(meta)

    }

    /// The metadata cache: records of a change hash, its metadata in the

    /// flat layout, and the first 8 bytes of BLAKE3 over both, each

    /// appended in one write. Derived only: a record that does not check

    /// ends the reading (a torn write), and the cache can be deleted.

    fn read_metas_cache(&self) -> crate::fasthash::FastMap<ObjectRef, crate::state::ChangeMeta> {

        let mut out = crate::fasthash::FastMap::default();

        let Ok(bytes) = fs::read(self.dir.join("metas")) else {

            return out;

        };

        let mut r = crate::flat::Reader::new(&bytes);

        let mut good = 0;

        while !r.at_end() {

            let mut record = || -> std::result::Result<_, ObjectError> {

                let h = r.object()?;

                let body = r.bytes()?;

                let check = r.fixed::<8>()?;

                Ok((h, body, check))

            };

            let Ok((h, body, check)) = record() else {

                break;

            };

            let mut sum = blake3::Hasher::new();

            sum.update(&h.0).update(body);

            if sum.finalize().as_bytes()[..8] != check {

                break;

            }

            match crate::state::ChangeMeta::read_flat(&mut crate::flat::Reader::new(body)) {

                Ok(m) => out.insert(h, m),

                Err(_) => break,

            };

            good += 32 + 4 + body.len() + 8;

        }

        // Cut a bad tail, so records appended later are read.

        if good < bytes.len() {

            let _ = fs::OpenOptions::new()

                .write(true)

                .open(self.dir.join("metas"))

                .and_then(|f| f.set_len(good as u64));

        }

        out

    }

    /// Add a change's metadata to the cache; quietly nothing when it

    /// cannot be written (it is only a cache).

    fn remember_meta(&self, r: &ObjectRef, meta: &crate::state::ChangeMeta) {

        let mut body = crate::flat::Writer::default();

        meta.write_flat(&mut body);

        let mut w = crate::flat::Writer::default();

        w.object(r);

        w.bytes(&body.0);

        let mut sum = blake3::Hasher::new();

        sum.update(&r.0).update(&body.0);

        w.fixed(&sum.finalize().as_bytes()[..8]);

        let _ = fs::OpenOptions::new()

            .create(true)

            .append(true)

            .open(self.dir.join("metas"))

            .and_then(|mut f| f.write_all(&w.0));

        if let Some(m) = self.metas.borrow_mut().as_mut() {

            m.insert(*r, meta.clone());

        }