wreq 1.2.12 → 1.2.13

data/src/arch.rs

@@ -8,35 +8,63 @@
 
 use std::mem::ManuallyDrop;
 
-/// Native state that belongs to the process where the extension was loaded.
+use magnus::Ruby;
+
+#[cfg(unix)]
+use crate::error::fork_error;
+
+/// Native state that belongs to the process where it was created.
 ///
 /// A forked child must not destroy inherited clients, channels, or response
 /// bodies because their synchronization state may belong to threads that no
 /// longer exist. The child intentionally leaks the value and lets the operating
 /// system reclaim it when the process exits.
 ///
-/// This wrapper only controls destruction. Call [`crate::rt::ensure_current`]
-/// before using process-bound state stored inside it.
-#[derive(Clone)]
-pub(crate) struct ProcessLocal<T>(ManuallyDrop<T>);
+/// `Send` and `Sync` only describe access between threads in one process. They
+/// do not make a runtime, lock, channel, or connection pool safe after `fork`.
+///
+/// [`ProcessLocal::get`] is the only access path and checks the object's own
+/// process generation before exposing its value.
+pub(crate) struct ProcessLocal<T> {
+    value: ManuallyDrop<T>,
+    #[cfg(unix)]
+    owner: unix::ProcessToken,
+}
 
 impl<T> ProcessLocal<T> {
     /// Wrap native state created by the current process.
     pub(crate) fn new(value: T) -> Self {
-        Self(ManuallyDrop::new(value))
+        Self {
+            value: ManuallyDrop::new(value),
+            #[cfg(unix)]
+            owner: unix::ProcessToken::current(),
+        }
     }
-}
 
