move statekeyshort_cache to service

src/database.rs

@@ -236,8 +236,6 @@ pub(crate) struct KeyValueDatabase {
     pub(super) senderkey_pusher: Arc<dyn KvTree>,
 
     // Uncategorized trees
-    pub(super) statekeyshort_cache:
-        Mutex<LruCache<(StateEventType, String), ShortStateKey>>,
     pub(super) shortstatekey_cache:
         Mutex<LruCache<ShortStateKey, (StateEventType, String)>>,
     pub(super) our_real_users_cache:
@@ -471,14 +469,6 @@ impl KeyValueDatabase {
             shortstatekey_cache: Mutex::new(LruCache::new(
                 (100_000.0 * config.cache_capacity_modifier) as usize,
             )),
-            #[allow(
-                clippy::as_conversions,
-                clippy::cast_sign_loss,
-                clippy::cast_possible_truncation
-            )]
-            statekeyshort_cache: Mutex::new(LruCache::new(
-                (100_000.0 * config.cache_capacity_modifier) as usize,
-            )),
             our_real_users_cache: RwLock::new(HashMap::new()),
             appservice_in_room_cache: RwLock::new(HashMap::new()),
             lasttimelinecount_cache: Mutex::new(HashMap::new()),

src/database/key_value/rooms/short.rs

@@ -47,18 +47,6 @@ impl service::rooms::short::Data for KeyValueDatabase {
         event_type: &StateEventType,
         state_key: &str,
     ) -> Result<Option<ShortStateKey>> {
-        let lookup = Lookup::StateKeyToShort;
-
-        if let Some(short) = self
-            .statekeyshort_cache
-            .lock()
-            .unwrap()
-            .get_mut(&(event_type.clone(), state_key.to_owned()))
-        {
-            METRICS.record_lookup(lookup, FoundIn::Cache);
-            return Ok(Some(*short));
-        }
-
         let mut db_key = event_type.to_string().as_bytes().to_vec();
         db_key.push(0xFF);
         db_key.extend_from_slice(state_key.as_bytes());
@@ -75,17 +63,6 @@ impl service::rooms::short::Data for KeyValueDatabase {
             })
             .transpose()?;
 
-        if let Some(s) = short {
-            METRICS.record_lookup(lookup, FoundIn::Database);
-
-            self.statekeyshort_cache
-                .lock()
-                .unwrap()
-                .insert((event_type.clone(), state_key.to_owned()), s);
-        } else {
-            METRICS.record_lookup(lookup, FoundIn::Nothing);
-        }
-
         Ok(short)
     }
 
@@ -94,50 +71,32 @@ impl service::rooms::short::Data for KeyValueDatabase {
         &self,
         event_type: &StateEventType,
         state_key: &str,
-    ) -> Result<ShortStateKey> {
+    ) -> Result<(ShortStateKey, bool)> {
-        let lookup = Lookup::CreateStateKeyToShort;
-
-        if let Some(short) = self
-            .statekeyshort_cache
-            .lock()
-            .unwrap()
-            .get_mut(&(event_type.clone(), state_key.to_owned()))
-        {
-            METRICS.record_lookup(lookup, FoundIn::Cache);
-            return Ok(*short);
-        }
-
         let mut db_key = event_type.to_string().as_bytes().to_vec();
         db_key.push(0xFF);
         db_key.extend_from_slice(state_key.as_bytes());
 
-        let short = if let Some(shortstatekey) =
+        let (short, created) = if let Some(shortstatekey) =
             self.statekey_shortstatekey.get(&db_key)?
         {
-            METRICS.record_lookup(lookup, FoundIn::Database);
+            (
-
+                utils::u64_from_bytes(&shortstatekey).map_err(|_| {
-            utils::u64_from_bytes(&shortstatekey).map_err(|_| {
+                    Error::bad_database("Invalid shortstatekey in db.")
-                Error::bad_database("Invalid shortstatekey in db.")
+                })?,
-            })?
+                false,
+            )
         } else {
-            METRICS.record_lookup(lookup, FoundIn::Nothing);
-
             let shortstatekey = services().globals.next_count()?;
             self.statekey_shortstatekey
                 .insert(&db_key, &shortstatekey.to_be_bytes())?;
             self.shortstatekey_statekey
                 .insert(&shortstatekey.to_be_bytes(), &db_key)?;
-            shortstatekey
+            (shortstatekey, true)
         };
 
         let short = ShortStateKey::new(short);
 
-        self.statekeyshort_cache
+        Ok((short, created))
-            .lock()
-            .unwrap()
-            .insert((event_type.clone(), state_key.to_owned()), short);
-
-        Ok(short)
     }
 
     #[tracing::instrument(skip(self))]

