omq-backend-rust 0.1.7 → 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.1.7"
+    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.1.7
+  version: 0.3.0
 platform: ruby
 authors:
 - Patrik Wenger
@@ -24,44 +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/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/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:
@@ -83,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,34 +0,0 @@
-[package]
-name    = "omq_backend_rust"
-version = "0.1.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.0", default-features = false }
-omq-tokio = { version = "=0.21.0", 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"
-
-[build-dependencies]
-rb-sys = "0.9"

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,15 +0,0 @@
-use magnus::{Error, Ruby};
-use omq_proto::error::Error as OmqError;
-
-pub fn map_err(ruby: &Ruby, e: OmqError) -> Error {
-    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}")),
-    }
-}

data/ext/omq_backend_rust/src/lib.rs

@@ -1,26 +0,0 @@
-mod error;
-mod notify;
-mod options;
-mod runtime;
-mod socket;
-
-use magnus::{Error, Ruby, function, prelude::*};
-
-fn set_io_threads(n: usize) {
-    socket::set_io_threads(n);
-}
-
-#[magnus::init]
-fn init(ruby: &Ruby) -> Result<(), Error> {
-    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")?;
-
-    native.define_module_function("io_threads=", function!(set_io_threads, 1))?;
-
-    socket::register(ruby)?;
-
-    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,207 +0,0 @@
-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> {
-    let mut opts = omq_tokio::Options::default();
-
-    if let Some(v) = get_opt::<i64>(ruby, hash, "send_hwm")? {
-        opts.send_hwm = v.max(0) as u32;
-    }
-    if let Some(v) = get_opt::<i64>(ruby, 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() {
-            None
-        } else {
-            Some(Duration::from_secs_f64(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::<bool>(ruby, hash, "router_mandatory")? {
-        opts.router_mandatory = v;
-    }
-    if let Some(v) = get_opt::<bool>(ruby, hash, "conflate")? {
-        opts.conflate = v;
-    }
-    if let Some(v) = get_opt_duration(ruby, hash, "heartbeat_interval")? {
-        opts.heartbeat_interval = Some(v);
-    }
-    if let Some(v) = get_opt_duration(ruby, hash, "heartbeat_ttl")? {
-        opts.heartbeat_ttl = Some(v);
-    }
-    if let Some(v) = get_opt_duration(ruby, 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::<i64>(ruby, hash, "sndbuf")? {
-        opts.send_buffer_size = Some(v as usize);
-    }
-    if let Some(v) = get_opt::<i64>(ruby, hash, "rcvbuf")? {
-        opts.recv_buffer_size = Some(v as usize);
-    }
-    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::<bool>(ruby, 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::<i64>(ruby, 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::<i64>(ruby, hash, "max_recv_dict_size")? {
-        opts.max_recv_dict_size = Some(v as usize);
-    }
-    if let Some(v) = get_opt::<i64>(ruby, 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")? {
-        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);
-        opts.reconnect = omq_proto::options::ReconnectPolicy::Exponential {
-            min: Duration::from_secs_f64(min),
-            max: Duration::from_secs_f64(max),
-        };
-    }
-
-    if let Some(mech_type) = get_opt::<String>(ruby, hash, "mechanism_type")? {
-        apply_mechanism(ruby, hash, &mech_type, &mut opts)?;
-    }
-
-    Ok(opts)
-}
-
-fn apply_mechanism(
-    ruby: &Ruby,
-    hash: RHash,
-    mech_type: &str,
-    opts: &mut omq_tokio::Options,
-) -> Result<(), Error> {
-    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")?;
-
-            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",
-                        )?),
-                    };
-                    opts.mechanism = omq_proto::MechanismSetup::CurveServer {
-                        our_keypair: keypair,
-                        options: omq_proto::CurveServerOptions::default(),
-                    };
-                }
-            } else {
-                let srv_key = get_opt_bytes(ruby, 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",
-                        )?),
-                    };
-                    opts.mechanism = omq_proto::MechanismSetup::CurveClient {
-                        our_keypair: keypair,
-                        server_public: omq_proto::CurvePublicKey::from_bytes(to_32(
-                            ruby,
-                            &svk,
-                            "server key",
-                        )?),
-                    };
-                }
-            }
-        }
-
-        _ => {}
-    }
-    Ok(())
-}
-
-fn to_32(ruby: &Ruby, bytes: &[u8], label: &str) -> Result<[u8; 32], Error> {
-    bytes.try_into().map_err(|_| {
-        Error::new(
-            ruby.exception_arg_error(),
-            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()))
-        }
-        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)?))
-            }
-        }
-        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))),
-        None => Ok(None),
-    }
-}