wreq 1.2.11 → 1.2.13

data/src/client/req.rs

@@ -184,131 +184,128 @@ pub fn execute_request<U: AsRef<str>>(
     url: U,
     mut request: Request,
 ) -> Result<Response, magnus::Error> {
-    rt::try_block_on(
-        ruby,
-        async move {
-            let mut builder = client.request(method.into_ffi(), url.as_ref());
-
-            // Emulation options.
-            apply_option!(set_if_some_inner, builder, request.emulation, emulation);
-
-            // Version options.
-            apply_option!(
-                set_if_some_map,
-                builder,
-                request.version,
-                version,
-                Version::into_ffi
-            );
-
-            // Timeout options.
-            apply_option!(
-                set_if_some_map,
-                builder,
-                request.timeout,
-                timeout,
-                Duration::from_secs
-            );
-            apply_option!(
-                set_if_some_map,
-                builder,
-                request.read_timeout,
-                read_timeout,
-                Duration::from_secs
-            );
-
-            // Network options.
-            apply_option!(set_if_some, builder, request.proxy, proxy);
-            apply_option!(set_if_some, builder, request.local_address, local_address);
-            #[cfg(any(
-                target_os = "android",
-                target_os = "fuchsia",
-                target_os = "illumos",
-                target_os = "ios",
-                target_os = "linux",
-                target_os = "macos",
-                target_os = "solaris",
-                target_os = "tvos",
-                target_os = "visionos",
-                target_os = "watchos",
-            ))]
-            apply_option!(set_if_some, builder, request.interface, interface);
-
-            // Headers options.
-            apply_option!(set_if_some_into_inner, builder, request.headers, headers);
-            apply_option!(
-                set_if_some_inner,
-                builder,
-                request.orig_headers,
-                orig_headers
-            );
-            apply_option!(
-                set_if_some,
-                builder,
-                request.default_headers,
-                default_headers
-            );
-
-            // Cookies options.
-            if let Some(cookies) = request.cookies.take() {
-                for cookie in cookies.0 {
-                    builder = builder.header(header::COOKIE, cookie);
-                }
-            }
+    rt::block_on(ruby, async move {
+        let mut builder = client.request(method.into_ffi(), url.as_ref());
+
+        // Emulation options.
+        apply_option!(set_if_some_inner, builder, request.emulation, emulation);
+
+        // Version options.
+        apply_option!(
+            set_if_some_map,
+            builder,
+            request.version,
+            version,
+            Version::into_ffi
+        );
+
+        // Timeout options.
+        apply_option!(
+            set_if_some_map,
+            builder,
+            request.timeout,
+            timeout,
+            Duration::from_secs
+        );
+        apply_option!(
+            set_if_some_map,
+            builder,
+            request.read_timeout,
+            read_timeout,
+            Duration::from_secs
+        );
 
-            // Authentication options.
-            apply_option!(
-                set_if_some_map_ref,
-                builder,
-                request.auth,
-                auth,
-                AsRef::<str>::as_ref
-            );
-            apply_option!(set_if_some, builder, request.bearer_auth, bearer_auth);
-            if let Some(basic_auth) = request.basic_auth.take() {
-                builder = builder.basic_auth(basic_auth.0, basic_auth.1);
+        // Network options.
+        apply_option!(set_if_some, builder, request.proxy, proxy);
+        apply_option!(set_if_some, builder, request.local_address, local_address);
+        #[cfg(any(
+            target_os = "android",
+            target_os = "fuchsia",
+            target_os = "illumos",
+            target_os = "ios",
+            target_os = "linux",
+            target_os = "macos",
+            target_os = "solaris",
+            target_os = "tvos",
+            target_os = "visionos",
+            target_os = "watchos",
+        ))]
+        apply_option!(set_if_some, builder, request.interface, interface);
+
+        // Headers options.
+        apply_option!(set_if_some_into_inner, builder, request.headers, headers);
+        apply_option!(
+            set_if_some_inner,
+            builder,
+            request.orig_headers,
+            orig_headers
+        );
+        apply_option!(
+            set_if_some,
+            builder,
+            request.default_headers,
+            default_headers
+        );
+
+        // Cookies options.
+        if let Some(cookies) = request.cookies.take() {
+            for cookie in cookies.0 {
+                builder = builder.header(header::COOKIE, cookie);
             }
+        }
 
