refactor: Ruma upstreaming, half-baked edition

Co-authored-by: Jade Ellis <jade@ellis.link>
2026-05-26 20:49:55 +00:00 · 2026-03-29 12:25:42 -04:00
parent 1cc9dbf2a4
commit 204bc1367e
141 changed files with 2715 additions and 2279 deletions
@@ -15,20 +15,16 @@ use conduwuit::{
 };
 use futures::{FutureExt, StreamExt};
 use ruma::{
-	CanonicalJsonObject, CanonicalJsonValue, OwnedEventId, OwnedRoomId, OwnedServerName, RoomId,
-	RoomVersionId, UserId,
-	api::{
+	CanonicalJsonObject, CanonicalJsonValue, OwnedEventId, OwnedRoomId, OwnedServerName, OwnedUserId, RoomId, RoomVersionId, UserId, api::{
 		client::knock::knock_room,
 		federation::{self},
-	},
-	canonical_json::to_canonical_value,
-	events::{
+	}, canonical_json::to_canonical_value, events::{
 		StateEventType,
 		room::{
 			join_rules::{AllowRule, JoinRule},
 			member::{MembershipState, RoomMemberEventContent},
 		},
-	},
+	}
 };
 use service::{
 	Services,
@@ -73,7 +69,6 @@ pub(crate) async fn knock_room_route(
 					.rooms
 					.state_cache
 					.servers_invite_via(&room_id)
-					.map(ToOwned::to_owned)
 					.collect::<Vec<_>>()
 					.await,
 			);
@@ -116,8 +111,7 @@ pub(crate) async fn knock_room_route(
 			let addl_via_servers = services
 				.rooms
 				.state_cache
-				.servers_invite_via(&room_id)
-				.map(ToOwned::to_owned);
+				.servers_invite_via(&room_id);

 			let addl_state_servers = services
 				.rooms
@@ -130,7 +124,7 @@ pub(crate) async fn knock_room_route(
 				.iter()
 				.map(|event| event.get_field("sender"))
 				.filter_map(FlatOk::flat_ok)
-				.map(|user: &UserId| user.server_name().to_owned())
+				.map(|user: OwnedUserId| user.server_name().to_owned())
 				.stream()
 				.chain(addl_via_servers)
 				.collect()
@@ -188,7 +182,7 @@ async fn knock_room_by_id_helper(
 		.await
 	{
 		debug_warn!("{sender_user} is already knocked in {room_id}");
-		return Ok(knock_room::v3::Response { room_id: room_id.into() });
+		return Ok(knock_room::v3::Response::new(room_id.into()));
 	}

 	if let Ok(membership) = services
@@ -353,13 +347,11 @@ async fn knock_room_helper_local(
 		return Err!(Request(Forbidden("This room does not support knocking.")));
 	}

-	let content = RoomMemberEventContent {
-		displayname: services.users.displayname(sender_user).await.ok(),
-		avatar_url: services.users.avatar_url(sender_user).await.ok(),
-		blurhash: services.users.blurhash(sender_user).await.ok(),
-		reason: reason.clone(),
-		..RoomMemberEventContent::new(MembershipState::Knock)
-	};
+	let mut content = RoomMemberEventContent::new(MembershipState::Knock);
+	content.displayname = services.users.displayname(sender_user).await.ok();
+	content.avatar_url = services.users.avatar_url(sender_user).await.ok();
+	content.blurhash = services.users.blurhash(sender_user).await.ok();
+	content.reason = reason.clone();

 	// Try normal knock first
 	let Err(error) = services
@@ -424,13 +416,7 @@ async fn knock_room_helper_local(
 	);
 	knock_event_stub.insert(
 		"content".to_owned(),
-		to_canonical_value(RoomMemberEventContent {
-			displayname: services.users.displayname(sender_user).await.ok(),
-			avatar_url: services.users.avatar_url(sender_user).await.ok(),
-			blurhash: services.users.blurhash(sender_user).await.ok(),
-			reason,
-			..RoomMemberEventContent::new(MembershipState::Knock)
-		})
+		to_canonical_value(content)
 		.expect("event is valid, we just created it"),
 	);

@@ -451,14 +437,14 @@ async fn knock_room_helper_local(
 	let knock_event = knock_event_stub;

 	info!("Asking {remote_server} for send_knock in room {room_id}");
-	let send_knock_request = federation::knock::send_knock::v1::Request {
-		room_id: room_id.to_owned(),
-		event_id: event_id.clone(),
-		pdu: services
+	let send_knock_request = federation::membership::create_knock_event::v1::Request::new(
+		room_id.to_owned(),
+		event_id.clone(),
+		services
 			.sending
 			.convert_to_outgoing_federation_event(knock_event.clone())
 			.await,
-	};
+	);

 	services
 		.sending
@@ -545,15 +531,16 @@ async fn knock_room_helper_remote(
 				.expect("Timestamp is valid js_int value"),
 		),
 	);
+
+	let mut knock_content = RoomMemberEventContent::new(MembershipState::Knock);
+	knock_content.displayname = services.users.displayname(sender_user).await.ok();
+	knock_content.avatar_url = services.users.avatar_url(sender_user).await.ok();
+	knock_content.blurhash = services.users.blurhash(sender_user).await.ok();
+	knock_content.reason = reason;
+
 	knock_event_stub.insert(
 		"content".to_owned(),
-		to_canonical_value(RoomMemberEventContent {
-			displayname: services.users.displayname(sender_user).await.ok(),
-			avatar_url: services.users.avatar_url(sender_user).await.ok(),
-			blurhash: services.users.blurhash(sender_user).await.ok(),
-			reason,
-			..RoomMemberEventContent::new(MembershipState::Knock)
-		})
+		to_canonical_value(knock_content)
 		.expect("event is valid, we just created it"),
 	);

@@ -574,18 +561,18 @@ async fn knock_room_helper_remote(
 	let knock_event = knock_event_stub;

 	info!("Asking {remote_server} for send_knock in room {room_id}");
-	let send_knock_request = federation::knock::send_knock::v1::Request {
-		room_id: room_id.to_owned(),
-		event_id: event_id.clone(),
-		pdu: services
+	let request = federation::membership::create_knock_event::v1::Request::new(
+		room_id.to_owned(),
+		event_id.clone(),
+		services
 			.sending
 			.convert_to_outgoing_federation_event(knock_event.clone())
-			.await,
-	};
+			.await
+	);

 	let send_knock_response = services
 		.sending
-		.send_federation_request(&remote_server, send_knock_request)
+		.send_federation_request(&remote_server, request)
 		.await?;

 	info!("send_knock finished");
@@ -604,7 +591,20 @@ async fn knock_room_helper_remote(
 	let state = send_knock_response
 		.knock_room_state
 		.iter()
-		.map(|event| serde_json::from_str::<CanonicalJsonObject>(event.clone().into_json().get()))
+		.map(|event| {
+			#[allow(deprecated)]
+			let raw_value = match event {
+				federation::membership::RawStrippedState::Stripped(raw_state) => {
+					&raw_state.clone().into_json()
+				},
+				federation::membership::RawStrippedState::Pdu(raw_value) => {
+					raw_value
+				},
+				_ => panic!("unknown raw stripped state type"),
+			};
+
+			serde_json::from_str::<CanonicalJsonObject>(raw_value.get())
+		})
 		.filter_map(Result::ok);

 	let mut state_map: HashMap<u64, OwnedEventId> = HashMap::new();
@@ -709,7 +709,7 @@ async fn make_knock_request(
 	sender_user: &UserId,
 	room_id: &RoomId,
 	servers: &[OwnedServerName],
-) -> Result<(federation::knock::create_knock_event_template::v1::Response, OwnedServerName)> {
+) -> Result<(federation::membership::prepare_knock_event::v1::Response, OwnedServerName)> {
 	let mut make_knock_response_and_server =
 		Err!(BadServerResponse("No server available to assist in knocking."));

@@ -722,15 +722,14 @@ async fn make_knock_request(

 		info!("Asking {remote_server} for make_knock ({make_knock_counter})");

+		let mut request = federation::membership::prepare_knock_event::v1::Request::new(room_id.to_owned(), sender_user.to_owned());
+		request.ver = services.server.supported_room_versions().collect();
+
 		let make_knock_response = services
 			.sending
 			.send_federation_request(
 				remote_server,
-				federation::knock::create_knock_event_template::v1::Request {
-					room_id: room_id.to_owned(),
-					user_id: sender_user.to_owned(),
-					ver: services.server.supported_room_versions().collect(),
-				},
+				request,
 			)
 			.await;