omq-backend-rust 0.2.0 → 0.3.0

data/lib/omq/rust/java/platform.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+
+require_relative "../version"
+
+module OMQ
+  module Rust
+    module Java
+      class UnsupportedPlatformError < LoadError; end
+
+      class << self
+        def classifier
+          override = ENV.fetch("OMQ_JAVA_CLASSIFIER", "").strip
+          return validate_classifier(override) unless override.empty?
+
+          classifier_for(os_name: host_os_name, os_arch: host_os_arch)
+        end
+
+
+        def classifier_for(os_name:, os_arch:)
+          os   = normalize_os(os_name)
+          arch = normalize_arch(os_arch)
+
+          classifier = "#{os}-#{arch}" if os && arch
+          return classifier if OMQ::Rust::OMQ_JAVA_CLASSIFIERS.include?(classifier)
+
+          raise UnsupportedPlatformError,
+                "unsupported OMQ.java platform: #{os_name.inspect}/#{os_arch.inspect} " \
+                "(supported: #{OMQ::Rust::OMQ_JAVA_CLASSIFIERS.join(", ")})"
+        end
+
+
+        private
+
+
+        def validate_classifier(classifier)
+          return classifier if OMQ::Rust::OMQ_JAVA_CLASSIFIERS.include?(classifier)
+
+          raise UnsupportedPlatformError,
+                "unsupported OMQ.java classifier: #{classifier.inspect} " \
+                "(supported: #{OMQ::Rust::OMQ_JAVA_CLASSIFIERS.join(", ")})"
+        end
+
+
+        def host_os_name
+          java_system_property("os.name") ||
+            RbConfig::CONFIG["host_os"] ||
+            RbConfig::CONFIG["target_os"] ||
+            RUBY_PLATFORM
+        end
+
+
+        def host_os_arch
+          java_system_property("os.arch") ||
+            RbConfig::CONFIG["host_cpu"] ||
+            RbConfig::CONFIG["target_cpu"] ||
+            RUBY_PLATFORM
+        end
+
+
+        def java_system_property(name)
+          return unless RUBY_ENGINE == "jruby"
+
+          require "java"
+          ::Java::JavaLang::System.get_property(name)
+        rescue LoadError, NameError
+          nil
+        end
+
+
+        def normalize_os(value)
+          case value.to_s.downcase
+          when /linux/
+            "linux"
+          when /darwin|mac\s*os|macos/
+            "macos"
+          when /windows|mswin|mingw|cygwin/
+            "windows"
+          end
+        end
+
+
+        def normalize_arch(value)
+          case value.to_s.downcase
+          when "amd64", "x64", "x86-64", "x86_64"
+            "x86_64"
+          when "aarch64", "arm64"
+            "aarch64"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omq/rust/version.rb

@@ -1,7 +1,19 @@
 # frozen_string_literal: true
 
 module OMQ
+  module Backend
+    module Rust
+      VERSION = "0.3.0"
+    end
+  end
+
   module Rust
-    VERSION = "0.2.0"
+    OMQ_JAVA_VERSION = "0.3.0"
+    OMQ_JAVA_CLASSIFIERS = [
+      "linux-x86_64",
+      "macos-aarch64",
+      "macos-x86_64",
+      "windows-x86_64",
+    ].freeze
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omq-backend-rust
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Patrik Wenger
@@ -24,47 +24,36 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.28'
 - !ruby/object:Gem::Dependency
-  name: rb_sys
+  name: omq-rs
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: '0.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: '0.1'
 description: Drop-in Rust backend for OMQ. Same socket API (REQ/REP, PUB/SUB, PUSH/PULL,
-  DEALER/ROUTER, and all draft types), but networking runs on a Tokio runtime inside
-  a native extension compiled via rb_sys. Fully interoperable with the default Ruby
-  engine.
+  DEALER/ROUTER, and all draft types), backed by the first-class omq-rs Ruby binding.
+  Fully interoperable with the default Ruby engine.
 email:
 - paddor@gmail.com
 executables: []
-extensions:
-- ext/omq_backend_rust/extconf.rb
+extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
-- Cargo.toml
 - LICENSE
 - README.md
