char
/
conduit
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
conduit/src/client_server/directory.rs

335 lines
12 KiB
Rust
Raw Normal View History

refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
use super::State;
feat: first steps towards joining rooms over federation
2020-08-14 09:31:31 +00:00
use crate::{server_server, ConduitResult, Database, Error, Result, Ruma};
improvement: more logging
2020-11-15 11:17:21 +00:00
use log::info;
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
use ruma::{
feat: first steps towards joining rooms over federation
2020-08-14 09:31:31 +00:00
api::{
client::{
error::ErrorKind,
r0::{
directory::{
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
get_public_rooms, get_public_rooms_filtered, get_room_visibility,
feat: first steps towards joining rooms over federation
2020-08-14 09:31:31 +00:00
set_room_visibility,
},
room,
feat: handle /publicRooms pagination
2020-07-30 20:09:11 +00:00
},
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
},
feat: first steps towards joining rooms over federation
2020-08-14 09:31:31 +00:00
federation,
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
},
Reformat imports and fix clippy warnings
2020-11-08 19:45:52 +00:00
directory::{Filter, IncomingFilter, IncomingRoomNetwork, PublicRoomsChunk, RoomNetwork},
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
events::{
room::{avatar, canonical_alias, guest_access, history_visibility, name, topic},
EventType,
},
improvement: try out multiple servers when joining remote rooms
2020-09-14 09:00:31 +00:00
Raw, ServerName,
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
};
#[cfg(feature = "conduit_bin")]
use rocket::{get, post, put};
#[cfg_attr(
feature = "conduit_bin",
feat: handle /publicRooms pagination
2020-07-30 20:09:11 +00:00
post("/_matrix/client/r0/publicRooms", data = "<body>")
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
)]
feat: handle /publicRooms pagination
2020-07-30 20:09:11 +00:00
pub async fn get_public_rooms_filtered_route(
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
db: State<'_, Database>,
Update ruma version
2020-09-08 15:32:03 +00:00
body: Ruma<get_public_rooms_filtered::Request<'_>>,
feat: handle /publicRooms pagination
2020-07-30 20:09:11 +00:00
) -> ConduitResult<get_public_rooms_filtered::Response> {
Use helper instead of route for get_public_rooms_filtered
2020-08-23 12:32:43 +00:00
get_public_rooms_filtered_helper(
&db,
fix: room list over federation
2020-09-14 09:42:16 +00:00
body.server.as_deref(),
body.limit,
body.since.as_deref(),
&body.filter,
&body.room_network,
Use helper instead of route for get_public_rooms_filtered
2020-08-23 12:32:43 +00:00
)
.await
}
#[cfg_attr(
feature = "conduit_bin",
get("/_matrix/client/r0/publicRooms", data = "<body>")
)]
pub async fn get_public_rooms_route(
db: State<'_, Database>,
Update ruma version
2020-09-08 15:32:03 +00:00
body: Ruma<get_public_rooms::Request<'_>>,
Use helper instead of route for get_public_rooms_filtered
2020-08-23 12:32:43 +00:00
) -> ConduitResult<get_public_rooms::Response> {
Fix review issues, move state-res to spec-comp branch
2020-08-26 15:15:52 +00:00
let response = get_public_rooms_filtered_helper(
Use helper instead of route for get_public_rooms_filtered
2020-08-23 12:32:43 +00:00
&db,
improvement: try out multiple servers when joining remote rooms
2020-09-14 09:00:31 +00:00
body.server.as_deref(),
body.limit,
body.since.as_deref(),
fix: room list over federation
2020-09-14 09:42:16 +00:00
&IncomingFilter::default(),
&IncomingRoomNetwork::Matrix,
Use helper instead of route for get_public_rooms_filtered
2020-08-23 12:32:43 +00:00
)
.await?
.0;
Ok(get_public_rooms::Response {
Fix review issues, move state-res to spec-comp branch
2020-08-26 15:15:52 +00:00
chunk: response.chunk,
prev_batch: response.prev_batch,
next_batch: response.next_batch,
total_room_count_estimate: response.total_room_count_estimate,
Use helper instead of route for get_public_rooms_filtered
2020-08-23 12:32:43 +00:00
}
.into())
}
#[cfg_attr(
feature = "conduit_bin",
put("/_matrix/client/r0/directory/list/room/<_>", data = "<body>")
)]
pub async fn set_room_visibility_route(
db: State<'_, Database>,
Update ruma version
2020-09-08 15:32:03 +00:00
body: Ruma<set_room_visibility::Request<'_>>,
Use helper instead of route for get_public_rooms_filtered
2020-08-23 12:32:43 +00:00
) -> ConduitResult<set_room_visibility::Response> {
improvement: more logging
2020-11-15 11:17:21 +00:00
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
Use helper instead of route for get_public_rooms_filtered
2020-08-23 12:32:43 +00:00
match body.visibility {
improvement: more logging
2020-11-15 11:17:21 +00:00
room::Visibility::Public => {
db.rooms.set_public(&body.room_id, true)?;
info!("{} made {} public", sender_user, body.room_id);
}
Use helper instead of route for get_public_rooms_filtered
2020-08-23 12:32:43 +00:00
room::Visibility::Private => db.rooms.set_public(&body.room_id, false)?,
}
improvement: flush after every request that manipulates the db
2020-10-21 19:28:02 +00:00
db.flush().await?;
Use helper instead of route for get_public_rooms_filtered
2020-08-23 12:32:43 +00:00
Ok(set_room_visibility::Response.into())
}
#[cfg_attr(
feature = "conduit_bin",
get("/_matrix/client/r0/directory/list/room/<_>", data = "<body>")
)]
pub async fn get_room_visibility_route(
db: State<'_, Database>,
Update ruma version
2020-09-08 15:32:03 +00:00
body: Ruma<get_room_visibility::Request<'_>>,
Use helper instead of route for get_public_rooms_filtered
2020-08-23 12:32:43 +00:00
) -> ConduitResult<get_room_visibility::Response> {
Ok(get_room_visibility::Response {
visibility: if db.rooms.is_public_room(&body.room_id)? {
room::Visibility::Public
} else {
room::Visibility::Private
},
}
.into())
}
pub async fn get_public_rooms_filtered_helper(
db: &Database,
improvement: try out multiple servers when joining remote rooms
2020-09-14 09:00:31 +00:00
server: Option<&ServerName>,
Use helper instead of route for get_public_rooms_filtered
2020-08-23 12:32:43 +00:00
limit: Option<js_int::UInt>,
since: Option<&str>,
fix: filter public room dir
2020-09-14 14:23:15 +00:00
filter: &IncomingFilter,
fix: room list over federation
2020-09-14 09:42:16 +00:00
_network: &IncomingRoomNetwork,
Use helper instead of route for get_public_rooms_filtered
2020-08-23 12:32:43 +00:00
) -> ConduitResult<get_public_rooms_filtered::Response> {
if let Some(other_server) = server
feat: first steps towards joining rooms over federation
2020-08-14 09:31:31 +00:00
.clone()
Use helper instead of route for get_public_rooms_filtered
2020-08-23 12:32:43 +00:00
.filter(|server| *server != db.globals.server_name().as_str())
feat: first steps towards joining rooms over federation
2020-08-14 09:31:31 +00:00
{
let response = server_server::send_request(
feat: send messages over federation
2020-09-14 18:23:19 +00:00
&db.globals,
fix: send to all servers and fix media store
2020-09-15 06:16:20 +00:00
other_server.to_owned(),
fix: filter public room dir
2020-09-14 14:23:15 +00:00
federation::directory::get_public_rooms_filtered::v1::Request {
Use helper instead of route for get_public_rooms_filtered
2020-08-23 12:32:43 +00:00
limit,
since: since.as_deref(),
fix: filter public room dir
2020-09-14 14:23:15 +00:00
filter: Filter {
generic_search_term: filter.generic_search_term.as_deref(),
},
fix: room list over federation
2020-09-14 09:42:16 +00:00
room_network: RoomNetwork::Matrix,
feat: first steps towards joining rooms over federation
2020-08-14 09:31:31 +00:00
},
)
.await?;
return Ok(get_public_rooms_filtered::Response {
chunk: response
.chunk
.into_iter()
.map(|c| {
// Convert ruma::api::federation::directory::get_public_rooms::v1::PublicRoomsChunk
// to ruma::api::client::r0::directory::PublicRoomsChunk
Ok::<_, Error>(
serde_json::from_str(
&serde_json::to_string(&c)
.expect("PublicRoomsChunk::to_string always works"),
)
.expect("federation and client-server PublicRoomsChunk are the same type"),
)
})
.filter_map(|r| r.ok())
.collect(),
prev_batch: response.prev_batch,
next_batch: response.next_batch,
total_room_count_estimate: response.total_room_count_estimate,
}
.into());
}
Use helper instead of route for get_public_rooms_filtered
2020-08-23 12:32:43 +00:00
let limit = limit.map_or(10, u64::from);
let mut num_since = 0_u64;
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
Use helper instead of route for get_public_rooms_filtered
2020-08-23 12:32:43 +00:00
if let Some(s) = &since {
feat: handle /publicRooms pagination
2020-07-30 20:09:11 +00:00
let mut characters = s.chars();
let backwards = match characters.next() {
Some('n') => false,
Some('p') => true,
_ => {
return Err(Error::BadRequest(
ErrorKind::InvalidParam,
"Invalid `since` token",
))
}
};
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
Use helper instead of route for get_public_rooms_filtered
2020-08-23 12:32:43 +00:00
num_since = characters
feat: handle /publicRooms pagination
2020-07-30 20:09:11 +00:00
.collect::<String>()
.parse()
.map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "Invalid `since` token."))?;
if backwards {
Use helper instead of route for get_public_rooms_filtered
2020-08-23 12:32:43 +00:00
num_since = num_since.saturating_sub(limit);
feat: handle /publicRooms pagination
2020-07-30 20:09:11 +00:00
}
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
}
feat: handle /publicRooms pagination
2020-07-30 20:09:11 +00:00
let mut all_rooms =
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
db.rooms
.public_rooms()
.map(|room_id| {
let room_id = room_id?;
// TODO: Do not load full state?
let state = db.rooms.room_state_full(&room_id)?;
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
let chunk = PublicRoomsChunk {
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
aliases: Vec::new(),
canonical_alias: state
.get(&(EventType::RoomCanonicalAlias, "".to_owned()))
.map_or(Ok::<_, Error>(None), |s| {
Ok(serde_json::from_value::<
Raw<canonical_alias::CanonicalAliasEventContent>,
>(s.content.clone())
.expect("from_value::<Raw<..>> can never fail")
.deserialize()
.map_err(|_| {
Error::bad_database("Invalid canonical alias event in database.")
})?
.alias)
})?,
name: state.get(&(EventType::RoomName, "".to_owned())).map_or(
Ok::<_, Error>(None),
|s| {
Ok(serde_json::from_value::<Raw<name::NameEventContent>>(
s.content.clone(),
)
.expect("from_value::<Raw<..>> can never fail")
.deserialize()
.map_err(|_| {
Error::bad_database("Invalid room name event in database.")
})?
.name()
.map(|n| n.to_owned()))
},
)?,
num_joined_members: (db.rooms.room_members(&room_id).count() as u32).into(),
room_id,
topic: state.get(&(EventType::RoomTopic, "".to_owned())).map_or(
Ok::<_, Error>(None),
|s| {
Ok(Some(
serde_json::from_value::<Raw<topic::TopicEventContent>>(
s.content.clone(),
)
.expect("from_value::<Raw<..>> can never fail")
.deserialize()
.map_err(|_| {
Error::bad_database("Invalid room topic event in database.")
})?
.topic,
))
},
)?,
world_readable: state
.get(&(EventType::RoomHistoryVisibility, "".to_owned()))
.map_or(Ok::<_, Error>(false), |s| {
Ok(serde_json::from_value::<
Raw<history_visibility::HistoryVisibilityEventContent>,
>(s.content.clone())
.expect("from_value::<Raw<..>> can never fail")
.deserialize()
.map_err(|_| {
Error::bad_database(
"Invalid room history visibility event in database.",
)
})?
.history_visibility
== history_visibility::HistoryVisibility::WorldReadable)
})?,
guest_can_join: state
.get(&(EventType::RoomGuestAccess, "".to_owned()))
.map_or(Ok::<_, Error>(false), |s| {
Ok(
serde_json::from_value::<Raw<guest_access::GuestAccessEventContent>>(
s.content.clone(),
)
.expect("from_value::<Raw<..>> can never fail")
.deserialize()
.map_err(|_| {
Error::bad_database("Invalid room guest access event in database.")
})?
.guest_access
== guest_access::GuestAccess::CanJoin,
)
})?,
avatar_url: state
.get(&(EventType::RoomAvatar, "".to_owned()))
.map(|s| {
Ok::<_, Error>(
serde_json::from_value::<Raw<avatar::AvatarEventContent>>(
s.content.clone(),
)
.expect("from_value::<Raw<..>> can never fail")
.deserialize()
.map_err(|_| {
Error::bad_database("Invalid room avatar event in database.")
})?
.url,
)
})
.transpose()?,
};
Ok(chunk)
})
.filter_map(|r: Result<_>| r.ok()) // Filter out buggy rooms
// We need to collect all, so we can sort by member count
.collect::<Vec<_>>();
feat: handle /publicRooms pagination
2020-07-30 20:09:11 +00:00
all_rooms.sort_by(|l, r| r.num_joined_members.cmp(&l.num_joined_members));
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
feat: handle /publicRooms pagination
2020-07-30 20:09:11 +00:00
let total_room_count_estimate = (all_rooms.len() as u32).into();
let chunk = all_rooms
.into_iter()
Use helper instead of route for get_public_rooms_filtered
2020-08-23 12:32:43 +00:00
.skip(num_since as usize)
feat: handle /publicRooms pagination
2020-07-30 20:09:11 +00:00
.take(limit as usize)
.collect::<Vec<_>>();
Use helper instead of route for get_public_rooms_filtered
2020-08-23 12:32:43 +00:00
let prev_batch = if num_since == 0 {
feat: handle /publicRooms pagination
2020-07-30 20:09:11 +00:00
None
} else {
Use helper instead of route for get_public_rooms_filtered
2020-08-23 12:32:43 +00:00
Some(format!("p{}", num_since))
feat: handle /publicRooms pagination
2020-07-30 20:09:11 +00:00
};
let next_batch = if chunk.len() < limit as usize {
None
} else {
Use helper instead of route for get_public_rooms_filtered
2020-08-23 12:32:43 +00:00
Some(format!("n{}", num_since + limit))
feat: handle /publicRooms pagination
2020-07-30 20:09:11 +00:00
};
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
Ok(get_public_rooms_filtered::Response {
chunk,
feat: handle /publicRooms pagination
2020-07-30 20:09:11 +00:00
prev_batch,
next_batch,
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
total_room_count_estimate: Some(total_room_count_estimate),
}
.into())
}