wreq-rb 0.3.0

data/vendor/wreq/src/dns/gai.rs

@@ -0,0 +1,249 @@
+use std::{
+    future::Future,
+    io,
+    net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs},
+    pin::Pin,
+    task::{self, Poll},
+    vec,
+};
+
+use tokio::task::JoinHandle;
+use tower::Service;
+
+use super::{Addrs, Name, Resolve, Resolving};
+
+/// A resolver using blocking `getaddrinfo` calls in a threadpool.
+#[derive(Clone, Default)]
+pub struct GaiResolver {
+    _priv: (),
+}
+
+/// An iterator of IP addresses returned from `getaddrinfo`.
+pub struct GaiAddrs {
+    inner: SocketAddrs,
+}
+
+/// A future to resolve a name returned by `GaiResolver`.
+pub struct GaiFuture {
+    inner: JoinHandle<Result<SocketAddrs, io::Error>>,
+}
+
+/// A wrapper around `SocketAddrs` to implement the `Iterator` trait.
+pub(crate) struct SocketAddrs {
+    iter: vec::IntoIter<SocketAddr>,
+}
+
+// ==== impl GaiResolver ====
+
+impl GaiResolver {
+    /// Creates a new [`GaiResolver`].
+    pub fn new() -> Self {
+        GaiResolver { _priv: () }
+    }
+}
+
+impl Service<Name> for GaiResolver {
+    type Response = GaiAddrs;
+    type Error = io::Error;
+    type Future = GaiFuture;
+
+    fn poll_ready(&mut self, _cx: &mut task::Context<'_>) -> Poll<Result<(), io::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn call(&mut self, name: Name) -> Self::Future {
+        let blocking = tokio::task::spawn_blocking(move || {
+            debug!("resolving {}", name);
+            (name.as_str(), 0)
+                .to_socket_addrs()
+                .map(|i| SocketAddrs { iter: i })
+        });
+
+        GaiFuture { inner: blocking }
+    }
+}
+
+impl Resolve for GaiResolver {
+    fn resolve(&self, name: Name) -> Resolving {
+        let mut this = self.clone();
+        Box::pin(async move {
+            this.call(name)
+                .await
+                .map(|addrs| Box::new(addrs) as Addrs)
+                .map_err(Into::into)
+        })
+    }
+}
+
+// ==== impl GaiFuture ====
+
+impl Future for GaiFuture {
+    type Output = Result<GaiAddrs, io::Error>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
+        Pin::new(&mut self.inner).poll(cx).map(|res| match res {
+            Ok(Ok(addrs)) => Ok(GaiAddrs { inner: addrs }),
+            Ok(Err(err)) => Err(err),
+            Err(join_err) => {
+                if join_err.is_cancelled() {
+                    Err(io::Error::new(io::ErrorKind::Interrupted, join_err))
+                } else {
+                    panic!("gai background task failed: {join_err:?}")
+                }
+            }
+        })
+    }
+}
+
+impl Drop for GaiFuture {
+    fn drop(&mut self) {
+        self.inner.abort();
+    }
+}
+
+// ==== impl GaiAddrs ====
+
+impl Iterator for GaiAddrs {
+    type Item = SocketAddr;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.inner.next()
+    }
+}
+
+// ==== impl SocketAddrs ====
+
+impl SocketAddrs {
+    pub(crate) fn new(addrs: Vec<SocketAddr>) -> Self {
+        SocketAddrs {
+            iter: addrs.into_iter(),
+        }
+    }
+
+    pub(crate) fn try_parse(host: &str, port: u16) -> Option<SocketAddrs> {
+        if let Ok(addr) = host.parse::<Ipv4Addr>() {
+            let addr = SocketAddrV4::new(addr, port);
+            return Some(SocketAddrs {
+                iter: vec![SocketAddr::V4(addr)].into_iter(),
+            });
+        }
+        if let Ok(addr) = host.parse::<Ipv6Addr>() {
+            let addr = SocketAddrV6::new(addr, port, 0, 0);
+            return Some(SocketAddrs {
+                iter: vec![SocketAddr::V6(addr)].into_iter(),
+            });
+        }
+        None
+    }
+
+    #[inline]
+    fn filter(self, predicate: impl FnMut(&SocketAddr) -> bool) -> SocketAddrs {
+        SocketAddrs::new(self.iter.filter(predicate).collect())
+    }
+
+    pub(crate) fn split_by_preference(
+        self,
+        local_addr_ipv4: Option<Ipv4Addr>,
+        local_addr_ipv6: Option<Ipv6Addr>,
+    ) -> (SocketAddrs, SocketAddrs) {
+        match (local_addr_ipv4, local_addr_ipv6) {
+            (Some(_), None) => (self.filter(SocketAddr::is_ipv4), SocketAddrs::new(vec![])),
+            (None, Some(_)) => (self.filter(SocketAddr::is_ipv6), SocketAddrs::new(vec![])),
+            _ => {
+                let preferring_v6 = self
+                    .iter
+                    .as_slice()
+                    .first()
+                    .map(SocketAddr::is_ipv6)
+                    .unwrap_or(false);
+
+                let (preferred, fallback) = self
+                    .iter
+                    .partition::<Vec<_>, _>(|addr| addr.is_ipv6() == preferring_v6);
+
+                (SocketAddrs::new(preferred), SocketAddrs::new(fallback))
+            }
+        }
+    }
+
+    pub(crate) fn is_empty(&self) -> bool {
+        self.iter.as_slice().is_empty()
+    }
+
+    pub(crate) fn len(&self) -> usize {
+        self.iter.as_slice().len()
+    }
+}
+
+impl Iterator for SocketAddrs {
+    type Item = SocketAddr;
+    #[inline]
+    fn next(&mut self) -> Option<SocketAddr> {
+        self.iter.next()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::net::{Ipv4Addr, Ipv6Addr};
+
+    use super::*;
+
+    #[test]
+    fn test_ip_addrs_split_by_preference() {
+        let ip_v4 = Ipv4Addr::new(127, 0, 0, 1);
+        let ip_v6 = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1);
+        let v4_addr = (ip_v4, 80).into();
+        let v6_addr = (ip_v6, 80).into();
+
+        let (mut preferred, mut fallback) = SocketAddrs {
+            iter: vec![v4_addr, v6_addr].into_iter(),
+        }
+        .split_by_preference(None, None);
+        assert!(preferred.next().unwrap().is_ipv4());
+        assert!(fallback.next().unwrap().is_ipv6());
+
+        let (mut preferred, mut fallback) = SocketAddrs {
+            iter: vec![v6_addr, v4_addr].into_iter(),
+        }
+        .split_by_preference(None, None);
+        assert!(preferred.next().unwrap().is_ipv6());
+        assert!(fallback.next().unwrap().is_ipv4());
+
+        let (mut preferred, mut fallback) = SocketAddrs {
+            iter: vec![v4_addr, v6_addr].into_iter(),
+        }
+        .split_by_preference(Some(ip_v4), Some(ip_v6));
+        assert!(preferred.next().unwrap().is_ipv4());
+        assert!(fallback.next().unwrap().is_ipv6());
+
+        let (mut preferred, mut fallback) = SocketAddrs {
+            iter: vec![v6_addr, v4_addr].into_iter(),
+        }
+        .split_by_preference(Some(ip_v4), Some(ip_v6));
+        assert!(preferred.next().unwrap().is_ipv6());
+        assert!(fallback.next().unwrap().is_ipv4());
+
+        let (mut preferred, fallback) = SocketAddrs {
+            iter: vec![v4_addr, v6_addr].into_iter(),
+        }
+        .split_by_preference(Some(ip_v4), None);
+        assert!(preferred.next().unwrap().is_ipv4());
+        assert!(fallback.is_empty());
+
+        let (mut preferred, fallback) = SocketAddrs {
+            iter: vec![v4_addr, v6_addr].into_iter(),
+        }
+        .split_by_preference(None, Some(ip_v6));
+        assert!(preferred.next().unwrap().is_ipv6());
+        assert!(fallback.is_empty());
+    }
+
+    #[test]
+    fn test_name_from_str() {
+        const DOMAIN: &str = "test.example.com";
+        let name = Name::from(DOMAIN);
+        assert_eq!(name.as_str(), DOMAIN);
+        assert_eq!(name.to_string(), DOMAIN);
+    }
+}

