oo7-rb 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ef2fd80ab2a8f10c5d088bbbec07818d02de3f10052481948aaa696ea06edeb7
-  data.tar.gz: cec2a14c4480f65cc60c153bc13288c37f18cb2f465276979acbd1ca26ef86dd
+  metadata.gz: b297fb73779f9906f68e6c4d095e063ba13d4eda98602a9b11f46b25454138c8
+  data.tar.gz: 9d1216cf3d649f149f7c02a1843c8bde9bdad07232a4e2c39ecfc68f1d2dd616
 SHA512:
-  metadata.gz: 333db89d32d32c9bce18e3ef5d44bfa84473849005c7b972b63f3220de0af49688aaf433d2c9f2762b61e5db5da696ce55f60472b57e2c559a3237a80027a92a
-  data.tar.gz: 8c4a678e0c38fe38e056aa456855b1066a2225c276cdb2d9e5165edffb197078be52dc112e67fb94e35842d2bb523758f098907a63c5e817fcdb798f20349270
+  metadata.gz: 12300842da80f184bf6546dd13d1431522942eb0e306a9da4ec9a4ed3feb4389a93e033a2db848965b18027e2b722d88fcca0c43ae9b60f00da85fffdd754578
+  data.tar.gz: 72555652dd852e1dacfa27b873d8275629b0fa239134a7ea89dc16ec9d586c5daa417c632cc6ae48fd403bb749ea88abc91af2364d4291730c3c25632b96f677

data/CHANGELOG.md

@@ -7,6 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [1.0.1] - 2026-11-02
+
+### Fixed
+
+- The GVL is released while a call waits, via `rb_thread_call_without_gvl`.
+  Every method previously held it for the whole D-Bus round trip, so a worker
+  thread blocked the main thread too -- the GVL is global -- and a GTK
+  application could not keep its main loop answering by moving the call off it.
+  It froze instead, and took the desktop with it, which is the thing this gem
+  exists to avoid. magnus 0.9 does not bind that function, so the crate declares
+  it.
+- `test/oo7/concurrency.rb` checks it by behaviour rather than by inspection: a
+  second Ruby thread has to make progress while a keyring call is in flight.
+  With the GVL held it records zero ticks, so the test fails if the release is
+  ever lost again.
+
 ## [1.0.0] - 2026-11-02
 
 ### Added

data/ext/oo7/src/lib.rs

@@ -14,9 +14,13 @@
 //!
 //! Every method on the crate is async. Each binding drives it to completion on a
 //! Tokio runtime owned by this extension and returns the result, so the Ruby API
-//! is ordinary and synchronous. The calling thread is blocked while it waits and
-//! the GVL is held, so a keyring call should not be made from a thread that
-//! something else is waiting on -- on a GTK main loop, put it on a Ruby thread.
+//! is ordinary and synchronous.
+//!
+//! The calling thread waits, but it waits with the GVL released, so every other
+//! Ruby thread keeps running. That is what lets a GTK application put a keyring
+//! call on a worker thread and keep its main loop answering: without it the
+//! worker would hold the GVL throughout and freeze the main thread anyway, which
+//! is a frozen desktop rather than a slow one.
 //!
 //! # Provenance
 //!
@@ -28,6 +32,7 @@
 //!   - <https://gitlab.gnome.org/World/fractal> (GPL-3.0-or-later; read only)
 
 use std::collections::HashMap;
+use std::ffi::c_void;
 use std::future::Future;
 use std::sync::OnceLock;
 
@@ -59,8 +64,73 @@ fn runtime() -> Result<&'static Runtime, Error> {
         .map_err(rt_err)
 }
 
+// Ruby's public C API, which magnus 0.9 does not bind (its list carries
+// rb_thread_call_without_gvl commented out). Declared here rather than reached
+// for through rb-sys' generated bindings, which depend on what bindgen picked up
+// from this Ruby's headers.
+unsafe extern "C" {
+    fn rb_thread_call_without_gvl(
+        func: extern "C" fn(*mut c_void) -> *mut c_void,
+        data1: *mut c_void,
+        ubf: Option<extern "C" fn(*mut c_void)>,
+        data2: *mut c_void,
+    ) -> *mut c_void;
+}
+
+/// Run `work` with the GVL released.
+///
+/// This is the whole reason a Ruby thread can be used to keep a keyring call off
+/// a GTK main loop. The GVL is global: a worker thread that blocks inside an
+/// extension still holding it stops every other Ruby thread, the main one
+/// included, so offloading the call would otherwise buy nothing at all.
+///
+/// `work` must not touch Ruby -- no values, no exceptions, no allocation through
+/// the VM -- because this thread does not hold the GVL while it runs. Driving a
+/// future over D-Bus touches only Rust, which is what makes it eligible.
+///
+/// The unblocking function is None, so the call is not interruptible: a D-Bus
+/// round trip that never answers cannot be killed by Thread#kill. That is the
+/// trade for not blocking the VM, and it is the right way round for a UI, where
+/// the alternative is a frozen desktop.
+fn without_gvl<F, T>(work: F) -> T
+where
+    F: FnOnce() -> T,
+{
+    struct Payload<F, T> {
+        work: Option<F>,
+        out: Option<T>,
+    }
+
+    extern "C" fn call<F, T>(data: *mut c_void) -> *mut c_void
+    where
+        F: FnOnce() -> T,
+    {
+        // Safe: the pointer is the Payload below, alive for the whole call, and
+        // reached from this one thread only.
+        let payload = unsafe { &mut *data.cast::<Payload<F, T>>() };
+        let work = payload.work.take().expect("the work runs once");
+        payload.out = Some(work());
+        std::ptr::null_mut()
+    }
+
+    let mut payload = Payload { work: Some(work), out: None };
+
+    unsafe {
+        rb_thread_call_without_gvl(
+            call::<F, T>,
+            (&raw mut payload).cast::<c_void>(),
+            None,
+            std::ptr::null_mut(),
+        );
+    }
+
+    payload.out.expect("the work ran")
+}
+
 fn block<F: Future>(future: F) -> Result<F::Output, Error> {
-    Ok(runtime()?.block_on(future))
+    let runtime = runtime()?;
+
+    Ok(without_gvl(|| runtime.block_on(future)))
 }
 
 /// A Ruby hash of strings, which is what the Secret Service calls attributes.

data/lib/oo7/version.rb

@@ -4,5 +4,5 @@
 # Copyright, 2026, by General Intelligence Systems.
 
 module Oo7
-  VERSION = "1.0.0"
+  VERSION = "1.0.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: oo7-rb
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Nathan Kidd