Hot-Reloading Refactor

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

src/api/Cargo.toml

@@ -0,0 +1,66 @@
+[package]
+name = "conduit_api"
+version.workspace = true
+edition.workspace = true
+
+[lib]
+path = "mod.rs"
+crate-type = [
+	"rlib",
+#	"dylib",
+]
+
+[features]
+default = [
+	"element_hacks",
+	"gzip_compression",
+	"brotli_compression",
+	"release_max_log_level",
+]
+
+element_hacks = []
+dev_release_log_level = []
+release_max_log_level = [
+	"tracing/max_level_trace",
+	"tracing/release_max_level_info",
+	"log/max_level_trace",
+	"log/release_max_level_info",
+]
+gzip_compression = [
+	"reqwest/gzip",
+]
+brotli_compression = [
+	"reqwest/brotli",
+]
+
+[dependencies]
+argon2.workspace = true
+axum-extra.workspace = true
+axum.workspace = true
+base64.workspace = true
+bytes.workspace = true
+conduit-core.workspace = true
+conduit-database.workspace = true
+conduit-service.workspace = true
+futures-util.workspace = true
+hmac.workspace = true
+http.workspace = true
+hyper.workspace = true
+image.workspace = true
+ipaddress.workspace = true
+jsonwebtoken.workspace = true
+log.workspace = true
+rand.workspace = true
+reqwest.workspace = true
+ruma.workspace = true
+serde_html_form.workspace = true
+serde_json.workspace = true
+serde.workspace = true
+sha-1.workspace = true
+thiserror.workspace = true
+tokio.workspace = true
+tracing.workspace = true
+webpage.workspace = true
+
+[lints]
+workspace = true

src/api/client_server/account.rs

@@ -19,9 +19,10 @@ use tracing::{error, info, warn};
 
 use super::{DEVICE_ID_LENGTH, SESSION_ID_LENGTH, TOKEN_LENGTH};
 use crate::{
-	api::client_server::{self, join_room_by_id_helper},
-	service, services,
-	utils::{self, user_id::user_is_local},
+	client_server::{self, join_room_by_id_helper},
+	service::user_is_local,
+	services,
+	utils::{self},
 	Error, Result, Ruma,
 };
 

src/api/client_server/alias.rs