-impl<T> AsRef<T> for ProcessLocal<T> {
-    fn as_ref(&self) -> &T {
-        &self.0
+    /// Borrow native state only from the process that created it.
+    ///
+    /// # Errors
+    ///
+    /// Returns `Wreq::ForkError` when the value was inherited from a parent
+    /// process.
+    #[inline]
+    pub(crate) fn get(&self, ruby: &Ruby) -> Result<&T, magnus::Error> {
+        #[cfg(unix)]
+        if let Some((owner_pid, current_pid)) = self.owner.forked_process_ids() {
+            return Err(fork_error(ruby, owner_pid, current_pid));
+        }
+
+        #[cfg(not(unix))]
+        let _ = ruby;
+
+        Ok(&self.value)
     }
 }
 
 impl<T> Drop for ProcessLocal<T> {
     fn drop(&mut self) {
         #[cfg(unix)]
-        if forked_process_ids().is_some() {
+        if self.owner.forked_process_ids().is_some() {
             return;
         }
 
@@ -44,7 +72,7 @@ impl<T> Drop for ProcessLocal<T> {
         // prevents an automatic second drop, and this wrapper's `Drop`
         // implementation runs at most once.
         unsafe {
-            ManuallyDrop::drop(&mut self.0);
+            ManuallyDrop::drop(&mut self.value);
         }
     }
 }
@@ -74,54 +102,72 @@ pub(crate) const SUPPORTS_INTERFACE: bool = cfg!(any(
 mod unix {
     use std::{io, process, sync::OnceLock};
 
-    /// Process state captured when the extension initializes.
+    /// Identity of the process generation that created native state.
     ///
-    /// The atfork guard uses a POSIX child handler to advance an atomic fork
-    /// generation without running Ruby code.
+    /// Forkguard's child callback only advances an atomic generation counter.
+    /// The PID is retained for diagnostics and as a fallback if registering
+    /// the callback fails.
     /// https://pubs.opengroup.org/onlinepubs/9799919799/functions/pthread_atfork.html
-    struct ForkGuard {
-        detector: forkguard::Guard,
+    pub(super) struct ProcessToken {
+        detector: Option<forkguard::Guard>,
         owner_pid: u32,
     }
 
-    impl ForkGuard {
-        /// Create a guard and register fork detection with the process.
-        fn new() -> io::Result<Self> {
+    impl ProcessToken {
+        /// Capture the current process and fork generation.
+        pub(super) fn current() -> Self {
+            Self::try_current().unwrap_or_else(|_| Self {
+                detector: None,
+                owner_pid: process::id(),
+            })
+        }
+
+        /// Capture the current process after registering fork detection.
+        fn try_current() -> io::Result<Self> {
             forkguard::Guard::try_new()
                 .map(|detector| Self {
-                    detector,
+                    detector: Some(detector),
                     owner_pid: process::id(),
                 })
                 .map_err(|error| io::Error::from_raw_os_error(error.code().get()))
         }
 
-        /// Return process IDs when this guard was inherited through a fork.
-        fn forked_process_ids(&self) -> Option<(u32, u32)> {
-            // Keep the stored generation unchanged so every runtime access in
-            // the child remains rejected. Cloning the detector copies one usize.
-            let mut detector = self.detector.clone();
-            detector
-                .detected_fork()
-                .then(|| (self.owner_pid, process::id()))
+        /// Return process IDs when this token was inherited through a fork.
+        pub(super) fn forked_process_ids(&self) -> Option<(u32, u32)> {
+            if let Some(detector) = &self.detector {
+                // Keep the stored generation unchanged so repeated accesses
+                // continue to reject the same inherited object. Cloning the
+                // detector copies one usize.
+                return detector
+                    .clone()
+                    .detected_fork()
+                    .then(|| (self.owner_pid, process::id()));
+            }
+
+            let current_pid = process::id();
+            (self.owner_pid != current_pid).then_some((self.owner_pid, current_pid))
         }
     }
 
-    static FORK_GUARD: OnceLock<ForkGuard> = OnceLock::new();
+    /// Runtime owner captured when Tokio first initializes.
+    static RUNTIME_OWNER: OnceLock<ProcessToken> = OnceLock::new();
 
-    /// Register process fork tracking before the extension exposes its API.
+    /// Register process fork tracking before the Tokio runtime is initialized.
     pub(crate) fn initialize_fork_tracking() -> io::Result<()> {
-        if FORK_GUARD.get().is_some() {
+        if RUNTIME_OWNER.get().is_some() {
             return Ok(());
         }
 
-        let guard = ForkGuard::new()?;
-        let _ = FORK_GUARD.set(guard);
+        let owner = ProcessToken::try_current()?;
+        let _ = RUNTIME_OWNER.set(owner);
         Ok(())
     }
 
-    /// Return process IDs only when this process inherited the extension.
+    /// Return process IDs when this process inherited an initialized runtime.
     pub(crate) fn forked_process_ids() -> Option<(u32, u32)> {
-        FORK_GUARD.get().and_then(ForkGuard::forked_process_ids)
+        RUNTIME_OWNER
+            .get()
+            .and_then(ProcessToken::forked_process_ids)
     }
 }
 
@@ -175,7 +221,7 @@ mod tests {
 
         {
             let value = ProcessLocal::new(DropCounter(&drops));
-            assert_eq!(value.as_ref().0.get(), 0);
+            assert_eq!(value.value.0.get(), 0);
         }
 
         assert_eq!(drops.get(), 1);

data/src/client/body/stream.rs

@@ -65,17 +65,14 @@ impl BodyReceiver {
 
     /// Read the next body chunk, converting stream errors into Ruby errors.
     pub fn next(&self, ruby: &Ruby) -> Result<Option<Bytes>, Error> {
-        rt::try_block_on(
-            ruby,
-            async {
-                match self.0.lock().await.as_mut().next().await {
-                    Some(Ok(data)) => Ok(Some(data)),
-                    Some(Err(err)) => Err(err),
-                    None => Ok(None),
-                }
-            },
-            wreq_error,
-        )
+        rt::block_on(ruby, async {
+            match self.0.lock().await.as_mut().next().await {
+                Some(Ok(data)) => Ok(Some(data)),
+                Some(Err(err)) => Err(err),
+                None => Ok(None),
+            }
+        })?
+        .map_err(|err| wreq_error(ruby, err))
     }
 }
 
@@ -90,10 +87,8 @@ impl BodySender {
     /// # Errors
     ///
     /// Returns `TypeError` for a non-Integer capacity and `ArgumentError` for
-    /// an invalid range or argument count. Returns `Wreq::ForkError` before
-    /// creating a channel in a child that inherited the extension.
+    /// an invalid range or argument count.
     pub fn new(ruby: &Ruby, args: &[Value]) -> Result<Self, Error> {
-        rt::ensure_current(ruby)?;
         let capacity = parse_capacity(ruby, args)?;
 
         // Create the Tokio channel without allowing an unwind to cross the Ruby FFI boundary.
@@ -121,8 +116,6 @@ impl BodySender {
     /// wait raises `Wreq::InterruptError`. Returns `Wreq::ForkError` before
     /// reading an inherited channel.
     pub fn push(ruby: &Ruby, rb_self: &Self, data: RString) -> Result<(), Error> {
-        rt::ensure_current(ruby)?;
-
         // Clone during the shared borrow, then release it before waiting
         // for capacity. Request attachment needs a mutable borrow.
         let tx = match &rb_self.read_inner(ruby)?.tx {
@@ -130,7 +123,8 @@ impl BodySender {
             _ => return Err(closed_body_sender_error(ruby)),
         };
 
-        rt::try_block_on(ruby, tx.send(data.to_bytes()), body_sender_send_error)
+        rt::block_on(ruby, tx.send(data.to_bytes()))?
+            .map_err(|err| body_sender_send_error(ruby, err))
     }
 
     /// Close the producing side while retaining the receiver and queued chunks.
@@ -142,7 +136,6 @@ impl BodySender {
     /// Returns `Wreq::ForkError` before reading an inherited channel, or
     /// `Wreq::BodyError` if the internal state is already borrowed.
     pub fn close(ruby: &Ruby, rb_self: &Self) -> Result<(), Error> {
-        rt::ensure_current(ruby)?;
         let mut inner = rb_self.write_inner(ruby)?;
         inner.tx.take();
         Ok(())
@@ -155,22 +148,21 @@ impl BodySender {
     /// Returns `Wreq::ForkError` before reading an inherited channel, or
     /// `Wreq::BodyError` if the internal state is already borrowed.
     pub fn is_closed(ruby: &Ruby, rb_self: &Self) -> Result<bool, Error> {
-        rt::ensure_current(ruby)?;
         rb_self.read_inner(ruby).map(|r| r.is_closed())
     }
 
-    /// Borrow the channel state without panicking on accidental re-entry.
+    /// Borrow channel state only in the process that created this sender.
     fn read_inner(&self, ruby: &Ruby) -> Result<Ref<'_, InnerBodySender>, Error> {
         self.0
-            .as_ref()
+            .get(ruby)?
             .try_borrow()
             .map_err(|err| body_sender_borrow_error(ruby, err))
     }
 
-    /// Mutably borrow the channel state without panicking on accidental re-entry.
+    /// Mutably borrow channel state only in the process that created this sender.
     fn write_inner(&self, ruby: &Ruby) -> Result<RefMut<'_, InnerBodySender>, Error> {
         self.0
-            .as_ref()
+            .get(ruby)?
             .try_borrow_mut()
             .map_err(|err| body_sender_borrow_mut_error(ruby, err))
     }
@@ -182,7 +174,6 @@ impl BodySender {
     /// Returns `Wreq::MemoryError` if the receiver was already consumed, or
     /// `Wreq::BodyError` if Ruby re-enters while the state is borrowed.
     pub(super) fn take_receiver(&self, ruby: &Ruby) -> Result<ReceiverStream<Bytes>, Error> {
-        rt::ensure_current(ruby)?;
         self.write_inner(ruby)?
             .rx
             .take()

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))
 }