omq-backend-rust 0.1.7 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b22c5a39d466ddff0ea811bfadff93fe58e64c3ea08bb213f61419e5efd13cc6
-  data.tar.gz: '09ef0d2306516c3809a957f61e234360d9f2bbe34b0389cf874c8d5cdc87abc8'
+  metadata.gz: ec3e72f8903532375903dac4637b6f4ebc1c9b09a0f2d1d1475420797464e800
+  data.tar.gz: d4cb76d8140f6f10d3b4eda7f9f720a7901407dcf0ea45da3e7a48989a137ca4
 SHA512:
-  metadata.gz: bae7c0181f01e714d3fbbb11546bb84dc6642d77661734e5d5eaa5467af153a5437b0a9af1ff0d1b8f894609928d7952a83bcb492ef299e327253acdc6a1f85d
-  data.tar.gz: b787de3962b49bf2c784596f8fd82901e0323e74270915ba051359eb73a46022389726cea92b1a6364c7780eaf296a457d8355d90507503a5690f4de4de8410b
+  metadata.gz: 5921c0fcc3fd18908cbc142ae481aa4e61d8005ab68f2ebc61fd316f65089f8d6453acddb76e073a2c06e0a47581900878a47d5c0dc2b7899bb2bd815a500fec
+  data.tar.gz: 7401afef781cc1000b175dd1e28f89241e2002abfc0a415d8bedd1d5a341398dce599574a6ced626f17a8c94ab3add861699f254e4f32a2d8f439322add19272

data/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 ## [Unreleased]
 
+## [0.2.0] - 2026-08-08
+
+### Added
+
+- Added TruffleRuby support for the Rust backend.
+- Added a shared fallback file descriptor watcher for Rubies without a
+  native `Fiber.scheduler`.
+- Added TruffleRuby CI coverage for the Rust backend.
+
+### Changed
+
+- Updated to `omq-tokio` 0.21.1 and `omq-proto` 0.25.1.
+- Replaced Magnus with a small `rb-sys` helper layer that uses public
+  Ruby C API calls.
+
+### Fixed
+
+- Raised Ruby exceptions through public C API entry points for
+  TruffleRuby compatibility.
+- Rejected invalid negative numeric options before they can overflow Rust
+  sizes or panic on invalid durations.
+
 ## [0.1.7] - 2026-08-02
 
 ### Added

data/ext/omq_backend_rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name    = "omq_backend_rust"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2024"
 license = "ISC"
 authors = ["Patrik Wenger <paddor@gmail.com>"]
@@ -18,15 +18,14 @@ lz4     = ["omq-tokio/lz4"]
 zstd    = ["omq-tokio/zstd"]
 
 [dependencies]
-omq-proto = { version = "=0.25.0", default-features = false }
-omq-tokio = { version = "=0.21.0", default-features = false }
+omq-proto = { version = "=0.25.1", default-features = false }
+omq-tokio = { version = "=0.21.1", default-features = false }
 tokio     = { version = "1.52.0", features = ["rt", "rt-multi-thread", "time", "sync", "io-util", "net"] }
 yring     = { version = "0.3.11", features = ["async"] }
 
 bytes   = "1.12.0"
 flume   = { version = "0.12", default-features = false, features = ["async"] }
 futures = { version = "0.3", default-features = false, features = ["std", "async-await"] }
-magnus  = "0.8"
 rb-sys  = "0.9"
 libc    = "0.2"
 

data/ext/omq_backend_rust/build.rs

