fix(stdlib): properly detect tokio runtime in dns_lookup

Cargo.toml

@@ -99,6 +99,7 @@ stdlib = [
  "dep:snap",
  "dep:strip-ansi-escapes",
  "dep:syslog_loose",
+ "dep:tokio",
  "dep:uaparser",
  "dep:url",
  "dep:utf8-width",
@@ -203,6 +204,7 @@ domain = { version = "0.10.0", optional = true, features = ["resolv-sync", "serd
 hostname = { version = "0.4", optional = true }
 grok = { version = "2", optional = true }
 onig = { version = "6", default-features = false, optional = true }
+tokio = { version = "1.37", optional = true, features = ["io-util", "macros", "net", "time", "sync", "rt", "rt-multi-thread" ] }
 uuid = { version = "1", features = ["v4", "v7"], optional = true }
 
 # Dependencies used for WASM

src/stdlib/dns_lookup.rs

@@ -3,7 +3,10 @@ use crate::compiler::prelude::*;
 #[cfg(not(target_arch = "wasm32"))]
 mod non_wasm {
     use std::collections::BTreeMap;
+    use std::io::Error;
     use std::net::ToSocketAddrs;
+    use std::sync::{mpsc, Arc, Mutex};
+    use std::thread;
     use std::time::Duration;
 
     use domain::base::iana::Class;
@@ -12,10 +15,69 @@ mod non_wasm {
     use domain::resolv::stub::conf::{ResolvConf, ResolvOptions, ServerConf, Transport};
     use domain::resolv::stub::Answer;
     use domain::resolv::StubResolver;
+    use once_cell::sync::Lazy;
+    use tokio::runtime::Handle;
 
     use crate::compiler::prelude::*;
     use crate::value::Value;
 
+    static WORKER: Lazy<Worker> = Lazy::new(|| Worker::new());
+
+    type Job<T> = Box<dyn FnOnce() -> T + Send + 'static>;
+    struct JobHandle<T> {
+        job: Job<T>,
+        result: Arc<mpsc::Sender<T>>,
+    }
+
+    struct Worker {
+        thread: Option<thread::JoinHandle<()>>,
+        queue: Option<mpsc::Sender<JobHandle<Result<Answer, Error>>>>,
+    }
+
+    impl Worker {
+        fn new() -> Self {
+            let (sender, receiver) = mpsc::channel::<JobHandle<Result<Answer, Error>>>();
+            let receiver = Arc::new(Mutex::new(receiver));
+            Self {
+                thread: Some(thread::spawn(move || loop {
+                    match receiver.lock().unwrap().recv() {
+                        Ok(handle) => {
+                            let result = (handle.job)();
+                            handle.result.as_ref().send(result).unwrap();
+                        }
+                        Err(_) => todo!(),
+                    }
+                })),
+                queue: Some(sender),
+            }
+        }
+
+        fn execute<F>(&self, f: F) -> Result<Answer, Error>
+        where
+            F: FnOnce() -> Result<Answer, Error> + Send + 'static,
+        {
+            let job = Box::new(f);
+            let (sender, receiver) = mpsc::channel();
+            let receiver = Arc::new(Mutex::new(receiver));
+            let handle = JobHandle {
+                job,
+                result: Arc::new(sender),
+            };
+
+            self.queue.as_ref().unwrap().send(handle).unwrap();
+            return receiver.lock().unwrap().recv().unwrap();
+        }
+    }
+
+    impl Drop for Worker {
+        fn drop(&mut self) {
+            drop(self.queue.take());
+            if let Some(thread) = self.thread.take() {
+                thread.join().unwrap();
+            }
+        }
+    }
+
     fn dns_lookup(value: Value, qtype: Value, qclass: Value, options: Value) -> Resolved {
         let host: Name<Vec<_>> = value
             .try_bytes_utf8_lossy()?
@@ -34,9 +96,16 @@ mod non_wasm {
             .map_err(|err| format!("parsing query class failed: {err}"))?;
 
         let conf = build_options(options.try_object()?)?;
-        let answer = StubResolver::run_with_conf(conf, move |stub| async move {
-            stub.query((host, qtype, qclass)).await
-        })
+        let answer = match Handle::try_current() {
+            Ok(_) => WORKER.execute(move || {
+                StubResolver::run_with_conf(conf, move |stub| async move {
+                    stub.query((host, qtype, qclass)).await
+                })
+            }),
+            Err(_) => StubResolver::run_with_conf(conf, move |stub| async move {
+                stub.query((host, qtype, qclass)).await
+            }),
+        }
         .map_err(|err| format!("query failed: {err}"))?;
 
         Ok(parse_answer(answer)?.into())