tuwunel_service/rooms/event_handler/
state_at_incoming.rs1use std::{collections::HashMap, sync::atomic::AtomicBool};
2
3use futures::{
4 FutureExt, StreamExt, TryFutureExt, TryStreamExt,
5 future::{join, try_join},
6};
7use ruma::{EventId, OwnedEventId, RoomId, RoomVersionId};
8use tuwunel_core::{
9 Error, Result, debug, debug_warn, err, implement,
10 itertools::Itertools,
11 ref_at, trace,
12 utils::{
13 option::OptionExt,
14 stream::{BroadbandExt, IterStream, ReadyExt, TryBroadbandExt, WidebandExt},
15 },
16};
17use tuwunel_matrix::{
18 Event,
19 pdu::check_room_id,
20 room::state::resolution::{AuthSet, StateMap},
21};
22
23use crate::rooms::short::{ShortStateHash, ShortStateKey};
24
25enum ForkError {
26 State(Error),
27 Chain(Error),
28}
29
30#[implement(super::Service)]
32#[tracing::instrument(name = "state1", level = "debug", skip_all)]
34pub(super) async fn state_at_incoming_degree_one<Pdu>(
35 &self,
36 incoming_pdu: &Pdu,
37) -> Result<Option<HashMap<u64, OwnedEventId>>>
38where
39 Pdu: Event,
40{
41 debug_assert!(
42 incoming_pdu.prev_events().count() == 1,
43 "Incoming PDU must have one prev_event to make this call"
44 );
45
46 let prev_event_id = incoming_pdu
47 .prev_events()
48 .next()
49 .expect("at least one prev_event");
50
51 let Ok(prev_event_sstatehash) = self
52 .services
53 .state
54 .pdu_shortstatehash(prev_event_id)
55 .inspect_err(|e| debug_warn!(?prev_event_id, %e, "Missing state at prev_event."))
56 .await
57 else {
58 return Ok(None);
59 };
60
61 debug!(?prev_event_id, ?prev_event_sstatehash, "Resolving state at prev_event.");
62
63 let prev_event = self
64 .services
65 .timeline
66 .get_pdu(prev_event_id)
67 .map_err(|e| err!(Database("Could not find prev_event, but we know the state: {e:?}")));
68
69 let state = self
70 .services
71 .state_accessor
72 .state_full_ids_strict(prev_event_sstatehash)
73 .try_collect::<HashMap<_, _>>()
74 .map(|state| {
75 state
76 .inspect_err(|error| {
77 debug_warn!(
78 %prev_event_id,
79 ?prev_event_sstatehash,
80 %error,
81 "Failed to materialize state at prev_event.",
82 );
83 })
84 .ok()
85 })
86 .map(Ok);
87
88 let (prev_event, state) = try_join(prev_event, state).await?;
89
90 check_room_id(&prev_event, incoming_pdu.room_id())?;
91
92 let Some(mut state) = state else {
93 return Ok(None);
94 };
95
96 debug!(
97 ?prev_event_id,
98 ?prev_event_sstatehash,
99 state_ids = state.len(),
100 "Resolved state at prev_event.",
101 );
102
103 if let Some(state_key) = prev_event.state_key() {
108 let prev_event_type = prev_event.event_type().to_cow_str().into();
109
110 let shortstatekey = self
111 .services
112 .short
113 .get_or_create_shortstatekey(&prev_event_type, state_key)
114 .await;
115
116 state.insert(shortstatekey, prev_event.event_id().into());
117 debug!(
119 ?prev_event_id,
120 ?prev_event_type,
121 ?prev_event_sstatehash,
122 ?shortstatekey,
123 state_ids = state.len(),
124 "Added prev_event to state.",
125 );
126 }
127
128 debug_assert!(!state.is_empty(), "should be returning None for empty HashMap result");
129
130 Ok(Some(state))
131}
132
133#[implement(super::Service)]
134#[tracing::instrument(name = "stateN", level = "debug", skip_all)]
135pub(super) async fn state_at_incoming_resolved<Pdu>(
136 &self,
137 incoming_pdu: &Pdu,
138 room_id: &RoomId,
139 room_version: &RoomVersionId,
140) -> Result<Option<HashMap<u64, OwnedEventId>>>
141where
142 Pdu: Event,
143{
144 debug_assert!(
145 incoming_pdu.prev_events().count() > 1,
146 "Incoming PDU should have more than one prev_event for this codepath"
147 );
148
149 trace!("Calculating extremity statehashes...");
150 let Ok(prevs) = incoming_pdu
151 .prev_events()
152 .try_stream()
153 .broad_and_then(|prev_event_id| {
154 let sstatehash = self
155 .services
156 .state
157 .pdu_shortstatehash(prev_event_id);
158
159 let prev_event = self.services.timeline.get_pdu(prev_event_id);
160
161 try_join(sstatehash, prev_event).inspect_err(move |e| {
162 debug_warn!(?prev_event_id, %e, "Missing state at prev_event.");
163 })
164 })
165 .try_collect::<Vec<_>>()
166 .await
167 else {
168 return Ok(None);
169 };
170
171 trace!("Calculating fork states...");
172 prevs
173 .iter()
174 .try_for_each(|(_, pdu)| check_room_id(pdu, room_id))?;
175
176 let forks = prevs
177 .into_iter()
178 .sorted_unstable_by(|a, b| fork_identity(a).cmp(&fork_identity(b)))
179 .dedup_by(|a, b| fork_identity(a) == fork_identity(b))
180 .stream()
181 .wide_then(|(sstatehash, prev_event)| {
182 self.state_at_incoming_fork(room_id, room_version, sstatehash, prev_event)
183 })
184 .map(|fork| match fork {
185 | Ok(fork) => Ok(Ok(fork)),
186 | Err(ForkError::State(error)) => Ok(Err(error)),
187 | Err(ForkError::Chain(error)) => Err(error),
188 })
189 .try_collect::<Vec<_>>()
190 .await?;
191
192 let Ok((fork_states, auth_chain_sets)): Result<(Vec<_>, Vec<_>)> = forks
193 .into_iter()
194 .process_results(|complete| complete.unzip())
195 .inspect_err(|error| debug_warn!(%error, "Failed to materialize sibling fork state."))
196 else {
197 return Ok(None);
198 };
199
200 let fork_states = fork_states.into_iter().stream();
201 let auth_chain_sets = auth_chain_sets.into_iter().stream();
202
203 trace!("Resolving state");
204 let Ok(new_state) = self
205 .state_resolution(room_id, room_version, fork_states, auth_chain_sets, None)
206 .inspect_ok(|_| trace!("State resolution done."))
207 .await
208 else {
209 return Ok(None);
210 };
211
212 new_state
213 .into_iter()
214 .stream()
215 .broad_then(async |((event_type, state_key), event_id)| {
216 self.services
217 .short
218 .get_or_create_shortstatekey(&event_type, &state_key)
219 .map(move |shortstatekey| (shortstatekey, event_id))
220 .await
221 })
222 .collect::<HashMap<_, _>>()
223 .inspect(|state| trace!(state = state.len(), "Created shortstatekeys."))
224 .map(Some)
225 .map(Ok)
226 .await
227}
228
229fn fork_identity<Pdu>(
235 (sstatehash, prev_event): &(ShortStateHash, Pdu),
236) -> (ShortStateHash, Option<&EventId>)
237where
238 Pdu: Event,
239{
240 let leaf = prev_event
241 .state_key()
242 .map(|_| prev_event.event_id());
243
244 (*sstatehash, leaf)
245}
246
247#[implement(super::Service)]
248#[tracing::instrument(
249 name = "fork",
250 level = "debug",
251 skip_all,
252 fields(
253 ?sstatehash,
254 prev_event = ?prev_event.event_id(),
255 )
256)]
257async fn state_at_incoming_fork<Pdu>(
258 &self,
259 room_id: &RoomId,
260 room_version: &RoomVersionId,
261 sstatehash: ShortStateHash,
262 prev_event: Pdu,
263) -> Result<(StateMap<OwnedEventId>, AuthSet<OwnedEventId>), ForkError>
264where
265 Pdu: Event,
266{
267 let leaf = prev_event
272 .state_key()
273 .map_stream(async |state_key| {
274 let event_id = prev_event.event_id();
275 let event_type = prev_event.kind().to_cow_str().into();
276 let shortstatekey = self
277 .services
278 .short
279 .get_or_create_shortstatekey(&event_type, state_key)
280 .await;
281
282 (shortstatekey, event_id.to_owned())
283 });
284
285 let snapshot = self
286 .services
287 .state_accessor
288 .state_full_ids_complete(sstatehash)
289 .map_err(ForkError::State)
290 .await?;
291
292 let leaf_state_after_event = leaf
294 .ready_fold(snapshot, |mut state, entry| {
295 state.push(entry);
296 state
297 })
298 .await;
299
300 trace!(
301 prev_event = ?prev_event.event_id(),
302 ?sstatehash,
303 leaf_states = leaf_state_after_event.len(),
304 "leaf state after event"
305 );
306
307 let state = leaf_state_after_event
308 .iter()
309 .map(|(shortstatekey, event_id)| (*shortstatekey, event_id));
310
311 let starting_events = leaf_state_after_event
312 .iter()
313 .map(ref_at!(1))
314 .map(AsRef::as_ref);
315
316 let (state, chain) =
317 join(self.fork_state(state), self.fork_chain(room_id, room_version, starting_events))
318 .await;
319
320 let chain = chain.map_err(ForkError::Chain)?;
321 let state = state.map_err(ForkError::State)?;
322
323 Ok((state, chain))
324}
325
326#[implement(super::Service)]
331pub(super) async fn fork_state<'a, State>(
332 &'a self,
333 state: State,
334) -> Result<StateMap<OwnedEventId>>
335where
336 State: Iterator<Item = (ShortStateKey, &'a OwnedEventId)> + Send + 'a,
337{
338 state
339 .stream()
340 .wide_then(|(k, id)| {
341 self.services
342 .short
343 .get_statekey_from_short(k)
344 .map_ok(|(ty, sk)| ((ty, sk), id.clone()))
345 })
346 .try_collect()
347 .await
348}
349
350#[implement(super::Service)]
356pub(super) async fn fork_chain<'a, Events>(
357 &'a self,
358 room_id: &'a RoomId,
359 room_version: &'a RoomVersionId,
360 starting_events: Events,
361) -> Result<AuthSet<OwnedEventId>>
362where
363 Events: Iterator<Item = &'a EventId> + Clone + ExactSizeIterator + Send + 'a,
364{
365 self.services
366 .auth_chain
367 .event_ids_iter(room_id, room_version, starting_events)
368 .try_collect()
369 .map_ok(AuthSet::from_distinct)
370 .await
371}
372
373#[implement(super::Service)]
378pub(super) async fn fork_chain_strict<'a, Events>(
379 &'a self,
380 room_id: &'a RoomId,
381 room_version: &'a RoomVersionId,
382 starting_events: Events,
383 complete: &'a AtomicBool,
384) -> Result<AuthSet<OwnedEventId>>
385where
386 Events: Iterator<Item = &'a EventId> + Clone + ExactSizeIterator + Send + 'a,
387{
388 self.services
389 .auth_chain
390 .event_ids_iter_strict(room_id, room_version, starting_events, complete)
391 .try_collect()
392 .map_ok(AuthSet::from_distinct)
393 .await
394}