admin terminal console

Signed-off-by: Jason Volk <jason@zemos.net>

src/service/admin/mod.rs

@@ -0,0 +1,247 @@
+pub mod console;
+mod create;
+mod grant;
+
+use std::{future::Future, pin::Pin, sync::Arc};
+
+use conduit::{Error, Result};
+pub use create::create_admin_room;
+pub use grant::make_user_admin;
+use ruma::{
+	events::{room::message::RoomMessageEventContent, TimelineEventType},
+	EventId, OwnedRoomId, RoomId, UserId,
+};
+use serde_json::value::to_raw_value;
+use tokio::{
+	sync::{Mutex, MutexGuard},
+	task::JoinHandle,
+};
+use tracing::error;
+
+use crate::{pdu::PduBuilder, services};
+
+pub type HandlerResult = Pin<Box<dyn Future<Output = Result<AdminEvent, Error>> + Send>>;
+pub type Handler = fn(AdminEvent) -> HandlerResult;
+
+pub struct Service {
+	sender: loole::Sender<AdminEvent>,
+	receiver: Mutex<loole::Receiver<AdminEvent>>,
+	handler_join: Mutex<Option<JoinHandle<()>>>,
+	pub handle: Mutex<Option<Handler>>,
+	#[cfg(feature = "console")]
+	pub console: Arc<console::Console>,
+}
+
+#[derive(Debug)]
+pub enum AdminEvent {
+	Command(String, Option<Arc<EventId>>),
+	Reply(Option<RoomMessageEventContent>),
+	Notice(RoomMessageEventContent),
+}
+
+impl Service {
+	#[must_use]
+	pub fn build() -> Arc<Self> {
+		let (sender, receiver) = loole::unbounded();
+		Arc::new(Self {
+			sender,
+			receiver: Mutex::new(receiver),
+			handler_join: Mutex::new(None),
+			handle: Mutex::new(None),
+			#[cfg(feature = "console")]
+			console: console::Console::new(),
+		})
+	}
+
+	pub fn interrupt(&self) {
+		#[cfg(feature = "console")]
+		self.console.interrupt();
+
+		if !self.sender.is_closed() {
+			self.sender.close();
+		}
+	}
+
+	pub async fn close(&self) {
+		self.interrupt();
+
+		#[cfg(feature = "console")]
+		self.console.close().await;
+
+		if let Some(handler_join) = self.handler_join.lock().await.take() {
+			if let Err(e) = handler_join.await {
+				error!("Failed to shutdown: {e:?}");
+			}
+		}
+	}
+
+	pub async fn start_handler(self: &Arc<Self>) {
+		let self_ = Arc::clone(self);
+		let handle = services().server.runtime().spawn(async move {
+			self_
+				.handler()
+				.await
+				.expect("Failed to initialize admin room handler");
+		});
+
+		_ = self.handler_join.lock().await.insert(handle);
+	}
+
+	async fn handler(self: &Arc<Self>) -> Result<()> {
+		let receiver = self.receiver.lock().await;
+		let mut signals = services().server.signal.subscribe();
+		loop {
+			debug_assert!(!receiver.is_closed(), "channel closed");
+			tokio::select! {
+				event = receiver.recv_async() => match event {
+					Ok(event) => self.receive(event).await,
+					Err(_) => return Ok(()),
+				},
+				sig = signals.recv() => match sig {
+					Ok(sig) => self.handle_signal(sig).await,
+					Err(_) => continue,
+				},
+			}
+		}
+	}
+
+	pub async fn send_text(&self, body: &str) {
+		self.send_message(RoomMessageEventContent::text_plain(body))
+			.await;
+	}
+
+	pub async fn send_message(&self, message_content: RoomMessageEventContent) {
+		self.send(AdminEvent::Notice(message_content)).await;
+	}
+
+	pub async fn command(&self, command: String, event_id: Option<Arc<EventId>>) {
+		self.send(AdminEvent::Command(command, event_id)).await;
+	}
+
+	pub async fn command_in_place(
+		&self, command: String, event_id: Option<Arc<EventId>>,
+	) -> Result<Option<RoomMessageEventContent>> {
+		match self.handle(AdminEvent::Command(command, event_id)).await? {
+			AdminEvent::Reply(content) => Ok(content),
+			_ => Ok(None),
+		}
+	}
+
+	async fn send(&self, message: AdminEvent) {
+		debug_assert!(!self.sender.is_full(), "channel full");
+		debug_assert!(!self.sender.is_closed(), "channel closed");
+		self.sender.send(message).expect("message sent");
+	}
+
+	async fn receive(&self, event: AdminEvent) {
+		if let Ok(AdminEvent::Reply(content)) = self.handle(event).await {
+			handle_response(content).await;
+		}
+	}
+
+	async fn handle(&self, event: AdminEvent) -> Result<AdminEvent, Error> {
+		if let Some(handle) = self.handle.lock().await.as_ref() {
+			handle(event).await
+		} else {
+			Err(Error::Err("Admin module is not loaded.".into()))
+		}
+	}
+
+	async fn handle_signal(&self, #[allow(unused_variables)] sig: &'static str) {
+		#[cfg(feature = "console")]
+		if sig == "SIGINT" && services().server.running() {
+			self.console.start().await;
+		}
+	}
+
+	/// Checks whether a given user is an admin of this server
+	pub async fn user_is_admin(&self, user_id: &UserId) -> Result<bool> {
+		let Ok(Some(admin_room)) = Self::get_admin_room() else {
+			return Ok(false);
+		};
+
+		services().rooms.state_cache.is_joined(user_id, &admin_room)
+	}
+
+	/// Gets the room ID of the admin room
+	///
+	/// Errors are propagated from the database, and will have None if there is
+	/// no admin room
+	pub fn get_admin_room() -> Result<Option<OwnedRoomId>> {
+		services()
+			.rooms
+			.alias
+			.resolve_local_alias(&services().globals.admin_alias)
+	}
+}
+
+async fn handle_response(content: Option<RoomMessageEventContent>) {
+	if let Some(content) = content {
+		if let Err(e) = respond_to_room(content).await {
+			error!("{e}");
+		}
+	}
+}
+
+async fn respond_to_room(output_content: RoomMessageEventContent) -> Result<()> {
+	let Ok(Some(admin_room)) = Service::get_admin_room() else {
+		return Ok(());
+	};
+
+	let mutex_state = Arc::clone(
+		services()
+			.globals
+			.roomid_mutex_state
+			.write()
+			.await
+			.entry(admin_room.clone())
+			.or_default(),
+	);
+	let state_lock = mutex_state.lock().await;
+
+	let response_pdu = PduBuilder {
+		event_type: TimelineEventType::RoomMessage,
+		content: to_raw_value(&output_content).expect("event is valid, we just created it"),
+		unsigned: None,
+		state_key: None,
+		redacts: None,
+	};
+
+	let server_user = &services().globals.server_user;
+	if let Err(e) = services()
+		.rooms
+		.timeline
+		.build_and_append_pdu(response_pdu, server_user, &admin_room, &state_lock)
+		.await
+	{
+		handle_response_error(&e, &admin_room, server_user, &state_lock).await?;
+	}
+
+	Ok(())
+}
+
+async fn handle_response_error(
+	e: &Error, admin_room: &RoomId, server_user: &UserId, state_lock: &MutexGuard<'_, ()>,
+) -> Result<()> {
+	error!("Failed to build and append admin room response PDU: \"{e}\"");
+	let error_room_message = RoomMessageEventContent::text_plain(format!(
+		"Failed to build and append admin room PDU: \"{e}\"\n\nThe original admin command may have finished \
+		 successfully, but we could not return the output."
+	));
+
+	let response_pdu = PduBuilder {
+		event_type: TimelineEventType::RoomMessage,
+		content: to_raw_value(&error_room_message).expect("event is valid, we just created it"),
+		unsigned: None,
+		state_key: None,
+		redacts: None,
+	};
+
+	services()
+		.rooms
+		.timeline
+		.build_and_append_pdu(response_pdu, server_user, admin_room, state_lock)
+		.await?;
+
+	Ok(())
+}