contextualize handler in object

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

src/admin/handler.rs

@@ -12,16 +12,28 @@ use ruma::{
 };
 
 use conduit::{utils::string::common_prefix, Result};
-use service::admin::{Command, CommandOutput, CommandResult, HandlerResult};
+use service::{
+	admin::{Command, CommandOutput, CommandResult, HandlerResult},
+	Services,
+};
 
-use crate::{admin, admin::AdminCommand, services};
+use crate::{admin, admin::AdminCommand};
+
+struct Handler<'a> {
+	services: &'a Services,
+}
+
+#[must_use]
+pub(super) fn complete(line: &str) -> String {
+	Handler {
+		services: service::services(),
+	}
+	.complete_command(AdminCommand::command(), line)
+}
 
 #[must_use]
 pub(super) fn handle(command: Command) -> HandlerResult { Box::pin(handle_command(command)) }
 
-#[must_use]
-pub(super) fn complete(line: &str) -> String { complete_command(AdminCommand::command(), line) }
-
 #[tracing::instrument(skip_all, name = "admin")]
 async fn handle_command(command: Command) -> CommandResult {
 	AssertUnwindSafe(process_command(&command))
@@ -32,7 +44,10 @@ async fn handle_command(command: Command) -> CommandResult {
 }
 
 async fn process_command(command: &Command) -> CommandOutput {
-	process(&command.command)
+	Handler {
+		services: service::services(),
+	}
+	.process(&command.command)
 	.await
 	.and_then(|content| reply(content, command.reply_id.clone()))
 }
@@ -55,22 +70,23 @@ fn reply(mut content: RoomMessageEventContent, reply_id: Option<OwnedEventId>) -
 	Some(content)
 }
 
-// Parse and process a message from the admin room
+impl Handler<'_> {
-async fn process(msg: &str) -> CommandOutput {
+	// Parse and process a message from the admin room
+	async fn process(&self, msg: &str) -> CommandOutput {
 		let mut lines = msg.lines().filter(|l| !l.trim().is_empty());
 		let command = lines.next().expect("each string has at least one line");
 		let body = lines.collect::<Vec<_>>();
-	let parsed = match parse_command(command) {
+		let parsed = match self.parse_command(command) {
 			Ok(parsed) => parsed,
 			Err(error) => {
-			let server_name = services().globals.server_name();
+				let server_name = self.services.globals.server_name();
 				let message = error.replace("server.name", server_name.as_str());
 				return Some(RoomMessageEventContent::notice_markdown(message));
 			},
 		};
 
 		let timer = Instant::now();
-	let result = admin::process(parsed, body).await;
+		let result = Box::pin(admin::process(parsed, body)).await;
 		let elapsed = timer.elapsed();
 		conduit::debug!(?command, ok = result.is_ok(), "command processed in {elapsed:?}");
 		match result {
@@ -79,16 +95,16 @@ async fn process(msg: &str) -> CommandOutput {
 				"Encountered an error while handling the command:\n```\n{error:#?}\n```"
 			))),
 		}
-}
+	}
 
-// Parse chat messages from the admin room into an AdminCommand object
+	// Parse chat messages from the admin room into an AdminCommand object
-fn parse_command(command_line: &str) -> Result<AdminCommand, String> {
+	fn parse_command(&self, command_line: &str) -> Result<AdminCommand, String> {
-	let argv = parse_line(command_line);
+		let argv = self.parse_line(command_line);
 		AdminCommand::try_parse_from(argv).map_err(|error| error.to_string())
-}
+	}
 
-fn complete_command(mut cmd: clap::Command, line: &str) -> String {
+	fn complete_command(&self, mut cmd: clap::Command, line: &str) -> String {
-	let argv = parse_line(line);
+		let argv = self.parse_line(line);
 		let mut ret = Vec::<String>::with_capacity(argv.len().saturating_add(1));
 
 		'token: for token in argv.into_iter().skip(1) {
@@ -128,10 +144,10 @@ fn complete_command(mut cmd: clap::Command, line: &str) -> String {
 		// Return from no completion. Needs a space though.
 		ret.push(String::new());
 		ret.join(" ")
-}
+	}
 
-// Parse chat messages from the admin room into an AdminCommand object
+	// Parse chat messages from the admin room into an AdminCommand object
-fn parse_line(command_line: &str) -> Vec<String> {
+	fn parse_line(&self, command_line: &str) -> Vec<String> {
 		let mut argv = command_line
 			.split_whitespace()
 			.map(str::to_owned)
@@ -143,7 +159,7 @@ fn parse_line(command_line: &str) -> Vec<String> {
 		}
 
 		// First indice has to be "admin" but for console convenience we add it here
-	let server_user = services().globals.server_user.as_str();
+		let server_user = self.services.globals.server_user.as_str();
 		if !argv.is_empty() && !argv[0].ends_with("admin") && !argv[0].starts_with(server_user) {
 			argv.insert(0, "admin".to_owned());
 		}
@@ -173,4 +189,5 @@ fn parse_line(command_line: &str) -> Vec<String> {
 
 		trace!(?command_line, ?argv, "parse");
 		argv
+	}
 }