diffuse get_alias_helper into services::rooms::alias

Signed-off-by: Jason Volk <jason@zemos.net>

src/service/rooms/alias/mod.rs

@@ -1,4 +1,5 @@
 mod data;
+mod remote;
 
 use std::sync::Arc;
 
@@ -6,15 +7,15 @@ use conduit::{Error, Result, Server};
 use data::Data;
 use database::Database;
 use ruma::{
-	api::client::error::ErrorKind,
+	api::{appservice, client::error::ErrorKind},
 	events::{
 		room::power_levels::{RoomPowerLevels, RoomPowerLevelsEventContent},
 		StateEventType,
 	},
-	OwnedRoomAliasId, OwnedRoomId, RoomAliasId, RoomId, UserId,
+	OwnedRoomAliasId, OwnedRoomId, OwnedServerName, RoomAliasId, RoomId, UserId,
 };
 
-use crate::services;
+use crate::{appservice::RegistrationInfo, server_is_ours, services};
 
 pub struct Service {
 	db: Data,
@@ -51,6 +52,30 @@ impl Service {
 		}
 	}
 
+	#[tracing::instrument(skip(self), name = "resolve")]
+	pub async fn resolve_alias(
+		&self, room_alias: &RoomAliasId, servers: Option<&Vec<OwnedServerName>>,
+	) -> Result<(OwnedRoomId, Option<Vec<OwnedServerName>>)> {
+		if !server_is_ours(room_alias.server_name())
+			&& (!servers
+				.as_ref()
+				.is_some_and(|servers| servers.contains(&services().globals.server_name().to_owned()))
+				|| servers.as_ref().is_none())
+		{
+			return remote::resolve(room_alias, servers).await;
+		}
+
+		let room_id: Option<OwnedRoomId> = match self.resolve_local_alias(room_alias)? {
+			Some(r) => Some(r),
+			None => self.resolve_appservice_alias(room_alias).await?,
+		};
+
+		room_id.map_or_else(
+			|| Err(Error::BadRequest(ErrorKind::NotFound, "Room with alias not found.")),
+			|room_id| Ok((room_id, None)),
+		)
+	}
+
 	#[tracing::instrument(skip(self))]
 	pub fn resolve_local_alias(&self, alias: &RoomAliasId) -> Result<Option<OwnedRoomId>> {
 		self.db.resolve_local_alias(alias)
@@ -112,4 +137,48 @@ impl Service {
 			Err(Error::bad_database("Room has no m.room.create event"))
 		}
 	}
+
+	async fn resolve_appservice_alias(&self, room_alias: &RoomAliasId) -> Result<Option<OwnedRoomId>> {
+		for appservice in services().appservice.read().await.values() {
+			if appservice.aliases.is_match(room_alias.as_str())
+				&& matches!(
+					services()
+						.sending
+						.send_appservice_request(
+							appservice.registration.clone(),
+							appservice::query::query_room_alias::v1::Request {
+								room_alias: room_alias.to_owned(),
+							},
+						)
+						.await,
+					Ok(Some(_opt_result))
+				) {
+				return Ok(Some(
+					services()
+						.rooms
+						.alias
+						.resolve_local_alias(room_alias)?
+						.ok_or_else(|| Error::bad_config("Room does not exist."))?,
+				));
+			}
+		}
+
+		Ok(None)
+	}
+}
+
+pub async fn appservice_checks(room_alias: &RoomAliasId, appservice_info: &Option<RegistrationInfo>) -> Result<()> {
+	if !server_is_ours(room_alias.server_name()) {
+		return Err(Error::BadRequest(ErrorKind::InvalidParam, "Alias is from another server."));
+	}
+
+	if let Some(ref info) = appservice_info {
+		if !info.aliases.is_match(room_alias.as_str()) {
+			return Err(Error::BadRequest(ErrorKind::Exclusive, "Room alias is not in namespace."));
+		}
+	} else if services().appservice.is_exclusive_alias(room_alias).await {
+		return Err(Error::BadRequest(ErrorKind::Exclusive, "Room alias reserved by appservice."));
+	}
+
+	Ok(())
 }

src/service/rooms/alias/remote.rs

@@ -0,0 +1,71 @@
+use conduit::{debug, debug_info, debug_warn, Error, Result};
+use ruma::{
+	api::{client::error::ErrorKind, federation},
+	OwnedRoomId, OwnedServerName, RoomAliasId,
+};
+
+use crate::services;
+
+pub(super) async fn resolve(
+	room_alias: &RoomAliasId, servers: Option<&Vec<OwnedServerName>>,
+) -> Result<(OwnedRoomId, Option<Vec<OwnedServerName>>)> {
+	debug!(?room_alias, ?servers, "resolve");
+
+	let mut response = services()
+		.sending
+		.send_federation_request(
+			room_alias.server_name(),
+			federation::query::get_room_information::v1::Request {
+				room_alias: room_alias.to_owned(),
+			},
+		)
+		.await;
+
+	debug!("room alias server_name get_alias_helper response: {response:?}");
+
+	if let Err(ref e) = response {
+		debug_info!(
+			"Server {} of the original room alias failed to assist in resolving room alias: {e}",
+			room_alias.server_name()
+		);
+	}
+
+	if response.as_ref().is_ok_and(|resp| resp.servers.is_empty()) || response.as_ref().is_err() {
+		if let Some(servers) = servers {
+			for server in servers {
+				response = services()
+					.sending
+					.send_federation_request(
+						server,
+						federation::query::get_room_information::v1::Request {
+							room_alias: room_alias.to_owned(),
+						},
+					)
+					.await;
+				debug!("Got response from server {server} for room aliases: {response:?}");
+
+				if let Ok(ref response) = response {
+					if !response.servers.is_empty() {
+						break;
+					}
+					debug_warn!("Server {server} responded with room aliases, but was empty? Response: {response:?}");
+				}
+			}
+		}
+	}
+
+	if let Ok(response) = response {
+		let room_id = response.room_id;
+
+		let mut pre_servers = response.servers;
+		// since the room alis server responded, insert it into the list
+		pre_servers.push(room_alias.server_name().into());
+
+		return Ok((room_id, Some(pre_servers)));
+	}
+
+	Err(Error::BadRequest(
+		ErrorKind::NotFound,
+		"No servers could assist in resolving the room alias",
+	))
+}