omq 0.21.0 → 0.22.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f24ac91fe456168b4d369f63506cf1d3d2b48488637ce767363aa17bb542d2b3
-  data.tar.gz: ca1b98ab4083ad90f7f483bc9df937656ae9862c9fd07800fc46315543e5fe75
+  metadata.gz: f58b9e0c8c49bcdfb8dd80ec5eda6a6b6e5b09f04a2a7851001449449ba448fd
+  data.tar.gz: 0f6cbd451adc8b1d1cde0771d6535c5959f09e4b3f0442164b0544964755795e
 SHA512:
-  metadata.gz: 16f20fa600ebd66228589da4e03efc809a616d6a74fbe3460a8ced6811349fb86903e43a440708e1e78f102af711d6f9ea3ebf9cbc0e7fb4aef9591db5061e39
-  data.tar.gz: 89ff3da1bb5caa2223d1e323a389cacc4f270fed719902dbd0721c56da8ff5c0a1cbf1e6eebc59c8386f470c433c69dfb20462d46f84c9a2fa848b3e1364dfd0
+  metadata.gz: d7d13f97eeacf998f1e0137bdbc5dd4a471195ff628fd7da97720a019e30c2a9c200fab761c38943bbbada056bf81880e6ca2dd87d3936f150f0fa22566cebe5
+  data.tar.gz: f97931ecb4893ecd0155c37ea18793c9414bd57de6918496ef7af18bad714720aa2e146531788956265d6f85bc3e18f6dd403f71df8683913d322c94a6dd1bdb

data/CHANGELOG.md

@@ -1,5 +1,67 @@
 # Changelog
 
+## 0.22.1 — 2026-04-16
+
+### Changed
+
+- **Reuse batch arrays in send pumps.** All send pumps (RoundRobin,
+  Pair, ConnSendPump, FanOut, FanOut-conflate) now pre-allocate a
+  single batch array and clear it between cycles instead of
+  allocating a fresh `[msg]` per dequeue.
+
+- **`Routing.dequeue_batch`** consolidates the blocking-dequeue +
+  non-blocking-sweep pattern that was duplicated across four call
+  sites into one method. `dequeue_batch_capped` does the same for
+  the byte/message-capped RoundRobin variant.
+
+- **REP envelope stored as `[conn, envelope]`** instead of a Hash,
+  and reply assembly uses `<<` + `concat` instead of double splat.
+
+- **Heartbeat drops redundant `context: "".b`** — the default is
+  now `EMPTY_BINARY` in protocol-zmtp.
+
+- **Bench harness accepts `OMQ_BENCH_SIZES`, `OMQ_BENCH_TRANSPORTS`,
+  and `OMQ_BENCH_PEERS`** env vars to scope runs without editing
+  code.
+
+## 0.22.0 — 2026-04-15
+
+### Fixed
+
+- **PUB/SUB interop with ZMTP 3.0 peers** (libzmq, JeroMQ, pyzmq,
+  NetMQ). OMQ previously sent `SUBSCRIBE`/`CANCEL` as ZMTP 3.1
+  command frames unconditionally; 3.0 peers expect message-form
+  (`\x01`/`\x00` + prefix data frames) and silently dropped them.
+  `Routing::Sub` and `Routing::XSub` now dispatch on
+  `conn.peer_minor`: command-form to ZMTP 3.1+ peers,
+  message-form to ZMTP 3.0 peers. `FanOut`'s subscription listener
+  already accepts both forms via `Protocol::ZMTP::Codec::Subscription.parse`,
+  so PUB/XPUB now also accept legacy message-form subscriptions
+  from 3.0 peers. Verified against JeroMQ in all six role/direction
+  combinations.
+- **ZMTP/2.0 peers are now dropped loudly** during handshake
+  instead of hanging `read_exactly` forever. The underlying
+  `Greeting.read_from` helper in `protocol-zmtp` sniffs the
+  revision byte after 11 bytes and raises; the engine's existing
+  handshake-failure path closes the connection.
+- **`Inproc::DirectPipe#read_frame`** now returns a data `Frame`
+  for non-command queue entries instead of silently dropping
+  them. Previously the fast-path `read_frame` only handled
+  `[:command, cmd]`-tagged items, so a message-form subscription
+  arriving on an inproc pipe was lost. Fallout from the PUB/SUB
+  fix above — without it the inproc tests for that path hung.
+
+### Added
+
+- **ZMTP 3.0 / 3.1 compat tests** (`test/omq/zmtp_30_compat_test.rb`).
+  Hand-crafted raw TCP peer fakes cover: OMQ SUB → 3.0 PUB (message-form),
+  OMQ SUB → 3.1 PUB (command-form), OMQ XSUB → 3.0 PUB, OMQ XSUB → 3.1 PUB,
+  and OMQ PUB accepting message-form SUBSCRIBE from a 3.0 SUB peer.
+- **`Inproc::DirectPipe#peer_major` / `#peer_minor`** — hard-coded to
+  3/1 since both ends of an inproc pipe are OMQ. Lets the routing
+  layer dispatch uniformly on `conn.peer_minor` without special-casing
+  the transport.
+
 ## 0.21.0 — 2026-04-15
 
 ### Changed

