chris/ruwuma
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use RoomEventType instead of EventType for PDUs and power levels

Browse Source
This commit is contained in:
Jonas Platte
2022-03-15 16:35:08 +01:00
parent 6f6e7ca68e
commit ce785064a9
8 changed files with 174 additions and 174 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
crates/ruma-state-res/benches/state_res_bench.rs
View File

@@ -28,7 +28,7 @@ use ruma_common::{
join_rules::{JoinRule, RoomJoinRulesEventContent},
member::{MembershipState, RoomMemberEventContent},
},
EventType,
RoomEventType,
},
room_id, user_id, EventId, MilliSecondsSinceUnixEpoch, RoomId, RoomVersionId, UserId,
};
@@ -240,7 +240,7 @@ impl TestStore<StateEvent> {
let create_event = to_pdu_event::<&EventId>(
"CREATE",
alice(),
EventType::RoomCreate,
RoomEventType::RoomCreate,
Some(""),
to_raw_json_value(&json!({ "creator": alice() })).unwrap(),
&[],
@@ -252,7 +252,7 @@ impl TestStore<StateEvent> {
let alice_mem = to_pdu_event(
"IMA",
alice(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(alice().to_string().as_str()),
member_content_join(),
&[cre.clone()],
@@ -263,7 +263,7 @@ impl TestStore<StateEvent> {
let join_rules = to_pdu_event(
"IJR",
alice(),
EventType::RoomJoinRules,
RoomEventType::RoomJoinRules,
Some(""),
to_raw_json_value(&RoomJoinRulesEventContent::new(JoinRule::Public)).unwrap(),
&[cre.clone(), alice_mem.event_id().to_owned()],
@@ -276,7 +276,7 @@ impl TestStore<StateEvent> {
let bob_mem = to_pdu_event(
"IMB",
bob(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(bob().to_string().as_str()),
member_content_join(),
&[cre.clone(), join_rules.event_id().to_owned()],
@@ -287,7 +287,7 @@ impl TestStore<StateEvent> {
let charlie_mem = to_pdu_event(
"IMC",
charlie(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(charlie().to_string().as_str()),
member_content_join(),
&[cre, join_rules.event_id().to_owned()],
@@ -367,7 +367,7 @@ fn member_content_join() -> Box<RawJsonValue> {
fn to_pdu_event<S>(
id: &str,
sender: Box<UserId>,
ev_type: EventType,
ev_type: RoomEventType,
state_key: Option<&str>,
content: Box<RawJsonValue>,
auth_events: &[S],
@@ -413,7 +413,7 @@ fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event::<&EventId>(
"CREATE",
alice(),
EventType::RoomCreate,
RoomEventType::RoomCreate,
Some(""),
to_raw_json_value(&json!({ "creator": alice() })).unwrap(),
&[],
@@ -422,7 +422,7 @@ fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event(
"IMA",
alice(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(alice().to_string().as_str()),
member_content_join(),
&["CREATE"],
@@ -431,7 +431,7 @@ fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event(
"IPOWER",
alice(),
EventType::RoomPowerLevels,
RoomEventType::RoomPowerLevels,
Some(""),
to_raw_json_value(&json!({ "users": { alice().to_string(): 100 } })).unwrap(),
&["CREATE", "IMA"],
@@ -440,7 +440,7 @@ fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event(
"IJR",
alice(),
EventType::RoomJoinRules,
RoomEventType::RoomJoinRules,
Some(""),
to_raw_json_value(&RoomJoinRulesEventContent::new(JoinRule::Public)).unwrap(),
&["CREATE", "IMA", "IPOWER"],
@@ -449,7 +449,7 @@ fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event(
"IMB",
bob(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(bob().to_string().as_str()),
member_content_join(),
&["CREATE", "IJR", "IPOWER"],
@@ -458,7 +458,7 @@ fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event(
"IMC",
charlie(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(charlie().to_string().as_str()),
member_content_join(),
&["CREATE", "IJR", "IPOWER"],
@@ -467,7 +467,7 @@ fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event::<&EventId>(
"START",
charlie(),
EventType::RoomTopic,
RoomEventType::RoomTopic,
Some(""),
to_raw_json_value(&json!({})).unwrap(),
&[],
@@ -476,7 +476,7 @@ fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event::<&EventId>(
"END",
charlie(),
EventType::RoomTopic,
RoomEventType::RoomTopic,
Some(""),
to_raw_json_value(&json!({})).unwrap(),
&[],
@@ -495,7 +495,7 @@ fn BAN_STATE_SET() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event(
"PA",
alice(),
EventType::RoomPowerLevels,
RoomEventType::RoomPowerLevels,
Some(""),
to_raw_json_value(&json!({ "users": { alice(): 100, bob(): 50 } })).unwrap(),
&["CREATE", "IMA", "IPOWER"], // auth_events
@@ -504,7 +504,7 @@ fn BAN_STATE_SET() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event(
"PB",
alice(),
EventType::RoomPowerLevels,
RoomEventType::RoomPowerLevels,
Some(""),
to_raw_json_value(&json!({ "users": { alice(): 100, bob(): 50 } })).unwrap(),
&["CREATE", "IMA", "IPOWER"],
@@ -513,7 +513,7 @@ fn BAN_STATE_SET() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event(
"MB",
alice(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(ella().as_str()),
member_content_ban(),
&["CREATE", "IMA", "PB"],
@@ -522,7 +522,7 @@ fn BAN_STATE_SET() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event(
"IME",
ella(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(ella().as_str()),
member_content_join(),
&["CREATE", "IJR", "PA"],
@@ -536,7 +536,7 @@ fn BAN_STATE_SET() -> HashMap<Box<EventId>, Arc<StateEvent>> {
mod event {
use ruma_common::{
events::{pdu::Pdu, EventType},
events::{pdu::Pdu, RoomEventType},
EventId, MilliSecondsSinceUnixEpoch, RoomId, UserId,
};
use ruma_state_res::Event;
@@ -568,7 +568,7 @@ mod event {
}
}
fn event_type(&self) -> &EventType {
fn event_type(&self) -> &RoomEventType {
match &self.rest {
Pdu::RoomV1Pdu(ev) => &ev.kind,
Pdu::RoomV3Pdu(ev) => &ev.kind,

141
crates/ruma-state-res/src/event_auth.rs
View File

@@ -10,7 +10,7 @@ use ruma_common::{
power_levels::RoomPowerLevelsEventContent,
third_party_invite::RoomThirdPartyInviteEventContent,
},
EventType,
RoomEventType,
},
serde::{Base64, Raw},
RoomVersionId, UserId,
@@ -45,22 +45,22 @@ struct PowerLevelsContentInvite {
///
/// This function will return an error if the supplied `content` is not a JSON object.
pub fn auth_types_for_event(
kind: &EventType,
kind: &RoomEventType,
sender: &UserId,
state_key: Option<&str>,
content: &RawJsonValue,
) -> serde_json::Result<Vec<(EventType, String)>> {
if kind == &EventType::RoomCreate {
) -> serde_json::Result<Vec<(RoomEventType, String)>> {
if kind == &RoomEventType::RoomCreate {
return Ok(vec![]);
}
let mut auth_types = vec![
(EventType::RoomPowerLevels, "".to_owned()),
(EventType::RoomMember, sender.to_string()),
(EventType::RoomCreate, "".to_owned()),
(RoomEventType::RoomPowerLevels, "".to_owned()),
(RoomEventType::RoomMember, sender.to_string()),
(RoomEventType::RoomCreate, "".to_owned()),
];
if kind == &EventType::RoomMember {
if kind == &RoomEventType::RoomMember {
#[derive(Deserialize)]
struct RoomMemberContentFields {
membership: Option<Raw<MembershipState>>,
@@ -75,7 +75,7 @@ pub fn auth_types_for_event(
if [MembershipState::Join, MembershipState::Invite, MembershipState::Knock]
.contains(&membership)
{
let key = (EventType::RoomJoinRules, "".to_owned());
let key = (RoomEventType::RoomJoinRules, "".to_owned());
if !auth_types.contains(&key) {
auth_types.push(key);
}
@@ -83,21 +83,21 @@ pub fn auth_types_for_event(
if let Some(Ok(u)) =
content.join_authorised_via_users_server.map(|m| m.deserialize())
{
let key = (EventType::RoomMember, u.to_string());
let key = (RoomEventType::RoomMember, u.to_string());
if !auth_types.contains(&key) {
auth_types.push(key);
}
}
}
let key = (EventType::RoomMember, state_key.to_owned());
let key = (RoomEventType::RoomMember, state_key.to_owned());
if !auth_types.contains(&key) {
auth_types.push(key);
}
if membership == MembershipState::Invite {
if let Some(Ok(t_id)) = content.third_party_invite.map(|t| t.deserialize()) {
let key = (EventType::RoomThirdPartyInvite, t_id.signed.token);
let key = (RoomEventType::RoomThirdPartyInvite, t_id.signed.token);
if !auth_types.contains(&key) {
auth_types.push(key);
}
@@ -123,7 +123,7 @@ pub fn auth_check<E: Event>(
room_version: &RoomVersion,
incoming_event: impl Event,
current_third_party_invite: Option<impl Event>,
fetch_state: impl Fn(&EventType, &str) -> Option<E>,
fetch_state: impl Fn(&RoomEventType, &str) -> Option<E>,
) -> Result<bool> {
info!(
"auth_check beginning for {} ({})",
@@ -144,7 +144,7 @@ pub fn auth_check<E: Event>(
// Implementation of https://spec.matrix.org/v1.2/rooms/v1/#authorization-rules
//
// 1. If type is m.room.create:
if *incoming_event.event_type() == EventType::RoomCreate {
if *incoming_event.event_type() == RoomEventType::RoomCreate {
#[derive(Deserialize)]
struct RoomCreateContentFields {
room_version: Option<Raw<RoomVersionId>>,
@@ -208,7 +208,7 @@ pub fn auth_check<E: Event>(
}
*/
let room_create_event = match fetch_state(&EventType::RoomCreate, "") {
let room_create_event = match fetch_state(&RoomEventType::RoomCreate, "") {
None => {
warn!("no m.room.create event in auth chain");
return Ok(false);
@@ -228,7 +228,7 @@ pub fn auth_check<E: Event>(
// Only in some room versions 6 and below
if room_version.special_case_aliases_auth {
// 4. If type is m.room.aliases
if *incoming_event.event_type() == EventType::RoomAliases {
if *incoming_event.event_type() == RoomEventType::RoomAliases {
info!("starting m.room.aliases check");
// If sender's domain doesn't matches state_key, reject
@@ -243,10 +243,10 @@ pub fn auth_check<E: Event>(
}
// If type is m.room.member
let power_levels_event = fetch_state(&EventType::RoomPowerLevels, "");
let sender_member_event = fetch_state(&EventType::RoomMember, sender.as_str());
let power_levels_event = fetch_state(&RoomEventType::RoomPowerLevels, "");
let sender_member_event = fetch_state(&RoomEventType::RoomMember, sender.as_str());
if *incoming_event.event_type() == EventType::RoomMember {
if *incoming_event.event_type() == RoomEventType::RoomMember {
info!("starting m.room.member check");
let state_key = match incoming_event.state_key() {
None => {
@@ -270,7 +270,7 @@ pub fn auth_check<E: Event>(
let user_for_join_auth_membership = user_for_join_auth
.as_ref()
.and_then(|auth_user| fetch_state(&EventType::RoomMember, auth_user.as_str()))
.and_then(|auth_user| fetch_state(&RoomEventType::RoomMember, auth_user.as_str()))
.and_then(|mem| from_json_str::<GetMembership>(mem.content().get()).ok())
.map(|mem| mem.membership)
.unwrap_or(MembershipState::Leave);
@@ -278,13 +278,13 @@ pub fn auth_check<E: Event>(
if !valid_membership_change(
room_version,
target_user,
fetch_state(&EventType::RoomMember, target_user.as_str()).as_ref(),
fetch_state(&RoomEventType::RoomMember, target_user.as_str()).as_ref(),
sender,
sender_member_event.as_ref(),
&incoming_event,
current_third_party_invite,
power_levels_event.as_ref(),
fetch_state(&EventType::RoomJoinRules, "").as_ref(),
fetch_state(&RoomEventType::RoomJoinRules, "").as_ref(),
user_for_join_auth.as_deref(),
&user_for_join_auth_membership,
room_create_event,
@@ -338,7 +338,7 @@ pub fn auth_check<E: Event>(
// Allow if and only if sender's current power level is greater than
// or equal to the invite level
if *incoming_event.event_type() == EventType::RoomThirdPartyInvite {
if *incoming_event.event_type() == RoomEventType::RoomThirdPartyInvite {
let invite_level = match &power_levels_event {
Some(power_levels) => {
from_json_str::<PowerLevelsContentInvite>(power_levels.content().get())?.invite
@@ -360,7 +360,7 @@ pub fn auth_check<E: Event>(
}
// If type is m.room.power_levels
if *incoming_event.event_type() == EventType::RoomPowerLevels {
if *incoming_event.event_type() == RoomEventType::RoomPowerLevels {
info!("starting m.room.power_levels check");
if let Some(required_pwr_lvl) = check_power_levels(
@@ -388,7 +388,7 @@ pub fn auth_check<E: Event>(
// power levels.
if room_version.extra_redaction_checks
&& *incoming_event.event_type() == EventType::RoomRedaction
&& *incoming_event.event_type() == RoomEventType::RoomRedaction
{
#[derive(Deserialize)]
struct PowerLevelsContentRedact {
@@ -762,7 +762,6 @@ fn check_power_levels(
let old_list = &current_content.events;
let new_list = &user_content.events;
for ev_id in old_list.keys().chain(new_list.keys()) {
let ev_id: &EventType = ev_id;
event_levels_to_check.insert(ev_id);
}
@@ -889,7 +888,7 @@ fn check_redaction(
/// Helper function to fetch the power level needed to send an event of type
/// `e_type` based on the rooms "m.room.power_level" event.
fn get_send_level(
e_type: &EventType,
e_type: &RoomEventType,
state_key: Option<&str>,
power_lvl: Option<impl Event>,
) -> Int {
@@ -975,7 +974,7 @@ mod tests {
},
member::{MembershipState, RoomMemberEventContent},
},
EventType,
RoomEventType,
};
use serde_json::value::to_raw_value as to_raw_json_value;
@@ -1004,7 +1003,7 @@ mod tests {
let requester = to_pdu_event(
"HELLO",
alice(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(charlie().as_str()),
member_content_ban(),
&[],
@@ -1018,16 +1017,16 @@ mod tests {
assert!(valid_membership_change(
&RoomVersion::V6,
&target_user,
fetch_state(EventType::RoomMember, target_user.to_string()),
fetch_state(RoomEventType::RoomMember, target_user.to_string()),
&sender,
fetch_state(EventType::RoomMember, sender.to_string()),
fetch_state(RoomEventType::RoomMember, sender.to_string()),
&requester,
None::<StateEvent>,
fetch_state(EventType::RoomPowerLevels, "".to_owned()),
fetch_state(EventType::RoomJoinRules, "".to_owned()),
fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
None,
&MembershipState::Leave,
fetch_state(EventType::RoomCreate, "".to_owned()).unwrap(),
fetch_state(RoomEventType::RoomCreate, "".to_owned()).unwrap(),
)
.unwrap());
}
@@ -1048,7 +1047,7 @@ mod tests {
let requester = to_pdu_event(
"HELLO",
charlie(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(charlie().as_str()),
member_content_join(),
&["CREATE"],
@@ -1062,16 +1061,16 @@ mod tests {
assert!(!valid_membership_change(
&RoomVersion::V6,
&target_user,
fetch_state(EventType::RoomMember, target_user.to_string()),
fetch_state(RoomEventType::RoomMember, target_user.to_string()),
&sender,
fetch_state(EventType::RoomMember, sender.to_string()),
fetch_state(RoomEventType::RoomMember, sender.to_string()),
&requester,
None::<StateEvent>,
fetch_state(EventType::RoomPowerLevels, "".to_owned()),
fetch_state(EventType::RoomJoinRules, "".to_owned()),
fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
None,
&MembershipState::Leave,
fetch_state(EventType::RoomCreate, "".to_owned()).unwrap(),
fetch_state(RoomEventType::RoomCreate, "".to_owned()).unwrap(),
)
.unwrap());
}
@@ -1092,7 +1091,7 @@ mod tests {
let requester = to_pdu_event(
"HELLO",
alice(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(alice().as_str()),
member_content_join(),
&["CREATE"],
@@ -1106,16 +1105,16 @@ mod tests {
assert!(valid_membership_change(
&RoomVersion::V6,
&target_user,
fetch_state(EventType::RoomMember, target_user.to_string()),
fetch_state(RoomEventType::RoomMember, target_user.to_string()),
&sender,
fetch_state(EventType::RoomMember, sender.to_string()),
fetch_state(RoomEventType::RoomMember, sender.to_string()),
&requester,
None::<StateEvent>,
fetch_state(EventType::RoomPowerLevels, "".to_owned()),
fetch_state(EventType::RoomJoinRules, "".to_owned()),
fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
None,
&MembershipState::Leave,
fetch_state(EventType::RoomCreate, "".to_owned()).unwrap(),
fetch_state(RoomEventType::RoomCreate, "".to_owned()).unwrap(),
)
.unwrap());
}
@@ -1136,7 +1135,7 @@ mod tests {
let requester = to_pdu_event(
"HELLO",
charlie(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(alice().as_str()),
member_content_ban(),
&[],
@@ -1150,16 +1149,16 @@ mod tests {
assert!(!valid_membership_change(
&RoomVersion::V6,
&target_user,
fetch_state(EventType::RoomMember, target_user.to_string()),
fetch_state(RoomEventType::RoomMember, target_user.to_string()),
&sender,
fetch_state(EventType::RoomMember, sender.to_string()),
fetch_state(RoomEventType::RoomMember, sender.to_string()),
&requester,
None::<StateEvent>,
fetch_state(EventType::RoomPowerLevels, "".to_owned()),
fetch_state(EventType::RoomJoinRules, "".to_owned()),
fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
None,
&MembershipState::Leave,
fetch_state(EventType::RoomCreate, "".to_owned()).unwrap(),
fetch_state(RoomEventType::RoomCreate, "".to_owned()).unwrap(),
)
.unwrap());
}
@@ -1172,7 +1171,7 @@ mod tests {
*events.get_mut(&event_id("IJR")).unwrap() = to_pdu_event(
"IJR",
alice(),
EventType::RoomJoinRules,
RoomEventType::RoomJoinRules,
Some(""),
to_raw_json_value(&RoomJoinRulesEventContent::new(JoinRule::Restricted(
Restricted::new(vec![AllowRule::RoomMembership(RoomMembership::new(
@@ -1197,7 +1196,7 @@ mod tests {
let requester = to_pdu_event(
"HELLO",
ella(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(ella().as_str()),
to_raw_json_value(&RoomMemberEventContent::new(MembershipState::Join)).unwrap(),
&["CREATE", "IJR", "IPOWER", "new"],
@@ -1211,32 +1210,32 @@ mod tests {
assert!(valid_membership_change(
&RoomVersion::V9,
&target_user,
fetch_state(EventType::RoomMember, target_user.to_string()),
fetch_state(RoomEventType::RoomMember, target_user.to_string()),
&sender,
fetch_state(EventType::RoomMember, sender.to_string()),
fetch_state(RoomEventType::RoomMember, sender.to_string()),
&requester,
None::<StateEvent>,
fetch_state(EventType::RoomPowerLevels, "".to_owned()),
fetch_state(EventType::RoomJoinRules, "".to_owned()),
fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
Some(&alice()),
&MembershipState::Join,
fetch_state(EventType::RoomCreate, "".to_owned()).unwrap(),
fetch_state(RoomEventType::RoomCreate, "".to_owned()).unwrap(),
)
.unwrap());
assert!(!valid_membership_change(
&RoomVersion::V9,
&target_user,
fetch_state(EventType::RoomMember, target_user.to_string()),
fetch_state(RoomEventType::RoomMember, target_user.to_string()),
&sender,
fetch_state(EventType::RoomMember, sender.to_string()),
fetch_state(RoomEventType::RoomMember, sender.to_string()),
&requester,
None::<StateEvent>,
fetch_state(EventType::RoomPowerLevels, "".to_owned()),
fetch_state(EventType::RoomJoinRules, "".to_owned()),
fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
Some(&ella()),
&MembershipState::Leave,
fetch_state(EventType::RoomCreate, "".to_owned()).unwrap(),
fetch_state(RoomEventType::RoomCreate, "".to_owned()).unwrap(),
)
.unwrap());
}
@@ -1249,7 +1248,7 @@ mod tests {
*events.get_mut(&event_id("IJR")).unwrap() = to_pdu_event(
"IJR",
alice(),
EventType::RoomJoinRules,
RoomEventType::RoomJoinRules,
Some(""),
to_raw_json_value(&RoomJoinRulesEventContent::new(JoinRule::Knock)).unwrap(),
&["CREATE", "IMA", "IPOWER"],
@@ -1266,7 +1265,7 @@ mod tests {
let requester = to_pdu_event(
"HELLO",
ella(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(ella().as_str()),
to_raw_json_value(&RoomMemberEventContent::new(MembershipState::Knock)).unwrap(),
&[],
@@ -1280,16 +1279,16 @@ mod tests {
assert!(valid_membership_change(
&RoomVersion::V7,
&target_user,
fetch_state(EventType::RoomMember, target_user.to_string()),
fetch_state(RoomEventType::RoomMember, target_user.to_string()),
&sender,
fetch_state(EventType::RoomMember, sender.to_string()),
fetch_state(RoomEventType::RoomMember, sender.to_string()),
&requester,
None::<StateEvent>,
fetch_state(EventType::RoomPowerLevels, "".to_owned()),
fetch_state(EventType::RoomJoinRules, "".to_owned()),
fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
None,
&MembershipState::Leave,
fetch_state(EventType::RoomCreate, "".to_owned()).unwrap(),
fetch_state(RoomEventType::RoomCreate, "".to_owned()).unwrap(),
)
.unwrap());
}

95
crates/ruma-state-res/src/lib.rs
View File

@@ -10,7 +10,7 @@ use js_int::{int, Int};
use ruma_common::{
events::{
room::member::{MembershipState, RoomMemberEventContent},
EventType,
RoomEventType,
},
EventId, MilliSecondsSinceUnixEpoch, RoomVersionId, UserId,
};
@@ -31,7 +31,7 @@ pub use room_version::RoomVersion;
pub use state_event::Event;
/// A mapping of event type and state_key to some value `T`, usually an `EventId`.
pub type StateMap<T> = HashMap<(EventType, String), T>;
pub type StateMap<T> = HashMap<(RoomEventType, String), T>;
/// Resolve sets of state events as they come in.
///
@@ -132,7 +132,7 @@ where
trace!("{:?}", events_to_resolve);
// This "epochs" power level event
let power_event = resolved_control.get(&(EventType::RoomPowerLevels, "".into()));
let power_event = resolved_control.get(&(RoomEventType::RoomPowerLevels, "".into()));
debug!("power event: {:?}", power_event);
@@ -368,7 +368,7 @@ fn get_power_level_for_sender<E: Event>(
for aid in event.as_ref().map(|pdu| pdu.auth_events()).into_iter().flatten() {
if let Some(aev) = fetch_event(aid.borrow()) {
if is_type_and_key(&aev, &EventType::RoomPowerLevels, "") {
if is_type_and_key(&aev, &RoomEventType::RoomPowerLevels, "") {
pl = Some(aev);
break;
}
@@ -458,7 +458,7 @@ fn iterative_auth_check<E: Event + Clone>(
// The key for this is (eventType + a state_key of the signed token not sender) so
// search for it
let current_third_party = auth_events.iter().find_map(|(_, pdu)| {
(*pdu.event_type() == EventType::RoomThirdPartyInvite).then(|| pdu)
(*pdu.event_type() == RoomEventType::RoomThirdPartyInvite).then(|| pdu)
});
if auth_check(room_version, &event, current_third_party, |ty, key| {
@@ -509,7 +509,7 @@ fn mainline_sort<E: Event>(
for aid in event.auth_events() {
let ev = fetch_event(aid.borrow())
.ok_or_else(|| Error::NotFound(format!("Failed to find {}", aid)))?;
if is_type_and_key(&ev, &EventType::RoomPowerLevels, "") {
if is_type_and_key(&ev, &RoomEventType::RoomPowerLevels, "") {
pl = Some(aid.to_owned());
break;
}
@@ -568,7 +568,7 @@ fn get_mainline_depth<E: Event>(
for aid in sort_ev.auth_events() {
let aev = fetch_event(aid.borrow())
.ok_or_else(|| Error::NotFound(format!("Failed to find {}", aid)))?;
if is_type_and_key(&aev, &EventType::RoomPowerLevels, "") {
if is_type_and_key(&aev, &RoomEventType::RoomPowerLevels, "") {
event = Some(aev);
break;
}
@@ -610,16 +610,16 @@ fn is_power_event_id<E: Event>(event_id: &EventId, fetch: impl Fn(&EventId) -> O
}
}
fn is_type_and_key(ev: impl Event, ev_type: &EventType, state_key: &str) -> bool {
fn is_type_and_key(ev: impl Event, ev_type: &RoomEventType, state_key: &str) -> bool {
ev.event_type() == ev_type && ev.state_key() == Some(state_key)
}
fn is_power_event(event: impl Event) -> bool {
match event.event_type() {
EventType::RoomPowerLevels | EventType::RoomJoinRules | EventType::RoomCreate => {
event.state_key() == Some("")
}
EventType::RoomMember => {
RoomEventType::RoomPowerLevels
| RoomEventType::RoomJoinRules
| RoomEventType::RoomCreate => event.state_key() == Some(""),
RoomEventType::RoomMember => {
if let Ok(content) = from_json_str::<RoomMemberEventContent>(event.content().get()) {
if [MembershipState::Leave, MembershipState::Ban].contains(&content.membership) {
return Some(event.sender().as_str()) != event.state_key();
@@ -645,7 +645,7 @@ mod tests {
use ruma_common::{
events::{
room::join_rules::{JoinRule, RoomJoinRulesEventContent},
EventType,
RoomEventType,
},
EventId, MilliSecondsSinceUnixEpoch, RoomVersionId,
};
@@ -701,7 +701,8 @@ mod tests {
events_to_sort.shuffle(&mut rand::thread_rng());
let power_level = resolved_power.get(&(EventType::RoomPowerLevels, "".to_owned())).cloned();
let power_level =
resolved_power.get(&(RoomEventType::RoomPowerLevels, "".to_owned())).cloned();
let sorted_event_ids =
crate::mainline_sort(&events_to_sort, power_level, |id| events.get(id).map(Arc::clone))
@@ -740,28 +741,28 @@ mod tests {
to_init_pdu_event(
"PA",
alice(),
EventType::RoomPowerLevels,
RoomEventType::RoomPowerLevels,
Some(""),
to_raw_json_value(&json!({ "users": { alice(): 100, bob(): 50 } })).unwrap(),
),
to_init_pdu_event(
"MA",
alice(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(alice().to_string().as_str()),
member_content_join(),
),
to_init_pdu_event(
"MB",
alice(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(bob().to_string().as_str()),
member_content_ban(),
),
to_init_pdu_event(
"PB",
bob(),
EventType::RoomPowerLevels,
RoomEventType::RoomPowerLevels,
Some(""),
to_raw_json_value(&json!({ "users": { alice(): 100, bob(): 50 } })).unwrap(),
),
@@ -787,42 +788,42 @@ mod tests {
to_init_pdu_event(
"T1",
alice(),
EventType::RoomTopic,
RoomEventType::RoomTopic,
Some(""),
to_raw_json_value(&json!({})).unwrap(),
),
to_init_pdu_event(
"PA1",
alice(),
EventType::RoomPowerLevels,
RoomEventType::RoomPowerLevels,
Some(""),
to_raw_json_value(&json!({ "users": { alice(): 100, bob(): 50 } })).unwrap(),
),
to_init_pdu_event(
"T2",
alice(),
EventType::RoomTopic,
RoomEventType::RoomTopic,
Some(""),
to_raw_json_value(&json!({})).unwrap(),
),
to_init_pdu_event(
"PA2",
alice(),
EventType::RoomPowerLevels,
RoomEventType::RoomPowerLevels,
Some(""),
to_raw_json_value(&json!({ "users": { alice(): 100, bob(): 0 } })).unwrap(),
),
to_init_pdu_event(
"PB",
bob(),
EventType::RoomPowerLevels,
RoomEventType::RoomPowerLevels,
Some(""),
to_raw_json_value(&json!({ "users": { alice(): 100, bob(): 50 } })).unwrap(),
),
to_init_pdu_event(
"T3",
bob(),
EventType::RoomTopic,
RoomEventType::RoomTopic,
Some(""),
to_raw_json_value(&json!({})).unwrap(),
),
@@ -848,28 +849,28 @@ mod tests {
to_init_pdu_event(
"T1",
alice(),
EventType::RoomTopic,
RoomEventType::RoomTopic,
Some(""),
to_raw_json_value(&json!({})).unwrap(),
),
to_init_pdu_event(
"PA",
alice(),
EventType::RoomPowerLevels,
RoomEventType::RoomPowerLevels,
Some(""),
to_raw_json_value(&json!({ "users": { alice(): 100, bob(): 50 } })).unwrap(),
),
to_init_pdu_event(
"T2",
bob(),
EventType::RoomTopic,
RoomEventType::RoomTopic,
Some(""),
to_raw_json_value(&json!({})).unwrap(),
),
to_init_pdu_event(
"MB",
alice(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(bob().to_string().as_str()),
member_content_ban(),
),
@@ -895,14 +896,14 @@ mod tests {
to_init_pdu_event(
"JR",
alice(),
EventType::RoomJoinRules,
RoomEventType::RoomJoinRules,
Some(""),
to_raw_json_value(&RoomJoinRulesEventContent::new(JoinRule::Private)).unwrap(),
),
to_init_pdu_event(
"ME",
ella(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(ella().to_string().as_str()),
member_content_join(),
),
@@ -927,14 +928,14 @@ mod tests {
to_init_pdu_event(
"PA",
alice(),
EventType::RoomPowerLevels,
RoomEventType::RoomPowerLevels,
Some(""),
to_raw_json_value(&json!({ "users": { alice(): 100, bob(): 50 } })).unwrap(),
),
to_init_pdu_event(
"PB",
bob(),
EventType::RoomPowerLevels,
RoomEventType::RoomPowerLevels,
Some(""),
to_raw_json_value(&json!({ "users": { alice(): 100, bob(): 50, charlie(): 50 } }))
.unwrap(),
@@ -942,7 +943,7 @@ mod tests {
to_init_pdu_event(
"PC",
charlie(),
EventType::RoomPowerLevels,
RoomEventType::RoomPowerLevels,
Some(""),
to_raw_json_value(&json!({ "users": { alice(): 100, bob(): 50, charlie(): 0 } }))
.unwrap(),
@@ -968,56 +969,56 @@ mod tests {
to_init_pdu_event(
"T1",
alice(),
EventType::RoomTopic,
RoomEventType::RoomTopic,
Some(""),
to_raw_json_value(&json!({})).unwrap(),
),
to_init_pdu_event(
"PA1",
alice(),
EventType::RoomPowerLevels,
RoomEventType::RoomPowerLevels,
Some(""),
to_raw_json_value(&json!({ "users": { alice(): 100, bob(): 50 } })).unwrap(),
),
to_init_pdu_event(
"T2",
alice(),
EventType::RoomTopic,
RoomEventType::RoomTopic,
Some(""),
to_raw_json_value(&json!({})).unwrap(),
),
to_init_pdu_event(
"PA2",
alice(),
EventType::RoomPowerLevels,
RoomEventType::RoomPowerLevels,
Some(""),
to_raw_json_value(&json!({ "users": { alice(): 100, bob(): 0 } })).unwrap(),
),
to_init_pdu_event(
"PB",
bob(),
EventType::RoomPowerLevels,
RoomEventType::RoomPowerLevels,
Some(""),
to_raw_json_value(&json!({ "users": { alice(): 100, bob(): 50 } })).unwrap(),
),
to_init_pdu_event(
"T3",
bob(),
EventType::RoomTopic,
RoomEventType::RoomTopic,
Some(""),
to_raw_json_value(&json!({})).unwrap(),
),
to_init_pdu_event(
"MZ1",
zara(),
EventType::RoomTopic,
RoomEventType::RoomTopic,
Some(""),
to_raw_json_value(&json!({})).unwrap(),
),
to_init_pdu_event(
"T4",
alice(),
EventType::RoomTopic,
RoomEventType::RoomTopic,
Some(""),
to_raw_json_value(&json!({})).unwrap(),
),
@@ -1212,7 +1213,7 @@ mod tests {
to_pdu_event(
"PA",
alice(),
EventType::RoomPowerLevels,
RoomEventType::RoomPowerLevels,
Some(""),
to_raw_json_value(&json!({ "users": { alice(): 100, bob(): 50 } })).unwrap(),
&["CREATE", "IMA", "IPOWER"], // auth_events
@@ -1221,7 +1222,7 @@ mod tests {
to_pdu_event(
"PB",
alice(),
EventType::RoomPowerLevels,
RoomEventType::RoomPowerLevels,
Some(""),
to_raw_json_value(&json!({ "users": { alice(): 100, bob(): 50 } })).unwrap(),
&["CREATE", "IMA", "IPOWER"],
@@ -1230,7 +1231,7 @@ mod tests {
to_pdu_event(
"MB",
alice(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(ella().as_str()),
member_content_ban(),
&["CREATE", "IMA", "PB"],
@@ -1239,7 +1240,7 @@ mod tests {
to_pdu_event(
"IME",
ella(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(ella().as_str()),
member_content_join(),
&["CREATE", "IJR", "PA"],
@@ -1257,7 +1258,7 @@ mod tests {
to_pdu_event(
"JR",
alice(),
EventType::RoomJoinRules,
RoomEventType::RoomJoinRules,
Some(""),
to_raw_json_value(&json!({ "join_rule": "invite" })).unwrap(),
&["CREATE", "IMA", "IPOWER"],
@@ -1266,7 +1267,7 @@ mod tests {
to_pdu_event(
"IMZ",
zara(),
EventType::RoomPowerLevels,
RoomEventType::RoomPowerLevels,
Some(zara().as_str()),
member_content_join(),
&["CREATE", "JR", "IPOWER"],

8
crates/ruma-state-res/src/state_event.rs
View File

@@ -5,7 +5,7 @@ use std::{
sync::Arc,
};
use ruma_common::{events::EventType, EventId, MilliSecondsSinceUnixEpoch, RoomId, UserId};
use ruma_common::{events::RoomEventType, EventId, MilliSecondsSinceUnixEpoch, RoomId, UserId};
use serde_json::value::RawValue as RawJsonValue;
/// Abstraction of a PDU so users can have their own PDU types.
@@ -25,7 +25,7 @@ pub trait Event {
fn origin_server_ts(&self) -> MilliSecondsSinceUnixEpoch;
/// The event type.
fn event_type(&self) -> &EventType;
fn event_type(&self) -> &RoomEventType;
/// The event's content.
fn content(&self) -> &RawJsonValue;
@@ -64,7 +64,7 @@ impl<T: Event> Event for &T {
(*self).origin_server_ts()
}
fn event_type(&self) -> &EventType {
fn event_type(&self) -> &RoomEventType {
(*self).event_type()
}
@@ -108,7 +108,7 @@ impl<T: Event> Event for Arc<T> {
(**self).origin_server_ts()
}
fn event_type(&self) -> &EventType {
fn event_type(&self) -> &RoomEventType {
(**self).event_type()
}

40
crates/ruma-state-res/src/test_utils.rs
View File

@@ -17,7 +17,7 @@ use ruma_common::{
join_rules::{JoinRule, RoomJoinRulesEventContent},
member::{MembershipState, RoomMemberEventContent},
},
EventType,
RoomEventType,
},
room_id, user_id, EventId, MilliSecondsSinceUnixEpoch, RoomId, RoomVersionId, UserId,
};
@@ -198,7 +198,7 @@ pub fn do_check(
// Filter out the dummy messages events.
// These act as points in time where there should be a known state to
// test against.
&& **k != (EventType::RoomMessage, "dummy".to_owned())
&& **k != (RoomEventType::RoomMessage, "dummy".to_owned())
})
.map(|(k, v)| (k.clone(), v.clone()))
.collect::<StateMap<Box<EventId>>>();
@@ -252,7 +252,7 @@ impl TestStore<StateEvent> {
let create_event = to_pdu_event::<&EventId>(
"CREATE",
alice(),
EventType::RoomCreate,
RoomEventType::RoomCreate,
Some(""),
to_raw_json_value(&json!({ "creator": alice() })).unwrap(),
&[],
@@ -264,7 +264,7 @@ impl TestStore<StateEvent> {
let alice_mem = to_pdu_event(
"IMA",
alice(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(alice().to_string().as_str()),
member_content_join(),
&[cre.clone()],
@@ -275,7 +275,7 @@ impl TestStore<StateEvent> {
let join_rules = to_pdu_event(
"IJR",
alice(),
EventType::RoomJoinRules,
RoomEventType::RoomJoinRules,
Some(""),
to_raw_json_value(&RoomJoinRulesEventContent::new(JoinRule::Public)).unwrap(),
&[cre.clone(), alice_mem.event_id().to_owned()],
@@ -288,7 +288,7 @@ impl TestStore<StateEvent> {
let bob_mem = to_pdu_event(
"IMB",
bob(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(bob().to_string().as_str()),
member_content_join(),
&[cre.clone(), join_rules.event_id().to_owned()],
@@ -299,7 +299,7 @@ impl TestStore<StateEvent> {
let charlie_mem = to_pdu_event(
"IMC",
charlie(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(charlie().to_string().as_str()),
member_content_join(),
&[cre, join_rules.event_id().to_owned()],
@@ -384,7 +384,7 @@ pub fn member_content_join() -> Box<RawJsonValue> {
pub fn to_init_pdu_event(
id: &str,
sender: Box<UserId>,
ev_type: EventType,
ev_type: RoomEventType,
state_key: Option<&str>,
content: Box<RawJsonValue>,
) -> Arc<StateEvent> {
@@ -417,7 +417,7 @@ pub fn to_init_pdu_event(
pub fn to_pdu_event<S>(
id: &str,
sender: Box<UserId>,
ev_type: EventType,
ev_type: RoomEventType,
state_key: Option<&str>,
content: Box<RawJsonValue>,
auth_events: &[S],
@@ -461,7 +461,7 @@ pub fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event::<&EventId>(
"CREATE",
alice(),
EventType::RoomCreate,
RoomEventType::RoomCreate,
Some(""),
to_raw_json_value(&json!({ "creator": alice() })).unwrap(),
&[],
@@ -470,7 +470,7 @@ pub fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event(
"IMA",
alice(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(alice().to_string().as_str()),
member_content_join(),
&["CREATE"],
@@ -479,7 +479,7 @@ pub fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event(
"IPOWER",
alice(),
EventType::RoomPowerLevels,
RoomEventType::RoomPowerLevels,
Some(""),
to_raw_json_value(&json!({ "users": { alice().to_string(): 100 } })).unwrap(),
&["CREATE", "IMA"],
@@ -488,7 +488,7 @@ pub fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event(
"IJR",
alice(),
EventType::RoomJoinRules,
RoomEventType::RoomJoinRules,
Some(""),
to_raw_json_value(&RoomJoinRulesEventContent::new(JoinRule::Public)).unwrap(),
&["CREATE", "IMA", "IPOWER"],
@@ -497,7 +497,7 @@ pub fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event(
"IMB",
bob(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(bob().to_string().as_str()),
member_content_join(),
&["CREATE", "IJR", "IPOWER"],
@@ -506,7 +506,7 @@ pub fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event(
"IMC",
charlie(),
EventType::RoomMember,
RoomEventType::RoomMember,
Some(charlie().to_string().as_str()),
member_content_join(),
&["CREATE", "IJR", "IPOWER"],
@@ -515,7 +515,7 @@ pub fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event::<&EventId>(
"START",
charlie(),
EventType::RoomMessage,
RoomEventType::RoomMessage,
Some("dummy"),
to_raw_json_value(&json!({})).unwrap(),
&[],
@@ -524,7 +524,7 @@ pub fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
to_pdu_event::<&EventId>(
"END",
charlie(),
EventType::RoomMessage,
RoomEventType::RoomMessage,
Some("dummy"),
to_raw_json_value(&json!({})).unwrap(),
&[],
@@ -542,7 +542,7 @@ pub fn INITIAL_EVENTS_CREATE_ROOM() -> HashMap<Box<EventId>, Arc<StateEvent>> {
vec![to_pdu_event::<&EventId>(
"CREATE",
alice(),
EventType::RoomCreate,
RoomEventType::RoomCreate,
Some(""),
to_raw_json_value(&json!({ "creator": alice() })).unwrap(),
&[],
@@ -563,7 +563,7 @@ pub fn INITIAL_EDGES() -> Vec<Box<EventId>> {
pub mod event {
use ruma_common::{
events::{pdu::Pdu, EventType},
events::{pdu::Pdu, RoomEventType},
EventId, MilliSecondsSinceUnixEpoch, RoomId, UserId,
};
use serde::{Deserialize, Serialize};
@@ -596,7 +596,7 @@ pub mod event {
}
}
fn event_type(&self) -> &EventType {
fn event_type(&self) -> &RoomEventType {
match &self.rest {
Pdu::RoomV1Pdu(ev) => &ev.kind,
Pdu::RoomV3Pdu(ev) => &ev.kind,