omq-backend-rust 0.1.7 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b22c5a39d466ddff0ea811bfadff93fe58e64c3ea08bb213f61419e5efd13cc6
-  data.tar.gz: '09ef0d2306516c3809a957f61e234360d9f2bbe34b0389cf874c8d5cdc87abc8'
+  metadata.gz: 4f12671673afe657015b59cf65873132c88c5cbb15cf34962b54318fb944310c
+  data.tar.gz: 3b7de77e6e01dc461fa0aa969870472442a2f9b3b4657fa5b35ca1fe90bd8940
 SHA512:
-  metadata.gz: bae7c0181f01e714d3fbbb11546bb84dc6642d77661734e5d5eaa5467af153a5437b0a9af1ff0d1b8f894609928d7952a83bcb492ef299e327253acdc6a1f85d
-  data.tar.gz: b787de3962b49bf2c784596f8fd82901e0323e74270915ba051359eb73a46022389726cea92b1a6364c7780eaf296a457d8355d90507503a5690f4de4de8410b
+  metadata.gz: 77dda34fcf69ef4d048d74276b1ae5cd455b23086de0a826f751862014e0d048dd8f27ccc2042f5332ff91a5410f11243f687450ca0093e58ab19377b64ec9dd
+  data.tar.gz: 2536562047da85d828e732a03c5a551a85b2b0774821f3ada32f890ba48f4453696c0243ef5e66248cbdee763623d1cf0f9b45bb74ac5e9aedba6aab014558ed

data/CHANGELOG.md

@@ -2,6 +2,40 @@
 
 ## [Unreleased]
 
+## [0.3.0] - 2026-08-26
+
+### Added
+
+- Added JRuby support through OMQ.java Maven artifacts for Linux x86_64,
+  macOS aarch64, macOS x86_64, and Windows x86_64.
+
+### Changed
+
+- Replaced the private MRI/TruffleRuby native extension with the first-class
+  `omq-rs` binding.
+
+## [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/README.md

