tuwunel_admin/debug/
force_set_room_state_from_server.rs1use 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 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}