microsandbox-rb 0.5.11 → 0.5.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a2d0013cf55f89aa21492847859554937ff838d5d38d4f5f34d0e8da473c9554
-  data.tar.gz: 95bd9d994905567facd356597a8fee6e7f25715a485edbbc48bf98bb09f90eb3
+  metadata.gz: 82e3bca57a41c8b7a0b03e92baf14dc84f413e89e438616a0ea48c95ea237063
+  data.tar.gz: 4b3498e04b1ea1ff2f03e706bcc401bd9a216f622b38c9bf6e2e33f96a9dfaf9
 SHA512:
-  metadata.gz: 337de8ed90dfea5b44d959579a16dafdd736e33fbfff7e10ed8ad4678184f84bdf417f33d85a7a8f11ab69a4785a91c381ea719600769b804d9a71c1c048adb1
-  data.tar.gz: 672d7c7945e3a5561ad9934bc682b5f9764d1873d4235105e33ca1494a0079d11e574d520ed0e1f90bb66049264cdc783180448d2f456c78185024d9f18b186d
+  metadata.gz: cfed8fb4ae35f54dbb099fb306899c0e669f6ac7a607c283480637125f57575707534607a92604be78b8ca0135b6e1ec15869c369cfb75b809f14a70847f42d7
+  data.tar.gz: 1583a6b01336edb76312cde96b32bca2e124f2f2c815ddb26f5273930fe5e0e40f3b761e44e763a440a0d8ff368ca30cee30ee65991c1518110ad938b23ef6ba

data/CHANGELOG.md

@@ -6,6 +6,21 @@ upstream microsandbox runtime.
 
 ## [Unreleased]
 
+## [0.5.12] - 2026-06-23
+
+### Fixed
+
+- **fork-safe tokio runtime.** The process-wide multi-threaded runtime is now
+  tagged with the pid it was built under and rebuilt automatically after a
+  `fork(2)`. A forking host (Solid Queue / Resque job servers, clustered Puma)
+  used to inherit a runtime whose worker + I/O-driver threads do not survive the
+  fork — `block_on` could still drive the calling thread, but background I/O (e.g.
+  the agent-relay connection that streams `exec_stream` output) never ran, so
+  long-lived operations stalled or the connection dropped mid-stream in the child.
+  `runtime()` now detects the pid change and builds a fresh runtime for the child
+  (the stale one is leaked, never dropped — dropping a runtime whose threads
+  vanished across fork can hang on the shutdown join). No API change.
+
 ## [0.5.11] - 2026-06-23
 
 ### Added

data/Cargo.lock

