(libmcping): Enable DNS caching for maximum SPEEEEEEEEEED

Author: randomairborne

libmcping/src/tokio/bedrock.rs

@@ -7,7 +7,6 @@ use std::{
     time::{Duration, Instant},
 };
 
-use hickory_resolver::{config::*, TokioAsyncResolver};
 use tokio::{
     io::{AsyncRead, AsyncReadExt, AsyncWriteExt},
     net::UdpSocket,
@@ -94,8 +93,7 @@ impl Connection {
         };
 
         // Do a hostname lookup
-        let resolver =
-            TokioAsyncResolver::tokio(ResolverConfig::default(), ResolverOpts::default());
+        let resolver = super::resolver();
 
         let ip = resolver
             .lookup_ip(host.as_str())

libmcping/src/tokio/java.rs

@@ -7,7 +7,6 @@ use std::{
     time::{Duration, Instant},
 };
 
-use hickory_resolver::{config::*, TokioAsyncResolver};
 use tokio::{
     io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt},
     net::TcpStream,
@@ -122,8 +121,7 @@ impl Connection {
         };
 
         // Attempt to lookup the ip of the server from an srv record, falling back on the ip from a host
-        let resolver =
-            TokioAsyncResolver::tokio(ResolverConfig::default(), ResolverOpts::default());
+        let resolver = super::resolver();
 
         // Determine what host to lookup by doing the following:
         // - Lookup the SRV record for the domain, if it exists perform a lookup of the ip from the target

libmcping/src/tokio/mod.rs

@@ -1,6 +1,13 @@
 mod bedrock;
 mod java;
 
+use std::sync::OnceLock;
+
+use hickory_resolver::{
+    config::{ResolverConfig, ResolverOpts},
+    TokioAsyncResolver,
+};
+
 use crate::Error;
 
 /// Represents a pingable entity.
@@ -52,3 +59,16 @@ pub trait AsyncPingable {
 pub async fn get_status<P: AsyncPingable>(pingable: P) -> Result<(u64, P::Response), Error> {
     pingable.ping().await
 }
+
+fn new_resolver() -> TokioAsyncResolver {
+    let config = ResolverConfig::cloudflare();
+    let mut opts = ResolverOpts::default();
+    opts.cache_size = 64;
+    opts.attempts = 3;
+    TokioAsyncResolver::tokio(config, opts)
+}
+
+pub fn resolver() -> &'static TokioAsyncResolver {
+    static RESOLVER: OnceLock<TokioAsyncResolver> = OnceLock::new();
+    RESOLVER.get_or_init(new_resolver)
+}