Skip to main content

tuwunel_service/rooms/pdu_metadata/
purge.rs

1use ruma::{
2	EventId, RoomId,
3	events::{relation::RelationType, room::encrypted::Relation},
4};
5use tuwunel_core::{
6	Result,
7	arrayvec::ArrayVec,
8	debug_warn, implement, info,
9	result::NotFound,
10	utils::stream::{ReadyExt, TryBroadbandExt, TryIgnore, TryReadyExt},
11};
12use tuwunel_matrix::{Event, Pdu, PduCount, PduId, RawPduId};
13
14use super::{
15	ExtractRelatesTo, Service,
16	typed_relations::{Derived, KEY_LEN, indexed_key, tag},
17};
18use crate::{
19	integrity::relatesto_typed::{Expected, Row, expected},
20	rooms::short::ShortRoomId,
21};
22
23type Prefix = ArrayVec<u8, 16>;
24
25/// What the relation rebuild made of one event row.
26///
27/// A relation whose parent cannot be resolved is skipped and counted, so the
28/// rebuild carries on past a bad read or a damaged mapping.
29enum Indexed {
30	Written,
31	Skipped,
32	Unparsable,
33}
34
35/// Purges one event's metadata during a history purge.
36///
37/// Relation rows keyed by this event as parent or target are removed. Rows
38/// keyed by it as a surviving event's child remain dangling because relation
39/// reads discard IDs that no longer resolve. Soft-fail and policy decisions are
40/// cleared after the relation indexes.
41#[implement(Service)]
42pub async fn purge_event_relations(
43	&self,
44	shortroomid: ShortRoomId,
45	parent: PduCount,
46	room_id: &RoomId,
47	event_id: &EventId,
48) {
49	let target = parent.to_be_bytes();
50
51	self.db
52		.tofrom_relation
53		.raw_keys_from(target.as_slice())
54		.ignore_err()
55		.ready_take_while(move |key| key.starts_with(&target))
56		.ready_for_each(|key| self.db.tofrom_relation.remove(key))
57		.await;
58
59	let mut prefix = Prefix::new();
60
61	prefix.extend(shortroomid.to_be_bytes());
62	prefix.extend(parent.to_be_bytes());
63
64	self.db
65		.relatesto_typed
66		.raw_keys_from(prefix.as_slice())
67		.ignore_err()
68		.ready_take_while(move |key| key.starts_with(&prefix))
69		.ready_for_each(|key| self.db.relatesto_typed.remove(key))
70		.await;
71
72	self.db.referencedevents.del((room_id, event_id));
73
74	self.services
75		.event_handler
76		.clear_policy_signature_state(event_id);
77
78	self.clear_event_soft_failed(event_id);
79}
80
81/// Rebuilds `relatesto_typed` from every stored PDU.
82///
83/// Runs once at startup behind a `global` marker, and on demand from the admin
84/// command. It clears the index first, so a partial or stale one is replaced
85/// wholesale, then writes the rows the relation index check expects. A cursor
86/// failure ends it with an error, leaving the index partial, while a relation
87/// whose parent lookup fails, or whose parent mapping is unreadable, is skipped
88/// and counted.
89#[implement(Service)]
90pub async fn rebuild_typed_relations(&self) -> Result {
91	self.db.relatesto_typed.clear().await;
92
93	let (written, skipped, unparsable) = expected(&self.services)
94		.broad_and_then(async |expected| Ok(self.index_expected(expected).await))
95		.ready_try_fold((0_usize, 0_usize, 0_usize), |(written, skipped, unparsable), indexed| {
96			Ok(match indexed {
97				| Indexed::Written => (written.saturating_add(1), skipped, unparsable),
98				| Indexed::Skipped => (written, skipped.saturating_add(1), unparsable),
99				| Indexed::Unparsable => (written, skipped, unparsable.saturating_add(1)),
100			})
101		})
102		.await?;
103
104	info!(%written, %skipped, %unparsable, "Rebuilt relatesto_typed relation index");
105
106	Ok(())
107}
108
109#[implement(Service)]
110#[tracing::instrument(level = "debug", skip_all)]
111async fn index_expected(&self, expected: Expected) -> Indexed {
112	match expected {
113		| Expected::Unparsable(_) => Indexed::Unparsable,
114		| Expected::Unresolved { pdu_id, error } => {
115			debug_warn!(?pdu_id, %error, "Relation not indexed, its parent lookup failed");
116
117			Indexed::Skipped
118		},
119		| Expected::UnreadableParent { child, parent } => {
120			debug_warn!(%child, %parent, "Relation not indexed, its parent mapping is unreadable");
121
122			Indexed::Skipped
123		},
124		| Expected::Row(row) => {
125			self.index_row(row).await;
126
127			Indexed::Written
128		},
129	}
130}
131
132#[implement(Service)]
133#[tracing::instrument(level = "debug", skip_all)]
134async fn index_row(&self, Row { key, child }: Row) {
135	let child_short = self
136		.services
137		.short
138		.get_or_create_shorteventid(&child)
139		.await;
140
141	self.db
142		.relatesto_typed
143		.aput_raw::<KEY_LEN, _, _>(key.as_slice(), child_short.to_be_bytes());
144}
145
146/// The `relatesto_typed` key an event is indexed under, if any.
147///
148/// Only an `m.replace` or `m.reference` relation is indexed, and only as
149/// [`Service::add_typed_relation`] indexes it. Unlike that live path, the
150/// parent's mapping is decoded without trusting it, so a damaged one is reported
151/// rather than panicking. A lookup failing other than as absent is returned.
152#[implement(Service)]
153#[tracing::instrument(level = "debug", skip_all)]
154pub(crate) async fn typed_relation_key(&self, pdu_id: PduId, pdu: &Pdu) -> Result<Derived> {
155	let Ok(content) = pdu.get_content::<ExtractRelatesTo>() else {
156		return Ok(Derived::Unindexed);
157	};
158
159	let (rel_type, parent) = match content.relates_to {
160		| Relation::Replacement(replacement) => (RelationType::Replacement, replacement.event_id),
161		| Relation::Reference(reference) => (RelationType::Reference, reference.event_id),
162		| _ => return Ok(Derived::Unindexed),
163	};
164
165	let Some(tag) = tag(&rel_type) else {
166		return Ok(Derived::Unindexed);
167	};
168
169	let Some(parent_id) = self
170		.db
171		.eventid_pduid
172		.get(&parent)
173		.await
174		.optional()?
175		.map(|parent_id| RawPduId::try_from_bytes(&parent_id))
176	else {
177		return Ok(Derived::Unindexed);
178	};
179
180	let Some(parent_id) = parent_id else {
181		return Ok(Derived::UnreadableParent(parent));
182	};
183
184	let key = indexed_key(pdu_id.shortroomid, parent_id.pdu_count(), tag, pdu, pdu_id.count);
185
186	let derived = key.map_or(Derived::Unindexed, Derived::Key);
187
188	Ok(derived)
189}