data/lib/omq/engine/heartbeat.rb

@@ -24,7 +24,7 @@ module OMQ
         tasks << parent.async(transient: true, annotation: "heartbeat") do
           loop do
             sleep interval
-            conn.send_command(Protocol::ZMTP::Codec::Command.ping(ttl: ttl, context: "".b))
+            conn.send_command(Protocol::ZMTP::Codec::Command.ping(ttl: ttl))
             if conn.heartbeat_expired?(timeout)
               conn.close
               break

data/lib/omq/routing/conn_send_pump.rb

@@ -18,9 +18,10 @@ module OMQ
       #
       def self.start(engine, conn, q, tasks)
         task = engine.spawn_conn_pump_task(conn, annotation: "send pump") do
+          batch = []
+
           loop do
-            batch = [q.dequeue]
-            Routing.drain_send_queue(q, batch)
+            Routing.dequeue_batch(q, batch)
 
             if batch.size == 1
               conn.write_message batch.first
@@ -30,7 +31,11 @@ module OMQ
 
             conn.flush
 
-            batch.each { |parts| engine.emit_verbose_msg_sent(conn, parts) }
+            batch.each do |parts|
+              engine.emit_verbose_msg_sent(conn, parts)
+            end
+
+            batch.clear
           end
         end
 

data/lib/omq/routing/fan_out.rb

@@ -133,15 +133,14 @@ module OMQ
         @tasks << @engine.spawn_conn_pump_task(conn, annotation: "subscription listener") do
           loop do
             frame = conn.read_frame
-            next unless frame.command?
 
-            cmd = Protocol::ZMTP::Codec::Command.from_body(frame.body)
-
-            case cmd.name
-            when "SUBSCRIBE"
-              on_subscribe(conn, cmd.data)
-            when "CANCEL"
-              on_cancel(conn, cmd.data)
+            case Protocol::ZMTP::Codec::Subscription.parse(frame)
+            in [:subscribe, prefix]
+              on_subscribe(conn, prefix)
+            in [:cancel, prefix]
+              on_cancel(conn, prefix)
+            else
+              next
             end
           end
         end
@@ -182,14 +181,16 @@ module OMQ
       #
       def start_conn_send_pump_normal(conn, q, use_wire)
         @engine.spawn_conn_pump_task(conn, annotation: "send pump") do
+          batch = []
+
           loop do
-            batch = [q.dequeue]
-            Routing.drain_send_queue(q, batch)
+            Routing.dequeue_batch(q, batch)
 
             if write_matching_batch(conn, batch, use_wire)
               conn.flush
               batch.each { |parts| @engine.emit_verbose_msg_sent(conn, parts) }
             end
+            batch.clear
           end
         end
       end
@@ -228,14 +229,17 @@ module OMQ
       #
       def start_conn_send_pump_conflate(conn, q)
         @engine.spawn_conn_pump_task(conn, annotation: "send pump") do
+          batch = []
+
           loop do
-            batch = [q.dequeue]
-            Routing.drain_send_queue(q, batch)
+            Routing.dequeue_batch(q, batch)
 
             # Keep only the latest message that matches the subscription.
             latest = batch.reverse.find do |parts|
               subscribed?(conn, parts.first || EMPTY_BINARY)
             end
+
+            batch.clear
             next unless latest
 
             conn.write_message(latest)

data/lib/omq/routing/pair.rb

@@ -106,9 +106,10 @@ module OMQ
 
       def start_send_pump(conn)
         @send_pump = @engine.spawn_conn_pump_task(conn, annotation: "send pump") do