data/vendor/wreq/src/dns/hickory.rs

@@ -0,0 +1,78 @@
+//! DNS resolution via the [hickory-resolver](https://github.com/hickory-dns/hickory-dns) crate
+
+use std::{net::SocketAddr, sync::LazyLock};
+
+use hickory_resolver::{
+    TokioResolver,
+    config::{LookupIpStrategy, ResolverConfig},
+    lookup_ip::LookupIpIntoIter,
+    name_server::TokioConnectionProvider,
+};
+
+use super::{Addrs, Name, Resolve, Resolving};
+
+/// Wrapper around an [`TokioResolver`], which implements the `Resolve` trait.
+#[derive(Debug, Clone)]
+pub struct HickoryDnsResolver {
+    /// Shared, lazily-initialized Tokio-based DNS resolver.
+    ///
+    /// Backed by [`LazyLock`] to guarantee thread-safe, one-time creation.
+    /// On initialization, it attempts to load the system's DNS configuration;
+    /// if unavailable, it falls back to sensible default settings.
+    resolver: &'static LazyLock<TokioResolver>,
+}
+
+impl HickoryDnsResolver {
+    /// Create a new resolver with the default configuration,
+    /// which reads from `/etc/resolve.conf`. The options are
+    /// overriden to look up for both IPv4 and IPv6 addresses
+    /// to work with "happy eyeballs" algorithm.
+    pub fn new() -> HickoryDnsResolver {
+        static RESOLVER: LazyLock<TokioResolver> = LazyLock::new(|| {
+            let mut builder = match TokioResolver::builder_tokio() {
+                Ok(resolver) => {
+                    debug!("using system DNS configuration");
+                    resolver
+                }
+                Err(_err) => {
+                    debug!("error reading DNS system conf: {}, using defaults", _err);
+                    TokioResolver::builder_with_config(
+                        ResolverConfig::default(),
+                        TokioConnectionProvider::default(),
+                    )
+                }
+            };
+            builder.options_mut().ip_strategy = LookupIpStrategy::Ipv4AndIpv6;
+            builder.build()
+        });
+
+        HickoryDnsResolver {
+            resolver: &RESOLVER,
+        }
+    }
+}
+
+struct SocketAddrs {
+    iter: LookupIpIntoIter,
+}
+
+impl Resolve for HickoryDnsResolver {
+    fn resolve(&self, name: Name) -> Resolving {
+        let resolver = self.clone();
+        Box::pin(async move {
+            let lookup = resolver.resolver.lookup_ip(name.as_str()).await?;
+            let addrs: Addrs = Box::new(SocketAddrs {
+                iter: lookup.into_iter(),
+            });
+            Ok(addrs)
+        })
+    }
+}
+
+impl Iterator for SocketAddrs {
+    type Item = SocketAddr;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.iter.next().map(|ip_addr| SocketAddr::new(ip_addr, 0))
+    }
+}

