backups/grapevine
1
0
Fork 0
mirror of https://gitlab.computer.surgery/matrix/grapevine.git synced 2025-12-16 15:21:24 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

use event content in account_data service api instead of full events

Browse source 
This eliminates the possibility of passing an event that has a
mismatching type, reducing the space of possible invalid states.
This commit is contained in:
Olivia Lee 2025-03-23 14:45:33 -07:00
parent 66210bc32d
commit b82458a460
No known key found for this signature in database
GPG key ID: 54D568A15B9CD1F9
15 changed files with 277 additions and 240 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -12,8 +12,7 @@ use ruma::{
uiaa::{AuthFlow, AuthType, UiaaInfo}, uiaa::{AuthFlow, AuthType, UiaaInfo},
}, },
events::{ events::{
room::message::RoomMessageEventContent, AnyGlobalAccountDataEvent, room::message::RoomMessageEventContent, GlobalAccountDataEventType,
GlobalAccountDataEventType,
}, },
push, push,
serde::Raw, serde::Raw,
@ -240,13 +239,13 @@ pub(crate) async fn register_route(
services().account_data.update_global( services().account_data.update_global(
&user_id, &user_id,
&GlobalAccountDataEventType::PushRules, &GlobalAccountDataEventType::PushRules,
&Raw::new(&ruma::events::push_rules::PushRulesEvent { &Raw::new(
content: ruma::events::push_rules::PushRulesEventContent { &ruma::events::push_rules::PushRulesEventContent {
global: push::Ruleset::server_default(&user_id), global: push::Ruleset::server_default(&user_id),
}, }
}) .into(),
.expect("constructed event should be valid") )
.cast::<AnyGlobalAccountDataEvent>(), .expect("constructed event should be valid"),
)?; )?;
// Inhibit login does not work for guests // Inhibit login does not work for guests

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

@ -1,19 +1,10 @@
use ruma::{ use ruma::api::client::{
api::client::{ config::{
config::{ get_global_account_data, get_room_account_data,
get_global_account_data, get_room_account_data, set_global_account_data, set_room_account_data,
set_global_account_data, set_room_account_data,
},
error::ErrorKind,
}, },
events::{ error::ErrorKind,
AnyGlobalAccountDataEvent, AnyGlobalAccountDataEventContent,
AnyRoomAccountDataEvent, AnyRoomAccountDataEventContent,
},
serde::Raw,
}; };
use serde::Deserialize;
use serde_json::json;
use crate::{services, Ar, Error, Ra, Result}; use crate::{services, Ar, Error, Ra, Result};
@ -25,17 +16,10 @@ pub(crate) async fn set_global_account_data_route(
) -> Result<Ra<set_global_account_data::v3::Response>> { ) -> Result<Ra<set_global_account_data::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated"); let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let event = Raw::new(&json!({
"type": &body.event_type,
"content": &body.data,
}))
.map_err(|_| Error::BadRequest(ErrorKind::BadJson, "Data is invalid."))?
.cast::<AnyGlobalAccountDataEvent>();
services().account_data.update_global( services().account_data.update_global(
sender_user, sender_user,
&body.event_type, &body.event_type,
&event, &body.data,
)?; )?;
Ok(Ra(set_global_account_data::v3::Response {})) Ok(Ra(set_global_account_data::v3::Response {}))
@ -49,18 +33,11 @@ pub(crate) async fn set_room_account_data_route(
) -> Result<Ra<set_room_account_data::v3::Response>> { ) -> Result<Ra<set_room_account_data::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated"); let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let event = Raw::new(&json!({
"type": &body.event_type,
"content": &body.data,
}))
.map_err(|_| Error::BadRequest(ErrorKind::BadJson, "Data is invalid."))?
.cast::<AnyRoomAccountDataEvent>();
services().account_data.update_room( services().account_data.update_room(
&body.room_id, &body.room_id,
sender_user, sender_user,
&body.event_type, &body.event_type,
&event, &body.data,
)?; )?;
Ok(Ra(set_room_account_data::v3::Response {})) Ok(Ra(set_room_account_data::v3::Response {}))
@ -74,16 +51,11 @@ pub(crate) async fn get_global_account_data_route(
) -> Result<Ra<get_global_account_data::v3::Response>> { ) -> Result<Ra<get_global_account_data::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated"); let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let event = services() let account_data = services()
.account_data .account_data
.get_global(sender_user, &body.event_type)? .get_global(sender_user, &body.event_type)?
.ok_or(Error::BadRequest(ErrorKind::NotFound, "Data not found."))?; .ok_or(Error::BadRequest(ErrorKind::NotFound, "Data not found."))?;
let account_data = event
.deserialize_as::<ExtractGlobalEventContent>()
.map_err(|_| Error::bad_database("Invalid account data event in db."))?
.content;
Ok(Ra(get_global_account_data::v3::Response { Ok(Ra(get_global_account_data::v3::Response {
account_data, account_data,
})) }))
@ -97,27 +69,12 @@ pub(crate) async fn get_room_account_data_route(
) -> Result<Ra<get_room_account_data::v3::Response>> { ) -> Result<Ra<get_room_account_data::v3::Response>> {
let sender_user = body.sender_user.as_ref().expect("user is authenticated"); let sender_user = body.sender_user.as_ref().expect("user is authenticated");
let event = services() let account_data = services()
.account_data .account_data
.get_room(&body.room_id, sender_user, &body.event_type)? .get_room(&body.room_id, sender_user, &body.event_type)?
.ok_or(Error::BadRequest(ErrorKind::NotFound, "Data not found."))?; .ok_or(Error::BadRequest(ErrorKind::NotFound, "Data not found."))?;
let account_data = event
.deserialize_as::<ExtractRoomEventContent>()
.map_err(|_| Error::bad_database("Invalid account data event in db."))?
.content;
Ok(Ra(get_room_account_data::v3::Response { Ok(Ra(get_room_account_data::v3::Response {
account_data, account_data,
})) }))
} }
#[derive(Deserialize)]
struct ExtractRoomEventContent {
content: Raw<AnyRoomAccountDataEventContent>,
}
#[derive(Deserialize)]
struct ExtractGlobalEventContent {
content: Raw<AnyGlobalAccountDataEventContent>,
}

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

