Skip to main content

tuwunel_service/rooms/delete/
mod.rs

1use std::sync::Arc;
2
3use futures::{FutureExt, StreamExt};
4use ruma::{OwnedRoomAliasId, OwnedRoomId, OwnedUserId, RoomId};
5use serde::{Deserialize, Serialize};
6use tuwunel_core::{Result, debug, result::LogErr, trace, utils::future::BoolExt, warn};
7
8use crate::rooms::timeline::RoomMutexGuard;
9
10#[cfg(test)]
11mod tests;
12
13pub struct Service {
14	services: Arc<crate::services::OnceServices>,
15}
16
17/// Records local-user eviction results and aliases targeted for removal.
18///
19/// Its serialized layout matches Synapse's `ShutdownRoom`.
20#[derive(Clone, Debug, Default, Serialize, Deserialize)]
21pub struct ShutdownRoom {
22	pub kicked_users: Vec<OwnedUserId>,
23	pub failed_to_kick_users: Vec<OwnedUserId>,
24	pub local_aliases: Vec<OwnedRoomAliasId>,
25	pub new_room_id: Option<OwnedRoomId>,
26}
27
28impl crate::Service for Service {
29	fn build(args: &crate::Args<'_>) -> Result<Arc<Self>> {
30		Ok(Arc::new(Self { services: args.services.clone() }))
31	}
32
33	fn name(&self) -> &str { crate::service::make_name(std::module_path!()) }
34}
35
36impl Service {
37	pub async fn delete_if_empty_local(&self, room_id: &RoomId, state_lock: RoomMutexGuard) {
38		debug_assert!(
39			self.services.config.rooms.delete_after_leave,
40			"Caller must check whether rooms.delete_after_leave is configured."
41		);
42
43		let has_local_users = self
44			.services
45			.state_cache
46			.local_users_in_room(room_id)
47			.boxed() // Unpin for into_future
48			.into_future()
49			.map(|(next, ..)| next.as_ref().is_some());
50
51		let has_local_invites = self
52			.services
53			.state_cache
54			.local_users_invited_to_room(room_id)
55			.boxed() // Unpin for into_future
56			.into_future()
57			.map(|(next, ..)| next.as_ref().is_some());
58
59		if has_local_users.or(has_local_invites).await {
60			trace!(?room_id, "Not deleting with local joined or invited");
61			return;
62		}
63
64		debug!(?room_id, "Preparing to delete room...");
65
66		self.services
67			.delete
68			.delete_room(room_id, false, state_lock)
69			.boxed() // size firewall
70			.await
71			.expect("unhandled error during room deletion");
72	}
73
74	pub async fn delete_room(
75		&self,
76		room_id: &RoomId,
77		force: bool,
78		state_lock: RoomMutexGuard,
79	) -> Result<ShutdownRoom> {
80		let summary = self.shutdown_room(room_id, &state_lock).await;
81
82		self.purge_room(room_id, force, &state_lock).await;
83
84		debug!(?room_id, "Successfully deleted room from our database");
85
86		Ok(summary)
87	}
88
89	/// Evicts every local user, strips the room's local aliases, and
90	/// unpublishes it from the directory, returning the shutdown summary. The
91	/// admin delete runs this phase alone when `purge` is false.
92	pub async fn shutdown_room(
93		&self,
94		room_id: &RoomId,
95		state_lock: &RoomMutexGuard,
96	) -> ShutdownRoom {
97		debug!(?room_id, "Making all local users leave the room and forgetting it");
98		let (kicked_users, failed_to_kick_users) = self
99			.services
100			.state_cache
101			.local_users_in_room(room_id)
102			.map(ToOwned::to_owned)
103			.fold((Vec::new(), Vec::new()), async |(mut kicked, mut failed), user_id| {
104				match self
105					.services
106					.membership
107					.leave(&user_id, room_id, Some("Room Deleted".into()), true, state_lock)
108					.await
109				{
110					| Ok(()) => kicked.push(user_id),
111					| Err(e) => {
112						warn!(%e, "Failed to leave room");
113						failed.push(user_id);
114					},
115				}
116
117				(kicked, failed)
118			})
119			.await;
120
121		debug!("Deleting all our room aliases for the room");
122		let local_aliases = self
123			.services
124			.alias
125			.local_aliases_for_room(room_id)
126			.map(ToOwned::to_owned)
127			.collect::<Vec<_>>()
128			.await;
129
130		for alias in &local_aliases {
131			self.services
132				.alias
133				.remove_alias(alias)
134				.await
135				.log_err()
136				.ok();
137		}
138
139		debug!("Removing/unpublishing room from our room directory");
140		self.services.directory.set_not_public(room_id);
141
142		ShutdownRoom {
143			kicked_users,
144			failed_to_kick_users,
145			local_aliases,
146			new_room_id: None,
147		}
148	}
149
150	/// Wipes the room's storage. `force` widens the erasure of local users'
151	/// left-state (it is not Synapse's `force_purge`).
152	async fn purge_room(&self, room_id: &RoomId, force: bool, state_lock: &RoomMutexGuard) {
153		debug!("Deleting room's threads from database");
154		self.services
155			.threads
156			.delete_all_rooms_threads(room_id)
157			.await
158			.log_err()
159			.ok();
160
161		debug!("Deleting all the room's search token IDs from our database");
162		self.services
163			.search
164			.delete_all_search_tokenids_for_room(room_id)
165			.await
166			.log_err()
167			.ok();
168
169		debug!("Deleting all room's forward extremities from our database");
170		self.services
171			.state
172			.delete_all_rooms_forward_extremities(room_id)
173			.await
174			.log_err()
175			.ok();
176
177		debug!("Deleting all the room's event (PDU) references");
178		self.services
179			.pdu_metadata
180			.delete_all_referenced_for_room(room_id)
181			.await
182			.log_err()
183			.ok();
184
185		debug!("Deleting all the room's typed relation index entries");
186		self.services
187			.pdu_metadata
188			.delete_all_relatesto_typed_for_room(room_id)
189			.await
190			.log_err()
191			.ok();
192
193		debug!("Deleting all the room's soft-fail markers");
194		self.services
195			.pdu_metadata
196			.delete_all_soft_failed_for_room(room_id)
197			.await;
198
199		debug!("Deleting all the room's member counts");
200		self.services
201			.state_cache
202			.delete_room_join_counts(room_id, force)
203			.await
204			.log_err()
205			.ok();
206
207		debug!("Deleting all the room's private read receipts");
208		self.services
209			.read_receipt
210			.delete_all_read_receipts(room_id)
211			.await
212			.log_err()
213			.ok();
214
215		debug!("Deleting the room's last notifications read.");
216		self.services
217			.pusher
218			.delete_room_notification_read(room_id)
219			.await
220			.log_err()
221			.ok();
222
223		debug!("Deleting room state hash from our database");
224		self.services
225			.state
226			.delete_room_shortstatehash(room_id, state_lock)
227			.log_err()
228			.ok();
229
230		debug!("Deleting PDUs");
231		self.services
232			.timeline
233			.delete_pdus(room_id)
234			.await
235			.log_err()
236			.ok();
237
238		debug!("Deleting internal room ID from our database");
239		self.services
240			.short
241			.delete_shortroomid(room_id)
242			.await
243			.log_err()
244			.ok();
245	}
246}