remove pointless and buggy *_visibility in-memory caches

Signed-off-by: June Clementine Strawberry <june@3.dog>

conduwuit-example.toml

@@ -195,14 +195,6 @@
 #
 #servernameevent_data_cache_capacity = varies by system
 
-# This item is undocumented. Please contribute documentation for it.
-#
-#server_visibility_cache_capacity = varies by system
-
-# This item is undocumented. Please contribute documentation for it.
-#
-#user_visibility_cache_capacity = varies by system
-
 # This item is undocumented. Please contribute documentation for it.
 #
 #stateinfo_cache_capacity = varies by system

src/core/config/mod.rs

@@ -252,14 +252,6 @@ pub struct Config {
 	#[serde(default = "default_servernameevent_data_cache_capacity")]
 	pub servernameevent_data_cache_capacity: u32,
 
-	/// default: varies by system
-	#[serde(default = "default_server_visibility_cache_capacity")]
-	pub server_visibility_cache_capacity: u32,
-
-	/// default: varies by system
-	#[serde(default = "default_user_visibility_cache_capacity")]
-	pub user_visibility_cache_capacity: u32,
-
 	/// default: varies by system
 	#[serde(default = "default_stateinfo_cache_capacity")]
 	pub stateinfo_cache_capacity: u32,
@@ -2035,10 +2027,6 @@ fn default_servernameevent_data_cache_capacity() -> u32 {
 	parallelism_scaled_u32(100_000).saturating_add(500_000)
 }
 
-fn default_server_visibility_cache_capacity() -> u32 { parallelism_scaled_u32(500) }
-
-fn default_user_visibility_cache_capacity() -> u32 { parallelism_scaled_u32(1000) }
-
 fn default_stateinfo_cache_capacity() -> u32 { parallelism_scaled_u32(100) }
 
 fn default_roomid_spacehierarchy_cache_capacity() -> u32 { parallelism_scaled_u32(1000) }

src/service/rooms/state_accessor/mod.rs

@@ -3,21 +3,13 @@ mod server_can;
 mod state;
 mod user_can;
 
-use std::{
+use std::sync::Arc;
-	fmt::Write,
-	sync::{Arc, Mutex as StdMutex, Mutex},
-};
 
 use async_trait::async_trait;
-use conduwuit::{
+use conduwuit::{Result, err};
-	Result, err, utils,
-	utils::math::{Expected, usize_from_f64},
-};
 use database::Map;
-use lru_cache::LruCache;
 use ruma::{
-	EventEncryptionAlgorithm, JsOption, OwnedRoomAliasId, OwnedRoomId, OwnedServerName,
+	EventEncryptionAlgorithm, JsOption, OwnedRoomAliasId, OwnedRoomId, RoomId, UserId,
-	OwnedUserId, RoomId, UserId,
 	events::{
 		StateEventType,
 		room::{
@@ -37,11 +29,9 @@ use ruma::{
 	space::SpaceRoomJoinRule,
 };
 
-use crate::{Dep, rooms, rooms::short::ShortStateHash};
+use crate::{Dep, rooms};
 
 pub struct Service {
-	pub server_visibility_cache: Mutex<LruCache<(OwnedServerName, ShortStateHash), bool>>,
-	pub user_visibility_cache: Mutex<LruCache<(OwnedUserId, ShortStateHash), bool>>,
 	services: Services,
 	db: Data,
 }
@@ -61,19 +51,7 @@ struct Data {
 #[async_trait]
 impl crate::Service for Service {
 	fn build(args: crate::Args<'_>) -> Result<Arc<Self>> {
-		let config = &args.server.config;
-		let server_visibility_cache_capacity =
-			f64::from(config.server_visibility_cache_capacity) * config.cache_capacity_modifier;
-		let user_visibility_cache_capacity =
-			f64::from(config.user_visibility_cache_capacity) * config.cache_capacity_modifier;
-
 		Ok(Arc::new(Self {
-			server_visibility_cache: StdMutex::new(LruCache::new(usize_from_f64(
-				server_visibility_cache_capacity,
-			)?)),
-			user_visibility_cache: StdMutex::new(LruCache::new(usize_from_f64(
-				user_visibility_cache_capacity,
-			)?)),
 			services: Services {
 				state_cache: args.depend::<rooms::state_cache::Service>("rooms::state_cache"),
 				timeline: args.depend::<rooms::timeline::Service>("rooms::timeline"),
@@ -88,44 +66,6 @@ impl crate::Service for Service {
 		}))
 	}
 
-	async fn memory_usage(&self, out: &mut (dyn Write + Send)) -> Result {
-		use utils::bytes::pretty;
-
-		let (svc_count, svc_bytes) = self.server_visibility_cache.lock()?.iter().fold(
-			(0_usize, 0_usize),
-			|(count, bytes), (key, _)| {
-				(
-					count.expected_add(1),
-					bytes
-						.expected_add(key.0.capacity())
-						.expected_add(size_of_val(&key.1)),
-				)
-			},
-		);
-
-		let (uvc_count, uvc_bytes) = self.user_visibility_cache.lock()?.iter().fold(
-			(0_usize, 0_usize),
-			|(count, bytes), (key, _)| {
-				(
-					count.expected_add(1),
-					bytes
-						.expected_add(key.0.capacity())
-						.expected_add(size_of_val(&key.1)),
-				)
-			},
-		);
-
-		writeln!(out, "server_visibility_cache: {svc_count} ({})", pretty(svc_bytes))?;
-		writeln!(out, "user_visibility_cache: {uvc_count} ({})", pretty(uvc_bytes))?;
-
-		Ok(())
-	}
-
-	async fn clear_cache(&self) {
-		self.server_visibility_cache.lock().expect("locked").clear();
-		self.user_visibility_cache.lock().expect("locked").clear();
-	}
-
 	fn name(&self) -> &str { crate::service::make_name(std::module_path!()) }
 }
 

src/service/rooms/state_accessor/server_can.rs

@@ -1,4 +1,4 @@
-use conduwuit::{error, implement, utils::stream::ReadyExt};
+use conduwuit::{debug_info, implement, utils::stream::ReadyExt};
 use futures::StreamExt;
 use ruma::{
 	EventId, RoomId, ServerName,
@@ -22,15 +22,6 @@ pub async fn server_can_see_event(
 		return true;
 	};
 
-	if let Some(visibility) = self
-		.server_visibility_cache
-		.lock()
-		.expect("locked")
-		.get_mut(&(origin.to_owned(), shortstatehash))
-	{
-		return *visibility;
-	}
-
 	let history_visibility = self
 		.state_get_content(shortstatehash, &StateEventType::RoomHistoryVisibility, "")
 		.await
@@ -44,7 +35,7 @@ pub async fn server_can_see_event(
 		.room_members(room_id)
 		.ready_filter(|member| member.server_name() == origin);
 
-	let visibility = match history_visibility {
+	match history_visibility {
 		| HistoryVisibility::WorldReadable | HistoryVisibility::Shared => true,
 		| HistoryVisibility::Invited => {
 			// Allow if any member on requesting server was AT LEAST invited, else deny
@@ -62,12 +53,5 @@ pub async fn server_can_see_event(
 			error!("Unknown history visibility {history_visibility}");
 			false
 		},
-	};
+	}
-
-	self.server_visibility_cache
-		.lock()
-		.expect("locked")
-		.insert((origin.to_owned(), shortstatehash), visibility);
-
-	visibility
 }

src/service/rooms/state_accessor/user_can.rs

@@ -1,4 +1,4 @@
-use conduwuit::{Err, Error, Result, error, implement, pdu::PduBuilder};
+use conduwuit::{Err, Error, Result, debug_info, implement, pdu::PduBuilder};
 use ruma::{
 	EventId, RoomId, UserId,
 	events::{
@@ -98,15 +98,6 @@ pub async fn user_can_see_event(
 		return true;
 	};
 
-	if let Some(visibility) = self
-		.user_visibility_cache
-		.lock()
-		.expect("locked")
-		.get_mut(&(user_id.to_owned(), shortstatehash))
-	{
-		return *visibility;
-	}
-
 	let currently_member = self.services.state_cache.is_joined(user_id, room_id).await;
 
 	let history_visibility = self
@@ -116,7 +107,7 @@ pub async fn user_can_see_event(
 			c.history_visibility
 		});
 
-	let visibility = match history_visibility {
+	match history_visibility {
 		| HistoryVisibility::WorldReadable => true,
 		| HistoryVisibility::Shared => currently_member,
 		| HistoryVisibility::Invited => {
@@ -131,14 +122,7 @@ pub async fn user_can_see_event(
 			error!("Unknown history visibility {history_visibility}");
 			false
 		},
-	};
+	}
-
-	self.user_visibility_cache
-		.lock()
-		.expect("locked")
-		.insert((user_id.to_owned(), shortstatehash), visibility);
-
-	visibility
 }
 
 /// Whether a user is allowed to see an event, based on