wip: Room data purging

.forgejo/actions/timelord/action.yml

@@ -71,7 +71,7 @@ runs:
 
     - name: Install timelord-cli and git-warp-time
       if: steps.check-binaries.outputs.need-install == 'true'
-      uses: https://github.com/taiki-e/install-action@b5fddbb5361bce8a06fb168c9d403a6cc552b084 # v2
+      uses: https://github.com/taiki-e/install-action@787505cde8a44ea468a00478fe52baf23b15bccd # v2
       with:
         tool: git-warp-time,timelord-cli@3.0.1
 

Cargo.toml

@@ -39,10 +39,7 @@ features = ["ffi", "std", "union"]
 version = "1.1.0"
 
 [workspace.dependencies.ctor]
-version = "0.13.0"
-
-[workspace.dependencies.dtor]
-version = "0.13.0"
+version = "0.10.0"
 
 [workspace.dependencies.cargo_toml]
 version = "0.22"
@@ -433,7 +430,7 @@ features = ["http", "grpc-tonic", "trace", "logs", "metrics"]
 
 # optional sentry metrics for crash/panic reporting
 [workspace.dependencies.sentry]
-version = "0.48.0"
+version = "0.47.0"
 default-features = false
 features = [
     "backtrace",
@@ -448,9 +445,9 @@ features = [
 ]
 
 [workspace.dependencies.sentry-tracing]
-version = "0.48.0"
+version = "0.47.0"
 [workspace.dependencies.sentry-tower]
-version = "0.48.0"
+version = "0.47.0"
 
 # jemalloc usage
 [workspace.dependencies.tikv-jemalloc-sys]
@@ -558,7 +555,7 @@ features = ["sync", "tls-rustls", "rustls-provider"]
 version = "1.0.1"
 
 [workspace.dependencies.askama]
-version = "0.16.0"
+version = "0.15.0"
 
 [workspace.dependencies.lettre]
 version = "0.11.19"

changelog.d/+48bfd52a.bugfix.md

@@ -1 +0,0 @@
-The invite recipient's membership event is now included in invite stripped state, which should fix flaky invite display in some clients. Contributed by @ginger

docker/Dockerfile

@@ -50,7 +50,7 @@ EOF
 
 # Developer tool versions
 # renovate: datasource=github-releases depName=cargo-bins/cargo-binstall
-ENV BINSTALL_VERSION=1.19.0
+ENV BINSTALL_VERSION=1.18.1
 # renovate: datasource=github-releases depName=psastras/sbom-rs
 ENV CARGO_SBOM_VERSION=0.9.1
 # renovate: datasource=crate depName=lddtree

docker/musl.Dockerfile

@@ -18,7 +18,7 @@ RUN --mount=type=cache,target=/etc/apk/cache apk add \
 
 # Developer tool versions
 # renovate: datasource=github-releases depName=cargo-bins/cargo-binstall
-ENV BINSTALL_VERSION=1.19.0
+ENV BINSTALL_VERSION=1.18.1
 # renovate: datasource=github-releases depName=psastras/sbom-rs
 ENV CARGO_SBOM_VERSION=0.9.1
 # renovate: datasource=crate depName=lddtree

flake.lock

@@ -3,11 +3,11 @@
     "advisory-db": {
       "flake": false,
       "locked": {
-        "lastModified": 1777645914,
-        "narHash": "sha256-P1T7QVQS13OvkXEuEhI91CLaQfyv6iqV9vW8IBLLDYg=",
+        "lastModified": 1775907537,
+        "narHash": "sha256-vbeLNgmsx1Z6TwnlDV0dKyeBCcon3UpkV9yLr/yc6HM=",
         "owner": "rustsec",
         "repo": "advisory-db",
-        "rev": "d6ba1f7070ba91f45efe372d68eb648be67d0417",
+        "rev": "d99f7b9eb81731bddebf80a355f8be7b2f8b1b28",
         "type": "github"
       },
       "original": {
@@ -18,11 +18,11 @@
     },
     "crane": {
       "locked": {
-        "lastModified": 1777335812,
-        "narHash": "sha256-bEg5xoAxAwsyfnGhkEX7RJViTIBIYPd8ISg4O1c0HFc=",
+        "lastModified": 1775839657,
+        "narHash": "sha256-SPm9ck7jh3Un9nwPuMGbRU04UroFmOHjLP56T10MOeM=",
         "owner": "ipetkov",
         "repo": "crane",
-        "rev": "5e0fb2f64edff2822249f21293b8304dedaaf676",
+        "rev": "7cf72d978629469c4bd4206b95c402514c1f6000",
         "type": "github"
       },
       "original": {
@@ -39,11 +39,11 @@
         "rust-analyzer-src": "rust-analyzer-src"
       },
       "locked": {
-        "lastModified": 1777624102,
-        "narHash": "sha256-thSyElkje577x/kAbP72nHlfiFc1a+tCudskLPHXe9s=",
+        "lastModified": 1775891769,
+        "narHash": "sha256-EOfVlTKw2n8w1uhfh46GS4hEGnQ7oWrIWQfIY6utIkI=",
         "owner": "nix-community",
         "repo": "fenix",
-        "rev": "4d81601e0b73f20d81d066754ad0e7d1e7f75a06",
+        "rev": "6fbc54dde15aee725bdc7aae5e478849685d5f56",
         "type": "github"
       },
       "original": {
@@ -89,11 +89,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1777268161,
-        "narHash": "sha256-bxrdOn8SCOv8tN4JbTF/TXq7kjo9ag4M+C8yzzIRYbE=",
+        "lastModified": 1775710090,
+        "narHash": "sha256-ar3rofg+awPB8QXDaFJhJ2jJhu+KqN/PRCXeyuXR76E=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "1c3fe55ad329cbcb28471bb30f05c9827f724c76",
+        "rev": "4c1018dae018162ec878d42fec712642d214fdfa",
         "type": "github"
       },
       "original": {
@@ -132,11 +132,11 @@
     "rust-analyzer-src": {
       "flake": false,
       "locked": {
-        "lastModified": 1777583169,
-        "narHash": "sha256-dVJ4+wrRKc8oIgp3rLOFSq1obt/sCKlXy3h47qof/w0=",
+        "lastModified": 1775843361,
+        "narHash": "sha256-j53ZgyDvmYf3Sjh1IPvvTjqa614qUfVQSzj59+MpzkY=",
         "owner": "rust-lang",
         "repo": "rust-analyzer",
-        "rev": "aa64e4828a2bbba44463c1229a81c748d3cce583",
+        "rev": "9eb97ea96d8400e8957ddd56702e962614296583",
         "type": "github"
       },
       "original": {

package-lock.json

@@ -1399,9 +1399,9 @@
       }
     },
     "node_modules/hookable": {
-      "version": "6.1.1",
-      "resolved": "https://registry.npmjs.org/hookable/-/hookable-6.1.1.tgz",
-      "integrity": "sha512-U9LYDy1CwhMCnprUfeAZWZGByVbhd54hwepegYTK7Pi5NvqEj63ifz5z+xukznehT7i6NIZRu89Ay1AZmRsLEQ==",
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/hookable/-/hookable-6.1.0.tgz",
+      "integrity": "sha512-ZoKZSJgu8voGK2geJS+6YtYjvIzu9AOM/KZXsBxr83uhLL++e9pEv/dlgwgy3dvHg06kTz6JOh1hk3C8Ceiymw==",
       "dev": true,
       "license": "MIT"
     },
@@ -2683,20 +2683,20 @@
       "license": "MIT"
     },
     "node_modules/oniguruma-parser": {
-      "version": "0.12.2",
-      "resolved": "https://registry.npmjs.org/oniguruma-parser/-/oniguruma-parser-0.12.2.tgz",
-      "integrity": "sha512-6HVa5oIrgMC6aA6WF6XyyqbhRPJrKR02L20+2+zpDtO5QAzGHAUGw5TKQvwi5vctNnRHkJYmjAhRVQF2EKdTQw==",
+      "version": "0.12.1",
+      "resolved": "https://registry.npmjs.org/oniguruma-parser/-/oniguruma-parser-0.12.1.tgz",
+      "integrity": "sha512-8Unqkvk1RYc6yq2WBYRj4hdnsAxVze8i7iPfQr8e4uSP3tRv0rpZcbGUDvxfQQcdwHt/e9PrMvGCsa8OqG9X3w==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/oniguruma-to-es": {
-      "version": "4.3.6",
-      "resolved": "https://registry.npmjs.org/oniguruma-to-es/-/oniguruma-to-es-4.3.6.tgz",
-      "integrity": "sha512-csuQ9x3Yr0cEIs/Zgx/OEt9iBw9vqIunAPQkx19R/fiMq2oGVTgcMqO/V3Ybqefr1TBvosI6jU539ksaBULJyA==",
+      "version": "4.3.5",
+      "resolved": "https://registry.npmjs.org/oniguruma-to-es/-/oniguruma-to-es-4.3.5.tgz",
+      "integrity": "sha512-Zjygswjpsewa0NLTsiizVuMQZbp0MDyM6lIt66OxsF21npUDlzpHi1Mgb/qhQdkb+dWFTzJmFbEWdvZgRho8eQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "oniguruma-parser": "^0.12.2",
+        "oniguruma-parser": "^0.12.1",
         "regex": "^6.1.0",
         "regex-recursion": "^6.0.2"
       }
@@ -2822,9 +2822,9 @@
       }
     },
     "node_modules/react-router": {
-      "version": "7.14.2",
-      "resolved": "https://registry.npmjs.org/react-router/-/react-router-7.14.2.tgz",
-      "integrity": "sha512-yCqNne6I8IB6rVCH7XUvlBK7/QKyqypBFGv+8dj4QBFJiiRX+FG7/nkdAvGElyvVZ/HQP5N19wzteuTARXi5Gw==",
+      "version": "7.14.0",
+      "resolved": "https://registry.npmjs.org/react-router/-/react-router-7.14.0.tgz",
+      "integrity": "sha512-m/xR9N4LQLmAS0ZhkY2nkPA1N7gQ5TUVa5n8TgANuDTARbn1gt+zLPXEm7W0XDTbrQ2AJSJKhoa6yx1D8BcpxQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -2845,13 +2845,13 @@
       }
     },
     "node_modules/react-router-dom": {
-      "version": "7.14.2",
-      "resolved": "https://registry.npmjs.org/react-router-dom/-/react-router-dom-7.14.2.tgz",
-      "integrity": "sha512-YZcM5ES8jJSM+KrJ9BdvHHqlnGTg5tH3sC5ChFRj4inosKctdyzBDhOyyHdGk597q2OT6NTrCA1OvB/YDwfekQ==",
+      "version": "7.14.0",
+      "resolved": "https://registry.npmjs.org/react-router-dom/-/react-router-dom-7.14.0.tgz",
+      "integrity": "sha512-2G3ajSVSZMEtmTjIklRWlNvo8wICEpLihfD/0YMDxbWK2UyP5EGfnoIn9AIQGnF3G/FX0MRbHXdFcD+rL1ZreQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "react-router": "7.14.2"
+        "react-router": "7.14.0"
       },
       "engines": {
         "node": ">=20.0.0"

src/admin/Cargo.toml

@@ -81,7 +81,6 @@ conduwuit-macros.workspace = true
 conduwuit-service.workspace = true
 const-str.workspace = true
 ctor.workspace = true
-dtor.workspace = true
 futures.workspace = true
 lettre.workspace = true
 log.workspace = true

src/admin/room/moderation.rs

@@ -1,9 +1,9 @@
 use api::client::leave_room;
 use clap::Subcommand;
 use conduwuit::{
-	Err, Result, debug, info,
-	utils::{IterStream, ReadyExt},
-	warn,
+	debug, info, utils::{IterStream, ReadyExt}, warn,
+	Err,
+	Result,
 };
 use futures::{FutureExt, StreamExt};
 use ruma::{OwnedRoomId, OwnedRoomOrAliasId, RoomAliasId, RoomId, RoomOrAliasId};
@@ -43,6 +43,12 @@ pub enum RoomModerationCommand {
 		/// information
 		no_details: bool,
 	},
+
+	/// Deletes a room
+	Delete {
+		/// The room ID
+		room_id: OwnedRoomId,
+	},
 }
 
 #[admin_command]
@@ -452,3 +458,62 @@ async fn list_banned_rooms(&self, no_details: bool) -> Result {
 	self.write_str(&format!("Rooms Banned ({num}):\n```\n{body}\n```"))
 		.await
 }
+
+#[admin_command]
+async fn delete(&self, room_id: OwnedRoomId) -> Result {
+	let is_banned = self.services.rooms.metadata.is_banned(&room_id).await;
+	let is_disabled = self.services.rooms.metadata.is_disabled(&room_id).await;
+
+	// Temporarily forcefully ban the room to prevent people trying to join while
+	// deletion is ongoing.
+	self.services.rooms.metadata.disable_room(&room_id, true);
+	self.services.rooms.metadata.ban_room(&room_id, true);
+
+	let mut users = self
+		.services
+		.rooms
+		.state_cache
+		.room_members(&room_id)
+		.ready_filter(|user| self.services.globals.user_is_local(user))
+		.boxed();
+
+	while let Some(ref user_id) = users.next().await {
+		info!("Removing {user_id} from {room_id}",);
+
+		if let Err(e) = leave_room(self.services, user_id, &room_id, None)
+			.boxed()
+			.await
+		{
+			warn!("Failed to remove {user_id} from {room_id}: {e}");
+		}
+
+		self.services.rooms.state_cache.forget(&room_id, user_id);
+	}
+
+	self.services
+		.rooms
+		.alias
+		.local_aliases_for_room(&room_id)
+		.for_each(|local_alias| async move {
+			info!("Removing alias {local_alias}");
+			self.services
+				.rooms
+				.alias
+				.remove_alias(&local_alias, &self.services.globals.server_user)
+				.await
+				.ok();
+		})
+		.await;
+
+	info!("Removing the room from the directory if it is present");
+	self.services.rooms.directory.set_not_public(&room_id);
+	info!("Removing lazy-loading metadata");
+	self.services.rooms.lazy_loading.purge(&room_id).await;
+	info!("Removing PDU metadata");
+	self.services.rooms.pdu_metadata.purge(&room_id).await;
+	info!("Removing state cache");
+	self.services.rooms.state_cache.purge(&room_id).await;
+	info!("Removing room state");
+	self.services.rooms.state.purge(&room_id).await;
+	Ok(())
+}

src/api/Cargo.toml

@@ -77,7 +77,6 @@ conduwuit-macros.workspace = true
 conduwuit-service.workspace = true
 const-str.workspace = true
 ctor.workspace = true
-dtor.workspace = true
 futures.workspace = true
 hmac.workspace = true
 http.workspace = true

src/api/client/media.rs

@@ -118,8 +118,9 @@ pub(crate) async fn get_content_thumbnail_route(
 	} = match fetch_thumbnail_meta(&services, &mxc, user, body.timeout_ms, &dim).await {
 		| Ok(meta) => meta,
 		| Err(conduwuit::Error::Io(e)) => match e.kind() {
-			| std::io::ErrorKind::NotFound =>
-				return Err!(Request(NotFound("Thumbnail not found."))),
+			| std::io::ErrorKind::NotFound => {
+				return Err!(Request(NotFound("Thumbnail not found.")));
+			},
 			| std::io::ErrorKind::PermissionDenied => {
 				error!("Permission denied when trying to read file: {e:?}");
 				return Err!(Request(Unknown("Unknown error when fetching thumbnail.")));

src/api/client/membership/invite.rs

@@ -163,11 +163,7 @@ pub(crate) async fn invite_helper(
 				)
 				.await?;
 
-			let invite_room_state = services
-				.rooms
-				.state
-				.summary_stripped(&pdu, room_id, recipient_user)
-				.await;
+			let invite_room_state = services.rooms.state.summary_stripped(&pdu, room_id).await;
 
 			drop(state_lock);
 

src/api/client/state.rs

@@ -375,7 +375,7 @@ async fn allowed_to_send_state_event(
 				},
 			}
 		},
-		| StateEventType::RoomMember =>
+		| StateEventType::RoomMember => {
 			match json.deserialize_as_unchecked::<RoomMemberEventContent>() {
 				| Ok(mut membership_content) => {
 					let Ok(state_key) = UserId::parse(state_key) else {
@@ -434,7 +434,8 @@ async fn allowed_to_send_state_event(
 						 membership state: {e}"
 					)));
 				},
-			},
+			}
+		},
 		| _ => (),
 	}
 

