feat: Combine local & remote force join

src/admin/debug/commands.rs

@@ -6,24 +6,24 @@ use std::{
 };
 
 use conduwuit::{
-	debug_error, err, info, matrix::{
+	Err, Result, debug_error, err, info,
-		pdu::{PduEvent, PduId, RawPduId},
+	matrix::{
 		Event,
-	}, trace,
+		pdu::{PduEvent, PduId, RawPduId},
-	utils,
+	},
+	trace, utils,
 	utils::{
 		stream::{IterStream, ReadyExt},
 		string::EMPTY,
-	}, warn,
+	},
-	Err,
+	warn,
-	Result,
 };
 use futures::{FutureExt, StreamExt, TryStreamExt};
 use lettre::message::Mailbox;
 use ruma::{
-	api::federation::event::get_room_state, events::AnyStateEvent, serde::Raw, CanonicalJsonObject, CanonicalJsonValue,
+	CanonicalJsonObject, CanonicalJsonValue, EventId, OwnedEventId, OwnedRoomId,
-	EventId, OwnedEventId, OwnedRoomId, OwnedRoomOrAliasId, OwnedServerName,
+	OwnedRoomOrAliasId, OwnedServerName, RoomId, RoomVersionId, UInt,
-	RoomId, RoomVersionId, UInt,
+	api::federation::event::get_room_state, events::AnyStateEvent, serde::Raw,
 };
 use service::rooms::{
 	short::{ShortEventId, ShortRoomId},
@@ -98,7 +98,8 @@ fn render_node(
 		| NodeStatus::Normal(false) => format!("{evt_str}: {name}"),
 		| NodeStatus::Normal(true) => format!("{evt_str}: {name} (missing locally)"),
 		| NodeStatus::SoftFailed(false) => format!("{evt_str}: {name} (soft-failed)"),
-		| NodeStatus::SoftFailed(true) => format!("{evt_str}: {name} (soft-failed & missing locally)"),
+		| NodeStatus::SoftFailed(true) =>
+			format!("{evt_str}: {name} (soft-failed & missing locally)"),
 		| NodeStatus::Rejected(false) => format!("{evt_str}: {name} (rejected)"),
 		| NodeStatus::Rejected(true) => format!("{evt_str}: {name} (rejected & missing locally)"),
 	};
@@ -186,7 +187,13 @@ pub(super) async fn show_auth_chain(&self, event_id: OwnedEventId) -> Result {
 		let current_node_id = node_id_for(&current_event_id, &mut node_ids, &mut next_node_id);
 		let current_status = node_status(&current_event_id, false).await;
 
-		render_node(&mut graph, &current_node_id, &current_event_id, &node_name(&event), current_status)?;
+		render_node(
+			&mut graph,
+			&current_node_id,
+			&current_event_id,
+			&node_name(&event),
+			current_status,
+		)?;
 
 		let mut children = Vec::with_capacity(event.auth_events.len());
 		for auth_event_id in event.auth_events().rev() {

src/admin/user/commands.rs

@@ -740,14 +740,19 @@ pub(super) async fn force_join_room(
 	&self,
 	user_id: String,
 	room_id: OwnedRoomOrAliasId,
+	via: Option<String>,
 ) -> Result {
 	let user_id = parse_local_user_id(self.services, &user_id)?;
-	let (room_id, servers) = self
+	let (room_id, mut servers) = self
 		.services
 		.rooms
 		.alias
 		.resolve_with_servers(&room_id, None)
 		.await?;
+	if let Some(via) = via.map(ServerName::parse).transpose()? {
+		servers.retain(|n| *n != via);
+		servers.insert(0, via);
+	}
 
 	assert!(
 		self.services.globals.user_is_local(&user_id),
@@ -763,41 +768,6 @@ pub(super) async fn force_join_room(
 		.await
 }
 
-#[admin_command]
-pub(super) async fn force_join_room_remotely(
-	&self,
-	user_id: String,
-	room_id: OwnedRoomOrAliasId,
-	via: String,
-) -> Result {
-	let via = ServerName::parse(&via)?;
-	let user_id = parse_local_user_id(self.services, &user_id)?;
-	let (room_id, mut servers) = self
-		.services
-		.rooms
-		.alias
-		.resolve_with_servers(&room_id, None)
-		.await?;
-	if servers.contains(&via) {
-		servers.retain(|n| *n != via);
-	}
-	servers.insert(0, via);
-
-	assert!(
-		self.services.globals.user_is_local(&user_id),
-		"Parsed user_id must be a local user"
-	);
-	let state_lock = self.services.rooms.state.mutex.lock(&*room_id).await;
-	self.services
-		.rooms
-		.membership
-		.join_remote_room(&user_id, &room_id, None, &servers, state_lock)
-		.await?;
-
-	self.write_str(&format!("{user_id} has been joined to {room_id}."))
-		.await
-}
-
 #[admin_command]
 pub(super) async fn force_leave_room(
 	&self,

src/admin/user/mod.rs

@@ -179,13 +179,6 @@ pub enum UserCommand {
 
 	/// Manually join a local user to a room.
 	ForceJoinRoom {
-		user_id: String,
-		room_id: OwnedRoomOrAliasId,
-	},
-
-	/// Manually join a local user to a room via a remote server, regardless of
-	/// our current residency.
-	ForceJoinRoomRemotely {
 		/// The user to join
 		user_id: String,
 		/// The room to join
@@ -194,7 +187,7 @@ pub enum UserCommand {
 		///
 		/// This server will always be tried first, however if more are
 		/// available, they may be tried after.
-		via: String,
+		via: Option<String>,
 	},
 
 	/// Manually leave a local user from a room.

src/service/rooms/event_handler/upgrade_outlier_pdu.rs

@@ -1,17 +1,17 @@
 use std::{borrow::Borrow, collections::BTreeMap, sync::Arc, time::Instant};
 
 use conduwuit::{
-	debug, debug_info, debug_warn, err, implement, is_equal_to, matrix::{state_res, Event, EventTypeExt, PduEvent, StateKey}, trace,
+	Err, Result, debug, debug_info, debug_warn, err, implement, is_equal_to,
+	matrix::{Event, EventTypeExt, PduEvent, StateKey, state_res},
+	trace,
 	utils::{
-		stream::{BroadbandExt, ReadyExt},
 		IterStream,
+		stream::{BroadbandExt, ReadyExt},
 	},
 	warn,
-	Err,
-	Result,
 };
-use futures::{future::ready, FutureExt, StreamExt};
+use futures::{FutureExt, StreamExt, future::ready};
-use ruma::{events::StateEventType, CanonicalJsonValue, RoomId, ServerName};
+use ruma::{CanonicalJsonValue, RoomId, ServerName, events::StateEventType};
 use tokio::join;
 
 use super::get_room_version_rules;