magmaus3/continuwuity
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

remove pointless and buggy *_visibility in-memory caches

Browse source 
Signed-off-by: June Clementine Strawberry <june@3.dog>
This commit is contained in:
June Clementine Strawberry 2025-04-02 22:38:47 -04:00
parent 1b71b99c51
commit ea246d91d9
No known key found for this signature in database
5 changed files with 10 additions and 122 deletions
Download patch file Download diff file Expand all files Collapse all files

8
conduwuit-example.toml
View file

@ -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

12
src/core/config/mod.rs
View file

@ -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) }

68
src/service/rooms/state_accessor/mod.rs
View file

@ -3,21 +3,13 @@ mod server_can;
mod state;
mod user_can;
use std::{
fmt::Write,
sync::{Arc, Mutex as StdMutex, Mutex},
};
use std::sync::Arc;
use async_trait::async_trait;
use conduwuit::{
Result, err, utils,
utils::math::{Expected, usize_from_f64},
};
use conduwuit::{Result, err};
use database::Map;
use lru_cache::LruCache;
use ruma::{
EventEncryptionAlgorithm, JsOption, OwnedRoomAliasId, OwnedRoomId, OwnedServerName,
OwnedUserId, RoomId, UserId,
EventEncryptionAlgorithm, JsOption, OwnedRoomAliasId, OwnedRoomId, 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!()) }
}

22
src/service/rooms/state_accessor/server_can.rs
View file

@ -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
}
}

22
src/service/rooms/state_accessor/user_can.rs
View file

@ -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