@@ -13,8 +13,9 @@ use ruma::{
 use tracing::debug;
 
 use crate::{
-	debug_info, debug_warn, service::appservice::RegistrationInfo, services, utils::server_name::server_is_ours, Error,
-	Result, Ruma,
+	debug_info, debug_warn,
+	service::{appservice::RegistrationInfo, server_is_ours},
+	services, Error, Result, Ruma,
 };
 
 /// # `PUT /_matrix/client/v3/directory/room/{roomAlias}`
@@ -65,7 +66,6 @@ pub(crate) async fn create_alias_route(body: Ruma<create_alias::v3::Request>) ->
 /// - TODO: Update canonical alias event
 pub(crate) async fn delete_alias_route(body: Ruma<delete_alias::v3::Request>) -> Result<delete_alias::v3::Response> {
 	alias_checks(&body.room_alias, &body.appservice_info).await?;
-
 	if services()
 		.rooms
 		.alias
@@ -99,7 +99,7 @@ pub(crate) async fn get_alias_route(body: Ruma<get_alias::v3::Request>) -> Resul
 	get_alias_helper(body.body.room_alias, None).await
 }
 
-pub(crate) async fn get_alias_helper(
+pub async fn get_alias_helper(
 	room_alias: OwnedRoomAliasId, servers: Option<Vec<OwnedServerName>>,
 ) -> Result<get_alias::v3::Response> {
 	debug!("get_alias_helper servers: {servers:?}");

src/api/client_server/directory.rs

@@ -24,7 +24,7 @@ use ruma::{
 };
 use tracing::{error, info, warn};
 
-use crate::{services, utils::server_name::server_is_ours, Error, Result, Ruma};
+use crate::{service::server_is_ours, services, Error, Result, Ruma};
 
 /// # `POST /_matrix/client/v3/publicRooms`
 ///

src/api/client_server/keys.rs

@@ -22,8 +22,9 @@ use tracing::debug;
 
 use super::SESSION_ID_LENGTH;
 use crate::{
+	service::user_is_local,
 	services,
-	utils::{self, user_id::user_is_local},
+	utils::{self},
 	Error, Result, Ruma,
 };
 

src/api/client_server/media.rs

@@ -15,14 +15,16 @@ use webpage::HTML;
 
 use crate::{
 	debug_warn,
-	service::media::{FileMeta, UrlPreviewData},
+	service::{
+		media::{FileMeta, UrlPreviewData},
+		server_is_ours,
+	},
 	services,
 	utils::{
 		self,
 		content_disposition::{
 			content_disposition_type, make_content_disposition, make_content_type, sanitise_filename,
 		},
-		server_name::server_is_ours,
 	},
 	Error, Result, Ruma, RumaResponse,
 };

src/api/client_server/membership.rs

@@ -35,9 +35,12 @@ use tracing::{debug, error, info, trace, warn};
 
 use super::get_alias_helper;
 use crate::{
-	service::pdu::{gen_event_id_canonical_json, PduBuilder},
+	service::{
+		pdu::{gen_event_id_canonical_json, PduBuilder},
+		server_is_ours, user_is_local,
+	},
 	services,
-	utils::{self, server_name::server_is_ours, user_id::user_is_local},
+	utils::{self},
 	Error, PduEvent, Result, Ruma,
 };
 
@@ -607,7 +610,7 @@ pub(crate) async fn joined_members_route(
 	})
 }
 
-pub(crate) async fn join_room_by_id_helper(
+pub async fn join_room_by_id_helper(
 	sender_user: Option<&UserId>, room_id: &RoomId, reason: Option<String>, servers: &[OwnedServerName],
 	_third_party_signed: Option<&ThirdPartySigned>,
 ) -> Result<join_room_by_id::v3::Response> {
@@ -1525,7 +1528,7 @@ pub(crate) async fn invite_helper(
 
 // Make a user leave all their joined rooms, forgets all rooms, and ignores
 // errors
-pub(crate) async fn leave_all_rooms(user_id: &UserId) {
+pub async fn leave_all_rooms(user_id: &UserId) {
 	let all_rooms = services()
 		.rooms
 		.state_cache
@@ -1550,7 +1553,7 @@ pub(crate) async fn leave_all_rooms(user_id: &UserId) {
 	}
 }
 
-pub(crate) async fn leave_room(user_id: &UserId, room_id: &RoomId, reason: Option<String>) -> Result<()> {
+pub async fn leave_room(user_id: &UserId, room_id: &RoomId, reason: Option<String>) -> Result<()> {
 	// Ask a remote server if we don't have this room
 	if !services()
 		.rooms

src/api/client_server/message.rs

@@ -3,6 +3,7 @@ use std::{
 	sync::Arc,
 };
 
+use conduit::PduCount;
 use ruma::{
 	api::client::{
 		error::ErrorKind,
@@ -14,10 +15,7 @@ use ruma::{
 };
 use serde_json::{from_str, Value};
 
-use crate::{
-	service::{pdu::PduBuilder, rooms::timeline::PduCount},
-	services, utils, Error, PduEvent, Result, Ruma,
-};
+use crate::{service::pdu::PduBuilder, services, utils, Error, PduEvent, Result, Ruma};
 
 /// # `PUT /_matrix/client/v3/rooms/{roomId}/send/{eventType}/{txnId}`
 ///

src/api/client_server/mod.rs

@@ -1,40 +1,41 @@
-mod account;
-mod alias;
-mod backup;
-mod capabilities;
-mod config;
-mod context;
-mod device;
-mod directory;
-mod filter;
-mod keys;
-mod media;
-mod membership;
-mod message;
-mod presence;
-mod profile;
-mod push;
-mod read_marker;
-mod redact;
-mod relations;
-mod report;
-mod room;
-mod search;
-mod session;
-mod space;
-mod state;
-mod sync;
-mod tag;
-mod thirdparty;
-mod threads;
-mod to_device;
-mod typing;
-mod unstable;
-mod unversioned;
-mod user_directory;
-mod voip;
+pub(crate) mod account;
+pub(crate) mod alias;
+pub(crate) mod backup;
+pub(crate) mod capabilities;
+pub(crate) mod config;
+pub(crate) mod context;
+pub(crate) mod device;
+pub(crate) mod directory;
+pub(crate) mod filter;
+pub(crate) mod keys;
+pub(crate) mod media;
+pub(crate) mod membership;
+pub(crate) mod message;
+pub(crate) mod presence;
+pub(crate) mod profile;
+pub(crate) mod push;
+pub(crate) mod read_marker;
+pub(crate) mod redact;
+pub(crate) mod relations;
+pub(crate) mod report;
+pub(crate) mod room;
+pub(crate) mod search;
+pub(crate) mod session;
+pub(crate) mod space;
+pub(crate) mod state;
+pub(crate) mod sync;
+pub(crate) mod tag;
+pub(crate) mod thirdparty;
+pub(crate) mod threads;
+pub(crate) mod to_device;
+pub(crate) mod typing;
+pub(crate) mod unstable;
+pub(crate) mod unversioned;
+pub(crate) mod user_directory;
+pub(crate) mod voip;
 
 pub(crate) use account::*;
+pub use alias::get_alias_helper;
 pub(crate) use alias::*;
 pub(crate) use backup::*;
 pub(crate) use capabilities::*;
@@ -46,6 +47,7 @@ pub(crate) use filter::*;
 pub(crate) use keys::*;
 pub(crate) use media::*;
 pub(crate) use membership::*;
+pub use membership::{join_room_by_id_helper, leave_all_rooms, leave_room};
 pub(crate) use message::*;
 pub(crate) use presence::*;
 pub(crate) use profile::*;
@@ -77,7 +79,4 @@ const DEVICE_ID_LENGTH: usize = 10;
 const TOKEN_LENGTH: usize = 32;
 
 /// generated user session ID length
-pub(crate) const SESSION_ID_LENGTH: usize = 32;
-
-/// auto-generated password length
-pub(crate) const AUTO_GEN_PASSWORD_LENGTH: usize = 25;
+const SESSION_ID_LENGTH: usize = service::uiaa::SESSION_ID_LENGTH;

src/api/client_server/profile.rs

@@ -13,7 +13,10 @@ use ruma::{
 };
 use serde_json::value::to_raw_value;
 
-use crate::{service::pdu::PduBuilder, services, utils::user_id::user_is_local, Error, Result, Ruma};
+use crate::{
+	service::{pdu::PduBuilder, user_is_local},
+	services, Error, Result, Ruma,
+};
 
 /// # `PUT /_matrix/client/r0/profile/{userId}/displayname`
 ///

src/api/client_server/read_marker.rs

@@ -1,5 +1,6 @@
 use std::collections::BTreeMap;
 
+use conduit::PduCount;
 use ruma::{
 	api::client::{error::ErrorKind, read_marker::set_read_marker, receipt::create_receipt},
 	events::{
@@ -9,7 +10,7 @@ use ruma::{
 	MilliSecondsSinceUnixEpoch,
 };
 
-use crate::{service::rooms::timeline::PduCount, services, Error, Result, Ruma};
+use crate::{services, Error, Result, Ruma};
 
 /// # `POST /_matrix/client/r0/rooms/{roomId}/read_markers`
 ///

src/api/client_server/room.rs

@@ -1,5 +1,6 @@
 use std::{cmp::max, collections::BTreeMap, sync::Arc};
 
+use conduit::{debug_info, debug_warn};
 use ruma::{
 	api::client::{
 		error::ErrorKind,
@@ -28,8 +29,7 @@ use serde_json::{json, value::to_raw_value};
 use tracing::{error, info, warn};
 
 use crate::{
-	api::client_server::invite_helper,
-	debug_info, debug_warn,
+	client_server::invite_helper,
 	service::{appservice::RegistrationInfo, pdu::PduBuilder},
 	services, Error, Result, Ruma,
 };

src/api/client_server/state.rs

@@ -19,10 +19,8 @@ use ruma::{
 use tracing::{error, log::warn};
 
 use crate::{
-	service::{self, pdu::PduBuilder},
-	services,
-	utils::server_name::server_is_ours,
-	Error, Result, Ruma, RumaResponse,
+	service::{pdu::PduBuilder, server_is_ours},
+	services, Error, Result, Ruma, RumaResponse,
 };
 
 /// # `PUT /_matrix/client/*/rooms/{roomId}/state/{eventType}/{stateKey}`

src/api/client_server/sync.rs

@@ -5,6 +5,7 @@ use std::{
 	time::Duration,
 };
 
+use conduit::PduCount;
 use ruma::{
 	api::client::{
 		filter::{FilterDefinition, LazyLoadOptions},
@@ -29,10 +30,7 @@ use ruma::{
 };
 use tracing::{error, Instrument as _, Span};
 
-use crate::{
-	service::{pdu::EventHash, rooms::timeline::PduCount},
-	services, utils, Error, PduEvent, Result, Ruma, RumaResponse,
-};
+use crate::{service::pdu::EventHash, services, utils, Error, PduEvent, Result, Ruma, RumaResponse};
 
 /// # `GET /_matrix/client/r0/sync`
 ///

src/api/client_server/to_device.rs

@@ -8,7 +8,7 @@ use ruma::{
 	to_device::DeviceIdOrAllDevices,
 };
 
-use crate::{services, utils::user_id::user_is_local, Error, Result, Ruma};
+use crate::{services, user_is_local, Error, Result, Ruma};
 
 /// # `PUT /_matrix/client/r0/sendToDevice/{eventType}/{txnId}`
 ///

src/api/mod.rs

@@ -1,3 +1,15 @@
-pub(crate) mod client_server;
+pub mod client_server;
+pub mod router;
 pub(crate) mod ruma_wrapper;
-pub(crate) mod server_server;
+pub mod server_server;
+
+extern crate conduit_core as conduit;
+extern crate conduit_service as service;
+
+pub use client_server::membership::{join_room_by_id_helper, leave_all_rooms};
+pub(crate) use conduit::{debug_error, debug_info, debug_warn, error::RumaResponse, utils, Error, Result};
+pub(crate) use ruma_wrapper::Ruma;
+pub(crate) use service::{pdu::PduEvent, services, user_is_local};
+
+conduit::mod_ctor! {}
+conduit::mod_dtor! {}

src/api/router.rs

@@ -0,0 +1,313 @@
+use std::future::Future;
+
+use axum::{
+	extract::FromRequestParts,
+	response::IntoResponse,
+	routing::{any, get, on, post, MethodFilter},
+	Router,
+};
+use conduit::{Error, Result, Server};
+use http::{Method, Uri};
+use ruma::api::{client::error::ErrorKind, IncomingRequest};
+
+use crate::{client_server, server_server, Ruma, RumaResponse};
+
+pub fn build(router: Router, server: &Server) -> Router {
+	let config = &server.config;
+	let router = router
+		.ruma_route(client_server::get_supported_versions_route)
+		.ruma_route(client_server::get_register_available_route)
+		.ruma_route(client_server::register_route)
+		.ruma_route(client_server::get_login_types_route)
+		.ruma_route(client_server::login_route)
+		.ruma_route(client_server::whoami_route)
+		.ruma_route(client_server::logout_route)
+		.ruma_route(client_server::logout_all_route)
+		.ruma_route(client_server::change_password_route)
+		.ruma_route(client_server::deactivate_route)
+		.ruma_route(client_server::third_party_route)
+		.ruma_route(client_server::request_3pid_management_token_via_email_route)
+		.ruma_route(client_server::request_3pid_management_token_via_msisdn_route)
+		.ruma_route(client_server::get_capabilities_route)
+		.ruma_route(client_server::get_pushrules_all_route)
+		.ruma_route(client_server::set_pushrule_route)
+		.ruma_route(client_server::get_pushrule_route)
+		.ruma_route(client_server::set_pushrule_enabled_route)
+		.ruma_route(client_server::get_pushrule_enabled_route)
+		.ruma_route(client_server::get_pushrule_actions_route)
+		.ruma_route(client_server::set_pushrule_actions_route)
+		.ruma_route(client_server::delete_pushrule_route)
+		.ruma_route(client_server::get_room_event_route)
+		.ruma_route(client_server::get_room_aliases_route)
+		.ruma_route(client_server::get_filter_route)
+		.ruma_route(client_server::create_filter_route)
+		.ruma_route(client_server::set_global_account_data_route)
+		.ruma_route(client_server::set_room_account_data_route)
+		.ruma_route(client_server::get_global_account_data_route)
+		.ruma_route(client_server::get_room_account_data_route)
+		.ruma_route(client_server::set_displayname_route)
+		.ruma_route(client_server::get_displayname_route)
+		.ruma_route(client_server::set_avatar_url_route)
+		.ruma_route(client_server::get_avatar_url_route)
+		.ruma_route(client_server::get_profile_route)
+		.ruma_route(client_server::set_presence_route)
+		.ruma_route(client_server::get_presence_route)
+		.ruma_route(client_server::upload_keys_route)
+		.ruma_route(client_server::get_keys_route)
+		.ruma_route(client_server::claim_keys_route)
+		.ruma_route(client_server::create_backup_version_route)
+		.ruma_route(client_server::update_backup_version_route)
+		.ruma_route(client_server::delete_backup_version_route)
+		.ruma_route(client_server::get_latest_backup_info_route)
+		.ruma_route(client_server::get_backup_info_route)
+		.ruma_route(client_server::add_backup_keys_route)
+		.ruma_route(client_server::add_backup_keys_for_room_route)
+		.ruma_route(client_server::add_backup_keys_for_session_route)
+		.ruma_route(client_server::delete_backup_keys_for_room_route)
+		.ruma_route(client_server::delete_backup_keys_for_session_route)
+		.ruma_route(client_server::delete_backup_keys_route)
+		.ruma_route(client_server::get_backup_keys_for_room_route)
+		.ruma_route(client_server::get_backup_keys_for_session_route)
+		.ruma_route(client_server::get_backup_keys_route)
+		.ruma_route(client_server::set_read_marker_route)
+		.ruma_route(client_server::create_receipt_route)
+		.ruma_route(client_server::create_typing_event_route)
+		.ruma_route(client_server::create_room_route)
+		.ruma_route(client_server::redact_event_route)
+		.ruma_route(client_server::report_event_route)
+		.ruma_route(client_server::create_alias_route)
+		.ruma_route(client_server::delete_alias_route)
+		.ruma_route(client_server::get_alias_route)
+		.ruma_route(client_server::join_room_by_id_route)
+		.ruma_route(client_server::join_room_by_id_or_alias_route)
+		.ruma_route(client_server::joined_members_route)
+		.ruma_route(client_server::leave_room_route)
+		.ruma_route(client_server::forget_room_route)
+		.ruma_route(client_server::joined_rooms_route)
+		.ruma_route(client_server::kick_user_route)
+		.ruma_route(client_server::ban_user_route)
+		.ruma_route(client_server::unban_user_route)
+		.ruma_route(client_server::invite_user_route)
+		.ruma_route(client_server::set_room_visibility_route)
+		.ruma_route(client_server::get_room_visibility_route)
+		.ruma_route(client_server::get_public_rooms_route)
+		.ruma_route(client_server::get_public_rooms_filtered_route)
+		.ruma_route(client_server::search_users_route)
+		.ruma_route(client_server::get_member_events_route)
+		.ruma_route(client_server::get_protocols_route)
+		.ruma_route(client_server::send_message_event_route)
+		.ruma_route(client_server::send_state_event_for_key_route)
+		.ruma_route(client_server::get_state_events_route)
+		.ruma_route(client_server::get_state_events_for_key_route)
+		// Ruma doesn't have support for multiple paths for a single endpoint yet, and these routes
+		// share one Ruma request / response type pair with {get,send}_state_event_for_key_route
+		.route(
+			"/_matrix/client/r0/rooms/:room_id/state/:event_type",
+			get(client_server::get_state_events_for_empty_key_route)
+				.put(client_server::send_state_event_for_empty_key_route),
+		)
+		.route(
+			"/_matrix/client/v3/rooms/:room_id/state/:event_type",
+			get(client_server::get_state_events_for_empty_key_route)
+				.put(client_server::send_state_event_for_empty_key_route),
+		)
+		// These two endpoints allow trailing slashes
+		.route(
+			"/_matrix/client/r0/rooms/:room_id/state/:event_type/",
+			get(client_server::get_state_events_for_empty_key_route)
+				.put(client_server::send_state_event_for_empty_key_route),
+		)
+		.route(
+			"/_matrix/client/v3/rooms/:room_id/state/:event_type/",
+			get(client_server::get_state_events_for_empty_key_route)
+				.put(client_server::send_state_event_for_empty_key_route),
+		)
+		.ruma_route(client_server::sync_events_route)
+		.ruma_route(client_server::sync_events_v4_route)
+		.ruma_route(client_server::get_context_route)
+		.ruma_route(client_server::get_message_events_route)
+		.ruma_route(client_server::search_events_route)
+		.ruma_route(client_server::turn_server_route)
+		.ruma_route(client_server::send_event_to_device_route)
+		.ruma_route(client_server::get_media_config_route)
+		.ruma_route(client_server::get_media_preview_route)
+		.ruma_route(client_server::create_content_route)
+		// legacy v1 media routes
+		.route(
+			"/_matrix/media/v1/preview_url",
+			get(client_server::get_media_preview_v1_route)
+		)
+		.route(
+			"/_matrix/media/v1/config",
+			get(client_server::get_media_config_v1_route)
+		)
+		.route(
+			"/_matrix/media/v1/upload",
+			post(client_server::create_content_v1_route)
+		)
+		.route(
+			"/_matrix/media/v1/download/:server_name/:media_id",
+			get(client_server::get_content_v1_route)
+		)
+		.route(
+			"/_matrix/media/v1/download/:server_name/:media_id/:file_name",
+			get(client_server::get_content_as_filename_v1_route)
+		)
+		.route(
+			"/_matrix/media/v1/thumbnail/:server_name/:media_id",
+			get(client_server::get_content_thumbnail_v1_route)
+		)
+		.ruma_route(client_server::get_content_route)
+		.ruma_route(client_server::get_content_as_filename_route)
+		.ruma_route(client_server::get_content_thumbnail_route)
+		.ruma_route(client_server::get_devices_route)
+		.ruma_route(client_server::get_device_route)
+		.ruma_route(client_server::update_device_route)
+		.ruma_route(client_server::delete_device_route)
+		.ruma_route(client_server::delete_devices_route)
+		.ruma_route(client_server::get_tags_route)
+		.ruma_route(client_server::update_tag_route)
+		.ruma_route(client_server::delete_tag_route)
+		.ruma_route(client_server::upload_signing_keys_route)
+		.ruma_route(client_server::upload_signatures_route)
+		.ruma_route(client_server::get_key_changes_route)
+		.ruma_route(client_server::get_pushers_route)
+		.ruma_route(client_server::set_pushers_route)
+		// .ruma_route(client_server::third_party_route)
+		.ruma_route(client_server::upgrade_room_route)
+		.ruma_route(client_server::get_threads_route)
+		.ruma_route(client_server::get_relating_events_with_rel_type_and_event_type_route)
+		.ruma_route(client_server::get_relating_events_with_rel_type_route)
+		.ruma_route(client_server::get_relating_events_route)
+		.ruma_route(client_server::get_hierarchy_route)
+        .ruma_route(client_server::get_mutual_rooms_route)
+        .ruma_route(client_server::well_known_support)
+        .ruma_route(client_server::well_known_client)
+        .route("/_conduwuit/server_version", get(client_server::conduwuit_server_version))
+		.route("/_matrix/client/r0/rooms/:room_id/initialSync", get(initial_sync))
+		.route("/_matrix/client/v3/rooms/:room_id/initialSync", get(initial_sync))
+		.route("/client/server.json", get(client_server::syncv3_client_server_json));
+
+	if config.allow_federation {
+		router
+			.ruma_route(server_server::get_server_version_route)
+			.route("/_matrix/key/v2/server", get(server_server::get_server_keys_route))
+			.route(
+				"/_matrix/key/v2/server/:key_id",
+				get(server_server::get_server_keys_deprecated_route),
+			)
+			.ruma_route(server_server::get_public_rooms_route)
+			.ruma_route(server_server::get_public_rooms_filtered_route)
+			.ruma_route(server_server::send_transaction_message_route)
+			.ruma_route(server_server::get_event_route)
+			.ruma_route(server_server::get_backfill_route)
+			.ruma_route(server_server::get_missing_events_route)
+			.ruma_route(server_server::get_event_authorization_route)
+			.ruma_route(server_server::get_room_state_route)
+			.ruma_route(server_server::get_room_state_ids_route)
+			.ruma_route(server_server::create_leave_event_template_route)
+			.ruma_route(server_server::create_leave_event_v1_route)
+			.ruma_route(server_server::create_leave_event_v2_route)
+			.ruma_route(server_server::create_join_event_template_route)
+			.ruma_route(server_server::create_join_event_v1_route)
+			.ruma_route(server_server::create_join_event_v2_route)
+			.ruma_route(server_server::create_invite_route)
+			.ruma_route(server_server::get_devices_route)
+			.ruma_route(server_server::get_room_information_route)
+			.ruma_route(server_server::get_profile_information_route)
+			.ruma_route(server_server::get_keys_route)
+			.ruma_route(server_server::claim_keys_route)
+			.ruma_route(server_server::get_hierarchy_route)
+			.ruma_route(server_server::well_known_server)
+	} else {
+		router
+			.route("/_matrix/federation/*path", any(federation_disabled))
+			.route("/.well-known/matrix/server", any(federation_disabled))
+			.route("/_matrix/key/*path", any(federation_disabled))
+	}
+}
+
+async fn initial_sync(_uri: Uri) -> impl IntoResponse {
+	Error::BadRequest(ErrorKind::GuestAccessForbidden, "Guest access not implemented")
+}
+
+async fn federation_disabled() -> impl IntoResponse { Error::bad_config("Federation is disabled.") }
+
+trait RouterExt {
+	fn ruma_route<H, T>(self, handler: H) -> Self
+	where
+		H: RumaHandler<T>,
+		T: 'static;
+}
+
+impl RouterExt for Router {
+	fn ruma_route<H, T>(self, handler: H) -> Self
+	where
+		H: RumaHandler<T>,
+		T: 'static,
+	{
+		handler.add_to_router(self)
+	}
+}
+
+trait RumaHandler<T> {
+	// Can't transform to a handler without boxing or relying on the nightly-only
+	// impl-trait-in-traits feature. Moving a small amount of extra logic into the
+	// trait allows bypassing both.
+	fn add_to_router(self, router: Router) -> Router;
+}
+
+macro_rules! impl_ruma_handler {
+    ( $($ty:ident),* $(,)? ) => {
+        #[axum::async_trait]
+        #[allow(non_snake_case)]
+        impl<Req, E, F, Fut, $($ty,)*> RumaHandler<($($ty,)* Ruma<Req>,)> for F
+        where
+            Req: IncomingRequest + Send + 'static,
+            F: FnOnce($($ty,)* Ruma<Req>) -> Fut + Clone + Send + 'static,
+            Fut: Future<Output = Result<Req::OutgoingResponse, E>>
+                + Send,
+            E: IntoResponse,
+            $( $ty: FromRequestParts<()> + Send + 'static, )*
+        {
+            fn add_to_router(self, mut router: Router) -> Router {
+                let meta = Req::METADATA;
+                let method_filter = method_to_filter(meta.method);
+
+                for path in meta.history.all_paths() {
+                    let handler = self.clone();
+
+                    router = router.route(path, on(method_filter, |$( $ty: $ty, )* req| async move {
+                        handler($($ty,)* req).await.map(RumaResponse)
+                    }))
+                }
+
+                router
+            }
+        }
+    };
+}
+
+impl_ruma_handler!();
+impl_ruma_handler!(T1);
+impl_ruma_handler!(T1, T2);
+impl_ruma_handler!(T1, T2, T3);
+impl_ruma_handler!(T1, T2, T3, T4);
+impl_ruma_handler!(T1, T2, T3, T4, T5);
+impl_ruma_handler!(T1, T2, T3, T4, T5, T6);
+impl_ruma_handler!(T1, T2, T3, T4, T5, T6, T7);
+impl_ruma_handler!(T1, T2, T3, T4, T5, T6, T7, T8);
+
+fn method_to_filter(method: Method) -> MethodFilter {
+	match method {
+		Method::DELETE => MethodFilter::DELETE,
+		Method::GET => MethodFilter::GET,
+		Method::HEAD => MethodFilter::HEAD,
+		Method::OPTIONS => MethodFilter::OPTIONS,
+		Method::PATCH => MethodFilter::PATCH,
+		Method::POST => MethodFilter::POST,
+		Method::PUT => MethodFilter::PUT,
+		Method::TRACE => MethodFilter::TRACE,
+		m => panic!("Unsupported HTTP method: {m:?}"),
+	}
+}

src/api/ruma_wrapper/axum.rs

@@ -3,30 +3,26 @@ use std::{collections::BTreeMap, str};
 use axum::{
 	async_trait,
 	extract::{FromRequest, Path},
-	response::{IntoResponse, Response},
 	RequestExt, RequestPartsExt,
 };
 use axum_extra::{
-	headers::{
-		authorization::{Bearer, Credentials},
-		Authorization,
-	},
+	headers::{authorization::Bearer, Authorization},
 	typed_header::TypedHeaderRejectionReason,
 	TypedHeader,
 };
 use bytes::{BufMut, BytesMut};
-use http::{uri::PathAndQuery, StatusCode};
-use http_body_util::Full;
+use conduit::debug_warn;
+use http::uri::PathAndQuery;
 use hyper::Request;
 use ruma::{
-	api::{client::error::ErrorKind, AuthScheme, IncomingRequest, OutgoingResponse},
-	CanonicalJsonValue, OwnedDeviceId, OwnedServerName, OwnedUserId, UserId,
+	api::{client::error::ErrorKind, AuthScheme, IncomingRequest},
+	CanonicalJsonValue, OwnedDeviceId, OwnedUserId, UserId,
 };
 use serde::Deserialize;
 use tracing::{debug, error, trace, warn};
 
-use super::{Ruma, RumaResponse};
-use crate::{debug_warn, service::appservice::RegistrationInfo, services, Error, Result};
+use super::{xmatrix::XMatrix, Ruma};
+use crate::{service::appservice::RegistrationInfo, services, Error, Result};
 
 enum Token {
 	Appservice(Box<RegistrationInfo>),
@@ -332,68 +328,3 @@ where
 		})
 	}
 }
-
-struct XMatrix {
-	origin: OwnedServerName,
-	destination: Option<String>,
-	key: String, // KeyName?
-	sig: String,
-}
-
-impl Credentials for XMatrix {
-	const SCHEME: &'static str = "X-Matrix";
-
-	fn decode(value: &http::HeaderValue) -> Option<Self> {
-		debug_assert!(
-			value.as_bytes().starts_with(b"X-Matrix "),
-			"HeaderValue to decode should start with \"X-Matrix ..\", received = {value:?}",
-		);
-
-		let parameters = str::from_utf8(&value.as_bytes()["X-Matrix ".len()..])
-			.ok()?
-			.trim_start();
-
-		let mut origin = None;
-		let mut destination = None;
-		let mut key = None;
-		let mut sig = None;
-
-		for entry in parameters.split_terminator(',') {
-			let (name, value) = entry.split_once('=')?;
-
-			// It's not at all clear why some fields are quoted and others not in the spec,
-			// let's simply accept either form for every field.
-			let value = value
-				.strip_prefix('"')
-				.and_then(|rest| rest.strip_suffix('"'))
-				.unwrap_or(value);
-
-			// FIXME: Catch multiple fields of the same name
-			match name {
-				"origin" => origin = Some(value.try_into().ok()?),
-				"key" => key = Some(value.to_owned()),
-				"sig" => sig = Some(value.to_owned()),
-				"destination" => destination = Some(value.to_owned()),
-				_ => debug!("Unexpected field `{name}` in X-Matrix Authorization header"),
-			}
-		}
-
-		Some(Self {
-			origin: origin?,
-			key: key?,
-			sig: sig?,
-			destination,
-		})
-	}
-
-	fn encode(&self) -> http::HeaderValue { todo!() }
-}
-
-impl<T: OutgoingResponse> IntoResponse for RumaResponse<T> {
-	fn into_response(self) -> Response {
-		match self.0.try_into_http_response::<BytesMut>() {
-			Ok(res) => res.map(BytesMut::freeze).map(Full::new).into_response(),
-			Err(_) => StatusCode::INTERNAL_SERVER_ERROR.into_response(),
-		}
-	}
-}

src/api/ruma_wrapper/mod.rs

@@ -1,10 +1,11 @@
+pub(crate) mod axum;
+mod xmatrix;
+
 use std::ops::Deref;
 
-use ruma::{api::client::uiaa::UiaaResponse, CanonicalJsonValue, OwnedDeviceId, OwnedServerName, OwnedUserId};
+use ruma::{CanonicalJsonValue, OwnedDeviceId, OwnedServerName, OwnedUserId};
 
-use crate::{service::appservice::RegistrationInfo, Error};
-
-mod axum;
+use crate::service::appservice::RegistrationInfo;
 
 /// Extractor for Ruma request structs
 pub(crate) struct Ruma<T> {
@@ -21,14 +22,3 @@ impl<T> Deref for Ruma<T> {
 
 	fn deref(&self) -> &Self::Target { &self.body }
 }
-
-#[derive(Clone)]
-pub(crate) struct RumaResponse<T>(pub(crate) T);
-
-impl<T> From<T> for RumaResponse<T> {
-	fn from(t: T) -> Self { Self(t) }
-}
-
-impl From<Error> for RumaResponse<UiaaResponse> {
-	fn from(t: Error) -> Self { t.to_response() }
-}

src/api/ruma_wrapper/xmatrix.rs

@@ -0,0 +1,61 @@
+use std::str;
+
+use axum_extra::headers::authorization::Credentials;
+use ruma::OwnedServerName;
+use tracing::debug;
+
+pub(crate) struct XMatrix {
+	pub(crate) origin: OwnedServerName,
+	pub(crate) destination: Option<String>,
+	pub(crate) key: String, // KeyName?
+	pub(crate) sig: String,
+}
+
+impl Credentials for XMatrix {
+	const SCHEME: &'static str = "X-Matrix";
+
+	fn decode(value: &http::HeaderValue) -> Option<Self> {
+		debug_assert!(
+			value.as_bytes().starts_with(b"X-Matrix "),
+			"HeaderValue to decode should start with \"X-Matrix ..\", received = {value:?}",
+		);
+
+		let parameters = str::from_utf8(&value.as_bytes()["X-Matrix ".len()..])
+			.ok()?
+			.trim_start();
+
+		let mut origin = None;
+		let mut destination = None;
+		let mut key = None;
+		let mut sig = None;
+
+		for entry in parameters.split_terminator(',') {
+			let (name, value) = entry.split_once('=')?;
+
+			// It's not at all clear why some fields are quoted and others not in the spec,
+			// let's simply accept either form for every field.
+			let value = value
+				.strip_prefix('"')
+				.and_then(|rest| rest.strip_suffix('"'))
+				.unwrap_or(value);
+
+			// FIXME: Catch multiple fields of the same name
+			match name {
+				"origin" => origin = Some(value.try_into().ok()?),
+				"key" => key = Some(value.to_owned()),
+				"sig" => sig = Some(value.to_owned()),
+				"destination" => destination = Some(value.to_owned()),
+				_ => debug!("Unexpected field `{name}` in X-Matrix Authorization header"),
+			}
+		}
+
+		Some(Self {
+			origin: origin?,
+			key: key?,
+			sig: sig?,
+			destination,
+		})
+	}
+
+	fn encode(&self) -> http::HeaderValue { todo!() }
+}

src/api/server_server.rs

@@ -44,19 +44,23 @@ use ruma::{
 	},
 	serde::{Base64, JsonObject, Raw},
 	to_device::DeviceIdOrAllDevices,
-	uint, user_id, CanonicalJsonObject, CanonicalJsonValue, EventId, MilliSecondsSinceUnixEpoch, OwnedEventId,
-	OwnedRoomId, OwnedServerName, OwnedServerSigningKeyId, OwnedUserId, RoomId, RoomVersionId, ServerName,
+	uint, user_id, CanonicalJsonValue, EventId, MilliSecondsSinceUnixEpoch, OwnedEventId, OwnedServerName,
+	OwnedServerSigningKeyId, OwnedUserId, RoomId, RoomVersionId, ServerName,
 };
 use serde_json::value::{to_raw_value, RawValue as RawJsonValue};
 use tokio::sync::RwLock;
 use tracing::{debug, error, trace, warn};
 
 use crate::{
-	api::client_server::{self, claim_keys_helper, get_keys_helper},
+	client_server::{self, claim_keys_helper, get_keys_helper},
 	debug_error,
-	service::pdu::{gen_event_id_canonical_json, PduBuilder},
+	service::{
+		pdu::{gen_event_id_canonical_json, PduBuilder},
+		rooms::event_handler::parse_incoming_pdu,
+		server_is_ours, user_is_local,
+	},
 	services,
-	utils::{self, server_name::server_is_ours, user_id::user_is_local},
+	utils::{self},
 	Error, PduEvent, Result, Ruma,
 };
 
@@ -196,32 +200,6 @@ pub(crate) async fn get_public_rooms_route(
 	})
 }
 
-pub(crate) fn parse_incoming_pdu(pdu: &RawJsonValue) -> Result<(OwnedEventId, CanonicalJsonObject, OwnedRoomId)> {
-	let value: CanonicalJsonObject = serde_json::from_str(pdu.get()).map_err(|e| {
-		warn!("Error parsing incoming event {:?}: {:?}", pdu, e);
-		Error::BadServerResponse("Invalid PDU in server response")
-	})?;
-
-	let room_id: OwnedRoomId = value
-		.get("room_id")
-		.and_then(|id| RoomId::parse(id.as_str()?).ok())
-		.ok_or(Error::BadRequest(ErrorKind::InvalidParam, "Invalid room id in pdu"))?;
-
-	let Ok(room_version_id) = services().rooms.state.get_room_version(&room_id) else {
-		return Err(Error::Err(format!("Server is not in room {room_id}")));
-	};
-
-	let Ok((event_id, value)) = gen_event_id_canonical_json(pdu, &room_version_id) else {
-		// Event could not be converted to canonical json
-		return Err(Error::BadRequest(
-			ErrorKind::InvalidParam,
-			"Could not convert event to canonical json.",
-		));
-	};
-
-	Ok((event_id, value, room_id))
-}
-
 /// # `PUT /_matrix/federation/v1/send/{txnId}`
 ///
 /// Push EDUs and PDUs to this server.