update ruma appservice Registration type MR

from https://gitlab.com/famedly/conduit/-/merge_requests/583

and fixed panic from blocking async call in timeline/mod.rs

Co-authored-by: strawberry <strawberry@puppygock.gay>
Signed-off-by: strawberry <strawberry@puppygock.gay>

src/service/admin/mod.rs

@@ -567,7 +567,7 @@ impl Service {
 						let appservice_config = body[1..body.len() - 1].join("\n");
 						let parsed_config = serde_yaml::from_str::<Registration>(&appservice_config);
 						match parsed_config {
-							Ok(yaml) => match services().appservice.register_appservice(yaml) {
+							Ok(yaml) => match services().appservice.register_appservice(yaml).await {
 								Ok(id) => {
 									RoomMessageEventContent::text_plain(format!("Appservice registered with ID: {id}."))
 								},
@@ -587,7 +587,7 @@ impl Service {
 				},
 				AppserviceCommand::Unregister {
 					appservice_identifier,
-				} => match services().appservice.unregister_appservice(&appservice_identifier) {
+				} => match services().appservice.unregister_appservice(&appservice_identifier).await {
 					Ok(()) => RoomMessageEventContent::text_plain("Appservice unregistered."),
 					Err(e) => RoomMessageEventContent::text_plain(format!("Failed to unregister appservice: {e}")),
 				},

src/service/appservice/mod.rs

@@ -1,24 +1,118 @@
 mod data;
 
-pub(crate) use data::Data;
-use ruma::api::appservice::Registration;
+use std::collections::HashMap;
 
-use crate::Result;
+pub(crate) use data::Data;
+use regex::RegexSet;
+use ruma::api::appservice::{Namespace, Registration};
+use tokio::sync::RwLock;
+
+use crate::{services, Result};
+
+/// Compiled regular expressions for a namespace
+pub struct NamespaceRegex {
+	pub exclusive: Option<RegexSet>,
+	pub non_exclusive: Option<RegexSet>,
+}
+
+impl NamespaceRegex {
+	/// Checks if this namespace has rights to a namespace
+	pub fn is_match(&self, heystack: &str) -> bool {
+		if self.is_exclusive_match(heystack) {
+			return true;
+		}
+
+		if let Some(non_exclusive) = &self.non_exclusive {
+			if non_exclusive.is_match(heystack) {
+				return true;
+			}
+		}
+		false
+	}
+
+	/// Checks if this namespace has exlusive rights to a namespace
+	pub fn is_exclusive_match(&self, heystack: &str) -> bool {
+		if let Some(exclusive) = &self.exclusive {
+			if exclusive.is_match(heystack) {
+				return true;
+			}
+		}
+		false
+	}
+}
+
+impl TryFrom<Vec<Namespace>> for NamespaceRegex {
+	type Error = regex::Error;
+
+	fn try_from(value: Vec<Namespace>) -> Result<Self, regex::Error> {
+		let mut exclusive = vec![];
+		let mut non_exclusive = vec![];
+
+		for namespace in value {
+			if namespace.exclusive {
+				exclusive.push(namespace.regex);
+			} else {
+				non_exclusive.push(namespace.regex);
+			}
+		}
+
+		Ok(NamespaceRegex {
+			exclusive: if exclusive.is_empty() {
+				None
+			} else {
+				Some(RegexSet::new(exclusive)?)
+			},
+			non_exclusive: if non_exclusive.is_empty() {
+				None
+			} else {
+				Some(RegexSet::new(non_exclusive)?)
+			},
+		})
+	}
+}
+
+/// Compiled regular expressions for an appservice
+pub struct RegistrationInfo {
+	pub registration: Registration,
+	pub users: NamespaceRegex,
+	pub aliases: NamespaceRegex,
+	pub rooms: NamespaceRegex,
+}
+
+impl TryFrom<Registration> for RegistrationInfo {
+	type Error = regex::Error;
+
+	fn try_from(value: Registration) -> Result<RegistrationInfo, regex::Error> {
+		Ok(RegistrationInfo {
+			users: value.namespaces.users.clone().try_into()?,
+			aliases: value.namespaces.aliases.clone().try_into()?,
+			rooms: value.namespaces.rooms.clone().try_into()?,
+			registration: value,
+		})
+	}
+}
 
 pub struct Service {
 	pub db: &'static dyn Data,
+	pub registration_info: RwLock<HashMap<String, RegistrationInfo>>,
 }
 
 impl Service {
 	/// Registers an appservice and returns the ID to the caller
-	pub fn register_appservice(&self, yaml: Registration) -> Result<String> { self.db.register_appservice(yaml) }
+	pub async fn register_appservice(&self, yaml: Registration) -> Result<String> {
+		services().appservice.registration_info.write().await.insert(yaml.id.clone(), yaml.clone().try_into()?);
+
+		self.db.register_appservice(yaml)
+	}
 
 	/// Remove an appservice registration
 	///
 	/// # Arguments
 	///
 	/// * `service_name` - the name you send to register the service previously
-	pub fn unregister_appservice(&self, service_name: &str) -> Result<()> {
+	pub async fn unregister_appservice(&self, service_name: &str) -> Result<()> {
+		services().appservice.registration_info.write().await.remove(service_name);
+
 		self.db.unregister_appservice(service_name)
 	}
 

src/service/mod.rs

@@ -57,6 +57,7 @@ impl Services<'_> {
 		Ok(Self {
 			appservice: appservice::Service {
 				db,
+				registration_info: RwLock::new(HashMap::new()),
 			},
 			pusher: pusher::Service {
 				db,

src/service/rooms/state_cache/data.rs

@@ -1,13 +1,12 @@
 use std::{collections::HashSet, sync::Arc};
 
 use ruma::{
-	api::appservice::Registration,
 	events::{AnyStrippedStateEvent, AnySyncStateEvent},
 	serde::Raw,
 	OwnedRoomId, OwnedServerName, OwnedUserId, RoomId, ServerName, UserId,
 };
 
-use crate::Result;
+use crate::{service::appservice::RegistrationInfo, Result};
 
 type StrippedStateEventIter<'a> = Box<dyn Iterator<Item = Result<(OwnedRoomId, Vec<Raw<AnyStrippedStateEvent>>)>> + 'a>;
 
@@ -25,7 +24,7 @@ pub trait Data: Send + Sync {
 
 	fn get_our_real_users(&self, room_id: &RoomId) -> Result<Arc<HashSet<OwnedUserId>>>;
 
-	fn appservice_in_room(&self, room_id: &RoomId, appservice: &(String, Registration)) -> Result<bool>;
+	fn appservice_in_room(&self, room_id: &RoomId, appservice: &RegistrationInfo) -> Result<bool>;
 
 	/// Makes a user forget a room.
 	fn forget(&self, room_id: &RoomId, user_id: &UserId) -> Result<()>;

src/service/rooms/state_cache/mod.rs

@@ -2,7 +2,7 @@ use std::{collections::HashSet, sync::Arc};
 
 pub use data::Data;
 use ruma::{
-	api::{appservice::Registration, federation},
+	api::federation,
 	events::{
 		direct::DirectEvent,
 		ignored_user_list::IgnoredUserListEvent,
@@ -17,7 +17,7 @@ use ruma::{
 };
 use tracing::warn;
 
-use crate::{services, Error, Result};
+use crate::{service::appservice::RegistrationInfo, services, Error, Result};
 
 mod data;
 
@@ -201,7 +201,7 @@ impl Service {
 	}
 
 	#[tracing::instrument(skip(self, room_id, appservice))]
-	pub fn appservice_in_room(&self, room_id: &RoomId, appservice: &(String, Registration)) -> Result<bool> {
+	pub fn appservice_in_room(&self, room_id: &RoomId, appservice: &RegistrationInfo) -> Result<bool> {
 		self.db.appservice_in_room(room_id, appservice)
 	}
 

src/service/rooms/timeline/mod.rs

@@ -7,7 +7,6 @@ use std::{
 };
 
 pub use data::Data;
-use regex::Regex;
 use ruma::{
 	api::{client::error::ErrorKind, federation},
 	canonical_json::to_canonical_value,
@@ -36,7 +35,10 @@ use tracing::{error, info, warn};
 use super::state_compressor::CompressedStateEvent;
 use crate::{
 	api::server_server,
-	service::pdu::{EventHash, PduBuilder},
+	service::{
+		appservice::NamespaceRegex,
+		pdu::{EventHash, PduBuilder},
+	},
 	services, utils, Error, PduEvent, Result,
 };
 
@@ -506,9 +508,9 @@ impl Service {
 			}
 		}
 
-		for appservice in services().appservice.all()? {
-			if services().rooms.state_cache.appservice_in_room(&pdu.room_id, &appservice)? {
-				services().sending.send_pdu_appservice(appservice.0, pdu_id.clone())?;
+		for appservice in services().appservice.registration_info.read().await.values() {
+			if services().rooms.state_cache.appservice_in_room(&pdu.room_id, appservice)? {
+				services().sending.send_pdu_appservice(appservice.registration.id.clone(), pdu_id.clone())?;
 				continue;
 			}
 
@@ -518,30 +520,20 @@ impl Service {
 				if let Some(state_key_uid) =
 					&pdu.state_key.as_ref().and_then(|state_key| UserId::parse(state_key.as_str()).ok())
 				{
-					let appservice_uid = appservice.1.sender_localpart.as_str();
+					let appservice_uid = appservice.registration.sender_localpart.as_str();
 					if state_key_uid == appservice_uid {
-						services().sending.send_pdu_appservice(appservice.0, pdu_id.clone())?;
+						services().sending.send_pdu_appservice(appservice.registration.id.clone(), pdu_id.clone())?;
 						continue;
 					}
 				}
 			}
 
-			let namespaces = appservice.1.namespaces;
-
-			// TODO: create some helper function to change from Strings to Regexes
-			let users =
-				namespaces.users.iter().filter_map(|user| Regex::new(user.regex.as_str()).ok()).collect::<Vec<_>>();
-			let aliases =
-				namespaces.aliases.iter().filter_map(|alias| Regex::new(alias.regex.as_str()).ok()).collect::<Vec<_>>();
-			let rooms =
-				namespaces.rooms.iter().filter_map(|room| Regex::new(room.regex.as_str()).ok()).collect::<Vec<_>>();
-
-			let matching_users = |users: &Regex| {
-				users.is_match(pdu.sender.as_str())
+			let matching_users = |users: &NamespaceRegex| {
+				appservice.users.is_match(pdu.sender.as_str())
 					|| pdu.kind == TimelineEventType::RoomMember
 						&& pdu.state_key.as_ref().map_or(false, |state_key| users.is_match(state_key))
 			};
-			let matching_aliases = |aliases: &Regex| {
+			let matching_aliases = |aliases: &NamespaceRegex| {
 				services()
 					.rooms
 					.alias
@@ -550,11 +542,11 @@ impl Service {
 					.any(|room_alias| aliases.is_match(room_alias.as_str()))
 			};
 
-			if aliases.iter().any(matching_aliases)
-				|| rooms.iter().any(|namespace| namespace.is_match(pdu.room_id.as_str()))
-				|| users.iter().any(matching_users)
+			if matching_aliases(&appservice.aliases)
+				|| appservice.rooms.is_match(pdu.room_id.as_str())
+				|| matching_users(&appservice.users)
 			{
-				services().sending.send_pdu_appservice(appservice.0, pdu_id.clone())?;
+				services().sending.send_pdu_appservice(appservice.registration.id.clone(), pdu_id.clone())?;
 			}
 		}