backups/grapevine
1
0
Fork 0
mirror of https://gitlab.computer.surgery/matrix/grapevine.git synced 2025-12-17 07:41:23 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

don't automatically wrap in RumaResponse

Browse source 
This allows us to use the `ruma_route` convenience function even when we
need to add our own hacks into the responses, thus making us less
reliant on Ruma.
This commit is contained in:
Charles Hall 2024-05-18 18:31:36 -07:00
parent 87ac0e2a38
commit 230ebd3884
No known key found for this signature in database
GPG key ID: 7B8E0645816E07CF
35 changed files with 438 additions and 405 deletions
Download patch file Download diff file Expand all files Collapse all files

48
src/api/client_server/account.rs
View file

@ -19,7 +19,9 @@ use ruma::{
use tracing::{info, warn};
use super::{DEVICE_ID_LENGTH, SESSION_ID_LENGTH, TOKEN_LENGTH};
use crate::{api::client_server, services, utils, Error, Result, Ruma};
use crate::{
api::client_server, services, utils, Error, Result, Ruma, RumaResponse,
};
const RANDOM_USER_ID_LENGTH: usize = 10;
@ -36,7 +38,7 @@ const RANDOM_USER_ID_LENGTH: usize = 10;
/// invalid when trying to register
pub(crate) async fn get_register_available_route(
body: Ruma<get_username_availability::v3::Request>,
) -> Result<get_username_availability::v3::Response> {
) -> Result<RumaResponse<get_username_availability::v3::Response>> {
// Validate user id
let user_id = UserId::parse_with_server_name(
body.username.to_lowercase(),
@ -63,9 +65,9 @@ pub(crate) async fn get_register_available_route(
// TODO add check for appservice namespaces
// If no if check is true we have an username that's available to be used.
Ok(get_username_availability::v3::Response {
Ok(RumaResponse(get_username_availability::v3::Response {
available: true,
})
}))
}
/// # `POST /_matrix/client/r0/register`
@ -88,7 +90,7 @@ pub(crate) async fn get_register_available_route(
#[allow(clippy::too_many_lines)]
pub(crate) async fn register_route(
body: Ruma<register::v3::Request>,
) -> Result<register::v3::Response> {
) -> Result<RumaResponse<register::v3::Response>> {
if !services().globals.allow_registration()
&& body.appservice_info.is_none()
{
@ -248,13 +250,13 @@ pub(crate) async fn register_route(
// Inhibit login does not work for guests
if !is_guest && body.inhibit_login {
return Ok(register::v3::Response {
return Ok(RumaResponse(register::v3::Response {
access_token: None,
user_id,
device_id: None,
refresh_token: None,
expires_in: None,
});
}));
}
// Generate new device id if the user didn't specify one
@ -300,13 +302,13 @@ pub(crate) async fn register_route(
}
}
Ok(register::v3::Response {
Ok(RumaResponse(register::v3::Response {
access_token: Some(token),
user_id,
device_id: Some(device_id),
refresh_token: None,
expires_in: None,
})
}))
}
/// # `POST /_matrix/client/r0/account/password`
@ -328,7 +330,7 @@ pub(crate) async fn register_route(
/// - Triggers device list updates
pub(crate) async fn change_password_route(
body: Ruma<change_password::v3::Request>,
) -> Result<change_password::v3::Response> {
) -> Result<RumaResponse<change_password::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let sender_device =
body.sender_device.as_ref().expect("user is authenticated");
@ -381,7 +383,7 @@ pub(crate) async fn change_password_route(
format!("User {sender_user} changed their password."),
));
Ok(change_password::v3::Response {})
Ok(RumaResponse(change_password::v3::Response {}))
}
/// # `GET _matrix/client/r0/account/whoami`
@ -391,16 +393,16 @@ pub(crate) async fn change_password_route(
/// Note: Also works for Application Services
pub(crate) async fn whoami_route(
body: Ruma<whoami::v3::Request>,
) -> Result<whoami::v3::Response> {
) -> Result<RumaResponse<whoami::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let device_id = body.sender_device.as_ref().cloned();
Ok(whoami::v3::Response {
Ok(RumaResponse(whoami::v3::Response {
user_id: sender_user.clone(),
device_id,
is_guest: services().users.is_deactivated(sender_user)?
&& body.appservice_info.is_none(),
})
}))
}
/// # `POST /_matrix/client/r0/account/deactivate`
@ -416,7 +418,7 @@ pub(crate) async fn whoami_route(
/// - Removes ability to log in again
pub(crate) async fn deactivate_route(
body: Ruma<deactivate::v3::Request>,
) -> Result<deactivate::v3::Response> {
) -> Result<RumaResponse<deactivate::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let sender_device =
body.sender_device.as_ref().expect("user is authenticated");
@ -461,9 +463,9 @@ pub(crate) async fn deactivate_route(
format!("User {sender_user} deactivated their account."),
));
Ok(deactivate::v3::Response {
Ok(RumaResponse(deactivate::v3::Response {
id_server_unbind_result: ThirdPartyIdRemovalStatus::NoSupport,
})
}))
}
/// # `GET _matrix/client/v3/account/3pid`
@ -473,11 +475,11 @@ pub(crate) async fn deactivate_route(
/// - Currently always returns empty list
pub(crate) async fn third_party_route(
body: Ruma<get_3pids::v3::Request>,
) -> Result<get_3pids::v3::Response> {
) -> Result<RumaResponse<get_3pids::v3::Response>> {
let _sender_user =
body.sender_user.as_ref().expect("user is authenticated");
Ok(get_3pids::v3::Response::new(Vec::new()))
Ok(RumaResponse(get_3pids::v3::Response::new(Vec::new())))
}
/// # `POST /_matrix/client/v3/account/3pid/email/requestToken`
@ -489,7 +491,8 @@ pub(crate) async fn third_party_route(
/// as a contact option.
pub(crate) async fn request_3pid_management_token_via_email_route(
_body: Ruma<request_3pid_management_token_via_email::v3::Request>,
) -> Result<request_3pid_management_token_via_email::v3::Response> {
) -> Result<RumaResponse<request_3pid_management_token_via_email::v3::Response>>
{
Err(Error::BadRequest(
ErrorKind::ThreepidDenied,
"Third party identifier is not allowed",
@ -503,9 +506,12 @@ pub(crate) async fn request_3pid_management_token_via_email_route(
///
/// - 403 signals that The homeserver does not allow the third party identifier
/// as a contact option.
#[rustfmt::skip]
pub(crate) async fn request_3pid_management_token_via_msisdn_route(
_body: Ruma<request_3pid_management_token_via_msisdn::v3::Request>,
) -> Result<request_3pid_management_token_via_msisdn::v3::Response> {
)
-> Result<RumaResponse<request_3pid_management_token_via_msisdn::v3::Response>>
{
Err(Error::BadRequest(
ErrorKind::ThreepidDenied,
"Third party identifier is not allowed",

14
src/api/client_server/alias.rs
View file

@ -11,14 +11,14 @@ use ruma::{
OwnedRoomAliasId,
};
use crate::{services, Error, Result, Ruma};
use crate::{services, Error, Result, Ruma, RumaResponse};
/// # `PUT /_matrix/client/r0/directory/room/{roomAlias}`
///
/// Creates a new room alias on this server.
pub(crate) async fn create_alias_route(
body: Ruma<create_alias::v3::Request>,
) -> Result<create_alias::v3::Response> {
) -> Result<RumaResponse<create_alias::v3::Response>> {
if body.room_alias.server_name() != services().globals.server_name() {
return Err(Error::BadRequest(
ErrorKind::InvalidParam,
@ -46,7 +46,7 @@ pub(crate) async fn create_alias_route(
services().rooms.alias.set_alias(&body.room_alias, &body.room_id)?;
Ok(create_alias::v3::Response::new())
Ok(RumaResponse(create_alias::v3::Response::new()))
}
/// # `DELETE /_matrix/client/r0/directory/room/{roomAlias}`
@ -57,7 +57,7 @@ pub(crate) async fn create_alias_route(
/// - TODO: Update canonical alias event
pub(crate) async fn delete_alias_route(
body: Ruma<delete_alias::v3::Request>,
) -> Result<delete_alias::v3::Response> {
) -> Result<RumaResponse<delete_alias::v3::Response>> {
if body.room_alias.server_name() != services().globals.server_name() {
return Err(Error::BadRequest(
ErrorKind::InvalidParam,
@ -83,7 +83,7 @@ pub(crate) async fn delete_alias_route(
// TODO: update alt_aliases?
Ok(delete_alias::v3::Response::new())
Ok(RumaResponse(delete_alias::v3::Response::new()))
}
/// # `GET /_matrix/client/r0/directory/room/{roomAlias}`
@ -93,8 +93,8 @@ pub(crate) async fn delete_alias_route(
/// - TODO: Suggest more servers to join via
pub(crate) async fn get_alias_route(
body: Ruma<get_alias::v3::Request>,
) -> Result<get_alias::v3::Response> {
get_alias_helper(body.body.room_alias).await
) -> Result<RumaResponse<get_alias::v3::Response>> {
get_alias_helper(body.body.room_alias).await.map(RumaResponse)
}
pub(crate) async fn get_alias_helper(

82
src/api/client_server/backup.rs
View file

@ -9,21 +9,21 @@ use ruma::api::client::{
error::ErrorKind,
};
use crate::{services, Error, Result, Ruma};
use crate::{services, Error, Result, Ruma, RumaResponse};
/// # `POST /_matrix/client/r0/room_keys/version`
///
/// Creates a new backup.
pub(crate) async fn create_backup_version_route(
body: Ruma<create_backup_version::v3::Request>,
) -> Result<create_backup_version::v3::Response> {
) -> Result<RumaResponse<create_backup_version::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let version =
services().key_backups.create_backup(sender_user, &body.algorithm)?;
Ok(create_backup_version::v3::Response {
Ok(RumaResponse(create_backup_version::v3::Response {
version,
})
}))
}
/// # `PUT /_matrix/client/r0/room_keys/version/{version}`
@ -32,7 +32,7 @@ pub(crate) async fn create_backup_version_route(
/// modified.
pub(crate) async fn update_backup_version_route(
body: Ruma<update_backup_version::v3::Request>,
) -> Result<update_backup_version::v3::Response> {
) -> Result<RumaResponse<update_backup_version::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
services().key_backups.update_backup(
sender_user,
@ -40,7 +40,7 @@ pub(crate) async fn update_backup_version_route(
&body.algorithm,
)?;
Ok(update_backup_version::v3::Response {})
Ok(RumaResponse(update_backup_version::v3::Response {}))
}
/// # `GET /_matrix/client/r0/room_keys/version`
@ -48,7 +48,7 @@ pub(crate) async fn update_backup_version_route(
/// Get information about the latest backup version.
pub(crate) async fn get_latest_backup_info_route(
body: Ruma<get_latest_backup_info::v3::Request>,
) -> Result<get_latest_backup_info::v3::Response> {
) -> Result<RumaResponse<get_latest_backup_info::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let (version, algorithm) = services()
@ -59,7 +59,7 @@ pub(crate) async fn get_latest_backup_info_route(
"Key backup does not exist.",
))?;
Ok(get_latest_backup_info::v3::Response {
Ok(RumaResponse(get_latest_backup_info::v3::Response {
algorithm,
count: services()
.key_backups
@ -68,7 +68,7 @@ pub(crate) async fn get_latest_backup_info_route(
.expect("count should fit in UInt"),
etag: services().key_backups.get_etag(sender_user, &version)?,
version,
})
}))
}
/// # `GET /_matrix/client/r0/room_keys/version`
@ -76,7 +76,7 @@ pub(crate) async fn get_latest_backup_info_route(
/// Get information about an existing backup.
pub(crate) async fn get_backup_info_route(
body: Ruma<get_backup_info::v3::Request>,
) -> Result<get_backup_info::v3::Response> {
) -> Result<RumaResponse<get_backup_info::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let algorithm = services()
.key_backups
@ -86,7 +86,7 @@ pub(crate) async fn get_backup_info_route(
"Key backup does not exist.",
))?;
Ok(get_backup_info::v3::Response {
Ok(RumaResponse(get_backup_info::v3::Response {
algorithm,
count: services()
.key_backups
@ -95,7 +95,7 @@ pub(crate) async fn get_backup_info_route(
.expect("count should fit in UInt"),
etag: services().key_backups.get_etag(sender_user, &body.version)?,
version: body.version.clone(),
})
}))
}
/// # `DELETE /_matrix/client/r0/room_keys/version/{version}`
@ -106,12 +106,12 @@ pub(crate) async fn get_backup_info_route(
/// to the backup
pub(crate) async fn delete_backup_version_route(
body: Ruma<delete_backup_version::v3::Request>,
) -> Result<delete_backup_version::v3::Response> {
) -> Result<RumaResponse<delete_backup_version::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
services().key_backups.delete_backup(sender_user, &body.version)?;
Ok(delete_backup_version::v3::Response {})
Ok(RumaResponse(delete_backup_version::v3::Response {}))
}
/// # `PUT /_matrix/client/r0/room_keys/keys`
@ -124,7 +124,7 @@ pub(crate) async fn delete_backup_version_route(
/// - Returns the new number of keys in this backup and the etag
pub(crate) async fn add_backup_keys_route(
body: Ruma<add_backup_keys::v3::Request>,
) -> Result<add_backup_keys::v3::Response> {
) -> Result<RumaResponse<add_backup_keys::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
if Some(&body.version)
@ -152,14 +152,14 @@ pub(crate) async fn add_backup_keys_route(
}
}
Ok(add_backup_keys::v3::Response {
Ok(RumaResponse(add_backup_keys::v3::Response {
count: services()
.key_backups
.count_keys(sender_user, &body.version)?
.try_into()
.expect("count should fit in UInt"),
etag: services().key_backups.get_etag(sender_user, &body.version)?,
})
}))
}
/// # `PUT /_matrix/client/r0/room_keys/keys/{roomId}`
@ -172,7 +172,7 @@ pub(crate) async fn add_backup_keys_route(
/// - Returns the new number of keys in this backup and the etag
pub(crate) async fn add_backup_keys_for_room_route(
body: Ruma<add_backup_keys_for_room::v3::Request>,
) -> Result<add_backup_keys_for_room::v3::Response> {
) -> Result<RumaResponse<add_backup_keys_for_room::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
if Some(&body.version)
@ -198,14 +198,14 @@ pub(crate) async fn add_backup_keys_for_room_route(
)?;
}
Ok(add_backup_keys_for_room::v3::Response {
Ok(RumaResponse(add_backup_keys_for_room::v3::Response {
count: services()
.key_backups
.count_keys(sender_user, &body.version)?
.try_into()
.expect("count should fit in UInt"),
etag: services().key_backups.get_etag(sender_user, &body.version)?,
})
}))
}
/// # `PUT /_matrix/client/r0/room_keys/keys/{roomId}/{sessionId}`
@ -218,7 +218,7 @@ pub(crate) async fn add_backup_keys_for_room_route(
/// - Returns the new number of keys in this backup and the etag
pub(crate) async fn add_backup_keys_for_session_route(
body: Ruma<add_backup_keys_for_session::v3::Request>,
) -> Result<add_backup_keys_for_session::v3::Response> {
) -> Result<RumaResponse<add_backup_keys_for_session::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
if Some(&body.version)
@ -242,14 +242,14 @@ pub(crate) async fn add_backup_keys_for_session_route(
&body.session_data,
)?;
Ok(add_backup_keys_for_session::v3::Response {
Ok(RumaResponse(add_backup_keys_for_session::v3::Response {
count: services()
.key_backups
.count_keys(sender_user, &body.version)?
.try_into()
.expect("count should fit in UInt"),
etag: services().key_backups.get_etag(sender_user, &body.version)?,
})
}))
}
/// # `GET /_matrix/client/r0/room_keys/keys`
@ -257,14 +257,14 @@ pub(crate) async fn add_backup_keys_for_session_route(
/// Retrieves all keys from the backup.
pub(crate) async fn get_backup_keys_route(
body: Ruma<get_backup_keys::v3::Request>,
) -> Result<get_backup_keys::v3::Response> {
) -> Result<RumaResponse<get_backup_keys::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let rooms = services().key_backups.get_all(sender_user, &body.version)?;
Ok(get_backup_keys::v3::Response {
Ok(RumaResponse(get_backup_keys::v3::Response {
rooms,
})
}))
}
/// # `GET /_matrix/client/r0/room_keys/keys/{roomId}`
@ -272,7 +272,7 @@ pub(crate) async fn get_backup_keys_route(
/// Retrieves all keys from the backup for a given room.
pub(crate) async fn get_backup_keys_for_room_route(
body: Ruma<get_backup_keys_for_room::v3::Request>,
) -> Result<get_backup_keys_for_room::v3::Response> {
) -> Result<RumaResponse<get_backup_keys_for_room::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let sessions = services().key_backups.get_room(
@ -281,9 +281,9 @@ pub(crate) async fn get_backup_keys_for_room_route(
&body.room_id,
)?;
Ok(get_backup_keys_for_room::v3::Response {
Ok(RumaResponse(get_backup_keys_for_room::v3::Response {
sessions,
})
}))
}
/// # `GET /_matrix/client/r0/room_keys/keys/{roomId}/{sessionId}`
@ -291,7 +291,7 @@ pub(crate) async fn get_backup_keys_for_room_route(
/// Retrieves a key from the backup.
pub(crate) async fn get_backup_keys_for_session_route(
body: Ruma<get_backup_keys_for_session::v3::Request>,
) -> Result<get_backup_keys_for_session::v3::Response> {
) -> Result<RumaResponse<get_backup_keys_for_session::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let key_data = services()
@ -307,9 +307,9 @@ pub(crate) async fn get_backup_keys_for_session_route(
"Backup key not found for this user's session.",
))?;
Ok(get_backup_keys_for_session::v3::Response {
Ok(RumaResponse(get_backup_keys_for_session::v3::Response {
key_data,
})
}))
}
/// # `DELETE /_matrix/client/r0/room_keys/keys`
@ -317,19 +317,19 @@ pub(crate) async fn get_backup_keys_for_session_route(
/// Delete the keys from the backup.
pub(crate) async fn delete_backup_keys_route(
body: Ruma<delete_backup_keys::v3::Request>,
) -> Result<delete_backup_keys::v3::Response> {
) -> Result<RumaResponse<delete_backup_keys::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
services().key_backups.delete_all_keys(sender_user, &body.version)?;
Ok(delete_backup_keys::v3::Response {
Ok(RumaResponse(delete_backup_keys::v3::Response {
count: services()
.key_backups
.count_keys(sender_user, &body.version)?
.try_into()
.expect("count should fit in UInt"),
etag: services().key_backups.get_etag(sender_user, &body.version)?,
})
}))
}
/// # `DELETE /_matrix/client/r0/room_keys/keys/{roomId}`
@ -337,7 +337,7 @@ pub(crate) async fn delete_backup_keys_route(
/// Delete the keys from the backup for a given room.
pub(crate) async fn delete_backup_keys_for_room_route(
body: Ruma<delete_backup_keys_for_room::v3::Request>,
) -> Result<delete_backup_keys_for_room::v3::Response> {
) -> Result<RumaResponse<delete_backup_keys_for_room::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
services().key_backups.delete_room_keys(
@ -346,14 +346,14 @@ pub(crate) async fn delete_backup_keys_for_room_route(
&body.room_id,
)?;
Ok(delete_backup_keys_for_room::v3::Response {
Ok(RumaResponse(delete_backup_keys_for_room::v3::Response {
count: services()
.key_backups
.count_keys(sender_user, &body.version)?
.try_into()
.expect("count should fit in UInt"),
etag: services().key_backups.get_etag(sender_user, &body.version)?,
})
}))
}
/// # `DELETE /_matrix/client/r0/room_keys/keys/{roomId}/{sessionId}`
@ -361,7 +361,7 @@ pub(crate) async fn delete_backup_keys_for_room_route(
/// Delete a key from the backup.
pub(crate) async fn delete_backup_keys_for_session_route(
body: Ruma<delete_backup_keys_for_session::v3::Request>,
) -> Result<delete_backup_keys_for_session::v3::Response> {
) -> Result<RumaResponse<delete_backup_keys_for_session::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
services().key_backups.delete_room_key(
@ -371,12 +371,12 @@ pub(crate) async fn delete_backup_keys_for_session_route(
&body.session_id,
)?;
Ok(delete_backup_keys_for_session::v3::Response {
Ok(RumaResponse(delete_backup_keys_for_session::v3::Response {
count: services()
.key_backups
.count_keys(sender_user, &body.version)?
.try_into()
.expect("count should fit in UInt"),
etag: services().key_backups.get_etag(sender_user, &body.version)?,
})
}))
}

8
src/api/client_server/capabilities.rs
View file

@ -4,7 +4,7 @@ use ruma::api::client::discovery::get_capabilities::{
self, Capabilities, RoomVersionStability, RoomVersionsCapability,
};
use crate::{services, Result, Ruma};
use crate::{services, Result, Ruma, RumaResponse};
/// # `GET /_matrix/client/r0/capabilities`
///
@ -12,7 +12,7 @@ use crate::{services, Result, Ruma};
/// of this server.
pub(crate) async fn get_capabilities_route(
_body: Ruma<get_capabilities::v3::Request>,
) -> Result<get_capabilities::v3::Response> {
) -> Result<RumaResponse<get_capabilities::v3::Response>> {
let mut available = BTreeMap::new();
for room_version in &services().globals.unstable_room_versions {
available.insert(room_version.clone(), RoomVersionStability::Unstable);
@ -27,7 +27,7 @@ pub(crate) async fn get_capabilities_route(
available,
};
Ok(get_capabilities::v3::Response {
Ok(RumaResponse(get_capabilities::v3::Response {
capabilities,
})
}))
}

22
src/api/client_server/config.rs
View file

@ -14,14 +14,14 @@ use ruma::{
use serde::Deserialize;
use serde_json::{json, value::RawValue as RawJsonValue};
use crate::{services, Error, Result, Ruma};
use crate::{services, Error, Result, Ruma, RumaResponse};
/// # `PUT /_matrix/client/r0/user/{userId}/account_data/{type}`
///
/// Sets some account data for the sender user.
pub(crate) async fn set_global_account_data_route(
body: Ruma<set_global_account_data::v3::Request>,
) -> Result<set_global_account_data::v3::Response> {
) -> Result<RumaResponse<set_global_account_data::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let data: serde_json::Value = serde_json::from_str(body.data.json().get())
@ -41,7 +41,7 @@ pub(crate) async fn set_global_account_data_route(
}),
)?;
Ok(set_global_account_data::v3::Response {})
Ok(RumaResponse(set_global_account_data::v3::Response {}))
}
/// # `PUT /_matrix/client/r0/user/{userId}/rooms/{roomId}/account_data/{type}`
@ -49,7 +49,7 @@ pub(crate) async fn set_global_account_data_route(
/// Sets some room account data for the sender user.
pub(crate) async fn set_room_account_data_route(
body: Ruma<set_room_account_data::v3::Request>,
) -> Result<set_room_account_data::v3::Response> {
) -> Result<RumaResponse<set_room_account_data::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let data: serde_json::Value = serde_json::from_str(body.data.json().get())
@ -69,7 +69,7 @@ pub(crate) async fn set_room_account_data_route(
}),
)?;
Ok(set_room_account_data::v3::Response {})
Ok(RumaResponse(set_room_account_data::v3::Response {}))
}
/// # `GET /_matrix/client/r0/user/{userId}/account_data/{type}`
@ -77,7 +77,7 @@ pub(crate) async fn set_room_account_data_route(
/// Gets some account data for the sender user.
pub(crate) async fn get_global_account_data_route(
body: Ruma<get_global_account_data::v3::Request>,
) -> Result<get_global_account_data::v3::Response> {
) -> Result<RumaResponse<get_global_account_data::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let event: Box<RawJsonValue> = services()
@ -92,9 +92,9 @@ pub(crate) async fn get_global_account_data_route(
})?
.content;
Ok(get_global_account_data::v3::Response {
Ok(RumaResponse(get_global_account_data::v3::Response {
account_data,
})
}))
}
/// # `GET /_matrix/client/r0/user/{userId}/rooms/{roomId}/account_data/{type}`
@ -102,7 +102,7 @@ pub(crate) async fn get_global_account_data_route(
/// Gets some room account data for the sender user.
pub(crate) async fn get_room_account_data_route(
body: Ruma<get_room_account_data::v3::Request>,
) -> Result<get_room_account_data::v3::Response> {
) -> Result<RumaResponse<get_room_account_data::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let event: Box<RawJsonValue> = services()
@ -117,9 +117,9 @@ pub(crate) async fn get_room_account_data_route(
})?
.content;
Ok(get_room_account_data::v3::Response {
Ok(RumaResponse(get_room_account_data::v3::Response {
account_data,
})
}))
}
#[derive(Deserialize)]

6
src/api/client_server/context.rs
View file

@ -9,7 +9,7 @@ use ruma::{
};
use tracing::error;
use crate::{services, Error, Result, Ruma};
use crate::{services, Error, Result, Ruma, RumaResponse};
/// # `GET /_matrix/client/r0/rooms/{roomId}/context`
///
@ -21,7 +21,7 @@ use crate::{services, Error, Result, Ruma};
#[allow(clippy::too_many_lines)]
pub(crate) async fn get_context_route(
body: Ruma<get_context::v3::Request>,
) -> Result<get_context::v3::Response> {
) -> Result<RumaResponse<get_context::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let sender_device =
body.sender_device.as_ref().expect("user is authenticated");
@ -187,5 +187,5 @@ pub(crate) async fn get_context_route(
state,
};
Ok(resp)
Ok(RumaResponse(resp))
}

26
src/api/client_server/device.rs
View file

@ -8,14 +8,14 @@ use ruma::api::client::{
};
use super::SESSION_ID_LENGTH;
use crate::{services, utils, Error, Result, Ruma};
use crate::{services, utils, Error, Result, Ruma, RumaResponse};
/// # `GET /_matrix/client/r0/devices`
///
/// Get metadata on all devices of the sender user.
pub(crate) async fn get_devices_route(
body: Ruma<get_devices::v3::Request>,
) -> Result<get_devices::v3::Response> {
) -> Result<RumaResponse<get_devices::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let devices: Vec<device::Device> = services()
@ -24,9 +24,9 @@ pub(crate) async fn get_devices_route(
.filter_map(Result::ok)
.collect();
Ok(get_devices::v3::Response {
Ok(RumaResponse(get_devices::v3::Response {
devices,
})
}))
}
/// # `GET /_matrix/client/r0/devices/{deviceId}`
@ -34,7 +34,7 @@ pub(crate) async fn get_devices_route(
/// Get metadata on a single device of the sender user.
pub(crate) async fn get_device_route(
body: Ruma<get_device::v3::Request>,
) -> Result<get_device::v3::Response> {
) -> Result<RumaResponse<get_device::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let device = services()
@ -42,9 +42,9 @@ pub(crate) async fn get_device_route(
.get_device_metadata(sender_user, &body.body.device_id)?
.ok_or(Error::BadRequest(ErrorKind::NotFound, "Device not found."))?;
Ok(get_device::v3::Response {
Ok(RumaResponse(get_device::v3::Response {
device,
})
}))
}
/// # `PUT /_matrix/client/r0/devices/{deviceId}`
@ -52,7 +52,7 @@ pub(crate) async fn get_device_route(
/// Updates the metadata on a given device of the sender user.
pub(crate) async fn update_device_route(
body: Ruma<update_device::v3::Request>,
) -> Result<update_device::v3::Response> {
) -> Result<RumaResponse<update_device::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let mut device = services()
@ -68,7 +68,7 @@ pub(crate) async fn update_device_route(
&device,
)?;
Ok(update_device::v3::Response {})
Ok(RumaResponse(update_device::v3::Response {}))
}
/// # `DELETE /_matrix/client/r0/devices/{deviceId}`
@ -83,7 +83,7 @@ pub(crate) async fn update_device_route(
/// - Triggers device list updates
pub(crate) async fn delete_device_route(
body: Ruma<delete_device::v3::Request>,
) -> Result<delete_device::v3::Response> {
) -> Result<RumaResponse<delete_device::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let sender_device =
body.sender_device.as_ref().expect("user is authenticated");
@ -120,7 +120,7 @@ pub(crate) async fn delete_device_route(
services().users.remove_device(sender_user, &body.device_id)?;
Ok(delete_device::v3::Response {})
Ok(RumaResponse(delete_device::v3::Response {}))
}
/// # `PUT /_matrix/client/r0/devices/{deviceId}`
@ -137,7 +137,7 @@ pub(crate) async fn delete_device_route(
/// - Triggers device list updates
pub(crate) async fn delete_devices_route(
body: Ruma<delete_devices::v3::Request>,
) -> Result<delete_devices::v3::Response> {
) -> Result<RumaResponse<delete_devices::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let sender_device =
body.sender_device.as_ref().expect("user is authenticated");
@ -176,5 +176,5 @@ pub(crate) async fn delete_devices_route(
services().users.remove_device(sender_user, device_id)?;
}
Ok(delete_devices::v3::Response {})
Ok(RumaResponse(delete_devices::v3::Response {}))
}

21
src/api/client_server/directory.rs
View file

@ -29,7 +29,7 @@ use ruma::{
};
use tracing::{error, info, warn};
use crate::{services, Error, Result, Ruma};
use crate::{services, Error, Result, Ruma, RumaResponse};
/// # `POST /_matrix/client/r0/publicRooms`
///
@ -38,7 +38,7 @@ use crate::{services, Error, Result, Ruma};
/// - Rooms are ordered by the number of joined members
pub(crate) async fn get_public_rooms_filtered_route(
body: Ruma<get_public_rooms_filtered::v3::Request>,
) -> Result<get_public_rooms_filtered::v3::Response> {
) -> Result<RumaResponse<get_public_rooms_filtered::v3::Response>> {
get_public_rooms_filtered_helper(
body.server.as_deref(),
body.limit,
@ -47,6 +47,7 @@ pub(crate) async fn get_public_rooms_filtered_route(
&body.room_network,
)
.await
.map(RumaResponse)
}
/// # `GET /_matrix/client/r0/publicRooms`
@ -56,7 +57,7 @@ pub(crate) async fn get_public_rooms_filtered_route(
/// - Rooms are ordered by the number of joined members
pub(crate) async fn get_public_rooms_route(
body: Ruma<get_public_rooms::v3::Request>,
) -> Result<get_public_rooms::v3::Response> {
) -> Result<RumaResponse<get_public_rooms::v3::Response>> {
let response = get_public_rooms_filtered_helper(
body.server.as_deref(),
body.limit,
@ -66,12 +67,12 @@ pub(crate) async fn get_public_rooms_route(
)
.await?;
Ok(get_public_rooms::v3::Response {
Ok(RumaResponse(get_public_rooms::v3::Response {
chunk: response.chunk,
prev_batch: response.prev_batch,
next_batch: response.next_batch,
total_room_count_estimate: response.total_room_count_estimate,
})
}))
}
/// # `PUT /_matrix/client/r0/directory/list/room/{roomId}`
@ -81,7 +82,7 @@ pub(crate) async fn get_public_rooms_route(
/// - TODO: Access control checks
pub(crate) async fn set_room_visibility_route(
body: Ruma<set_room_visibility::v3::Request>,
) -> Result<set_room_visibility::v3::Response> {
) -> Result<RumaResponse<set_room_visibility::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
if !services().rooms.metadata.exists(&body.room_id)? {
@ -105,7 +106,7 @@ pub(crate) async fn set_room_visibility_route(
}
}
Ok(set_room_visibility::v3::Response {})
Ok(RumaResponse(set_room_visibility::v3::Response {}))
}
/// # `GET /_matrix/client/r0/directory/list/room/{roomId}`
@ -113,13 +114,13 @@ pub(crate) async fn set_room_visibility_route(
/// Gets the visibility of a given room in the room directory.
pub(crate) async fn get_room_visibility_route(
body: Ruma<get_room_visibility::v3::Request>,
) -> Result<get_room_visibility::v3::Response> {
) -> Result<RumaResponse<get_room_visibility::v3::Response>> {
if !services().rooms.metadata.exists(&body.room_id)? {
// Return 404 if the room doesn't exist
return Err(Error::BadRequest(ErrorKind::NotFound, "Room not found"));
}
Ok(get_room_visibility::v3::Response {
Ok(RumaResponse(get_room_visibility::v3::Response {
visibility: if services()
.rooms
.directory
@ -129,7 +130,7 @@ pub(crate) async fn get_room_visibility_route(
} else {
room::Visibility::Private
},
})
}))
}
#[allow(clippy::too_many_lines)]

12
src/api/client_server/filter.rs
View file

@ -3,7 +3,7 @@ use ruma::api::client::{
filter::{create_filter, get_filter},
};
use crate::{services, Error, Result, Ruma};
use crate::{services, Error, Result, Ruma, RumaResponse};
/// # `GET /_matrix/client/r0/user/{userId}/filter/{filterId}`
///
@ -12,7 +12,7 @@ use crate::{services, Error, Result, Ruma};
/// - A user can only access their own filters
pub(crate) async fn get_filter_route(
body: Ruma<get_filter::v3::Request>,
) -> Result<get_filter::v3::Response> {
) -> Result<RumaResponse<get_filter::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let Some(filter) =
services().users.get_filter(sender_user, &body.filter_id)?
@ -23,7 +23,7 @@ pub(crate) async fn get_filter_route(
));
};
Ok(get_filter::v3::Response::new(filter))
Ok(RumaResponse(get_filter::v3::Response::new(filter)))
}
/// # `PUT /_matrix/client/r0/user/{userId}/filter`
@ -31,9 +31,9 @@ pub(crate) async fn get_filter_route(
/// Creates a new filter to be used by other endpoints.
pub(crate) async fn create_filter_route(
body: Ruma<create_filter::v3::Request>,
) -> Result<create_filter::v3::Response> {
) -> Result<RumaResponse<create_filter::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
Ok(create_filter::v3::Response::new(
Ok(RumaResponse(create_filter::v3::Response::new(
services().users.create_filter(sender_user, &body.filter)?,
))
)))
}

32
src/api/client_server/keys.rs
View file

@ -23,7 +23,7 @@ use serde_json::json;
use tracing::debug;
use super::SESSION_ID_LENGTH;
use crate::{services, utils, Error, Result, Ruma};
use crate::{services, utils, Error, Result, Ruma, RumaResponse};
/// # `POST /_matrix/client/r0/keys/upload`
///
@ -34,7 +34,7 @@ use crate::{services, utils, Error, Result, Ruma};
/// existing keys?)
pub(crate) async fn upload_keys_route(
body: Ruma<upload_keys::v3::Request>,
) -> Result<upload_keys::v3::Response> {
) -> Result<RumaResponse<upload_keys::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let sender_device =
body.sender_device.as_ref().expect("user is authenticated");
@ -64,11 +64,11 @@ pub(crate) async fn upload_keys_route(
}
}
Ok(upload_keys::v3::Response {
Ok(RumaResponse(upload_keys::v3::Response {
one_time_key_counts: services()
.users
.count_one_time_keys(sender_user, sender_device)?,
})
}))
}
/// # `POST /_matrix/client/r0/keys/query`
@ -81,7 +81,7 @@ pub(crate) async fn upload_keys_route(
/// allowed to see
pub(crate) async fn get_keys_route(
body: Ruma<get_keys::v3::Request>,
) -> Result<get_keys::v3::Response> {
) -> Result<RumaResponse<get_keys::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let response = get_keys_helper(Some(sender_user), &body.device_keys, |u| {
@ -89,7 +89,7 @@ pub(crate) async fn get_keys_route(
})
.await?;
Ok(response)
Ok(RumaResponse(response))
}
/// # `POST /_matrix/client/r0/keys/claim`
@ -97,10 +97,10 @@ pub(crate) async fn get_keys_route(
/// Claims one-time keys
pub(crate) async fn claim_keys_route(
body: Ruma<claim_keys::v3::Request>,
) -> Result<claim_keys::v3::Response> {
) -> Result<RumaResponse<claim_keys::v3::Response>> {
let response = claim_keys_helper(&body.one_time_keys).await?;
Ok(response)
Ok(RumaResponse(response))
}
/// # `POST /_matrix/client/r0/keys/device_signing/upload`
@ -110,7 +110,7 @@ pub(crate) async fn claim_keys_route(
/// - Requires UIAA to verify password
pub(crate) async fn upload_signing_keys_route(
body: Ruma<upload_signing_keys::v3::Request>,
) -> Result<upload_signing_keys::v3::Response> {
) -> Result<RumaResponse<upload_signing_keys::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let sender_device =
body.sender_device.as_ref().expect("user is authenticated");
@ -156,7 +156,7 @@ pub(crate) async fn upload_signing_keys_route(
)?;
}
Ok(upload_signing_keys::v3::Response {})
Ok(RumaResponse(upload_signing_keys::v3::Response {}))
}
/// # `POST /_matrix/client/r0/keys/signatures/upload`
@ -164,7 +164,7 @@ pub(crate) async fn upload_signing_keys_route(
/// Uploads end-to-end key signatures from the sender user.
pub(crate) async fn upload_signatures_route(
body: Ruma<upload_signatures::v3::Request>,
) -> Result<upload_signatures::v3::Response> {
) -> Result<RumaResponse<upload_signatures::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
for (user_id, keys) in &body.signed_keys {
@ -213,10 +213,10 @@ pub(crate) async fn upload_signatures_route(
}
}
Ok(upload_signatures::v3::Response {
Ok(RumaResponse(upload_signatures::v3::Response {
// TODO: integrate
failures: BTreeMap::new(),
})
}))
}
/// # `POST /_matrix/client/r0/keys/changes`
@ -227,7 +227,7 @@ pub(crate) async fn upload_signatures_route(
/// - TODO: left users
pub(crate) async fn get_key_changes_route(
body: Ruma<get_key_changes::v3::Request>,
) -> Result<get_key_changes::v3::Response> {
) -> Result<RumaResponse<get_key_changes::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let mut device_list_updates = HashSet::new();
@ -277,11 +277,11 @@ pub(crate) async fn get_key_changes_route(
.filter_map(Result::ok),
);
}
Ok(get_key_changes::v3::Response {
Ok(RumaResponse(get_key_changes::v3::Response {
changed: device_list_updates.into_iter().collect(),
// TODO
left: Vec::new(),
})
}))
}
#[allow(clippy::too_many_lines)]

43
src/api/client_server/media.rs
View file

@ -8,7 +8,10 @@ use ruma::api::client::{
},
};
use crate::{service::media::FileMeta, services, utils, Error, Result, Ruma};
use crate::{
service::media::FileMeta, services, utils, Error, Result, Ruma,
RumaResponse,
};
const MXC_LENGTH: usize = 32;
@ -17,10 +20,10 @@ const MXC_LENGTH: usize = 32;
/// Returns max upload size.
pub(crate) async fn get_media_config_route(
_body: Ruma<get_media_config::v3::Request>,
) -> Result<get_media_config::v3::Response> {
Ok(get_media_config::v3::Response {
) -> Result<RumaResponse<get_media_config::v3::Response>> {
Ok(RumaResponse(get_media_config::v3::Response {
upload_size: services().globals.max_request_size().into(),
})
}))
}
/// # `POST /_matrix/media/r0/upload`
@ -31,7 +34,7 @@ pub(crate) async fn get_media_config_route(
/// - Media will be saved in the media/ directory
pub(crate) async fn create_content_route(
body: Ruma<create_content::v3::Request>,
) -> Result<create_content::v3::Response> {
) -> Result<RumaResponse<create_content::v3::Response>> {
let mxc = format!(
"mxc://{}/{}",
services().globals.server_name(),
@ -51,10 +54,10 @@ pub(crate) async fn create_content_route(
)
.await?;
Ok(create_content::v3::Response {
Ok(RumaResponse(create_content::v3::Response {
content_uri: mxc.into(),
blurhash: None,
})
}))
}
pub(crate) async fn get_remote_content(
@ -96,7 +99,7 @@ pub(crate) async fn get_remote_content(
/// - Only allows federation if `allow_remote` is true
pub(crate) async fn get_content_route(
body: Ruma<get_content::v3::Request>,
) -> Result<get_content::v3::Response> {
) -> Result<RumaResponse<get_content::v3::Response>> {
let mxc = format!("mxc://{}/{}", body.server_name, body.media_id);
if let Some(FileMeta {
@ -105,19 +108,19 @@ pub(crate) async fn get_content_route(
file,
}) = services().media.get(mxc.clone()).await?
{
Ok(get_content::v3::Response {
Ok(RumaResponse(get_content::v3::Response {
file,
content_type,
content_disposition,
cross_origin_resource_policy: Some("cross-origin".to_owned()),
})
}))
} else if &*body.server_name != services().globals.server_name()
&& body.allow_remote
{
let remote_content_response =
get_remote_content(&mxc, &body.server_name, body.media_id.clone())
.await?;
Ok(remote_content_response)
Ok(RumaResponse(remote_content_response))
} else {
Err(Error::BadRequest(ErrorKind::NotFound, "Media not found."))
}
@ -130,7 +133,7 @@ pub(crate) async fn get_content_route(
/// - Only allows federation if `allow_remote` is true
pub(crate) async fn get_content_as_filename_route(
body: Ruma<get_content_as_filename::v3::Request>,
) -> Result<get_content_as_filename::v3::Response> {
) -> Result<RumaResponse<get_content_as_filename::v3::Response>> {
let mxc = format!("mxc://{}/{}", body.server_name, body.media_id);
if let Some(FileMeta {
@ -139,7 +142,7 @@ pub(crate) async fn get_content_as_filename_route(
..
}) = services().media.get(mxc.clone()).await?
{
Ok(get_content_as_filename::v3::Response {
Ok(RumaResponse(get_content_as_filename::v3::Response {
file,
content_type,
content_disposition: Some(format!(
@ -147,7 +150,7 @@ pub(crate) async fn get_content_as_filename_route(
body.filename
)),
cross_origin_resource_policy: Some("cross-origin".to_owned()),
})
}))
} else if &*body.server_name != services().globals.server_name()
&& body.allow_remote
{
@ -155,7 +158,7 @@ pub(crate) async fn get_content_as_filename_route(
get_remote_content(&mxc, &body.server_name, body.media_id.clone())
.await?;
Ok(get_content_as_filename::v3::Response {
Ok(RumaResponse(get_content_as_filename::v3::Response {
content_disposition: Some(format!(
"inline: filename={}",
body.filename
@ -163,7 +166,7 @@ pub(crate) async fn get_content_as_filename_route(
content_type: remote_content_response.content_type,
file: remote_content_response.file,
cross_origin_resource_policy: Some("cross-origin".to_owned()),
})
}))
} else {
Err(Error::BadRequest(ErrorKind::NotFound, "Media not found."))
}
@ -176,7 +179,7 @@ pub(crate) async fn get_content_as_filename_route(
/// - Only allows federation if `allow_remote` is true
pub(crate) async fn get_content_thumbnail_route(
body: Ruma<get_content_thumbnail::v3::Request>,
) -> Result<get_content_thumbnail::v3::Response> {
) -> Result<RumaResponse<get_content_thumbnail::v3::Response>> {
let mxc = format!("mxc://{}/{}", body.server_name, body.media_id);
if let Some(FileMeta {
@ -196,11 +199,11 @@ pub(crate) async fn get_content_thumbnail_route(
)
.await?
{
Ok(get_content_thumbnail::v3::Response {
Ok(RumaResponse(get_content_thumbnail::v3::Response {
file,
content_type,
cross_origin_resource_policy: Some("cross-origin".to_owned()),
})
}))
} else if &*body.server_name != services().globals.server_name()
&& body.allow_remote
{
@ -233,7 +236,7 @@ pub(crate) async fn get_content_thumbnail_route(
)
.await?;
Ok(get_thumbnail_response)
Ok(RumaResponse(get_thumbnail_response))
} else {
Err(Error::BadRequest(ErrorKind::NotFound, "Media not found."))
}

59
src/api/client_server/membership.rs
View file

@ -36,7 +36,7 @@ use tracing::{debug, error, info, warn};
use super::get_alias_helper;
use crate::{
service::pdu::{gen_event_id_canonical_json, PduBuilder},
services, utils, Error, PduEvent, Result, Ruma,
services, utils, Error, PduEvent, Result, Ruma, RumaResponse,
};
/// # `POST /_matrix/client/r0/rooms/{roomId}/join`
@ -49,7 +49,7 @@ use crate::{
/// federation
pub(crate) async fn join_room_by_id_route(
body: Ruma<join_room_by_id::v3::Request>,
) -> Result<join_room_by_id::v3::Response> {
) -> Result<RumaResponse<join_room_by_id::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
// There is no body.server_name for /roomId/join
@ -83,6 +83,7 @@ pub(crate) async fn join_room_by_id_route(
body.third_party_signed.as_ref(),
)
.await
.map(RumaResponse)
}
/// # `POST /_matrix/client/r0/join/{roomIdOrAlias}`
@ -95,7 +96,7 @@ pub(crate) async fn join_room_by_id_route(
/// federation
pub(crate) async fn join_room_by_id_or_alias_route(
body: Ruma<join_room_by_id_or_alias::v3::Request>,
) -> Result<join_room_by_id_or_alias::v3::Response> {
) -> Result<RumaResponse<join_room_by_id_or_alias::v3::Response>> {
let sender_user =
body.sender_user.as_deref().expect("user is authenticated");
let body = body.body;
@ -147,9 +148,9 @@ pub(crate) async fn join_room_by_id_or_alias_route(
)
.await?;
Ok(join_room_by_id_or_alias::v3::Response {
Ok(RumaResponse(join_room_by_id_or_alias::v3::Response {
room_id: join_room_response.room_id,
})
}))
}
/// # `POST /_matrix/client/r0/rooms/{roomId}/leave`
@ -159,12 +160,12 @@ pub(crate) async fn join_room_by_id_or_alias_route(
/// - This should always work if the user is currently joined.
pub(crate) async fn leave_room_route(
body: Ruma<leave_room::v3::Request>,
) -> Result<leave_room::v3::Response> {
) -> Result<RumaResponse<leave_room::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
leave_room(sender_user, &body.room_id, body.reason.clone()).await?;
Ok(leave_room::v3::Response::new())
Ok(RumaResponse(leave_room::v3::Response::new()))
}
/// # `POST /_matrix/client/r0/rooms/{roomId}/invite`
@ -172,7 +173,7 @@ pub(crate) async fn leave_room_route(
/// Tries to send an invite event into the room.
pub(crate) async fn invite_user_route(
body: Ruma<invite_user::v3::Request>,
) -> Result<invite_user::v3::Response> {
) -> Result<RumaResponse<invite_user::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
if let invite_user::v3::InvitationRecipient::UserId {
@ -187,7 +188,7 @@ pub(crate) async fn invite_user_route(
false,
)
.await?;
Ok(invite_user::v3::Response {})
Ok(RumaResponse(invite_user::v3::Response {}))
} else {
Err(Error::BadRequest(ErrorKind::NotFound, "User not found."))
}
@ -198,13 +199,13 @@ pub(crate) async fn invite_user_route(
/// Tries to send a kick event into the room.
pub(crate) async fn kick_user_route(
body: Ruma<kick_user::v3::Request>,
) -> Result<kick_user::v3::Response> {
) -> Result<RumaResponse<kick_user::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
if let Ok(true) =
services().rooms.state_cache.is_left(sender_user, &body.room_id)
{
return Ok(kick_user::v3::Response {});
return Ok(RumaResponse(kick_user::v3::Response {}));
}
let mut event: RoomMemberEventContent = serde_json::from_str(
@ -259,7 +260,7 @@ pub(crate) async fn kick_user_route(
drop(state_lock);
Ok(kick_user::v3::Response::new())
Ok(RumaResponse(kick_user::v3::Response::new()))
}
/// # `POST /_matrix/client/r0/rooms/{roomId}/ban`
@ -267,14 +268,14 @@ pub(crate) async fn kick_user_route(
/// Tries to send a ban event into the room.
pub(crate) async fn ban_user_route(
body: Ruma<ban_user::v3::Request>,
) -> Result<ban_user::v3::Response> {
) -> Result<RumaResponse<ban_user::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
if let Ok(Some(membership_event)) =
services().rooms.state_accessor.get_member(&body.room_id, sender_user)
{
if membership_event.membership == MembershipState::Ban {
return Ok(ban_user::v3::Response {});
return Ok(RumaResponse(ban_user::v3::Response {}));
}
}
@ -343,7 +344,7 @@ pub(crate) async fn ban_user_route(
drop(state_lock);
Ok(ban_user::v3::Response::new())
Ok(RumaResponse(ban_user::v3::Response::new()))
}
/// # `POST /_matrix/client/r0/rooms/{roomId}/unban`
@ -351,14 +352,14 @@ pub(crate) async fn ban_user_route(
/// Tries to send an unban event into the room.
pub(crate) async fn unban_user_route(
body: Ruma<unban_user::v3::Request>,
) -> Result<unban_user::v3::Response> {
) -> Result<RumaResponse<unban_user::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
if let Ok(Some(membership_event)) =
services().rooms.state_accessor.get_member(&body.room_id, sender_user)
{
if membership_event.membership != MembershipState::Ban {
return Ok(unban_user::v3::Response {});
return Ok(RumaResponse(unban_user::v3::Response {}));
}
}
@ -414,7 +415,7 @@ pub(crate) async fn unban_user_route(
drop(state_lock);
Ok(unban_user::v3::Response::new())
Ok(RumaResponse(unban_user::v3::Response::new()))
}
/// # `POST /_matrix/client/r0/rooms/{roomId}/forget`
@ -428,12 +429,12 @@ pub(crate) async fn unban_user_route(
/// forgotten, so this has to be called from every device
pub(crate) async fn forget_room_route(
body: Ruma<forget_room::v3::Request>,
) -> Result<forget_room::v3::Response> {
) -> Result<RumaResponse<forget_room::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
services().rooms.state_cache.forget(&body.room_id, sender_user)?;
Ok(forget_room::v3::Response::new())
Ok(RumaResponse(forget_room::v3::Response::new()))
}
/// # `POST /_matrix/client/r0/joined_rooms`
@ -441,17 +442,17 @@ pub(crate) async fn forget_room_route(
/// Lists all rooms the user has joined.
pub(crate) async fn joined_rooms_route(
body: Ruma<joined_rooms::v3::Request>,
) -> Result<joined_rooms::v3::Response> {
) -> Result<RumaResponse<joined_rooms::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
Ok(joined_rooms::v3::Response {
Ok(RumaResponse(joined_rooms::v3::Response {
joined_rooms: services()
.rooms
.state_cache
.rooms_joined(sender_user)
.filter_map(Result::ok)
.collect(),
})
}))
}
/// # `POST /_matrix/client/r0/rooms/{roomId}/members`
@ -462,7 +463,7 @@ pub(crate) async fn joined_rooms_route(
/// - Only works if the user is currently joined
pub(crate) async fn get_member_events_route(
body: Ruma<get_member_events::v3::Request>,
) -> Result<get_member_events::v3::Response> {
) -> Result<RumaResponse<get_member_events::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
if !services()
@ -476,7 +477,7 @@ pub(crate) async fn get_member_events_route(
));
}
Ok(get_member_events::v3::Response {
Ok(RumaResponse(get_member_events::v3::Response {
chunk: services()
.rooms
.state_accessor
@ -486,7 +487,7 @@ pub(crate) async fn get_member_events_route(
.filter(|(key, _)| key.0 == StateEventType::RoomMember)
.map(|(_, pdu)| pdu.to_member_event())
.collect(),
})
}))
}
/// # `POST /_matrix/client/r0/rooms/{roomId}/joined_members`
@ -497,7 +498,7 @@ pub(crate) async fn get_member_events_route(
/// - TODO: An appservice just needs a puppet joined
pub(crate) async fn joined_members_route(
body: Ruma<joined_members::v3::Request>,
) -> Result<joined_members::v3::Response> {
) -> Result<RumaResponse<joined_members::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
if !services()
@ -530,9 +531,9 @@ pub(crate) async fn joined_members_route(
);
}
Ok(joined_members::v3::Response {
Ok(RumaResponse(joined_members::v3::Response {
joined,
})
}))
}
#[allow(clippy::too_many_lines)]

16
src/api/client_server/message.rs
View file

@ -14,7 +14,7 @@ use ruma::{
use crate::{
service::{pdu::PduBuilder, rooms::timeline::PduCount},
services, utils, Error, Result, Ruma,
services, utils, Error, Result, Ruma, RumaResponse,
};
/// # `PUT /_matrix/client/r0/rooms/{roomId}/send/{eventType}/{txnId}`
@ -28,7 +28,7 @@ use crate::{
/// allowed
pub(crate) async fn send_message_event_route(
body: Ruma<send_message_event::v3::Request>,
) -> Result<send_message_event::v3::Response> {
) -> Result<RumaResponse<send_message_event::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let sender_device = body.sender_device.as_deref();
@ -77,9 +77,9 @@ pub(crate) async fn send_message_event_route(
.map_err(|_| {
Error::bad_database("Invalid event id in txnid data.")
})?;
return Ok(send_message_event::v3::Response {
return Ok(RumaResponse(send_message_event::v3::Response {
event_id,
});
}));
}
let mut unsigned = BTreeMap::new();
@ -118,7 +118,9 @@ pub(crate) async fn send_message_event_route(
drop(state_lock);
Ok(send_message_event::v3::Response::new((*event_id).to_owned()))
Ok(RumaResponse(send_message_event::v3::Response::new(
(*event_id).to_owned(),
)))
}
/// # `GET /_matrix/client/r0/rooms/{roomId}/messages`
@ -131,7 +133,7 @@ pub(crate) async fn send_message_event_route(
#[allow(clippy::too_many_lines)]
pub(crate) async fn get_message_events_route(
body: Ruma<get_message_events::v3::Request>,
) -> Result<get_message_events::v3::Response> {
) -> Result<RumaResponse<get_message_events::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let sender_device =
body.sender_device.as_ref().expect("user is authenticated");
@ -308,5 +310,5 @@ pub(crate) async fn get_message_events_route(
}
*/
Ok(resp)
Ok(RumaResponse(resp))
}

42
src/api/client_server/profile.rs
View file

@ -18,7 +18,9 @@ use ruma::{
use serde_json::value::to_raw_value;
use tracing::warn;
use crate::{service::pdu::PduBuilder, services, Error, Result, Ruma};
use crate::{
service::pdu::PduBuilder, services, Error, Result, Ruma, RumaResponse,
};
/// # `PUT /_matrix/client/r0/profile/{userId}/displayname`
///
@ -27,7 +29,7 @@ use crate::{service::pdu::PduBuilder, services, Error, Result, Ruma};
/// - Also makes sure other users receive the update using presence EDUs
pub(crate) async fn set_displayname_route(
body: Ruma<set_display_name::v3::Request>,
) -> Result<set_display_name::v3::Response> {
) -> Result<RumaResponse<set_display_name::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
services().users.set_displayname(sender_user, body.displayname.clone())?;
@ -107,7 +109,7 @@ pub(crate) async fn set_displayname_route(
}
}
Ok(set_display_name::v3::Response {})
Ok(RumaResponse(set_display_name::v3::Response {}))
}
/// # `GET /_matrix/client/r0/profile/{userId}/displayname`
@ -117,7 +119,7 @@ pub(crate) async fn set_displayname_route(
/// - If user is on another server: Fetches displayname over federation
pub(crate) async fn get_displayname_route(
body: Ruma<get_display_name::v3::Request>,
) -> Result<get_display_name::v3::Response> {
) -> Result<RumaResponse<get_display_name::v3::Response>> {
if body.user_id.server_name() != services().globals.server_name() {
let response = services()
.sending
@ -130,14 +132,14 @@ pub(crate) async fn get_displayname_route(
)
.await?;
return Ok(get_display_name::v3::Response {
return Ok(RumaResponse(get_display_name::v3::Response {
displayname: response.displayname,
});
}));
}
Ok(get_display_name::v3::Response {
Ok(RumaResponse(get_display_name::v3::Response {
displayname: services().users.displayname(&body.user_id)?,
})
}))
}
/// # `PUT /_matrix/client/r0/profile/{userId}/avatar_url`
@ -147,7 +149,7 @@ pub(crate) async fn get_displayname_route(
/// - Also makes sure other users receive the update using presence EDUs
pub(crate) async fn set_avatar_url_route(
body: Ruma<set_avatar_url::v3::Request>,
) -> Result<set_avatar_url::v3::Response> {
) -> Result<RumaResponse<set_avatar_url::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
services().users.set_avatar_url(sender_user, body.avatar_url.clone())?;
@ -229,7 +231,7 @@ pub(crate) async fn set_avatar_url_route(
};
}
Ok(set_avatar_url::v3::Response {})
Ok(RumaResponse(set_avatar_url::v3::Response {}))
}
/// # `GET /_matrix/client/r0/profile/{userId}/avatar_url`
@ -240,7 +242,7 @@ pub(crate) async fn set_avatar_url_route(
/// federation
pub(crate) async fn get_avatar_url_route(
body: Ruma<get_avatar_url::v3::Request>,
) -> Result<get_avatar_url::v3::Response> {
) -> Result<RumaResponse<get_avatar_url::v3::Response>> {
if body.user_id.server_name() != services().globals.server_name() {
let response = services()
.sending
@ -253,16 +255,16 @@ pub(crate) async fn get_avatar_url_route(
)
.await?;
return Ok(get_avatar_url::v3::Response {
return Ok(RumaResponse(get_avatar_url::v3::Response {
avatar_url: response.avatar_url,
blurhash: response.blurhash,
});
}));
}
Ok(get_avatar_url::v3::Response {
Ok(RumaResponse(get_avatar_url::v3::Response {
avatar_url: services().users.avatar_url(&body.user_id)?,
blurhash: services().users.blurhash(&body.user_id)?,
})
}))
}
/// # `GET /_matrix/client/r0/profile/{userId}`
@ -272,7 +274,7 @@ pub(crate) async fn get_avatar_url_route(
/// - If user is on another server: Fetches profile over federation
pub(crate) async fn get_profile_route(
body: Ruma<get_profile::v3::Request>,
) -> Result<get_profile::v3::Response> {
) -> Result<RumaResponse<get_profile::v3::Response>> {
if body.user_id.server_name() != services().globals.server_name() {
let response = services()
.sending
@ -285,11 +287,11 @@ pub(crate) async fn get_profile_route(
)
.await?;
return Ok(get_profile::v3::Response {
return Ok(RumaResponse(get_profile::v3::Response {
displayname: response.displayname,
avatar_url: response.avatar_url,
blurhash: response.blurhash,
});
}));
}
if !services().users.exists(&body.user_id)? {
@ -300,9 +302,9 @@ pub(crate) async fn get_profile_route(
));
}
Ok(get_profile::v3::Response {
Ok(RumaResponse(get_profile::v3::Response {
avatar_url: services().users.avatar_url(&body.user_id)?,
blurhash: services().users.blurhash(&body.user_id)?,
displayname: services().users.displayname(&body.user_id)?,
})
}))
}

52
src/api/client_server/push.rs
View file

@ -11,14 +11,14 @@ use ruma::{
push::{AnyPushRuleRef, InsertPushRuleError, RemovePushRuleError},
};
use crate::{services, Error, Result, Ruma};
use crate::{services, Error, Result, Ruma, RumaResponse};
/// # `GET /_matrix/client/r0/pushrules`
///
/// Retrieves the push rules event for this user.
pub(crate) async fn get_pushrules_all_route(
body: Ruma<get_pushrules_all::v3::Request>,
) -> Result<get_pushrules_all::v3::Response> {
) -> Result<RumaResponse<get_pushrules_all::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let event = services()
@ -37,9 +37,9 @@ pub(crate) async fn get_pushrules_all_route(
.map_err(|_| Error::bad_database("Invalid account data event in db."))?
.content;
Ok(get_pushrules_all::v3::Response {
Ok(RumaResponse(get_pushrules_all::v3::Response {
global: account_data.global,
})
}))
}
/// # `GET /_matrix/client/r0/pushrules/{scope}/{kind}/{ruleId}`
@ -47,7 +47,7 @@ pub(crate) async fn get_pushrules_all_route(
/// Retrieves a single specified push rule for this user.
pub(crate) async fn get_pushrule_route(
body: Ruma<get_pushrule::v3::Request>,
) -> Result<get_pushrule::v3::Response> {
) -> Result<RumaResponse<get_pushrule::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let event = services()
@ -72,9 +72,9 @@ pub(crate) async fn get_pushrule_route(
.map(Into::into);
if let Some(rule) = rule {
Ok(get_pushrule::v3::Response {
Ok(RumaResponse(get_pushrule::v3::Response {
rule,
})
}))
} else {
Err(Error::BadRequest(ErrorKind::NotFound, "Push rule not found."))
}
@ -85,7 +85,7 @@ pub(crate) async fn get_pushrule_route(
/// Creates a single specified push rule for this user.
pub(crate) async fn set_pushrule_route(
body: Ruma<set_pushrule::v3::Request>,
) -> Result<set_pushrule::v3::Response> {
) -> Result<RumaResponse<set_pushrule::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let body = body.body;
@ -157,7 +157,7 @@ pub(crate) async fn set_pushrule_route(
.expect("to json value always works"),
)?;
Ok(set_pushrule::v3::Response {})
Ok(RumaResponse(set_pushrule::v3::Response {}))
}
/// # `GET /_matrix/client/r0/pushrules/{scope}/{kind}/{ruleId}/actions`
@ -165,7 +165,7 @@ pub(crate) async fn set_pushrule_route(
/// Gets the actions of a single specified push rule for this user.
pub(crate) async fn get_pushrule_actions_route(
body: Ruma<get_pushrule_actions::v3::Request>,
) -> Result<get_pushrule_actions::v3::Response> {
) -> Result<RumaResponse<get_pushrule_actions::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
if body.scope != RuleScope::Global {
@ -200,9 +200,9 @@ pub(crate) async fn get_pushrule_actions_route(
"Push rule not found.",
))?;
Ok(get_pushrule_actions::v3::Response {
Ok(RumaResponse(get_pushrule_actions::v3::Response {
actions,
})
}))
}
/// # `PUT /_matrix/client/r0/pushrules/{scope}/{kind}/{ruleId}/actions`
@ -210,7 +210,7 @@ pub(crate) async fn get_pushrule_actions_route(
/// Sets the actions of a single specified push rule for this user.
pub(crate) async fn set_pushrule_actions_route(
body: Ruma<set_pushrule_actions::v3::Request>,
) -> Result<set_pushrule_actions::v3::Response> {
) -> Result<RumaResponse<set_pushrule_actions::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
if body.scope != RuleScope::Global {
@ -257,7 +257,7 @@ pub(crate) async fn set_pushrule_actions_route(
.expect("to json value always works"),
)?;
Ok(set_pushrule_actions::v3::Response {})
Ok(RumaResponse(set_pushrule_actions::v3::Response {}))
}
/// # `GET /_matrix/client/r0/pushrules/{scope}/{kind}/{ruleId}/enabled`
@ -265,7 +265,7 @@ pub(crate) async fn set_pushrule_actions_route(
/// Gets the enabled status of a single specified push rule for this user.
pub(crate) async fn get_pushrule_enabled_route(
body: Ruma<get_pushrule_enabled::v3::Request>,
) -> Result<get_pushrule_enabled::v3::Response> {
) -> Result<RumaResponse<get_pushrule_enabled::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
if body.scope != RuleScope::Global {
@ -301,9 +301,9 @@ pub(crate) async fn get_pushrule_enabled_route(
"Push rule not found.",
))?;
Ok(get_pushrule_enabled::v3::Response {
Ok(RumaResponse(get_pushrule_enabled::v3::Response {
enabled,
})
}))
}
/// # `PUT /_matrix/client/r0/pushrules/{scope}/{kind}/{ruleId}/enabled`
@ -311,7 +311,7 @@ pub(crate) async fn get_pushrule_enabled_route(
/// Sets the enabled status of a single specified push rule for this user.
pub(crate) async fn set_pushrule_enabled_route(
body: Ruma<set_pushrule_enabled::v3::Request>,
) -> Result<set_pushrule_enabled::v3::Response> {
) -> Result<RumaResponse<set_pushrule_enabled::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
if body.scope != RuleScope::Global {
@ -358,7 +358,7 @@ pub(crate) async fn set_pushrule_enabled_route(
.expect("to json value always works"),
)?;
Ok(set_pushrule_enabled::v3::Response {})
Ok(RumaResponse(set_pushrule_enabled::v3::Response {}))
}
/// # `DELETE /_matrix/client/r0/pushrules/{scope}/{kind}/{ruleId}`
@ -366,7 +366,7 @@ pub(crate) async fn set_pushrule_enabled_route(
/// Deletes a single specified push rule for this user.
pub(crate) async fn delete_pushrule_route(
body: Ruma<delete_pushrule::v3::Request>,
) -> Result<delete_pushrule::v3::Response> {
) -> Result<RumaResponse<delete_pushrule::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
if body.scope != RuleScope::Global {
@ -418,7 +418,7 @@ pub(crate) async fn delete_pushrule_route(
.expect("to json value always works"),
)?;
Ok(delete_pushrule::v3::Response {})
Ok(RumaResponse(delete_pushrule::v3::Response {}))
}
/// # `GET /_matrix/client/r0/pushers`
@ -426,12 +426,12 @@ pub(crate) async fn delete_pushrule_route(
/// Gets all currently active pushers for the sender user.
pub(crate) async fn get_pushers_route(
body: Ruma<get_pushers::v3::Request>,
) -> Result<get_pushers::v3::Response> {
) -> Result<RumaResponse<get_pushers::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
Ok(get_pushers::v3::Response {
Ok(RumaResponse(get_pushers::v3::Response {
pushers: services().pusher.get_pushers(sender_user)?,
})
}))
}
/// # `POST /_matrix/client/r0/pushers/set`
@ -441,10 +441,10 @@ pub(crate) async fn get_pushers_route(
/// - TODO: Handle `append`
pub(crate) async fn set_pushers_route(
body: Ruma<set_pusher::v3::Request>,
) -> Result<set_pusher::v3::Response> {
) -> Result<RumaResponse<set_pusher::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
services().pusher.set_pusher(sender_user, body.action.clone())?;
Ok(set_pusher::v3::Response::default())
Ok(RumaResponse(set_pusher::v3::Response::default()))
}

9
src/api/client_server/read_marker.rs
View file

@ -13,6 +13,7 @@ use ruma::{
use crate::{
service::rooms::timeline::PduCount, services, Error, Result, Ruma,
RumaResponse,
};
/// # `POST /_matrix/client/r0/rooms/{roomId}/read_markers`
@ -24,7 +25,7 @@ use crate::{
/// EDU
pub(crate) async fn set_read_marker_route(
body: Ruma<set_read_marker::v3::Request>,
) -> Result<set_read_marker::v3::Response> {
) -> Result<RumaResponse<set_read_marker::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
if let Some(fully_read) = &body.fully_read {
@ -97,7 +98,7 @@ pub(crate) async fn set_read_marker_route(
)?;
}
Ok(set_read_marker::v3::Response {})
Ok(RumaResponse(set_read_marker::v3::Response {}))
}
/// # `POST /_matrix/client/r0/rooms/{roomId}/receipt/{receiptType}/{eventId}`
@ -105,7 +106,7 @@ pub(crate) async fn set_read_marker_route(
/// Sets private read marker and public read receipt EDU.
pub(crate) async fn create_receipt_route(
body: Ruma<create_receipt::v3::Request>,
) -> Result<create_receipt::v3::Response> {
) -> Result<RumaResponse<create_receipt::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
if matches!(
@ -187,5 +188,5 @@ pub(crate) async fn create_receipt_route(
_ => return Err(Error::bad_database("Unsupported receipt type")),
}
Ok(create_receipt::v3::Response {})
Ok(RumaResponse(create_receipt::v3::Response {}))
}

8
src/api/client_server/redact.rs
View file

@ -6,7 +6,7 @@ use ruma::{
};
use serde_json::value::to_raw_value;
use crate::{service::pdu::PduBuilder, services, Result, Ruma};
use crate::{service::pdu::PduBuilder, services, Result, Ruma, RumaResponse};
/// # `PUT /_matrix/client/r0/rooms/{roomId}/redact/{eventId}/{txnId}`
///
@ -15,7 +15,7 @@ use crate::{service::pdu::PduBuilder, services, Result, Ruma};
/// - TODO: Handle txn id
pub(crate) async fn redact_event_route(
body: Ruma<redact_event::v3::Request>,
) -> Result<redact_event::v3::Response> {
) -> Result<RumaResponse<redact_event::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let body = body.body;
@ -54,7 +54,7 @@ pub(crate) async fn redact_event_route(
drop(state_lock);
let event_id = (*event_id).to_owned();
Ok(redact_event::v3::Response {
Ok(RumaResponse(redact_event::v3::Response {
event_id,
})
}))
}

30
src/api/client_server/relations.rs
View file

@ -6,12 +6,18 @@ use ruma::{
uint,
};
use crate::{service::rooms::timeline::PduCount, services, Result, Ruma};
use crate::{
service::rooms::timeline::PduCount, services, Result, Ruma, RumaResponse,
};
/// # `GET /_matrix/client/r0/rooms/{roomId}/relations/{eventId}/{relType}/{eventType}`
pub(crate) async fn get_relating_events_with_rel_type_and_event_type_route(
body: Ruma<get_relating_events_with_rel_type_and_event_type::v1::Request>,
) -> Result<get_relating_events_with_rel_type_and_event_type::v1::Response> {
) -> Result<
RumaResponse<
get_relating_events_with_rel_type_and_event_type::v1::Response,
>,
> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let from = match body.from.clone() {
@ -44,17 +50,19 @@ pub(crate) async fn get_relating_events_with_rel_type_and_event_type_route(
limit,
)?;
Ok(get_relating_events_with_rel_type_and_event_type::v1::Response {
Ok(RumaResponse(
get_relating_events_with_rel_type_and_event_type::v1::Response {
chunk: res.chunk,
next_batch: res.next_batch,
prev_batch: res.prev_batch,
})
},
))
}
/// # `GET /_matrix/client/r0/rooms/{roomId}/relations/{eventId}/{relType}`
pub(crate) async fn get_relating_events_with_rel_type_route(
body: Ruma<get_relating_events_with_rel_type::v1::Request>,
) -> Result<get_relating_events_with_rel_type::v1::Response> {
) -> Result<RumaResponse<get_relating_events_with_rel_type::v1::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let from = match body.from.clone() {
@ -87,17 +95,17 @@ pub(crate) async fn get_relating_events_with_rel_type_route(
limit,
)?;
Ok(get_relating_events_with_rel_type::v1::Response {
Ok(RumaResponse(get_relating_events_with_rel_type::v1::Response {
chunk: res.chunk,
next_batch: res.next_batch,
prev_batch: res.prev_batch,
})
}))
}
/// # `GET /_matrix/client/r0/rooms/{roomId}/relations/{eventId}`
pub(crate) async fn get_relating_events_route(
body: Ruma<get_relating_events::v1::Request>,
) -> Result<get_relating_events::v1::Response> {
) -> Result<RumaResponse<get_relating_events::v1::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let from = match body.from.clone() {
@ -119,7 +127,10 @@ pub(crate) async fn get_relating_events_route(
.try_into()
.expect("0-100 should fit in usize");
services().rooms.pdu_metadata.paginate_relations_with_filter(
services()
.rooms
.pdu_metadata
.paginate_relations_with_filter(
sender_user,
&body.room_id,
&body.event_id,
@ -129,4 +140,5 @@ pub(crate) async fn get_relating_events_route(
to,
limit,
)
.map(RumaResponse)
}

6
src/api/client_server/report.rs
View file

@ -4,14 +4,14 @@ use ruma::{
int,
};
use crate::{services, Error, Result, Ruma};
use crate::{services, Error, Result, Ruma, RumaResponse};
/// # `POST /_matrix/client/r0/rooms/{roomId}/report/{eventId}`
///
/// Reports an inappropriate event to homeserver admins
pub(crate) async fn report_event_route(
body: Ruma<report_content::v3::Request>,
) -> Result<report_content::v3::Response> {
) -> Result<RumaResponse<report_content::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let Some(pdu) = services().rooms.timeline.get_pdu(&body.event_id)? else {
@ -91,5 +91,5 @@ pub(crate) async fn report_event_route(
),
));
Ok(report_content::v3::Response {})
Ok(RumaResponse(report_content::v3::Response {}))
}

24
src/api/client_server/room.rs
View file

@ -31,7 +31,7 @@ use tracing::{info, warn};
use crate::{
api::client_server::invite_helper, service::pdu::PduBuilder, services,
Error, Result, Ruma,
Error, Result, Ruma, RumaResponse,
};
/// # `POST /_matrix/client/r0/createRoom`
@ -53,7 +53,7 @@ use crate::{
#[allow(clippy::too_many_lines)]
pub(crate) async fn create_room_route(
body: Ruma<create_room::v3::Request>,
) -> Result<create_room::v3::Response> {
) -> Result<RumaResponse<create_room::v3::Response>> {
use create_room::v3::RoomPreset;
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -538,7 +538,7 @@ pub(crate) async fn create_room_route(
info!("{} created a room", sender_user);
Ok(create_room::v3::Response::new(room_id))
Ok(RumaResponse(create_room::v3::Response::new(room_id)))
}
/// # `GET /_matrix/client/r0/rooms/{roomId}/event/{eventId}`
@ -549,7 +549,7 @@ pub(crate) async fn create_room_route(
/// visibility)
pub(crate) async fn get_room_event_route(
body: Ruma<get_room_event::v3::Request>,
) -> Result<get_room_event::v3::Response> {
) -> Result<RumaResponse<get_room_event::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let event = services().rooms.timeline.get_pdu(&body.event_id)?.ok_or_else(
@ -573,9 +573,9 @@ pub(crate) async fn get_room_event_route(
let mut event = (*event).clone();
event.add_age()?;
Ok(get_room_event::v3::Response {
Ok(RumaResponse(get_room_event::v3::Response {
event: event.to_room_event(),
})
}))
}
/// # `GET /_matrix/client/r0/rooms/{roomId}/aliases`
@ -586,7 +586,7 @@ pub(crate) async fn get_room_event_route(
/// user to call it if `history_visibility` is world readable
pub(crate) async fn get_room_aliases_route(
body: Ruma<aliases::v3::Request>,
) -> Result<aliases::v3::Response> {
) -> Result<RumaResponse<aliases::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
if !services().rooms.state_cache.is_joined(sender_user, &body.room_id)? {
@ -596,14 +596,14 @@ pub(crate) async fn get_room_aliases_route(
));
}
Ok(aliases::v3::Response {
Ok(RumaResponse(aliases::v3::Response {
aliases: services()
.rooms
.alias
.local_aliases_for_room(&body.room_id)
.filter_map(Result::ok)
.collect(),
})
}))
}
/// # `POST /_matrix/client/r0/rooms/{roomId}/upgrade`
@ -619,7 +619,7 @@ pub(crate) async fn get_room_aliases_route(
#[allow(clippy::too_many_lines)]
pub(crate) async fn upgrade_room_route(
body: Ruma<upgrade_room::v3::Request>,
) -> Result<upgrade_room::v3::Response> {
) -> Result<RumaResponse<upgrade_room::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
if !services().globals.supported_room_versions().contains(&body.new_version)
@ -914,7 +914,7 @@ pub(crate) async fn upgrade_room_route(
drop(state_lock);
// Return the replacement room id
Ok(upgrade_room::v3::Response {
Ok(RumaResponse(upgrade_room::v3::Response {
replacement_room,
})
}))
}

8
src/api/client_server/search.rs
View file

@ -14,7 +14,7 @@ use ruma::{
uint,
};
use crate::{services, Error, Result, Ruma};
use crate::{services, Error, Result, Ruma, RumaResponse};
/// # `POST /_matrix/client/r0/search`
///
@ -25,7 +25,7 @@ use crate::{services, Error, Result, Ruma};
#[allow(clippy::too_many_lines)]
pub(crate) async fn search_events_route(
body: Ruma<search_events::v3::Request>,
) -> Result<search_events::v3::Response> {
) -> Result<RumaResponse<search_events::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let search_criteria = body.search_categories.room_events.as_ref().unwrap();
@ -136,7 +136,7 @@ pub(crate) async fn search_events_route(
Some((skip + limit).to_string())
};
Ok(search_events::v3::Response::new(ResultCategories {
Ok(RumaResponse(search_events::v3::Response::new(ResultCategories {
room_events: ResultRoomEvents {
count: None,
// TODO
@ -151,5 +151,5 @@ pub(crate) async fn search_events_route(
.map(str::to_lowercase)
.collect(),
},
}))
})))
}

22
src/api/client_server/session.rs
View file

@ -16,7 +16,7 @@ use serde::Deserialize;
use tracing::{info, warn};
use super::{DEVICE_ID_LENGTH, TOKEN_LENGTH};
use crate::{services, utils, Error, Result, Ruma};
use crate::{services, utils, Error, Result, Ruma, RumaResponse};
#[derive(Debug, Deserialize)]
struct Claims {
@ -29,13 +29,13 @@ struct Claims {
/// the `type` field when logging in.
pub(crate) async fn get_login_types_route(
_body: Ruma<get_login_types::v3::Request>,
) -> Result<get_login_types::v3::Response> {
Ok(get_login_types::v3::Response::new(vec![
) -> Result<RumaResponse<get_login_types::v3::Response>> {
Ok(RumaResponse(get_login_types::v3::Response::new(vec![
get_login_types::v3::LoginType::Password(PasswordLoginType::default()),
get_login_types::v3::LoginType::ApplicationService(
ApplicationServiceLoginType::default(),
),
]))
])))
}
/// # `POST /_matrix/client/r0/login`
@ -54,7 +54,7 @@ pub(crate) async fn get_login_types_route(
#[allow(clippy::too_many_lines)]
pub(crate) async fn login_route(
body: Ruma<login::v3::Request>,
) -> Result<login::v3::Response> {
) -> Result<RumaResponse<login::v3::Response>> {
// To allow deprecated login methods
#![allow(deprecated)]
// Validate login method
@ -256,7 +256,7 @@ pub(crate) async fn login_route(
// Homeservers are still required to send the `home_server` field
#[allow(deprecated)]
Ok(login::v3::Response {
Ok(RumaResponse(login::v3::Response {
user_id,
access_token: token,
home_server: Some(services().globals.server_name().to_owned()),
@ -264,7 +264,7 @@ pub(crate) async fn login_route(
well_known: None,
refresh_token: None,
expires_in: None,
})
}))
}
/// # `POST /_matrix/client/r0/logout`
@ -278,7 +278,7 @@ pub(crate) async fn login_route(
/// - Triggers device list updates
pub(crate) async fn logout_route(
body: Ruma<logout::v3::Request>,
) -> Result<logout::v3::Response> {
) -> Result<RumaResponse<logout::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let sender_device =
body.sender_device.as_ref().expect("user is authenticated");
@ -294,7 +294,7 @@ pub(crate) async fn logout_route(
services().users.remove_device(sender_user, sender_device)?;
Ok(logout::v3::Response::new())
Ok(RumaResponse(logout::v3::Response::new()))
}
/// # `POST /_matrix/client/r0/logout/all`
@ -311,7 +311,7 @@ pub(crate) async fn logout_route(
/// /_matrix/client/r0/logout`](logout_route) from each device of this user.
pub(crate) async fn logout_all_route(
body: Ruma<logout_all::v3::Request>,
) -> Result<logout_all::v3::Response> {
) -> Result<RumaResponse<logout_all::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
if let Some(info) = &body.appservice_info {
@ -332,5 +332,5 @@ pub(crate) async fn logout_all_route(
services().users.remove_device(sender_user, &device_id)?;
}
Ok(logout_all::v3::Response::new())
Ok(RumaResponse(logout_all::v3::Response::new()))
}

5
src/api/client_server/space.rs
View file

@ -1,6 +1,6 @@
use ruma::{api::client::space::get_hierarchy, uint};
use crate::{services, Result, Ruma};
use crate::{services, Result, Ruma, RumaResponse};
/// # `GET /_matrix/client/v1/rooms/{room_id}/hierarchy`
///
@ -8,7 +8,7 @@ use crate::{services, Result, Ruma};
/// of a given space.
pub(crate) async fn get_hierarchy_route(
body: Ruma<get_hierarchy::v1::Request>,
) -> Result<get_hierarchy::v1::Response> {
) -> Result<RumaResponse<get_hierarchy::v1::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let skip =
@ -40,4 +40,5 @@ pub(crate) async fn get_hierarchy_route(
body.suggested_only,
)
.await
.map(RumaResponse)
}

18
src/api/client_server/state.rs
View file

@ -28,7 +28,7 @@ use crate::{
/// - If event is new `canonical_alias`: Rejects if alias is incorrect
pub(crate) async fn send_state_event_for_key_route(
body: Ruma<send_state_event::v3::Request>,
) -> Result<send_state_event::v3::Response> {
) -> Result<RumaResponse<send_state_event::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let event_id = send_state_event_for_key_helper(
@ -42,9 +42,9 @@ pub(crate) async fn send_state_event_for_key_route(
.await?;
let event_id = (*event_id).to_owned();
Ok(send_state_event::v3::Response {
Ok(RumaResponse(send_state_event::v3::Response {
event_id,
})
}))
}
/// # `PUT /_matrix/client/r0/rooms/{roomId}/state/{eventType}`
@ -94,7 +94,7 @@ pub(crate) async fn send_state_event_for_empty_key_route(
/// readable
pub(crate) async fn get_state_events_route(
body: Ruma<get_state_events::v3::Request>,
) -> Result<get_state_events::v3::Response> {
) -> Result<RumaResponse<get_state_events::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
if !services()
@ -108,7 +108,7 @@ pub(crate) async fn get_state_events_route(
));
}
Ok(get_state_events::v3::Response {
Ok(RumaResponse(get_state_events::v3::Response {
room_state: services()
.rooms
.state_accessor
@ -117,7 +117,7 @@ pub(crate) async fn get_state_events_route(
.values()
.map(|pdu| pdu.to_state_event())
.collect(),
})
}))
}
/// # `GET /_matrix/client/r0/rooms/{roomid}/state/{eventType}/{stateKey}`
@ -128,7 +128,7 @@ pub(crate) async fn get_state_events_route(
/// readable
pub(crate) async fn get_state_events_for_key_route(
body: Ruma<get_state_events_for_key::v3::Request>,
) -> Result<get_state_events_for_key::v3::Response> {
) -> Result<RumaResponse<get_state_events_for_key::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
if !services()
@ -154,11 +154,11 @@ pub(crate) async fn get_state_events_for_key_route(
Error::BadRequest(ErrorKind::NotFound, "State event not found.")
})?;
Ok(get_state_events_for_key::v3::Response {
Ok(RumaResponse(get_state_events_for_key::v3::Response {
content: serde_json::from_str(event.content.get()).map_err(|_| {
Error::bad_database("Invalid event content in database")
})?,
})
}))
}
/// # `GET /_matrix/client/r0/rooms/{roomid}/state/{eventType}`

14
src/api/client_server/sync.rs
View file

@ -74,7 +74,8 @@ use crate::{
#[allow(clippy::too_many_lines)]
pub(crate) async fn sync_events_route(
body: Ruma<sync_events::v3::Request>,
) -> Result<sync_events::v3::Response, RumaResponse<UiaaResponse>> {
) -> Result<RumaResponse<sync_events::v3::Response>, RumaResponse<UiaaResponse>>
{
let sender_user = body.sender_user.expect("user is authenticated");
let sender_device = body.sender_device.expect("user is authenticated");
let body = body.body;
@ -457,10 +458,10 @@ pub(crate) async fn sync_events_route(
Ok(x) => x.expect("watcher should succeed"),
Err(error) => debug!(%error, "timed out"),
};
Ok(response)
Ok(RumaResponse(response))
} else {
// Only cache if we made progress
Ok(response)
Ok(RumaResponse(response))
}
}
@ -1127,7 +1128,8 @@ fn share_encrypted_room(
#[allow(clippy::too_many_lines)]
pub(crate) async fn sync_events_v4_route(
body: Ruma<sync_events::v4::Request>,
) -> Result<sync_events::v4::Response, RumaResponse<UiaaResponse>> {
) -> Result<RumaResponse<sync_events::v4::Response>, RumaResponse<UiaaResponse>>
{
let sender_user = body.sender_user.expect("user is authenticated");
let sender_device = body.sender_device.expect("user is authenticated");
let mut body = body.body;
@ -1700,7 +1702,7 @@ pub(crate) async fn sync_events_v4_route(
};
}
Ok(sync_events::v4::Response {
Ok(RumaResponse(sync_events::v4::Response {
initial: globalsince == 0,
txn_id: body.txn_id.clone(),
pos: next_batch.to_string(),
@ -1763,5 +1765,5 @@ pub(crate) async fn sync_events_v4_route(
},
},
delta_token: None,
})
}))
}

16
src/api/client_server/tag.rs
View file

@ -8,7 +8,7 @@ use ruma::{
},
};
use crate::{services, Error, Result, Ruma};
use crate::{services, Error, Result, Ruma, RumaResponse};
/// # `PUT /_matrix/client/r0/user/{userId}/rooms/{roomId}/tags/{tag}`
///
@ -17,7 +17,7 @@ use crate::{services, Error, Result, Ruma};
/// - Inserts the tag into the tag event of the room account data.
pub(crate) async fn update_tag_route(
body: Ruma<create_tag::v3::Request>,
) -> Result<create_tag::v3::Response> {
) -> Result<RumaResponse<create_tag::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let event = services().account_data.get(
@ -53,7 +53,7 @@ pub(crate) async fn update_tag_route(
&serde_json::to_value(tags_event).expect("to json value always works"),
)?;
Ok(create_tag::v3::Response {})
Ok(RumaResponse(create_tag::v3::Response {}))
}
/// # `DELETE /_matrix/client/r0/user/{userId}/rooms/{roomId}/tags/{tag}`
@ -63,7 +63,7 @@ pub(crate) async fn update_tag_route(
/// - Removes the tag from the tag event of the room account data.
pub(crate) async fn delete_tag_route(
body: Ruma<delete_tag::v3::Request>,
) -> Result<delete_tag::v3::Response> {
) -> Result<RumaResponse<delete_tag::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let event = services().account_data.get(
@ -96,7 +96,7 @@ pub(crate) async fn delete_tag_route(
&serde_json::to_value(tags_event).expect("to json value always works"),
)?;
Ok(delete_tag::v3::Response {})
Ok(RumaResponse(delete_tag::v3::Response {}))
}
/// # `GET /_matrix/client/r0/user/{userId}/rooms/{roomId}/tags`
@ -106,7 +106,7 @@ pub(crate) async fn delete_tag_route(
/// - Gets the tag event of the room account data.
pub(crate) async fn get_tags_route(
body: Ruma<get_tags::v3::Request>,
) -> Result<get_tags::v3::Response> {
) -> Result<RumaResponse<get_tags::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let event = services().account_data.get(
@ -130,7 +130,7 @@ pub(crate) async fn get_tags_route(
},
)?;
Ok(get_tags::v3::Response {
Ok(RumaResponse(get_tags::v3::Response {
tags: tags_event.content.tags,
})
}))
}

8
src/api/client_server/thirdparty.rs
View file

@ -2,16 +2,16 @@ use std::collections::BTreeMap;
use ruma::api::client::thirdparty::get_protocols;
use crate::{Result, Ruma};
use crate::{Result, Ruma, RumaResponse};
/// # `GET /_matrix/client/r0/thirdparty/protocols`
///
/// TODO: Fetches all metadata about protocols supported by the homeserver.
pub(crate) async fn get_protocols_route(
_body: Ruma<get_protocols::v3::Request>,
) -> Result<get_protocols::v3::Response> {
) -> Result<RumaResponse<get_protocols::v3::Response>> {
// TODO
Ok(get_protocols::v3::Response {
Ok(RumaResponse(get_protocols::v3::Response {
protocols: BTreeMap::new(),
})
}))
}

8
src/api/client_server/threads.rs
View file

@ -1,11 +1,11 @@
use ruma::api::client::{error::ErrorKind, threads::get_threads};
use crate::{services, Error, Result, Ruma};
use crate::{services, Error, Result, Ruma, RumaResponse};
/// # `GET /_matrix/client/r0/rooms/{roomId}/threads`
pub(crate) async fn get_threads_route(
body: Ruma<get_threads::v1::Request>,
) -> Result<get_threads::v1::Response> {
) -> Result<RumaResponse<get_threads::v1::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
// Use limit or else 10, with maximum 100
@ -36,11 +36,11 @@ pub(crate) async fn get_threads_route(
let next_batch = threads.last().map(|(count, _)| count.to_string());
Ok(get_threads::v1::Response {
Ok(RumaResponse(get_threads::v1::Response {
chunk: threads
.into_iter()
.map(|(_, pdu)| pdu.to_room_event())
.collect(),
next_batch,
})
}))
}

8
src/api/client_server/to_device.rs
View file

@ -8,14 +8,14 @@ use ruma::{
to_device::DeviceIdOrAllDevices,
};
use crate::{services, Error, Result, Ruma};
use crate::{services, Error, Result, Ruma, RumaResponse};
/// # `PUT /_matrix/client/r0/sendToDevice/{eventType}/{txnId}`
///
/// Send a to-device event to a set of client devices.
pub(crate) async fn send_event_to_device_route(
body: Ruma<send_event_to_device::v3::Request>,
) -> Result<send_event_to_device::v3::Response> {
) -> Result<RumaResponse<send_event_to_device::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let sender_device = body.sender_device.as_deref();
@ -25,7 +25,7 @@ pub(crate) async fn send_event_to_device_route(
.existing_txnid(sender_user, sender_device, &body.txn_id)?
.is_some()
{
return Ok(send_event_to_device::v3::Response {});
return Ok(RumaResponse(send_event_to_device::v3::Response {}));
}
for (target_user_id, map) in &body.messages {
@ -103,5 +103,5 @@ pub(crate) async fn send_event_to_device_route(
&[],
)?;
Ok(send_event_to_device::v3::Response {})
Ok(RumaResponse(send_event_to_device::v3::Response {}))
}

6
src/api/client_server/typing.rs
View file

@ -1,13 +1,13 @@
use ruma::api::client::{error::ErrorKind, typing::create_typing_event};
use crate::{services, utils, Error, Result, Ruma};
use crate::{services, utils, Error, Result, Ruma, RumaResponse};
/// # `PUT /_matrix/client/r0/rooms/{roomId}/typing/{userId}`
///
/// Sets the typing state of the sender user.
pub(crate) async fn create_typing_event_route(
body: Ruma<create_typing_event::v3::Request>,
) -> Result<create_typing_event::v3::Response> {
) -> Result<RumaResponse<create_typing_event::v3::Response>> {
use create_typing_event::v3::Typing;
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
@ -40,5 +40,5 @@ pub(crate) async fn create_typing_event_route(
.await?;
}
Ok(create_typing_event::v3::Response {})
Ok(RumaResponse(create_typing_event::v3::Response {}))
}

6
src/api/client_server/unversioned.rs
View file

@ -2,7 +2,7 @@ use std::{collections::BTreeMap, iter::FromIterator};
use ruma::api::client::discovery::get_supported_versions;
use crate::{Result, Ruma};
use crate::{Result, Ruma, RumaResponse};
/// # `GET /_matrix/client/versions`
///
@ -18,7 +18,7 @@ use crate::{Result, Ruma};
/// should avoid using unstable features in their stable releases
pub(crate) async fn get_supported_versions_route(
_body: Ruma<get_supported_versions::Request>,
) -> Result<get_supported_versions::Response> {
) -> Result<RumaResponse<get_supported_versions::Response>> {
let resp = get_supported_versions::Response {
versions: vec![
"r0.5.0".to_owned(),
@ -35,5 +35,5 @@ pub(crate) async fn get_supported_versions_route(
)]),
};
Ok(resp)
Ok(RumaResponse(resp))
}

8
src/api/client_server/user_directory.rs
View file

@ -6,7 +6,7 @@ use ruma::{
},
};
use crate::{services, Result, Ruma};
use crate::{services, Result, Ruma, RumaResponse};
/// # `POST /_matrix/client/r0/user_directory/search`
///
@ -17,7 +17,7 @@ use crate::{services, Result, Ruma};
/// and don't share a room with the sender
pub(crate) async fn search_users_route(
body: Ruma<search_users::v3::Request>,
) -> Result<search_users::v3::Response> {
) -> Result<RumaResponse<search_users::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let limit = body.limit.try_into().unwrap_or(usize::MAX);
@ -99,8 +99,8 @@ pub(crate) async fn search_users_route(
let results = users.by_ref().take(limit).collect();
let limited = users.next().is_some();
Ok(search_users::v3::Response {
Ok(RumaResponse(search_users::v3::Response {
results,
limited,
})
}))
}

8
src/api/client_server/voip.rs
View file

@ -5,7 +5,7 @@ use hmac::{Hmac, Mac};
use ruma::{api::client::voip::get_turn_server_info, SecondsSinceUnixEpoch};
use sha1::Sha1;
use crate::{services, Result, Ruma};
use crate::{services, Result, Ruma, RumaResponse};
type HmacSha1 = Hmac<Sha1>;
@ -14,7 +14,7 @@ type HmacSha1 = Hmac<Sha1>;
/// TODO: Returns information about the recommended turn server.
pub(crate) async fn turn_server_route(
body: Ruma<get_turn_server_info::v3::Request>,
) -> Result<get_turn_server_info::v3::Response> {
) -> Result<RumaResponse<get_turn_server_info::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let turn_secret = services().globals.turn_secret().clone();
@ -43,10 +43,10 @@ pub(crate) async fn turn_server_route(
(username, password)
};
Ok(get_turn_server_info::v3::Response {
Ok(RumaResponse(get_turn_server_info::v3::Response {
username,
password,
uris: services().globals.turn_uris().to_vec(),
ttl: Duration::from_secs(services().globals.turn_ttl()),
})
}))
}

116
src/api/server_server.rs
View file

@ -66,7 +66,7 @@ use tracing::{debug, error, warn};
use crate::{
api::client_server::{self, claim_keys_helper, get_keys_helper},
service::pdu::{gen_event_id_canonical_json, PduBuilder},
services, utils, Error, PduEvent, Result, Ruma,
services, utils, Error, PduEvent, Result, Ruma, RumaResponse,
};
/// Wraps either an literal IP address plus port, or a hostname plus complement
@ -554,13 +554,13 @@ async fn request_well_known(destination: &str) -> Option<String> {
/// Get version information on this server.
pub(crate) async fn get_server_version_route(
_body: Ruma<get_server_version::v1::Request>,
) -> Result<get_server_version::v1::Response> {
Ok(get_server_version::v1::Response {
) -> Result<RumaResponse<get_server_version::v1::Response>> {
Ok(RumaResponse(get_server_version::v1::Response {
server: Some(get_server_version::v1::Server {
name: Some(env!("CARGO_PKG_NAME").to_owned()),
version: Some(crate::version()),
}),
})
}))
}
/// # `GET /_matrix/key/v2/server`
@ -631,7 +631,7 @@ pub(crate) async fn get_server_keys_deprecated_route() -> impl IntoResponse {
/// Lists the public rooms on this server.
pub(crate) async fn get_public_rooms_filtered_route(
body: Ruma<get_public_rooms_filtered::v1::Request>,
) -> Result<get_public_rooms_filtered::v1::Response> {
) -> Result<RumaResponse<get_public_rooms_filtered::v1::Response>> {
let response = client_server::get_public_rooms_filtered_helper(
None,
body.limit,
@ -641,12 +641,12 @@ pub(crate) async fn get_public_rooms_filtered_route(
)
.await?;
Ok(get_public_rooms_filtered::v1::Response {
Ok(RumaResponse(get_public_rooms_filtered::v1::Response {
chunk: response.chunk,
prev_batch: response.prev_batch,
next_batch: response.next_batch,
total_room_count_estimate: response.total_room_count_estimate,
})
}))
}
/// # `GET /_matrix/federation/v1/publicRooms`
@ -654,7 +654,7 @@ pub(crate) async fn get_public_rooms_filtered_route(
/// Lists the public rooms on this server.
pub(crate) async fn get_public_rooms_route(
body: Ruma<get_public_rooms::v1::Request>,
) -> Result<get_public_rooms::v1::Response> {
) -> Result<RumaResponse<get_public_rooms::v1::Response>> {
let response = client_server::get_public_rooms_filtered_helper(
None,
body.limit,
@ -664,12 +664,12 @@ pub(crate) async fn get_public_rooms_route(
)
.await?;
Ok(get_public_rooms::v1::Response {
Ok(RumaResponse(get_public_rooms::v1::Response {
chunk: response.chunk,
prev_batch: response.prev_batch,
next_batch: response.next_batch,
total_room_count_estimate: response.total_room_count_estimate,
})
}))
}
pub(crate) fn parse_incoming_pdu(
@ -709,7 +709,7 @@ pub(crate) fn parse_incoming_pdu(
#[allow(clippy::too_many_lines)]
pub(crate) async fn send_transaction_message_route(
body: Ruma<send_transaction_message::v1::Request>,
) -> Result<send_transaction_message::v1::Response> {
) -> Result<RumaResponse<send_transaction_message::v1::Response>> {
let sender_servername =
body.sender_servername.as_ref().expect("server is authenticated");
@ -976,12 +976,12 @@ pub(crate) async fn send_transaction_message_route(
}
}
Ok(send_transaction_message::v1::Response {
Ok(RumaResponse(send_transaction_message::v1::Response {
pdus: resolved_map
.into_iter()
.map(|(e, r)| (e, r.map_err(|e| e.sanitized_error())))
.collect(),
})
}))
}
/// # `GET /_matrix/federation/v1/event/{eventId}`
@ -992,7 +992,7 @@ pub(crate) async fn send_transaction_message_route(
/// room
pub(crate) async fn get_event_route(
body: Ruma<get_event::v1::Request>,
) -> Result<get_event::v1::Response> {
) -> Result<RumaResponse<get_event::v1::Response>> {
let sender_servername =
body.sender_servername.as_ref().expect("server is authenticated");
@ -1035,11 +1035,11 @@ pub(crate) async fn get_event_route(
));
}
Ok(get_event::v1::Response {
Ok(RumaResponse(get_event::v1::Response {
origin: services().globals.server_name().to_owned(),
origin_server_ts: MilliSecondsSinceUnixEpoch::now(),
pdu: PduEvent::convert_to_outgoing_federation_event(event),
})
}))
}
/// # `GET /_matrix/federation/v1/backfill/<room_id>`
@ -1048,7 +1048,7 @@ pub(crate) async fn get_event_route(
/// history visibility allows.
pub(crate) async fn get_backfill_route(
body: Ruma<get_backfill::v1::Request>,
) -> Result<get_backfill::v1::Response> {
) -> Result<RumaResponse<get_backfill::v1::Response>> {
let sender_servername =
body.sender_servername.as_ref().expect("server is authenticated");
@ -1106,11 +1106,11 @@ pub(crate) async fn get_backfill_route(
.map(PduEvent::convert_to_outgoing_federation_event)
.collect();
Ok(get_backfill::v1::Response {
Ok(RumaResponse(get_backfill::v1::Response {
origin: services().globals.server_name().to_owned(),
origin_server_ts: MilliSecondsSinceUnixEpoch::now(),
pdus: events,
})
}))
}
/// # `POST /_matrix/federation/v1/get_missing_events/{roomId}`
@ -1118,7 +1118,7 @@ pub(crate) async fn get_backfill_route(
/// Retrieves events that the sender is missing.
pub(crate) async fn get_missing_events_route(
body: Ruma<get_missing_events::v1::Request>,
) -> Result<get_missing_events::v1::Response> {
) -> Result<RumaResponse<get_missing_events::v1::Response>> {
let sender_servername =
body.sender_servername.as_ref().expect("server is authenticated");
@ -1208,9 +1208,9 @@ pub(crate) async fn get_missing_events_route(
i += 1;
}
Ok(get_missing_events::v1::Response {
Ok(RumaResponse(get_missing_events::v1::Response {
events,
})
}))
}
/// # `GET /_matrix/federation/v1/event_auth/{roomId}/{eventId}`
@ -1220,7 +1220,7 @@ pub(crate) async fn get_missing_events_route(
/// - This does not include the event itself
pub(crate) async fn get_event_authorization_route(
body: Ruma<get_event_authorization::v1::Request>,
) -> Result<get_event_authorization::v1::Response> {
) -> Result<RumaResponse<get_event_authorization::v1::Response>> {
let sender_servername =
body.sender_servername.as_ref().expect("server is authenticated");
@ -1263,14 +1263,14 @@ pub(crate) async fn get_event_authorization_route(
.get_auth_chain(room_id, vec![Arc::from(&*body.event_id)])
.await?;
Ok(get_event_authorization::v1::Response {
Ok(RumaResponse(get_event_authorization::v1::Response {
auth_chain: auth_chain_ids
.filter_map(|id| {
services().rooms.timeline.get_pdu_json(&id).ok()?
})
.map(PduEvent::convert_to_outgoing_federation_event)
.collect(),
})
}))
}
/// # `GET /_matrix/federation/v1/state/{roomId}`
@ -1278,7 +1278,7 @@ pub(crate) async fn get_event_authorization_route(
/// Retrieves the current state of the room.
pub(crate) async fn get_room_state_route(
body: Ruma<get_room_state::v1::Request>,
) -> Result<get_room_state::v1::Response> {
) -> Result<RumaResponse<get_room_state::v1::Response>> {
let sender_servername =
body.sender_servername.as_ref().expect("server is authenticated");
@ -1326,7 +1326,7 @@ pub(crate) async fn get_room_state_route(
.get_auth_chain(&body.room_id, vec![Arc::from(&*body.event_id)])
.await?;
Ok(get_room_state::v1::Response {
Ok(RumaResponse(get_room_state::v1::Response {
auth_chain: auth_chain_ids
.filter_map(|id| {
if let Some(json) =
@ -1340,7 +1340,7 @@ pub(crate) async fn get_room_state_route(
})
.collect(),
pdus,
})
}))
}
/// # `GET /_matrix/federation/v1/state_ids/{roomId}`
@ -1348,7 +1348,7 @@ pub(crate) async fn get_room_state_route(
/// Retrieves the current state of the room.
pub(crate) async fn get_room_state_ids_route(
body: Ruma<get_room_state_ids::v1::Request>,
) -> Result<get_room_state_ids::v1::Response> {
) -> Result<RumaResponse<get_room_state_ids::v1::Response>> {
let sender_servername =
body.sender_servername.as_ref().expect("server is authenticated");
@ -1392,10 +1392,10 @@ pub(crate) async fn get_room_state_ids_route(
.get_auth_chain(&body.room_id, vec![Arc::from(&*body.event_id)])
.await?;
Ok(get_room_state_ids::v1::Response {
Ok(RumaResponse(get_room_state_ids::v1::Response {
auth_chain_ids: auth_chain_ids.map(|id| (*id).to_owned()).collect(),
pdu_ids,
})
}))
}
/// # `GET /_matrix/federation/v1/make_join/{roomId}/{userId}`
@ -1403,7 +1403,7 @@ pub(crate) async fn get_room_state_ids_route(
/// Creates a join template.
pub(crate) async fn create_join_event_template_route(
body: Ruma<prepare_join_event::v1::Request>,
) -> Result<prepare_join_event::v1::Response> {
) -> Result<RumaResponse<prepare_join_event::v1::Response>> {
if !services().rooms.metadata.exists(&body.room_id)? {
return Err(Error::BadRequest(
ErrorKind::NotFound,
@ -1504,11 +1504,11 @@ pub(crate) async fn create_join_event_template_route(
pdu_json.remove("event_id");
Ok(prepare_join_event::v1::Response {
Ok(RumaResponse(prepare_join_event::v1::Response {
room_version: Some(room_version_id),
event: to_raw_value(&pdu_json)
.expect("CanonicalJson can be serialized to JSON"),
})
}))
}
#[allow(clippy::too_many_lines)]
@ -1661,16 +1661,16 @@ async fn create_join_event(
/// Submits a signed join event.
pub(crate) async fn create_join_event_v1_route(
body: Ruma<create_join_event::v1::Request>,
) -> Result<create_join_event::v1::Response> {
) -> Result<RumaResponse<create_join_event::v1::Response>> {
let sender_servername =
body.sender_servername.as_ref().expect("server is authenticated");
let room_state =
create_join_event(sender_servername, &body.room_id, &body.pdu).await?;
Ok(create_join_event::v1::Response {
Ok(RumaResponse(create_join_event::v1::Response {
room_state,
})
}))
}
/// # `PUT /_matrix/federation/v2/send_join/{roomId}/{eventId}`
@ -1678,7 +1678,7 @@ pub(crate) async fn create_join_event_v1_route(
/// Submits a signed join event.
pub(crate) async fn create_join_event_v2_route(
body: Ruma<create_join_event::v2::Request>,
) -> Result<create_join_event::v2::Response> {
) -> Result<RumaResponse<create_join_event::v2::Response>> {
let sender_servername =
body.sender_servername.as_ref().expect("server is authenticated");
@ -1695,9 +1695,9 @@ pub(crate) async fn create_join_event_v2_route(
servers_in_room: None,
};
Ok(create_join_event::v2::Response {
Ok(RumaResponse(create_join_event::v2::Response {
room_state,
})
}))
}
/// # `PUT /_matrix/federation/v2/invite/{roomId}/{eventId}`
@ -1706,7 +1706,7 @@ pub(crate) async fn create_join_event_v2_route(
#[allow(clippy::too_many_lines)]
pub(crate) async fn create_invite_route(
body: Ruma<create_invite::v2::Request>,
) -> Result<create_invite::v2::Response> {
) -> Result<RumaResponse<create_invite::v2::Response>> {
let sender_servername =
body.sender_servername.as_ref().expect("server is authenticated");
@ -1827,9 +1827,9 @@ pub(crate) async fn create_invite_route(
)?;
}
Ok(create_invite::v2::Response {
Ok(RumaResponse(create_invite::v2::Response {
event: PduEvent::convert_to_outgoing_federation_event(signed_event),
})
}))
}
/// # `GET /_matrix/federation/v1/user/devices/{userId}`
@ -1837,7 +1837,7 @@ pub(crate) async fn create_invite_route(
/// Gets information on all devices of the user.
pub(crate) async fn get_devices_route(
body: Ruma<get_devices::v1::Request>,
) -> Result<get_devices::v1::Response> {
) -> Result<RumaResponse<get_devices::v1::Response>> {
if body.user_id.server_name() != services().globals.server_name() {
return Err(Error::BadRequest(
ErrorKind::InvalidParam,
@ -1848,7 +1848,7 @@ pub(crate) async fn get_devices_route(
let sender_servername =
body.sender_servername.as_ref().expect("server is authenticated");
Ok(get_devices::v1::Response {
Ok(RumaResponse(get_devices::v1::Response {
user_id: body.user_id.clone(),
stream_id: services()
.users
@ -1881,7 +1881,7 @@ pub(crate) async fn get_devices_route(
&body.user_id,
&|u| u.server_name() == sender_servername,
)?,
})
}))
}
/// # `GET /_matrix/federation/v1/query/directory`
@ -1889,16 +1889,16 @@ pub(crate) async fn get_devices_route(
/// Resolve a room alias to a room id.
pub(crate) async fn get_room_information_route(
body: Ruma<get_room_information::v1::Request>,
) -> Result<get_room_information::v1::Response> {
) -> Result<RumaResponse<get_room_information::v1::Response>> {
let room_id =
services().rooms.alias.resolve_local_alias(&body.room_alias)?.ok_or(
Error::BadRequest(ErrorKind::NotFound, "Room alias not found."),
)?;
Ok(get_room_information::v1::Response {
Ok(RumaResponse(get_room_information::v1::Response {
room_id,
servers: vec![services().globals.server_name().to_owned()],
})
}))
}
/// # `GET /_matrix/federation/v1/query/profile`
@ -1906,7 +1906,7 @@ pub(crate) async fn get_room_information_route(
/// Gets information on a profile.
pub(crate) async fn get_profile_information_route(
body: Ruma<get_profile_information::v1::Request>,
) -> Result<get_profile_information::v1::Response> {
) -> Result<RumaResponse<get_profile_information::v1::Response>> {
if body.user_id.server_name() != services().globals.server_name() {
return Err(Error::BadRequest(
ErrorKind::InvalidParam,
@ -1935,11 +1935,11 @@ pub(crate) async fn get_profile_information_route(
}
}
Ok(get_profile_information::v1::Response {
Ok(RumaResponse(get_profile_information::v1::Response {
displayname,
avatar_url,
blurhash,
})
}))
}
/// # `POST /_matrix/federation/v1/user/keys/query`
@ -1947,7 +1947,7 @@ pub(crate) async fn get_profile_information_route(
/// Gets devices and identity keys for the given users.
pub(crate) async fn get_keys_route(
body: Ruma<get_keys::v1::Request>,
) -> Result<get_keys::v1::Response> {
) -> Result<RumaResponse<get_keys::v1::Response>> {
if body
.device_keys
.iter()
@ -1964,11 +1964,11 @@ pub(crate) async fn get_keys_route(
})
.await?;
Ok(get_keys::v1::Response {
Ok(RumaResponse(get_keys::v1::Response {
device_keys: result.device_keys,
master_keys: result.master_keys,
self_signing_keys: result.self_signing_keys,
})
}))
}
/// # `POST /_matrix/federation/v1/user/keys/claim`
@ -1976,7 +1976,7 @@ pub(crate) async fn get_keys_route(
/// Claims one-time keys.
pub(crate) async fn claim_keys_route(
body: Ruma<claim_keys::v1::Request>,
) -> Result<claim_keys::v1::Response> {
) -> Result<RumaResponse<claim_keys::v1::Response>> {
if body
.one_time_keys
.iter()
@ -1990,9 +1990,9 @@ pub(crate) async fn claim_keys_route(
let result = claim_keys_helper(&body.one_time_keys).await?;
Ok(claim_keys::v1::Response {
Ok(RumaResponse(claim_keys::v1::Response {
one_time_keys: result.one_time_keys,
})
}))
}
#[cfg(test)]

8
src/main.rs
View file

@ -579,11 +579,13 @@ 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
impl<Req, Resp, E, F, Fut, $($ty,)*>
RumaHandler<($($ty,)* Ruma<Req>,)> for F
where
Req: IncomingRequest + Send + 'static,
Resp: IntoResponse,
F: FnOnce($($ty,)* Ruma<Req>) -> Fut + Clone + Send + 'static,
Fut: Future<Output = Result<Req::OutgoingResponse, E>>
Fut: Future<Output = Result<Resp, E>>
+ Send,
E: IntoResponse,
$( $ty: FromRequestParts<()> + Send + 'static, )*
@ -600,7 +602,7 @@ macro_rules! impl_ruma_handler {
on(
method_filter,
|$( $ty: $ty, )* req| async move {
handler($($ty,)* req).await.map(RumaResponse)
handler($($ty,)* req).await
}
)
)