DNS

/// Alias for an `Iterator` trait object over `SocketAddr`.
pub type Addrs = Box<dyn Iterator<Item = SocketAddr> + Send>;

/// Alias for the `Future` type returned by a DNS resolver.
pub type Resolving = Pin<Box<dyn Future<Output = Result<Addrs, BoxError>> + Send>>;

/// Trait for customizing DNS resolution in reqwest.
pub trait Resolve: Send + Sync {
    /// Performs DNS resolution on a `Name`.
    /// The return type is a future containing an iterator of `SocketAddr`.
    ///
    /// It differs from `tower_service::Service<Name>` in several ways:
    ///  * It is assumed that `resolve` will always be ready to poll.
    ///  * It does not need a mutable reference to `self`.
    ///  * Since trait objects cannot make use of associated types, it requires
    ///    wrapping the returned `Future` and its contained `Iterator` with `Box`.
    ///
    /// Explicitly specified port in the URL will override any port in the resolved `SocketAddr`s.
    /// Otherwise, port `0` will be replaced by the conventional port for the given scheme (e.g. 80 for http).
    fn resolve(&self, name: Name) -> Resolving;
}

        let resolver = {
            let mut resolver: Arc<dyn Resolve> = match config.hickory_dns {
                false => Arc::new(GaiResolver::new()),
                #[cfg(feature = "hickory-dns")]
                true => Arc::new(HickoryDnsResolver::default()),
                #[cfg(not(feature = "hickory-dns"))]
                true => unreachable!("hickory-dns shouldn't be enabled unless the feature is"),
            };
            if let Some(dns_resolver) = config.dns_resolver {
                resolver = dns_resolver;
            }
            if !config.dns_overrides.is_empty() {
                resolver = Arc::new(DnsResolverWithOverrides::new(
                    resolver,
                    config.dns_overrides,
                ));
            }
            DynResolver::new(resolver)
        };

impl Service<HyperName> for DynResolver {
    type Response = Addrs;
    type Error = BoxError;
    type Future = Resolving;

    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
        Poll::Ready(Ok(()))
    }

    fn call(&mut self, name: HyperName) -> Self::Future {
        let resolving = self.resolver.resolve(Name(name));
        // Tag resolution failures so `Error::is_dns` can recognize them once
        Box::pin(async move { resolving.await.map_err(crate::error::dns) })
    }
}

struct Fails;
impl Resolve for Fails {
  fn resolve(&self, name: Name) -> Resolving {
    let msg = format!("no such host: {}", name.as_str());
    Box::pin(async move { Err(msg.into()) })
  }
}

  failing resolver, other name: error after 0ms is_dns=true is_connect=true: no such host: b.test

impl Resolve for GaiResolver {
    fn resolve(&self, name: Name) -> Resolving {
        let mut this = self.0.clone();
        Box::pin(async move {
            this.call(name.0)
                .await
                .map(|addrs| Box::new(addrs) as Addrs)
                .map_err(|err| Box::new(err) as BoxError)
        })
    }
}

  let rt = tokio::runtime::Builder::new_current_thread()
    .enable_all()
    .on_thread_start(|| println!("  [thread started: {}]", std::thread::current().name().unwrap_or("?")))
    .build()
    .unwrap();
  // ...
    get("hickory (default with the feature)", Client::builder(), &local).await;
    get("no_hickory_dns (getaddrinfo)", Client::builder().no_hickory_dns(), &local).await;
    get("no_hickory_dns, second client", Client::builder().no_hickory_dns(), &local).await;

== localhost, server on 127.0.0.1 and ::1
  hickory (default with the feature): 200 OK from [::1]:50252 after 5ms
  [thread started: tokio-rt-worker]
  no_hickory_dns (getaddrinfo): 200 OK from [::1]:50252 after 2ms
  no_hickory_dns, second client: 200 OK from [::1]:50252 after 0ms