+          batch = []
+
           loop do
-            batch = [@send_queue.dequeue]
-            Routing.drain_send_queue(@send_queue, batch)
+            Routing.dequeue_batch(@send_queue, batch)
 
             if batch.size == 1
               conn.write_message(batch.first)
@@ -120,6 +121,7 @@ module OMQ
             batch.each do |parts|
               @engine.emit_verbose_msg_sent(conn, parts)
             end
+            batch.clear
           end
         end
 

data/lib/omq/routing/rep.rb

@@ -55,7 +55,7 @@ module OMQ
           envelope  = msg[0, delimiter]
           body      = msg[(delimiter + 1)..] || []
 
-          @pending_replies << { conn: connection, envelope: envelope }
+          @pending_replies << [connection, envelope]
           body
         end
         @tasks << task if task
@@ -69,7 +69,7 @@ module OMQ
       # @param connection [Connection]
       #
       def connection_removed(connection)
-        @pending_replies.reject! { |r| r[:conn] == connection }
+        @pending_replies.reject! { |r| r[0] == connection }
         @conn_queues.delete(connection)
         @conn_send_tasks.delete(connection)&.stop
       end
@@ -83,8 +83,12 @@ module OMQ
       def enqueue(parts)
         reply_info = @pending_replies.shift
         return unless reply_info
-        conn = reply_info[:conn]
-        @conn_queues[conn]&.enqueue([*reply_info[:envelope], EMPTY_FRAME, *parts])
+
+        conn, envelope = reply_info
+        msg = envelope
+        msg << EMPTY_FRAME
+        msg.concat(parts)
+        @conn_queues[conn]&.enqueue(msg)
       end
 
 

data/lib/omq/routing/req.rb

@@ -93,7 +93,7 @@ module OMQ
       # REQ prepends empty delimiter frame on the wire.
       #
       def transform_send(parts)
-        [EMPTY_BINARY, *parts]
+        parts.dup.unshift(EMPTY_BINARY)
       end
 
     end

data/lib/omq/routing/round_robin.rb

@@ -133,9 +133,10 @@ module OMQ
       #
       def start_conn_send_pump(conn)
         task = @engine.spawn_conn_pump_task(conn, annotation: "send pump") do
+          batch = []
+
           loop do
-            batch = [@send_queue.dequeue]
-            drain_send_queue_capped(batch)
+            dequeue_batch_capped(batch)
             @in_flight += batch.size
 
             begin
@@ -147,6 +148,7 @@ module OMQ
             batch.each do |parts|
               @engine.emit_verbose_msg_sent(conn, parts)
             end
+            batch.clear
 
             Async::Task.current.yield
           end
@@ -157,7 +159,8 @@ module OMQ
       end
 
 
-      def drain_send_queue_capped(batch)
+      def dequeue_batch_capped(batch = [])
+        batch << @send_queue.dequeue
         bytes = batch_bytes(batch.first)
 
         while batch.size < BATCH_MSG_CAP && bytes < BATCH_BYTE_CAP

data/lib/omq/routing/sub.rb

@@ -48,7 +48,7 @@ module OMQ
         @connections << connection
 
         @subscriptions.each do |prefix|
-          connection.send_command(Protocol::ZMTP::Codec::Command.subscribe(prefix))
+          send_subscribe(connection, prefix)
         end
 
         task = @engine.start_recv_pump(connection, @recv_queue)
@@ -76,9 +76,7 @@ module OMQ
       #
       def subscribe(prefix)
         @subscriptions << prefix
-        @connections.each do |conn|
-          conn.send_command(Protocol::ZMTP::Codec::Command.subscribe(prefix))
-        end
+        @connections.each { |conn| send_subscribe(conn, prefix) }
       end
 
 
@@ -88,9 +86,7 @@ module OMQ
       #
       def unsubscribe(prefix)
         @subscriptions.delete(prefix)
-        @connections.each do |conn|
-          conn.send_command(Protocol::ZMTP::Codec::Command.cancel(prefix))
-        end
+        @connections.each { |conn| send_cancel(conn, prefix) }
       end
 
 
@@ -103,6 +99,30 @@ module OMQ
         @tasks.clear
       end
 
