restructure server

src/dns.rs

@@ -1,15 +1,27 @@
 use anyhow::Result;
-use std::{error::Error, net::IpAddr};
+use std::{collections::HashSet, error::Error, net::IpAddr};
+use tokio::sync::mpsc::{channel, Receiver, Sender};
 
 use hickory_resolver::TokioAsyncResolver;
 
-pub struct DnsResolver {
+use crate::{client::ClientHandle, server::Server};
+
+pub(crate) struct DnsResolver {
     resolver: TokioAsyncResolver,
+    dns_request: Receiver<ClientHandle>,
 }
+
 impl DnsResolver {
-    pub(crate) async fn new() -> Result<Self> {
+    pub(crate) async fn new() -> Result<(Self, Sender<ClientHandle>)> {
         let resolver = TokioAsyncResolver::tokio_from_system_conf()?;
-        Ok(Self { resolver })
+        let (dns_tx, dns_request) = channel(1);
+        Ok((
+            Self {
+                resolver,
+                dns_request,
+            },
+            dns_tx,
+        ))
     }
 
     pub(crate) async fn resolve(&self, host: &str) -> Result<Vec<IpAddr>, Box<dyn Error>> {
@@ -20,4 +32,50 @@ impl DnsResolver {
         }
         Ok(response.iter().collect())
     }
+
+    pub async fn run(mut self, server: Server) {
+        tokio::select! {
+            _ = server.cancelled() => {},
+            _ = self.do_dns(&server) => {},
+        }
+    }
+
+    async fn do_dns(&mut self, server: &Server) {
+        loop {
+            let handle = self.dns_request.recv().await.expect("channel closed");
+
+            /* update resolving status */
+            let hostname = if let Some((c, s)) = server.client_manager.borrow_mut().get_mut(handle)
+            {
+                s.resolving = true;
+                c.hostname.clone()
+            } else {
+                continue;
+            };
+            let Some(hostname) = hostname else {
+                continue;
+            };
+
+            server.notify_client_update(handle);
+
+            let ips = match self.resolve(&hostname).await {
+                Ok(ips) => ips,
+                Err(e) => {
+                    log::warn!("could not resolve host '{hostname}': {e}");
+                    vec![]
+                }
+            };
+
+            /* update ips and resolving state */
+            if let Some((c, s)) = server.client_manager.borrow_mut().get_mut(handle) {
+                let mut addrs = HashSet::from_iter(c.fix_ips.iter().cloned());
+                for ip in ips {
+                    addrs.insert(ip);
+                }
+                s.ips = addrs;
+                s.resolving = false;
+            }
+            server.notify_client_update(handle);
+        }
+    }
 }