fn new_resolver() -> Result<TokioResolver, NetError> {
    let mut builder = TokioResolver::builder_tokio().unwrap_or_else(|err| {
        log::debug!(
            "hickory-dns: failed to load system DNS configuration; falling back to Google DNS: {:?}",
            err
        );
        TokioResolver::builder_with_config(
            ResolverConfig::udp_and_tcp(&GOOGLE),
            TokioRuntimeProvider::default(),
        )
    });
    builder.options_mut().ip_strategy = LookupIpStrategy::Ipv6AndIpv4;
    builder.build()
}

    pub fn resolve_to_addrs(mut self, domain: &str, addrs: &[SocketAddr]) -> ClientBuilder {
        self.config
            .dns_overrides
            .insert(domain.to_ascii_lowercase(), addrs.to_vec());
        self
    }

impl Resolve for DnsResolverWithOverrides {
    fn resolve(&self, name: Name) -> Resolving {
        match self.overrides.get(name.as_str()) {
            Some(dest) => {
                let addrs: Addrs = Box::new(dest.clone().into_iter());
                Box::pin(std::future::ready(Ok(addrs)))
            }
            None => self.dns_resolver.resolve(name),
        }
    }
}

    let p = |x: u16| SocketAddr::from(([127, 0, 0, 1], x));
    get("override port 0, URL with port", Client::builder().resolve("a.test", p(0)), &format!("http://a.test:{port}/")).await;
    get("override with port, URL without port", Client::builder().resolve("a.test", p(port)), "http://a.test/").await;
    get("override port 1, URL with port", Client::builder().resolve("a.test", p(1)), &format!("http://a.test:{port}/")).await;
    get("override for A.TEST, URL a.test", Client::builder().resolve("A.TEST", p(port)), "http://a.test/").await;
    get("override + failing resolver", Client::builder().dns_resolver(Fails).resolve("a.test", p(port)), "http://a.test/").await;
    get("failing resolver, other name", Client::builder().dns_resolver(Fails).resolve("a.test", p(port)), "http://b.test/").await;

== resolve() overrides
  override port 0, URL with port: 200 OK from 127.0.0.1:50252 after 0ms
  override with port, URL without port: 200 OK from 127.0.0.1:50252 after 0ms
  override port 1, URL with port: 200 OK from 127.0.0.1:50252 after 0ms
  override for A.TEST, URL a.test: 200 OK from 127.0.0.1:50252 after 0ms
  override + failing resolver: 200 OK from 127.0.0.1:50252 after 0ms
  failing resolver, other name: error after 0ms is_dns=true is_connect=true: no such host: b.test

    let black = SocketAddr::from(([127, 0, 0, 2], port));
    let live6: SocketAddr = format!("[::1]:{port}").parse().unwrap();
    let url = format!("http://dual.test:{port}/");
    get("[black4, live6]", Client::builder().resolve_to_addrs("dual.test", &[black, live6]), &url).await;
    get("[black4, live4], connect_timeout 1s", Client::builder().resolve_to_addrs("dual.test", &[black, p(port)]).connect_timeout(Duration::from_secs(1)), &url).await;

== resolve_to_addrs with a black-holed first address (127.0.0.2)
  [black4, live6]: 200 OK from [::1]:50252 after 302ms
  [black4, live4], connect_timeout 1s: 200 OK from 127.0.0.1:50252 after 503ms

== resolver that takes 2s
no timeouts: 200 OK after 2005ms
connect_timeout(300ms): after 303ms is_connect=true is_timeout=true is_dns=false
    error sending request for url (http://slow.test:64705/) <- client error (Connect) <- operation timed out

  [black4, black4, black4, live4], connect_timeout 1s: 200 OK from 127.0.0.1:50252 after 760ms

  5 x black4 + live4, connect_timeout 1s: 200 OK from 127.0.0.1:56522 after 849ms
  6 x black4 + live4, connect_timeout 1s: 200 OK from 127.0.0.1:56522 after 876ms