wreq-rb 0.5.0 → 0.5.1

data/vendor/wreq/src/rt.rs

@@ -0,0 +1,208 @@
+//! Runtime components — executor and timer abstractions.
+//!
+//! This module provides [`Executor`] and [`Timer`], the two runtime primitives
+//! used by the HTTP client for spawning background tasks and driving timeouts.
+//!
+//! # Feature flags
+//!
+//! At least one of the following features must be enabled:
+//!
+//! - `tokio-rt` — uses [tokio] as the underlying runtime (default).
+//! - `compio-rt` — uses [compio] as the underlying runtime.
+//!
+//! When both are enabled, `tokio-rt` takes precedence for both [`Executor`]
+//! and [`Timer`].  When neither is enabled, [`Executor::default`] and
+//! [`Timer::default`] return empty placeholders that panic on use, so a
+//! runtime feature flag **must** be active in practice.
+//!
+//! [tokio]: https://docs.rs/tokio
+//! [compio]: https://docs.rs/compio
+
+use std::{
+    future::Future,
+    pin::Pin,
+    sync::Arc,
+    time::{Duration, Instant},
+};
+
+use wreq_proto::rt::{self, Sleep, Time};
+
+/// A heap-allocated, type-erased future that is [`Send`] and resolves to `()`.
+///
+/// This is the concrete future type passed to [`rt::Executor::execute`] by the
+/// client's background task machinery.  Callers do not need to construct this
+/// type directly; the [`rt::Executor<F>`] blanket implementation boxes and
+/// pins any qualifying `F` automatically.
+pub type BoxSendFuture = Pin<Box<dyn Future<Output = ()> + Send>>;
+
+/// A handle to an async task executor.
+///
+/// `Executor` is used by the HTTP client to spawn background tasks such as
+/// connection-pool cleanup and keep-alive management, without coupling the
+/// client to a specific async runtime.
+///
+/// # Default behavior
+///
+/// [`Executor::default`] picks the runtime-appropriate implementation based
+/// on the active feature flags:
+///
+/// | Feature flags active              | Executor          |
+/// |-----------------------------------|-------------------|
+/// | `tokio-rt` only                   | `TokioExecutor`   |
+/// | `compio-rt` only                  | `CompioExecutor`  |
+/// | both `tokio-rt` and `compio-rt`   | `TokioExecutor`   |
+/// | neither                           | empty (panics)    |
+#[derive(Clone)]
+pub struct Executor(Arc<dyn rt::Executor<BoxSendFuture> + Send + Sync>);
+
+// ===== impl Executor =====
+
+impl Executor {
+    /// Creates an [`Executor`] backed by a custom implementation.
+    ///
+    /// The value is wrapped in an [`Arc`] and type-erased, so the resulting
+    /// handle is cheap to clone and safe to share across threads.
+    #[inline]
+    pub fn new<E>(exec: E) -> Self
+    where
+        E: rt::Executor<BoxSendFuture> + Send + Sync + 'static,
+    {
+        Executor(Arc::new(exec))
+    }
+}
+
+impl<Fut> rt::Executor<Fut> for Executor
+where
+    Fut: Future<Output = ()> + Send + 'static,
+{
+    /// Spawns `fut` on the underlying executor.
+    ///
+    /// The future is boxed and pinned internally, so any `F` satisfying the
+    /// bounds can be passed without the caller needing to allocate first.
+    #[track_caller]
+    #[inline(always)]
+    fn execute(&self, fut: Fut) {
+        self.0.execute(Box::pin(fut))
+    }
+}
+
+impl Default for Executor {
+    /// Returns the runtime-appropriate default executor.
+    ///
+    /// See the [type-level documentation][Executor] for the feature-flag
+    /// selection table.
+    #[inline]
+    fn default() -> Self {
+        if_tokio_rt!(block: {
+            return Executor(Arc::new(wreq_rt::rt::tokio::TokioExecutor::new()))
+        });
+
+        if_compio_rt!(block: {
+            return Executor(Arc::new(wreq_rt::rt::compio::CompioExecutor::new()))
+        });
+
+        if_all_rt!(block: {
+            return Executor(Arc::new(wreq_rt::rt::tokio::TokioExecutor::new()))
+        });
+
+        if_no_rt!(block:{
+            panic!(
+                "no async runtime feature enabled; at least one of `tokio-rt` or `compio-rt` must be active"
+            );
+        });
+    }
+}
+
+// ===== Timer =====
+
+/// A handle to an async timer.
+///
+/// `Timer` is used by the HTTP client to drive request and connection timeouts,
+/// as well as the connection pool's idle-expiry loop.  It wraps an
+/// [`rt::Timer`] implementation in a cheap-to-clone, type-erased handle.
+///
+/// # Default behavior
+///
+/// [`Timer::default`] picks the runtime-appropriate implementation based on
+/// the active feature flags:
+///
+/// | Feature flags active              | Timer           |
+/// |-----------------------------------|-----------------|
+/// | `tokio-rt` only                   | `TokioTimer`    |
+/// | `compio-rt` only                  | `CompioTimer`   |
+/// | both `tokio-rt` and `compio-rt`   | `TokioTimer`    |
+/// | neither                           | empty (panics)  |
+#[derive(Clone)]
+pub struct Timer(Time);
+
+// ===== impl Timer =====
+
+impl Timer {
+    /// Creates a [`Timer`] backed by a custom implementation.
+    #[inline]
+    pub fn new<M>(timer: M) -> Self
+    where
+        M: rt::Timer + Send + Sync + 'static,
+    {
+        Timer(Time::Timer(Arc::new(timer)))
+    }
+
+    #[cfg(test)]
+    #[doc(hidden)]
+    pub fn empty() -> Self {
+        Timer(Time::Empty)
+    }
+
+    /// Returns `true` if no timer implementation has been configured.
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        matches!(self.0, Time::Empty)
+    }
+}
+
+impl Default for Timer {
+    #[inline]
+    fn default() -> Self {
+        if_tokio_rt!(block: {
+            return Timer(rt::Time::Timer(Arc::new(wreq_rt::rt::tokio::TokioTimer::new())))
+        });
+
+        if_compio_rt!(block: {
+            return Timer(rt::Time::Timer(Arc::new(wreq_rt::rt::compio::CompioTimer::new())))
+        });
+
+        if_all_rt!(block: {
+            return Timer(rt::Time::Timer(Arc::new(wreq_rt::rt::tokio::TokioTimer::new())))
+        });
+
+        if_no_rt!(block: {
+            Timer(Time::Empty)
+        })
+    }
+}
+
+impl rt::Timer for Timer {
+    /// Returns a future that resolves after `duration`.
+    #[inline]
+    fn sleep(&self, duration: Duration) -> Pin<Box<dyn Sleep>> {
+        self.0.sleep(duration)
+    }
+
+    /// Returns the current time according to the underlying runtime.
+    #[inline]
+    fn now(&self) -> Instant {
+        self.0.now()
+    }
+
+    /// Returns a future that resolves at `deadline`.
+    #[inline]
+    fn sleep_until(&self, deadline: Instant) -> Pin<Box<dyn Sleep>> {
+        self.0.sleep_until(deadline)
+    }
+
+    /// Resets an in-flight sleep future to fire at `new_deadline` instead.
+    #[inline]
+    fn reset(&self, sleep: &mut Pin<Box<dyn Sleep>>, new_deadline: Instant) {
+        self.0.reset(sleep, new_deadline)
+    }
+}