-            // Allow redirects options.
-            match request.allow_redirects {
-                Some(false) => {
-                    builder = builder.redirect(wreq::redirect::Policy::none());
-                }
-                Some(true) => {
-                    builder = builder.redirect(
-                        request
-                            .max_redirects
-                            .take()
-                            .map(wreq::redirect::Policy::limited)
-                            .unwrap_or_default(),
-                    );
-                }
-                None => {}
-            };
-
-            // Compression options.
-            apply_option!(set_if_some, builder, request.gzip, gzip);
-            apply_option!(set_if_some, builder, request.brotli, brotli);
-            apply_option!(set_if_some, builder, request.deflate, deflate);
-            apply_option!(set_if_some, builder, request.zstd, zstd);
-
-            // Query options.
-            apply_option!(set_if_some_ref, builder, request.query, query);
-
-            // Form options.
-            apply_option!(set_if_some_ref, builder, request.form, form);
-
-            // JSON options.
-            apply_option!(set_if_some_ref, builder, request.json, json);
-
-            // Body options.
-            if let Some(body) = request.body.take() {
-                builder = builder.body(wreq::Body::from(body));
+        // Authentication options.
+        apply_option!(
+            set_if_some_map_ref,
+            builder,
+            request.auth,
+            auth,
+            AsRef::<str>::as_ref
+        );
+        apply_option!(set_if_some, builder, request.bearer_auth, bearer_auth);
+        if let Some(basic_auth) = request.basic_auth.take() {
+            builder = builder.basic_auth(basic_auth.0, basic_auth.1);
+        }
+
+        // Allow redirects options.
+        match request.allow_redirects {
+            Some(false) => {
+                builder = builder.redirect(wreq::redirect::Policy::none());
+            }
+            Some(true) => {
+                builder = builder.redirect(
+                    request
+                        .max_redirects
+                        .take()
+                        .map(wreq::redirect::Policy::limited)
+                        .unwrap_or_default(),
+                );
             }
+            None => {}
+        };
+
+        // Compression options.
+        apply_option!(set_if_some, builder, request.gzip, gzip);
+        apply_option!(set_if_some, builder, request.brotli, brotli);
+        apply_option!(set_if_some, builder, request.deflate, deflate);
+        apply_option!(set_if_some, builder, request.zstd, zstd);
+
+        // Query options.
+        apply_option!(set_if_some_ref, builder, request.query, query);
+
+        // Form options.
+        apply_option!(set_if_some_ref, builder, request.form, form);
+
+        // JSON options.
+        apply_option!(set_if_some_ref, builder, request.json, json);
+
+        // Body options.
+        if let Some(body) = request.body.take() {
+            builder = builder.body(wreq::Body::from(body));
+        }
 
-            // Send request.
-            builder.send().await.map(Response::new)
-        },
-        wreq_error,
-    )
+        // Send request.
+        builder.send().await.map(Response::new)
+    })?
+    .map_err(|err| wreq_error(ruby, err))
 }

data/src/client/resp.rs

