wreq-rb 0.5.0 → 0.5.1

data/patches/0002-add-cancel-connections.patch

@@ -1,181 +0,0 @@
-diff --git a/src/client/http.rs b/src/client/http.rs
-index 462c77d0..6231e700 100644
---- a/src/client/http.rs
-+++ b/src/client/http.rs
-@@ -171,6 +171,7 @@ type ClientRef = Either<ClientService, BoxedClientService>;
- #[derive(Clone)]
- pub struct Client {
-     inner: Arc<ClientRef>,
-+    cancel_connections: Arc<dyn Fn() + Send + Sync>,
- }
- 
- /// A [`ClientBuilder`] can be used to create a [`Client`] with custom configuration.
-@@ -439,6 +440,14 @@ impl Client {
-         let fut = Oneshot::new(self.inner.as_ref().clone(), req);
-         Pending::request(uri, fut)
-     }
-+
-+    /// Cancel all background connection tasks immediately.
-+    ///
-+    /// This force-drops every tracked H1/H2 connection task, causing the
-+    /// underlying TCP socket to close abruptly.
-+    pub fn cancel_connections(&self) {
-+        (self.cancel_connections)()
-+    }
- }
- 
- impl tower::Service<Request> for Client {
-@@ -495,7 +504,7 @@ impl ClientBuilder {
-         }
- 
-         // Create base client service
--        let service = {
-+        let (service, cancel_connections) = {
-             let (tls_options, http1_options, http2_options) = config.transport_options.into();
- 
-             let resolver = {
-@@ -555,7 +564,7 @@ impl ClientBuilder {
-                 .build(config.connector_layers)?;
- 
-             // Build client
--            HttpClient::builder(TokioExecutor::new())
-+            let http_client = HttpClient::builder(TokioExecutor::new())
-                 .http1_options(http1_options)
-                 .http2_options(http2_options)
-                 .http2_only(matches!(config.http_version_pref, HttpVersionPref::Http2))
-@@ -564,8 +573,10 @@ impl ClientBuilder {
-                 .pool_idle_timeout(config.pool_idle_timeout)
-                 .pool_max_idle_per_host(config.pool_max_idle_per_host)
-                 .pool_max_size(config.pool_max_size)
--                .build(connector)
--                .map_err(Into::into as _)
-+                .build(connector);
-+            // Capture abort fn before tower layers consume the client
-+            let cancel_connections = http_client.cancel_connections_fn();
-+            (http_client.map_err(Into::into as _), cancel_connections)
-         };
- 
-         // Configured client service with layers
-@@ -633,6 +644,7 @@ impl ClientBuilder {
- 
-         Ok(Client {
-             inner: Arc::new(client),
-+            cancel_connections,
-         })
-     }
- 
-diff --git a/src/client/http/client.rs b/src/client/http/client.rs
-index a29c52dd..7f6ce68f 100644
---- a/src/client/http/client.rs
-+++ b/src/client/http/client.rs
-@@ -10,7 +10,7 @@ use std::{
-     future::Future,
-     num::NonZeroU32,
-     pin::Pin,
--    sync::Arc,
-+    sync::{Arc, Mutex},
-     task::{self, Poll},
-     time::Duration,
- };
-@@ -119,6 +119,7 @@ pub struct HttpClient<C, B> {
-     h1_builder: conn::http1::Builder,
-     h2_builder: conn::http2::Builder<Exec>,
-     pool: pool::Pool<PoolClient<B>, ConnectIdentity>,
-+    conn_abort_handles: Arc<Mutex<Vec<tokio::task::AbortHandle>>>,
- }
- 
- #[derive(Clone, Copy)]
-@@ -452,8 +453,8 @@ where
-     + Send
-     + Unpin
-     + 'static {
--        let executor = self.exec.clone();
-         let pool = self.pool.clone();
-+        let conn_abort_handles = self.conn_abort_handles.clone();
- 
-         let h1_builder = self.h1_builder.clone();
-         let h2_builder = self.h2_builder.clone();
-@@ -513,10 +514,17 @@ where
-                                     trace!(
-                                         "http2 handshake complete, spawning background dispatcher task"
-                                     );
--                                    executor.execute(
--                                        conn.map_err(|_e| debug!("client connection error: {}", _e))
--                                            .map(|_| ()),
--                                    );
-+                                    let h2_conn_future = conn
-+                                        .map_err(|_e| debug!("client connection error: {}", _e))
-+                                        .map(|_| ());
-+                                    let abort_handle = tokio::spawn(h2_conn_future).abort_handle();
-+                                    {
-+                                        let mut handles = conn_abort_handles.lock().unwrap_or_else(|e| e.into_inner());
-+                                        if handles.len() >= 64 {
-+                                            handles.retain(|h| !h.is_finished());
-+                                        }
-+                                        handles.push(abort_handle);
-+                                    }
- 
-                                     // Wait for 'conn' to ready up before we
-                                     // declare this tx as usable
-@@ -544,8 +552,7 @@ where
-                                     // Spawn the connection task in the background using the executor.
-                                     // The task manages the HTTP/1.1 connection, including upgrades (e.g., WebSocket).
-                                     // Errors are sent via err_tx to ensure they can be checked if the sender (tx) fails.
--                                    executor.execute(
--                                        conn.with_upgrades()
-+                                    let h1_conn_future = conn.with_upgrades()
-                                                 .map_err(|e| {
-                                                 // Log the connection error at debug level for diagnostic purposes.
-                                                 debug!("client connection error: {:?}", e);
-@@ -555,8 +562,15 @@ where
-                                                 // (e.g., if the receiver is dropped, which is handled later).
-                                                 let _ = err_tx.send(e);
-                                             })
--                                            .map(|_| ()),
--                                    );
-+                                            .map(|_| ());
-+                                    let abort_handle = tokio::spawn(h1_conn_future).abort_handle();
-+                                    {
-+                                        let mut handles = conn_abort_handles.lock().unwrap_or_else(|e| e.into_inner());
-+                                        if handles.len() >= 64 {
-+                                            handles.retain(|h| !h.is_finished());
-+                                        }
-+                                        handles.push(abort_handle);
-+                                    }
- 
-                                     // Log that the client is waiting for the connection to be ready.
-                                     // Readiness indicates the sender (tx) can accept a request without blocking. More actions
-@@ -682,10 +696,25 @@ impl<C: Clone, B> Clone for HttpClient<C, B> {
-             h2_builder: self.h2_builder.clone(),
-             connector: self.connector.clone(),
-             pool: self.pool.clone(),
-+            conn_abort_handles: self.conn_abort_handles.clone(),
-         }
-     }
- }
- 
-+impl<C, B> HttpClient<C, B> {
-+    /// Returns a closure that cancels all tracked connection tasks when called.
-+    /// Each call drains the handle list and aborts every stored task.
-+    pub fn cancel_connections_fn(&self) -> Arc<dyn Fn() + Send + Sync + 'static> {
-+        let handles = self.conn_abort_handles.clone();
-+        Arc::new(move || {
-+            let mut guard = handles.lock().unwrap_or_else(|e| e.into_inner());
-+            for handle in guard.drain(..) {
-+                handle.abort();
-+            }
-+        })
-+    }
-+}
-+
- /// A pooled HTTP connection that can send requests
- struct PoolClient<B> {
-     conn_info: Connected,
-@@ -998,6 +1027,7 @@ impl Builder {
-             h2_builder: self.h2_builder,
-             connector,
-             pool: pool::Pool::new(self.pool_config, exec, timer),
-+            conn_abort_handles: Arc::new(Mutex::new(Vec::new())),
-         }
-     }
- }

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

@@ -1,231 +0,0 @@
-use std::{
-    io::{self, IoSlice},
-    pin::Pin,
-    task::{Context, Poll},
-};
-
-use pin_project_lite::pin_project;
-#[cfg(unix)]
-use tokio::net::UnixStream;
-use tokio::{
-    io::{AsyncRead, AsyncWrite, ReadBuf},
-    net::TcpStream,
-};
-use tokio_boring2::SslStream;
-
-use super::{AsyncConnWithInfo, Connected, Connection, TlsInfoFactory};
-use crate::{
-    proxy::matcher::Intercept,
-    tls::{TlsInfo, conn::MaybeHttpsStream},
-};
-
-pin_project! {
-    /// Note: the `is_proxy` member means *is plain text HTTP proxy*.
-    /// This tells core whether the URI should be written in
-    /// * origin-form (`GET /just/a/path HTTP/1.1`), when `is_proxy == false`, or
-    /// * absolute-form (`GET http://foo.bar/and/a/path HTTP/1.1`), otherwise.
-    pub struct Conn {
-        #[pin]
-        pub(super) inner: Box<dyn AsyncConnWithInfo>,
-        pub(super) tls_info: bool,
-        pub(super) proxy: Option<Intercept>,
-    }
-}
-
-pin_project! {
-    /// A wrapper around `SslStream` that adapts it for use as a generic async connection.
-    ///
-    /// This type enables unified handling of plain TCP and TLS-encrypted streams by providing
-    /// implementations of `Connection`, `Read`, `Write`, and `TlsInfoFactory`.
-    /// It is mainly used internally to abstract over different connection types.
-    pub struct TlsConn<T> {
-        #[pin]
-        inner: SslStream<T>,
-    }
-}
-
-// ==== impl Conn ====
-
-impl Connection for Conn {
-    fn connected(&self) -> Connected {
-        let mut connected = self.inner.connected();
-
-        if let Some(proxy) = &self.proxy {
-            connected = connected.proxy(proxy.clone());
-        }
-
-        if self.tls_info {
-            if let Some(tls_info) = self.inner.tls_info() {
-                connected.extra(tls_info)
-            } else {
-                connected
-            }
-        } else {
-            connected
-        }
-    }
-}
-
-impl AsyncRead for Conn {
-    #[inline]
-    fn poll_read(
-        self: Pin<&mut Self>,
-        cx: &mut Context,
-        buf: &mut ReadBuf<'_>,
-    ) -> Poll<io::Result<()>> {
-        AsyncRead::poll_read(self.project().inner, cx, buf)
-    }
-}
-
-impl AsyncWrite for Conn {
-    #[inline]
-    fn poll_write(
-        self: Pin<&mut Self>,
-        cx: &mut Context,
-        buf: &[u8],
-    ) -> Poll<Result<usize, io::Error>> {
-        AsyncWrite::poll_write(self.project().inner, cx, buf)
-    }
-
-    #[inline]
-    fn poll_write_vectored(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        bufs: &[IoSlice<'_>],
-    ) -> Poll<Result<usize, io::Error>> {
-        AsyncWrite::poll_write_vectored(self.project().inner, cx, bufs)
-    }
-
-    #[inline]
-    fn is_write_vectored(&self) -> bool {
-        self.inner.is_write_vectored()
-    }
-
-    #[inline]
-    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), io::Error>> {
-        AsyncWrite::poll_flush(self.project().inner, cx)
-    }
-
-    #[inline]
-    fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), io::Error>> {
-        AsyncWrite::poll_shutdown(self.project().inner, cx)
-    }
-}
-
-// ==== impl TlsConn ====
-
-impl<T> TlsConn<T>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-{
-    /// Creates a new `TlsConn` wrapping the provided `SslStream`.
-    #[inline(always)]
-    pub fn new(inner: SslStream<T>) -> Self {
-        Self { inner }
-    }
-}
-
-// ===== impl TcpStream =====
-
-impl Connection for TlsConn<TcpStream> {
-    fn connected(&self) -> Connected {
-        let connected = self.inner.get_ref().connected();
-        if self.inner.ssl().selected_alpn_protocol() == Some(b"h2") {
-            connected.negotiated_h2()
-        } else {
-            connected
-        }
-    }
-}
-
-impl Connection for TlsConn<MaybeHttpsStream<TcpStream>> {
-    fn connected(&self) -> Connected {
-        let connected = self.inner.get_ref().connected();
-        if self.inner.ssl().selected_alpn_protocol() == Some(b"h2") {
-            connected.negotiated_h2()
-        } else {
-            connected
-        }
-    }
-}
-
-// ===== impl UnixStream =====
-
-#[cfg(unix)]
-impl Connection for TlsConn<UnixStream> {
-    fn connected(&self) -> Connected {
-        let connected = self.inner.get_ref().connected();
-        if self.inner.ssl().selected_alpn_protocol() == Some(b"h2") {
-            connected.negotiated_h2()
-        } else {
-            connected
-        }
-    }
-}
-
-#[cfg(unix)]
-impl Connection for TlsConn<MaybeHttpsStream<UnixStream>> {
-    fn connected(&self) -> Connected {
-        let connected = self.inner.get_ref().connected();
-        if self.inner.ssl().selected_alpn_protocol() == Some(b"h2") {
-            connected.negotiated_h2()
-        } else {
-            connected
-        }
-    }
-}
-
-impl<T: AsyncRead + AsyncWrite + Unpin> AsyncRead for TlsConn<T> {
-    #[inline]
-    fn poll_read(
-        self: Pin<&mut Self>,
-        cx: &mut Context,
-        buf: &mut ReadBuf<'_>,
-    ) -> Poll<tokio::io::Result<()>> {
-        AsyncRead::poll_read(self.project().inner, cx, buf)
-    }
-}
-
-impl<T: AsyncRead + AsyncWrite + Unpin> AsyncWrite for TlsConn<T> {
-    #[inline]
-    fn poll_write(
-        self: Pin<&mut Self>,
-        cx: &mut Context,
-        buf: &[u8],
-    ) -> Poll<Result<usize, tokio::io::Error>> {
-        AsyncWrite::poll_write(self.project().inner, cx, buf)
-    }
-
-    #[inline]
-    fn poll_write_vectored(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        bufs: &[IoSlice<'_>],
-    ) -> Poll<Result<usize, io::Error>> {
-        AsyncWrite::poll_write_vectored(self.project().inner, cx, bufs)
-    }
-
-    #[inline]
-    fn is_write_vectored(&self) -> bool {
-        self.inner.is_write_vectored()
-    }
-
-    #[inline]
-    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), tokio::io::Error>> {
-        AsyncWrite::poll_flush(self.project().inner, cx)
-    }
-
-    #[inline]
-    fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), tokio::io::Error>> {
-        AsyncWrite::poll_shutdown(self.project().inner, cx)
-    }
-}
-
-impl<T> TlsInfoFactory for TlsConn<T>
-where
-    SslStream<T>: TlsInfoFactory,
-{
-    fn tls_info(&self) -> Option<TlsInfo> {
-        self.inner.tls_info()
-    }
-}