qualia_core_db/bundle/stream/publish/
entries.rs1use 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 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}