microsandbox-rb 0.5.10 → 0.5.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d4d9e8db2dddac7a22c2910c82a56603e95ad702d328c6a020f514997d29859c
-  data.tar.gz: 5f19089f8d1d0f18d5d930cf49576d25862f02323495ffa02db683f57a3439cd
+  metadata.gz: 82e3bca57a41c8b7a0b03e92baf14dc84f413e89e438616a0ea48c95ea237063
+  data.tar.gz: 4b3498e04b1ea1ff2f03e706bcc401bd9a216f622b38c9bf6e2e33f96a9dfaf9
 SHA512:
-  metadata.gz: 88e44654909dd3f39ac23c6cf682bd62519bbaf7f57ca24f611a66e05bb66c825919fc1f2be6f9044513c99508bfedd412e5c72c1f15fc8b66c3ac11ee2b78ac
-  data.tar.gz: 00b0f44a4568107891a2ce9a623950245457ea51d0700f45333b96fec7eb73e6572b8b9b67b4147490423687fa1ff7dcb96b6edd29c2aa28c3ed22807eab7bdb
+  metadata.gz: cfed8fb4ae35f54dbb099fb306899c0e669f6ac7a607c283480637125f57575707534607a92604be78b8ca0135b6e1ec15869c369cfb75b809f14a70847f42d7
+  data.tar.gz: 1583a6b01336edb76312cde96b32bca2e124f2f2c815ddb26f5273930fe5e0e40f3b761e44e763a440a0d8ff368ca30cee30ee65991c1518110ad938b23ef6ba

data/CHANGELOG.md

@@ -6,6 +6,35 @@ 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
+
+- **Read-only / mount-option passthrough for volumes.** A volume spec Hash may
+  now carry `ro:`/`readonly:`, `noexec:`, `nosuid:`, `nodev:`, or an explicit
+  `options:` array, e.g. `volumes: { "/repos" => { bind: "/host/repos", ro: true } }`.
+  The Ruby layer appends a 4th comma-joined options element to the normalized
+  mount triple and the native ext applies the matching `MountBuilder` flags. RO is
+  enforced both host-side (virtiofs rejects writes) and guest-side (kernel returns
+  `EROFS`). Previously the gem could only request read-write mounts, so callers had
+  to fake read-only with host `chmod -R a-w`. Backward compatible: String specs and
+  option-less Hash specs serialize to the exact same 3-element triple as before.
+
 ## [0.5.10] - 2026-06-22
 
 ### Added

data/Cargo.lock

@@ -3249,7 +3249,7 @@ dependencies = [
 
 [[package]]
 name = "microsandbox_rb"
-version = "0.5.10"
+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.10"
+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/ext/microsandbox/src/sandbox.rs

@@ -89,9 +89,11 @@ impl Sandbox {
         for (host, guest) in conv::opt_port_map(opts, "ports")? {
             b = b.port(host, guest);
         }
-        // volumes: normalized by the Ruby layer to [guest, kind, source] triples.
+        // volumes: normalized by the Ruby layer to [guest, kind, source] triples,
+        // or [guest, kind, source, options] quads where options is a comma-joined
+        // list (ro/readonly, rw, noexec, nosuid, nodev).
         for spec in conv::opt::<Vec<Vec<String>>>(opts, "volumes")?.unwrap_or_default() {
-            if spec.len() != 3 {
+            if spec.len() < 3 || spec.len() > 4 {
                 return Err(error::base_error("invalid volume mount spec"));
             }
             let (guest, kind, source) = (spec[0].clone(), spec[1].clone(), spec[2].clone());
@@ -103,12 +105,43 @@ impl Sandbox {
                     )))
                 }
             }
