Skip to main content

tuwunel_service/rooms/event_handler/
state_at_incoming.rs

1use 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// TODO: if we know the prev_events of the incoming event we can avoid the
31#[implement(super::Service)]
32// request and build the state from a known point and resolve if > 1 prev_event
33#[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	// Every event holding a `shorteventid_shortstatehash` row passed spec check 5
104	// (auth against the state at its own position) as a hard reject; soft failure
105	// (spec check 6) still writes the row, so soft-failed events are valid fold
106	// inputs while positionally rejected events never gain a row.
107	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		// Now it's the state after the pdu
118		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
229/// The fork a prev event contributes to resolution.
230///
231/// A prev's snapshot is the state before it, so a state prev also carries its
232/// own event; siblings sharing a snapshot share a fork only when neither sets
233/// state.
234fn 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	// Every event holding a `shorteventid_shortstatehash` row passed spec check 5
268	// (auth against the state at its own position) as a hard reject; soft failure
269	// (spec check 6) still writes the row, so soft-failed events are valid fold
270	// inputs while positionally rejected events never gain a row.
271	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	// The leaf goes last so `fork_state` lets it replace the snapshot's entry.
293	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/// Converts one fork branch from short state keys to typed state keys.
327///
328/// A later duplicate state key replaces an earlier entry. Short state key
329/// lookup failures are returned without constructing a partial map.
330#[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/// Collects the full auth chain for one fork branch.
351///
352/// The chain walk dedups short ids, so the ids are distinct unless a damaged
353/// short-id mapping repeats one, which the auth difference counts once.
354/// Iteration order is arbitrary.
355#[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/// Collects the strict full auth chain for one fork branch.
374///
375/// The shared completeness flag is cleared when a polled chain source cannot
376/// be loaded.
377#[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}