@@ -9,6 +9,7 @@ use magnus::{Error, Module, RArray, RModule, Ruby, Value, scan_args::scan_args};
 use wreq::Uri;
 
 use crate::{
+    arch::ProcessLocal,
     client::body::{json::Json, stream::BodyReceiver},
     cookie::Cookie,
     error::{memory_error, no_block_given_error, wreq_error},
@@ -16,11 +17,15 @@ use crate::{
     header::Headers,
     http::{StatusCode, Version},
     rt,
+    tls::TlsInfo,
 };
 
 /// A response from a request.
 #[magnus::wrap(class = "Wreq::Response", free_immediately, size)]
-pub struct Response {
+pub struct Response(ProcessLocal<ResponseInner>);
+
+/// Inner response state owned by the process that received it.
+struct ResponseInner {
     uri: Uri,
     version: Version,
     status: StatusCode,
@@ -50,50 +55,54 @@ impl Response {
         let response = HttpResponse::from(response);
         let (parts, body) = response.into_parts();
 
-        Response {
+        Response(ProcessLocal::new(ResponseInner {
             uri,
             local_addr,
             remote_addr,
             content_length,
-            extensions: parts.extensions,
             version: Version::from_ffi(parts.version),
             status: StatusCode::from(parts.status),
             headers: parts.headers,
             body: ArcSwapOption::from_pointee(Body::Streamable(body)),
-        }
+            extensions: parts.extensions,
+        }))
     }
 
     /// Internal method to get the wreq::Response, optionally streaming the body.
     fn response(&self, ruby: &Ruby, stream: bool) -> Result<wreq::Response, Error> {
+        let state = self.0.get(ruby)?;
+
         let build_response = |body: wreq::Body| -> wreq::Response {
             let mut response = HttpResponse::new(body);
-            *response.version_mut() = self.version.into_ffi();
-            *response.status_mut() = self.status.0;
-            *response.headers_mut() = self.headers.clone();
-            *response.extensions_mut() = self.extensions.clone();
+            *response.version_mut() = state.version.into_ffi();
+            *response.status_mut() = state.status.0;
+            *response.headers_mut() = state.headers.clone();
+            *response.extensions_mut() = state.extensions.clone();
             wreq::Response::from(response)
         };
 
-        if let Some(arc) = self.body.swap(None) {
+        if let Some(arc) = state.body.swap(None) {
             match Arc::try_unwrap(arc) {
                 Ok(Body::Streamable(body)) => {
                     return if stream {
                         Ok(build_response(body))
                     } else {
-                        let bytes = rt::try_block_on(
+                        let bytes = rt::block_on(
                             ruby,
                             BodyExt::collect(body).map_ok(|buf| buf.to_bytes()),
-                            wreq_error,
-                        )?;
+                        )?
+                        .map_err(|err| wreq_error(ruby, err))?;
 
-                        self.body
+                        state
+                            .body
                             .store(Some(Arc::new(Body::Reusable(bytes.clone()))));
 
                         Ok(build_response(wreq::Body::from(bytes)))
                     };
                 }
                 Ok(Body::Reusable(bytes)) => {
-                    self.body
+                    state
+                        .body
                         .store(Some(Arc::new(Body::Reusable(bytes.clone()))));
 
                     if !stream {
@@ -110,38 +119,66 @@ impl Response {
 
 impl Response {
     /// Get the response status code as a u16.
+    ///
+    /// # Errors
+    ///
+    /// Returns `Wreq::ForkError` when the response belongs to a parent process.
     #[inline]
-    pub fn code(&self) -> u16 {
-        self.status.0.as_u16()
+    pub fn code(ruby: &Ruby, rb_self: &Self) -> Result<u16, Error> {
+        rb_self
+            .0
+            .get(ruby)
+            .map(|response| response.status.0.as_u16())
     }
 
     /// Get the response status code.
+    ///
+    /// # Errors
+    ///
+    /// Returns `Wreq::ForkError` when the response belongs to a parent process.
     #[inline]
-    pub fn status(&self) -> StatusCode {
-        self.status
+    pub fn status(ruby: &Ruby, rb_self: &Self) -> Result<StatusCode, Error> {
+        rb_self.0.get(ruby).map(|response| response.status)
     }
 
     /// Get the response HTTP version.
+    ///
+    /// # Errors
+    ///
+    /// Returns `Wreq::ForkError` when the response belongs to a parent process.
     #[inline]
-    pub fn version(&self) -> Version {
-        self.version
+    pub fn version(ruby: &Ruby, rb_self: &Self) -> Result<Version, Error> {
+        rb_self.0.get(ruby).map(|response| response.version)
     }
 
     /// Get the response URL.
+    ///
+    /// # Errors
+    ///
+    /// Returns `Wreq::ForkError` when the response belongs to a parent process.
     #[inline]
-    pub fn url(&self) -> String {
-        self.uri.to_string()
+    pub fn url(ruby: &Ruby, rb_self: &Self) -> Result<String, Error> {
+        rb_self.0.get(ruby).map(|response| response.uri.to_string())
     }
 
     /// Get the content length of the response, if known.
+    ///
+    /// # Errors
+    ///
+    /// Returns `Wreq::ForkError` when the response belongs to a parent process.
     #[inline]
-    pub fn content_length(&self) -> Option<u64> {
-        self.content_length
+    pub fn content_length(ruby: &Ruby, rb_self: &Self) -> Result<Option<u64>, Error> {
+        rb_self.0.get(ruby).map(|response| response.content_length)
     }
 
     /// Get the response cookies.
+    ///
+    /// # Errors
+    ///
+    /// Returns `Wreq::ForkError` when the response belongs to a parent process.
     pub fn cookies(ruby: &Ruby, rb_self: &Self) -> Result<RArray, Error> {
-        let cookies = Cookie::extract_headers_cookies(&rb_self.headers);
+        let response = rb_self.0.get(ruby)?;
+        let cookies = Cookie::extract_headers_cookies(&response.headers);
         let ary = ruby.ary_new_capa(cookies.len());
         for cookie in cookies {
             ary.push(cookie)?;
@@ -150,27 +187,63 @@ impl Response {
     }
 
     /// Get the response headers.
+    ///
+    /// # Errors
+    ///
+    /// Returns `Wreq::ForkError` when the response belongs to a parent process.
     #[inline]
-    pub fn headers(&self) -> Headers {
-        Headers::from(self.headers.clone())
+    pub fn headers(ruby: &Ruby, rb_self: &Self) -> Result<Headers, Error> {
+        rb_self
+            .0
+            .get(ruby)
+            .map(|response| Headers::from(response.headers.clone()))
     }
 
     /// Get the local socket address, if available.
+    ///
+    /// # Errors
+    ///
+    /// Returns `Wreq::ForkError` when the response belongs to a parent process.
     #[inline]
-    pub fn local_addr(&self) -> Option<String> {
-        self.local_addr.map(|addr| addr.to_string())
+    pub fn local_addr(ruby: &Ruby, rb_self: &Self) -> Result<Option<String>, Error> {
+        rb_self
+            .0
+            .get(ruby)
+            .map(|response| response.local_addr.map(|addr| addr.to_string()))
     }
 
     /// Get the remote socket address, if available.
+    ///
+    /// # Errors
+    ///
+    /// Returns `Wreq::ForkError` when the response belongs to a parent process.
     #[inline]
-    pub fn remote_addr(&self) -> Option<String> {
-        self.remote_addr.map(|addr| addr.to_string())
+    pub fn remote_addr(ruby: &Ruby, rb_self: &Self) -> Result<Option<String>, Error> {
+        rb_self
+            .0
+            .get(ruby)
+            .map(|response| response.remote_addr.map(|addr| addr.to_string()))
+    }
+
+    /// Return peer certificate data retained for this response.
+    ///
+    /// # Errors
+    ///
+    /// Returns `Wreq::ForkError` when the response belongs to a parent process.
+    fn tls_info(ruby: &Ruby, rb_self: &Self) -> Result<Option<TlsInfo>, Error> {
+        Ok(rb_self
+            .0
+            .get(ruby)?
+            .extensions
+            .get::<wreq::tls::TlsInfo>()
+            .cloned()
+            .map(TlsInfo))
     }
 
     /// Get the response body as bytes.
     pub fn bytes(ruby: &Ruby, rb_self: &Self) -> Result<Bytes, Error> {
         let response = rb_self.response(ruby, false)?;
-        rt::try_block_on(ruby, response.bytes(), wreq_error)
+        rt::block_on(ruby, response.bytes())?.map_err(|err| wreq_error(ruby, err))
     }
 
     ///  Get the full response text given a specific encoding.
@@ -178,17 +251,17 @@ impl Response {
         let args = scan_args::<(), (Option<String>,), (), (), (), ()>(args)?;
         let response = rb_self.response(ruby, false)?;
         match args.optional.0 {
-            Some(encoding) => {
-                rt::try_block_on(ruby, response.text_with_charset(encoding), wreq_error)
-            }
-            None => rt::try_block_on(ruby, response.text(), wreq_error),
+            Some(encoding) => rt::block_on(ruby, response.text_with_charset(encoding))?
+                .map_err(|err| wreq_error(ruby, err)),
+            None => rt::block_on(ruby, response.text())?.map_err(|err| wreq_error(ruby, err)),
         }
     }
 
     /// Get the response body as JSON.
     pub fn json(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
         let response = rb_self.response(ruby, false)?;
-        let json = rt::try_block_on(ruby, response.json::<Json>(), wreq_error)?;
+        let json =
+            rt::block_on(ruby, response.json::<Json>())?.map_err(|err| wreq_error(ruby, err))?;
         crate::serde::serialize(ruby, &json)
     }
 
@@ -211,16 +284,15 @@ impl Response {
     }
 
     /// Close the response body, dropping any resources.
-    #[inline]
-    pub fn close(&self) {
-        gvl::nogvl(|| self.body.swap(None));
-    }
-}
-
-impl Drop for Response {
-    fn drop(&mut self) {
-        // Ensure body is dropped in GVL
-        self.body.swap(None);
+    ///
+    /// # Errors
+    ///
+    /// Returns `Wreq::ForkError` before touching a response inherited from the
+    /// parent process.
+    pub fn close(ruby: &Ruby, rb_self: &Self) -> Result<(), Error> {
+        let response = rb_self.0.get(ruby)?;
+        gvl::nogvl(|| response.body.swap(None));
+        Ok(())
     }
 }
 
@@ -243,5 +315,6 @@ pub fn include(ruby: &Ruby, gem_module: &RModule) -> Result<(), Error> {
     response.define_method("json", magnus::method!(Response::json, 0))?;
     response.define_method("chunks", magnus::method!(Response::chunks, 0))?;
     response.define_method("close", magnus::method!(Response::close, 0))?;
+    response.define_method("tls_info", magnus::method!(Response::tls_info, 0))?;
     Ok(())
 }