conduit/src/client_server/alias.rs

use crate::{database::DatabaseGuard, ConduitResult, Database, Error, Ruma};
use regex::Regex;
use ruma::{
    api::{
        appservice,
        client::{
            error::ErrorKind,
            r0::alias::{create_alias, delete_alias, get_alias},
        },
        federation,
    },
    RoomAliasId,
};

#[cfg(feature = "conduit_bin")]
use rocket::{delete, get, put};

#[cfg_attr(
    feature = "conduit_bin",
    put("/_matrix/client/r0/directory/room/<_>", data = "<body>")
)]
#[tracing::instrument(skip(db, body))]
pub async fn create_alias_route(
    db: DatabaseGuard,
    body: Ruma<create_alias::Request<'_>>,
) -> ConduitResult<create_alias::Response> {
    if db.rooms.id_from_alias(&body.room_alias)?.is_some() {
        return Err(Error::Conflict("Alias already exists."));
    }

    db.rooms
        .set_alias(&body.room_alias, Some(&body.room_id), &db.globals)?;

    db.flush().await?;

    Ok(create_alias::Response::new().into())
}

#[cfg_attr(
    feature = "conduit_bin",
    delete("/_matrix/client/r0/directory/room/<_>", data = "<body>")
)]
#[tracing::instrument(skip(db, body))]
pub async fn delete_alias_route(
    db: DatabaseGuard,
    body: Ruma<delete_alias::Request<'_>>,
) -> ConduitResult<delete_alias::Response> {
    db.rooms.set_alias(&body.room_alias, None, &db.globals)?;

    db.flush().await?;

    Ok(delete_alias::Response::new().into())
}

#[cfg_attr(
    feature = "conduit_bin",
    get("/_matrix/client/r0/directory/room/<_>", data = "<body>")
)]
#[tracing::instrument(skip(db, body))]
pub async fn get_alias_route(
    db: DatabaseGuard,
    body: Ruma<get_alias::Request<'_>>,
) -> ConduitResult<get_alias::Response> {
    get_alias_helper(&db, &body.room_alias).await
}

pub async fn get_alias_helper(
    db: &Database,
    room_alias: &RoomAliasId,
) -> ConduitResult<get_alias::Response> {
    if room_alias.server_name() != db.globals.server_name() {
        let response = db
            .sending
            .send_federation_request(
                &db.globals,
                room_alias.server_name(),
                federation::query::get_room_information::v1::Request { room_alias },
            )
            .await?;

        return Ok(get_alias::Response::new(response.room_id, response.servers).into());
    }

    let mut room_id = None;
    match db.rooms.id_from_alias(&room_alias)? {
        Some(r) => room_id = Some(r),
        None => {
            let iter = db.appservice.iter_all()?;
            for (_id, registration) in iter.filter_map(|r| r.ok()) {
                let aliases = registration
                    .get("namespaces")
                    .and_then(|ns| ns.get("aliases"))
                    .and_then(|aliases| aliases.as_sequence())
                    .map_or_else(Vec::new, |aliases| {
                        aliases
                            .iter()
                            .filter_map(|aliases| Regex::new(aliases.get("regex")?.as_str()?).ok())
                            .collect::<Vec<_>>()
                    });

                if aliases
                    .iter()
                    .any(|aliases| aliases.is_match(room_alias.as_str()))
                    && db
                        .sending
                        .send_appservice_request(
                            &db.globals,
                            registration,
                            appservice::query::query_room_alias::v1::Request { room_alias },
                        )
                        .await
                        .is_ok()
                {
                    room_id = Some(db.rooms.id_from_alias(&room_alias)?.ok_or_else(|| {
                        Error::bad_config("Appservice lied to us. Room does not exist.")
                    })?);
                    break;
                }
            }
        }
    };

    let room_id = match room_id {
        Some(room_id) => room_id,
        None => {
            return Err(Error::BadRequest(
                ErrorKind::NotFound,
                "Room with alias not found.",
            ))
        }
    };

    Ok(get_alias::Response::new(room_id, vec![db.globals.server_name().to_owned()]).into())
}
Sqlite 2021-07-14 07:07:08 +00:00			`use crate::{database::DatabaseGuard, ConduitResult, Database, Error, Ruma};`
fix: don't always query aliases of appservices only do so if the alias matches the regex in the registration file 2021-03-03 20:41:26 +00:00			`use regex::Regex;`
Add helper function for get_alias route 2020-08-20 16:12:02 +00:00			`use ruma::{`
			`api::{`