data/vendor/wreq/src/sync.rs

@@ -5,125 +5,124 @@
 //!
 //! This is useful in high-availability systems where panic recovery is done externally,
 //! or poisoning is not meaningful in context.
-
-use std::{
-    ops::{Deref, DerefMut},
-    sync,
-};
-
-/// A [`Mutex`] that never poisons and has the same interface as [`std::sync::Mutex`].
-pub struct Mutex<T: ?Sized>(sync::Mutex<T>);
-
-impl<T> Mutex<T> {
-    /// Like [`std::sync::Mutex::new`].
-    #[inline]
-    pub fn new(t: T) -> Mutex<T> {
-        Mutex(sync::Mutex::new(t))
-    }
-}
-
-impl<T: ?Sized> Mutex<T> {
-    /// Like [`std::sync::Mutex::lock`].
-    #[inline]
-    pub fn lock(&self) -> MutexGuard<'_, T> {
-        MutexGuard(self.0.lock().unwrap_or_else(|e| e.into_inner()))
+//!
+//! ## Implementation
+//! - When the `parking_lot` feature is enabled, it uses [`parking_lot::Mutex`] and
+//!   [`parking_lot::RwLock`].
+//! - Otherwise, it wraps [`std::sync::Mutex`] and [`std::sync::RwLock`], using `.unwrap_or_else(|e|
+//!   e.into_inner())` to silently recover from poisoning.
+
+#[cfg(feature = "parking_lot")]
+pub use parking_lot::*;
+
+#[cfg(not(feature = "parking_lot"))]
+pub use self::std::*;
+
+#[cfg(not(feature = "parking_lot"))]
+mod std {
+    use std::{
+        ops::{Deref, DerefMut},
+        sync,
+    };
+
+    /// A [`Mutex`] that never poisons and has the same interface as [`std::sync::Mutex`].
+    ///
+    /// See [`crate::sync`] for more details.
+    #[derive(Debug)]
+    pub struct Mutex<T: ?Sized>(sync::Mutex<T>);
+
+    impl<T> Mutex<T> {
+        /// Like [`std::sync::Mutex::new`].
+        #[inline]
+        pub fn new(t: T) -> Mutex<T> {
+            Mutex(sync::Mutex::new(t))
+        }
     }
-}
 
-impl<T> Default for Mutex<T>
-where
-    T: Default,
-{
-    #[inline]
-    fn default() -> Self {
-        Mutex::new(T::default())
+    impl<T: ?Sized> Mutex<T> {
+        /// Like [`std::sync::Mutex::lock`].
+        #[inline]
+        pub fn lock<'a>(&'a self) -> MutexGuard<'a, T> {
+            MutexGuard(self.0.lock().unwrap_or_else(|e| e.into_inner()))
+        }
     }
-}
 
