resolver: encapsulate channel logic

src/dns.rs

@@ -1,5 +1,5 @@
-use local_channel::mpsc::Receiver;
-use std::net::IpAddr;
+use local_channel::mpsc::{channel, Receiver, Sender};
+use tokio::task::{JoinHandle, spawn_local};
 
 use hickory_resolver::{error::ResolveError, TokioAsyncResolver};
 
@@ -7,37 +7,35 @@ use crate::server::Server;
 use lan_mouse_ipc::ClientHandle;
 
 pub(crate) struct DnsResolver {
-    resolver: TokioAsyncResolver,
-    dns_request: Receiver<ClientHandle>,
+    _task: JoinHandle<()>,
+    tx: Sender<ClientHandle>,
 }
 
 impl DnsResolver {
-    pub(crate) fn new(dns_request: Receiver<ClientHandle>) -> Result<Self, ResolveError> {
+    pub(crate) fn new(server: Server) -> Result<Self, ResolveError> {
         let resolver = TokioAsyncResolver::tokio_from_system_conf()?;
+        let (tx, rx) = channel();
+        let _task = spawn_local(Self::run(server, resolver, rx));
         Ok(Self {
-            resolver,
-            dns_request,
+            _task,
+            tx,
         })
     }
 
-    async fn resolve(&self, host: &str) -> Result<Vec<IpAddr>, ResolveError> {
-        let response = self.resolver.lookup_ip(host).await?;
-        for ip in response.iter() {
-            log::info!("{host}: adding ip {ip}");
-        }
-        Ok(response.iter().collect())
+    pub(crate) fn resolve(&self, host: ClientHandle) {
+        self.tx.send(host).expect("channel closed");
     }
 
-    pub(crate) async fn run(mut self, server: Server) {
+    async fn run(server: Server, resolver: TokioAsyncResolver, mut rx: Receiver<ClientHandle>) {
         tokio::select! {
             _ = server.cancelled() => {},
-            _ = self.do_dns(&server) => {},
+            _ = Self::do_dns(&server, &resolver, &mut rx) => {},
         }
     }
 
-    async fn do_dns(&mut self, server: &Server) {
+    async fn do_dns(server: &Server, resolver: &TokioAsyncResolver, rx: &mut Receiver<ClientHandle>) {
         loop {
-            let handle = self.dns_request.recv().await.expect("channel closed");
+            let handle = rx.recv().await.expect("channel closed");
 
             /* update resolving status */
             let hostname = match server.get_hostname(handle) {
@@ -48,8 +46,15 @@ impl DnsResolver {
             log::info!("resolving ({handle}) `{hostname}` ...");
             server.set_resolving(handle, true);
 
-            let ips = match self.resolve(&hostname).await {
-                Ok(ips) => ips,
+            /* resolve host */
+            let ips = match resolver.lookup_ip(&hostname).await {
+                Ok(response) => {
+                    let ips = response.iter().collect::<Vec<_>>();
+                    for ip in ips.iter() {
+                        log::info!("{hostname}: adding ip {ip}");
+                    }
+                    ips
+                }
                 Err(e) => {
                     log::warn!("could not resolve host '{hostname}': {e}");
                     vec![]