hostname resolution in routing targets

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "hopper"
-version = "0.3.3"
+version = "0.3.4"
 edition = "2021"
 
 [features]

src/config/balancer.rs

@@ -1,10 +1,11 @@
+use serde::Deserialize;
 use std::net::SocketAddr;
 
-use serde::Deserialize;
+use super::resolver::ResolvableAddr;
 
 #[derive(Debug)]
 pub struct Balanced {
-    servers: Vec<SocketAddr>,
+    servers: Vec<ResolvableAddr>,
     last_used: usize,
 }
 
@@ -13,9 +14,8 @@ impl<'de> Deserialize<'de> for Balanced {
     where
         D: serde::Deserializer<'de>,
     {
-        let servers = Vec::deserialize(deserializer)?;
         Ok(Self {
-            servers,
+            servers: Vec::deserialize(deserializer)?,
             last_used: Default::default(),
         })
     }
@@ -26,6 +26,6 @@ impl Balanced {
         let item = self.servers[self.last_used];
         self.last_used = (self.last_used + 1) % self.servers.len();
 
-        item
+        item.into()
     }
 }

src/config/mod.rs

@@ -12,9 +12,10 @@ use serde::{Deserialize, Deserializer};
 use std::{collections::HashMap, net::SocketAddr};
 use tokio::sync::Mutex;
 
-use self::balancer::Balanced;
+use self::{balancer::Balanced, resolver::ResolvableAddr};
 
 mod balancer;
+mod resolver;
 
 #[derive(Deserialize)]
 /// Defines the structure of a config file. Extension can be
@@ -50,15 +51,15 @@ where
 #[derive(Deserialize, Debug)]
 #[serde(untagged)]
 enum RouteType {
-    Simple(SocketAddr),
+    Simple(ResolvableAddr),
     #[serde(deserialize_with = "deserialize_mutex")]
     Balanced(Mutex<Balanced>),
 }
 
 impl RouteType {
     async fn get(&self) -> SocketAddr {
         match self {
-            RouteType::Simple(route) => *route,
+            RouteType::Simple(route) => (*route).into(),
             RouteType::Balanced(balancer) => balancer.lock().await.get(),
         }
     }

src/config/resolver.rs

@@ -0,0 +1,27 @@
+use std::net::{SocketAddr, ToSocketAddrs};
+
+use serde::{Deserialize, Deserializer};
+
+#[derive(Deserialize, Debug, Clone, Copy)]
+pub(super) struct ResolvableAddr(#[serde(deserialize_with = "resolve_hostname")] SocketAddr);
+
+fn resolve_hostname<'de, D>(deserializer: D) -> Result<SocketAddr, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    use serde::de::Error;
+
+    let inner = <String>::deserialize(deserializer)?;
+
+    let mut addr = inner
+        .to_socket_addrs()
+        .map_err(|err| Error::custom(format!("invalid hostname format: {err}")))?;
+
+    addr.next().ok_or_else(|| Error::custom("msg"))
+}
+
+impl From<ResolvableAddr> for SocketAddr {
+    fn from(addr: ResolvableAddr) -> Self {
+        addr.0
+    }
+}

src/server.rs

@@ -41,7 +41,7 @@ impl Hopper {
                     }
                     Err(err) => {
                         log::error!("Couldn't connect {client}: {err}");
-                        Err(client.disconnect_err_chain(err).await.into())
+                        Err(client.disconnect_err_chain(err.into()).await)
                     }
                 }
             };