duckai 0.1.7

DuckDuckGo AI to OpenAI API
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

use std::time::Instant;

use futures_util::future::join_all;
use hickory_resolver::{
    config::{LookupIpStrategy, ResolverConfig, ResolverOpts},
    TokioAsyncResolver,
};
use tokio::sync::OnceCell;

pub const FASTEST_DNS_CONFIG: OnceCell<ResolverConfig> = OnceCell::const_new();

/// Fastest DNS resolver
pub async fn load_fastest_dns() -> crate::Result<ResolverConfig> {
    let mut tasks = Vec::new();

    let mut opts = ResolverOpts::default();
    opts.ip_strategy = LookupIpStrategy::Ipv4AndIpv6;

    let configs = vec![
        ResolverConfig::google(),
        ResolverConfig::quad9(),
        ResolverConfig::cloudflare(),
    ];

    for config in configs {
        let resolver = TokioAsyncResolver::tokio(config.clone(), opts.clone());
        let task = async move {
            let start = Instant::now();
            let ips = resolver.lookup_ip("duckduckgo.com").await?;
            let elapsed = start.elapsed();
            let ips = ips.iter().collect::<Vec<_>>();
            tracing::debug!("Fastest DNS resovler: {ips:?} ({elapsed:?})");
            Ok((elapsed, config))
        };
        tasks.push(task);
    }

    // Join all tasks and return the fastest DNS
    let r = join_all(tasks)
        .await
        .into_iter()
        .collect::<crate::Result<Vec<_>>>()?;

    if let Some((elapsed, conf)) = r.into_iter().min_by_key(|(elapsed, _)| *elapsed) {
        // '\n*' split fastest_dns_group
        let mut fastest_dns_group = conf
            .name_servers()
            .iter()
            .map(|ns| ns.socket_addr.to_string())
            .collect::<Vec<_>>();

        // this removes all duplicates
        fastest_dns_group.dedup();

        tracing::info!(
            "Fastest DNS group ({elapsed:?}):\n* {}",
            fastest_dns_group.join("\n* ")
        );

        return Ok(conf);
    }

    Ok(ResolverConfig::default())
}