tuwunel_service/rooms/pdu_metadata/
bundling.rs1use std::collections::BTreeSet;
2
3use futures::{Stream, StreamExt, TryFutureExt, pin_mut};
4use ruma::{OwnedUserId, UserId, api::Direction, events::room::encrypted::Relation};
5use tuwunel_core::{
6 arrayvec::ArrayVec,
7 implement,
8 result::LogErr,
9 utils::{
10 BoolExt,
11 stream::{ReadyExt, TryIgnore},
12 u64_from_u8,
13 },
14};
15use tuwunel_matrix::{Event, Pdu, PduCount, PduId, RawPduId};
16
17use super::{
18 ExtractRelatesTo, IgnoredThreadView,
19 IgnoredThreadView::{Adjusted, Unchanged, WithoutSummary},
20 Service,
21 typed_relations::{CHILD_COUNT_OFFSET, KEY_LEN, Tag, prefix},
22};
23
24type Seek = ArrayVec<u8, KEY_LEN>;
25
26#[implement(Service)]
37#[tracing::instrument(skip_all, level = "trace")]
38pub async fn bundle_aggregations(&self, sender_user: &UserId, mut pdu: Pdu) -> Pdu {
39 if let Some(pruned) = self
42 .services
43 .state_accessor
44 .erased_view(sender_user, &pdu)
45 .await
46 {
47 return pruned;
48 }
49
50 self.bundle_thread_for(sender_user, &mut pdu)
51 .await;
52
53 let replacement = self
54 .services
55 .server
56 .config
57 .rooms
58 .relations
59 .bundle_edits
60 .then_async(|| self.newest_replacement(&pdu))
61 .await
62 .flatten();
63
64 if let Some(replacement) = replacement
65 && !self
66 .services
67 .state_accessor
68 .erased_for(sender_user, &replacement)
69 .await
70 {
71 let replacement = replacement.without_private_unless_sender(Some(sender_user));
72
73 pdu.set_replacement_bundle(&replacement.into_format())
74 .log_err()
75 .ok();
76 }
77
78 let references = self
79 .services
80 .server
81 .config
82 .rooms
83 .relations
84 .bundle_references
85 .then_async(|| self.references(&pdu))
86 .await
87 .unwrap_or_default();
88
89 if !references.is_empty() {
90 pdu.set_reference_bundle(&references)
91 .log_err()
92 .ok();
93 }
94
95 pdu
96}
97
98#[implement(Service)]
99#[tracing::instrument(skip_all, level = "trace")]
100async fn bundle_thread_for(&self, sender_user: &UserId, pdu: &mut Pdu) {
101 if pdu
102 .has_thread_bundle()
103 .log_err()
104 .unwrap_or(true)
105 .is_false()
106 {
107 return;
108 }
109
110 if pdu
111 .thread_latest_event()
112 .log_err()
113 .ok()
114 .flatten()
115 .is_none()
116 || pdu
117 .remove_thread_latest_transaction_id_unless_sender(sender_user)
118 .log_err()
119 .is_err()
120 {
121 drop_thread_bundle(pdu);
122 return;
123 }
124
125 let participated = self
126 .services
127 .threads
128 .user_participated(pdu.event_id(), sender_user)
129 .await;
130
131 let participation = pdu
132 .set_thread_participated(participated)
133 .log_err();
134
135 if thread_result_or_drop(pdu, participation).is_none() {
136 return;
137 }
138
139 self.erase_thread_latest(sender_user, pdu).await;
140
141 let _: Option<()> = self
142 .services
143 .server
144 .config
145 .rooms
146 .relations
147 .bundle_edits
148 .then_async(|| self.bundle_thread_latest_edit(sender_user, pdu))
149 .await;
150}
151
152#[implement(Service)]
156#[tracing::instrument(skip_all, level = "trace")]
157async fn erase_thread_latest(&self, sender_user: &UserId, pdu: &mut Pdu) {
158 let identity = pdu.thread_latest_event().log_err();
159
160 let Some((event_id, sender)) = thread_result_or_drop(pdu, identity).flatten() else {
161 return;
162 };
163
164 if !self.services.users.is_erased(&sender).await {
165 return;
166 }
167
168 let latest = self.services.timeline.get_pdu(&event_id).await;
169 let Some(latest) = thread_result_or_drop(pdu, latest) else {
170 return;
171 };
172
173 let Some(pruned) = self
174 .services
175 .state_accessor
176 .erased_view(sender_user, &latest)
177 .await
178 else {
179 return;
180 };
181
182 if pdu
183 .set_thread_latest_event(&pruned.into_format())
184 .log_err()
185 .is_err()
186 {
187 drop_thread_bundle(pdu);
188 }
189}
190
191fn thread_result_or_drop<T, E>(pdu: &mut Pdu, result: Result<T, E>) -> Option<T> {
192 result
193 .inspect_err(|_| drop_thread_bundle(pdu))
194 .ok()
195}
196
197fn drop_thread_bundle(pdu: &mut Pdu) { pdu.remove_thread_bundle().log_err().ok(); }
198
199#[implement(Service)]
204#[tracing::instrument(skip_all, level = "trace")]
205async fn bundle_thread_latest_edit(&self, sender_user: &UserId, pdu: &mut Pdu) {
206 let identity = pdu.thread_latest_event().log_err();
207
208 let Some((event_id, _)) = thread_result_or_drop(pdu, identity).flatten() else {
209 return;
210 };
211
212 let latest_event = self
213 .services
214 .timeline
215 .get_pdu(&event_id)
216 .await
217 .log_err();
218
219 let Some(mut latest_event) = thread_result_or_drop(pdu, latest_event) else {
220 return;
221 };
222
223 if self
224 .services
225 .state_accessor
226 .erased_for(sender_user, &latest_event)
227 .await
228 {
229 return;
230 }
231
232 let Some(mut replacement_event) = self.newest_replacement(&latest_event).await else {
233 return;
234 };
235
236 if self
237 .services
238 .state_accessor
239 .erased_for(sender_user, &replacement_event)
240 .await
241 {
242 return;
243 }
244
245 replacement_event.remove_private_unless_sender(Some(sender_user));
246 latest_event.remove_private_unless_sender(Some(sender_user));
247
248 let replacement = latest_event
249 .set_replacement_bundle(&replacement_event.into_format())
250 .log_err();
251
252 if thread_result_or_drop(pdu, replacement).is_none() {
253 return;
254 }
255
256 let latest = pdu
257 .set_thread_latest_event(&latest_event.into_format())
258 .log_err();
259
260 thread_result_or_drop(pdu, latest);
261}
262
263#[implement(Service)]
268#[tracing::instrument(skip_all, level = "trace")]
269async fn newest_replacement(&self, parent: &Pdu) -> Option<Pdu> {
270 if parent.is_redacted() {
271 return None;
272 }
273
274 let parent_id: PduId = self
275 .services
276 .timeline
277 .get_pdu_id(parent.event_id())
278 .map_ok(Into::into)
279 .await
280 .ok()?;
281
282 let replacements = self.replacement_children(parent, parent_id);
283
284 pin_mut!(replacements);
285 replacements.next().await
286}
287
288#[implement(Service)]
292fn replacement_children<'a>(
293 &'a self,
294 parent: &'a Pdu,
295 parent_id: PduId,
296) -> impl Stream<Item = Pdu> + Send + 'a {
297 let shortroomid = parent_id.shortroomid;
298 let prefix = prefix(shortroomid, parent_id.count, Tag::Replace);
299
300 let mut seek = Seek::new();
301
302 seek.extend(prefix.iter().copied());
303 seek.extend([u8::MAX; size_of::<u64>() * 2]);
304
305 self.db
306 .relatesto_typed
307 .rev_raw_keys_from(seek.as_slice())
308 .ignore_err()
309 .ready_take_while(move |key| key.starts_with(&prefix))
310 .map(|key| u64_from_u8(&key[CHILD_COUNT_OFFSET..KEY_LEN]))
311 .map(PduCount::from_unsigned)
312 .map(move |count| (shortroomid, count))
313 .filter_map(async |(shortroomid, count)| {
314 let child_id: RawPduId = PduId { shortroomid, count }.into();
315 self.services
316 .timeline
317 .get_pdu_from_id(&child_id)
318 .await
319 .ok()
320 .filter(|child| !child.is_redacted())
321 .filter(|child| child.sender() == parent.sender())
322 .filter(|child| child.kind() == parent.kind())
323 })
324}
325
326#[implement(Service)]
333#[tracing::instrument(skip_all, level = "trace")]
334pub async fn ignored_thread_view(
335 &self,
336 sender_user: &UserId,
337 ignored: &BTreeSet<OwnedUserId>,
338 root: &Pdu,
339) -> IgnoredThreadView {
340 let Ok(root_id) = self
341 .services
342 .timeline
343 .get_pdu_id(root.event_id())
344 .await
345 else {
346 return Unchanged;
347 };
348
349 let participants = self
350 .services
351 .threads
352 .get_participants(&root_id)
353 .await
354 .unwrap_or_default();
355
356 if !participants
357 .iter()
358 .any(|user| ignored.contains(user))
359 {
360 return Unchanged;
361 }
362
363 let root_pid: PduId = root_id.into();
364 let replies = self
365 .get_relations(
366 root_pid.shortroomid,
367 root_pid.count,
368 None,
369 Direction::Backward,
370 Some(sender_user),
371 )
372 .ready_filter_map(|(_, pdu)| {
373 pdu.get_content()
374 .is_ok_and(|content: ExtractRelatesTo| {
375 matches!(content.relates_to, Relation::Thread(_))
376 })
377 .then_some(pdu)
378 });
379
380 let fold = |(total, unignored, latest): (usize, usize, Option<Pdu>), pdu: Pdu| match ignored
381 .contains(pdu.sender())
382 {
383 | true => (total.saturating_add(1), unignored, latest),
384 | false => (total.saturating_add(1), unignored.saturating_add(1), latest.or(Some(pdu))),
385 };
386
387 let (total, unignored, latest) = replies.ready_fold((0, 0, None), fold).await;
388
389 if total == 0 {
390 return match self.redacted_root(ignored, root).await {
391 | None => Unchanged,
392 | root => Adjusted { root, count: None, latest: None },
393 };
394 }
395
396 if unignored == 0 {
397 return WithoutSummary {
398 root: self.redacted_root(ignored, root).await,
399 };
400 }
401
402 let swap = root
403 .thread_latest_event()
404 .ok()
405 .flatten()
406 .is_some_and(|(_, sender)| ignored.contains(&sender));
407
408 let latest = match swap.then_some(latest).flatten() {
409 | None => None,
410 | Some(reply) => {
411 let reply = self
414 .services
415 .state_accessor
416 .erased_view(sender_user, &reply)
417 .await
418 .unwrap_or(reply);
419
420 Some(reply.into_format())
421 },
422 };
423
424 let count = unignored.ne(&total).then_some(unignored);
425
426 let root = self.redacted_root(ignored, root).await;
427
428 if root.is_none() && count.is_none() && latest.is_none() {
429 return Unchanged;
430 }
431
432 Adjusted { root, count, latest }
433}
434
435#[implement(Service)]
439#[tracing::instrument(skip_all, level = "trace")]
440async fn redacted_root(&self, ignored: &BTreeSet<OwnedUserId>, root: &Pdu) -> Option<Box<Pdu>> {
441 ignored
442 .contains(root.sender())
443 .then_async(async || {
444 self.services
445 .state
446 .get_room_version_rules(root.room_id())
447 .await
448 .log_err()
449 .ok()
450 .and_then(|rules| root.redacted(&rules.redaction).log_err().ok())
451 .map(Box::new)
452 })
453 .await
454 .flatten()
455}
456
457#[cfg(test)]
458mod tests {
459 use serde_json::json;
460
461 use super::*;
462
463 #[test]
464 fn thread_latest_load_error_drops_bundle() {
465 let mut pdu: Pdu = serde_json::from_value(json!({
466 "type": "m.room.member",
467 "content": { "membership": "join" },
468 "event_id": "$member:example.com",
469 "room_id": "!room:example.com",
470 "sender": "@alice:example.com",
471 "state_key": "@alice:example.com",
472 "prev_events": ["$prev:example.com"],
473 "auth_events": ["$auth:example.com"],
474 "origin_server_ts": 1_838_188_000,
475 "depth": 12,
476 "hashes": { "sha256": "thishashcoversallfieldsincasethisisredacted" },
477 "unsigned": {
478 "age": 4612,
479 "m.relations": {
480 "m.replace": { "event_id": "$edit:example.com" },
481 "m.thread": { "count": 3 },
482 },
483 },
484 }))
485 .expect("test fixture should deserialize as a valid PDU");
486
487 let latest: Option<()> = thread_result_or_drop(&mut pdu, Err("missing latest event"));
488
489 assert!(latest.is_none(), "load failure returned a latest event");
490
491 let unsigned: serde_json::Value = serde_json::from_str(
492 pdu.unsigned
493 .as_ref()
494 .expect("sibling unsigned data should remain")
495 .json()
496 .get(),
497 )
498 .expect("remaining unsigned data should be valid JSON");
499
500 assert!(
501 unsigned["m.relations"].get("m.thread").is_none(),
502 "failed load retained the thread bundle",
503 );
504
505 assert_eq!(
506 unsigned["m.relations"]["m.replace"],
507 json!({ "event_id": "$edit:example.com" }),
508 "failed load removed a sibling relation",
509 );
510 assert_eq!(unsigned["age"], 4612, "failed load removed outer unsigned data");
511 }
512}