From ec7aeb1096d97bdd947bb7fbad04b972465404cc Mon Sep 17 00:00:00 2001
From: Charles Hall <charles@computer.surgery>
Date: Wed, 24 Jan 2024 18:41:03 -0500
Subject: [PATCH] move resolver logic into the resolver

Honestly not sure why it wasn't done like this before. This code is much
less awkward to follow and more compartmentalized.

These changes were mainly motivated by a clippy lint triggering on the
original code, which then made me wonder if I could get rid of some of
the `Box`ing. Turns out I could, and this is the result of that.

Co-authored-by: strawberry <strawberry@puppygock.gay>
Signed-off-by: strawberry <strawberry@puppygock.gay>
---
 src/service/globals/mod.rs | 44 ++++++++++++++++++++------------------
 1 file changed, 23 insertions(+), 21 deletions(-)

diff --git a/src/service/globals/mod.rs b/src/service/globals/mod.rs
index e9da0e15..44a22166 100644
--- a/src/service/globals/mod.rs
+++ b/src/service/globals/mod.rs
@@ -111,15 +111,13 @@ impl Default for RotationHandler {
     }
 }
 
-type DnsOverrides = Box<dyn Fn(&str) -> Option<SocketAddr> + Send + Sync>;
-
 struct Resolver {
     inner: GaiResolver,
-    overrides: DnsOverrides,
+    overrides: Arc<RwLock<TlsNameMap>>,
 }
 
 impl Resolver {
-    fn new(overrides: DnsOverrides) -> Resolver {
+    fn new(overrides: Arc<RwLock<TlsNameMap>>) -> Self {
         Resolver {
             inner: GaiResolver::new(),
             overrides,
@@ -129,16 +127,26 @@ impl Resolver {
 
 impl Resolve for Resolver {
     fn resolve(&self, name: Name) -> Resolving {
-        if let Some(addr) = (self.overrides)(name.as_str()) {
-            let once: Box<dyn Iterator<Item = SocketAddr> + Send> = Box::new(iter::once(addr));
-            return Box::pin(future::ready(Ok(once)));
-        }
-        let this = &mut self.inner.clone();
-        Box::pin(HyperService::<Name>::call(this, name).map(|result| {
-            result
-                .map(|addrs| -> Addrs { Box::new(addrs) })
-                .map_err(|err| -> Box<dyn StdError + Send + Sync> { Box::new(err) })
-        }))
+        self.overrides
+            .read()
+            .expect("lock should not be poisoned")
+            .get(name.as_str())
+            .and_then(|(override_name, port)| {
+                override_name.first().map(|first_name| {
+                    let x: Box<dyn Iterator<Item = SocketAddr> + Send> =
+                        Box::new(iter::once(SocketAddr::new(*first_name, *port)));
+                    let x: Resolving = Box::pin(future::ready(Ok(x)));
+                    x
+                })
+            })
+            .unwrap_or_else(|| {
+                let this = &mut self.inner.clone();
+                Box::pin(HyperService::<Name>::call(this, name).map(|result| {
+                    result
+                        .map(|addrs| -> Addrs { Box::new(addrs) })
+                        .map_err(|err| -> Box<dyn StdError + Send + Sync> { Box::new(err) })
+                }))
+            })
     }
 }
 
@@ -163,14 +171,8 @@ impl Service<'_> {
             .map(|secret| jsonwebtoken::DecodingKey::from_secret(secret.as_bytes()));
 
         let default_client = reqwest_client_builder(&config)?.build()?;
-        let name_override = Arc::clone(&tls_name_override);
         let federation_client = reqwest_client_builder(&config)?
-            .dns_resolver(Arc::new(Resolver::new(Box::new(move |domain| {
-                let read_guard = name_override.read().unwrap();
-                let (override_name, port) = read_guard.get(domain)?;
-                let first_name = override_name.first()?;
-                Some(SocketAddr::new(*first_name, *port))
-            }))))
+            .dns_resolver(Arc::new(Resolver::new(tls_name_override.clone())))
             .build()?;
 
         // Supported and stable room versions