data/vendor/wreq/src/dns/resolve.rs

@@ -0,0 +1,180 @@
+use std::{
+    borrow::Cow,
+    collections::HashMap,
+    fmt,
+    future::Future,
+    net::SocketAddr,
+    pin::Pin,
+    sync::Arc,
+    task::{Context, Poll},
+};
+
+use tower::Service;
+
+use crate::error::BoxError;
+
+/// A domain name to resolve into IP addresses.
+#[derive(Clone, Hash, Eq, PartialEq)]
+pub struct Name {
+    host: Box<str>,
+}
+
+impl Name {
+    /// Creates a new [`Name`] from a string slice.
+    #[inline]
+    pub fn new(host: Box<str>) -> Name {
+        Name { host }
+    }
+
+    /// View the hostname as a string slice.
+    #[inline]
+    pub fn as_str(&self) -> &str {
+        &self.host
+    }
+}
+
+impl From<&str> for Name {
+    fn from(value: &str) -> Self {
+        Name::new(value.into())
+    }
+}
+
+impl fmt::Debug for Name {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(&self.host, f)
+    }
+}
+
+impl fmt::Display for Name {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(&self.host, f)
+    }
+}
+
+/// 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 wreq.
+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<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 URI 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;
+}
+
+/// Trait for converting types into a shared DNS resolver ([`Arc<dyn Resolve>`]).
+///
+/// Implemented for any [`Resolve`] type, [`Arc<T>`] where `T: Resolve`, and [`Arc<dyn Resolve>`].
+/// Enables ergonomic conversion to a trait object for use in APIs without manual Arc wrapping.
+pub trait IntoResolve {
+    /// Converts the implementor into an [`Arc<dyn Resolve>`].
+    ///
+    /// This method enables ergonomic conversion of concrete resolvers, [`Arc<T>`], or
+    /// existing [`Arc<dyn Resolve>`] into a trait object suitable for APIs that expect
+    /// a shared DNS resolver.
+    fn into_resolve(self) -> Arc<dyn Resolve>;
+}
+
+impl IntoResolve for Arc<dyn Resolve> {
+    #[inline]
+    fn into_resolve(self) -> Arc<dyn Resolve> {
+        self
+    }
+}
+
+impl<R> IntoResolve for Arc<R>
+where
+    R: Resolve + 'static,
+{
+    #[inline]
+    fn into_resolve(self) -> Arc<dyn Resolve> {
+        self
+    }
+}
+
+impl<R> IntoResolve for R
+where
+    R: Resolve + 'static,
+{
+    #[inline]
+    fn into_resolve(self) -> Arc<dyn Resolve> {
+        Arc::new(self)
+    }
+}
+
+/// Adapter that wraps a [`Resolve`] trait object to work with Tower's `Service` trait.
+///
+/// This allows custom DNS resolvers implementing `Resolve` to be used in contexts
+/// that expect a `Service<Name>` implementation.
+#[derive(Clone)]
+pub(crate) struct DynResolver {
+    resolver: Arc<dyn Resolve>,
+}
+
+impl DynResolver {
+    /// Creates a new [`DynResolver`] with the provided resolver.
+    pub(crate) fn new(resolver: Arc<dyn Resolve>) -> Self {
+        Self { resolver }
+    }
+}
+
+impl Service<Name> 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: Name) -> Self::Future {
+        self.resolver.resolve(name)
+    }
+}
+
+/// DNS resolver that supports hostname overrides.
+///
+/// This resolver first checks for manual hostname-to-IP mappings before
+/// falling back to the underlying DNS resolver. Useful for testing or
+/// bypassing DNS for specific domains.
+pub(crate) struct DnsResolverWithOverrides {
+    dns_resolver: Arc<dyn Resolve>,
+    overrides: Arc<HashMap<Cow<'static, str>, Vec<SocketAddr>>>,
+}
+
+impl DnsResolverWithOverrides {
+    /// Creates a new [`DnsResolverWithOverrides`] with the provided DNS resolver and overrides.
+    pub(crate) fn new(
+        dns_resolver: Arc<dyn Resolve>,
+        overrides: HashMap<Cow<'static, str>, Vec<SocketAddr>>,
+    ) -> Self {
+        DnsResolverWithOverrides {
+            dns_resolver,
+            overrides: Arc::new(overrides),
+        }
+    }
+}
+
+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),
+        }
+    }
+}