feat: implement appservices this also reverts some stateres changes 2020-12-08 09:33:44 +00:00			`appservice,`
Add helper function for get_alias route 2020-08-20 16:12:02 +00:00			`client::{`
			`error::ErrorKind,`
			`r0::alias::{create_alias, delete_alias, get_alias},`
			`},`
			`federation,`
fmt 2020-08-14 09:34:15 +00:00			`},`
Add helper function for get_alias route 2020-08-20 16:12:02 +00:00			`RoomAliasId,`
fmt 2020-08-14 09:34:15 +00:00			`};`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00
			`#[cfg(feature = "conduit_bin")]`
			`use rocket::{delete, get, put};`

			`#[cfg_attr(`
			`feature = "conduit_bin",`
			`put("/_matrix/client/r0/directory/room/<_>", data = "<body>")`
			`)]`
feat: opentelemetry/jaeger support 2021-02-28 11:41:03 +00:00			`#[tracing::instrument(skip(db, body))]`
improvement: flush after every request that manipulates the db 2020-10-21 19:28:02 +00:00			`pub async fn create_alias_route(`
Sqlite 2021-07-14 07:07:08 +00:00			`db: DatabaseGuard,`
Update ruma version 2020-09-08 15:32:03 +00:00			`body: Ruma<create_alias::Request<'_>>,`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00			`) -> ConduitResult<create_alias::Response> {`
			`if db.rooms.id_from_alias(&body.room_alias)?.is_some() {`
			`return Err(Error::Conflict("Alias already exists."));`
			`}`

			`db.rooms`
			`.set_alias(&body.room_alias, Some(&body.room_id), &db.globals)?;`

improvement: flush after every request that manipulates the db 2020-10-21 19:28:02 +00:00			`db.flush().await?;`

Keep track of State at event for state resolution feat: first steps towards joining rooms over federation Add state-res as a dependency of conduit Add reverse_topological_power_sort before append_pdu Implement statehashstatid_pduid tree for keeping track of state Clean up implementation of state_hash as key for tracking state 2020-08-06 12:29:59 +00:00			`Ok(create_alias::Response::new().into())`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00			`}`

			`#[cfg_attr(`
			`feature = "conduit_bin",`
			`delete("/_matrix/client/r0/directory/room/<_>", data = "<body>")`
			`)]`
feat: opentelemetry/jaeger support 2021-02-28 11:41:03 +00:00			`#[tracing::instrument(skip(db, body))]`
improvement: flush after every request that manipulates the db 2020-10-21 19:28:02 +00:00			`pub async fn delete_alias_route(`
Sqlite 2021-07-14 07:07:08 +00:00			`db: DatabaseGuard,`
Update ruma version 2020-09-08 15:32:03 +00:00			`body: Ruma<delete_alias::Request<'_>>,`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00			`) -> ConduitResult<delete_alias::Response> {`
			`db.rooms.set_alias(&body.room_alias, None, &db.globals)?;`

improvement: flush after every request that manipulates the db 2020-10-21 19:28:02 +00:00			`db.flush().await?;`

Keep track of State at event for state resolution feat: first steps towards joining rooms over federation Add state-res as a dependency of conduit Add reverse_topological_power_sort before append_pdu Implement statehashstatid_pduid tree for keeping track of state Clean up implementation of state_hash as key for tracking state 2020-08-06 12:29:59 +00:00			`Ok(delete_alias::Response::new().into())`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00			`}`

			`#[cfg_attr(`
			`feature = "conduit_bin",`
			`get("/_matrix/client/r0/directory/room/<_>", data = "<body>")`
			`)]`
feat: opentelemetry/jaeger support 2021-02-28 11:41:03 +00:00			`#[tracing::instrument(skip(db, body))]`
feat: first steps towards joining rooms over federation 2020-08-14 09:31:31 +00:00			`pub async fn get_alias_route(`
Sqlite 2021-07-14 07:07:08 +00:00			`db: DatabaseGuard,`
Update ruma version 2020-09-08 15:32:03 +00:00			`body: Ruma<get_alias::Request<'_>>,`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00			`) -> ConduitResult<get_alias::Response> {`
Replace route calling routes with helpers This fixes the panic from ruma "index out of bounds" 2020-08-21 21:19:18 +00:00			`get_alias_helper(&db, &body.room_alias).await`
Add helper function for get_alias route 2020-08-20 16:12:02 +00:00			`}`

			`pub async fn get_alias_helper(`
