Skip to main content

tuwunel_service/integrity/short_ids/
references.rs

1use 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		// The tail was not empty above, so only a consumed separator empties it here.
133		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}