tuwunel_service/rooms/pdu_metadata/
purge.rs1use 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
25enum Indexed {
30 Written,
31 Skipped,
32 Unparsable,
33}
34
35#[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#[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#[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}