-/// Like [`std::sync::MutexGuard`].
-#[must_use]
-pub struct MutexGuard<'a, T: ?Sized + 'a>(sync::MutexGuard<'a, T>);
+    /// Like [`std::sync::MutexGuard`].
+    #[must_use]
+    pub struct MutexGuard<'a, T: ?Sized + 'a>(sync::MutexGuard<'a, T>);
 
-impl<T: ?Sized> Deref for MutexGuard<'_, T> {
-    type Target = T;
+    impl<'a, T: ?Sized> Deref for MutexGuard<'a, T> {
+        type Target = T;
 
-    #[inline]
-    fn deref(&self) -> &T {
-        self.0.deref()
+        #[inline]
+        fn deref(&self) -> &T {
+            self.0.deref()
+        }
     }
-}
 
-impl<T: ?Sized> DerefMut for MutexGuard<'_, T> {
-    #[inline]
-    fn deref_mut(&mut self) -> &mut T {
-        self.0.deref_mut()
+    impl<'a, T: ?Sized> DerefMut for MutexGuard<'a, T> {
+        #[inline]
+        fn deref_mut(&mut self) -> &mut T {
+            self.0.deref_mut()
+        }
     }
-}
 
-/// A [`RwLock`] that never poisons and has the same interface as [`std::sync::RwLock`].
-pub struct RwLock<T: ?Sized>(sync::RwLock<T>);
-
-impl<T> RwLock<T> {
-    /// Like [`std::sync::RwLock::new`].
-    #[inline]
-    pub fn new(t: T) -> RwLock<T> {
-        RwLock(sync::RwLock::new(t))
-    }
-}
-
-impl<T: ?Sized> RwLock<T> {
-    /// Like [`std::sync::RwLock::read`].
-    #[inline]
-    pub fn read(&self) -> RwLockReadGuard<'_, T> {
-        RwLockReadGuard(self.0.read().unwrap_or_else(|e| e.into_inner()))
-    }
-
-    /// Like [`std::sync::RwLock::write`].
-    #[inline]
-    pub fn write(&self) -> RwLockWriteGuard<'_, T> {
-        RwLockWriteGuard(self.0.write().unwrap_or_else(|e| e.into_inner()))
+    impl<T: Default> Default for Mutex<T> {
+        fn default() -> Self {
+            Mutex(Default::default())
+        }
     }
-}
 
-impl<T> Default for RwLock<T>
-where
-    T: Default,
-{
-    #[inline]
-    fn default() -> Self {
-        RwLock::new(T::default())
+    /// A [`RwLock`] that never poisons and has the same interface as [`std::sync::RwLock`].
+    ///
+    /// See [`crate::sync`] for more details.
+    #[derive(Debug, Default)]
+    pub struct RwLock<T: ?Sized>(sync::RwLock<T>);
+
+    impl<T: ?Sized> RwLock<T> {
+        /// Like [`std::sync::RwLock::read`].
+        #[inline]
+        pub fn read<'a>(&'a self) -> RwLockReadGuard<'a, T> {
+            RwLockReadGuard(self.0.read().unwrap_or_else(|e| e.into_inner()))
+        }
+
+        /// Like [`std::sync::RwLock::write`].
+        #[inline]
+        pub fn write<'a>(&'a self) -> RwLockWriteGuard<'a, T> {
+            RwLockWriteGuard(self.0.write().unwrap_or_else(|e| e.into_inner()))
+        }
     }
