microsandbox-rb 0.5.8 → 0.5.10

data/ext/microsandbox/src/image.rs

@@ -8,8 +8,8 @@
 use magnus::{function, prelude::*, Error, RArray, RHash, RModule, Ruby};
 use microsandbox::image::{Image, ImageDetail, ImageHandle, ImagePruneReport};
 
-use crate::error;
-use crate::runtime::{block_on, ruby};
+use crate::backend::with_local_backend;
+use crate::runtime::ruby;
 
 fn handle_to_hash(h: &ImageHandle) -> RHash {
     let hash = ruby().hash_new();
@@ -76,12 +76,12 @@ fn report_to_hash(report: ImagePruneReport) -> RHash {
 }
 
 fn get(reference: String) -> Result<RHash, Error> {
-    let handle = block_on(Image::get(&reference)).map_err(error::to_ruby)?;
+    let handle = with_local_backend(async |local| Image::get(local, &reference).await)?;
     Ok(handle_to_hash(&handle))
 }
 
 fn list() -> Result<RArray, Error> {
-    let handles = block_on(Image::list()).map_err(error::to_ruby)?;
+    let handles = with_local_backend(async |local| Image::list(local).await)?;
     let arr = ruby().ary_new();
     for h in handles.iter() {
         arr.push(handle_to_hash(h))?;
@@ -90,16 +90,16 @@ fn list() -> Result<RArray, Error> {
 }
 
 fn inspect(reference: String) -> Result<RHash, Error> {
-    let detail = block_on(Image::inspect(&reference)).map_err(error::to_ruby)?;
+    let detail = with_local_backend(async |local| Image::inspect(local, &reference).await)?;
     Ok(detail_to_hash(detail))
 }
 
 fn remove(reference: String, force: bool) -> Result<(), Error> {
-    block_on(Image::remove(&reference, force)).map_err(error::to_ruby)
+    with_local_backend(async |local| Image::remove(local, &reference, force).await)
 }
 
 fn prune() -> Result<RHash, Error> {
-    let report = block_on(Image::prune()).map_err(error::to_ruby)?;
+    let report = with_local_backend(async |local| Image::prune(local).await)?;
     Ok(report_to_hash(report))
 }
 

data/ext/microsandbox/src/lib.rs

@@ -8,6 +8,8 @@
 //! Everything here lives under `Microsandbox::Native`; the ergonomic, idiomatic
 //! surface is the pure-Ruby layer in `lib/microsandbox/`.
 
+mod agent;
+mod backend;
 mod conv;
 mod error;
 mod exec;
@@ -15,6 +17,7 @@ mod image;
 mod runtime;
 mod sandbox;
 mod snapshot;
+mod ssh;
 mod stream;
 mod volume;
 
@@ -29,8 +32,9 @@ fn version() -> String {
 /// Ruby Hash. Mirrors the official `all_sandbox_metrics` / `allSandboxMetrics`
 /// helpers (Python/Node/Go).
 fn all_sandbox_metrics() -> Result<RHash, Error> {
-    let map =
-        runtime::block_on(microsandbox::sandbox::all_sandbox_metrics()).map_err(error::to_ruby)?;
+    let map = backend::with_local_backend(async |local| {
+        microsandbox::sandbox::all_sandbox_metrics(local).await
+    })?;
     let hash = runtime::ruby().hash_new();
     for (name, metrics) in &map {
         hash.aset(name.as_str(), sandbox::metrics_to_hash(metrics))?;
@@ -53,9 +57,25 @@ fn set_runtime_msb_path(path: String) {
     microsandbox::config::set_sdk_msb_path(path);
 }
 
-/// The currently-resolved `msb` runtime path.
+/// Override the resolved `libkrunfw` path (SDK tier of the resolver). Set-once
+/// per process; the `MSB_LIBKRUNFW_PATH` env var still takes precedence. Mirrors
+/// `set_runtime_msb_path` for the libkrunfw shared library.
+fn set_runtime_libkrunfw_path(path: String) {
+    microsandbox::config::set_sdk_libkrunfw_path(path);
+}
+
+/// The currently-resolved `msb` runtime path. Synchronous (filesystem probes,
+/// no async) — runs on the Ruby thread; resolves the path from the local
+/// backend's config.
 fn resolved_msb_path() -> Result<String, Error> {
-    let path = microsandbox::config::resolve_msb_path().map_err(error::to_ruby)?;
+    let backend = microsandbox::default_backend();
+    let local = backend.as_local().ok_or_else(|| {
+        error::to_ruby(microsandbox::MicrosandboxError::Unsupported {
+            feature: "resolved_msb_path requires a local backend".into(),
+            available_when: "with the local backend".into(),
+        })
+    })?;
+    let path = microsandbox::config::resolve_msb_path(local.config()).map_err(error::to_ruby)?;
     Ok(path.to_string_lossy().into_owned())
 }
 
@@ -70,15 +90,22 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     native.define_singleton_method("install", function!(install, 0))?;
     native.define_singleton_method("installed?", function!(is_installed, 0))?;
     native.define_singleton_method("set_runtime_msb_path", function!(set_runtime_msb_path, 1))?;
+    native.define_singleton_method(
+        "set_runtime_libkrunfw_path",
+        function!(set_runtime_libkrunfw_path, 1),
+    )?;
     native.define_singleton_method("resolved_msb_path", function!(resolved_msb_path, 0))?;
     native.define_singleton_method("all_sandbox_metrics", function!(all_sandbox_metrics, 0))?;
 
+    backend::define(ruby, &native)?;
     sandbox::define(ruby, &native)?;
     exec::define(ruby, &native)?;
     stream::define(ruby, &native)?;
     snapshot::define(ruby, &native)?;
     image::define(ruby, &native)?;
     volume::define(ruby, &native)?;
+    agent::define(ruby, &native)?;
+    ssh::define(ruby, &native)?;
 
     Ok(())
 }