92 lines
2.2 KiB
Rust
92 lines
2.2 KiB
Rust
use std::{
|
|
mem::size_of,
|
|
sync::{Arc, Mutex},
|
|
};
|
|
|
|
use conduwuit::{Err, Result, err, utils, utils::math::usize_from_f64};
|
|
use database::Map;
|
|
use lru_cache::LruCache;
|
|
|
|
use crate::rooms::short::ShortEventId;
|
|
|
|
pub(super) struct Data {
|
|
shorteventid_authchain: Arc<Map>,
|
|
pub(super) auth_chain_cache: Mutex<LruCache<Vec<u64>, Arc<[ShortEventId]>>>,
|
|
}
|
|
|
|
impl Data {
|
|
pub(super) fn new(args: &crate::Args<'_>) -> Self {
|
|
let db = &args.db;
|
|
let config = &args.server.config;
|
|
let cache_size = f64::from(config.auth_chain_cache_capacity);
|
|
let cache_size = usize_from_f64(cache_size * config.cache_capacity_modifier)
|
|
.expect("valid cache size");
|
|
Self {
|
|
shorteventid_authchain: db["shorteventid_authchain"].clone(),
|
|
auth_chain_cache: Mutex::new(LruCache::new(cache_size)),
|
|
}
|
|
}
|
|
|
|
pub(super) async fn get_cached_eventid_authchain(
|
|
&self,
|
|
key: &[u64],
|
|
) -> Result<Arc<[ShortEventId]>> {
|
|
debug_assert!(!key.is_empty(), "auth_chain key must not be empty");
|
|
|
|
// Check RAM cache
|
|
if let Some(result) = self
|
|
.auth_chain_cache
|
|
.lock()
|
|
.expect("cache locked")
|
|
.get_mut(key)
|
|
{
|
|
return Ok(Arc::clone(result));
|
|
}
|
|
|
|
// We only save auth chains for single events in the db
|
|
if key.len() != 1 {
|
|
return Err!(Request(NotFound("auth_chain not cached")));
|
|
}
|
|
|
|
// Check database
|
|
let chain = self
|
|
.shorteventid_authchain
|
|
.qry(&key[0])
|
|
.await
|
|
.map_err(|_| err!(Request(NotFound("auth_chain not found"))))?;
|
|
|
|
let chain = chain
|
|
.chunks_exact(size_of::<u64>())
|
|
.map(utils::u64_from_u8)
|
|
.collect::<Arc<[u64]>>();
|
|
|
|
// Cache in RAM
|
|
self.auth_chain_cache
|
|
.lock()
|
|
.expect("cache locked")
|
|
.insert(vec![key[0]], Arc::clone(&chain));
|
|
|
|
Ok(chain)
|
|
}
|
|
|
|
pub(super) fn cache_auth_chain(&self, key: Vec<u64>, auth_chain: Arc<[ShortEventId]>) {
|
|
debug_assert!(!key.is_empty(), "auth_chain key must not be empty");
|
|
|
|
// Only persist single events in db
|
|
if key.len() == 1 {
|
|
let key = key[0].to_be_bytes();
|
|
let val = auth_chain
|
|
.iter()
|
|
.flat_map(|s| s.to_be_bytes().to_vec())
|
|
.collect::<Vec<u8>>();
|
|
|
|
self.shorteventid_authchain.insert(&key, &val);
|
|
}
|
|
|
|
// Cache in RAM
|
|
self.auth_chain_cache
|
|
.lock()
|
|
.expect("cache locked")
|
|
.insert(key, auth_chain);
|
|
}
|
|
}
|