data/vendor/wreq/src/dns.rs

@@ -0,0 +1,69 @@
+//! DNS resolution
+
+pub(crate) mod gai;
+#[cfg(feature = "hickory-dns")]
+pub(crate) mod hickory;
+pub(crate) mod resolve;
+
+pub use resolve::{Addrs, IntoResolve, Name, Resolve, Resolving};
+
+pub(crate) use self::{
+    gai::{GaiResolver, SocketAddrs},
+    resolve::{DnsResolverWithOverrides, DynResolver},
+    sealed::{InternalResolve, resolve},
+};
+
+mod sealed {
+    use std::{
+        future::Future,
+        net::SocketAddr,
+        task::{self, Poll},
+    };
+
+    use tower::Service;
+
+    use super::Name;
+    use crate::error::BoxError;
+
+    /// Internal adapter trait for DNS resolvers.
+    ///
+    /// This trait provides a unified interface for different resolver implementations,
+    /// allowing both custom [`super::Resolve`] types and Tower [`Service`] implementations
+    /// to be used interchangeably within the connector.
+    pub trait InternalResolve {
+        type Addrs: Iterator<Item = SocketAddr>;
+        type Error: Into<BoxError>;
+        type Future: Future<Output = Result<Self::Addrs, Self::Error>>;
+
+        fn poll_ready(&mut self, cx: &mut task::Context<'_>) -> Poll<Result<(), Self::Error>>;
+        fn resolve(&mut self, name: Name) -> Self::Future;
+    }
+
+    /// Automatic implementation for any Tower [`Service`] that resolves names to socket addresses.
+    impl<S> InternalResolve for S
+    where
+        S: Service<Name>,
+        S::Response: Iterator<Item = SocketAddr>,
+        S::Error: Into<BoxError>,
+    {
+        type Addrs = S::Response;
+        type Error = S::Error;
+        type Future = S::Future;
+
+        fn poll_ready(&mut self, cx: &mut task::Context<'_>) -> Poll<Result<(), Self::Error>> {
+            Service::poll_ready(self, cx)
+        }
+
+        fn resolve(&mut self, name: Name) -> Self::Future {
+            Service::call(self, name)
+        }
+    }
+
+    pub async fn resolve<R>(resolver: &mut R, name: Name) -> Result<R::Addrs, R::Error>
+    where
+        R: InternalResolve,
+    {
+        std::future::poll_fn(|cx| resolver.poll_ready(cx)).await?;
+        resolver.resolve(name).await
+    }
+}