chore: Merge resolver service into client service

src/admin/debug/commands.rs

@@ -1017,7 +1017,7 @@ impl crate::Context<'_> {
 				.http_client(self.services.client.default.clone())
 				.build()?
 		} else {
-			&self.services.resolver.resolver
+			&self.services.client.resolver
 		};
 
 		let actual = resolver.resolve_server(server_name.as_str()).await?;
@@ -1027,7 +1027,10 @@ impl crate::Context<'_> {
 			| ResolvedDestination::Named(host, port) => format!("{host}:{port}"),
 		};
 
-		let msg = format!("Destination: {}\nHostname URI (SNI): {}", destination, actual.host);
+		let msg = format!(
+			"Destination: {}\nHostname URI (SNI): {}\nIs override?: {}\nResolution step: {}",
+			destination, actual.host, actual.is_override, actual.resolution_step
+		);
 		self.write_str(&msg).await
 	}
 

src/admin/query/resolver.rs

@@ -1,6 +1,6 @@
 use clap::Subcommand;
 use conduwuit::{Err, Result, utils::time};
-use futures::StreamExt;
+use resolvematrix::resolution::Resolution;
 use ruma::OwnedServerName;
 
 use crate::admin_command_dispatch;
@@ -10,14 +10,13 @@ use crate::admin_command_dispatch;
 #[allow(clippy::enum_variant_names)]
 /// Resolver service and caches
 pub enum ResolverCommand {
-	/// Query the destinations cache
-	DestinationsCache {
+	/// Query the destinations or overrides cache, depending on the value of the
+	/// `overrides` flag (default false)
+	Cache {
 		server_name: Option<OwnedServerName>,
-	},
 
-	/// Query the overrides cache
-	OverridesCache {
-		name: Option<String>,
+		#[arg(short, long)]
+		overrides: Option<bool>,
 	},
 
 	/// Flush a given server from the resolver caches or flush them completely
@@ -40,49 +39,39 @@ pub enum ResolverCommand {
 }
 
 impl crate::Context<'_> {
-	async fn destinations_cache(&self, server_name: Option<OwnedServerName>) -> Result {
-		use service::resolver::cache::CachedDest;
+	async fn cache(
+		&self,
+		server_name: Option<OwnedServerName>,
+		overrides: Option<bool>,
+	) -> Result {
+		writeln!(self, "| Server Name | Destination | SNI | Override | Step | Expires |").await?;
+		writeln!(self, "| ----------- | ----------- | --- | -------- | ---- | ------- |").await?;
 
-		writeln!(self, "| Server Name | Destination | Hostname | Expires |").await?;
-		writeln!(self, "| ----------- | ----------- | -------- | ------- |").await?;
+		let entries = self.services.client.resolver.get_all_cache_entries();
 
-		let mut destinations = self.services.resolver.dns.cache.destinations().boxed();
-
-		while let Some((name, CachedDest { dest, host, expire })) = destinations.next().await {
-			if let Some(server_name) = server_name.as_ref() {
-				if name != *server_name {
-					continue;
-				}
+		for (host, entry) in entries {
+			if let Some(ors) = overrides
+				&& entry.is_override != ors
+			{
+				continue;
 			}
 
-			let expire = time::format(expire, "%+");
-			self.write_str(&format!("| {name} | {dest} | {host} | {expire} |\n"))
-				.await?;
-		}
-
-		Ok(())
-	}
-
-	async fn overrides_cache(&self, server_name: Option<String>) -> Result {
-		use service::resolver::cache::CachedOverride;
-
-		writeln!(self, "| Server Name | IP  | Port | Expires | Overriding |").await?;
-		writeln!(self, "| ----------- | --- | ----:| ------- | ---------- |").await?;
-
-		let mut overrides = self.services.resolver.dns.cache.overrides().boxed();
-
-		while let Some((name, CachedOverride { ips, port, expire, overriding })) =
-			overrides.next().await
-		{
-			if let Some(server_name) = server_name.as_ref() {
-				if name != *server_name {
-					continue;
-				}
+			if let Some(server_name) = server_name.as_ref()
+				&& host != *server_name
+			{
+				continue;
 			}
 
-			let expire = time::format(expire, "%+");
+			let Resolution {
+				destination,
+				is_override,
+				host: sni_host,
+				resolution_step,
+			} = entry.resolution;
+			let expires = time::format(entry.expires_at, "%Y-%m-%dT%H:%M:%S%.3f%z");
 			self.write_str(&format!(
-				"| {name} | {ips:?} | {port} | {expire} | {overriding:?} |\n"
+				"| {host} | {destination:?} | {sni_host} | {is_override:?} | {resolution_step} \
+				 | {expires} |\n"
 			))
 			.await?;
 		}
@@ -92,16 +81,14 @@ impl crate::Context<'_> {
 
 	async fn flush_cache(&self, name: Option<OwnedServerName>, all: bool) -> Result {
 		if all {
-			self.services.resolver.resolver.clear_cache();
-			self.services.resolver.dns.cache.clear().await;
-			writeln!(self, "Resolver caches cleared!").await
+			self.services.client.resolver.clear_cache();
+			self.services.client.dns.clear_cache();
+			writeln!(self, "Resolver and DNS caches cleared!").await
 		} else if let Some(name) = name {
 			self.services
-				.resolver
+				.client
 				.resolver
 				.remove_cache_entry(name.as_str());
-			self.services.resolver.dns.cache.del_destination(&name);
-			self.services.resolver.dns.cache.del_override(&name);
 			self.write_str(&format!("Cleared {name} from resolver caches!"))
 				.await
 		} else {