omq-backend-rust 0.2.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ec3e72f8903532375903dac4637b6f4ebc1c9b09a0f2d1d1475420797464e800
-  data.tar.gz: d4cb76d8140f6f10d3b4eda7f9f720a7901407dcf0ea45da3e7a48989a137ca4
+  metadata.gz: ed979a32dfef182642cb03dba149e36843c9e37fed1e75032c439b35d769d145
+  data.tar.gz: bd80cf78e629a3b4af1bec1ec6646ea9df635be16c096b1a9d597aed05918d79
 SHA512:
-  metadata.gz: 5921c0fcc3fd18908cbc142ae481aa4e61d8005ab68f2ebc61fd316f65089f8d6453acddb76e073a2c06e0a47581900878a47d5c0dc2b7899bb2bd815a500fec
-  data.tar.gz: 7401afef781cc1000b175dd1e28f89241e2002abfc0a415d8bedd1d5a341398dce599574a6ced626f17a8c94ab3add861699f254e4f32a2d8f439322add19272
+  metadata.gz: fe616024d998eeae83b17b81bfedba2e49bc542a16b8fb6a4f13df4e6a21f768603e497276817c722a5dd1308c54979ad6b615af0d944d692f2faf78c9c77efc
+  data.tar.gz: be283792e7d988030b6d13859b206e10c6c8ae355285809a9282ff40c7b14ae4a7b35fa908a24a3e5daa122040c82073c7f022569d163ce451b80ebb8d37faa5

data/CHANGELOG.md

@@ -2,6 +2,35 @@
 
 ## [Unreleased]
 
+## [0.3.1] - 2026-10-15
+
+### Fixed
+
+- Resolve RADIO subscriber readiness on `join_received` monitor events.
+- Reject unsupported security mechanisms instead of silently using NULL.
+- Forward CURVE authenticators on MRI, TruffleRuby, and JRuby, preserving the
+  Ruby `PeerInfo` and crypto public-key types.
+- Reject JRuby authenticator configuration when the OMQ.java callback classes
+  are missing from the JVM classpath.
+
+### Changed
+
+- Require `omq-rs >= 0.2.5` for native authentication callbacks and REQ/REP
+  fixes: reject unrelated REQ replies and bodyless REP requests, and preserve
+  REP reply destinations across prefetched requests and disconnects.
+
+## [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

data/README.md

