tuwunel_service/integrity/short_ids/
references.rs1use std::{collections::BTreeSet, iter::repeat};
2
3use tuwunel_core::{Err, Result, err, implement, utils::TryReadyExt};
4
5use super::{
6 identity::{Family, Identities, Kind},
7 short_of,
8};
9use crate::{Services, integrity::ScanExt};
10
11pub(crate) struct References {
12 pub(crate) events: BTreeSet<u64>,
13 pub(crate) statekeys: BTreeSet<u64>,
14 pub(crate) event_complete: bool,
15 pub(crate) statekey_complete: bool,
16}
17
18#[implement(References)]
19#[tracing::instrument(level = "debug", skip_all)]
20pub(crate) async fn census(services: &Services, identities: &Identities) -> Result<Self> {
21 let db = &services.db;
22 let aliases = |family: &Family| {
23 family
24 .candidates
25 .iter()
26 .filter(|candidate| matches!(candidate.kind, Kind::Alias(_)))
27 .map(|candidate| candidate.short)
28 .collect::<BTreeSet<_>>()
29 };
30
31 let event_aliases = aliases(&identities.events);
32 let statekey_aliases = aliases(&identities.statekeys);
33 let references = Self {
34 events: BTreeSet::new(),
35 statekeys: BTreeSet::new(),
36 event_complete: true,
37 statekey_complete: true,
38 };
39
40 if event_aliases.is_empty() && statekey_aliases.is_empty() {
41 return Ok(references);
42 }
43
44 let references = db["shortstatehash_statediff"]
45 .raw_stream()
46 .scanned(&services.server)
47 .ready_try_fold(references, |mut references, (_, value)| {
48 references.retain_statediff(&event_aliases, &statekey_aliases, value);
49
50 Ok(references)
51 })
52 .await?;
53
54 if event_aliases.is_empty() {
55 return Ok(references);
56 }
57
58 let references = db["shorteventid_shortstatehash"]
59 .raw_keys()
60 .scanned(&services.server)
61 .ready_try_fold(references, |mut references, key| {
62 references.retain_event(&event_aliases, key);
63
64 Ok(references)
65 })
66 .await?;
67
68 let references = db["relatesto_typed"]
69 .raw_stream()
70 .scanned(&services.server)
71 .ready_try_fold(references, |mut references, (_, value)| {
72 references.retain_event(&event_aliases, value);
73
74 Ok(references)
75 })
76 .await?;
77
78 db["authchainkey_authchain"]
79 .raw_stream()
80 .scanned(&services.server)
81 .ready_try_fold(references, |mut references, (key, value)| {
82 references.event_complete &=
83 !key.is_empty() && key.len().is_multiple_of(8) && value.len().is_multiple_of(8);
84
85 key.as_chunks()
86 .0
87 .iter()
88 .chain(value.as_chunks().0.iter())
89 .for_each(|bytes: &[u8; 8]| references.retain_event(&event_aliases, bytes));
90
91 Ok(references)
92 })
93 .await
94}
95
96#[implement(References)]
97fn retain_statediff(
98 &mut self,
99 event_aliases: &BTreeSet<u64>,
100 statekey_aliases: &BTreeSet<u64>,
101 value: &[u8],
102) {
103 let valid = entries(value)
104 .try_for_each(|entry| {
105 entry.map(|(statekey, event)| {
106 retain(&mut self.statekeys, statekey_aliases, statekey);
107 retain(&mut self.events, event_aliases, event);
108 })
109 })
110 .is_ok();
111
112 self.event_complete &= valid;
113 self.statekey_complete &= valid;
114}
115
116pub(crate) fn entries(value: &[u8]) -> impl Iterator<Item = Result<(u64, u64)>> + '_ {
117 repeat(()).scan((value.get(8..), false), |state, ()| {
118 let (Some(tail), removed) = state else {
119 *state = (Some(&[]), false);
120 return Some(Err!("malformed state diff parent"));
121 };
122
123 if tail.is_empty() {
124 return None;
125 }
126
127 if !*removed && tail.starts_with(&0_u64.to_be_bytes()) {
128 *removed = true;
129 *tail = tail.get(8..).unwrap_or_default();
130 }
131
132 if tail.is_empty() {
134 return Some(Err!("empty state diff removed run"));
135 }
136
137 let entry = tail
138 .get(..16)
139 .and_then(|bytes| Some((short_of(bytes.get(..8)?)?, short_of(bytes.get(8..)?)?)))
140 .filter(|&(key, event)| key != 0 && event != 0)
141 .ok_or_else(|| err!("malformed state diff entry"));
142
143 *tail = tail.get(16..).unwrap_or_default();
144
145 Some(entry)
146 })
147}
148
149#[implement(References)]
150fn retain_event(&mut self, aliases: &BTreeSet<u64>, bytes: &[u8]) {
151 match short_of(bytes).filter(|short| *short != 0) {
152 | Some(event) => retain(&mut self.events, aliases, event),
153 | None => self.event_complete = false,
154 }
155}
156
157fn retain(references: &mut BTreeSet<u64>, aliases: &BTreeSet<u64>, short: u64) {
158 if aliases.contains(&short) {
159 references.insert(short);
160 }
161}