wreq-rb 0.5.1 → 0.6.1

data/vendor/wreq/bench/support.rs

@@ -1,5 +1,6 @@
 pub mod bench;
 pub mod client;
+pub mod rt;
 pub mod server;
 
 use std::fmt;
@@ -39,18 +40,3 @@ impl fmt::Display for Tls {
         f.write_str(value)
     }
 }
-
-pub fn current_thread_runtime() -> tokio::runtime::Runtime {
-    tokio::runtime::Builder::new_current_thread()
-        .enable_all()
-        .build()
-        .expect("Failed to build current-thread runtime")
-}
-
-pub fn multi_thread_runtime() -> tokio::runtime::Runtime {
-    tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(4)
-        .enable_all()
-        .build()
-        .expect("Failed to build multi-thread runtime")
-}

data/vendor/wreq/examples/cert_store.rs

@@ -56,21 +56,21 @@ async fn main() -> wreq::Result<()> {
 
     // Use the API you're already familiar with
     let resp = client.get("https://self-signed.badssl.com/").send().await?;
-    if let Some(tls_info) = resp.extensions().get::<TlsInfo>() {
-        if let Some(peer_cert_der) = tls_info.peer_certificate() {
-            // Create self-signed certificate Store
-            let self_signed_store = CertStore::from_der_certs(&[peer_cert_der])?;
+    if let Some(tls_info) = resp.extensions().get::<TlsInfo>()
+        && let Some(peer_cert_der) = tls_info.peer_certificate()
+    {
+        // Create self-signed certificate Store
+        let self_signed_store = CertStore::from_der_certs([peer_cert_der])?;
 
-            // Create a client with self-signed certificate store
-            let client = Client::builder()
-                .tls_cert_store(self_signed_store)
-                .connect_timeout(Duration::from_secs(10))
-                .build()?;
+        // Create a client with self-signed certificate store
+        let client = Client::builder()
+            .tls_cert_store(self_signed_store)
+            .connect_timeout(Duration::from_secs(10))
+            .build()?;
 
-            // Use the API you're already familiar with
-            let resp = client.get("https://self-signed.badssl.com/").send().await?;
-            println!("{}", resp.text().await?);
-        }
+        // Use the API you're already familiar with
+        let resp = client.get("https://self-signed.badssl.com/").send().await?;
+        println!("{}", resp.text().await?);
     }
 
     Ok(())

data/vendor/wreq/examples/request_with_emulate.rs

@@ -105,7 +105,7 @@ async fn main() -> wreq::Result<()> {
         .build(Default::default());
 
     // Use the API you're already familiar with
-    let resp = wreq::get("https://tls.peet.ws/api/all")
+    let resp = wreq::get("https://pingly.us.kg/api/all")
         .emulation(emulation)
         .send()
         .await?;

data/vendor/wreq/examples/tcp_linger.rs

@@ -0,0 +1,22 @@
+use std::time::Duration;
+
+use wreq::Client;
+
+#[tokio::main]
+async fn main() -> wreq::Result<()> {
+    // Reset connections on close rather than closing them gracefully.
+    let client = Client::builder().tcp_linger(Duration::ZERO).build()?;
+
+    let resp = client.get("https://tls.peet.ws/api/all").send().await?;
+    println!("{}", resp.text().await?);
+
+    // Non-zero duration waits for unsent data to be flushed.
+    let client = Client::builder()
+        .tcp_linger(Duration::from_secs(5))
+        .build()?;
+
+    let resp = client.get("https://tls.peet.ws/api/all").send().await?;
+    println!("{}", resp.text().await?);
+
+    Ok(())
+}

data/vendor/wreq/src/client/layer/client/pool.rs

@@ -156,20 +156,20 @@ impl<T: Poolable, K: Key> Pool<T, K> {
     /// Ensure that there is only ever 1 connecting task for HTTP/2
     /// connections. This does nothing for HTTP/1.
     pub fn connecting(&self, key: K, ver: Ver) -> Option<Connecting<T, K>> {
-        if ver == Ver::Http2 {
-            if let Some(ref enabled) = self.inner {
-                let mut inner = enabled.lock();
-                return if inner.connecting.insert(key.clone()) {
-                    let connecting = Connecting {
-                        key,
-                        pool: WeakOpt::downgrade(enabled),
-                    };
-                    Some(connecting)
-                } else {
-                    trace!("HTTP/2 connecting already in progress for {:?}", key);
-                    None
+        if ver == Ver::Http2
+            && let Some(ref enabled) = self.inner
+        {
+            let mut inner = enabled.lock();
+            return if inner.connecting.insert(key.clone()) {
+                let connecting = Connecting {
+                    key,
+                    pool: WeakOpt::downgrade(enabled),
                 };
-            }
+                Some(connecting)
+            } else {
+                trace!("HTTP/2 connecting already in progress for {:?}", key);
+                None
+            };
         }
 
         // else
@@ -233,10 +233,10 @@ impl<T: Poolable, K: Key> Pool<T, K> {
         // unique or shared. So, the hack is to just assume Ver::Http2 means
         // shared... :(
         let mut pool_ref = WeakOpt::none();
-        if !value.can_share() {
-            if let Some(ref enabled) = self.inner {
-                pool_ref = WeakOpt::downgrade(enabled);
-            }
+        if !value.can_share()
+            && let Some(ref enabled) = self.inner
+        {
+            pool_ref = WeakOpt::downgrade(enabled);
         }
 
         Pooled {

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

@@ -232,6 +232,7 @@ where
         }
     }
 
+    #[allow(clippy::result_large_err)]
     async fn try_send_request(
         &self,
         mut req: Request<B>,
@@ -751,6 +752,7 @@ impl<B> PoolClient<B> {
 
 impl<B: Body + 'static> PoolClient<B> {
     #[inline]
+    #[allow(clippy::result_large_err)]
     fn try_send_request(
         &mut self,
         req: Request<B>,

data/vendor/wreq/src/client/layer/decoder.rs

@@ -2,7 +2,10 @@
 
 use std::task::{Context, Poll};
 
-use http::{Request, Response};
+use http::{
+    HeaderValue, Request, Response,
+    header::{ACCEPT_ENCODING, RANGE},
+};
 use http_body::Body;
 use tower::{Layer, Service};
 use tower_http::decompression::{self, DecompressionBody, ResponseFuture};
@@ -26,15 +29,26 @@ pub(crate) struct AcceptEncoding {
     pub(crate) deflate: bool,
 }
 
-/// Layer that adds response body decompression to a service.
+/// Builds response decompression middleware for a client service.
+///
+/// `DecompressionLayer` stores the client's default [`AcceptEncoding`] configuration
+/// and applies it when constructing a [`Decompression`] service.
 #[derive(Clone)]
 pub struct DecompressionLayer {
     accept: AcceptEncoding,
 }
 
-/// Service that decompresses response bodies based on the [`AcceptEncoding`] configuration.
+/// Negotiates response encodings and transparently decodes response bodies.
+///
+/// Before forwarding a request, `Decompression` applies request-specific
+/// [`AcceptEncoding`] settings and keeps range requests on the identity representation.
+/// The wrapped `tower-http` service then advertises enabled encodings and decodes matching
+/// responses.
 #[derive(Clone)]
-pub struct Decompression<S>(Option<decompression::Decompression<S>>);
+pub struct Decompression<S> {
+    decoder: Option<decompression::Decompression<S>>,
+    enabled: bool,
+}
 
 // ===== AcceptEncoding =====
 
@@ -53,6 +67,32 @@ impl Default for AcceptEncoding {
     }
 }
 
+impl AcceptEncoding {
+    fn is_enabled(&self) -> bool {
+        #[cfg(feature = "gzip")]
+        if self.gzip {
+            return true;
+        }
+
+        #[cfg(feature = "deflate")]
+        if self.deflate {
+            return true;
+        }
+
+        #[cfg(feature = "brotli")]
+        if self.brotli {
+            return true;
+        }
+
+        #[cfg(feature = "zstd")]
+        if self.zstd {
+            return true;
+        }
+
+        false
+    }
+}
+
 impl_request_config_value!(AcceptEncoding);
 
 // ===== impl DecompressionLayer =====
@@ -75,10 +115,10 @@ impl<S> Layer<S> for DecompressionLayer {
             .no_deflate()
             .no_gzip()
             .no_zstd();
-        Decompression(Some(Decompression::<S>::accept_in_place(
-            decoder,
-            &self.accept,
-        )))
+        Decompression {
+            decoder: Some(Decompression::<S>::accept_in_place(decoder, &self.accept)),
+            enabled: self.accept.is_enabled(),
+        }
     }
 }
 
@@ -127,18 +167,32 @@ where
 
     #[inline(always)]
     fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.0.as_mut().expect(Self::BUG_MSG).poll_ready(cx)
+        self.decoder.as_mut().expect(Self::BUG_MSG).poll_ready(cx)
     }
 
-    fn call(&mut self, req: Request<ReqBody>) -> Self::Future {
-        if let Some(accept_encoding) = RequestConfig::<AcceptEncoding>::get(req.extensions()) {
-            if let Some(decoder) = self.0.take() {
-                self.0
-                    .replace(Decompression::accept_in_place(decoder, accept_encoding));
-            }
-            debug_assert!(self.0.is_some());
+    fn call(&mut self, mut req: Request<ReqBody>) -> Self::Future {
+        let enabled =
+            if let Some(accept_encoding) = RequestConfig::<AcceptEncoding>::get(req.extensions()) {
+                if let Some(decoder) = self.decoder.take() {
+                    self.decoder
+                        .replace(Decompression::accept_in_place(decoder, accept_encoding));
+                }
+                debug_assert!(self.decoder.is_some());
+                accept_encoding.is_enabled()
+            } else {
+                self.enabled
+            };
+
+        if enabled && req.headers().contains_key(RANGE) {
+            // tower-http does not account for Range when adding Accept-Encoding, so correct it
+            // before delegating. RFC 9110 section 14.1.2 applies byte ranges to the encoded
+            // representation, and Fetch avoids partial codings by requesting identity:
+            // https://www.rfc-editor.org/rfc/rfc9110.html#section-14.1.2
+            // https://fetch.spec.whatwg.org/#http-network-or-cache-fetch
+            req.headers_mut()
+                .insert(ACCEPT_ENCODING, HeaderValue::from_static("identity"));
         }
 
-        self.0.as_mut().expect(Self::BUG_MSG).call(req)
+        self.decoder.as_mut().expect(Self::BUG_MSG).call(req)
     }
 }

data/vendor/wreq/src/client/layer/redirect/future.rs

@@ -9,42 +9,40 @@ use futures_util::future::Either;
 use http::{
     HeaderMap, Method, Request, Response, StatusCode, Uri,
     header::{CONTENT_ENCODING, CONTENT_LENGTH, CONTENT_TYPE, LOCATION, TRANSFER_ENCODING},
-    request::Parts,
 };
-use http_body::Body;
 use pin_project_lite::pin_project;
 use tower::{BoxError, Service, util::Oneshot};
 use url::Url;
 
 use super::{
     BodyRepr,
-    policy::{Action, Attempt, Policy},
+    policy::{Action, Attempt},
 };
-use crate::{Error, ext::RequestUri, into_uri::IntoUriSealed};
+use crate::{Body, ext::RequestUri, into_uri::IntoUriSealed, redirect::FollowRedirectPolicy};
 
 /// Pending future state for handling redirects.
-pub struct Pending<ReqBody, Response> {
+pub struct Pending<Response> {
     future: Pin<Box<dyn Future<Output = Action> + Send>>,
     location: Uri,
-    body: ReqBody,
+    body: Body,
     res: Response,
 }
 
 pin_project! {
     /// Response future for [`FollowRedirect`].
     #[project = ResponseFutureProj]
-    pub enum ResponseFuture<S, B, P>
+    pub enum ResponseFuture<S>
     where
-        S: Service<Request<B>>,
+        S: Service<Request<Body>>,
     {
         Redirect {
             #[pin]
-            future: Either<S::Future, Oneshot<S, Request<B>>>,
-            pending_future: Option<Pending<B, S::Response>>,
+            future: Either<S::Future, Oneshot<S, Request<Body>>>,
+            pending_future: Option<Pending<S::Response>>,
             service: S,
-            policy: P,
-            parts: Parts,
-            body_repr: BodyRepr<B>,
+            policy: FollowRedirectPolicy,
+            request: Request<()>,
+            body_repr: BodyRepr<Body>,
         },
 
         Direct {
@@ -54,14 +52,12 @@ pin_project! {
     }
 }
 
-impl<S, ReqBody, ResBody, P> Future for ResponseFuture<S, ReqBody, P>
+impl<S, B> Future for ResponseFuture<S>
 where
-    S: Service<Request<ReqBody>, Response = Response<ResBody>> + Clone,
+    S: Service<Request<Body>, Response = Response<B>> + Clone,
     S::Error: From<BoxError>,
-    P: Policy<ReqBody, S::Error>,
-    ReqBody: Body + Default,
 {
-    type Output = Result<Response<ResBody>, S::Error>;
+    type Output = Result<Response<B>, S::Error>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         match self.project() {
@@ -71,7 +67,7 @@ where
                 pending_future,
                 service,
                 policy,
-                parts,
+                request,
                 body_repr,
             } => {
                 // Check if we have a pending action to resolve
@@ -91,7 +87,7 @@ where
                             future: &mut future,
                             service,
                             policy,
-                            parts,
+                            request,
                             body: state.body,
                             body_repr,
                             res: state.res,
@@ -103,7 +99,8 @@ where
                 // Poll the current future to get the response
                 let mut res = {
                     let mut res = ready!(future.as_mut().poll(cx)?);
-                    res.extensions_mut().insert(RequestUri(parts.uri.clone()));
+                    res.extensions_mut()
+                        .insert(RequestUri(request.uri().clone()));
                     res
                 };
 
@@ -112,19 +109,19 @@ where
                     StatusCode::MOVED_PERMANENTLY | StatusCode::FOUND => {
                         // User agents MAY change the request method from POST to GET
                         // (RFC 7231 section 6.4.2. and 6.4.3.).
-                        if parts.method == Method::POST {
-                            parts.method = Method::GET;
+                        if request.method() == Method::POST {
+                            *request.method_mut() = Method::GET;
                             *body_repr = BodyRepr::Empty;
-                            drop_payload_headers(&mut parts.headers);
+                            drop_payload_headers(request.headers_mut());
                         }
                     }
                     StatusCode::SEE_OTHER => {
                         // A user agent can perform a GET or HEAD request (RFC 7231 section 6.4.4.).
-                        if parts.method != Method::HEAD {
-                            parts.method = Method::GET;
+                        if request.method() != Method::HEAD {
+                            *request.method_mut() = Method::GET;
                         }
                         *body_repr = BodyRepr::Empty;
-                        drop_payload_headers(&mut parts.headers);
+                        drop_payload_headers(request.headers_mut());
                     }
                     StatusCode::TEMPORARY_REDIRECT | StatusCode::PERMANENT_REDIRECT => {}
                     _ => {
@@ -144,7 +141,7 @@ where
                     .headers()
                     .get(LOCATION)
                     .and_then(|loc| loc.to_str().ok())
-                    .and_then(|loc| resolve_uri(loc, &parts.uri))
+                    .and_then(|loc| resolve_uri(loc, request.uri()))
                 else {
                     return Poll::Ready(Ok(res));
                 };
@@ -154,7 +151,7 @@ where
                     status: res.status(),
                     headers: res.headers(),
                     location: &location,
-                    previous: &parts.uri,
+                    previous: request.uri(),
                 };
 
                 // Resolve the action, awaiting if it's pending
@@ -180,7 +177,7 @@ where
                         future: &mut future,
                         service,
                         policy,
-                        parts,
+                        request,
                         body,
                         body_repr,
                         res,
@@ -215,59 +212,48 @@ fn drop_payload_headers(headers: &mut HeaderMap) {
     }
 }
 
-type RedirectFuturePin<'a, S, ReqBody> =
-    Pin<&'a mut Either<<S as Service<Request<ReqBody>>>::Future, Oneshot<S, Request<ReqBody>>>>;
+type RedirectFuturePin<'a, S> =
+    Pin<&'a mut Either<<S as Service<Request<Body>>>::Future, Oneshot<S, Request<Body>>>>;
 
-struct RedirectAction<'a, S, ReqBody, ResBody, P>
+struct RedirectAction<'a, S, B>
 where
-    S: Service<Request<ReqBody>, Response = Response<ResBody>> + Clone,
-    P: Policy<ReqBody, S::Error>,
+    S: Service<Request<Body>, Response = Response<B>> + Clone,
 {
     action: Action,
-    future: &'a mut RedirectFuturePin<'a, S, ReqBody>,
+    future: &'a mut RedirectFuturePin<'a, S>,
     service: &'a S,
-    policy: &'a mut P,
-    parts: &'a mut Parts,
-    body: ReqBody,
-    body_repr: &'a mut BodyRepr<ReqBody>,
-    res: Response<ResBody>,
+    policy: &'a mut FollowRedirectPolicy,
+    request: &'a mut Request<()>,
+    body: Body,
+    body_repr: &'a mut BodyRepr<Body>,
+    res: Response<B>,
     location: Uri,
 }
 
-fn handle_action<S, ReqBody, ResBody, P>(
+fn handle_action<S, B>(
     cx: &mut Context<'_>,
-    redirect: RedirectAction<'_, S, ReqBody, ResBody, P>,
-) -> Poll<Result<Response<ResBody>, S::Error>>
+    redirect: RedirectAction<'_, S, B>,
+) -> Poll<Result<Response<B>, S::Error>>
 where
-    S: Service<Request<ReqBody>, Response = Response<ResBody>> + Clone,
+    S: Service<Request<Body>, Response = Response<B>> + Clone,
     S::Error: From<BoxError>,
-    P: Policy<ReqBody, S::Error>,
-    ReqBody: Body + Default,
 {
     match redirect.action {
         Action::Follow => {
-            redirect.parts.uri = redirect.location;
-            redirect
-                .body_repr
-                .try_clone_from(&redirect.body, redirect.policy);
+            *redirect.request.uri_mut() = redirect.location;
+            redirect.body_repr.try_clone_from(&redirect.body);
+            redirect.policy.on_request(redirect.request);
 
-            let mut req = Request::from_parts(redirect.parts.clone(), redirect.body);
-            redirect.policy.on_request(&mut req);
-            redirect
-                .future
-                .set(Either::Right(Oneshot::new(redirect.service.clone(), req)));
+            redirect.future.set(Either::Right(Oneshot::new(
+                redirect.service.clone(),
+                redirect.request.clone().map(|_| redirect.body),
+            )));
 
             cx.waker().wake_by_ref();
             Poll::Pending
         }
         Action::Stop => Poll::Ready(Ok(redirect.res)),
-        Action::Pending(_) => Poll::Ready(Err(S::Error::from(
-            Error::redirect(
-                "Nested pending Action is not supported in redirect policy",
-                redirect.parts.uri.clone(),
-            )
-            .into(),
-        ))),
         Action::Error(err) => Poll::Ready(Err(err.into())),
+        Action::Pending(_) => unreachable!(),
     }
 }

data/vendor/wreq/src/client/layer/redirect/policy.rs

@@ -2,34 +2,10 @@
 
 use std::{fmt, pin::Pin};
 
-use http::{HeaderMap, Request, Response, StatusCode, Uri};
+use http::{HeaderMap, StatusCode, Uri};
 
 use crate::error::BoxError;
 
-/// Trait for the policy on handling redirection responses.
-pub trait Policy<B, E> {
-    /// Invoked when the service received a response with a redirection status code (`3xx`).
-    ///
-    /// This method returns an [`Action`] which indicates whether the service should follow
-    /// the redirection.
-    fn redirect(&mut self, attempt: Attempt<'_>) -> Result<Action, E>;
-
-    /// Returns whether redirection is currently permitted by this policy.
-    ///
-    /// This method is called to determine whether the client should follow redirects at all.
-    /// It allows policies to enable or disable redirection behavior based on the [`Request`].
-    fn follow_redirects(&mut self, _request: &mut Request<B>) -> bool;
-
-    /// Invoked right before the service makes a [`Request`].
-    fn on_request(&mut self, _request: &mut Request<B>);
-
-    /// Invoked right after the service received a [`Response`].
-    fn on_response<Body>(&mut self, _response: &mut Response<Body>);
-
-    /// Try to clone a request body before the service makes a redirected request.
-    fn clone_body(&self, _body: &B) -> Option<B>;
-}
-
 /// A type that holds information on a redirection attempt.
 pub struct Attempt<'a> {
     pub(crate) status: StatusCode,
@@ -38,7 +14,7 @@ pub struct Attempt<'a> {
     pub(crate) previous: &'a Uri,
 }
 
-/// A value returned by [`Policy::redirect`] which indicates the action
+/// A value which indicates the action
 /// [`FollowRedirect`][super::FollowRedirect] should take for a redirection response.
 pub enum Action {
     /// Follow the redirection.