refactor(appservices): avoid cloning frequently

src/api/appservice_server.rs

@@ -17,9 +17,7 @@ pub(crate) async fn send_request<T: OutgoingRequest>(
 where
     T: Debug,
 {
-    let Some(destination) = registration.url else {
-        return None;
-    };
+    let destination = registration.url?;
 
     let hs_token = registration.hs_token.as_str();
 

src/api/client_server/alias.rs

@@ -100,7 +100,7 @@ pub(crate) async fn get_alias_helper(
     match services().rooms.alias.resolve_local_alias(&room_alias)? {
         Some(r) => room_id = Some(r),
         None => {
-            for appservice in services().appservice.all().await {
+            for appservice in services().appservice.read().await.values() {
                 if appservice.aliases.is_match(room_alias.as_str())
                     && if let Some(opt_result) = services()
                         .sending

src/api/ruma_wrapper/axum.rs

@@ -80,10 +80,11 @@ where
 
         let mut json_body = serde_json::from_slice::<CanonicalJsonValue>(&body).ok();
 
-        let appservices = services().appservice.all().await;
-        let appservice_registration = appservices
-            .iter()
-            .find(|info| Some(info.registration.as_token.as_str()) == token);
+        let appservice_registration = if let Some(token) = token {
+            services().appservice.find_from_token(token).await
+        } else {
+            None
+        };
 
         let (sender_user, sender_device, sender_servername, from_appservice) =
             if let Some(info) = appservice_registration {

src/service/admin/mod.rs

@@ -369,25 +369,13 @@ impl Service {
                 )),
             },
             AdminCommand::ListAppservices => {
-                if let Ok(appservices) = services()
-                    .appservice
-                    .iter_ids()
-                    .map(|ids| ids.collect::<Vec<_>>())
-                {
-                    let count = appservices.len();
-                    let output = format!(
-                        "Appservices ({}): {}",
-                        count,
-                        appservices
-                            .into_iter()
-                            .filter_map(|r| r.ok())
-                            .collect::<Vec<_>>()
-                            .join(", ")
-                    );
-                    RoomMessageEventContent::text_plain(output)
-                } else {
-                    RoomMessageEventContent::text_plain("Failed to get appservices.")
-                }
+                let appservices = services().appservice.iter_ids().await;
+                let output = format!(
+                    "Appservices ({}): {}",
+                    appservices.len(),
+                    appservices.join(", ")
+                );
+                RoomMessageEventContent::text_plain(output)
             }
             AdminCommand::ListRooms => {
                 let room_ids = services().rooms.metadata.iter_ids();

src/service/appservice/mod.rs

@@ -4,6 +4,7 @@ use std::collections::BTreeMap;
 
 pub use data::Data;
 
+use futures_util::Future;
 use regex::RegexSet;
 use ruma::api::appservice::{Namespace, Registration};
 use tokio::sync::RwLock;
@@ -147,20 +148,36 @@ impl Service {
         self.db.unregister_appservice(service_name)
     }
 
-    pub fn get_registration(&self, id: &str) -> Result<Option<Registration>> {
-        self.db.get_registration(id)
-    }
-
-    pub fn iter_ids(&self) -> Result<impl Iterator<Item = Result<String>> + '_> {
-        self.db.iter_ids()
-    }
-
-    pub async fn all(&self) -> Vec<RegistrationInfo> {
+    pub async fn get_registration(&self, id: &str) -> Option<Registration> {
         self.registration_info
             .read()
             .await
-            .values()
+            .get(id)
+            .cloned()
+            .map(|info| info.registration)
+    }
+
+    pub async fn iter_ids(&self) -> Vec<String> {
+        self.registration_info
+            .read()
+            .await
+            .keys()
             .cloned()
             .collect()
     }
+
+    pub async fn find_from_token(&self, token: &str) -> Option<RegistrationInfo> {
+        self.read()
+            .await
+            .values()
+            .find(|info| info.registration.as_token == token)
+            .cloned()
+    }
+
+    pub fn read(
+        &self,
+    ) -> impl Future<Output = tokio::sync::RwLockReadGuard<'_, BTreeMap<String, RegistrationInfo>>>
+    {
+        self.registration_info.read()
+    }
 }

src/service/rooms/timeline/mod.rs

@@ -524,11 +524,11 @@ impl Service {
             }
         }
 
-        for appservice in services().appservice.all().await {
+        for appservice in services().appservice.read().await.values() {
             if services()
                 .rooms
                 .state_cache
-                .appservice_in_room(&pdu.room_id, &appservice)?
+                .appservice_in_room(&pdu.room_id, appservice)?
             {
                 services()
                     .sending

src/service/sending/mod.rs

@@ -488,7 +488,7 @@ impl Service {
                     services()
                         .appservice
                         .get_registration(id)
-                        .map_err(|e| (kind.clone(), e))?
+                        .await
                         .ok_or_else(|| {
                             (
                                 kind.clone(),