@@ -0,0 +1,23 @@
+use std::process::Command;
+
+fn main() {
+    println!("cargo:rerun-if-env-changed=RUBY");
+    println!("cargo:rustc-check-cfg=cfg(ruby_engine, values(\"mri\", \"truffleruby\"))");
+
+    let ruby = std::env::var("RUBY").unwrap_or_else(|_| "ruby".to_string());
+    let output = Command::new(&ruby)
+        .arg("-rrbconfig")
+        .arg("-e")
+        .arg("print RbConfig::CONFIG.fetch('ruby_install_name')")
+        .output()
+        .unwrap_or_else(|err| panic!("failed to run {ruby}: {err}"));
+
+    if !output.status.success() {
+        panic!("failed to query Ruby engine with {ruby}");
+    }
+
+    match String::from_utf8_lossy(&output.stdout).trim() {
+        "truffleruby" => println!("cargo:rustc-cfg=ruby_engine=\"truffleruby\""),
+        _ => println!("cargo:rustc-cfg=ruby_engine=\"mri\""),
+    }
+}

data/ext/omq_backend_rust/src/error.rs

@@ -1,15 +1,16 @@
-use magnus::{Error, Ruby};
 use omq_proto::error::Error as OmqError;
 
-pub fn map_err(ruby: &Ruby, e: OmqError) -> Error {
+use crate::rb::RubyErr;
+
+pub fn map_err(e: OmqError) -> RubyErr {
     match e {
-        OmqError::Closed => Error::new(ruby.exception_io_error(), "socket closed"),
-        OmqError::Timeout => Error::new(ruby.exception_runtime_error(), "operation timed out"),
-        OmqError::Unroutable => Error::new(ruby.exception_runtime_error(), "no route to peer"),
-        OmqError::InvalidEndpoint(msg) => Error::new(ruby.exception_arg_error(), msg),
-        OmqError::Protocol(msg) => Error::new(ruby.exception_runtime_error(), msg),
-        OmqError::Io(e) => Error::new(ruby.exception_runtime_error(), e.to_string()),
-        OmqError::HandshakeFailed(msg) => Error::new(ruby.exception_runtime_error(), msg),
-        _ => Error::new(ruby.exception_runtime_error(), format!("{e}")),
+        OmqError::Closed => RubyErr::io("socket closed"),
+        OmqError::Timeout => RubyErr::runtime("operation timed out"),
+        OmqError::Unroutable => RubyErr::runtime("no route to peer"),
+        OmqError::InvalidEndpoint(msg) => RubyErr::arg(msg),
+        OmqError::Protocol(msg) => RubyErr::runtime(msg),
+        OmqError::Io(e) => RubyErr::runtime(e.to_string()),
+        OmqError::HandshakeFailed(msg) => RubyErr::runtime(msg),
+        _ => RubyErr::runtime(format!("{e}")),
     }
 }

data/ext/omq_backend_rust/src/lib.rs

@@ -1,26 +1,51 @@
 mod error;
 mod notify;
 mod options;
+mod rb;
 mod runtime;
 mod socket;
 
-use magnus::{Error, Ruby, function, prelude::*};
+use rb_sys::VALUE;
 
-fn set_io_threads(n: usize) {
+use crate::rb::{RbResult, RubyErr};
+
+fn set_io_threads_impl(n: VALUE) -> RbResult<VALUE> {
+    let n = rb::value_to_i64(n)?;
+    if n < 0 {
+        return Err(RubyErr::arg("io_threads must be non-negative"));
+    }
+    let n = usize::try_from(n).map_err(|_| RubyErr::arg("io_threads too large"))?;
     socket::set_io_threads(n);
+    Ok(rb::qnil())
+}
+
+unsafe extern "C" fn set_io_threads(_module: VALUE, n: VALUE) -> VALUE {
+    rb::wrap(|| set_io_threads_impl(n))
+}
+
+#[unsafe(no_mangle)]
+/// # Safety
+///
+/// Ruby calls this once while loading the native extension.
+pub unsafe extern "C" fn Init_omq_backend_rust() {
+    rb::wrap_init(init);
 }
 
-#[magnus::init]
-fn init(ruby: &Ruby) -> Result<(), Error> {
-    unsafe { rb_sys::rb_ext_ractor_safe(true) };
+fn init() -> RbResult<()> {
+    #[cfg(ruby_engine = "mri")]
+    unsafe {
+        rb_sys::rb_ext_ractor_safe(true);
+    }
 
-    let omq = ruby.define_module("OMQ")?;
-    let rust = omq.define_module("Rust")?;
-    let native = rust.define_module("Native")?;
+    let omq = unsafe { rb::define_module(c"OMQ")? };
+    let rust = unsafe { rb::define_module_under(omq, c"Rust")? };
+    let native = unsafe { rb::define_module_under(rust, c"Native")? };
 
-    native.define_module_function("io_threads=", function!(set_io_threads, 1))?;
+    unsafe {
+        rb::define_module_function_1(native, c"io_threads=", set_io_threads)?;
+    }
 
-    socket::register(ruby)?;
+    socket::register(native)?;
 
     Ok(())
 }

data/ext/omq_backend_rust/src/options.rs

@@ -1,129 +1,124 @@
 use std::time::Duration;
 
 use bytes::Bytes;
-use magnus::{Error, Ruby, TryConvert, r_hash::RHash, value::ReprValue};
 
-pub fn build_options(ruby: &Ruby, hash: RHash) -> Result<omq_tokio::Options, Error> {
+use rb_sys::VALUE;
+
+use crate::rb::{self, RbResult, RubyErr};
+
+pub fn build_options(hash: VALUE) -> RbResult<omq_tokio::Options> {
+    rb::check_hash(hash)?;
+
     let mut opts = omq_tokio::Options::default();
 
-    if let Some(v) = get_opt::<i64>(ruby, hash, "send_hwm")? {
+    if let Some(v) = get_opt_i64(hash, "send_hwm")? {
         opts.send_hwm = v.max(0) as u32;
     }
-    if let Some(v) = get_opt::<i64>(ruby, hash, "recv_hwm")? {
+    if let Some(v) = get_opt_i64(hash, "recv_hwm")? {
         opts.recv_hwm = v.max(0) as u32;
     }
-    if let Some(v) = get_opt::<f64>(ruby, hash, "linger")? {
-        opts.linger = if v.is_infinite() {
+    if let Some(v) = get_opt_f64(hash, "linger")? {
+        opts.linger = if v.is_infinite() && v.is_sign_positive() {
             None
         } else {
-            Some(Duration::from_secs_f64(v))
+            Some(duration_from_seconds("linger", v)?)
         };
     }
-    if let Some(v) = get_opt_bytes(ruby, hash, "identity")? {
-        if !v.is_empty() {
-            opts.identity = Bytes::from(v);
-        }
+    if let Some(v) = get_opt_bytes(hash, "identity")?
+        && !v.is_empty()
+    {
+        opts.identity = Bytes::from(v);
     }
-    if let Some(v) = get_opt::<bool>(ruby, hash, "router_mandatory")? {
+    if let Some(v) = get_opt_bool(hash, "router_mandatory")? {
         opts.router_mandatory = v;
     }
-    if let Some(v) = get_opt::<bool>(ruby, hash, "conflate")? {
+    if let Some(v) = get_opt_bool(hash, "conflate")? {
         opts.conflate = v;
     }
-    if let Some(v) = get_opt_duration(ruby, hash, "heartbeat_interval")? {
+    if let Some(v) = get_opt_duration(hash, "heartbeat_interval")? {
         opts.heartbeat_interval = Some(v);
     }
-    if let Some(v) = get_opt_duration(ruby, hash, "heartbeat_ttl")? {
+    if let Some(v) = get_opt_duration(hash, "heartbeat_ttl")? {
         opts.heartbeat_ttl = Some(v);
     }
-    if let Some(v) = get_opt_duration(ruby, hash, "heartbeat_timeout")? {
+    if let Some(v) = get_opt_duration(hash, "heartbeat_timeout")? {
         opts.heartbeat_timeout = Some(v);
     }
-    if let Some(v) = get_opt::<i64>(ruby, hash, "max_message_size")? {
-        opts.max_message_size = Some(v as usize);
+    if let Some(v) = get_opt_usize(hash, "max_message_size")? {
+        opts.max_message_size = Some(v);
     }
-    if let Some(v) = get_opt::<i64>(ruby, hash, "sndbuf")? {
-        opts.send_buffer_size = Some(v as usize);
+    if let Some(v) = get_opt_usize(hash, "sndbuf")? {
+        opts.send_buffer_size = Some(v);
     }
-    if let Some(v) = get_opt::<i64>(ruby, hash, "rcvbuf")? {
-        opts.recv_buffer_size = Some(v as usize);
+    if let Some(v) = get_opt_usize(hash, "rcvbuf")? {
+        opts.recv_buffer_size = Some(v);
     }
-    if let Some(v) = get_opt_bytes(ruby, hash, "compression_dict")? {
-        if !v.is_empty() {
-            opts.compression_dict = Some(Bytes::from(v));
-        }
+    if let Some(v) = get_opt_bytes(hash, "compression_dict")?
+        && !v.is_empty()
+    {
+        opts.compression_dict = Some(Bytes::from(v));
     }
-    if let Some(v) = get_opt::<bool>(ruby, hash, "compression_auto_train")? {
+    if let Some(v) = get_opt_bool(hash, "compression_auto_train")? {
         opts.compression_auto_train = v;
     }
-    if let Some(v) = get_opt::<i64>(ruby, hash, "compression_threshold")? {
-        opts.compression_threshold = Some(v as usize);
+    if let Some(v) = get_opt_usize(hash, "compression_threshold")? {
+        opts.compression_threshold = Some(v);
     }
-    if let Some(v) = get_opt::<i64>(ruby, hash, "compression_level")? {
+    if let Some(v) = get_opt_i64(hash, "compression_level")? {
         opts.compression_level = Some(v as i32);
     }
-    if let Some(v) = get_opt::<i64>(ruby, hash, "compression_dict_capacity")? {
-        opts.compression_dict_capacity = Some(v as usize);
+    if let Some(v) = get_opt_usize(hash, "compression_dict_capacity")? {
+        opts.compression_dict_capacity = Some(v);
     }
-    if let Some(v) = get_opt::<i64>(ruby, hash, "max_recv_dict_size")? {
-        opts.max_recv_dict_size = Some(v as usize);
+    if let Some(v) = get_opt_usize(hash, "max_recv_dict_size")? {
+        opts.max_recv_dict_size = Some(v);
     }
-    if let Some(v) = get_opt::<i64>(ruby, hash, "compression_offload_threshold")? {
+    if let Some(v) = get_opt_i64(hash, "compression_offload_threshold")? {
         opts.compression_offload_threshold = if v < 0 { None } else { Some(v as usize) };
     }
-    if let Some(v) = get_opt::<String>(ruby, hash, "on_mute")? {
+    if let Some(v) = get_opt_string(hash, "on_mute")? {
         opts.on_mute = match v.as_str() {
             "drop_newest" | "drop" => omq_tokio::OnMute::DropNewest,
             _ => omq_tokio::OnMute::Block,
         };
     }
 
-    if let Some(v) = get_opt::<f64>(ruby, hash, "reconnect_interval")? {
-        opts.reconnect = omq_proto::options::ReconnectPolicy::Fixed(Duration::from_secs_f64(v));
-    }
-    if let Some(min) = get_opt::<f64>(ruby, hash, "reconnect_interval_min")? {
-        let max = get_opt::<f64>(ruby, hash, "reconnect_interval_max")?.unwrap_or(min * 16.0);
+    if let Some(v) = get_opt_f64(hash, "reconnect_interval")? {
+        opts.reconnect = omq_proto::options::ReconnectPolicy::Fixed(duration_from_seconds(
+            "reconnect_interval",
+            v,
+        )?);
+    }
+    if let Some(min) = get_opt_f64(hash, "reconnect_interval_min")? {
+        let max = get_opt_f64(hash, "reconnect_interval_max")?.unwrap_or(min * 16.0);
         opts.reconnect = omq_proto::options::ReconnectPolicy::Exponential {
-            min: Duration::from_secs_f64(min),
-            max: Duration::from_secs_f64(max),
+            min: duration_from_seconds("reconnect_interval min", min)?,
+            max: duration_from_seconds("reconnect_interval max", max)?,
         };
     }
 
-    if let Some(mech_type) = get_opt::<String>(ruby, hash, "mechanism_type")? {
-        apply_mechanism(ruby, hash, &mech_type, &mut opts)?;
+    if let Some(mech_type) = get_opt_string(hash, "mechanism_type")? {
+        apply_mechanism(hash, &mech_type, &mut opts)?;
     }
 
     Ok(opts)
 }
 
-fn apply_mechanism(
-    ruby: &Ruby,
-    hash: RHash,
-    mech_type: &str,
-    opts: &mut omq_tokio::Options,
-) -> Result<(), Error> {
+fn apply_mechanism(hash: VALUE, mech_type: &str, opts: &mut omq_tokio::Options) -> RbResult<()> {
     match mech_type {
         "null" => {}
 
         #[cfg(feature = "curve")]
         "curve" => {
-            let is_server = get_opt::<bool>(ruby, hash, "mechanism_server")?.unwrap_or(false);
-            let pub_key = get_opt_bytes(ruby, hash, "mechanism_public_key")?;
-            let sec_key = get_opt_bytes(ruby, hash, "mechanism_secret_key")?;
+            let is_server = get_opt_bool(hash, "mechanism_server")?.unwrap_or(false);
+            let pub_key = get_opt_bytes(hash, "mechanism_public_key")?;
+            let sec_key = get_opt_bytes(hash, "mechanism_secret_key")?;
 
             if is_server {
                 if let (Some(pk), Some(sk)) = (pub_key, sec_key) {
                     let keypair = omq_proto::CurveKeypair {
-                        public: omq_proto::CurvePublicKey::from_bytes(to_32(
-                            ruby,
-                            &pk,
-                            "public key",
-                        )?),
-                        secret: omq_proto::CurveSecretKey::from_bytes(to_32(
-                            ruby,
-                            &sk,
-                            "secret key",
-                        )?),
+                        public: omq_proto::CurvePublicKey::from_bytes(to_32(&pk, "public key")?),
+                        secret: omq_proto::CurveSecretKey::from_bytes(to_32(&sk, "secret key")?),
                     };
                     opts.mechanism = omq_proto::MechanismSetup::CurveServer {
                         our_keypair: keypair,
@@ -131,24 +126,15 @@ fn apply_mechanism(
                     };
                 }
             } else {
-                let srv_key = get_opt_bytes(ruby, hash, "mechanism_server_key")?;
+                let srv_key = get_opt_bytes(hash, "mechanism_server_key")?;
                 if let (Some(pk), Some(sk), Some(svk)) = (pub_key, sec_key, srv_key) {
                     let keypair = omq_proto::CurveKeypair {
-                        public: omq_proto::CurvePublicKey::from_bytes(to_32(
-                            ruby,
-                            &pk,
-                            "public key",
-                        )?),
-                        secret: omq_proto::CurveSecretKey::from_bytes(to_32(
-                            ruby,
-                            &sk,
-                            "secret key",
-                        )?),
+                        public: omq_proto::CurvePublicKey::from_bytes(to_32(&pk, "public key")?),
+                        secret: omq_proto::CurveSecretKey::from_bytes(to_32(&sk, "secret key")?),
                     };
                     opts.mechanism = omq_proto::MechanismSetup::CurveClient {
                         our_keypair: keypair,
                         server_public: omq_proto::CurvePublicKey::from_bytes(to_32(
-                            ruby,
                             &svk,
                             "server key",
                         )?),
@@ -162,46 +148,73 @@ fn apply_mechanism(
     Ok(())
 }
 
-fn to_32(ruby: &Ruby, bytes: &[u8], label: &str) -> Result<[u8; 32], Error> {
+fn to_32(bytes: &[u8], label: &str) -> RbResult<[u8; 32]> {
     bytes.try_into().map_err(|_| {
-        Error::new(
-            ruby.exception_arg_error(),
-            format!("{label} must be exactly 32 bytes, got {}", bytes.len()),
-        )
+        RubyErr::arg(format!(
+            "{label} must be exactly 32 bytes, got {}",
+            bytes.len()
+        ))
     })
 }
 
-fn get_opt_bytes(ruby: &Ruby, hash: RHash, key: &str) -> Result<Option<Vec<u8>>, Error> {
-    let k = ruby.str_new(key);
-    match hash.get(k) {
-        Some(v) => {
-            if v.is_nil() {
-                return Ok(None);
-            }
-            let s = magnus::r_string::RString::try_convert(v)?;
-            Ok(Some(unsafe { s.as_slice() }.to_vec()))
-        }
+fn get_opt_bytes(hash: VALUE, key: &str) -> RbResult<Option<Vec<u8>>> {
+    match rb::hash_get(hash, key)? {
+        Some(v) if v == rb::qnil() => Ok(None),
+        Some(v) => Ok(Some(rb::value_to_bytes(v)?)),
         None => Ok(None),
     }
 }
 
-fn get_opt<T: TryConvert>(ruby: &Ruby, hash: RHash, key: &str) -> Result<Option<T>, Error> {
-    let k = ruby.str_new(key);
-    match hash.get(k) {
-        Some(v) => {
-            if v.is_nil() {
-                Ok(None)
-            } else {
-                Ok(Some(T::try_convert(v)?))
-            }
-        }
+fn get_opt_string(hash: VALUE, key: &str) -> RbResult<Option<String>> {
+    match rb::hash_get(hash, key)? {
+        Some(v) if v == rb::qnil() => Ok(None),
+        Some(v) => Ok(Some(rb::value_to_string(v)?)),
+        None => Ok(None),
+    }
+}
+
+fn get_opt_i64(hash: VALUE, key: &str) -> RbResult<Option<i64>> {
+    match rb::hash_get(hash, key)? {
+        Some(v) if v == rb::qnil() => Ok(None),
+        Some(v) => Ok(Some(rb::value_to_i64(v)?)),
+        None => Ok(None),
+    }
+}
+
+fn get_opt_f64(hash: VALUE, key: &str) -> RbResult<Option<f64>> {
+    match rb::hash_get(hash, key)? {
+        Some(v) if v == rb::qnil() => Ok(None),
+        Some(v) => Ok(Some(rb::value_to_f64(v)?)),
+        None => Ok(None),
+    }
+}
+
+fn get_opt_usize(hash: VALUE, key: &str) -> RbResult<Option<usize>> {
+    let Some(v) = get_opt_i64(hash, key)? else {
+        return Ok(None);
+    };
+
+    usize::try_from(v)
+        .map(Some)
+        .map_err(|_| RubyErr::arg(format!("{key} must be non-negative")))
+}
+
+fn get_opt_bool(hash: VALUE, key: &str) -> RbResult<Option<bool>> {
+    match rb::hash_get(hash, key)? {
+        Some(v) if v == rb::qnil() => Ok(None),
+        Some(v) => Ok(Some(rb::value_to_bool(v)?)),
         None => Ok(None),
     }
 }
 
-fn get_opt_duration(ruby: &Ruby, hash: RHash, key: &str) -> Result<Option<Duration>, Error> {
-    match get_opt::<f64>(ruby, hash, key)? {
-        Some(v) => Ok(Some(Duration::from_secs_f64(v))),
+fn get_opt_duration(hash: VALUE, key: &str) -> RbResult<Option<Duration>> {
+    match get_opt_f64(hash, key)? {
+        Some(v) => Ok(Some(duration_from_seconds(key, v)?)),
         None => Ok(None),
     }
 }
+
+fn duration_from_seconds(label: &str, value: f64) -> RbResult<Duration> {
+    Duration::try_from_secs_f64(value)
+        .map_err(|_| RubyErr::arg(format!("{label} must be finite and non-negative")))
+}