-- ext/omq_backend_rust/Cargo.toml
-- ext/omq_backend_rust/build.rs
-- ext/omq_backend_rust/extconf.rb
-- ext/omq_backend_rust/src/error.rs
-- ext/omq_backend_rust/src/lib.rs
-- ext/omq_backend_rust/src/notify.rs
-- ext/omq_backend_rust/src/options.rs
-- ext/omq_backend_rust/src/rb.rs
-- ext/omq_backend_rust/src/runtime.rs
-- ext/omq_backend_rust/src/socket.rs
 - lib/omq/backend/rust.rb
 - lib/omq/rust/engine.rb
 - lib/omq/rust/fd_watcher.rb
+- lib/omq/rust/java/engine.rb
+- lib/omq/rust/java/platform.rb
 - lib/omq/rust/version.rb
 homepage: https://github.com/zeromq/omq.rb/tree/main/gems/omq-backend-rust
 licenses:
@@ -86,5 +75,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 4.0.16
 specification_version: 4
-summary: Rust-backed engine for OMQ using omq-tokio
+summary: OMQ.rs backend for OMQ.rb
 test_files: []

data/Cargo.toml

@@ -1,3 +0,0 @@
-[workspace]
-members = ["ext/omq_backend_rust"]
-resolver = "3"

data/ext/omq_backend_rust/Cargo.toml

@@ -1,33 +0,0 @@
-[package]
-name    = "omq_backend_rust"
-version = "0.2.0"
-edition = "2024"
-license = "ISC"
-authors = ["Patrik Wenger <paddor@gmail.com>"]
-publish = false
-
-[lib]
-name       = "omq_backend_rust"
-crate-type = ["cdylib"]
-
-[features]
-default = ["plain", "curve", "lz4", "zstd"]
-plain   = ["omq-tokio/plain"]
-curve   = ["omq-tokio/curve"]
-lz4     = ["omq-tokio/lz4"]
-zstd    = ["omq-tokio/zstd"]
-
-[dependencies]
-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"] }
-rb-sys  = "0.9"
-libc    = "0.2"
-
-[build-dependencies]
-rb-sys = "0.9"

data/ext/omq_backend_rust/build.rs

@@ -1,23 +0,0 @@
-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/extconf.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-require "mkmf"
-require "rb_sys/mkmf"
-
-create_rust_makefile("omq/rust/omq_backend_rust") do |r|
-  r.profile = ENV.fetch("RB_SYS_CARGO_PROFILE", :release).to_sym
-end

data/ext/omq_backend_rust/src/error.rs

@@ -1,16 +0,0 @@
-use omq_proto::error::Error as OmqError;
-
-use crate::rb::RubyErr;
-
-pub fn map_err(e: OmqError) -> RubyErr {
-    match 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,51 +0,0 @@
-mod error;
-mod notify;
-mod options;
-mod rb;
-mod runtime;
-mod socket;
-
-use rb_sys::VALUE;
-
-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);
-}
-
-fn init() -> RbResult<()> {
-    #[cfg(ruby_engine = "mri")]
-    unsafe {
-        rb_sys::rb_ext_ractor_safe(true);
-    }
-
-    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")? };
-
-    unsafe {
-        rb::define_module_function_1(native, c"io_threads=", set_io_threads)?;
-    }
-
-    socket::register(native)?;
-
-    Ok(())
-}

data/ext/omq_backend_rust/src/notify.rs

@@ -1,69 +0,0 @@
-use std::os::fd::RawFd;
-use std::sync::atomic::{AtomicBool, Ordering};
-
-pub struct PipeNotify {
-    read_fd: RawFd,
-    write_fd: RawFd,
-    parking: AtomicBool,
-}
-
-unsafe impl Send for PipeNotify {}
-unsafe impl Sync for PipeNotify {}
-
-impl PipeNotify {
-    pub fn new() -> Self {
-        let mut fds = [0i32; 2];
-        let ret = unsafe { libc::pipe2(fds.as_mut_ptr(), libc::O_NONBLOCK | libc::O_CLOEXEC) };
-        assert!(
-            ret == 0,
-            "pipe2 failed: {}",
-            std::io::Error::last_os_error()
-        );
-        Self {
-            read_fd: fds[0],
-            write_fd: fds[1],
-            parking: AtomicBool::new(false),
-        }
-    }
-
-    pub fn notify(&self) {
-        if self.parking.load(Ordering::Acquire) {
-            self.write_byte();
-        }
-    }
-
-    pub fn force_wake(&self) {
-        self.write_byte();
-    }
-
-    pub fn read_fd(&self) -> RawFd {
-        self.read_fd
-    }
-
-    pub fn park_begin(&self) {
-        self.parking.store(true, Ordering::Release);
-    }
-
-    fn write_byte(&self) {
-        let val: u8 = 1;
-        loop {
-            let ret =
-                unsafe { libc::write(self.write_fd, &val as *const u8 as *const libc::c_void, 1) };
-            if ret >= 0 {
-                break;
-            }
-            if std::io::Error::last_os_error().raw_os_error() != Some(libc::EINTR) {
-                break;
-            }
-        }
-    }
-}
-
-impl Drop for PipeNotify {
-    fn drop(&mut self) {
-        unsafe {
-            libc::close(self.read_fd);
-            libc::close(self.write_fd);
-        }
-    }
-}