+            // Validate options up front (the volume closure cannot return an error).
+            let mount_opts: Vec<String> = spec
+                .get(3)
+                .map(|s| {
+                    s.split(',')
+                        .map(|o| o.trim().to_string())
+                        .filter(|o| !o.is_empty())
+                        .collect()
+                })
+                .unwrap_or_default();
+            for opt in &mount_opts {
+                match opt.as_str() {
+                    "ro" | "readonly" | "rw" | "noexec" | "nosuid" | "nodev" => {}
+                    other => {
+                        return Err(error::base_error(format!(
+                            "unknown volume mount option {other:?} \
+                             (expected ro/rw/noexec/nosuid/nodev)"
+                        )))
+                    }
+                }
+            }
             b = b.volume(guest, move |m| {
-                if kind == "named" {
+                let mut m = if kind == "named" {
                     m.named(source)
                 } else {
                     m.bind(source)
+                };
+                for opt in &mount_opts {
+                    m = match opt.as_str() {
+                        "ro" | "readonly" => m.readonly(),
+                        "noexec" => m.noexec(),
+                        "nosuid" => m.nosuid(),
+                        "nodev" => m.nodev(),
+                        _ => m, // "rw" — default; already validated above
+                    };
                 }
+                m
             });
         }
         // patches: rootfs modifications applied before boot. The Ruby layer

data/lib/microsandbox/sandbox.rb

@@ -387,8 +387,10 @@ module Microsandbox
       end
 
       # Normalize volumes (Hash of guest_path => spec) into [guest, kind, source]
-      # triples for the native layer. A spec is a host path String (bind mount),
-      # or a Hash { bind: "/host" } / { named: "volume-name" }.
+      # triples (or [guest, kind, source, options] quads) for the native layer. A
+      # spec is a host path String (read-write bind mount), or a Hash
+      # { bind: "/host" } / { named: "volume-name" } optionally carrying mount
+      # options: { bind: "/host", ro: true } / { named: "v", options: %w[ro noexec] }.
       def normalize_volumes(volumes)
         volumes.map do |guest, spec|
           guest = guest.to_s
@@ -396,19 +398,39 @@ module Microsandbox
           when String
             [guest, "bind", spec]
           when Hash
-            if (named = spec[:named] || spec["named"])
-              [guest, "named", named.to_s]
-            elsif (bind = spec[:bind] || spec["bind"])
-              [guest, "bind", bind.to_s]
-            else
-              raise ArgumentError, "volume spec for #{guest.inspect} needs :bind or :named"
-            end
+            triple =
+              if (named = spec[:named] || spec["named"])
+                [guest, "named", named.to_s]
+              elsif (bind = spec[:bind] || spec["bind"])
+                [guest, "bind", bind.to_s]
+              else
+                raise ArgumentError, "volume spec for #{guest.inspect} needs :bind or :named"
+              end
+            # Optional 4th element: comma-joined mount options. Omitted when empty
+            # so existing [guest,kind,source] consumers and the common read-write
+            # case are byte-for-byte unchanged.
+            opts = mount_options(spec)
+            opts.empty? ? triple : triple + [opts.join(",")]
           else
             raise ArgumentError, "invalid volume spec for #{guest.inspect}: #{spec.inspect}"
           end
         end
       end
 
+      # Collect mount options from a volume spec Hash. `ro:`/`readonly:` makes the
+      # mount read-only (host virtiofs rejects writes + guest kernel returns EROFS);
+      # `noexec:`/`nosuid:`/`nodev:` set the matching flags; an explicit `options:`
+      # array passes through verbatim. Unknown options are rejected natively.
+      def mount_options(spec)
+        opts = []
+        opts << "ro" if spec[:ro] || spec["ro"] || spec[:readonly] || spec["readonly"]
+        opts << "noexec" if spec[:noexec] || spec["noexec"]
+        opts << "nosuid" if spec[:nosuid] || spec["nosuid"]
+        opts << "nodev" if spec[:nodev] || spec["nodev"]
+        Array(spec[:options] || spec["options"]).each { |o| opts << o.to_s }
+        opts.uniq
+      end
+
       # Normalize a list of patches (each a Hash from the {Patch} factory, or a
       # plain Hash) into string-keyed Hashes for the native layer. Values are
       # passed through unchanged (mode stays Integer, content stays String).

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.10"
+  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.10
+  version: 0.5.12
 platform: ruby
 authors:
 - ya-luotao