@@ -3249,7 +3249,7 @@ dependencies = [
 
 [[package]]
 name = "microsandbox_rb"
-version = "0.5.11"
+version = "0.5.12"
 dependencies = [
  "chrono",
  "futures",

data/ext/microsandbox/Cargo.toml

@@ -7,7 +7,7 @@ description = "Ruby SDK native extension for microsandbox — secure, fast micro
 # Must equal Microsandbox::VERSION (lib/microsandbox/version.rb) — Native.version
 # returns this via env!("CARGO_PKG_VERSION") and version_spec.rb asserts equality.
 # The core-crate dependency below stays pinned at its own tag (v0.5.8).
-version = "0.5.11"
+version = "0.5.12"
 authors = ["Super Rad Company <development@superrad.company>"]
 repository = "https://github.com/superradcompany/microsandbox"
 license = "Apache-2.0"

data/ext/microsandbox/src/runtime.rs

@@ -9,7 +9,8 @@
 use std::ffi::c_void;
 use std::future::Future;
 use std::panic::{catch_unwind, AssertUnwindSafe};
-use std::sync::OnceLock;
+use std::sync::atomic::{AtomicPtr, AtomicU32, Ordering};
+use std::sync::Mutex;
 
 use magnus::Ruby;
 use tokio::runtime::Runtime;
@@ -21,17 +22,60 @@ pub fn ruby() -> Ruby {
     Ruby::get().expect("microsandbox: not on a Ruby thread")
 }
 
-static RUNTIME: OnceLock<Runtime> = OnceLock::new();
+// The process-wide tokio runtime, guarded by the pid it was built under. A
+// multi-threaded runtime owns worker + I/O-driver threads, and `fork(2)` copies
+// ONLY the calling thread — so a child that inherits this runtime has a runtime
+// whose threads are gone: `block_on` can still drive the current thread, but the
+// background I/O that keeps e.g. the agent-relay connection alive never runs, so
+// connections stall/drop mid-use. This is hit in practice by forking job servers
+// (Solid Queue, Resque) and clustered web servers (Puma workers).
+//
+// Fix: store the runtime behind a leaked raw pointer tagged with the building
+// pid. If `runtime()` is called in a process whose pid differs (we forked), build
+// a FRESH runtime for this process and swap the pointer. The stale runtime is
+// LEAKED, never dropped — dropping a tokio runtime whose worker threads vanished
+// across fork can hang on the shutdown thread-join. One runtime is leaked per
+// process that uses the SDK (bounded; equivalent to the old set-once behavior in
+// the common no-fork case).
+static RUNTIME_PTR: AtomicPtr<Runtime> = AtomicPtr::new(std::ptr::null_mut());
+static RUNTIME_PID: AtomicU32 = AtomicU32::new(0);
+static RUNTIME_LOCK: Mutex<()> = Mutex::new(());
 
-/// The process-wide multi-threaded tokio runtime, built on first use.
+fn build_runtime() -> Runtime {
+    tokio::runtime::Builder::new_multi_thread()
+        .enable_all()
+        .thread_name("microsandbox-rb")
+        .build()
+        .expect("microsandbox: failed to build tokio runtime")
+}
+
+/// The multi-threaded tokio runtime for THIS process, built on first use and
+/// rebuilt after a `fork(2)` (fork-safe — see the note above).
 pub fn runtime() -> &'static Runtime {
-    RUNTIME.get_or_init(|| {
-        tokio::runtime::Builder::new_multi_thread()
-            .enable_all()
-            .thread_name("microsandbox-rb")
-            .build()
-            .expect("microsandbox: failed to build tokio runtime")
-    })
+    let cur = std::process::id();
+    let ptr = RUNTIME_PTR.load(Ordering::Acquire);
+    if !ptr.is_null() && RUNTIME_PID.load(Ordering::Acquire) == cur {
+        // SAFETY: ptr was produced by Box::leak (valid for 'static) and matches
+        // this process's pid, so its runtime threads are live in this process.
+        return unsafe { &*ptr };
+    }
+
+    let _guard = RUNTIME_LOCK
+        .lock()
+        .expect("microsandbox: runtime lock poisoned");
+    // Re-check under the lock (another thread may have just built it).
+    let ptr = RUNTIME_PTR.load(Ordering::Acquire);
+    if !ptr.is_null() && RUNTIME_PID.load(Ordering::Acquire) == cur {
+        return unsafe { &*ptr };
+    }
+
+    // Build a fresh runtime for this process and publish it. The previous pointer
+    // (if any) belonged to a parent process and is intentionally leaked, not
+    // dropped (its threads are gone post-fork; Drop would block on join).
+    let rt: &'static Runtime = Box::leak(Box::new(build_runtime()));
+    RUNTIME_PTR.store(rt as *const Runtime as *mut Runtime, Ordering::Release);
+    RUNTIME_PID.store(cur, Ordering::Release);
+    rt
 }
 
 /// Run `f` with the Ruby GVL released.

data/lib/microsandbox/version.rb

@@ -5,5 +5,5 @@ module Microsandbox
   # the pinned core-crate tag); the patch segment advances for gem-only revisions
   # that add bindings atop the same core. Must equal the native ext's Cargo crate
   # version (`Native.version`), enforced by spec/unit/version_spec.rb.
-  VERSION = "0.5.11"
+  VERSION = "0.5.12"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: microsandbox-rb
 version: !ruby/object:Gem::Version
-  version: 0.5.11
+  version: 0.5.12
 platform: ruby
 authors:
 - ya-luotao