+
+      private
+
+
+      # Sends a SUBSCRIBE to +conn+ using the wire form the peer understands:
+      # command-form for ZMTP 3.1+, legacy message-form for ZMTP 3.0.
+      #
+      def send_subscribe(conn, prefix)
+        if conn.peer_minor >= 1
+          conn.send_command(Protocol::ZMTP::Codec::Command.subscribe(prefix))
+        else
+          conn.send_message([Protocol::ZMTP::Codec::Subscription.body(prefix)])
+        end
+      end
+
+
+      def send_cancel(conn, prefix)
+        if conn.peer_minor >= 1
+          conn.send_command(Protocol::ZMTP::Codec::Command.cancel(prefix))
+        else
+          conn.send_message([Protocol::ZMTP::Codec::Subscription.body(prefix, cancel: true)])
+        end
+      end
+
     end
   end
 end

data/lib/omq/routing/xsub.rb

@@ -112,9 +112,19 @@ module OMQ
 
             case flag
             when 0x01
-              conn.send_command(Protocol::ZMTP::Codec::Command.subscribe(prefix))
+              if conn.peer_minor >= 1
+                conn.send_command(Protocol::ZMTP::Codec::Command.subscribe(prefix))
+              else
+                conn.send_message([frame])
+              end
             when 0x00
-              conn.send_command(Protocol::ZMTP::Codec::Command.cancel(prefix))
+              if conn.peer_minor >= 1
+                conn.send_command(Protocol::ZMTP::Codec::Command.cancel(prefix))
+              else
+                conn.send_message([frame])
+              end
+            else
+              next
             end
           end
         end

data/lib/omq/routing.rb

@@ -57,7 +57,8 @@ module OMQ
 
 
     # Drains all available messages from +queue+ into +batch+ without
-    # blocking. Call after the initial blocking dequeue.
+    # Blocks for the first message, then sweeps all immediately
+    # available messages into +batch+ without blocking.
     #
     # No cap is needed: IO::Stream auto-flushes at 64 KB, so the
     # write buffer hits the wire naturally under sustained load.
@@ -67,7 +68,9 @@ module OMQ
     # @param batch [Array]
     # @return [void]
     #
-    def self.drain_send_queue(queue, batch)
+    def self.dequeue_batch(queue, batch = [])
+      batch << queue.dequeue
+
       loop do
         msg = queue.dequeue(timeout: 0) or break
         batch << msg

data/lib/omq/transport/inproc/direct_pipe.rb

@@ -20,6 +20,20 @@ module OMQ
         attr_reader :peer_socket_type
 
 
+        # @return [Integer] always 3 — inproc peers are OMQ
+        #
+        def peer_major
+          3
+        end
+
+
+        # @return [Integer] always 1 — inproc peers are OMQ (ZMTP 3.1)
+        #
+        def peer_minor
+          1
+        end
+
+
         # @return [String] peer's identity
         #
         attr_reader :peer_identity
@@ -158,19 +172,20 @@ module OMQ
         end
 
 
-        # Reads one command frame from the internal command queue.
-        # Used by PUB/XPUB subscription listeners.
+        # Reads one frame. Used by PUB/XPUB subscription listeners,
+        # which must see both the legacy message-form subscription
+        # (ZMTP 3.0) and the command-form (ZMTP 3.1).
         #
         # @return [Protocol::ZMTP::Codec::Frame]
         #
         def read_frame
-          loop do
-            item = @receive_queue.dequeue
-            raise EOFError, "connection closed" if item.nil?
+          item = @receive_queue.dequeue
+          raise EOFError, "connection closed" if item.nil?
 
-            if item.is_a?(Array) && item.first == :command
-              return Protocol::ZMTP::Codec::Frame.new(item[1].to_body, command: true)
-            end
+          if item.is_a?(Array) && item.first == :command
+            Protocol::ZMTP::Codec::Frame.new(item[1].to_body, command: true)
+          else
+            Protocol::ZMTP::Codec::Frame.new(item.first || "".b)
           end
         end
 

data/lib/omq/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OMQ
-  VERSION = "0.21.0"
+  VERSION = "0.22.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omq
 version: !ruby/object:Gem::Version
-  version: 0.21.0
+  version: 0.22.1
 platform: ruby
 authors:
 - Patrik Wenger
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: '0.8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: '0.8'
 - !ruby/object:Gem::Dependency
   name: async
   requirement: !ruby/object:Gem::Requirement