src/service.rs

@@ -120,6 +120,14 @@ impl Services {
                     {
                         (100_000.0 * config.cache_capacity_modifier) as usize
                     },
+                    #[allow(
+                        clippy::as_conversions,
+                        clippy::cast_sign_loss,
+                        clippy::cast_possible_truncation
+                    )]
+                    {
+                        (100_000.0 * config.cache_capacity_modifier) as usize
+                    },
                 ),
                 state: rooms::state::Service {
                     db,

src/service/rooms/short.rs

@@ -39,6 +39,8 @@ pub(crate) struct Service {
     db: &'static dyn Data,
     shorteventid_cache: Mutex<LruCache<ShortEventId, Arc<EventId>>>,
     eventidshort_cache: Mutex<LruCache<OwnedEventId, ShortEventId>>,
+    statekeyshort_cache:
+        Mutex<LruCache<(StateEventType, String), ShortStateKey>>,
 }
 
 impl Service {
@@ -46,6 +48,7 @@ impl Service {
         db: &'static dyn Data,
         shorteventid_cache_size: usize,
         eventidshort_cache_size: usize,
+        statekeyshort_cache_size: usize,
     ) -> Self {
         Self {
             db,
@@ -55,6 +58,9 @@ impl Service {
             eventidshort_cache: Mutex::new(LruCache::new(
                 eventidshort_cache_size,
             )),
+            statekeyshort_cache: Mutex::new(LruCache::new(
+                statekeyshort_cache_size,
+            )),
         }
     }
 
@@ -92,7 +98,32 @@ impl Service {
         event_type: &StateEventType,
         state_key: &str,
     ) -> Result<Option<ShortStateKey>> {
-        self.db.get_shortstatekey(event_type, state_key)
+        let lookup = Lookup::StateKeyToShort;
+
+        if let Some(short) = self
+            .statekeyshort_cache
+            .lock()
+            .unwrap()
+            .get_mut(&(event_type.clone(), state_key.to_owned()))
+        {
+            METRICS.record_lookup(lookup, FoundIn::Cache);
+            return Ok(Some(*short));
+        }
+
+        let short = self.db.get_shortstatekey(event_type, state_key)?;
+
+        if let Some(short) = short {
+            METRICS.record_lookup(lookup, FoundIn::Database);
+
+            self.statekeyshort_cache
+                .lock()
+                .unwrap()
+                .insert((event_type.clone(), state_key.to_owned()), short);
+        } else {
+            METRICS.record_lookup(lookup, FoundIn::Nothing);
+        }
+
+        Ok(short)
     }
 
     pub(crate) fn get_or_create_shortstatekey(
@@ -100,7 +131,33 @@ impl Service {
         event_type: &StateEventType,
         state_key: &str,
     ) -> Result<ShortStateKey> {
-        self.db.get_or_create_shortstatekey(event_type, state_key)
+        let lookup = Lookup::CreateStateKeyToShort;
+
+        if let Some(short) = self
+            .statekeyshort_cache
+            .lock()
+            .unwrap()
+            .get_mut(&(event_type.clone(), state_key.to_owned()))
+        {
+            METRICS.record_lookup(lookup, FoundIn::Cache);
+            return Ok(*short);
+        }
+
+        let (short, created) =
+            self.db.get_or_create_shortstatekey(event_type, state_key)?;
+
+        if created {
+            METRICS.record_lookup(lookup, FoundIn::Nothing);
+        } else {
+            METRICS.record_lookup(lookup, FoundIn::Database);
+        }
+
+        self.statekeyshort_cache
+            .lock()
+            .unwrap()
+            .insert((event_type.clone(), state_key.to_owned()), short);
+
+        Ok(short)
     }
 
     pub(crate) fn get_eventid_from_short(

src/service/rooms/short/data.rs

@@ -18,11 +18,12 @@ pub(crate) trait Data: Send + Sync {
         state_key: &str,
     ) -> Result<Option<ShortStateKey>>;
 
+    /// The returned bool indicates whether it was created
     fn get_or_create_shortstatekey(
         &self,
         event_type: &StateEventType,
         state_key: &str,
-    ) -> Result<ShortStateKey>;
+    ) -> Result<(ShortStateKey, bool)>;
 
     fn get_eventid_from_short(
         &self,