wreq-rb 0.3.0

data/vendor/wreq/src/client/conn/verbose.rs

@@ -0,0 +1,149 @@
+use super::AsyncConnWithInfo;
+
+/// Controls whether to enable verbose tracing for connections.
+///
+/// When enabled (with the `tracing` feature), connections are wrapped to log I/O operations for
+/// debugging.
+#[derive(Clone, Copy)]
+pub struct Verbose(pub(super) bool);
+
+impl Verbose {
+    pub const OFF: Verbose = Verbose(false);
+
+    #[cfg_attr(not(feature = "tracing"), inline(always))]
+    pub(super) fn wrap<T>(&self, conn: T) -> Box<dyn AsyncConnWithInfo>
+    where
+        T: AsyncConnWithInfo + 'static,
+    {
+        #[cfg(feature = "tracing")]
+        if self.0 {
+            return Box::new(sealed::Wrapper {
+                id: crate::util::fast_random(),
+                inner: conn,
+            });
+        }
+
+        Box::new(conn)
+    }
+}
+
+#[cfg(feature = "tracing")]
+mod sealed {
+    use std::{
+        fmt,
+        io::{self, IoSlice},
+        pin::Pin,
+        task::{Context, Poll},
+    };
+
+    use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
+
+    use super::super::{Connected, Connection, TlsInfoFactory};
+    use crate::{tls::TlsInfo, util::Escape};
+
+    pub(super) struct Wrapper<T> {
+        pub(super) id: u64,
+        pub(super) inner: T,
+    }
+
+    impl<T: Connection + AsyncRead + AsyncWrite + Unpin> Connection for Wrapper<T> {
+        #[inline]
+        fn connected(&self) -> Connected {
+            self.inner.connected()
+        }
+    }
+
+    impl<T: AsyncRead + AsyncWrite + Unpin> AsyncRead for Wrapper<T> {
+        fn poll_read(
+            mut self: Pin<&mut Self>,
+            cx: &mut Context,
+            buf: &mut ReadBuf<'_>,
+        ) -> Poll<std::io::Result<()>> {
+            match Pin::new(&mut self.inner).poll_read(cx, buf) {
+                Poll::Ready(Ok(())) => {
+                    trace!("{:08x} read: {:?}", self.id, Escape::new(buf.filled()));
+                    Poll::Ready(Ok(()))
+                }
+                Poll::Ready(Err(e)) => Poll::Ready(Err(e)),
+                Poll::Pending => Poll::Pending,
+            }
+        }
+    }
+
+    impl<T: AsyncRead + AsyncWrite + Unpin> AsyncWrite for Wrapper<T> {
+        fn poll_write(
+            mut self: Pin<&mut Self>,
+            cx: &mut Context,
+            buf: &[u8],
+        ) -> Poll<io::Result<usize>> {
+            match Pin::new(&mut self.inner).poll_write(cx, buf) {
+                Poll::Ready(Ok(n)) => {
+                    trace!("{:08x} write: {:?}", self.id, Escape::new(&buf[..n]));
+                    Poll::Ready(Ok(n))
+                }
+                Poll::Ready(Err(e)) => Poll::Ready(Err(e)),
+                Poll::Pending => Poll::Pending,
+            }
+        }
+
+        fn poll_write_vectored(
+            mut self: Pin<&mut Self>,
+            cx: &mut Context<'_>,
+            bufs: &[IoSlice<'_>],
+        ) -> Poll<io::Result<usize>> {
+            match Pin::new(&mut self.inner).poll_write_vectored(cx, bufs) {
+                Poll::Ready(Ok(nwritten)) => {
+                    trace!(
+                        "{:08x} write (vectored): {:?}",
+                        self.id,
+                        Vectored { bufs, nwritten }
+                    );
+                    Poll::Ready(Ok(nwritten))
+                }
+                Poll::Ready(Err(e)) => Poll::Ready(Err(e)),
+                Poll::Pending => Poll::Pending,
+            }
+        }
+
+        #[inline]
+        fn is_write_vectored(&self) -> bool {
+            self.inner.is_write_vectored()
+        }
+
+        #[inline]
+        fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<io::Result<()>> {
+            Pin::new(&mut self.inner).poll_flush(cx)
+        }
+
+        #[inline]
+        fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<io::Result<()>> {
+            Pin::new(&mut self.inner).poll_shutdown(cx)
+        }
+    }
+
+    impl<T: TlsInfoFactory> TlsInfoFactory for Wrapper<T> {
+        fn tls_info(&self) -> Option<TlsInfo> {
+            self.inner.tls_info()
+        }
+    }
+
+    struct Vectored<'a, 'b> {
+        bufs: &'a [IoSlice<'b>],
+        nwritten: usize,
+    }
+
+    impl fmt::Debug for Vectored<'_, '_> {
+        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+            let mut left = self.nwritten;
+            for buf in self.bufs.iter() {
+                if left == 0 {
+                    break;
+                }
+                let n = std::cmp::min(left, buf.len());
+                Escape::new(&buf[..n]).fmt(f)?;
+                left -= n;
+            }
+            Ok(())
+        }
+    }
+}

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