-}
 
-/// Like [`std::sync::RwLockReadGuard`].
-#[must_use]
-pub struct RwLockReadGuard<'a, T: ?Sized + 'a>(sync::RwLockReadGuard<'a, T>);
+    /// Like [`std::sync::RwLockReadGuard`].
+    #[must_use]
+    pub struct RwLockReadGuard<'a, T: ?Sized + 'a>(sync::RwLockReadGuard<'a, T>);
 
-impl<T: ?Sized> Deref for RwLockReadGuard<'_, T> {
-    type Target = T;
+    impl<'a, T: ?Sized> Deref for RwLockReadGuard<'a, T> {
+        type Target = T;
 
-    #[inline]
-    fn deref(&self) -> &T {
-        self.0.deref()
+        #[inline]
+        fn deref(&self) -> &T {
+            self.0.deref()
+        }
     }
-}
 
-/// Like [`std::sync::RwLockWriteGuard`].
-#[must_use]
-pub struct RwLockWriteGuard<'a, T: ?Sized + 'a>(sync::RwLockWriteGuard<'a, T>);
+    /// Like [`std::sync::RwLockWriteGuard`].
+    #[must_use]
+    pub struct RwLockWriteGuard<'a, T: ?Sized + 'a>(sync::RwLockWriteGuard<'a, T>);
 
-impl<T: ?Sized> Deref for RwLockWriteGuard<'_, T> {
-    type Target = T;
+    impl<'a, T: ?Sized> Deref for RwLockWriteGuard<'a, T> {
+        type Target = T;
 
-    #[inline]
-    fn deref(&self) -> &T {
-        self.0.deref()
+        #[inline]
+        fn deref(&self) -> &T {
+            self.0.deref()
+        }
     }
-}
 
-impl<T: ?Sized> DerefMut for RwLockWriteGuard<'_, T> {
-    #[inline]
-    fn deref_mut(&mut self) -> &mut T {
-        self.0.deref_mut()
+    impl<'a, T: ?Sized> DerefMut for RwLockWriteGuard<'a, T> {
+        #[inline]
+        fn deref_mut(&mut self) -> &mut T {
+            self.0.deref_mut()
+        }
     }
 }

data/vendor/wreq/src/tls/compress.rs

@@ -0,0 +1,124 @@
+//! TLS certificate compression [RFC 8879](https://datatracker.ietf.org/doc/html/rfc8879).
+//!
+//! Reduces handshake latency by compressing certificate chains.
+//! Supports Zlib, Brotli, and Zstd algorithms to minimize bytes-on-wire
+//! and fit within the initial congestion window.
+
+use std::{fmt::Debug, io};
+
+use btls::{
+    error::ErrorStack,
+    ssl::{self, SslConnectorBuilder},
+};
+use btls_sys as ffi;
+// Re-export the `CertificateCompressionAlgorithm` enum for users of this module.
+pub use ssl::CertificateCompressionAlgorithm;
+
+/// Certificate compression or decompression.
+///
+/// Wraps a function pointer or closure that processes certificate data.
+#[allow(clippy::type_complexity)]
+pub enum Codec {
+    /// Function pointer.
+    Pointer(fn(&[u8], &mut dyn io::Write) -> io::Result<()>),
+    /// Closure or function object.
+    Dynamic(Box<dyn Fn(&[u8], &mut dyn io::Write) -> io::Result<()> + Send + Sync>),
+}
+
+/// Trait for TLS certificate compression implementations.
+///
+/// Provides methods for compressing and decompressing certificate data,
+/// as well as identifying the algorithm in use.
+///
+/// See [RFC 8879, §3](https://www.rfc-editor.org/rfc/rfc8879.html#name-compression-algorithms)
+/// for the list of IANA-assigned compression algorithm identifiers.
+pub trait CertificateCompressor: Debug + Sync + Send + 'static {
+    /// Returns the [`Codec`] used to compress certificate chains for this algorithm.
+    fn compress(&self) -> Codec;
+
+    /// Returns the [`Codec`] used to decompress certificate chains for this algorithm.
+    fn decompress(&self) -> Codec;
+
+    /// Returns the IANA-assigned identifier of the compression algorithm.
+    fn algorithm(&self) -> CertificateCompressionAlgorithm;
+}
+
+struct Compressor<const ALGORITHM: i32> {
+    compress: Codec,
+    decompress: Codec,
+}
+
+// ===== impl Codec =====
+
+impl Codec {
+    #[inline]
+    fn call(&self, input: &[u8], output: &mut dyn io::Write) -> io::Result<()> {
+        match self {
+            Codec::Pointer(func) => func(input, output),
+            Codec::Dynamic(closure) => closure(input, output),
+        }
+    }
+}
+
+// ===== impl Compressor =====
+
+impl<const ALGORITHM: i32> ssl::CertificateCompressor for Compressor<ALGORITHM> {
+    const ALGORITHM: CertificateCompressionAlgorithm = match ALGORITHM {
+        ffi::TLSEXT_cert_compression_zlib => CertificateCompressionAlgorithm::ZLIB,
+        ffi::TLSEXT_cert_compression_brotli => CertificateCompressionAlgorithm::BROTLI,
+        ffi::TLSEXT_cert_compression_zstd => CertificateCompressionAlgorithm::ZSTD,
+        _ => unreachable!(),
+    };
+    const CAN_COMPRESS: bool = true;
+    const CAN_DECOMPRESS: bool = true;
+
+    #[inline]
+    fn compress<W>(&self, input: &[u8], output: &mut W) -> io::Result<()>
+    where
+        W: io::Write,
+    {
+        self.compress.call(input, output)
+    }
+
+    #[inline]
+    fn decompress<W>(&self, input: &[u8], output: &mut W) -> io::Result<()>
+    where
+        W: io::Write,
+    {
+        self.decompress.call(input, output)
+    }
+}
+
+/// Register a certificate compressor with the given [`SslConnectorBuilder`].
+pub(super) fn register(
+    compressor: &dyn CertificateCompressor,
+    builder: &mut SslConnectorBuilder,
+) -> Result<(), ErrorStack> {
+    match compressor.algorithm() {
+        CertificateCompressionAlgorithm::ZLIB => {
+            builder.add_certificate_compression_algorithm(Compressor::<
+                { ffi::TLSEXT_cert_compression_zlib },
+            > {
+                compress: compressor.compress(),
+                decompress: compressor.decompress(),
+            })
+        }
+        CertificateCompressionAlgorithm::BROTLI => {
+            builder.add_certificate_compression_algorithm(Compressor::<
+                { ffi::TLSEXT_cert_compression_brotli },
+            > {
+                compress: compressor.compress(),
+                decompress: compressor.decompress(),
+            })
+        }
+        CertificateCompressionAlgorithm::ZSTD => {
+            builder.add_certificate_compression_algorithm(Compressor::<
+                { ffi::TLSEXT_cert_compression_zstd },
+            > {
+                compress: compressor.compress(),
+                decompress: compressor.decompress(),
+            })
+        }
+        _ => unreachable!(),
+    }
+}