wreq-rb 0.6.0 → 0.6.1

data/vendor/wreq/src/conn/connector.rs

@@ -1,31 +1,35 @@
 use std::{
     borrow::Cow,
-    future::Future,
-    pin::Pin,
     sync::Arc,
     task::{Context, Poll},
     time::Duration,
 };
 
+use futures_util::future::BoxFuture;
 use tokio_btls::SslStream;
 use tower::{
-    BoxError, Service, ServiceBuilder, ServiceExt,
-    timeout::TimeoutLayer,
-    util::{BoxCloneSyncService, MapRequestLayer},
+    BoxError, Layer, Service, ServiceBuilder, ServiceExt,
+    util::{BoxCloneSyncService, Either, MapRequest, MapRequestLayer},
 };
 
 #[cfg(unix)]
 use super::net::UnixConnector;
 use super::{
-    AsyncConnWithInfo, BoxedConnectorLayer, BoxedConnectorService, Conn, Connection, HttpConnector,
-    TlsConn, TlsInfoFactory, Unnameable, descriptor::ConnectionDescriptor, http::HttpConnect,
-    net::TcpConnector, proxy, verbose::Verbose,
+    AsyncConnWithInfo, BoxedConnectorLayer, BoxedTransportConnector, Conn, Connection,
+    HttpConnector, TlsConn, TlsInfoFactory, Unnameable,
+    descriptor::ConnectionDescriptor,
+    http::HttpConnect,
+    net::TcpConnector,
+    proxy,
+    timeout::{Timeout, TimeoutLayer},
+    verbose::Verbose,
 };
 use crate::{
     dns::DynResolver,
-    error::{ProxyConnect, TimedOut, map_timeout_to_connector_error},
+    error::{ProxyConnect, map_timeout_to_connector_error},
     ext::UriExt,
     proxy::{Intercepted, Matcher as ProxyMatcher, matcher::Intercept},
+    rt::Timer,
     tls::{
         TlsOptions,
         conn::{
@@ -34,41 +38,51 @@ use crate::{
     },
 };
 
-type Connecting = Pin<Box<dyn Future<Output = Result<Conn, BoxError>> + Send>>;
-
-/// Configuration for the connector service.
+/// Client-wide connection settings retained by each transport connector.
+///
+/// These defaults control proxy selection, socket behavior, stream instrumentation, and TLS
+/// metadata. Settings that can vary per request remain in [`ConnectionDescriptor`] and are
+/// applied when a connection starts.
 #[derive(Clone)]
 struct Config {
     proxies: Arc<Vec<ProxyMatcher>>,
     verbose: Verbose,
     nodelay: bool,
     tls_info: bool,
-    /// When there is a single timeout layer and no other layers,
-    /// we embed it directly inside our base Service::call().
-    /// This lets us avoid an extra `Box::pin` indirection layer
-    /// since `tokio::time::Timeout` is `Unpin`
-    timeout: Option<Duration>,
 }
 
-/// Builder for `Connector`.
+/// Assembles the transport service graph used by a client.
+///
+/// The builder owns DNS, TCP, TLS, and timeout configuration until [`ConnectorBuilder::build`]
+/// places the timeout around the concrete connector and any user-provided layers.
 pub struct ConnectorBuilder {
     config: Config,
+    timer: Timer,
+    timeout: Option<Duration>,
     #[cfg(feature = "socks")]
     resolver: DynResolver,
     http: HttpConnector,
     builder: TlsConnectorBuilder,
 }
 
-/// Connector service that establishes connections.
-#[derive(Clone)]
-pub enum Connector {
-    Simple(ConnectorService),
-    WithLayers(BoxedConnectorService),
-}
-
-/// Service that establishes connections to HTTP servers.
+/// Client-owned transport service selected when the connector graph is assembled.
+///
+/// The left branch keeps the graph concrete when no custom layers are present. The right branch
+/// wraps the type-erased custom-layer graph so it also accepts [`ConnectionDescriptor`]. Both
+/// branches remain with the client and create a separately timed future for each connection
+/// attempt.
+pub type Connector = Either<
+    Timeout<TransportConnector>,
+    MapRequest<BoxedTransportConnector, fn(ConnectionDescriptor) -> Unnameable>,
+>;
+
+/// Establishes the transport consumed by the HTTP protocol layer.
+///
+/// Each call selects the proxy path, applies request-specific socket and TLS settings, and returns
+/// an established [`Conn`]. The service is cloned into each in-flight connection future, while its
+/// immutable TLS builder is shared across those attempts.
 #[derive(Clone)]
-pub struct ConnectorService {
+pub struct TransportConnector {
     config: Config,
     #[cfg(feature = "socks")]
     resolver: DynResolver,
@@ -80,6 +94,24 @@ pub struct ConnectorService {
 // ===== impl ConnectorBuilder =====
 
 impl ConnectorBuilder {
+    /// Creates a builder with the client's proxy and DNS configuration.
+    pub(crate) fn new(proxies: Vec<ProxyMatcher>, resolver: DynResolver) -> Self {
+        Self {
+            config: Config {
+                proxies: Arc::new(proxies),
+                verbose: Verbose::OFF,
+                nodelay: true,
+                tls_info: false,
+            },
+            timer: Timer::default(),
+            timeout: None,
+            #[cfg(feature = "socks")]
+            resolver: resolver.clone(),
+            http: HttpConnector::new(resolver, TcpConnector::new()),
+            builder: TlsConnector::builder(),
+        }
+    }
+
     /// Set the HTTP connector to use.
     #[inline]
     pub fn with_http<F>(mut self, call: F) -> ConnectorBuilder
@@ -101,12 +133,16 @@ impl ConnectorBuilder {
     }
 
     /// Set the connect timeout.
-    ///
-    /// If a domain resolves to multiple IP addresses, the timeout will be
-    /// evenly divided across them.
     #[inline]
     pub fn timeout(mut self, timeout: Option<Duration>) -> ConnectorBuilder {
-        self.config.timeout = timeout;
+        self.timeout = timeout;
+        self
+    }
+
+    /// Set the timer used to drive the connect timeout.
+    #[inline]
+    pub fn timer(mut self, timer: Timer) -> ConnectorBuilder {
+        self.timer = timer;
         self
     }
 
@@ -137,7 +173,8 @@ impl ConnectorBuilder {
         tls_options: Option<TlsOptions>,
         layers: Vec<BoxedConnectorLayer>,
     ) -> crate::Result<Connector> {
-        let mut service = ConnectorService {
+        let timeout = TimeoutLayer::new(self.timer, self.timeout);
+        let service = TransportConnector {
             config: self.config,
             #[cfg(feature = "socks")]
             resolver: self.resolver.clone(),
@@ -150,12 +187,9 @@ impl ConnectorBuilder {
 
         // we have no user-provided layers, only use concrete types
         if layers.is_empty() {
-            return Ok(Connector::Simple(service));
+            return Ok(Either::Left(timeout.layer(service)));
         }
 
-        // user-provided layers exist, the timeout will be applied as an additional layer.
-        let timeout = service.config.timeout.take();
-
         // otherwise we have user provided layers
         // so we need type erasure all the way through
         // as well as mapping the unnameable type of the layers back to ConnectionDescriptor for the
@@ -169,78 +203,25 @@ impl ConnectorBuilder {
             |service, layer| ServiceBuilder::new().layer(layer).service(service),
         );
 
-        // now we handle the concrete stuff - any `connect_timeout`,
-        // plus a final map_err layer we can use to cast default tower layer
-        // errors to internal errors
-        match timeout {
-            Some(timeout) => {
-                let service = ServiceBuilder::new()
-                    .layer(TimeoutLayer::new(timeout))
-                    .service(service)
-                    .map_err(map_timeout_to_connector_error);
-
-                Ok(Connector::WithLayers(BoxCloneSyncService::new(service)))
-            }
-            None => {
-                // no timeout, but still map err
-                // no named timeout layer but we still map errors since
-                // we might have user-provided timeout layer
-                let service = ServiceBuilder::new()
-                    .service(service)
-                    .map_err(map_timeout_to_connector_error);
-
-                Ok(Connector::WithLayers(BoxCloneSyncService::new(service)))
-            }
-        }
-    }
-}
-
-// ===== impl Connector =====
-
-impl Connector {
-    /// Creates a new [`Connector`] with the provided configuration and optional layers.
-    pub(crate) fn builder(proxies: Vec<ProxyMatcher>, resolver: DynResolver) -> ConnectorBuilder {
-        ConnectorBuilder {
-            config: Config {
-                proxies: Arc::new(proxies),
-                verbose: Verbose::OFF,
-                nodelay: true,
-                tls_info: false,
-                timeout: None,
-            },
-            #[cfg(feature = "socks")]
-            resolver: resolver.clone(),
-            http: HttpConnector::new(resolver, TcpConnector::new()),
-            builder: TlsConnector::builder(),
-        }
-    }
-}
+        // Keep the built-in timeout outside user layers so it covers their work too.
+        // The final mapping also handles a tower timeout supplied by the caller.
+        let service = ServiceBuilder::new()
+            .layer(timeout)
+            .service(service)
+            .map_err(map_timeout_to_connector_error);
 
-impl Service<ConnectionDescriptor> for Connector {
-    type Response = Conn;
-    type Error = BoxError;
-    type Future = Connecting;
-
-    #[inline]
-    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        match self {
-            Connector::Simple(service) => service.poll_ready(cx),
-            Connector::WithLayers(service) => service.poll_ready(cx),
-        }
-    }
+        let service = MapRequest::new(
+            BoxCloneSyncService::new(service),
+            Unnameable as fn(ConnectionDescriptor) -> Unnameable,
+        );
 
-    #[inline]
-    fn call(&mut self, descriptor: ConnectionDescriptor) -> Self::Future {
-        match self {
-            Connector::Simple(service) => service.call(descriptor),
-            Connector::WithLayers(service) => service.call(Unnameable(descriptor)),
-        }
+        Ok(Either::Right(service))
     }
 }
 
-// ===== impl ConnectorService =====
+// ===== impl TransportConnector =====
 
-impl ConnectorService {
+impl TransportConnector {
     fn build_https_connector(
         &self,
         https: bool,
@@ -503,41 +484,30 @@ impl ConnectorService {
     async fn connect_auto(self, req: ConnectionDescriptor) -> Result<Conn, BoxError> {
         debug!("starting new connection: {:?}", req.uri());
 
-        let timeout = self.config.timeout;
-
         // Determine if a proxy should be used for this request.
-        let fut = async {
-            let intercepted = req
-                .proxy()
-                .and_then(|prox| prox.intercept(req.uri()))
-                .or_else(|| {
-                    self.config
-                        .proxies
-                        .iter()
-                        .find_map(|prox| prox.intercept(req.uri()))
-                });
-
-            // If a proxy is matched, connect via proxy; otherwise, connect directly.
-            if let Some(intercepted) = intercepted {
-                self.connect_via_proxy(req, intercepted).await
-            } else {
-                self.connect_auto_proxy(req, None).await
-            }
-        };
-
-        // Apply timeout if configured.
-        if let Some(to) = timeout {
-            tokio::time::timeout(to, fut).await.map_err(|_| TimedOut)?
+        let intercepted = req
+            .proxy()
+            .and_then(|prox| prox.intercept(req.uri()))
+            .or_else(|| {
+                self.config
+                    .proxies
+                    .iter()
+                    .find_map(|prox| prox.intercept(req.uri()))
+            });
+
+        // If a proxy is matched, connect via proxy; otherwise, connect directly.
+        if let Some(intercepted) = intercepted {
+            self.connect_via_proxy(req, intercepted).await
         } else {
-            fut.await
+            self.connect_auto_proxy(req, None).await
         }
     }
 }
 
-impl Service<ConnectionDescriptor> for ConnectorService {
+impl Service<ConnectionDescriptor> for TransportConnector {
     type Response = Conn;
     type Error = BoxError;
-    type Future = Connecting;
+    type Future = BoxFuture<'static, Result<Conn, BoxError>>;
 
     #[inline]
     fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {

data/vendor/wreq/src/conn/http.rs

@@ -20,7 +20,7 @@ use super::{
         tcp::{ConnectError, ConnectingTcp, TcpConnector, TcpKeepaliveOptions, TcpOptions},
     },
 };
-use crate::dns::{self, InternalResolve};
+use crate::dns::{self, DnsResolver};
 
 static INVALID_NOT_HTTP: &str = "invalid URI, scheme is not http";
 static INVALID_MISSING_SCHEME: &str = "invalid URI, scheme is missing";
@@ -56,16 +56,19 @@ where
     /// Set that all socket have `SO_REUSEADDR` set to the supplied value `reuse_address`.
     fn set_reuse_address(&mut self, reuse: bool);
 
+    /// Sets the value of the `SO_LINGER` option on the socket.
+    fn set_linger(&mut self, linger: Option<Duration>);
+
     /// Sets the value of the `TCP_USER_TIMEOUT` option on the socket.
     #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
     fn set_tcp_user_timeout(&mut self, time: Option<Duration>);
 
-    /// Set the connect timeout.
+    /// Set the timeout for the complete TCP connection race.
     fn set_connect_timeout(&mut self, dur: Option<Duration>);
 
-    /// Set timeout for [RFC 6555 (Happy Eyeballs)][RFC 6555] algorithm.
+    /// Set the delay between connection attempts for [RFC 8305 (Happy Eyeballs v2)][RFC 8305].
     ///
-    /// [RFC 6555]: https://tools.ietf.org/html/rfc6555
+    /// [RFC 8305]: https://www.rfc-editor.org/rfc/rfc8305.html#section-5
     fn set_happy_eyeballs_timeout(&mut self, dur: Option<Duration>);
 
     /// Set that all sockets have `SO_KEEPALIVE` set with the supplied duration
@@ -156,6 +159,7 @@ impl<R, S> HttpConnector<R, S> {
                 happy_eyeballs_timeout: Some(Duration::from_millis(300)),
                 nodelay: false,
                 reuse_address: false,
+                linger: None,
                 send_buffer_size: None,
                 recv_buffer_size: None,
                 #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
@@ -178,7 +182,7 @@ impl<R, S> HttpConnector<R, S> {
 
 impl<R, S> HttpConnect for HttpConnector<R, S>
 where
-    R: InternalResolve + Clone + Send + Sync + 'static,
+    R: DnsResolver + Clone + Send + Sync + 'static,
     R::Future: Send,
     S: TcpConnector,
 {
@@ -218,6 +222,14 @@ where
         self.config_mut().reuse_address = reuse_address;
     }
 
+    /// Sets the value of the SO_LINGER option on the socket.
+    ///
+    /// Default is `None`, which leaves the option untouched.
+    #[inline]
+    fn set_linger(&mut self, linger: Option<Duration>) {
+        self.config_mut().linger = linger;
+    }
+
     /// Sets the value of the TCP_USER_TIMEOUT option on the socket.
     #[inline]
     #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
@@ -225,10 +237,7 @@ where
         self.config_mut().tcp_user_timeout = time;
     }
 
-    /// Set the connect timeout.
-    ///
-    /// If a domain resolves to multiple IP addresses, the timeout will be
-    /// evenly divided across them.
+    /// Set the timeout for the complete TCP connection race.
     ///
     /// Default is `None`.
     #[inline]
@@ -236,18 +245,16 @@ where
         self.config_mut().connect_timeout = dur;
     }
 
-    /// Set timeout for [RFC 6555 (Happy Eyeballs)][RFC 6555] algorithm.
+    /// Set the delay between connection attempts for [RFC 8305 (Happy Eyeballs v2)][RFC 8305].
     ///
-    /// If hostname resolves to both IPv4 and IPv6 addresses and connection
-    /// cannot be established using preferred address family before timeout
-    /// elapses, then connector will in parallel attempt connection using other
-    /// address family.
+    /// The first address is attempted immediately. Later addresses are started
+    /// after this delay without waiting for the previous attempt to finish.
     ///
     /// If `None`, parallel connection attempts are disabled.
     ///
     /// Default is 300 milliseconds.
     ///
-    /// [RFC 6555]: https://tools.ietf.org/html/rfc6555
+    /// [RFC 8305]: https://www.rfc-editor.org/rfc/rfc8305.html#section-5
     #[inline]
     fn set_happy_eyeballs_timeout(&mut self, dur: Option<Duration>) {
         self.config_mut().happy_eyeballs_timeout = dur;
@@ -337,7 +344,7 @@ where
 
 impl<R, S> Service<Uri> for HttpConnector<R, S>
 where
-    R: InternalResolve + Clone + Send + Sync + 'static,
+    R: DnsResolver + Clone + Send + Sync + 'static,
     R::Future: Send,
     S: TcpConnector,
     S::TcpStream: From<socket2::Socket>,
@@ -358,7 +365,7 @@ where
             let options = &this.options;
 
             let (host, port) = get_host_port(options, &dst)?;
-            let host = host.trim_start_matches('[').trim_end_matches(']');
+            let host = crate::util::strip_ipv6_brackets(host);
 
             let addrs = if let Some(addrs) = dns::SocketAddrs::try_parse(host, port) {
                 addrs
@@ -472,7 +479,7 @@ pin_project! {
 
 impl<R, S> Future for HttpConnecting<R, S>
 where
-    R: InternalResolve,
+    R: DnsResolver,
     S: TcpConnector,
 {
     type Output = ConnectResult<S>;