@ -7,10 +7,7 @@ use ruma::{
set_pushrule_actions, set_pushrule_enabled, set_pushrule_actions, set_pushrule_enabled,
}, },
}, },
events::{ events::{push_rules::PushRulesEventContent, GlobalAccountDataEventType},
push_rules::PushRulesEvent, AnyGlobalAccountDataEvent,
GlobalAccountDataEventType,
},
push::{AnyPushRuleRef, InsertPushRuleError, RemovePushRuleError}, push::{AnyPushRuleRef, InsertPushRuleError, RemovePushRuleError},
serde::Raw, serde::Raw,
}; };
@ -33,10 +30,10 @@ pub(crate) async fn get_pushrules_all_route(
"PushRules event not found.", "PushRules event not found.",
))?; ))?;
let account_data = event let account_data =
.deserialize_as::<PushRulesEvent>() event.deserialize_as::<PushRulesEventContent>().map_err(|_| {
.map_err(|_| Error::bad_database("Invalid account data event in db."))? Error::bad_database("Invalid account data event in db.")
.content; })?;
Ok(Ra(get_pushrules_all::v3::Response { Ok(Ra(get_pushrules_all::v3::Response {
global: account_data.global, global: account_data.global,
@ -59,10 +56,10 @@ pub(crate) async fn get_pushrule_route(
"PushRules event not found.", "PushRules event not found.",
))?; ))?;
let account_data = event let account_data =
.deserialize_as::<PushRulesEvent>() event.deserialize_as::<PushRulesEventContent>().map_err(|_| {
.map_err(|_| Error::bad_database("Invalid account data event in db."))? Error::bad_database("Invalid account data event in db.")
.content; })?;
let rule = account_data let rule = account_data
.global .global
@ -96,11 +93,11 @@ pub(crate) async fn set_pushrule_route(
))?; ))?;
let mut account_data = let mut account_data =
event.deserialize_as::<PushRulesEvent>().map_err(|_| { event.deserialize_as::<PushRulesEventContent>().map_err(|_| {
Error::bad_database("Invalid account data event in db.") Error::bad_database("Invalid account data event in db.")
})?; })?;
if let Err(error) = account_data.content.global.insert( if let Err(error) = account_data.global.insert(
body.rule.clone(), body.rule.clone(),
body.after.as_deref(), body.after.as_deref(),
body.before.as_deref(), body.before.as_deref(),
@ -139,9 +136,8 @@ pub(crate) async fn set_pushrule_route(
services().account_data.update_global( services().account_data.update_global(
sender_user, sender_user,
&GlobalAccountDataEventType::PushRules, &GlobalAccountDataEventType::PushRules,
&Raw::new(&account_data) &Raw::new(&account_data.into())
.expect("json event serialization should always succeed") .expect("json event serialization should always succeed"),
.cast::<AnyGlobalAccountDataEvent>(),
)?; )?;
Ok(Ra(set_pushrule::v3::Response {})) Ok(Ra(set_pushrule::v3::Response {}))
@ -163,10 +159,10 @@ pub(crate) async fn get_pushrule_actions_route(
"PushRules event not found.", "PushRules event not found.",
))?; ))?;
let account_data = event let account_data =
.deserialize_as::<PushRulesEvent>() event.deserialize_as::<PushRulesEventContent>().map_err(|_| {
.map_err(|_| Error::bad_database("Invalid account data event in db."))? Error::bad_database("Invalid account data event in db.")
.content; })?;
let global = account_data.global; let global = account_data.global;
let actions = global let actions = global
@ -199,12 +195,11 @@ pub(crate) async fn set_pushrule_actions_route(
))?; ))?;
let mut account_data = let mut account_data =
event.deserialize_as::<PushRulesEvent>().map_err(|_| { event.deserialize_as::<PushRulesEventContent>().map_err(|_| {
Error::bad_database("Invalid account data event in db.") Error::bad_database("Invalid account data event in db.")
})?; })?;
if account_data if account_data
.content
.global .global
.set_actions(body.kind.clone(), &body.rule_id, body.actions.clone()) .set_actions(body.kind.clone(), &body.rule_id, body.actions.clone())
.is_err() .is_err()
@ -218,9 +213,8 @@ pub(crate) async fn set_pushrule_actions_route(
services().account_data.update_global( services().account_data.update_global(
sender_user, sender_user,
&GlobalAccountDataEventType::PushRules, &GlobalAccountDataEventType::PushRules,
&Raw::new(&account_data) &Raw::new(&account_data.into())
.expect("json event serialization should always suceed") .expect("json event serialization should always suceed"),
.cast::<AnyGlobalAccountDataEvent>(),
)?; )?;
Ok(Ra(set_pushrule_actions::v3::Response {})) Ok(Ra(set_pushrule_actions::v3::Response {}))
@ -243,11 +237,11 @@ pub(crate) async fn get_pushrule_enabled_route(
))?; ))?;
let account_data = let account_data =
event.deserialize_as::<PushRulesEvent>().map_err(|_| { event.deserialize_as::<PushRulesEventContent>().map_err(|_| {
Error::bad_database("Invalid account data event in db.") Error::bad_database("Invalid account data event in db.")
})?; })?;
let global = account_data.content.global; let global = account_data.global;
let enabled = global let enabled = global
.get(body.kind.clone(), &body.rule_id) .get(body.kind.clone(), &body.rule_id)
.map(AnyPushRuleRef::enabled) .map(AnyPushRuleRef::enabled)
@ -278,12 +272,11 @@ pub(crate) async fn set_pushrule_enabled_route(
))?; ))?;
let mut account_data = let mut account_data =
event.deserialize_as::<PushRulesEvent>().map_err(|_| { event.deserialize_as::<PushRulesEventContent>().map_err(|_| {
Error::bad_database("Invalid account data event in db.") Error::bad_database("Invalid account data event in db.")
})?; })?;
if account_data if account_data
.content
.global .global
.set_enabled(body.kind.clone(), &body.rule_id, body.enabled) .set_enabled(body.kind.clone(), &body.rule_id, body.enabled)
.is_err() .is_err()
@ -297,9 +290,8 @@ pub(crate) async fn set_pushrule_enabled_route(
services().account_data.update_global( services().account_data.update_global(
sender_user, sender_user,
&GlobalAccountDataEventType::PushRules, &GlobalAccountDataEventType::PushRules,
&Raw::new(&account_data) &Raw::new(&account_data.into())
.expect("json event serialization should always succeed") .expect("json event serialization should always succeed"),
.cast::<AnyGlobalAccountDataEvent>(),
)?; )?;
Ok(Ra(set_pushrule_enabled::v3::Response {})) Ok(Ra(set_pushrule_enabled::v3::Response {}))
@ -322,12 +314,12 @@ pub(crate) async fn delete_pushrule_route(
))?; ))?;
let mut account_data = let mut account_data =
event.deserialize_as::<PushRulesEvent>().map_err(|_| { event.deserialize_as::<PushRulesEventContent>().map_err(|_| {
Error::bad_database("Invalid account data event in db.") Error::bad_database("Invalid account data event in db.")
})?; })?;
if let Err(error) = if let Err(error) =
account_data.content.global.remove(body.kind.clone(), &body.rule_id) account_data.global.remove(body.kind.clone(), &body.rule_id)
{ {
let err = match error { let err = match error {
RemovePushRuleError::ServerDefault => Error::BadRequest( RemovePushRuleError::ServerDefault => Error::BadRequest(
@ -346,9 +338,8 @@ pub(crate) async fn delete_pushrule_route(
services().account_data.update_global( services().account_data.update_global(
sender_user, sender_user,
&GlobalAccountDataEventType::PushRules, &GlobalAccountDataEventType::PushRules,
&Raw::new(&account_data) &Raw::new(&account_data.into())
.expect("json event serialization should always suceed") .expect("json event serialization should always suceed"),
.cast::<AnyGlobalAccountDataEvent>(),
)?; )?;
Ok(Ra(delete_pushrule::v3::Response {})) Ok(Ra(delete_pushrule::v3::Response {}))

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

@ -6,7 +6,7 @@ use ruma::{
}, },
events::{ events::{
receipt::{ReceiptThread, ReceiptType}, receipt::{ReceiptThread, ReceiptType},
AnyRoomAccountDataEvent, RoomAccountDataEventType, RoomAccountDataEventType,
}, },
serde::Raw, serde::Raw,
MilliSecondsSinceUnixEpoch, MilliSecondsSinceUnixEpoch,
@ -29,18 +29,16 @@ pub(crate) async fn set_read_marker_route(
let sender_user = body.sender_user.as_ref().expect("user is authenticated"); let sender_user = body.sender_user.as_ref().expect("user is authenticated");
if let Some(fully_read) = &body.fully_read { if let Some(fully_read) = &body.fully_read {
let fully_read_event = ruma::events::fully_read::FullyReadEvent { let fully_read_event =
content: ruma::events::fully_read::FullyReadEventContent { ruma::events::fully_read::FullyReadEventContent {
event_id: fully_read.clone(), event_id: fully_read.clone(),
}, };
};
services().account_data.update_room( services().account_data.update_room(
&body.room_id, &body.room_id,
sender_user, sender_user,
&RoomAccountDataEventType::FullyRead, &RoomAccountDataEventType::FullyRead,
&Raw::new(&fully_read_event) &Raw::new(&fully_read_event.into())
.expect("json event serialization should always suceed") .expect("json event serialization should always suceed"),
.cast::<AnyRoomAccountDataEvent>(),
)?; )?;
} }
@ -126,18 +124,16 @@ pub(crate) async fn create_receipt_route(
match body.receipt_type { match body.receipt_type {
create_receipt::v3::ReceiptType::FullyRead => { create_receipt::v3::ReceiptType::FullyRead => {
let fully_read_event = ruma::events::fully_read::FullyReadEvent { let fully_read_event =
content: ruma::events::fully_read::FullyReadEventContent { ruma::events::fully_read::FullyReadEventContent {
event_id: body.event_id.clone(), event_id: body.event_id.clone(),
}, };
};
services().account_data.update_room( services().account_data.update_room(
&body.room_id, &body.room_id,
sender_user, sender_user,
&RoomAccountDataEventType::FullyRead, &RoomAccountDataEventType::FullyRead,
&Raw::new(&fully_read_event) &Raw::new(&fully_read_event.into())
.expect("json event serialization should always succeed") .expect("json event serialization should always succeed"),
.cast::<AnyRoomAccountDataEvent>(),
)?; )?;
} }
create_receipt::v3::ReceiptType::Read => { create_receipt::v3::ReceiptType::Read => {

11
src/api/client_server/sync/msc3575.rs
View file

@ -25,7 +25,8 @@ use tracing::{debug, error};
use super::{load_timeline, share_encrypted_room}; use super::{load_timeline, share_encrypted_room};
use crate::{ use crate::{
service::rooms::timeline::PduCount, services, Ar, Error, Ra, Result, service::{account_data, rooms::timeline::PduCount},
services, Ar, Error, Ra, Result,
}; };
#[allow(clippy::too_many_lines)] #[allow(clippy::too_many_lines)]
@ -645,7 +646,13 @@ pub(crate) async fn sync_events_v4_route(
services() services()
.account_data .account_data
.global_changes_since(&sender_user, globalsince)? .global_changes_since(&sender_user, globalsince)?
.into_values() .into_iter()
.map(|(event_type, content)| {
account_data::raw_global_event_from_parts(
&event_type,
&content,
)
})
.collect() .collect()
} else { } else {
Vec::new() Vec::new()

18
src/api/client_server/sync/v3.rs
View file

@ -27,7 +27,7 @@ use tracing::{debug, error, field};
use super::{load_timeline, share_encrypted_room}; use super::{load_timeline, share_encrypted_room};
use crate::{ use crate::{
service::{pdu::EventHash, rooms::timeline::PduCount}, service::{account_data, pdu::EventHash, rooms::timeline::PduCount},
services, utils, Ar, Error, PduEvent, Ra, Result, services, utils, Ar, Error, PduEvent, Ra, Result,
}; };
@ -235,7 +235,13 @@ pub(crate) async fn sync_events_route(
events: services() events: services()
.account_data .account_data
.global_changes_since(ctx.sender_user, ctx.since)? .global_changes_since(ctx.sender_user, ctx.since)?
.into_values() .into_iter()
.map(|(event_type, content)| {
account_data::raw_global_event_from_parts(
&event_type,
&content,
)
})
.collect(), .collect(),
}, },
device_lists: DeviceLists { device_lists: DeviceLists {
@ -872,7 +878,13 @@ async fn load_joined_room(
events: services() events: services()
.account_data .account_data
.room_changes_since(ctx.sender_user, room_id, ctx.since)? .room_changes_since(ctx.sender_user, room_id, ctx.since)?
.into_values() .into_iter()
.map(|(event_type, content)| {
account_data::raw_room_event_from_parts(
&event_type,
&content,
)
})
.collect(), .collect(),
}, },
summary: RoomSummary { summary: RoomSummary {

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

@ -2,10 +2,7 @@ use std::collections::BTreeMap;
use ruma::{ use ruma::{
api::client::tag::{create_tag, delete_tag, get_tags}, api::client::tag::{create_tag, delete_tag, get_tags},
events::{ events::{tag::TagEventContent, RoomAccountDataEventType},
tag::{TagEvent, TagEventContent},
AnyRoomAccountDataEvent, RoomAccountDataEventType,
},
serde::Raw, serde::Raw,
}; };
@ -29,31 +26,25 @@ pub(crate) async fn update_tag_route(
let mut tags_event = event.map_or_else( let mut tags_event = event.map_or_else(
|| { || {
Ok(TagEvent { Ok(TagEventContent {
content: TagEventContent { tags: BTreeMap::new(),
tags: BTreeMap::new(),
},
}) })
}, },
|e| { |e| {
e.deserialize_as::<TagEvent>().map_err(|_| { e.deserialize_as::<TagEventContent>().map_err(|_| {
Error::bad_database("Invalid account data event in db.") Error::bad_database("Invalid account data event in db.")
}) })
}, },
)?; )?;
tags_event tags_event.tags.insert(body.tag.clone().into(), body.tag_info.clone());
.content
.tags
.insert(body.tag.clone().into(), body.tag_info.clone());
services().account_data.update_room( services().account_data.update_room(
&body.room_id, &body.room_id,
sender_user, sender_user,
&RoomAccountDataEventType::Tag, &RoomAccountDataEventType::Tag,
&Raw::new(&tags_event) &Raw::new(&tags_event.into())
.expect("json event serialization should always suceed") .expect("json event serialization should always suceed"),
.cast::<AnyRoomAccountDataEvent>(),
)?; )?;
Ok(Ra(create_tag::v3::Response {})) Ok(Ra(create_tag::v3::Response {}))
@ -77,28 +68,25 @@ pub(crate) async fn delete_tag_route(
let mut tags_event = event.map_or_else( let mut tags_event = event.map_or_else(
|| { || {
Ok(TagEvent { Ok(TagEventContent {
content: TagEventContent { tags: BTreeMap::new(),
tags: BTreeMap::new(),
},
}) })
}, },
|e| { |e| {
e.deserialize_as::<TagEvent>().map_err(|_| { e.deserialize_as::<TagEventContent>().map_err(|_| {
Error::bad_database("Invalid account data event in db.") Error::bad_database("Invalid account data event in db.")
}) })
}, },
)?; )?;
tags_event.content.tags.remove(&body.tag.clone().into()); tags_event.tags.remove(&body.tag.clone().into());
services().account_data.update_room( services().account_data.update_room(
&body.room_id, &body.room_id,
sender_user, sender_user,
&RoomAccountDataEventType::Tag, &RoomAccountDataEventType::Tag,
&Raw::new(&tags_event) &Raw::new(&tags_event.into())
.expect("json value serialization should always succeed") .expect("json value serialization should always succeed"),
.cast::<AnyRoomAccountDataEvent>(),
)?; )?;
Ok(Ra(delete_tag::v3::Response {})) Ok(Ra(delete_tag::v3::Response {}))
@ -122,20 +110,18 @@ pub(crate) async fn get_tags_route(
let tags_event = event.map_or_else( let tags_event = event.map_or_else(
|| { || {
Ok(TagEvent { Ok(TagEventContent {
content: TagEventContent { tags: BTreeMap::new(),
tags: BTreeMap::new(),
},
}) })
}, },
|e| { |e| {
e.deserialize_as::<TagEvent>().map_err(|_| { e.deserialize_as::<TagEventContent>().map_err(|_| {
Error::bad_database("Invalid account data event in db.") Error::bad_database("Invalid account data event in db.")
}) })
}, },
)?; )?;
Ok(Ra(get_tags::v3::Response { Ok(Ra(get_tags::v3::Response {
tags: tags_event.content.tags, tags: tags_event.tags,
})) }))
} }

22
src/database.rs
View file

@ -7,10 +7,7 @@ use std::{
}; };
use ruma::{ use ruma::{
events::{ events::{push_rules::PushRulesEventContent, GlobalAccountDataEventType},
push_rules::PushRulesEvent, AnyGlobalAccountDataEvent,
GlobalAccountDataEventType,
},
push::Ruleset, push::Ruleset,
serde::Raw, serde::Raw,
EventId, OwnedRoomId, RoomId, UserId, EventId, OwnedRoomId, RoomId, UserId,
@ -871,9 +868,9 @@ impl KeyValueDatabase {
.expect("Username is invalid"); .expect("Username is invalid");
let mut account_data = raw_rules_list let mut account_data = raw_rules_list
.deserialize_as::<PushRulesEvent>() .deserialize_as::<PushRulesEventContent>()
.unwrap(); .unwrap();
let rules_list = &mut account_data.content.global; let rules_list = &mut account_data.global;
//content rule //content rule
{ {
@ -929,9 +926,8 @@ impl KeyValueDatabase {
services().account_data.update_global( services().account_data.update_global(
&user, &user,
&GlobalAccountDataEventType::PushRules, &GlobalAccountDataEventType::PushRules,
&Raw::new(&account_data) &Raw::new(&account_data.into())
.expect("json serialization should always succeed") .expect("json serialization should always succeed"),
.cast::<AnyGlobalAccountDataEvent>(),
)?; )?;
} }
Ok(()) Ok(())
@ -966,21 +962,19 @@ impl KeyValueDatabase {
.expect("Username is invalid"); .expect("Username is invalid");
let mut account_data = raw_rules_list let mut account_data = raw_rules_list
.deserialize_as::<PushRulesEvent>() .deserialize_as::<PushRulesEventContent>()
.unwrap(); .unwrap();
let user_default_rules = Ruleset::server_default(&user); let user_default_rules = Ruleset::server_default(&user);
account_data account_data
.content
.global .global
.update_with_server_default(user_default_rules); .update_with_server_default(user_default_rules);
services().account_data.update_global( services().account_data.update_global(
&user, &user,
&GlobalAccountDataEventType::PushRules, &GlobalAccountDataEventType::PushRules,
&Raw::new(&account_data) &Raw::new(&account_data.into())
.expect("json serialization should always succeed") .expect("json serialization should always succeed"),
.cast::<AnyGlobalAccountDataEvent>(),
)?; )?;
} }
Ok(()) Ok(())

158
src/service/account_data.rs
View file

@ -2,14 +2,16 @@ use std::collections::HashMap;
use ruma::{ use ruma::{
events::{ events::{
AnyGlobalAccountDataEvent, AnyRoomAccountDataEvent, AnyGlobalAccountDataEvent, AnyGlobalAccountDataEventContent,
AnyRoomAccountDataEvent, AnyRoomAccountDataEventContent,
GlobalAccountDataEventType, RoomAccountDataEventType, GlobalAccountDataEventType, RoomAccountDataEventType,
}, },
serde::Raw, serde::Raw,
RoomId, UserId, RoomId, UserId,
}; };
use serde::{Deserialize, Serialize};
use crate::Result; use crate::{Error, Result};
mod data; mod data;
@ -19,6 +21,78 @@ pub(crate) struct Service {
pub(crate) db: &'static dyn Data, pub(crate) db: &'static dyn Data,
} }
pub(crate) fn raw_global_event_to_parts(
event: &Raw<AnyGlobalAccountDataEvent>,
) -> serde_json::Result<(
GlobalAccountDataEventType,
Raw<AnyGlobalAccountDataEventContent>,
)> {
#[derive(Deserialize)]
struct Parts {
#[serde(rename = "type")]
event_type: GlobalAccountDataEventType,
content: Raw<AnyGlobalAccountDataEventContent>,
}
let parts = event.deserialize_as::<Parts>()?;
Ok((parts.event_type, parts.content))
}
pub(crate) fn raw_global_event_from_parts(
event_type: &GlobalAccountDataEventType,
content: &Raw<AnyGlobalAccountDataEventContent>,
) -> Raw<AnyGlobalAccountDataEvent> {
#[derive(Serialize)]
struct Parts<'a> {
#[serde(rename = "type")]
event_type: &'a GlobalAccountDataEventType,
content: &'a Raw<AnyGlobalAccountDataEventContent>,
}
Raw::new(&Parts {
event_type,
content,
})
.expect("json serialization should always succeed")
.cast::<AnyGlobalAccountDataEvent>()
}
pub(crate) fn raw_room_event_to_parts(
event: &Raw<AnyRoomAccountDataEvent>,
) -> serde_json::Result<(
RoomAccountDataEventType,
Raw<AnyRoomAccountDataEventContent>,
)> {
#[derive(Deserialize)]
struct Parts {
#[serde(rename = "type")]
event_type: RoomAccountDataEventType,
content: Raw<AnyRoomAccountDataEventContent>,
}
let parts = event.deserialize_as::<Parts>()?;
Ok((parts.event_type, parts.content))
}
pub(crate) fn raw_room_event_from_parts(
event_type: &RoomAccountDataEventType,
content: &Raw<AnyRoomAccountDataEventContent>,
) -> Raw<AnyRoomAccountDataEvent> {
#[derive(Serialize)]
struct Parts<'a> {
#[serde(rename = "type")]
event_type: &'a RoomAccountDataEventType,
content: &'a Raw<AnyRoomAccountDataEventContent>,
}
Raw::new(&Parts {
event_type,
content,
})
.expect("json serialization should always succeed")
.cast::<AnyRoomAccountDataEvent>()
}
impl Service { impl Service {
pub(crate) fn new(db: &'static dyn Data) -> Self { pub(crate) fn new(db: &'static dyn Data) -> Self {
Self { Self {
@ -28,26 +102,28 @@ impl Service {
/// Places one event in the global account data of the user and removes the /// Places one event in the global account data of the user and removes the
/// previous entry. /// previous entry.
#[tracing::instrument(skip(self, user_id, event))] #[tracing::instrument(skip(self, user_id, content))]
pub(crate) fn update_global( pub(crate) fn update_global(
&self, &self,
user_id: &UserId, user_id: &UserId,
event_type: &GlobalAccountDataEventType, event_type: &GlobalAccountDataEventType,
event: &Raw<AnyGlobalAccountDataEvent>, content: &Raw<AnyGlobalAccountDataEventContent>,
) -> Result<()> { ) -> Result<()> {
let event = raw_global_event_from_parts(event_type, content);
self.db.update(None, user_id, &event_type.to_string(), event.json()) self.db.update(None, user_id, &event_type.to_string(), event.json())
} }
/// Places one event in the room account data of the user and removes the /// Places one event in the room account data of the user and removes the
/// previous entry for that room. /// previous entry for that room.
#[tracing::instrument(skip(self, room_id, user_id, event))] #[tracing::instrument(skip(self, room_id, user_id, content))]
pub(crate) fn update_room( pub(crate) fn update_room(
&self, &self,
room_id: &RoomId, room_id: &RoomId,
user_id: &UserId, user_id: &UserId,
event_type: &RoomAccountDataEventType, event_type: &RoomAccountDataEventType,
event: &Raw<AnyRoomAccountDataEvent>, content: &Raw<AnyRoomAccountDataEventContent>,
) -> Result<()> { ) -> Result<()> {
let event = raw_room_event_from_parts(event_type, content);
self.db.update( self.db.update(
Some(room_id), Some(room_id),
user_id, user_id,
@ -62,11 +138,17 @@ impl Service {
&self, &self,
user_id: &UserId, user_id: &UserId,
event_type: &GlobalAccountDataEventType, event_type: &GlobalAccountDataEventType,
) -> Result<Option<Raw<AnyGlobalAccountDataEvent>>> { ) -> Result<Option<Raw<AnyGlobalAccountDataEventContent>>> {
Ok(self let Some(event) =
.db self.db.get(None, user_id, &event_type.to_string())?
.get(None, user_id, &event_type.to_string())? else {
.map(Raw::from_json)) return Ok(None);
};
let event = Raw::<AnyGlobalAccountDataEvent>::from_json(event);
let (_, content) = raw_global_event_to_parts(&event).map_err(|_| {
Error::bad_database("Invalid account data event in db.")
})?;
Ok(Some(content))
} }
/// Searches the room account data for a specific kind. /// Searches the room account data for a specific kind.
@ -76,11 +158,17 @@ impl Service {
room_id: &RoomId, room_id: &RoomId,
user_id: &UserId, user_id: &UserId,
event_type: &RoomAccountDataEventType, event_type: &RoomAccountDataEventType,
) -> Result<Option<Raw<AnyRoomAccountDataEvent>>> { ) -> Result<Option<Raw<AnyRoomAccountDataEventContent>>> {
Ok(self let Some(event) =
.db self.db.get(Some(room_id), user_id, &event_type.to_string())?
.get(Some(room_id), user_id, &event_type.to_string())? else {
.map(Raw::from_json)) return Ok(None);
};
let event = Raw::<AnyRoomAccountDataEvent>::from_json(event);
let (_, content) = raw_room_event_to_parts(&event).map_err(|_| {
Error::bad_database("Invalid account data event in db.")
})?;
Ok(Some(content))
} }
/// Returns all changes to global account data that happened after `since`. /// Returns all changes to global account data that happened after `since`.
@ -93,16 +181,21 @@ impl Service {
user_id: &UserId, user_id: &UserId,
since: u64, since: u64,
) -> Result< ) -> Result<
HashMap<GlobalAccountDataEventType, Raw<AnyGlobalAccountDataEvent>>, HashMap<
GlobalAccountDataEventType,
Raw<AnyGlobalAccountDataEventContent>,
>,
> { > {
Ok(self self.db
.db
.changes_since(None, user_id, since)? .changes_since(None, user_id, since)?
.into_iter() .into_values()
.map(|(event_type, event)| { .map(|event| {
(event_type.into(), Raw::from_json(event)) let event = Raw::<AnyGlobalAccountDataEvent>::from_json(event);
raw_global_event_to_parts(&event).map_err(|_| {
Error::bad_database("Invalid account data event in db")
})
}) })
.collect()) .collect()
} }
/// Returns all changes to room account data that happened after `since`. /// Returns all changes to room account data that happened after `since`.
@ -115,15 +208,18 @@ impl Service {
user_id: &UserId, user_id: &UserId,
room_id: &RoomId, room_id: &RoomId,
since: u64, since: u64,
) -> Result<HashMap<RoomAccountDataEventType, Raw<AnyRoomAccountDataEvent>>> ) -> Result<
{ HashMap<RoomAccountDataEventType, Raw<AnyRoomAccountDataEventContent>>,
Ok(self > {
.db self.db
.changes_since(Some(room_id), user_id, since)? .changes_since(Some(room_id), user_id, since)?
.into_iter() .into_values()
.map(|(event_type, event)| { .map(|event| {
(event_type.into(), Raw::from_json(event)) let event = Raw::<AnyRoomAccountDataEvent>::from_json(event);
raw_room_event_to_parts(&event).map_err(|_| {
Error::bad_database("Invalid account data event in db")
})
}) })
.collect()) .collect()
} }
} }

3
src/service/account_data/data.rs
View file

@ -9,6 +9,9 @@ use crate::Result;
/// distinguish between global and room events. Because there are no ruma types /// distinguish between global and room events. Because there are no ruma types
/// that cover both, we use strings for the event types and raw json values for /// that cover both, we use strings for the event types and raw json values for
/// the contents. /// the contents.
//
// TODO: once we have the ability to make db schema changes, we should consider
// storing only the content in the db, rather than the whole event object.
pub(crate) trait Data: Send + Sync { pub(crate) trait Data: Send + Sync {
/// Places one event in the account data of the user and removes the /// Places one event in the account data of the user and removes the
/// previous entry. /// previous entry.

16
src/service/admin.rs
View file

@ -5,7 +5,7 @@ use regex::Regex;
use ruma::{ use ruma::{
api::appservice::Registration, api::appservice::Registration,
events::{ events::{
push_rules::{PushRulesEvent, PushRulesEventContent}, push_rules::PushRulesEventContent,
room::{ room::{
canonical_alias::RoomCanonicalAliasEventContent, canonical_alias::RoomCanonicalAliasEventContent,
create::RoomCreateEventContent, create::RoomCreateEventContent,
@ -20,7 +20,7 @@ use ruma::{
power_levels::RoomPowerLevelsEventContent, power_levels::RoomPowerLevelsEventContent,
topic::RoomTopicEventContent, topic::RoomTopicEventContent,
}, },
AnyGlobalAccountDataEvent, TimelineEventType, TimelineEventType,
}, },
serde::Raw, serde::Raw,
signatures::verify_json, signatures::verify_json,
@ -774,15 +774,15 @@ impl Service {
services().account_data.update_global( services().account_data.update_global(
&user_id, &user_id,
&ruma::events::GlobalAccountDataEventType::PushRules, &ruma::events::GlobalAccountDataEventType::PushRules,
&Raw::new(&PushRulesEvent { &Raw::new(
content: PushRulesEventContent { &PushRulesEventContent {
global: ruma::push::Ruleset::server_default( global: ruma::push::Ruleset::server_default(
&user_id, &user_id,
), ),
}, }
}) .into(),
.expect("json serialization should always succeed") )
.cast::<AnyGlobalAccountDataEvent>(), .expect("json serialization should always succeed"),
)?; )?;
// we dont add a device since we're not the user, just the // we dont add a device since we're not the user, just the

15
src/service/globals.rs
View file

@ -18,8 +18,7 @@ use ruma::{
api::federation::discovery::ServerSigningKeys, api::federation::discovery::ServerSigningKeys,
events::{ events::{
push_rules::PushRulesEventContent, push_rules::PushRulesEventContent,
room::message::RoomMessageEventContent, AnyGlobalAccountDataEvent, room::message::RoomMessageEventContent, GlobalAccountDataEventType,
GlobalAccountDataEvent, GlobalAccountDataEventType,
}, },
push::Ruleset, push::Ruleset,
serde::{Base64, Raw}, serde::{Base64, Raw},
@ -495,13 +494,13 @@ impl Service {
services().account_data.update_global( services().account_data.update_global(
admin_bot, admin_bot,
&GlobalAccountDataEventType::PushRules, &GlobalAccountDataEventType::PushRules,
&Raw::new(&GlobalAccountDataEvent { &Raw::new(
content: PushRulesEventContent { &PushRulesEventContent {
global: ruleset, global: ruleset,
}, }
}) .into(),
.expect("json serialization should always succeed") )
.cast::<AnyGlobalAccountDataEvent>(), .expect("json serialization should always succeed"),
)?; )?;
res res

32
src/service/rooms/state_cache.rs
View file

@ -5,9 +5,10 @@ use std::{
use ruma::{ use ruma::{
events::{ events::{
ignored_user_list::IgnoredUserListEvent, room::member::MembershipState, ignored_user_list::IgnoredUserListEventContent,
AnyGlobalAccountDataEvent, AnyStrippedStateEvent, AnySyncStateEvent, room::member::MembershipState, AnyGlobalAccountDataEventContent,
GlobalAccountDataEventType, RoomAccountDataEventType, AnyStrippedStateEvent, AnySyncStateEvent, GlobalAccountDataEventType,
RoomAccountDataEventType,
}, },
serde::Raw, serde::Raw,
OwnedRoomId, OwnedServerName, OwnedUserId, RoomId, ServerName, UserId, OwnedRoomId, OwnedServerName, OwnedUserId, RoomId, ServerName, UserId,
@ -102,7 +103,7 @@ impl Service {
&GlobalAccountDataEventType::IgnoredUserList, &GlobalAccountDataEventType::IgnoredUserList,
)? )?
.map(|event| { .map(|event| {
event.deserialize_as::<IgnoredUserListEvent>() event.deserialize_as::<IgnoredUserListEventContent>()
.map_err(|error| { .map_err(|error| {
warn!( warn!(
%error, %error,
@ -114,7 +115,6 @@ impl Service {
.transpose()? .transpose()?
.is_some_and(|ignored| { .is_some_and(|ignored| {
ignored ignored
.content
.ignored_users .ignored_users
.iter() .iter()
.any(|(user, _details)| user == sender) .any(|(user, _details)| user == sender)
@ -221,14 +221,14 @@ impl Service {
from_room_id: &RoomId, from_room_id: &RoomId,
to_room_id: &RoomId, to_room_id: &RoomId,
) -> Result<()> { ) -> Result<()> {
let Some(event) = services() let Some(event_content) = services()
.account_data .account_data
.get_global(user_id, &GlobalAccountDataEventType::Direct)? .get_global(user_id, &GlobalAccountDataEventType::Direct)?
else { else {
return Ok(()); return Ok(());
}; };
let mut event = event let mut event_content = event_content
.deserialize_as::<serde_json::Value>() .deserialize_as::<serde_json::Value>()
.expect("RawValue -> Value should always succeed"); .expect("RawValue -> Value should always succeed");
@ -240,14 +240,11 @@ impl Service {
// //
// [1]: https://github.com/element-hq/element-web/issues/27630 // [1]: https://github.com/element-hq/element-web/issues/27630
// //
// A valid m.direct event looks like this: // Valid m.direct event content looks like this:
// //
// { // {
// "type": "m.account_data", // "@userid1": [ "!roomid1", "!roomid2" ],
// "content": { // "@userid2": [ "!roomid3" ],
// "@userid1": [ "!roomid1", "!roomid2" ],
// "@userid2": [ "!roomid3" ],
// }
// } // }
// //
// We want to find userid keys where the value contains from_room_id, // We want to find userid keys where the value contains from_room_id,
@ -257,10 +254,7 @@ impl Service {
// parts. // parts.
let mut event_updated = false; let mut event_updated = false;
let Some(direct_user_ids) = event.get_mut("content") else { let Some(direct_user_ids) = event_content.as_object_mut() else {
return Ok(());
};
let Some(direct_user_ids) = direct_user_ids.as_object_mut() else {
return Ok(()); return Ok(());
}; };
for room_ids in direct_user_ids.values_mut() { for room_ids in direct_user_ids.values_mut() {
@ -277,9 +271,9 @@ impl Service {
if let Err(error) = services().account_data.update_global( if let Err(error) = services().account_data.update_global(
user_id, user_id,
&GlobalAccountDataEventType::Direct, &GlobalAccountDataEventType::Direct,
&Raw::new(&event) &Raw::new(&event_content)
.expect("json serialization should always succeed") .expect("json serialization should always succeed")
.cast::<AnyGlobalAccountDataEvent>(), .cast::<AnyGlobalAccountDataEventContent>(),
) { ) {
warn!(%error, "error writing m.direct account data event after upgrading room"); warn!(%error, "error writing m.direct account data event after upgrading room");
} }

17
src/service/rooms/timeline.rs
View file

@ -9,7 +9,7 @@ use ruma::{
api::{client::error::ErrorKind, federation}, api::{client::error::ErrorKind, federation},
canonical_json::to_canonical_value, canonical_json::to_canonical_value,
events::{ events::{
push_rules::PushRulesEvent, push_rules::PushRulesEventContent,
room::{ room::{
create::RoomCreateEventContent, encrypted::Relation, create::RoomCreateEventContent, encrypted::Relation,
member::MembershipState, message::RoomMessageEventContent, member::MembershipState, message::RoomMessageEventContent,
@ -419,15 +419,16 @@ impl Service {
.account_data .account_data
.get_global(user, &GlobalAccountDataEventType::PushRules)? .get_global(user, &GlobalAccountDataEventType::PushRules)?
.map(|event| { .map(|event| {
event.deserialize_as::<PushRulesEvent>().map_err(|_| { event.deserialize_as::<PushRulesEventContent>().map_err(
Error::bad_database("Invalid push rules event in db.") |_| {
}) Error::bad_database(
"Invalid push rules event in db.",
)
},
)
}) })
.transpose()? .transpose()?
.map_or_else( .map_or_else(|| Ruleset::server_default(user), |ev| ev.global);
|| Ruleset::server_default(user),
|ev: PushRulesEvent| ev.content.global,
);
let mut highlight = false; let mut highlight = false;
let mut notify = false; let mut notify = false;

8
src/service/sending.rs
View file

@ -22,7 +22,7 @@ use ruma::{
}, },
device_id, device_id,
events::{ events::{
push_rules::PushRulesEvent, receipt::ReceiptType, push_rules::PushRulesEventContent, receipt::ReceiptType,
AnySyncEphemeralRoomEvent, GlobalAccountDataEventType, AnySyncEphemeralRoomEvent, GlobalAccountDataEventType,
}, },
push, push,
@ -859,10 +859,12 @@ async fn handle_push_event(
.account_data .account_data
.get_global(userid, &GlobalAccountDataEventType::PushRules) .get_global(userid, &GlobalAccountDataEventType::PushRules)
.unwrap_or_default() .unwrap_or_default()
.and_then(|event| event.deserialize_as::<PushRulesEvent>().ok()) .and_then(|event| {
event.deserialize_as::<PushRulesEventContent>().ok()
})
.map_or_else( .map_or_else(
|| push::Ruleset::server_default(userid), || push::Ruleset::server_default(userid),
|ev: PushRulesEvent| ev.content.global, |ev| ev.global,
); );
let unread: UInt = services() let unread: UInt = services()