Skip to main content

tuwunel_service/rooms/event_handler/
resolve_state.rs

1use 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			// The chain walk dedups short ids, so these are distinct unless a damaged
67			// short-id mapping repeats one, which the auth difference counts once.
68			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}