feat: config works

src/app.rs

@@ -6,16 +6,54 @@ use http::HeaderName;
 use pingora::{Error, ErrorType};
 use pingora::http::ResponseHeader;
 use pingora::prelude::{HttpPeer, ProxyHttp, Result, Session};
+use trust_dns_resolver::config::{ResolverConfig, ResolverOpts};
+use trust_dns_resolver::proto::rr::RData;
+use trust_dns_resolver::TokioAsyncResolver;
 
 use super::service::HostConfig;
 
 pub struct ProxyApp {
+    tls: bool,
+    lookup_dns: bool,
     host_configs: Vec<HostConfig>,
+    tokio_async_resolver: TokioAsyncResolver,
 }
 
 impl ProxyApp {
-    pub fn new(host_configs: Vec<HostConfig>) -> Self {
-        ProxyApp { host_configs }
+    pub fn new(tls: bool, lookup_dns: bool, host_configs: Vec<HostConfig>) -> Self {
+        let tokio_async_resolver = TokioAsyncResolver::tokio(
+            ResolverConfig::default(),
+            ResolverOpts::default(),
+        );
+        ProxyApp {
+            tls,
+            lookup_dns,
+            host_configs,
+            tokio_async_resolver,
+        }
+    }
+
+    async fn lookup_ipv4(&self, hostname: &str) -> Option<String> {
+        let ips = self.tokio_async_resolver.ipv4_lookup(hostname).await;
+        log::debug!("lookup {} --> {:#?}", hostname, ips);
+        match ips {
+            Ok(ips) => {
+                let records = ips.as_lookup().records();
+                if records.len() > 0 {
+                    let record = &records[0];
+                    if let Some(rdata) = record.data() {
+                        match rdata {
+                            RData::A(a) => {
+                                return Some(a.0.to_string());
+                            }
+                            _ => {}
+                        }
+                    }
+                }
+            }
+            Err(_) => {}
+        }
+        None
     }
 }
 
@@ -45,15 +83,30 @@ impl ProxyHttp for ProxyApp {
         let host_config = self
             .host_configs
             .iter()
-            .find(|x| x.proxy_hostname == hostname)
-            .unwrap_or_else(|| panic!("find config for: {} failed", hostname));
-        let peer = HttpPeer::new(
-            host_config.proxy_addr.as_str(),
-            host_config.proxy_tls,
-            host_config.proxy_hostname.clone(),
-        );
-        log::info!("Find peer: {:?}", peer._address);
-        Ok(Box::new(peer))
+            .find(|x| x.proxy_hostname == hostname);
+        if let Some(host_config) = host_config {
+            let peer = HttpPeer::new(
+                host_config.proxy_addr.as_str(),
+                host_config.proxy_tls,
+                host_config.proxy_hostname.clone(),
+            );
+            log::info!("Find peer: {} --> {:?}", hostname, host_config.proxy_addr);
+            return Ok(Box::new(peer));
+        }
+
+        if self.lookup_dns {
+            if let Some(address) = self.lookup_ipv4(&hostname).await {
+                let peer = HttpPeer::new(
+                    format!("{}:{}", address, if self.tls { 443 } else { 80 }),
+                    self.tls,
+                    hostname.to_string(),
+                );
+                log::info!("Find peer: {} --> {:?}", hostname, address);
+                return Ok(Box::new(peer));
+            }
+        }
+
+        panic!("Cannot find peer: {}", hostname);
     }
 
     async fn request_filter(&self, session: &mut Session, _ctx: &mut Self::CTX) -> Result<bool>