@@ -6,12 +6,16 @@
 [![Ruby](https://img.shields.io/badge/Ruby-%3E%3D%203.3-CC342D?logo=ruby&logoColor=white)](https://www.ruby-lang.org)
 
 Rust-backed engine for [OMQ](https://github.com/zeromq/omq.rb). Same socket API,
-but networking runs on a [Tokio](https://tokio.rs/) runtime inside a native
-extension compiled via [rb_sys](https://github.com/oxidize-rb/rb-sys).
+but networking runs through the first-class
+[omq-rs](https://github.com/paddor/omq.rs/tree/main/bindings/ruby) binding on
+MRI and TruffleRuby, or through OMQ.java on JRuby.
 
 ## Install
 
-Requires a Rust toolchain (stable) at gem install time.
+The `omq-rs` dependency compiles OMQ.rs during installation on MRI and
+TruffleRuby. JRuby uses OMQ.java on Java 25 or newer. The Java gem selects the
+matching OMQ.java artifact on Linux x86_64, macOS aarch64, macOS x86_64, and
+Windows x86_64.
 
 ```ruby
 # Gemfile
@@ -73,8 +77,8 @@ the first `bind` or `connect` for a Rust-backed socket.
 ## Development
 
 ```sh
-OMQ_DEV=1 bundle install
-OMQ_DEV=1 bundle exec rake
+OMQ_RS_PATH=/path/to/omq.rs/bindings/ruby bundle install
+OMQ_RS_PATH=/path/to/omq.rs/bindings/ruby bundle exec rake
 ```
 
 ## License

data/lib/omq/backend/rust.rb

@@ -1,16 +1,23 @@
 # frozen_string_literal: true
 
 require "omq"
-require_relative "../rust/omq_backend_rust"
 require_relative "../rust/version"
-require_relative "../rust/engine"
 
-module OMQ
-  module Rust
-    @io_threads = 1
+if RUBY_ENGINE == "jruby"
+  require_relative "../rust/java/engine"
+else
+  require "omq/rs"
+  require_relative "../rust/engine"
+end
+
+if RUBY_ENGINE == "jruby"
+  module OMQ
+    module Rust
+      @io_threads = 1
 
-    class << self
-      attr_accessor :io_threads
+      class << self
+        attr_accessor :io_threads
+      end
     end
   end
 end

data/lib/omq/rust/engine.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "async"
+require_relative "fd_watcher"
 
 module OMQ
   module Rust
@@ -14,20 +15,22 @@ module OMQ
 
 
       def initialize(socket_type, options)
-        @socket_type    = socket_type
-        @options        = options
-        @peer_connected = Async::Promise.new
-        @all_peers_gone = Async::Promise.new
-        @subscriber_joined = Async::Promise.new
-        @connections    = {}
-        @closed         = false
-        @parent_task    = nil
-        @on_io_thread   = false
-        @materialized   = false
-        @recv_sentinels = 0
-        @compression_options = {}
-
-        @native = Native::RustSocket.new(socket_type.to_s)
+        @socket_type          = socket_type
+        @options              = options
+        @peer_connected       = Async::Promise.new
+        @all_peers_gone       = Async::Promise.new
+        @subscriber_joined    = Async::Promise.new
+        @connections          = {}
+        @closed               = false
+        @parent_task          = nil
+        @on_io_thread         = false
+        @materialized         = false
+        @recv_sentinels       = 0
+        @compression_options  = {}
+        @socket               = nil
+        @monitor_task         = nil
+        @monitor_watching     = false
+        @had_peer             = false
 
         @routing = RoutingStub.new(self)
       end
@@ -40,6 +43,8 @@ module OMQ
           @parent_task = parent
         elsif Async::Task.current?
           @parent_task = Async::Task.current
+        elsif !Reactor.native_fiber_scheduler?
+          @parent_task = nil
         else
           @parent_task  = Reactor.root_task
           @on_io_thread = true
@@ -52,7 +57,7 @@ module OMQ
         capture_parent_task(parent: parent)
         apply_endpoint_options!(opts)
         ensure_materialized
-        resolved = @native.bind(endpoint)
+        resolved = @socket.bind(endpoint)
         URI.parse(resolved)
       end
 
@@ -61,54 +66,39 @@ module OMQ
         capture_parent_task(parent: parent)
         apply_endpoint_options!(opts)
         ensure_materialized
-        @native.connect(endpoint)
+        @socket.connect(endpoint)
         URI.parse(endpoint)
       end
 
 
       def disconnect(endpoint)
-        @native.disconnect(endpoint)
+        @socket.disconnect(endpoint)
       end
 
 
       def unbind(endpoint)
-        @native.unbind(endpoint)
+        @socket.unbind(endpoint)
       end
 
 
       def enqueue_send(parts)
         ensure_materialized
-        result = @native.enqueue_send(parts)
-        return if result == :ok
-
-        @send_signal_r ||= IO.for_fd(@native.send_fd, autoclose: false)
-        loop do
-          result = @native.enqueue_send(parts)
-          return if result == :ok
-
-          @send_signal_r.wait_readable
-          @send_signal_r.read_nonblock(256, exception: false)
-        end
+        @socket.send(normalize_outgoing(parts))
+        nil
       end
 
 
       def dequeue_recv
         ensure_materialized
 
-        if @recv_batch && !@recv_batch.empty?
-          return @recv_batch.shift
-        end
-
-        msg = try_recv_batch
+        msg = try_recv
         return msg if msg
 
         return take_recv_sentinel if @recv_sentinels.positive?
 
         loop do
-          @recv_signal_r.wait_readable
-          @recv_signal_r.read_nonblock(256, exception: false)
-
-          msg = try_recv_batch
+          @socket.wait_readable
+          msg = try_recv
           return msg if msg
 
           return take_recv_sentinel if @recv_sentinels.positive?
@@ -118,7 +108,7 @@ module OMQ
 
       def dequeue_recv_sentinel
         @recv_sentinels += 1
-        @native.wake_recv if @materialized
+        @socket.wake_recv if @materialized
         nil
       end
 
@@ -130,7 +120,9 @@ module OMQ
         @peer_connected.resolve(nil) unless @peer_connected.resolved?
         @all_peers_gone.resolve(nil) unless @all_peers_gone.resolved?
         @subscriber_joined.resolve(nil) unless @subscriber_joined.resolved?
-        @native.close
+        FdWatcher.unwatch_owner(self) unless Reactor.native_fiber_scheduler?
+        @socket&.close
+        @monitor_task&.stop
       end
 
 
@@ -173,19 +165,10 @@ module OMQ
         return if @materialized
 
         capture_parent_task unless @parent_task
-        Native.send(:io_threads=, OMQ::Rust.io_threads)
-        @native.set_options(extract_options)
-        @native.materialize
-        @recv_signal_r = IO.for_fd(@native.recv_fd, autoclose: false)
-        @materialized  = true
-
-        @routing.replay_pending(@native)
-
-        spawn_lifecycle_watcher(@native.peer_connected_fd, @peer_connected)
-        spawn_lifecycle_watcher(@native.all_peers_gone_fd, @all_peers_gone)
-        spawn_lifecycle_watcher(@native.subscriber_joined_fd, @subscriber_joined)
-
-        start_monitor_forwarder if @monitor_queue
+        @socket = OMQ::Rust.socket(@socket_type, **extract_options.transform_keys(&:to_sym))
+        @materialized = true
+        @routing.replay_pending(@socket)
+        start_monitor_forwarder
       end
 
 
@@ -195,55 +178,82 @@ module OMQ
       end
 
 
-      def try_recv_batch
-        batch = @native.try_recv_batch
-        return unless batch
+      def try_recv
+        message = @socket.try_recv
+        return unless message
+        return message unless @socket_type.to_sym == :SERVER
 
-        msg = batch.shift
-        @recv_batch = batch unless batch.empty?
-        msg
+        routing_id, *parts = message
+        [[routing_id].pack("N"), *parts]
       end
 
 
-      def spawn_lifecycle_watcher(fd, promise)
-        io = IO.for_fd(fd, autoclose: false)
-        @parent_task.async(transient: true) do
-          io.wait_readable
-          promise.resolve(true) unless promise.resolved? || @closed
-        rescue IOError, Errno::EBADF
+      def normalize_outgoing(parts)
+        return parts unless @socket_type.to_sym == :SERVER
+
+        routing_id, *body = parts
+        unless routing_id.is_a?(String) && routing_id.bytesize == 4
+          raise ArgumentError, "SERVER routing ID must be a 4-byte String"
         end
+        [routing_id.unpack1("N"), *body]
       end
 
 
       def start_monitor_forwarder
-        monitor_io = IO.for_fd(@native.monitor_fd, autoclose: false)
-        @parent_task.async(transient: true, annotation: "rust-monitor") do
-          loop do
-            monitor_io.wait_readable
-            monitor_io.read_nonblock(256, exception: false)
-            while (data = @native.try_recv_monitor)
-              track_connection_event(data)
-              @monitor_queue.enqueue(MonitorEvent.new(**data))
+        return if @monitor_task || @monitor_watching
+
+        if Reactor.native_fiber_scheduler?
+          @monitor_task = @parent_task.async(transient: true, annotation: "rust-monitor") do
+            monitor_loop
+          end
+        else
+          @monitor_watching = true
+          FdWatcher.watch_loop(@socket.monitor_fd, owner: self) do |io|
+            io.read_nonblock(256, exception: false)
+            while (data = @socket.try_monitor_event)
+              handle_monitor_event(data)
             end
+            @socket.monitor_fd unless @closed
           end
         end
       end
 
 
-      def track_connection_event(data)
-        detail = data[:detail] || {}
-        connection_id = detail[:connection_id]
+      def monitor_loop
+        until @closed
+          data = @socket.monitor.recv
+          break unless data
+
+          handle_monitor_event(data)
+        end
+      rescue IOError, Errno::EBADF
+        raise unless @closed
+      end
+
+
+      def handle_monitor_event(data)
+        type          = data.fetch(:event)
+        endpoint      = data[:endpoint]
+        connection_id = data[:connection_id]
 
-        case data[:type]
+        case type
         when :handshake_succeeded
+          @had_peer = true
           @connections[connection_id || Object.new] = true
+          @peer_connected.resolve(true) unless @peer_connected.resolved?
         when :disconnected
-          if connection_id
-            @connections.delete(connection_id)
-          else
-            @connections.shift
+          connection_id ? @connections.delete(connection_id) : @connections.shift
+          if @had_peer && @connections.empty? && !@all_peers_gone.resolved?
+            @all_peers_gone.resolve(true)
           end
+        when :subscribe_received
+          @subscriber_joined.resolve(true) unless @subscriber_joined.resolved?
         end
+
+        return unless @monitor_queue
+
+        detail = data.except(:event, :endpoint)
+        @monitor_queue.enqueue(MonitorEvent.new(type:, endpoint:, detail: detail.empty? ? nil : detail))
       end
 
 
@@ -404,9 +414,9 @@ module OMQ
 
 
         def subscribe(prefix)
-          native = @engine.instance_variable_get(:@native)
+          socket = @engine.instance_variable_get(:@socket)
           if @engine.instance_variable_get(:@materialized)
-            native.subscribe(prefix.b)
+            socket.subscribe(prefix.b)
           else
             @pending_subscribe << prefix.b
           end
@@ -414,14 +424,14 @@ module OMQ
 
 
         def unsubscribe(prefix)
-          @engine.instance_variable_get(:@native).unsubscribe(prefix.b)
+          @engine.instance_variable_get(:@socket).unsubscribe(prefix.b)
         end
 
 
         def join(group)
-          native = @engine.instance_variable_get(:@native)
+          socket = @engine.instance_variable_get(:@socket)
           if @engine.instance_variable_get(:@materialized)
-            native.join(group)
+            socket.join(group)
           else
             @pending_join << group
           end
@@ -429,14 +439,14 @@ module OMQ
 
 
         def leave(group)
-          @engine.instance_variable_get(:@native).leave(group)
+          @engine.instance_variable_get(:@socket).leave(group)
         end
 
 
-        def replay_pending(native)
-          @pending_subscribe.each { |p| native.subscribe(p) }
+        def replay_pending(socket)
+          @pending_subscribe.each { |p| socket.subscribe(p) }
           @pending_subscribe.clear
-          @pending_join.each { |g| native.join(g) }
+          @pending_join.each { |g| socket.join(g) }
           @pending_join.clear
         end
       end

data/lib/omq/rust/fd_watcher.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module OMQ
+  module Rust
+    class FdWatcher
+      Watch = Struct.new(:id, :io, :owner, :once, :callback, keyword_init: true)
+
+      class << self
+        def watch_once(fd, owner:, &block)
+          watch(fd, owner: owner, once: true, &block)
+        end
+
+
+        def watch_loop(fd, owner:, &block)
+          watch(fd, owner: owner, once: false, &block)
+        end
+
+
+        def unwatch_owner(owner)
+          removed = nil
+
+          mutex.synchronize do
+            reset_after_fork
+            removed = watchers.values.select { |watch| watch.owner.equal?(owner) }
+            removed.each { |watch| watchers.delete(watch.id) }
+          end
+
+          removed.each { |watch| close_io(watch.io) }
+          wake
+        end
+
+
+        private
+
+
+        def watch(fd, owner:, once:, &block)
+          raise ArgumentError, "block required" unless block
+
+          io = IO.for_fd(fd, autoclose: false)
+          mutex.synchronize do
+            reset_after_fork
+            ensure_started
+            id = next_id
+            watchers[id] = Watch.new(id: id, io: io, owner: owner, once: once, callback: block)
+            id
+          end
+        rescue StandardError
+          close_io(io)
+          raise
+        ensure
+          wake if io
+        end
+
+
+        def reset_after_fork
+          pid = Process.pid
+          return if @pid == pid
+
+          watchers.each_value { |watch| close_io(watch.io) }
+          close_io(@wake_r)
+          close_io(@wake_w)
+          @watchers = {}
+          @wake_r   = nil
+          @wake_w   = nil
+          @thread   = nil
+          @next_id  = 0
+          @pid      = pid
+        end
+
+
+        def ensure_started
+          return if @thread&.alive?
+
+          @wake_r, @wake_w = IO.pipe
+          @thread = Thread.new do
+            Thread.current.name = "omq-rust-watch" if Thread.current.respond_to?(:name=)
+            run
+          end
+        end
+
+
+        def run
+          loop do
+            wake_io, current = snapshot
+            readable = [wake_io, *current.map(&:io)].reject(&:closed?)
+            ready = IO.select(readable)&.first || []
+
+            drain_wake(wake_io) if ready.include?(wake_io)
+
+            current.each do |watch|
+              next unless ready.include?(watch.io)
+
+              dispatch(watch)
+            end
+          rescue IOError, SystemCallError
+            sweep_closed
+          end
+        end
+
+
+        def dispatch(watch)
+          active = watch.once ? delete_if_current(watch) : current?(watch)
+          return unless active
+
+          watch.callback.call(watch.io)
+        rescue StandardError
+          delete_if_current(watch)
+        ensure
+          close_io(watch.io) if watch.once
+        end
+
+
+        def snapshot
+          mutex.synchronize { [@wake_r, watchers.values] }
+        end
+
+
+        def current?(watch)
+          mutex.synchronize { watchers[watch.id].equal?(watch) }
+        end
+
+
+        def delete_if_current(watch)
+          mutex.synchronize do
+            if watchers[watch.id].equal?(watch)
+              watchers.delete(watch.id)
+              true
+            else
+              false
+            end
+          end
+        end
+
+
+        def sweep_closed
+          removed = nil
+          mutex.synchronize do
+            removed = watchers.values.select { |watch| watch.io.closed? }
+            removed.each { |watch| watchers.delete(watch.id) }
+          end
+          removed.each { |watch| close_io(watch.io) }
+        end
+
+
+        def drain_wake(io)
+          loop do
+            result = io.read_nonblock(256, exception: false)
+            break if result == :wait_readable || result.nil? || result.empty?
+          end
+        end
+
+
+        def wake
+          return unless @wake_w && !@wake_w.closed?
+
+          @wake_w.write_nonblock(".", exception: false)
+        rescue IOError, SystemCallError
+        end
+
+
+        def close_io(io)
+          io.close if io && !io.closed?
+        rescue IOError, SystemCallError
+        end
+
+
+        def watchers
+          @watchers ||= {}
+        end
+
+
+        def mutex
+          @mutex ||= Mutex.new
+        end
+
+
+        def next_id
+          @next_id ||= 0
+          @next_id += 1
+        end
+      end
+    end
+  end
+end