Merge branch 'ruma-registration-type' into 'next'

fix: don't panic if registration url is empty

See merge request famedly/conduit!583

src/api/appservice_server.rs

@@ -1,23 +1,29 @@
 use crate::{services, utils, Error, Result};
 use bytes::BytesMut;
-use ruma::api::{IncomingResponse, MatrixVersion, OutgoingRequest, SendAccessToken};
+use ruma::api::{
+    appservice::Registration, IncomingResponse, MatrixVersion, OutgoingRequest, SendAccessToken,
+};
 use std::{fmt::Debug, mem, time::Duration};
 use tracing::warn;
 
+/// Sends a request to an appservice
+///
+/// Only returns None if there is no url specified in the appservice registration file
 #[tracing::instrument(skip(request))]
 pub(crate) async fn send_request<T: OutgoingRequest>(
-    registration: serde_yaml::Value,
+    registration: Registration,
     request: T,
-) -> Result<T::IncomingResponse>
+) -> Option<Result<T::IncomingResponse>>
 where
     T: Debug,
 {
-    let destination = registration.get("url").unwrap().as_str().unwrap();
-    let hs_token = registration.get("hs_token").unwrap().as_str().unwrap();
+    let destination = registration.url?;
+
+    let hs_token = registration.hs_token.as_str();
 
     let mut http_request = request
         .try_into_http_request::<BytesMut>(
-            destination,
+            &destination,
             SendAccessToken::IfRequired(hs_token),
             &[MatrixVersion::V1_0],
         )
@@ -55,11 +61,9 @@ where
         Err(e) => {
             warn!(
                 "Could not send request to appservice {:?} at {}: {}",
-                registration.get("id"),
-                destination,
-                e
+                registration.id, destination, e
             );
-            return Err(e.into());
+            return Some(Err(e.into()));
         }
     };
 
@@ -95,11 +99,12 @@ where
             .body(body)
             .expect("reqwest body is valid http body"),
     );
-    response.map_err(|_| {
+
+    Some(response.map_err(|_| {
         warn!(
             "Appservice returned invalid response bytes {}\n{}",
             destination, url
         );
         Error::BadServerResponse("Server returned bad response.")
-    })
+    }))
 }

src/api/client_server/alias.rs

@@ -1,6 +1,5 @@
 use crate::{services, Error, Result, Ruma};
 use rand::seq::SliceRandom;
-use regex::Regex;
 use ruma::{
     api::{
         appservice,
@@ -101,31 +100,22 @@ pub(crate) async fn get_alias_helper(
     match services().rooms.alias.resolve_local_alias(&room_alias)? {
         Some(r) => room_id = Some(r),
         None => {
-            for (_id, registration) in services().appservice.all()? {
-                let aliases = registration
-                    .get("namespaces")
-                    .and_then(|ns| ns.get("aliases"))
-                    .and_then(|aliases| aliases.as_sequence())
-                    .map_or_else(Vec::new, |aliases| {
-                        aliases
-                            .iter()
-                            .filter_map(|aliases| Regex::new(aliases.get("regex")?.as_str()?).ok())
-                            .collect::<Vec<_>>()
-                    });
-
-                if aliases
-                    .iter()
-                    .any(|aliases| aliases.is_match(room_alias.as_str()))
-                    && services()
+            for appservice in services().appservice.read().await.values() {
+                if appservice.aliases.is_match(room_alias.as_str())
+                    && if let Some(opt_result) = services()
                         .sending
                         .send_appservice_request(
-                            registration,
+                            appservice.registration.clone(),
                             appservice::query::query_room_alias::v1::Request {
                                 room_alias: room_alias.clone(),
                             },
                         )
                         .await
-                        .is_ok()
+                    {
+                        opt_result.is_ok()
+                    } else {
+                        false
+                    }
                 {
                     room_id = Some(
                         services()

src/api/ruma_wrapper/axum.rs

@@ -80,26 +80,20 @@ where
 
         let mut json_body = serde_json::from_slice::<CanonicalJsonValue>(&body).ok();
 
-        let appservices = services().appservice.all().unwrap();
-        let appservice_registration = appservices.iter().find(|(_id, registration)| {
-            registration
-                .get("as_token")
-                .and_then(|as_token| as_token.as_str())
-                .map_or(false, |as_token| token == Some(as_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((_id, registration)) = appservice_registration {
+            if let Some(info) = appservice_registration {
                 match metadata.authentication {
                     AuthScheme::AccessToken => {
                         let user_id = query_params.user_id.map_or_else(
                             || {
                                 UserId::parse_with_server_name(
-                                    registration
-                                        .get("sender_localpart")
-                                        .unwrap()
-                                        .as_str()
-                                        .unwrap(),
+                                    info.registration.sender_localpart.as_str(),
                                     services().globals.server_name(),
                                 )
                                 .unwrap()