Skip to main content

qualia_core_db/bundle/stream/publish/
entries.rs

1use super::PlainPublisher;
2use crate::bundle::stream::descriptor::*;
3use crate::bundle::stream::proof::{
4    OutboardNode, ProofError, Representation, TreeBuilder, TreeSpec,
5};
6impl PlainPublisher<'_, '_> {
7    pub fn emit_entry_page(
8        &mut self,
9        page: usize,
10        out: &mut [u8],
11        framing: &mut [u8],
12        mut observe: impl FnMut(u32, OutboardNode) -> Result<(), DescriptorError>,
13        mut sink: impl FnMut(&[u8], PageRef) -> Result<(), DescriptorError>,
14    ) -> Result<usize, DescriptorError> {
15        self.live()?;
16        let context = self.context_id.ok_or(DescriptorError::Incomplete)?;
17        if page != self.entry_next || page >= self.page_count() {
18            return Err(DescriptorError::Page);
19        }
20        let first = page * PAGE_ROWS;
21        let count = (self.entry_count() - first).min(PAGE_ROWS);
22        let mut rows = [EntryRecord::EMPTY; PAGE_ROWS];
23        let mut seen = 0;
24        // Poison BEFORE the first observer so an error or unwind can never mint a final candidate.
25        self.poisoned = true;
26        for (i, entry) in self.index.entries().skip(first).take(count).enumerate() {
27            let entry = entry.map_err(|_| DescriptorError::Source)?;
28            let assignment = self.assignments[first + i];
29            let spec = TreeSpec::new(
30                context,
31                assignment.id,
32                self.parameters.generation,
33                Representation::Plaintext,
34                0,
35                entry.length(),
36            )
37            .map_err(|_| DescriptorError::Proof)?;
38            let start = usize::try_from(entry.offset()).map_err(|_| DescriptorError::Overflow)?;
39            let end = entry
40                .offset()
41                .checked_add(entry.length())
42                .and_then(|n| usize::try_from(n).ok())
43                .ok_or(DescriptorError::Overflow)?;
44            let bytes = self.source.get(start..end).ok_or(DescriptorError::Source)?;
45            let mut tree = TreeBuilder::new(spec);
46            for chunk in bytes.chunks(LEAF_BYTES as usize) {
47                tree.append(chunk, |node| {
48                    observe(assignment.id, node).map_err(|_| ProofError::Sink)
49                })
50                .map_err(|e| {
51                    if matches!(e, ProofError::Sink | ProofError::Poisoned) {
52                        DescriptorError::Sink
53                    } else {
54                        DescriptorError::Proof
55                    }
56                })?;
57            }
58            let root = tree
59                .finish(|node| observe(assignment.id, node).map_err(|_| ProofError::Sink))
60                .map_err(|e| {
61                    if matches!(e, ProofError::Sink | ProofError::Poisoned) {
62                        DescriptorError::Sink
63                    } else {
64                        DescriptorError::Proof
65                    }
66                })?;
67            rows[i] = EntryRecord {
68                id: assignment.id,
69                ordinal: (first + i) as u32,
70                kind: entry.kind(),
71                inner_version: assignment.inner_version,
72                offset: entry.offset(),
73                length: entry.length(),
74                root,
75            };
76            seen += 1;
77        }
78        if seen != count {
79            return Err(DescriptorError::Coverage);
80        }
81        let n = encode_entry_page_into(context, page as u32, first as u32, &rows[..count], out)?;
82        let digest = domain_digest(DigestDomain::EntryPage, &out[..n], framing)?;
83        let used = self.charge(n)?;
84        let reference = PageRef {
85            number: page as u32,
86            first: first as u32,
87            rows: count as u32,
88            encoded_length: n as u32,
89            digest,
90        };
91        sink(&out[..n], reference).map_err(|_| DescriptorError::Sink)?;
92        self.entry_refs[page] = reference;
93        self.entry_next += 1;
94        self.used = used;
95        self.poisoned = false;
96        Ok(n)
97    }
98}