@@ -0,0 +1,323 @@
+#[allow(clippy::module_inception)]
+mod conn;
+mod connector;
+mod http;
+mod proxy;
+mod tls_info;
+#[cfg(unix)]
+mod uds;
+mod verbose;
+
+use std::{
+    fmt::{self, Debug, Formatter},
+    sync::{
+        Arc,
+        atomic::{AtomicBool, Ordering},
+    },
+};
+
+use ::http::{Extensions, HeaderMap, HeaderValue};
+use tokio::io::{AsyncRead, AsyncWrite};
+use tower::{
+    BoxError,
+    util::{BoxCloneSyncService, BoxCloneSyncServiceLayer},
+};
+
+#[cfg(feature = "socks")]
+pub(super) use self::proxy::socks;
+pub(super) use self::{
+    conn::Conn,
+    connector::Connector,
+    http::{HttpInfo, TcpConnectOptions},
+    proxy::tunnel,
+    tls_info::TlsInfoFactory,
+};
+use crate::{client::ConnectRequest, dns::DynResolver, proxy::matcher::Intercept};
+
+/// HTTP connector with dynamic DNS resolver.
+pub type HttpConnector = self::http::HttpConnector<DynResolver>;
+
+/// Boxed connector service for establishing connections.
+pub type BoxedConnectorService = BoxCloneSyncService<Unnameable, Conn, BoxError>;
+
+/// Boxed layer for building a boxed connector service.
+pub type BoxedConnectorLayer =
+    BoxCloneSyncServiceLayer<BoxedConnectorService, Unnameable, Conn, BoxError>;
+
+/// A wrapper type for [`ConnectRequest`] used to erase its concrete type.
+///
+/// [`Unnameable`] allows passing connection requests through trait objects or
+/// type-erased interfaces where the concrete type of the request is not important.
+/// This is mainly used internally to simplify service composition and dynamic dispatch.
+pub struct Unnameable(pub(super) ConnectRequest);
+
+/// A trait alias for types that can be used as async connections.
+///
+/// This trait is automatically implemented for any type that satisfies the required bounds:
+/// - [`AsyncRead`] + [`AsyncWrite`]: For I/O operations
+/// - [`Connection`]: For connection metadata
+/// - [`Send`] + [`Sync`] + [`Unpin`] + `'static`: For async/await compatibility
+trait AsyncConn: AsyncRead + AsyncWrite + Connection + Send + Sync + Unpin + 'static {}
+
+/// An async connection that can also provide TLS information.
+///
+/// This extends [`AsyncConn`] with the ability to extract TLS certificate information
+/// when available. Useful for connections that may be either plain TCP or TLS-encrypted.
+trait AsyncConnWithInfo: AsyncConn + TlsInfoFactory {}
+
+impl<T> AsyncConn for T where T: AsyncRead + AsyncWrite + Connection + Send + Sync + Unpin + 'static {}
+
+impl<T> AsyncConnWithInfo for T where T: AsyncConn + TlsInfoFactory {}
+
+/// Describes a type returned by a connector.
+pub trait Connection {
+    /// Return metadata describing the connection.
+    fn connected(&self) -> Connected;
+}
+
+/// Indicates the negotiated ALPN protocol.
+#[derive(Clone, Copy, Debug, PartialEq)]
+enum Alpn {
+    H2,
+    None,
+}
+
+/// A pill that can be poisoned to indicate that a connection should not be reused.
+#[derive(Clone)]
+struct PoisonPill {
+    poisoned: Arc<AtomicBool>,
+}
+
+/// A boxed asynchronous connection with associated information.
+#[derive(Debug)]
+struct Extra(Box<dyn ExtraInner>);
+
+/// Inner trait for extra connection information.
+trait ExtraInner: Send + Sync + Debug {
+    fn clone_box(&self) -> Box<dyn ExtraInner>;
+    fn set(&self, res: &mut Extensions);
+}
+
+// This indirection allows the `Connected` to have a type-erased "extra" value,
+// while that type still knows its inner extra type. This allows the correct
+// TypeId to be used when inserting into `res.extensions_mut()`.
+#[derive(Debug, Clone)]
+struct ExtraEnvelope<T>(T);
+
+/// Chains two `ExtraInner` implementations together, inserting both into
+/// the extensions.
+#[derive(Debug)]
+struct ExtraChain<T>(Box<dyn ExtraInner>, T);
+
+/// Information about an HTTP proxy identity.
+#[derive(Debug, Default, Clone)]
+struct ProxyIdentity {
+    is_proxied: bool,
+    auth: Option<HeaderValue>,
+    headers: Option<HeaderMap>,
+}
+
+/// Extra information about the connected transport.
+///
+/// This can be used to inform recipients about things like if ALPN
+/// was used, or if connected to an HTTP proxy.
+#[derive(Debug)]
+pub struct Connected {
+    alpn: Alpn,
+    proxy: Box<ProxyIdentity>,
+    extra: Option<Extra>,
+    poisoned: PoisonPill,
+}
+
+// ===== impl PoisonPill =====
+
+impl fmt::Debug for PoisonPill {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        // print the address of the pill—this makes debugging issues much easier
+        write!(
+            f,
+            "PoisonPill@{:p} {{ poisoned: {} }}",
+            self.poisoned,
+            self.poisoned.load(Ordering::Relaxed)
+        )
+    }
+}
+
+impl PoisonPill {
+    /// Create a healthy (not poisoned) pill.
+    #[inline]
+    fn healthy() -> Self {
+        Self {
+            poisoned: Arc::new(AtomicBool::new(false)),
+        }
+    }
+
+    /// Poison this pill.
+    #[inline]
+    fn poison(&self) {
+        self.poisoned.store(true, Ordering::Relaxed)
+    }
+
+    /// Check if this pill is poisoned.
+    #[inline]
+    fn poisoned(&self) -> bool {
+        self.poisoned.load(Ordering::Relaxed)
+    }
+}
+
+// ===== impl Connected =====
+
+impl Connected {
+    /// Create new `Connected` type with empty metadata.
+    pub fn new() -> Connected {
+        Connected {
+            alpn: Alpn::None,
+            proxy: Box::new(ProxyIdentity::default()),
+            extra: None,
+            poisoned: PoisonPill::healthy(),
+        }
+    }
+
+    /// Set extra connection information to be set in the extensions of every `Response`.
+    pub fn extra<T: Clone + Send + Sync + Debug + 'static>(mut self, extra: T) -> Connected {
+        if let Some(prev) = self.extra {
+            self.extra = Some(Extra(Box::new(ExtraChain(prev.0, extra))));
+        } else {
+            self.extra = Some(Extra(Box::new(ExtraEnvelope(extra))));
+        }
+        self
+    }
+
+    /// Copies the extra connection information into an `Extensions` map.
+    pub fn set_extras(&self, extensions: &mut Extensions) {
+        if let Some(extra) = &self.extra {
+            extra.set(extensions);
+        }
+    }
+
+    /// Set that the proxy was used for this connected transport.
+    pub fn proxy(mut self, proxy: Intercept) -> Connected {
+        self.proxy.is_proxied = true;
+
+        if let Some(auth) = proxy.basic_auth() {
+            self.proxy.auth.replace(auth.clone());
+        }
+
+        if let Some(headers) = proxy.custom_headers() {
+            self.proxy.headers.replace(headers.clone());
+        }
+
+        self
+    }
+
+    /// Determines if the connected transport is to an HTTP proxy.
+    #[inline]
+    pub fn is_proxied(&self) -> bool {
+        self.proxy.is_proxied
+    }
+
+    /// Get the proxy identity information for the connected transport.
+    #[inline]
+    pub fn proxy_auth(&self) -> Option<&HeaderValue> {
+        self.proxy.auth.as_ref()
+    }
+
+    /// Get the custom proxy headers for the connected transport.
+    #[inline]
+    pub fn proxy_headers(&self) -> Option<&HeaderMap> {
+        self.proxy.headers.as_ref()
+    }
+
+    /// Set that the connected transport negotiated HTTP/2 as its next protocol.
+    #[inline]
+    pub fn negotiated_h2(mut self) -> Connected {
+        self.alpn = Alpn::H2;
+        self
+    }
+
+    /// Determines if the connected transport negotiated HTTP/2 as its next protocol.
+    #[inline]
+    pub fn is_negotiated_h2(&self) -> bool {
+        self.alpn == Alpn::H2
+    }
+
+    /// Determine if this connection is poisoned
+    #[inline]
+    pub fn poisoned(&self) -> bool {
+        self.poisoned.poisoned()
+    }
+
+    /// Poison this connection
+    ///
+    /// A poisoned connection will not be reused for subsequent requests by the pool
+    #[inline]
+    pub fn poison(&self) {
+        self.poisoned.poison();
+        debug!(
+            "connection was poisoned. this connection will not be reused for subsequent requests"
+        );
+    }
+
+    // Don't public expose that `Connected` is `Clone`, unsure if we want to
+    // keep that contract...
+    pub(crate) fn clone(&self) -> Connected {
+        Connected {
+            alpn: self.alpn,
+            proxy: self.proxy.clone(),
+            extra: self.extra.clone(),
+            poisoned: self.poisoned.clone(),
+        }
+    }
+}
+
+// ===== impl Extra =====
+
+impl Extra {
+    #[inline]
+    fn set(&self, res: &mut Extensions) {
+        self.0.set(res);
+    }
+}
+
+impl Clone for Extra {
+    fn clone(&self) -> Extra {
+        Extra(self.0.clone_box())
+    }
+}
+
+// ===== impl ExtraEnvelope =====
+
+impl<T> ExtraInner for ExtraEnvelope<T>
+where
+    T: Clone + Send + Sync + Debug + 'static,
+{
+    fn clone_box(&self) -> Box<dyn ExtraInner> {
+        Box::new(self.clone())
+    }
+
+    fn set(&self, res: &mut Extensions) {
+        res.insert(self.0.clone());
+    }
+}
+
+// ===== impl ExtraChain =====
+
+impl<T: Clone> Clone for ExtraChain<T> {
+    fn clone(&self) -> Self {
+        ExtraChain(self.0.clone_box(), self.1.clone())
+    }
+}
+
+impl<T> ExtraInner for ExtraChain<T>
+where
+    T: Clone + Send + Sync + Debug + 'static,
+{
+    fn clone_box(&self) -> Box<dyn ExtraInner> {
+        Box::new(self.clone())
+    }
+
+    fn set(&self, res: &mut Extensions) {
+        self.0.set(res);
+        res.insert(self.1.clone());
+    }
+}