@@ -6,12 +6,19 @@
 [![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 >= 0.2.5` dependency compiles OMQ.rs during installation on MRI
+and TruffleRuby. This minimum includes the REQ/REP envelope and reply-routing
+fixes in `omq-tokio` 0.28.1 and `omq-proto` 0.32.1.
+
+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
@@ -44,8 +51,7 @@ ensure
 end
 ```
 
-The `:rust` backend is fully interoperable with the default `:ruby` backend.
-Mix backends freely within the same process.
+Select a backend per socket to exchange ZMTP messages with Ruby and other peers.
 
 ## Supported socket types
 
@@ -58,6 +64,23 @@ SCATTER/GATHER, CHANNEL.
 - **NULL** (default)
 - **CURVE** (CurveZMQ, via [Nuckle](https://github.com/paddor/nuckle))
 
+CURVE authenticators receive `Protocol::ZMTP::PeerInfo`, including a public key
+from the configured crypto backend. As with the Ruby engine, the identity is
+empty during authentication.
+
+On JRuby, OMQ.java 0.3.0's JNI callback threads require the platform jar on the
+JVM `CLASSPATH`. For example:
+
+```sh
+CLASSPATH="$HOME/.m2/repository/io/github/paddor/omq-java/0.3.0/omq-java-0.3.0-linux-x86_64.jar" jruby app.rb
+```
+
+Without it, configuring a CURVE authenticator raises `ArgumentError` before
+opening a connection. CURVE without an authenticator does not need this workaround.
+
+PLAIN and custom mechanisms raise `ArgumentError` before binding, connecting,
+or sending. They are not supported by this adapter.
+
 ## Compressed transports
 
 The Rust backend supports `lz4+tcp://` and `zstd+tcp://`. Compression
@@ -73,8 +96,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

@@ -27,8 +27,10 @@ module OMQ
         @materialized         = false
         @recv_sentinels       = 0
         @compression_options  = {}
-
-        @native = Native::RustSocket.new(socket_type.to_s)
+        @socket               = nil
+        @monitor_task         = nil
+        @monitor_watching     = false
+        @had_peer             = false
 
         @routing = RoutingStub.new(self)
       end
@@ -55,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
 
@@ -64,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_native_fd(@native.send_fd)
-        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?
@@ -121,7 +108,7 @@ module OMQ
 
       def dequeue_recv_sentinel
         @recv_sentinels += 1
-        @native.wake_recv if @materialized
+        @socket.wake_recv if @materialized
         nil
       end
 
@@ -134,9 +121,8 @@ module OMQ
         @all_peers_gone.resolve(nil) unless @all_peers_gone.resolved?
         @subscriber_joined.resolve(nil) unless @subscriber_joined.resolved?
         FdWatcher.unwatch_owner(self) unless Reactor.native_fiber_scheduler?
-        @native.close
-        close_io_wrapper(@recv_signal_r)
-        close_io_wrapper(@send_signal_r)
+        @socket&.close
+        @monitor_task&.stop
       end
 
 
@@ -179,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_native_fd(@native.recv_fd)
-        @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
 
 
@@ -201,89 +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)
-        if Reactor.native_fiber_scheduler?
-          io = io_for_native_fd(fd)
-          @parent_task.async(transient: true) do
-            io.wait_readable
-            promise.resolve(true) unless promise.resolved? || @closed
-          rescue IOError, Errno::EBADF
-          ensure
-            close_io_wrapper(io)
-          end
-        else
-          FdWatcher.watch_once(fd, owner: self) do
-            promise.resolve(true) unless promise.resolved? || @closed
-          end
+      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
+        return if @monitor_task || @monitor_watching
+
         if Reactor.native_fiber_scheduler?
-          monitor_io = io_for_native_fd(@native.monitor_fd)
-          @parent_task.async(transient: true, annotation: "rust-monitor") do
-            until @closed
-              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))
-              end
-            end
-          rescue IOError, Errno::EBADF
-          ensure
-            close_io_wrapper(monitor_io)
+          @monitor_task = @parent_task.async(transient: true, annotation: "rust-monitor") do
+            monitor_loop
           end
         else
-          FdWatcher.watch_loop(@native.monitor_fd, owner: self) do |io|
+          @monitor_watching = true
+          FdWatcher.watch_loop(@socket.monitor_fd, owner: self) do |io|
             io.read_nonblock(256, exception: false)
-            while (data = @native.try_recv_monitor)
-              track_connection_event(data)
-              @monitor_queue.enqueue(MonitorEvent.new(**data))
+            while (data = @socket.try_monitor_event)
+              handle_monitor_event(data)
             end
+            @socket.monitor_fd unless @closed
           end
         end
       end
 
 
-      def io_for_native_fd(fd)
-        IO.for_fd(fd, autoclose: false)
-      end
-
+      def monitor_loop
+        until @closed
+          data = @socket.monitor.recv
+          break unless data
 
-      def close_io_wrapper(io)
-        return unless io && !io.closed?
-
-        io.close
-      rescue IOError, SystemCallError
+          handle_monitor_event(data)
+        end
+      rescue IOError, Errno::EBADF
+        raise unless @closed
       end
 
 
-      def track_connection_event(data)
-        detail = data[:detail] || {}
-        connection_id = detail[:connection_id]
+      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, :join_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
 
 
@@ -402,14 +372,12 @@ module OMQ
 
       def extract_mechanism(h)
         mech = @options.mechanism
-        case mech
-        when Protocol::ZMTP::Mechanism::Null
+        if mech.nil? || mech.instance_of?(Protocol::ZMTP::Mechanism::Null)
           h["mechanism_type"] = "null"
+        elsif defined?(Protocol::ZMTP::Mechanism::Curve) && mech.instance_of?(Protocol::ZMTP::Mechanism::Curve)
+          extract_curve_mechanism(h, mech)
         else
-          klass = mech.class.name
-          if klass&.include?("Curve")
-            extract_curve_mechanism(h, mech)
-          end
+          raise ArgumentError, "Rust backend does not support security mechanism #{mech.class}"
         end
       end
 
@@ -427,6 +395,15 @@ module OMQ
           srv_key = mech.instance_variable_get(:@server_public)
           h["mechanism_server_key"] = srv_key.to_s.b if srv_key
         end
+
+        if (authenticator = mech.instance_variable_get(:@authenticator))
+          require "protocol/zmtp/z85"
+          crypto = mech.instance_variable_get(:@crypto)
+          h["curve_auth"] = lambda do |peer|
+            public_key = crypto::PublicKey.new(Protocol::ZMTP::Z85.decode(peer.public_key))
+            authenticator.call(Protocol::ZMTP::PeerInfo.new(public_key: public_key, identity: ""))
+          end
+        end
       end
 
 
@@ -444,9 +421,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
@@ -454,14 +431,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
@@ -469,14 +446,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