refactor: Ruma upstraming, bake a little more

src/service/rooms/timeline/append.rs

@@ -18,10 +18,7 @@ use ruma::{
 	events::{
 		GlobalAccountDataEventType, TimelineEventType,
 		push_rules::PushRulesEvent,
-		room::{
-			encrypted::Relation,
-			redaction::RoomRedactionEventContent,
-		},
+		room::{encrypted::Relation, redaction::RoomRedactionEventContent},
 	},
 	push::{Action, Ruleset, Tweak},
 };
@@ -204,7 +201,11 @@ where
 	drop(insert_lock);
 
 	// See if the event matches any known pushers via power level
-	let power_levels = self.services.state_accessor.get_room_power_levels(room_id).await;
+	let power_levels = self
+		.services
+		.state_accessor
+		.get_room_power_levels(room_id)
+		.await;
 	let mut push_target: HashSet<_> = self
 			.services
 			.state_cache
@@ -251,7 +252,7 @@ where
 		{
 			match action {
 				| Action::Notify => notify = true,
-				| Action::SetTweak(Tweak::Highlight(true)) => {
+				| Action::SetTweak(Tweak::Highlight(ruma::push::HighlightTweakValue::Yes)) => {
 					highlight = true;
 				},
 				| _ => {},
@@ -366,10 +367,12 @@ where
 
 	if let Ok(content) = pdu.get_content::<ExtractRelatesTo>() {
 		match content.relates_to {
-			| Relation::Reply { in_reply_to } => {
+			| Relation::Reply(in_reply_to) => {
 				// We need to do it again here, because replies don't have
 				// event_id as a top level field
-				if let Ok(related_pducount) = self.get_pdu_count(&in_reply_to.event_id).await {
+				if let Ok(related_pducount) =
+					self.get_pdu_count(&in_reply_to.in_reply_to.event_id).await
+				{
 					self.services
 						.pdu_metadata
 						.add_relation(count2, related_pducount);

src/service/rooms/timeline/backfill.rs

@@ -12,10 +12,16 @@ use conduwuit_core::{
 };
 use futures::{FutureExt, Stream, StreamExt};
 use ruma::{
-	CanonicalJsonObject, EventId, Int, OwnedServerName, RoomId, ServerName, api::federation, events::{
+	CanonicalJsonObject, EventId, Int, OwnedServerName, RoomId, ServerName,
+	api::federation,
+	events::{
 		StateEventType, TimelineEventType,
-		room::{create::RoomCreateEventContent, power_levels::{RoomPowerLevelsEventContent, UserPowerLevel}},
-	}, uint
+		room::{
+			create::RoomCreateEventContent,
+			power_levels::{RoomPowerLevelsEventContent, UserPowerLevel},
+		},
+	},
+	uint,
 };
 use serde_json::value::RawValue as RawJsonValue;
 
@@ -66,7 +72,11 @@ pub async fn backfill_if_required(&self, room_id: &RoomId, from: PduCount) -> Re
 			.sending
 			.send_federation_request(
 				&backfill_server,
-				federation::backfill::get_backfill::v1::Request::new(room_id.to_owned(), vec![first_pdu.1.event_id().to_owned()], uint!(100))
+				federation::backfill::get_backfill::v1::Request::new(
+					room_id.to_owned(),
+					vec![first_pdu.1.event_id().to_owned()],
+					uint!(100),
+				),
 			)
 			.await;
 		match response {
@@ -125,7 +135,10 @@ pub async fn get_remote_pdu(&self, room_id: &RoomId, event_id: &EventId) -> Resu
 		let value = self
 			.services
 			.sending
-			.send_federation_request(&backfill_server, federation::event::get_event::v1::Request::new(event_id.to_owned()))
+			.send_federation_request(
+				&backfill_server,
+				federation::event::get_event::v1::Request::new(event_id.to_owned()),
+			)
 			.await
 			.and_then(|response| {
 				serde_json::from_str::<CanonicalJsonObject>(response.pdu.get()).map_err(|e| {
@@ -220,7 +233,11 @@ pub async fn backfill_pdu(&self, origin: &ServerName, pdu: Box<RawJsonValue>) ->
 async fn candidate_backfill_servers(&self, room_id: &RoomId) -> HashSet<OwnedServerName> {
 	let mut candidate_backfill_servers = HashSet::new();
 
-	let power_levels = self.services.state_accessor.get_room_power_levels(room_id).await;
+	let power_levels = self
+		.services
+		.state_accessor
+		.get_room_power_levels(room_id)
+		.await;
 
 	// Insert servers of room creators
 	if let Some(creators) = &power_levels.rules.privileged_creators {
@@ -237,19 +254,30 @@ async fn candidate_backfill_servers(&self, room_id: &RoomId) -> HashSet<OwnedSer
 	}
 
 	// Insert the canonical room alias server
-	if let Ok(canonical_alias) = self.services.state_accessor.get_canonical_alias(room_id).await {
+	if let Ok(canonical_alias) = self
+		.services
+		.state_accessor
+		.get_canonical_alias(room_id)
+		.await
+	{
 		candidate_backfill_servers.insert(canonical_alias.server_name().to_owned());
 	}
 
 	// Insert all trusted servers in the config
-	candidate_backfill_servers.extend(self.services.server.config.trusted_servers.iter().cloned());
+	candidate_backfill_servers
+		.extend(self.services.server.config.trusted_servers.iter().cloned());
 
 	// Remove our own name, we can't request backfill from ourselves
 	candidate_backfill_servers.remove(self.services.globals.server_name());
 
 	// Remove all servers that aren't in the room
 	for server in candidate_backfill_servers.clone() {
-		if !self.services.state_cache.server_in_room(&server, room_id).await {
+		if !self
+			.services
+			.state_cache
+			.server_in_room(&server, room_id)
+			.await
+		{
 			candidate_backfill_servers.remove(&server);
 		}
 	}

src/service/rooms/timeline/build.rs

@@ -140,7 +140,7 @@ pub async fn build_and_append_pdu(
 					body,
 					Some(pdu.event_id().into()),
 					source,
-					pdu.sender.clone().into(),
+					pdu.sender.clone(),
 				)?;
 			}
 		}

src/service/rooms/timeline/create.rs

@@ -96,7 +96,7 @@ pub async fn create_event(
 		event_type,
 		room_id.as_ref().map_or("None", |id| id.as_str())
 	);
-	let room_version_id = match room_id {
+	let room_version = match room_id {
 		| Some(room_id) => {
 			trace!(%room_id, "Looking up existing room ID");
 			self.services
@@ -114,7 +114,7 @@ pub async fn create_event(
 		| None => {
 			trace!("No room ID, assuming room creation");
 			room_version_from_event(
-				RoomId::new(self.services.globals.server_name()),
+				RoomId::new_v1(self.services.globals.server_name()),
 				&event_type.clone(),
 				&content.clone(),
 			)?
@@ -261,7 +261,7 @@ pub async fn create_event(
 		pdu.event_id,
 		pdu.room_id.as_ref().map_or("None", |id| id.as_str())
 	);
-	Ok((pdu, room_version_id))
+	Ok((pdu, room_version))
 }
 
 #[implement(super::Service)]
@@ -276,7 +276,7 @@ pub async fn create_hash_and_sign_event(
 	if !self.services.globals.user_is_local(sender) {
 		return Err!(Request(Forbidden("Sender must be a local user")));
 	}
-	let (mut pdu, room_version_id) = self
+	let (mut pdu, room_version) = self
 		.create_event(pdu_builder, sender, room_id, mutex_lock)
 		.await?;
 	// Hash and sign
@@ -292,7 +292,7 @@ pub async fn create_hash_and_sign_event(
 		.hash_and_sign_event(&mut pdu_json, &room_version)
 	{
 		return match e {
-			| Error::Signatures(ruma::signatures::Error::PduSize) => {
+			| Error::SignatureJson(ruma::signatures::JsonError::PduTooLarge) => {
 				Err!(Request(TooLarge("Message/PDU is too long (exceeds 65535 bytes)")))
 			},
 			| _ => Err!(Request(Unknown(warn!("Signing event failed: {e}")))),