Replace route calling routes with helpers This fixes the panic from ruma "index out of bounds" 2020-08-21 21:19:18 +00:00			`db: &Database,`
Add helper function for get_alias route 2020-08-20 16:12:02 +00:00			`room_alias: &RoomAliasId,`
			`) -> ConduitResult<get_alias::Response> {`
			`if room_alias.server_name() != db.globals.server_name() {`
feat: improved state store 2020-12-19 15:00:11 +00:00			`let response = db`
			`.sending`
			`.send_federation_request(`
			`&db.globals,`
Convert uses of Box<ServerName> to a ref 2021-01-14 19:39:56 +00:00			`room_alias.server_name(),`
feat: improved state store 2020-12-19 15:00:11 +00:00			`federation::query::get_room_information::v1::Request { room_alias },`
			`)`
			`.await?;`
feat: first steps towards joining rooms over federation 2020-08-14 09:31:31 +00:00
Keep track of State at event for state resolution feat: first steps towards joining rooms over federation Add state-res as a dependency of conduit Add reverse_topological_power_sort before append_pdu Implement statehashstatid_pduid tree for keeping track of state Clean up implementation of state_hash as key for tracking state 2020-08-06 12:29:59 +00:00			`return Ok(get_alias::Response::new(response.room_id, response.servers).into());`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00			`}`

feat: implement appservices this also reverts some stateres changes 2020-12-08 09:33:44 +00:00			`let mut room_id = None;`
			`match db.rooms.id_from_alias(&room_alias)? {`
			`Some(r) => room_id = Some(r),`
			`None => {`
feat: swappable database backend 2021-06-08 16:10:00 +00:00			`let iter = db.appservice.iter_all()?;`
			`for (_id, registration) in iter.filter_map(\|r\| r.ok()) {`
fix: don't always query aliases of appservices only do so if the alias matches the regex in the registration file 2021-03-03 20:41:26 +00:00			`let aliases = registration`
			`.get("namespaces")`
			`.and_then(\|ns\| ns.get("aliases"))`
fix: join appservice room with alias 2021-03-18 11:03:15 +00:00			`.and_then(\|aliases\| aliases.as_sequence())`
			`.map_or_else(Vec::new, \|aliases\| {`
			`aliases`
			`.iter()`
Use try operator for Option more 2021-06-17 18:37:07 +00:00			`.filter_map(\|aliases\| Regex::new(aliases.get("regex")?.as_str()?).ok())`
fix: join appservice room with alias 2021-03-18 11:03:15 +00:00			`.collect::<Vec<_>>()`
			`});`
fix: don't always query aliases of appservices only do so if the alias matches the regex in the registration file 2021-03-03 20:41:26 +00:00
fix: join appservice room with alias 2021-03-18 11:03:15 +00:00			`if aliases`
			`.iter()`
			`.any(\|aliases\| aliases.is_match(room_alias.as_str()))`
fix: don't always query aliases of appservices only do so if the alias matches the regex in the registration file 2021-03-03 20:41:26 +00:00			`&& db`
			`.sending`
			`.send_appservice_request(`
			`&db.globals,`
			`registration,`
			`appservice::query::query_room_alias::v1::Request { room_alias },`
			`)`
			`.await`
			`.is_ok()`
feat: implement appservices this also reverts some stateres changes 2020-12-08 09:33:44 +00:00			`{`
			`room_id = Some(db.rooms.id_from_alias(&room_alias)?.ok_or_else(\|\| {`
			`Error::bad_config("Appservice lied to us. Room does not exist.")`
			`})?);`
			`break;`
			`}`
			`}`
			`}`
			`};`

			`let room_id = match room_id {`
			`Some(room_id) => room_id,`
			`None => {`
			`return Err(Error::BadRequest(`
			`ErrorKind::NotFound,`
			`"Room with alias not found.",`
			`))`
			`}`
			`};`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00
improvement: try out multiple servers when joining remote rooms 2020-09-14 09:00:31 +00:00			`Ok(get_alias::Response::new(room_id, vec![db.globals.server_name().to_owned()]).into())`
refactor: put endpoints into modules 2020-07-30 16:14:47 +00:00			`}`