tuwunel_service/rooms/event_handler/
resolve_state.rs1use std::{
2 borrow::Borrow,
3 collections::HashMap,
4 sync::{
5 Arc,
6 atomic::{AtomicBool, Ordering},
7 },
8};
9
10use futures::{FutureExt, Stream, StreamExt, TryFutureExt, TryStreamExt};
11use ruma::{EventId, OwnedEventId, RoomId, RoomVersionId};
12use serde::Deserialize;
13use tuwunel_core::{
14 Err, Result, err, error, implement, trace,
15 utils::stream::{IterStream, ReadyExt, TryWidebandExt, WidebandExt},
16};
17use tuwunel_matrix::{
18 room::state::resolution::{AuthSet, FetchEvent, StateMap, resolve},
19 room_version::rules,
20};
21
22use crate::rooms::{state_compressor::CompressedState, timeline};
23
24#[derive(Clone, Copy)]
25struct Strict<'a> {
26 timeline: &'a timeline::Service,
27 complete: Option<&'a AtomicBool>,
28}
29
30#[implement(super::Service)]
31#[tracing::instrument(
32 name = "state",
33 level = "debug",
34 skip_all,
35 fields(
36 incoming = ?incoming_state.len()
37 ),
38)]
39pub async fn resolve_state(
40 &self,
41 room_id: &RoomId,
42 room_version: &RoomVersionId,
43 incoming_state: HashMap<u64, OwnedEventId>,
44) -> Result<Arc<CompressedState>> {
45 trace!("Loading current room state ids");
46 let current_sstatehash = self
47 .services
48 .state
49 .get_room_shortstatehash(room_id)
50 .map_err(|e| err!(Database(error!("No state for {room_id:?}: {e:?}"))))
51 .await?;
52
53 let current_state_ids: HashMap<_, _> = self
54 .services
55 .state_accessor
56 .state_full_ids(current_sstatehash)
57 .collect()
58 .await;
59
60 trace!("Loading fork states");
61 let fork_states = [current_state_ids, incoming_state];
62 let auth_chains = fork_states
63 .iter()
64 .try_stream()
65 .wide_and_then(|state| {
66 self.services
69 .auth_chain
70 .event_ids_iter(room_id, room_version, state.values().map(Borrow::borrow))
71 .try_collect()
72 .map_ok(AuthSet::from_distinct)
73 })
74 .ready_filter_map(Result::ok);
75
76 let fork_states = fork_states
77 .iter()
78 .stream()
79 .wide_then(|fork_state| {
80 let shortstatekeys = fork_state.keys().copied().stream();
81 let event_ids = fork_state.values().cloned().stream();
82 self.services
83 .short
84 .multi_get_statekey_from_short(shortstatekeys)
85 .zip(event_ids)
86 .ready_filter_map(|(ty_sk, id)| Some((ty_sk.ok()?, id)))
87 .collect::<StateMap<OwnedEventId>>()
88 });
89
90 trace!("Resolving state");
91 let state = self
92 .state_resolution(room_id, room_version, fork_states, auth_chains, None)
93 .await?;
94
95 trace!("State resolution done.");
96 let state_events: Vec<_> = state
97 .iter()
98 .stream()
99 .wide_then(|((event_type, state_key), event_id)| {
100 self.services
101 .short
102 .get_or_create_shortstatekey(event_type, state_key)
103 .map(move |shortstatekey| (shortstatekey, event_id))
104 })
105 .collect()
106 .await;
107
108 trace!("Compressing state...");
109 let new_room_state: CompressedState = self
110 .services
111 .state_compressor
112 .compress_state_events(
113 state_events
114 .iter()
115 .map(|(ssk, eid)| (ssk, (*eid).borrow())),
116 )
117 .collect()
118 .await;
119
120 Ok(Arc::new(new_room_state))
121}
122
123#[implement(super::Service)]
124#[tracing::instrument(name = "resolve", level = "debug", skip_all)]
125pub(super) async fn state_resolution<StateSets, AuthSets>(
126 &self,
127 _room_id: &RoomId,
128 room_version: &RoomVersionId,
129 state_sets: StateSets,
130 auth_chains: AuthSets,
131 complete: Option<&AtomicBool>,
132) -> Result<StateMap<OwnedEventId>>
133where
134 StateSets: Stream<Item = StateMap<OwnedEventId>> + Send,
135 AuthSets: Stream<Item = AuthSet<OwnedEventId>> + Send,
136{
137 let fetch = Strict {
138 timeline: &self.services.timeline,
139 complete,
140 };
141
142 let rules = rules(room_version)?;
143 let hydra_backports = self
144 .services
145 .server
146 .config
147 .compatibility
148 .hydra_backports;
149
150 resolve(&rules, state_sets, auth_chains, fetch, hydra_backports)
151 .inspect_err(|error| {
152 if let Some(complete) = complete {
153 complete.store(false, Ordering::Relaxed);
154 }
155
156 error!(?error, "State resolution failed.");
157 })
158 .await
159}
160
161impl FetchEvent for Strict<'_> {
162 async fn get<T>(self, event_id: &EventId) -> Result<T>
163 where
164 T: for<'de> Deserialize<'de> + Send,
165 {
166 FetchEvent::get(self.timeline, event_id)
167 .map_err(|error| match self.complete.filter(|_| error.is_not_found()) {
168 | None => error,
169 | Some(complete) => {
170 complete.store(false, Ordering::Relaxed);
171
172 err!(Database("State resolution references missing event {event_id}."))
173 },
174 })
175 .await
176 }
177
178 async fn exists(self, event_id: &EventId) -> Result<bool> {
179 let found = FetchEvent::exists(self.timeline, event_id).await?;
180
181 match self.complete.filter(|_| !found) {
182 | None => Ok(found),
183 | Some(complete) => {
184 complete.store(false, Ordering::Relaxed);
185
186 Err!(Database("State resolution references missing event {event_id}."))
187 },
188 }
189 }
190}