Log from the state index, signature marks without reading changes (refs #41) 4cce912a0953

        self.verify_change_known(hash, None)

    }

    /// `verify_change`, with the change's metadata when the caller has it

    /// (a change object can be as large as the tree it adds). Signatures

    /// are looked up first: an unsigned change needs no metadata.

    fn verify_change_known(

        &self,

        hash: &ChangeHash,

        known: Option<&crate::state::ChangeMeta>,

    ) -> Result<SignatureStatus> {

        let read;

        let change = match known {

            Some(m) => m,

            None => {

                read = self.store.get_change_meta(hash)?;

                &read

            }

        };

            match self.check_signer(change, sig, Domain::Change, hash) {

        self.authenticate_change_known(hash, None)

    }

    /// `authenticate_change`, with the change's metadata when the caller

    /// has it (from a log, say), so the change itself need not be read.

    pub fn authenticate_change_known(

        &self,

        hash: &ChangeHash,

        known: Option<&crate::state::ChangeMeta>,

    ) -> Result<SignatureStatus> {

        let direct = self.verify_change_known(hash, known)?;

        };

        let seals = self.store.seals_for(hash)?;

        if seals.is_empty() {

            return Ok(match last_err.is_empty() {

                true => SignatureStatus::Unsigned,

                false => SignatureStatus::Invalid(last_err),

            });

        }

        let read;

        let change = match known {

            Some(m) => m,

            None => {

                read = self.store.get_change_meta(hash)?;

                &read

            }

        for seal_ref in seals {

                match self.check_signer(change, &sig, Domain::Attest, &seal_ref) {

    /// The state index file: its heads, a hash of its changes block and one

    /// of the rest, then the body [`State::write_index`] gives, whose first

    /// block is the changes. Hashed in two parts so the log can read and

    /// check the changes alone.

        let (changes_sum, rest_sum) = (r.object().ok()?, r.object().ok()?);

        let body = &bytes[4 + 32 * heads.len() + 64..];

        let split = 4 + r.count().ok()?;

        // Checked whole, so a part decoded later (the tree's maps, a

        // file's history) can trust its bytes.

        let (changes, rest) = (body.get(..split)?, body.get(split..)?);

        h.update_rayon(rest);

        if *blake3::hash(changes).as_bytes() != changes_sum.0

            || *h.finalize().as_bytes() != rest_sum.0

        {

    }

    /// The changes of this workspace's state index (the closure of its

    /// heads), read without the rest of the index.

    pub(crate) fn read_state_index_changes(

        &self,

    ) -> Option<std::collections::HashMap<ChangeHash, std::sync::Arc<crate::state::ChangeMeta>>>

    {

        use std::io::Read;

        let _t = crate::timing::phase("load: state index changes");

        let mut f = fs::File::open(self.state_index_path()).ok()?;

        let mut word = [0u8; 4];

        f.read_exact(&mut word).ok()?;

        let n = u32::from_le_bytes(word) as usize;

        let mut head = vec![0u8; 32 * n + 64 + 4];

        f.read_exact(&mut head).ok()?;

        let sum = &head[32 * n..32 * n + 32];

        let len = u32::from_le_bytes(head[32 * n + 64..].try_into().unwrap()) as usize;

        let mut changes = vec![0u8; 4 + len];

        changes[..4].copy_from_slice(&head[32 * n + 64..]);

        f.read_exact(&mut changes[4..]).ok()?;

        if blake3::hash(&changes).as_bytes() != sum {

            return None;

        }

        State::read_index_changes(&changes[4..]).ok()

        let split = 4 + u32::from_le_bytes(body[..4].try_into().unwrap()) as usize;

        w.fixed(blake3::hash(&body[..split]).as_bytes());

        sum.update_rayon(&body[split..]);

        // The state index holds the metadata of its heads' closure: a

        // change found there is not read from the store (a change object

        // can be as large as the tree it adds).

        let indexed = self.read_state_index_changes();

        let (mut stored, mut from_store) = (0usize, std::time::Duration::ZERO);

            if let Some(meta) = indexed.as_ref().and_then(|m| m.get(&h)) {

                #[cfg(test)]

                assert_eq!(

                    **meta,

                    self.store.get_change_meta(&h)?,

                    "the state index holds a change's metadata"

                );

                stack.extend(meta.deps.iter().copied());

                out.push((h, (**meta).clone()));

                continue;

            }

            let started = std::time::Instant::now();

            stored += 1;

            from_store += started.elapsed();

        }

        if stored > 0 && crate::timing::enabled() {

            eprintln!("timing metadata: {stored} changes read whole, {from_store:.2?}");

    const INDEX_MAGIC: &'static [u8] = b"oxy state index 3\n";

        // The changes first, as a block a reader can take on its own (see

        // [`State::read_index_changes`]).

        let changes_block = std::mem::take(&mut w);

        w.bytes(&changes_block.0);

        let mut st = State::new_history_only();

        {

            let _t = crate::timing::phase("index: changes");

            st.changes = Self::read_index_changes(r.bytes()?)?;

        }

        let tree_bytes = r.bytes()?;

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

            let n = NodeId(r.fixed::<16>()?);

            let mut recs = Vec::new();

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

                recs.push((r.object()?, r.opt_object()?, r.opt_object()?));

            }

            st.replaces.insert(n, recs);

        }

        let deferred_bytes = r.bytes()?;

        if !r.at_end() {

            return Err(bad("trailing bytes"));

        }

        let (tree, deferred) = rayon::join(

            || TreeGraph::read_flat(&mut Reader::new(tree_bytes)),

            || Self::read_deferred(deferred_bytes),

        );

        st.tree = tree?;

        st.deferred = Some(deferred?);

        Ok(st)

    }

    /// The changes of a state index: its first block, which a reader can

    /// take without the rest (the log needs no more).

    pub fn read_index_changes(

        bytes: &[u8],

    ) -> Result<HashMap<ChangeHash, Arc<ChangeMeta>>, ObjectError> {

        use crate::flat::Reader;

        let mut r = Reader::new(bytes);

            return Err(ObjectError::Schema("state index: not a state index".into()));

        let mut changes = HashMap::with_capacity(n);

            changes.insert(h, Arc::new(meta));

            return Err(ObjectError::Schema("state index: trailing bytes".into()));

        Ok(changes)

/// A compact, styled authentication marker for log lines, from the

/// change's metadata when the caller has it (so the change itself need not

/// be read).

pub fn signature_mark(repo: &Repo, h: &ChangeHash, known: Option<&ChangeMeta>) -> Result<String> {

    Ok(match repo.authenticate_change_known(h, known)? {

    let heads = {

        let _t = oxy_core::timing::phase("status: heads");

        repo.bookmark_heads()?

    };

    let _drop = oxy_core::timing::phase("status: print and drop");

    let listing = oxy_core::timing::phase("log: entries");

    drop(listing);

    let _print = oxy_core::timing::phase("log: print");

                signature_mark(&repo, &e.hash, Some(c))?