data/ext/omq_backend_rust/src/options.rs

@@ -1,220 +0,0 @@
-use std::time::Duration;
-
-use bytes::Bytes;
-
-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(hash, "send_hwm")? {
-        opts.send_hwm = v.max(0) as u32;
-    }
-    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(hash, "linger")? {
-        opts.linger = if v.is_infinite() && v.is_sign_positive() {
-            None
-        } else {
-            Some(duration_from_seconds("linger", 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(hash, "router_mandatory")? {
-        opts.router_mandatory = v;
-    }
-    if let Some(v) = get_opt_bool(hash, "conflate")? {
-        opts.conflate = v;
-    }
-    if let Some(v) = get_opt_duration(hash, "heartbeat_interval")? {
-        opts.heartbeat_interval = Some(v);
-    }
-    if let Some(v) = get_opt_duration(hash, "heartbeat_ttl")? {
-        opts.heartbeat_ttl = Some(v);
-    }
-    if let Some(v) = get_opt_duration(hash, "heartbeat_timeout")? {
-        opts.heartbeat_timeout = Some(v);
-    }
-    if let Some(v) = get_opt_usize(hash, "max_message_size")? {
-        opts.max_message_size = Some(v);
-    }
-    if let Some(v) = get_opt_usize(hash, "sndbuf")? {
-        opts.send_buffer_size = Some(v);
-    }
-    if let Some(v) = get_opt_usize(hash, "rcvbuf")? {
-        opts.recv_buffer_size = Some(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(hash, "compression_auto_train")? {
-        opts.compression_auto_train = v;
-    }
-    if let Some(v) = get_opt_usize(hash, "compression_threshold")? {
-        opts.compression_threshold = Some(v);
-    }
-    if let Some(v) = get_opt_i64(hash, "compression_level")? {
-        opts.compression_level = Some(v as i32);
-    }
-    if let Some(v) = get_opt_usize(hash, "compression_dict_capacity")? {
-        opts.compression_dict_capacity = Some(v);
-    }
-    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(hash, "compression_offload_threshold")? {
-        opts.compression_offload_threshold = if v < 0 { None } else { Some(v as usize) };
-    }
-    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(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_seconds("reconnect_interval min", min)?,
-            max: duration_from_seconds("reconnect_interval max", max)?,
-        };
-    }
-
-    if let Some(mech_type) = get_opt_string(hash, "mechanism_type")? {
-        apply_mechanism(hash, &mech_type, &mut opts)?;
-    }
-
-    Ok(opts)
-}
-
-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(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(&pk, "public key")?),
-                        secret: omq_proto::CurveSecretKey::from_bytes(to_32(&sk, "secret key")?),
-                    };
-                    opts.mechanism = omq_proto::MechanismSetup::CurveServer {
-                        our_keypair: keypair,
-                        options: omq_proto::CurveServerOptions::default(),
-                    };
-                }
-            } else {
-                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(&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(
-                            &svk,
-                            "server key",
-                        )?),
-                    };
-                }
-            }
-        }
-
-        _ => {}
-    }
-    Ok(())
-}
-
-fn to_32(bytes: &[u8], label: &str) -> RbResult<[u8; 32]> {
-    bytes.try_into().map_err(|_| {
-        RubyErr::arg(format!(
-            "{label} must be exactly 32 bytes, got {}",
-            bytes.len()
-        ))
-    })
-}
-
-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_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(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")))
-}