src/api/client/well_known.rs

@@ -19,10 +19,11 @@ pub(crate) async fn well_known_client(
 ) -> Result<discover_homeserver::Response> {
 	let client_url = match services.config.well_known.client.as_ref() {
 		| Some(url) => url.to_string(),
-		| None =>
+		| None => {
 			return Err!(Request(NotFound(
 				"This server is not configured to serve well-known client information."
-			))),
+			)));
+		},
 	};
 
 	Ok(assign!(discover_homeserver::Response::new(HomeserverInfo::new(client_url)), {

src/api/router/auth.rs

@@ -89,8 +89,9 @@ impl CheckAuth for ServerSignatures {
 				origin: Some(output.origin.clone()),
 				..Default::default()
 			}),
-			| Err(err) =>
-				Err!(Request(Unauthorized(warn!("Failed to verify X-Matrix header: {err}")))),
+			| Err(err) => {
+				Err!(Request(Unauthorized(warn!("Failed to verify X-Matrix header: {err}"))))
+			},
 		}
 	}
 }

src/api/server/make_join.rs

@@ -252,7 +252,7 @@ pub(crate) async fn user_can_perform_restricted_join(
 					return Ok(true);
 				}
 			},
-			| other if other.rule_type() == "fi.mau.spam_checker" =>
+			| other if other.rule_type() == "fi.mau.spam_checker" => {
 				return match services
 					.antispam
 					.meowlnir_accept_make_join(room_id.to_owned(), user_id.to_owned())
@@ -260,7 +260,8 @@ pub(crate) async fn user_can_perform_restricted_join(
 				{
 					| Ok(()) => Ok(true),
 					| Err(_) => Err!(Request(Forbidden("Antispam rejected join request."))),
-				},
+				};
+			},
 			| _ => {
 				// We don't recognise this join rule, so we cannot satisfy the request.
 				could_satisfy = false;

src/api/server/send_knock.rs

@@ -183,7 +183,7 @@ pub(crate) async fn create_knock_event_v1_route(
 	let knock_room_state = services
 		.rooms
 		.state
-		.summary_stripped(&pdu, &body.room_id, &sender)
+		.summary_stripped(&pdu, &body.room_id)
 		.await;
 
 	Ok(create_knock_event::v1::Response::new(knock_room_state))

src/core/Cargo.toml

@@ -70,7 +70,6 @@ conduwuit-build-metadata.workspace = true
 const-str.workspace = true
 core_affinity.workspace = true
 ctor.workspace = true
-dtor.workspace = true
 cyborgtime.workspace = true
 either.workspace = true
 figment.workspace = true
@@ -87,7 +86,7 @@ lettre.workspace = true
 num-traits.workspace = true
 rand.workspace = true
 # tied to passwordhash 0.5.0
-rand_core = { version = "0.10.0", features = ["getrandom"] }
+rand_core = { version = "0.6.4", features = ["getrandom"] }
 regex.workspace = true
 reqwest.workspace = true
 sha2.workspace = true

src/core/alloc/je.rs

@@ -47,7 +47,7 @@ type Key = ArrayVec<usize, KEY_SEGS>;
 const NAME_MAX: usize = 128;
 const KEY_SEGS: usize = 8;
 
-#[ctor::ctor(unsafe)]
+#[ctor::ctor]
 fn _static_initialization() {
 	acq_epoch().expect("pre-initialization of jemalloc failed");
 	acq_epoch().expect("pre-initialization of jemalloc failed");

src/core/debug.rs

@@ -62,7 +62,7 @@ pub const INFO_SPAN_LEVEL: Level = if cfg!(debug_assertions) {
 pub static DEBUGGER: LazyLock<bool> =
 	LazyLock::new(|| env::var("_").unwrap_or_default().ends_with("gdb"));
 
-#[cfg_attr(debug_assertions, ctor::ctor(unsafe))]
+#[cfg_attr(debug_assertions, ctor::ctor)]
 #[cfg_attr(not(debug_assertions), allow(dead_code))]
 fn set_panic_trap() {
 	if !*DEBUGGER {

src/database/Cargo.toml

@@ -58,7 +58,6 @@ conduwuit-core.workspace = true
 conduwuit-macros.workspace = true
 const-str.workspace = true
 ctor.workspace = true
-dtor.workspace = true
 futures.workspace = true
 log.workspace = true
 minicbor.workspace = true

src/macros/build_info.rs

@@ -32,11 +32,11 @@ pub(super) fn introspect(_args: TokenStream) -> Result<TokenStream> {
 			const CRATE_NAME: &str = #crate_name;
 
 			/// Register this crate's features with the global registry during static initialization
-			#[::ctor::ctor(unsafe)]
+			#[::ctor::ctor]
 			fn register() {
 				conduwuit_core::info::introspection::ENABLED_FEATURES.lock().unwrap().insert(#crate_name, &ENABLED);
 			}
-			#[::dtor::dtor(unsafe)]
+			#[::ctor::dtor]
 			fn unregister() {
 				conduwuit_core::info::introspection::ENABLED_FEATURES.lock().unwrap().remove(#crate_name);
 			}

src/main/Cargo.toml

@@ -217,7 +217,6 @@ conduwuit-macros.workspace = true
 
 clap.workspace = true
 ctor.workspace = true
-dtor.workspace = true
 console-subscriber.optional = true
 console-subscriber.workspace = true
 const-str.workspace = true

src/router/Cargo.toml

@@ -105,7 +105,6 @@ conduwuit-service.workspace = true
 conduwuit-web.workspace = true
 const-str.workspace = true
 ctor.workspace = true
-dtor.workspace = true
 futures.workspace = true
 http.workspace = true
 http-body-util.workspace = true

src/service/Cargo.toml

@@ -89,7 +89,6 @@ conduwuit-database.workspace = true
 conduwuit-macros.workspace = true
 const-str.workspace = true
 ctor.workspace = true
-dtor.workspace = true
 either.workspace = true
 futures.workspace = true
 governor.workspace = true

src/service/admin/create.rs

@@ -160,7 +160,10 @@ pub async fn create_admin_room(services: &Services) -> Result {
 		.boxed()
 		.await?;
 
-	let room_topic = format!("Manage {} | Run commands prefixed with `!admin` | Run `!admin -h` for help | Documentation: https://continuwuity.org/", services.config.server_name);
+	let room_topic = format!(
+		"Manage {} | Run commands prefixed with `!admin` | Run `!admin -h` for help | Documentation: https://continuwuity.org/",
+		services.config.server_name
+	);
 	services
 		.rooms
 		.timeline

src/service/firstrun/mod.rs

@@ -312,7 +312,9 @@ impl Service {
 				 to open the console."
 			);
 		}
-		eprintln!("If you need assistance setting up your homeserver, make a Matrix account on another homeserver and join our chatroom: https://matrix.to/#/#continuwuity:continuwuity.org");
+		eprintln!(
+			"If you need assistance setting up your homeserver, make a Matrix account on another homeserver and join our chatroom: https://matrix.to/#/#continuwuity:continuwuity.org"
+		);
 
 		eprintln!("{}", "============".bold());
 	}

src/service/migrations.rs

@@ -802,7 +802,7 @@ async fn fix_local_invite_state(services: &Services) -> Result {
 				&& services.globals.user_is_local(&membership_event.sender) {
 
 				// build and save stripped state for their invite in the database
-				let stripped_state = services.rooms.state.summary_stripped(&membership_event, &room_id, &user_id).await;
+				let stripped_state = services.rooms.state.summary_stripped(&membership_event, &room_id).await;
 				userroomid_invitestate.put((&user_id, &room_id), Json(stripped_state));
 				fixed = fixed.saturating_add(1);
 			}

src/service/rooms/lazy_loading/mod.rs

@@ -67,6 +67,17 @@ pub async fn reset(&self, ctx: &Context<'_>) {
 		.await;
 }
 
+#[implement(Service)]
+pub async fn purge(&self, room_id: &RoomId) {
+	let prefix = (Interfix, Interfix, room_id, Interfix);
+	self.db
+		.lazyloadedids
+		.keys_prefix_raw(&prefix)
+		.ignore_err()
+		.ready_for_each(|key| self.db.lazyloadedids.remove(key))
+		.await;
+}
+
 /// Returns only the subset of `senders` which should be sent to the client
 /// according to the provided lazy loading context.
 #[implement(Service)]

src/service/rooms/pdu_metadata/data.rs

@@ -9,7 +9,7 @@ use conduwuit::{
 		u64_from_u8,
 	},
 };
-use database::Map;
+use database::{Interfix, Map};
 use futures::{Stream, StreamExt};
 use ruma::{EventId, RoomId, UserId, api::Direction};
 
@@ -46,6 +46,16 @@ impl Data {
 		}
 	}
 
+	pub(super) async fn purge(&self, room_id: &RoomId) {
+		// NOTE: This does not remove soft-failed event references, that must be done
+		// somewhere else.
+		self.referencedevents
+			.keys_prefix_raw(&(room_id, Interfix))
+			.ignore_err()
+			.ready_for_each(|key| self.referencedevents.remove(key))
+			.await;
+	}
+
 	pub(super) fn add_relation(&self, from: u64, to: u64) {
 		const BUFSIZE: usize = size_of::<u64>() * 2;
 
@@ -121,4 +131,8 @@ impl Data {
 	pub(super) async fn is_event_soft_failed(&self, event_id: &EventId) -> bool {
 		self.softfailedeventids.get(event_id).await.is_ok()
 	}
+
+	pub(super) async fn remove_soft_fail_marker(&self, event_id: &EventId) {
+		self.softfailedeventids.remove(event_id);
+	}
 }

src/service/rooms/pdu_metadata/mod.rs

@@ -140,4 +140,10 @@ impl Service {
 	pub async fn is_event_soft_failed(&self, event_id: &EventId) -> bool {
 		self.db.is_event_soft_failed(event_id).await
 	}
+
+	pub async fn purge(&self, room_id: &RoomId) { self.db.purge(room_id).await; }
+
+	pub async fn remove_soft_fail_marker(&self, event_id: &EventId) {
+		self.db.remove_soft_fail_marker(event_id).await;
+	}
 }

src/service/rooms/read_receipt/data.rs

@@ -115,4 +115,12 @@ impl Data {
 			.deserialized()
 			.unwrap_or(0)
 	}
+
+	pub(super) async fn purge(&self, room_id: &RoomId) {
+		self.readreceiptid_readreceipt
+			.keys_prefix_raw(room_id)
+			.ignore_err()
+			.ready_for_each(|key| self.readreceiptid_readreceipt.remove(key))
+			.await;
+	}
 }

src/service/rooms/read_receipt/mod.rs

@@ -142,6 +142,8 @@ impl Service {
 	pub async fn last_privateread_update(&self, user_id: &UserId, room_id: &RoomId) -> u64 {
 		self.db.last_privateread_update(user_id, room_id).await
 	}
+
+	pub async fn purge(&self, room_id: &RoomId) { self.db.purge(room_id).await }
 }
 
 #[must_use]

src/service/rooms/state/mod.rs

@@ -3,32 +3,32 @@ use std::{collections::HashMap, fmt::Write, sync::Arc};
 use async_trait::async_trait;
 use conduwuit::debug;
 use conduwuit_core::{
-	Event, PduEvent, Result, err,
-	result::FlatOk,
-	state_res::{self, StateMap},
-	utils::{
-		IterStream, MutexMap, MutexMapGuard, ReadyExt, calculate_hash,
-		stream::{BroadbandExt, TryIgnore},
+	err, result::FlatOk, state_res::{self, StateMap}, utils::{
+		calculate_hash, stream::{BroadbandExt, TryIgnore}, IterStream, MutexMap, MutexMapGuard,
+		ReadyExt,
 	},
 	warn,
+	Event,
+	PduEvent,
+	Result,
 };
 use conduwuit_database::{Deserialized, Ignore, Interfix, Map};
 use futures::{
-	FutureExt, Stream, StreamExt, TryFutureExt, TryStreamExt, future::join_all, pin_mut,
+	future::join_all, pin_mut, FutureExt, Stream, StreamExt, TryFutureExt, TryStreamExt,
 };
 use ruma::{
-	EventId, OwnedEventId, OwnedRoomId, RoomId, RoomVersionId, UserId,
-	api::federation::membership::RawStrippedState,
-	events::{StateEventType, TimelineEventType, room::create::RoomCreateEventContent},
-	room_version_rules::RoomVersionRules,
+	api::federation::membership::RawStrippedState, events::{room::create::RoomCreateEventContent, StateEventType, TimelineEventType}, room_version_rules::RoomVersionRules, EventId, OwnedEventId, OwnedRoomId,
+	RoomId,
+	RoomVersionId,
+	UserId,
 };
 
 use crate::{
-	Dep, globals, rooms,
-	rooms::{
+	globals, rooms, rooms::{
 		short::{ShortEventId, ShortStateHash},
-		state_compressor::{CompressedState, parse_compressed_state_event},
+		state_compressor::{parse_compressed_state_event, CompressedState},
 	},
+	Dep,
 };
 
 pub struct Service {
@@ -89,6 +89,25 @@ impl crate::Service for Service {
 }
 
 impl Service {
+	pub async fn purge(&self, room_id: &RoomId) {
+		self.db.roomid_pduleaves
+			.keys_prefix_raw(room_id)
+			.ignore_err()
+			.ready_for_each(|k| self.db.roomid_pduleaves.remove(k))
+			.await;
+		let mut shortstatehashes = self.db.roomid_shortstatehash
+			.keys_prefix_raw(room_id)
+			.ignore_err();
+		while let Some(key) = shortstatehashes.next().await {
+			self.db.shorteventid_shortstatehash
+				.keys_prefix_raw(&(Interfix, key))
+				.ignore_err()
+				.ready_for_each(|key| self.db.shorteventid_shortstatehash.remove(key))
+				.await;
+			self.db.roomid_shortstatehash.remove(key);
+		};
+	}
+
 	/// Set the room to the given statehash and update caches.
 	pub async fn force_state(
 		&self,
@@ -300,13 +319,12 @@ impl Service {
 		&self,
 		event: &'a E,
 		room_id: &RoomId,
-		target_user: &UserId,
 	) -> Vec<RawStrippedState>
 	where
 		E: Event + Send + Sync,
 		&'a E: Event + Send,
 	{
-		let mut state_events = [
+		let cells = [
 			(&StateEventType::RoomCreate, ""),
 			(&StateEventType::RoomJoinRules, ""),
 			(&StateEventType::RoomCanonicalAlias, ""),
@@ -315,14 +333,9 @@ impl Service {
 			(&StateEventType::RoomMember, event.sender().as_str()), // Add recommended events
 			(&StateEventType::RoomEncryption, ""),
 			(&StateEventType::RoomTopic, ""),
-		]
-		.to_vec();
+		];
 
-		if target_user != event.sender() {
-			state_events.push((&StateEventType::RoomMember, target_user.as_str()));
-		}
-
-		let fetches = state_events.into_iter().map(|(event_type, state_key)| {
+		let fetches = cells.into_iter().map(|(event_type, state_key)| {
 			self.services
 				.state_accessor
 				.room_state_get(room_id, event_type, state_key)

src/service/rooms/state_cache/mod.rs

@@ -4,20 +4,21 @@ mod via;
 use std::{collections::HashMap, sync::Arc};
 
 use conduwuit::{
-	Pdu, Result, SyncRwLock, implement,
-	result::LogErr,
-	utils::{ReadyExt, stream::TryIgnore},
-	warn,
+	implement, result::LogErr, utils::{stream::TryIgnore, ReadyExt}, warn,
+	Pdu,
+	Result,
+	SyncRwLock,
 };
 use database::{Deserialized, Ignore, Interfix, Map};
-use futures::{Stream, StreamExt, future::join5, pin_mut};
+use futures::{future::join5, pin_mut, Stream, StreamExt};
 use ruma::{
-	OwnedRoomId, OwnedServerName, OwnedUserId, RoomId, ServerName, UserId,
-	events::{AnyStrippedStateEvent, room::member::MembershipState},
-	serde::Raw,
+	events::{room::member::MembershipState, AnyStrippedStateEvent}, serde::Raw, OwnedRoomId, OwnedServerName, OwnedUserId, RoomId,
+	ServerName,
+	UserId,
 };
+use tokio::join;
 
-use crate::{Dep, account_data, appservice::RegistrationInfo, config, globals, rooms, users};
+use crate::{account_data, appservice::RegistrationInfo, config, globals, rooms, users, Dep};
 
 pub struct Service {
 	appservice_in_room_cache: AppServiceInRoomCache,
@@ -93,6 +94,90 @@ impl crate::Service for Service {
 	fn name(&self) -> &str { crate::service::make_name(std::module_path!()) }
 }
 
+#[implement(Service)]
+#[tracing::instrument(skip(self))]
+pub async fn purge(&self, room_id: &RoomId) {
+	let roomuser_key = (room_id, Interfix);
+	let userroom_key = (Interfix, room_id);
+	join!(
+		self.db
+			.roomid_invitedcount
+			.keys_prefix_raw(room_id)
+			.ignore_err()
+			.ready_for_each(|key| self.db.roomid_invitedcount.remove(key)),
+		self.db
+			.roomid_inviteviaservers
+			.keys_prefix_raw(room_id)
+			.ignore_err()
+			.ready_for_each(|key| self.db.roomid_inviteviaservers.remove(key)),
+		self.db
+			.roomid_joinedcount
+			.keys_prefix_raw(room_id)
+			.ignore_err()
+			.ready_for_each(|key| self.db.roomid_joinedcount.remove(key)),
+		self.db
+			.roomserverids
+			.keys_prefix_raw(room_id)
+			.ignore_err()
+			.ready_for_each(|key| self.db.roomserverids.remove(key)),
+		self.db
+			.roomuserid_invitecount
+			.keys_prefix_raw(&roomuser_key)
+			.ignore_err()
+			.ready_for_each(|key| self.db.roomuserid_invitecount.remove(key)),
+		self.db
+			.roomuserid_joined
+			.keys_prefix_raw(&roomuser_key)
+			.ignore_err()
+			.ready_for_each(|key| self.db.roomuserid_joined.remove(key)),
+		self.db
+			.roomuserid_leftcount
+			.keys_prefix_raw(&roomuser_key)
+			.ignore_err()
+			.ready_for_each(|key| self.db.roomuserid_leftcount.remove(key)),
+		self.db
+			.roomuserid_knockedcount
+			.keys_prefix_raw(&roomuser_key)
+			.ignore_err()
+			.ready_for_each(|key| self.db.roomuserid_knockedcount.remove(key)),
+		self.db
+			.roomuseroncejoinedids
+			.keys_prefix_raw(room_id)
+			.ignore_err()
+			.ready_for_each(|key| self.db.roomuseroncejoinedids.remove(key)),
+		self.db
+			.userroomid_invitestate
+			.keys_prefix_raw(&userroom_key)
+			.ignore_err()
+			.ready_for_each(|key| self.db.userroomid_invitestate.remove(key)),
+		self.db
+			.userroomid_joined
+			.keys_prefix_raw(&userroom_key)
+			.ignore_err()
+			.ready_for_each(|key| self.db.userroomid_joined.remove(key)),
+		self.db
+			.userroomid_leftstate
+			.keys_prefix_raw(&userroom_key)
+			.ignore_err()
+			.ready_for_each(|key| self.db.userroomid_leftstate.remove(key)),
+		self.db
+			.userroomid_knockedstate
+			.keys_prefix_raw(&userroom_key)
+			.ignore_err()
+			.ready_for_each(|key| self.db.userroomid_knockedstate.remove(key)),
+		self.db
+			.userroomid_invitesender
+			.keys_prefix_raw(&userroom_key)
+			.ignore_err()
+			.ready_for_each(|key| self.db.userroomid_invitesender.remove(key)),
+		self.db
+			.serverroomids
+			.keys_prefix_raw(&(Interfix, room_id))
+			.ignore_err()
+			.ready_for_each(|key| self.db.serverroomids.remove(key)),
+	);
+}
+
 #[implement(Service)]
 #[tracing::instrument(level = "trace", skip_all)]
 pub async fn appservice_in_room(&self, room_id: &RoomId, appservice: &RegistrationInfo) -> bool {

src/service/rooms/state_cache/update.rs

@@ -119,11 +119,7 @@ pub async fn update_membership(
 			self.mark_as_joined(user_id, room_id);
 		},
 		| MembershipState::Invite => {
-			let last_state = self
-				.services
-				.state
-				.summary_stripped(pdu, room_id, user_id)
-				.await;
+			let last_state = self.services.state.summary_stripped(pdu, room_id).await;
 
 			self.mark_as_invited(user_id, room_id, pdu.sender(), last_state, None)
 				.await?;

src/service/sending/antispam.rs

@@ -54,8 +54,9 @@ where
 	if !status.is_success() {
 		debug_error!("Antispam response bytes: {:?}", utils::string_from_bytes(&body));
 		return match status {
-			| http::StatusCode::FORBIDDEN =>
-				Err!(Request(Forbidden("Request was rejected by antispam service.",))),
+			| http::StatusCode::FORBIDDEN => {
+				Err!(Request(Forbidden("Request was rejected by antispam service.",)))
+			},
 			| _ => Err!(BadServerResponse(warn!(
 				"Antispam returned unsuccessful HTTP response {status}",
 			))),

src/service/uiaa/mod.rs

@@ -360,11 +360,12 @@ impl Service {
 							));
 						}
 					},
-					| _ =>
+					| _ => {
 						return Err(StandardErrorBody::new(
 							ErrorKind::Unrecognized,
 							"Identifier type not recognized".to_owned(),
-						)),
+						));
+					},
 				};
 
 				let Ok(user_id) = UserId::parse_with_server_name(

xtask/Cargo.toml

@@ -14,7 +14,7 @@ conduwuit-admin.workspace = true
 conduwuit.workspace = true
 clap.workspace = true
 
-askama = "0.16.0"
+askama = "0.15.1"
 cargo_metadata = "0.23.1"
 
 [lints]