tuwunel_service/rooms/delete/
mod.rs1use 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#[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() .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() .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() .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 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 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}