Hostnames in config

roles/jd-client/src/main.rs

@@ -17,7 +17,7 @@ use async_channel::{bounded, unbounded};
 use futures::{select, FutureExt};
 use roles_logic_sv2::utils::Mutex;
 use std::{
-    net::{IpAddr, SocketAddr},
+    net::{IpAddr, SocketAddr, ToSocketAddrs},
     str::FromStr,
     sync::Arc,
     time::Duration,
@@ -267,19 +267,17 @@ async fn initialize_jd(
         .unwrap_or(false);
 
     // Format `Upstream` connection address
-    let mut parts = upstream_config.pool_address.split(':');
-    let address = parts
+    let upstream_addr = upstream_config
+        .pool_address
+        .to_socket_addrs()
+        .unwrap_or_else(|e| {
+            panic!(
+                "Invalid pool address {}: {}",
+                upstream_config.pool_address, e
+            )
+        })
         .next()
-        .unwrap_or_else(|| panic!("Invalid pool address {}", upstream_config.pool_address));
-    let port = parts
-        .next()
-        .and_then(|p| p.parse::<u16>().ok())
-        .unwrap_or_else(|| panic!("Invalid pool address {}", upstream_config.pool_address));
-    let upstream_addr = SocketAddr::new(
-        IpAddr::from_str(address)
-            .unwrap_or_else(|_| panic!("Invalid pool address {}", upstream_config.pool_address)),
-        port,
-    );
+        .unwrap();
 
     // When Downstream receive a share that meets bitcoin target it transformit in a
     // SubmitSolution and send it to the TemplateReceiver
@@ -331,15 +329,21 @@ async fn initialize_jd(
     );
 
     // Initialize JD part
-    let mut parts = proxy_config.tp_address.split(':');
-    let ip_tp = parts.next().unwrap().to_string();
-    let port_tp = parts.next().unwrap().parse::<u16>().unwrap();
+    let tp_addr = proxy_config
+        .tp_address
+        .to_socket_addrs()
+        .unwrap_or_else(|e| panic!("Invalid tproxy address {}: {}", proxy_config.tp_address, e))
+        .next()
+        .unwrap();
 
-    let mut parts = upstream_config.jd_address.split(':');
-    let ip_jd = parts.next().unwrap().to_string();
-    let port_jd = parts.next().unwrap().parse::<u16>().unwrap();
+    let jd_addr = upstream_config
+        .jd_address
+        .to_socket_addrs()
+        .unwrap_or_else(|e| panic!("Invalid jds address {}: {}", upstream_config.jd_address, e))
+        .next()
+        .unwrap();
     let jd = match JobDeclarator::new(
-        SocketAddr::new(IpAddr::from_str(ip_jd.as_str()).unwrap(), port_jd),
+        jd_addr,
         upstream_config.authority_pubkey.into_bytes(),
         proxy_config.clone(),
         upstream.clone(),
@@ -376,7 +380,7 @@ async fn initialize_jd(
     .unwrap();
 
     TemplateRx::connect(
-        SocketAddr::new(IpAddr::from_str(ip_tp.as_str()).unwrap(), port_tp),
+        tp_addr,
         recv_solution,
         status::Sender::TemplateReceiver(tx_status.clone()),
         Some(jd.clone()),

roles/pool/src/main.rs

@@ -1,6 +1,7 @@
 #![allow(special_module_name)]
 use async_channel::{bounded, unbounded};
 
+use std::net::ToSocketAddrs;
 use tracing::{error, info, warn};
 mod lib;
 use lib::{
@@ -117,7 +118,7 @@ async fn main() {
     };
     let tp_authority_public_key = config.tp_authority_public_key;
     let template_rx_res = TemplateRx::connect(
-        config.tp_address.parse().unwrap(),
+        config.tp_address.to_socket_addrs().unwrap().next().unwrap(),
         s_new_t,
         s_prev_hash,
         r_solution,

roles/translator/src/main.rs

@@ -11,7 +11,7 @@ use roles_logic_sv2::utils::Mutex;
 use async_channel::{bounded, unbounded};
 use futures::{select, FutureExt};
 use std::{
-    net::{IpAddr, SocketAddr},
+    net::{IpAddr, SocketAddr, ToSocketAddrs},
     str::FromStr,
     sync::Arc,
 };
@@ -78,11 +78,19 @@ async fn main() {
     ) = broadcast::channel(10);
 
     // Format `Upstream` connection address
-    let upstream_addr = SocketAddr::new(
-        IpAddr::from_str(&proxy_config.upstream_address)
-            .expect("Failed to parse upstream address!"),
+    let upstream_addr = (
+        proxy_config.upstream_address.as_str(),
         proxy_config.upstream_port,
-    );
+    )
+        .to_socket_addrs()
+        .unwrap_or_else(|e| {
+            panic!(
+                "Invalid upstream address {}:{}: {}",
+                proxy_config.upstream_address, proxy_config.upstream_port, e
+            )
+        })
+        .next()
+        .unwrap();
 
     let diff_config = Arc::new(Mutex::new(proxy_config.upstream_difficulty_config.clone()));