Skip to main content

tuwunel_admin/debug/
force_set_room_state_from_server.rs

1use std::collections::HashMap;
2
3use futures::TryStreamExt;
4use ruma::{
5	CanonicalJsonObject, EventId, OwnedEventId, OwnedRoomId, OwnedServerName, RoomId,
6	api::federation::event::get_room_state,
7};
8use tuwunel_core::{
9	Err, Result, err, info,
10	utils::{
11		IterStream, ReadyExt,
12		stream::{BroadbandExt, WidebandExt},
13	},
14	warn,
15};
16use tuwunel_matrix::{
17	Event, RoomVersionRules,
18	pdu::{PduEvent, from_incoming_federation},
19	room_version::rules as room_version_rules,
20};
21use tuwunel_service::{Services, rooms::state_compressor::HashSetCompressStateEvent};
22
23use crate::admin_command;
24
25#[admin_command]
26#[tracing::instrument(level = "debug", skip(self))]
27pub(super) async fn force_set_room_state_from_server(
28	&self,
29	room_id: OwnedRoomId,
30	server_name: OwnedServerName,
31) -> Result {
32	// TODO: diverged from join remote
33
34	if !self
35		.services
36		.state_cache
37		.server_in_room(&self.services.server.name, &room_id)
38		.await
39	{
40		return Err!("We are not participating in the room / we don't know about the room ID.");
41	}
42
43	let first_pdu = self
44		.services
45		.timeline
46		.latest_pdu_in_room(&room_id)
47		.await
48		.map_err(|_| err!(Database("Failed to find the latest PDU in database")))?;
49
50	let room_version = self
51		.services
52		.state
53		.get_room_version(&room_id)
54		.await?;
55
56	let rules = room_version_rules(&room_version)?;
57
58	let remote_state_response = self
59		.services
60		.federation
61		.execute(&server_name, get_room_state::v1::Request {
62			room_id: room_id.clone(),
63			event_id: first_pdu.event_id().to_owned(),
64		})
65		.await?;
66
67	for pdu in remote_state_response.pdus.clone() {
68		match self
69			.services
70			.event_handler
71			.parse_incoming_pdu(&pdu)
72			.await
73		{
74			| Ok(t) => t,
75			| Err(e) => {
76				warn!("Could not parse PDU, ignoring: {e}");
77				continue;
78			},
79		};
80	}
81
82	info!("Acquiring server signing keys for response events");
83	self.services
84		.server_keys
85		.acquire_events_pubkeys(
86			remote_state_response
87				.auth_chain
88				.iter()
89				.chain(remote_state_response.pdus.iter()),
90		)
91		.await;
92
93	let validate = |pdu| {
94		self.services
95			.server_keys
96			.validate_and_add_event_id_no_fetch(pdu, &room_version)
97	};
98
99	info!("Going through room_state response PDUs");
100	let state: HashMap<u64, OwnedEventId> = remote_state_response
101		.pdus
102		.iter()
103		.stream()
104		.wide_filter_map(async |pdu| {
105			let (event_id, value, _) = validate(pdu).await.ok()?;
106
107			ingest_state_pdu(self.services, &room_id, &event_id, value, &rules)
108				.await
109				.transpose()
110		})
111		.try_collect()
112		.await?;
113
114	info!("Going through auth_chain response");
115	remote_state_response
116		.auth_chain
117		.iter()
118		.stream()
119		.broad_then(|pdu| validate(pdu))
120		.ready_filter_map(Result::ok)
121		.ready_for_each(|(event_id, value, _)| {
122			let value = from_incoming_federation(&room_id, &event_id, value, &rules);
123
124			self.services
125				.timeline
126				.add_pdu_outlier(&event_id, &value);
127		})
128		.await;
129
130	let new_room_state = self
131		.services
132		.event_handler
133		.resolve_state(&room_id, &room_version, state)
134		.await?;
135
136	info!("Forcing new room state");
137	let HashSetCompressStateEvent {
138		shortstatehash: short_state_hash,
139		added,
140		removed,
141	} = self
142		.services
143		.state_compressor
144		.save_state(room_id.clone().as_ref(), new_room_state)
145		.await?;
146
147	let state_lock = self.services.state.mutex.lock(&*room_id).await;
148
149	self.services
150		.state
151		.force_state(room_id.clone().as_ref(), short_state_hash, added, removed, &state_lock)
152		.await?;
153
154	info!(
155		"Updating joined counts for room just in case (e.g. we may have found a difference in \
156		 the room's m.room.member state"
157	);
158	self.services
159		.state_cache
160		.update_joined_count(&room_id)
161		.await;
162
163	self.write_str("Successfully forced the room state from the requested remote server.")
164		.await
165}
166
167async fn ingest_state_pdu(
168	services: &Services,
169	room_id: &RoomId,
170	event_id: &EventId,
171	value: CanonicalJsonObject,
172	rules: &RoomVersionRules,
173) -> Result<Option<(u64, OwnedEventId)>> {
174	let invalid_pdu_err = |e| {
175		err!(BadServerResponse(debug_error!(
176			"Invalid PDU {event_id} in fetching remote room state PDUs response: {e:?}"
177		)))
178	};
179
180	let (pdu, value) = PduEvent::from_object_federation(room_id, event_id, value, rules)
181		.map_err(invalid_pdu_err)?;
182
183	services
184		.timeline
185		.add_pdu_outlier(event_id, &value);
186
187	let Some(state_key) = &pdu.state_key else {
188		return Ok(None);
189	};
190
191	let shortstatekey = services
192		.short
193		.get_or_create_shortstatekey(&pdu.kind.to_string().into(), state_key)
194		.await;
195
196	Ok(Some((shortstatekey, pdu.event_id)))
197}