microsandbox-rb 0.17.2 → 0.17.3

data/ext/microsandbox/src/snapshot.rs

@@ -140,10 +140,13 @@ fn list_dir(dir: String) -> Result<RArray, Error> {
 fn reindex(dir: Option<String>) -> Result<u64, Error> {
     let dir: PathBuf = match dir {
         Some(d) => PathBuf::from(d),
-        None => microsandbox::default_backend()
-            .as_local()
-            .map(|l| l.snapshots_dir())
-            .unwrap_or_else(|| PathBuf::from(".")),
+        None => {
+            crate::backend::ensure_this_process_backend()?;
+            microsandbox::default_backend()
+                .as_local()
+                .map(|l| l.snapshots_dir())
+                .unwrap_or_else(|| PathBuf::from("."))
+        }
     };
     let n = block_on(Snapshot::reindex(&dir))?.map_err(error::to_ruby)?;
     Ok(n as u64)

data/ext/microsandbox/src/ssh.rs

@@ -21,7 +21,7 @@ use tokio::io::AsyncWriteExt;
 use tokio::sync::Mutex;
 
 use crate::error;
-use crate::runtime::{block_on, ruby};
+use crate::runtime::{block_on, ruby, ForkGuarded};
 
 /// A core error for a session whose value was already taken (closed). Built
 /// inside `block_on`, so it must be a plain Rust error, not a Ruby one.
@@ -35,19 +35,19 @@ fn consumed() -> MicrosandboxError {
 
 #[magnus::wrap(class = "Microsandbox::Native::SshClient", free_immediately, size)]
 pub struct SshClient {
-    inner: Arc<Mutex<Option<CoreSshClient>>>,
+    inner: ForkGuarded<Arc<Mutex<Option<CoreSshClient>>>>,
 }
 
 impl SshClient {
     pub fn from_core(inner: CoreSshClient) -> Self {
         Self {
-            inner: Arc::new(Mutex::new(Some(inner))),
+            inner: ForkGuarded::new("Microsandbox::SshClient", Arc::new(Mutex::new(Some(inner)))),
         }
     }
 
     /// Run a command over SSH and collect {status, stdout, stderr}.
     fn exec(&self, command: String, tty: bool) -> Result<RHash, Error> {
-        let inner = Arc::clone(&self.inner);
+        let inner = Arc::clone(self.inner.get()?);
         let result: MicrosandboxResult<SshOutput> = block_on(async move {
             let guard = inner.lock().await;
             let client = guard.as_ref().ok_or_else(consumed)?;
@@ -59,7 +59,7 @@ impl SshClient {
     /// Attach the local terminal to an interactive SSH shell; returns the exit
     /// status. Host-TTY coupled (raw mode); not meaningful without a real tty.
     fn attach(&self, term: Option<String>, detach_keys: Option<String>) -> Result<i32, Error> {
-        let inner = Arc::clone(&self.inner);
+        let inner = Arc::clone(self.inner.get()?);
         let result: MicrosandboxResult<i32> = block_on(async move {
             let guard = inner.lock().await;
             let client = guard.as_ref().ok_or_else(consumed)?;
@@ -80,7 +80,7 @@ impl SshClient {
 
     /// Open an SFTP session over this SSH connection.
     fn sftp(&self) -> Result<SftpClient, Error> {
-        let inner = Arc::clone(&self.inner);
+        let inner = Arc::clone(self.inner.get()?);
         let result: MicrosandboxResult<CoreSftp> = block_on(async move {
             let guard = inner.lock().await;
             let client = guard.as_ref().ok_or_else(consumed)?;
@@ -91,7 +91,7 @@ impl SshClient {
 
     /// Close the SSH client session. Idempotent.
     fn close(&self) -> Result<(), Error> {
-        let inner = Arc::clone(&self.inner);
+        let inner = Arc::clone(self.inner.get()?);
         let result: MicrosandboxResult<()> = block_on(async move {
             let client = {
                 let mut guard = inner.lock().await;
@@ -122,7 +122,7 @@ fn ssh_output_to_hash(output: SshOutput) -> RHash {
 
 #[magnus::wrap(class = "Microsandbox::Native::SftpClient", free_immediately, size)]
 pub struct SftpClient {
-    inner: Arc<Mutex<Option<CoreSftp>>>,
+    inner: ForkGuarded<Arc<Mutex<Option<CoreSftp>>>>,
 }
 
 /// Format an SFTP-layer error as a plain string inside `block_on`; the Ruby
@@ -134,12 +134,15 @@ fn sftp_str(e: impl std::fmt::Display) -> String {
 impl SftpClient {
     pub fn from_core(inner: CoreSftp) -> Self {
         Self {
-            inner: Arc::new(Mutex::new(Some(inner))),
+            inner: ForkGuarded::new(
+                "Microsandbox::SftpClient",
+                Arc::new(Mutex::new(Some(inner))),
+            ),
         }
     }
 
     fn read(&self, path: String) -> Result<RString, Error> {
-        let inner = Arc::clone(&self.inner);
+        let inner = Arc::clone(self.inner.get()?);
         let result: Result<Vec<u8>, String> = block_on(async move {
             let guard = inner.lock().await;
             let sftp = guard.as_ref().ok_or_else(|| sftp_str("session closed"))?;
@@ -150,7 +153,7 @@ impl SftpClient {
 
     fn write(&self, path: String, data: RString) -> Result<(), Error> {
         let bytes = unsafe { data.as_slice() }.to_vec();
-        let inner = Arc::clone(&self.inner);
+        let inner = Arc::clone(self.inner.get()?);
         let result: Result<(), String> = block_on(async move {
             let guard = inner.lock().await;
             let sftp = guard.as_ref().ok_or_else(|| sftp_str("session closed"))?;
@@ -163,7 +166,7 @@ impl SftpClient {
     }
 
     fn mkdir(&self, path: String) -> Result<(), Error> {
-        let inner = Arc::clone(&self.inner);
+        let inner = Arc::clone(self.inner.get()?);
         let result: Result<(), String> = block_on(async move {
             let guard = inner.lock().await;
             let sftp = guard.as_ref().ok_or_else(|| sftp_str("session closed"))?;
@@ -173,7 +176,7 @@ impl SftpClient {
     }
 
     fn remove_file(&self, path: String) -> Result<(), Error> {
-        let inner = Arc::clone(&self.inner);
+        let inner = Arc::clone(self.inner.get()?);
         let result: Result<(), String> = block_on(async move {
             let guard = inner.lock().await;
             let sftp = guard.as_ref().ok_or_else(|| sftp_str("session closed"))?;
@@ -183,7 +186,7 @@ impl SftpClient {
     }
 
     fn remove_dir(&self, path: String) -> Result<(), Error> {
-        let inner = Arc::clone(&self.inner);
+        let inner = Arc::clone(self.inner.get()?);
         let result: Result<(), String> = block_on(async move {
             let guard = inner.lock().await;
             let sftp = guard.as_ref().ok_or_else(|| sftp_str("session closed"))?;
@@ -193,7 +196,7 @@ impl SftpClient {
     }
 
     fn rename(&self, old_path: String, new_path: String) -> Result<(), Error> {
-        let inner = Arc::clone(&self.inner);
+        let inner = Arc::clone(self.inner.get()?);
         let result: Result<(), String> = block_on(async move {
             let guard = inner.lock().await;
             let sftp = guard.as_ref().ok_or_else(|| sftp_str("session closed"))?;
@@ -203,7 +206,7 @@ impl SftpClient {
     }
 
     fn symlink(&self, target: String, link_path: String) -> Result<(), Error> {
-        let inner = Arc::clone(&self.inner);
+        let inner = Arc::clone(self.inner.get()?);
         let result: Result<(), String> = block_on(async move {
             let guard = inner.lock().await;
             let sftp = guard.as_ref().ok_or_else(|| sftp_str("session closed"))?;
@@ -213,7 +216,7 @@ impl SftpClient {
     }
 
     fn real_path(&self, path: String) -> Result<String, Error> {
-        let inner = Arc::clone(&self.inner);
+        let inner = Arc::clone(self.inner.get()?);
         let result: Result<String, String> = block_on(async move {
             let guard = inner.lock().await;
             let sftp = guard.as_ref().ok_or_else(|| sftp_str("session closed"))?;
@@ -223,7 +226,7 @@ impl SftpClient {
     }
 
     fn read_link(&self, path: String) -> Result<String, Error> {
-        let inner = Arc::clone(&self.inner);
+        let inner = Arc::clone(self.inner.get()?);
         let result: Result<String, String> = block_on(async move {
             let guard = inner.lock().await;
             let sftp = guard.as_ref().ok_or_else(|| sftp_str("session closed"))?;
@@ -233,7 +236,7 @@ impl SftpClient {
     }
 
     fn close(&self) -> Result<(), Error> {
-        let inner = Arc::clone(&self.inner);
+        let inner = Arc::clone(self.inner.get()?);
         let result: Result<(), String> = block_on(async move {
             let sftp = {
                 let mut guard = inner.lock().await;
@@ -254,19 +257,19 @@ impl SftpClient {
 
 #[magnus::wrap(class = "Microsandbox::Native::SshServer", free_immediately, size)]
 pub struct SshServer {
-    inner: Arc<Mutex<Option<CoreSshServer>>>,
+    inner: ForkGuarded<Arc<Mutex<Option<CoreSshServer>>>>,
 }
 
 impl SshServer {
     pub fn from_core(inner: CoreSshServer) -> Self {
         Self {
-            inner: Arc::new(Mutex::new(Some(inner))),
+            inner: ForkGuarded::new("Microsandbox::SshServer", Arc::new(Mutex::new(Some(inner)))),
         }
     }
 
     /// Serve one SSH connection over this process's stdin/stdout.
     fn serve_connection(&self) -> Result<(), Error> {
-        let inner = Arc::clone(&self.inner);
+        let inner = Arc::clone(self.inner.get()?);
         let result: MicrosandboxResult<()> = block_on(async move {
             let server = {
                 let guard = inner.lock().await;
@@ -282,7 +285,7 @@ impl SshServer {
 
     /// Release the prepared server endpoint. Idempotent.
     fn close(&self) -> Result<(), Error> {
-        let inner = Arc::clone(&self.inner);
+        let inner = Arc::clone(self.inner.get()?);
         block_on(async move {
             inner.lock().await.take();
         })?;

data/ext/microsandbox/src/stream.rs

@@ -18,14 +18,14 @@ use microsandbox::MicrosandboxResult;
 use tokio::sync::Mutex;
 
 use crate::error;
-use crate::runtime::block_on;
+use crate::runtime::{block_on, ForkGuarded};
 use crate::sandbox::{log_entry_to_hash, metrics_to_hash};
 
 type BoxStream<T> = Pin<Box<dyn Stream<Item = MicrosandboxResult<T>> + Send>>;
 
 #[magnus::wrap(class = "Microsandbox::Native::LogStream", free_immediately, size)]
 pub struct LogStream {
-    inner: Arc<Mutex<BoxStream<LogEntry>>>,
+    inner: ForkGuarded<Arc<Mutex<BoxStream<LogEntry>>>>,
 }
 
 impl LogStream {
@@ -33,14 +33,17 @@ impl LogStream {
         stream: impl Stream<Item = MicrosandboxResult<LogEntry>> + Send + 'static,
     ) -> Self {
         Self {
-            inner: Arc::new(Mutex::new(Box::pin(stream))),
+            inner: ForkGuarded::new(
+                "Microsandbox::LogStream",
+                Arc::new(Mutex::new(Box::pin(stream))),
+            ),
         }
     }
 
     /// Next log entry as a Hash, or nil when the stream ends.
     fn recv(&self) -> Result<Option<RHash>, Error> {
         use futures::StreamExt;
-        let inner = Arc::clone(&self.inner);
+        let inner = Arc::clone(self.inner.get()?);
         match block_on(async move { inner.lock().await.next().await })? {
             Some(Ok(entry)) => Ok(Some(log_entry_to_hash(&entry))),
             Some(Err(e)) => Err(error::to_ruby(e)),
@@ -51,7 +54,7 @@ impl LogStream {
 
 #[magnus::wrap(class = "Microsandbox::Native::MetricsStream", free_immediately, size)]
 pub struct MetricsStream {
-    inner: Arc<Mutex<BoxStream<SandboxMetrics>>>,
+    inner: ForkGuarded<Arc<Mutex<BoxStream<SandboxMetrics>>>>,
 }
 
 impl MetricsStream {
@@ -59,14 +62,17 @@ impl MetricsStream {
         stream: impl Stream<Item = MicrosandboxResult<SandboxMetrics>> + Send + 'static,
     ) -> Self {
         Self {
-            inner: Arc::new(Mutex::new(Box::pin(stream))),
+            inner: ForkGuarded::new(
+                "Microsandbox::MetricsStream",
+                Arc::new(Mutex::new(Box::pin(stream))),
+            ),
         }
     }
 
     /// Next metrics snapshot as a Hash, or nil when the stream ends.
     fn recv(&self) -> Result<Option<RHash>, Error> {
         use futures::StreamExt;
-        let inner = Arc::clone(&self.inner);
+        let inner = Arc::clone(self.inner.get()?);
         match block_on(async move { inner.lock().await.next().await })? {
             Some(Ok(metrics)) => Ok(Some(metrics_to_hash(&metrics))),
             Some(Err(e)) => Err(error::to_ruby(e)),

data/ext/microsandbox/src/volume.rs

@@ -12,7 +12,7 @@ use microsandbox::{Backend, MicrosandboxError};
 
 use crate::conv;
 use crate::error;
-use crate::runtime::{block_on, ruby};
+use crate::runtime::{block_on, ruby, ForkGuarded};
 use crate::sandbox::{fs_entry_to_hash, fs_metadata_to_hash};
 
 fn handle_to_hash(h: &VolumeHandle) -> RHash {
@@ -128,7 +128,9 @@ fn contained(path: &str) -> Result<&str, Error> {
 /// each operation rebuilds it from the stored backend + name.
 #[magnus::wrap(class = "Microsandbox::Native::VolumeFs", free_immediately, size)]
 pub struct VolumeFs {
-    backend: Arc<dyn Backend>,
+    /// The backend this view is bound to — a clone of the creating process's
+    /// default backend, so it must not cross a fork.
+    backend: ForkGuarded<Arc<dyn Backend>>,
     name: String,
 }
 
@@ -138,40 +140,44 @@ impl VolumeFs {
     /// trait, which yields precise per-operation `Unsupported` errors on
     /// backends that can't serve it — no local-only downcast needed here.
     fn for_volume(name: String) -> Result<VolumeFs, Error> {
+        crate::backend::ensure_this_process_backend()?;
         Ok(VolumeFs {
-            backend: microsandbox::default_backend(),
+            backend: ForkGuarded::new("Microsandbox::VolumeFs", microsandbox::default_backend()),
             name,
         })
     }
 
-    fn fs(&self) -> microsandbox::volume::VolumeFs<'_> {
-        microsandbox::volume::VolumeFs::with_backend(self.backend.clone(), &self.name)
+    fn fs(&self) -> Result<microsandbox::volume::VolumeFs<'_>, Error> {
+        let backend = self.backend.get()?.clone();
+        Ok(microsandbox::volume::VolumeFs::with_backend(
+            backend, &self.name,
+        ))
     }
 
     fn read(&self, path: String) -> Result<RString, Error> {
+        let fs = self.fs()?;
         let path = contained(&path)?;
-        let fs = self.fs();
         let bytes = block_on(fs.read(path))?.map_err(error::to_ruby)?;
         Ok(ruby().str_from_slice(bytes.as_ref()))
     }
 
     fn read_text(&self, path: String) -> Result<String, Error> {
+        let fs = self.fs()?;
         let path = contained(&path)?;
-        let fs = self.fs();
         block_on(fs.read_to_string(path))?.map_err(error::to_ruby)
     }
 
     fn write(&self, path: String, data: RString) -> Result<(), Error> {
         // Copy the bytes out while the GVL is held (GC.compact could move them).
         let bytes = unsafe { data.as_slice() }.to_vec();
+        let fs = self.fs()?;
         let path = contained(&path)?;
-        let fs = self.fs();
         block_on(fs.write(path, &bytes))?.map_err(error::to_ruby)
     }
 
     fn list(&self, path: String) -> Result<RArray, Error> {
+        let fs = self.fs()?;
         let path = contained(&path)?;
-        let fs = self.fs();
         let entries = block_on(fs.list(path))?.map_err(error::to_ruby)?;
         let arr = ruby().ary_new();
         for entry in &entries {
@@ -181,46 +187,46 @@ impl VolumeFs {
     }
 
     fn mkdir(&self, path: String) -> Result<(), Error> {
+        let fs = self.fs()?;
         let path = contained(&path)?;
-        let fs = self.fs();
         block_on(fs.mkdir(path))?.map_err(error::to_ruby)
     }
 
     fn remove_file(&self, path: String) -> Result<(), Error> {
+        let fs = self.fs()?;
         let path = contained(&path)?;
-        let fs = self.fs();
         block_on(fs.remove(path))?.map_err(error::to_ruby)
     }
 
     fn remove_dir(&self, path: String) -> Result<(), Error> {
+        let fs = self.fs()?;
         let path = contained(&path)?;
-        let fs = self.fs();
         block_on(fs.remove_dir(path))?.map_err(error::to_ruby)
     }
 
     fn exists(&self, path: String) -> Result<bool, Error> {
+        let fs = self.fs()?;
         let path = contained(&path)?;
-        let fs = self.fs();
         block_on(fs.exists(path))?.map_err(error::to_ruby)
     }
 
     fn copy(&self, from: String, to: String) -> Result<(), Error> {
+        let fs = self.fs()?;
         let from = contained(&from)?;
         let to = contained(&to)?;
-        let fs = self.fs();
         block_on(fs.copy(from, to))?.map_err(error::to_ruby)
     }
 
     fn rename(&self, from: String, to: String) -> Result<(), Error> {
+        let fs = self.fs()?;
         let from = contained(&from)?;
         let to = contained(&to)?;
-        let fs = self.fs();
         block_on(fs.rename(from, to))?.map_err(error::to_ruby)
     }
 
     fn stat(&self, path: String) -> Result<RHash, Error> {
+        let fs = self.fs()?;
         let path = contained(&path)?;
-        let fs = self.fs();
         let meta = block_on(fs.stat(path))?.map_err(error::to_ruby)?;
         Ok(fs_metadata_to_hash(&meta))
     }

data/lib/microsandbox/errors.rb

@@ -102,6 +102,14 @@ module Microsandbox
   define_error(:CloudHttpError, "cloud-http")
   define_error(:UnsupportedError, "unsupported")
 
+  # Process model ------------------------------------------------------------
+  # A handle (a Sandbox, a SandboxHandle, an ExecHandle, a stream, an SSH or
+  # agent client, a VolumeFs, ...) was used in a process forked from the one
+  # that created it. Handles are bound to their creating process; a forked
+  # child opens its own (`Sandbox.get(name).connect`, `Volume.fs(name)`, ...).
+  # The message names both pids. Ruby-only: no other SDK has a counterpart.
+  define_error(:ForkedHandleError, "forked-handle")
+
   # As of runtime v0.6.8 the core keys Unsupported errors by a structured
   # (operation, reason) pair. The native layer renders both into the message
   # ("sandbox.kill is not supported by this backend: ...") and also attaches

data/lib/microsandbox/version.rb

@@ -8,7 +8,7 @@ module Microsandbox
   # Versioning section of the README for the full gem-to-runtime map. Must equal
   # the native ext's Cargo crate version (`Native.version`), enforced by
   # spec/unit/version_spec.rb.
-  VERSION = "0.17.2"
+  VERSION = "0.17.3"
 
   # The upstream microsandbox runtime release this gem build embeds — the `tag`
   # pinned on the `microsandbox`/`microsandbox-network` git deps in

data/lib/microsandbox.rb

@@ -240,6 +240,15 @@ module Microsandbox
     # avoid calling {set_default_backend} inside the block (the restore on exit
     # would overwrite that change). Mirrors the official SDKs' scoped-backend helper.
     #
+    # The restore can fail in one situation: the previous backend belonged to a
+    # parent process (the block is left in a child forked while it was running,
+    # or it is a forked child's first use of the SDK) and cannot be chosen
+    # again there — it came from the environment or config file, which no
+    # longer resolve. The block's temporary selection then stays in effect. If
+    # the block itself raised, its exception is the one that propagates and the
+    # restore failure is only warned about; otherwise the restore failure is
+    # raised.
+    #
     # @param kind ["local","cloud", Symbol]
     # @param url [String, nil]
     # @param api_key [String, nil]
@@ -248,10 +257,20 @@ module Microsandbox
     # @return [Object] the block's return value
     def with_backend(kind, url: nil, api_key: nil, profile: nil)
       token = Native.push_default_backend(kind.to_s, url&.to_s, api_key&.to_s, profile&.to_s)
+      raised = false
       begin
         yield
+      rescue Exception # standard:disable Lint/RescueException -- only noted, re-raised at once
+        raised = true
+        raise
       ensure
-        Native.pop_default_backend(token)
+        begin
+          Native.pop_default_backend(token)
+        rescue Microsandbox::Error => e
+          # Never let the restore failure replace what the block raised.
+          raise unless raised
+          warn "microsandbox: with_backend could not restore the previous backend: #{e.message}"
+        end
       end
     end
 

data/sig/microsandbox.rbs

@@ -64,6 +64,7 @@ module Microsandbox
   class MetricsUnavailableError < Error end
   class UnsupportedOperationError < Error end
   class CloudHttpError < Error end
+  class ForkedHandleError < Error end
   class UnsupportedError < Error
     def operation: () -> String?
     def hint: () -> String?

metadata

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