magmaus3/continuwuity
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

refactor to room_state_get_content() for serde_json::from_ elim

Browse source 
Signed-off-by: Jason Volk <jason@zemos.net>
This commit is contained in:
Jason Volk 2024-10-03 09:44:43 +00:00 • committed by strawberry
parent 68315ac112
commit f7af6966b7
7 changed files with 91 additions and 142 deletions
Download patch file Download diff file Expand all files Collapse all files

78
src/api/client/membership.rs
View file

@ -389,17 +389,12 @@ pub(crate) async fn kick_user_route(
let state_lock = services.rooms.state.mutex.lock(&body.room_id).await; let state_lock = services.rooms.state.mutex.lock(&body.room_id).await;
let mut event: RoomMemberEventContent = serde_json::from_str( let mut event: RoomMemberEventContent = services
services .rooms
.rooms .state_accessor
.state_accessor .room_state_get_content(&body.room_id, &StateEventType::RoomMember, body.user_id.as_ref())
.room_state_get(&body.room_id, &StateEventType::RoomMember, body.user_id.as_ref()) .await
.await .map_err(|_| err!(Request(BadState("Cannot kick member that's not in the room."))))?;
.map_err(|_| err!(Request(BadState("Cannot kick member that's not in the room."))))?
.content
.get(),
)
.map_err(|_| err!(Database("Invalid member event in database.")))?;
event.membership = MembershipState::Leave; event.membership = MembershipState::Leave;
event.reason.clone_from(&body.reason); event.reason.clone_from(&body.reason);
@ -442,10 +437,10 @@ pub(crate) async fn ban_user_route(
let event = services let event = services
.rooms .rooms
.state_accessor .state_accessor
.room_state_get(&body.room_id, &StateEventType::RoomMember, body.user_id.as_ref()) .room_state_get_content(&body.room_id, &StateEventType::RoomMember, body.user_id.as_ref())
.await .await
.map_or( .map_or_else(
Ok(RoomMemberEventContent { |_| RoomMemberEventContent {
membership: MembershipState::Ban, membership: MembershipState::Ban,
displayname: None, displayname: None,
avatar_url: None, avatar_url: None,
@ -454,21 +449,17 @@ pub(crate) async fn ban_user_route(
blurhash: blurhash.clone(), blurhash: blurhash.clone(),
reason: body.reason.clone(), reason: body.reason.clone(),
join_authorized_via_users_server: None, join_authorized_via_users_server: None,
}),
|event| {
serde_json::from_str(event.content.get())
.map(|event: RoomMemberEventContent| RoomMemberEventContent {
membership: MembershipState::Ban,
displayname: None,
avatar_url: None,
blurhash: blurhash.clone(),
reason: body.reason.clone(),
join_authorized_via_users_server: None,
..event
})
.map_err(|e| err!(Database("Invalid member event in database: {e:?}")))
}, },
)?; |event| RoomMemberEventContent {
membership: MembershipState::Ban,
displayname: None,
avatar_url: None,
blurhash: blurhash.clone(),
reason: body.reason.clone(),
join_authorized_via_users_server: None,
..event
},
);
services services
.rooms .rooms
@ -503,17 +494,12 @@ pub(crate) async fn unban_user_route(
let state_lock = services.rooms.state.mutex.lock(&body.room_id).await; let state_lock = services.rooms.state.mutex.lock(&body.room_id).await;
let mut event: RoomMemberEventContent = serde_json::from_str( let mut event: RoomMemberEventContent = services
services .rooms
.rooms .state_accessor
.state_accessor .room_state_get_content(&body.room_id, &StateEventType::RoomMember, body.user_id.as_ref())
.room_state_get(&body.room_id, &StateEventType::RoomMember, body.user_id.as_ref()) .await
.await .map_err(|_| err!(Request(BadState("Cannot unban a user who is not banned."))))?;
.map_err(|_| err!(Request(BadState("Cannot unban a user who is not banned."))))?
.content
.get(),
)
.map_err(|e| err!(Database("Invalid member event in database: {e:?}")))?;
event.membership = MembershipState::Leave; event.membership = MembershipState::Leave;
event.reason.clone_from(&body.reason); event.reason.clone_from(&body.reason);
@ -1650,14 +1636,13 @@ pub async fn leave_room(services: &Services, user_id: &UserId, room_id: &RoomId,
} else { } else {
let state_lock = services.rooms.state.mutex.lock(room_id).await; let state_lock = services.rooms.state.mutex.lock(room_id).await;
let member_event = services let Ok(mut event) = services
.rooms .rooms
.state_accessor .state_accessor
.room_state_get(room_id, &StateEventType::RoomMember, user_id.as_str()) .room_state_get_content::<RoomMemberEventContent>(room_id, &StateEventType::RoomMember, user_id.as_str())
.await; .await
else {
// Fix for broken rooms // Fix for broken rooms
let Ok(member_event) = member_event else {
error!("Trying to leave a room you are not a member of."); error!("Trying to leave a room you are not a member of.");
services services
@ -1677,9 +1662,6 @@ pub async fn leave_room(services: &Services, user_id: &UserId, room_id: &RoomId,
return Ok(()); return Ok(());
}; };
let mut event: RoomMemberEventContent = serde_json::from_str(member_event.content.get())
.map_err(|e| err!(Database(error!("Invalid room member event in database: {e}"))))?;
event.membership = MembershipState::Leave; event.membership = MembershipState::Leave;
event.reason = reason; event.reason = reason;

57
src/api/client/profile.rs
View file

@ -301,10 +301,10 @@ pub async fn update_displayname(
// Send a new join membership event into all joined rooms // Send a new join membership event into all joined rooms
let mut joined_rooms = Vec::new(); let mut joined_rooms = Vec::new();
for room_id in all_joined_rooms { for room_id in all_joined_rooms {
let Ok(event) = services let Ok(content) = services
.rooms .rooms
.state_accessor .state_accessor
.room_state_get(room_id, &StateEventType::RoomMember, user_id.as_str()) .room_state_get_content(room_id, &StateEventType::RoomMember, user_id.as_str())
.await .await
else { else {
continue; continue;
@ -315,7 +315,7 @@ pub async fn update_displayname(
content: to_raw_value(&RoomMemberEventContent { content: to_raw_value(&RoomMemberEventContent {
displayname: displayname.clone(), displayname: displayname.clone(),
join_authorized_via_users_server: None, join_authorized_via_users_server: None,
..serde_json::from_str(event.content.get()).expect("Database contains invalid PDU.") ..content
}) })
.expect("event is valid, we just created it"), .expect("event is valid, we just created it"),
unsigned: None, unsigned: None,
@ -354,35 +354,28 @@ pub async fn update_avatar_url(
.iter() .iter()
.try_stream() .try_stream()
.and_then(|room_id: &OwnedRoomId| async move { .and_then(|room_id: &OwnedRoomId| async move {
Ok(( let content = services
PduBuilder { .rooms
event_type: TimelineEventType::RoomMember, .state_accessor
content: to_raw_value(&RoomMemberEventContent { .room_state_get_content(room_id, &StateEventType::RoomMember, user_id.as_str())
avatar_url: avatar_url.clone(), .await?;
blurhash: blurhash.clone(),
join_authorized_via_users_server: None, let pdu = PduBuilder {
..serde_json::from_str( event_type: TimelineEventType::RoomMember,
services content: to_raw_value(&RoomMemberEventContent {
.rooms avatar_url: avatar_url.clone(),
.state_accessor blurhash: blurhash.clone(),
.room_state_get(room_id, &StateEventType::RoomMember, user_id.as_str()) join_authorized_via_users_server: None,
.await ..content
.map_err(|_| { })
Error::bad_database("Tried to send avatar URL update for user not in the room.") .expect("event is valid, we just created it"),
})? unsigned: None,
.content state_key: Some(user_id.to_string()),
.get(), redacts: None,
) timestamp: None,
.map_err(|_| Error::bad_database("Database contains invalid PDU."))? };
})
.expect("event is valid, we just created it"), Ok((pdu, room_id))
unsigned: None,
state_key: Some(user_id.to_string()),
redacts: None,
timestamp: None,
},
room_id,
))
}) })
.ignore_err() .ignore_err()
.collect() .collect()

32
src/api/client/room.rs
View file

@ -664,16 +664,12 @@ pub(crate) async fn upgrade_room_route(
let state_lock = services.rooms.state.mutex.lock(&replacement_room).await; let state_lock = services.rooms.state.mutex.lock(&replacement_room).await;
// Get the old room creation event // Get the old room creation event
let mut create_event_content = serde_json::from_str::<CanonicalJsonObject>( let mut create_event_content: CanonicalJsonObject = services
services .rooms
.rooms .state_accessor
.state_accessor .room_state_get_content(&body.room_id, &StateEventType::RoomCreate, "")
.room_state_get(&body.room_id, &StateEventType::RoomCreate, "") .await
.await .map_err(|_| err!(Database("Found room without m.room.create event.")))?;
.map_err(|_| err!(Database("Found room without m.room.create event.")))?
.content
.get(),
)?;
// Use the m.room.tombstone event as the predecessor // Use the m.room.tombstone event as the predecessor
let predecessor = Some(ruma::events::room::create::PreviousRoom::new( let predecessor = Some(ruma::events::room::create::PreviousRoom::new(
@ -825,16 +821,12 @@ pub(crate) async fn upgrade_room_route(
} }
// Get the old room power levels // Get the old room power levels
let mut power_levels_event_content: RoomPowerLevelsEventContent = serde_json::from_str( let mut power_levels_event_content: RoomPowerLevelsEventContent = services
services .rooms
.rooms .state_accessor
.state_accessor .room_state_get_content(&body.room_id, &StateEventType::RoomPowerLevels, "")
.room_state_get(&body.room_id, &StateEventType::RoomPowerLevels, "") .await
.await .map_err(|_| err!(Database("Found room without m.room.power_levels event.")))?;
.map_err(|_| err!(Database("Found room without m.room.create event.")))?
.content
.get(),
)?;
// Setting events_default and invite to the greater of 50 and users_default + 1 // Setting events_default and invite to the greater of 50 and users_default + 1
let new_level = max( let new_level = max(

27
src/service/rooms/alias/mod.rs
View file

@ -190,32 +190,31 @@ impl Service {
// Always allow the server service account to remove the alias, since there may not be an admin room // Always allow the server service account to remove the alias, since there may not be an admin room
|| server_user == user_id || server_user == user_id
{ {
Ok(true) return Ok(true);
// Checking whether the user is able to change canonical aliases of the }
// room
} else if let Ok(event) = self // Checking whether the user is able to change canonical aliases of the room
if let Ok(content) = self
.services .services
.state_accessor .state_accessor
.room_state_get(&room_id, &StateEventType::RoomPowerLevels, "") .room_state_get_content::<RoomPowerLevelsEventContent>(&room_id, &StateEventType::RoomPowerLevels, "")
.await .await
{ {
serde_json::from_str(event.content.get()) return Ok(RoomPowerLevels::from(content).user_can_send_state(user_id, StateEventType::RoomCanonicalAlias));
.map_err(|_| Error::bad_database("Invalid event content for m.room.power_levels")) }
.map(|content: RoomPowerLevelsEventContent| {
RoomPowerLevels::from(content).user_can_send_state(user_id, StateEventType::RoomCanonicalAlias)
})
// If there is no power levels event, only the room creator can change // If there is no power levels event, only the room creator can change
// canonical aliases // canonical aliases
} else if let Ok(event) = self if let Ok(event) = self
.services .services
.state_accessor .state_accessor
.room_state_get(&room_id, &StateEventType::RoomCreate, "") .room_state_get(&room_id, &StateEventType::RoomCreate, "")
.await .await
{ {
Ok(event.sender == user_id) return Ok(event.sender == user_id);
} else {
Err(Error::bad_database("Room has no m.room.create event"))
} }
Err!(Database("Room has no m.room.create event"))
} }
async fn who_created_alias(&self, alias: &RoomAliasId) -> Result<OwnedUserId> { async fn who_created_alias(&self, alias: &RoomAliasId) -> Result<OwnedUserId> {

9
src/service/rooms/spaces/mod.rs
View file

@ -380,14 +380,9 @@ impl Service {
let join_rule = self let join_rule = self
.services .services
.state_accessor .state_accessor
.room_state_get(room_id, &StateEventType::RoomJoinRules, "") .room_state_get_content(room_id, &StateEventType::RoomJoinRules, "")
.await .await
.map_or(JoinRule::Invite, |s| { .map_or(JoinRule::Invite, |c: RoomJoinRulesEventContent| c.join_rule);
serde_json::from_str(s.content.get())
.map(|c: RoomJoinRulesEventContent| c.join_rule)
.map_err(|e| err!(Database(error!("Invalid room join rule event in database: {e}"))))
.unwrap()
});
let allowed_room_ids = self let allowed_room_ids = self
.services .services

23
src/service/rooms/state_accessor/mod.rs
View file

@ -338,14 +338,13 @@ impl Service {
.map(|c: RoomNameEventContent| c.name) .map(|c: RoomNameEventContent| c.name)
} }
pub async fn get_avatar(&self, room_id: &RoomId) -> ruma::JsOption<RoomAvatarEventContent> { pub async fn get_avatar(&self, room_id: &RoomId) -> JsOption<RoomAvatarEventContent> {
self.room_state_get(room_id, &StateEventType::RoomAvatar, "") let content = self
.room_state_get_content(room_id, &StateEventType::RoomAvatar, "")
.await .await
.map_or(ruma::JsOption::Undefined, |s| { .ok();
serde_json::from_str(s.content.get())
.map_err(|_| Error::bad_database("Invalid room avatar event in database.")) JsOption::from_option(content)
.unwrap()
})
} }
pub async fn get_member(&self, room_id: &RoomId, user_id: &UserId) -> Result<RoomMemberEventContent> { pub async fn get_member(&self, room_id: &RoomId, user_id: &UserId) -> Result<RoomMemberEventContent> {
@ -416,16 +415,10 @@ impl Service {
&self, redacts: &EventId, sender: &UserId, room_id: &RoomId, federation: bool, &self, redacts: &EventId, sender: &UserId, room_id: &RoomId, federation: bool,
) -> Result<bool> { ) -> Result<bool> {
if let Ok(event) = self if let Ok(event) = self
.room_state_get(room_id, &StateEventType::RoomPowerLevels, "") .room_state_get_content::<RoomPowerLevelsEventContent>(room_id, &StateEventType::RoomPowerLevels, "")
.await .await
{ {
let Ok(event) = serde_json::from_str(event.content.get()) let event: RoomPowerLevels = event.into();
.map(|content: RoomPowerLevelsEventContent| content.into())
.map(|event: RoomPowerLevels| event)
else {
return Ok(false);
};
Ok(event.user_can_redact_event_of_other(sender) Ok(event.user_can_redact_event_of_other(sender)
|| event.user_can_redact_own_event(sender) || event.user_can_redact_own_event(sender)
&& if let Ok(pdu) = self.services.timeline.get_pdu(redacts).await { && if let Ok(pdu) = self.services.timeline.get_pdu(redacts).await {

7
src/service/rooms/timeline/mod.rs
View file

@ -1061,13 +1061,8 @@ impl Service {
let power_levels: RoomPowerLevelsEventContent = self let power_levels: RoomPowerLevelsEventContent = self
.services .services
.state_accessor .state_accessor
.room_state_get(room_id, &StateEventType::RoomPowerLevels, "") .room_state_get_content(room_id, &StateEventType::RoomPowerLevels, "")
.await .await
.map(|ev| {
serde_json::from_str(ev.content.get())
.map_err(|_| Error::bad_database("invalid m.room.power_levels event"))
.unwrap()
})
.unwrap_or_default(); .unwrap_or_default();
let room_mods = power_levels.users.iter().filter_map(|(user_id, level)| { let room_mods = power_levels.users.iter().filter_map(|(user_id, level)| {