omq 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0dc74658712882f8d0eb8f58b0c9a37c959d50c87116677d23be39904f7002e7
-  data.tar.gz: 1ba17796cac6b1cd594ebbee874428e0675153d461d168e0f69f07abab608ef8
+  metadata.gz: 37d1cbdb4834bd8c3171e5317403066d6cc84f454ab4f3c076655019480634ad
+  data.tar.gz: 95e1712a3c993aad845d499c5b2462c42ab6720aa4c7f4134aab05fd4f972ea5
 SHA512:
-  metadata.gz: 3628a755a53010690ae407ac790eb83ef7592ac5cac34bddff8a62782c20cb6092c3dd300ae71a2dfff324eaf8457ba319305b6892ca259f8990ce63267c74e0
-  data.tar.gz: 76502cad1a484cf8224285fbf4259e9ba8e5daa396caa42ac3716b50ada2e72a4c31b8d256208ab7410f5e48727216fee526efbf6166e3a1a32bb7bc1701cacb
+  metadata.gz: 4e8412637f3eb2adce4451866217018e2947ab0e1ff1324664ff9946d658115ab042d3c429811d0d7c269704c54bb7c6ba2902570a8e882a2e5349b9504665c7
+  data.tar.gz: fc54cbabda462a9a50a9135f9c7f4da202229a768c74f60fff8cfe56fccd6ad7bdfd68a90e4e4525e091b8d0b71640692997596978b696596a33d572227bdbd3

data/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## 0.5.0 — 2026-03-28
+
+### Added
+
+- **Draft socket types** (RFCs 41, 48, 49, 51, 52):
+  - `CLIENT`/`SERVER` — thread-safe REQ/REP without envelope, 4-byte routing IDs
+  - `RADIO`/`DISH` — group-based pub/sub with exact match, JOIN/LEAVE commands.
+    `radio.publish(group, body)`, `radio.send(body, group:)`, `radio << [group, body]`
+  - `SCATTER`/`GATHER` — thread-safe PUSH/PULL
+  - `PEER` — bidirectional multi-peer with 4-byte routing IDs
+  - `CHANNEL` — thread-safe PAIR
+- All draft types enforce single-frame messages (no multipart)
+- Reconnect-after-restart tests for all 10 socket type pairings
+
+### Fixed
+
+- **PUSH/SCATTER silently wrote to dead peers** — write-only sockets had
+  no recv pump to detect peer disconnection. Writes succeeded because the
+  kernel send buffer absorbed the data, preventing reconnect from
+  triggering. Added background monitor task per connection.
+- **PAIR/CHANNEL stale send pump after reconnect** — old send pump kept
+  its captured connection reference and raced with the new send pump,
+  sending to the dead connection. Now stopped in `connection_removed`.
+
 ## 0.4.2 — 2026-03-27
 
 ### Fixed

data/README.md

@@ -18,7 +18,7 @@ Pure Ruby implementation of the [ZMTP 3.1](https://rfc.zeromq.org/spec/23/) wire
 ## Highlights
 
 - **Pure Ruby** — no C extensions, no FFI, no libzmq/libczmq dependency
-- **All socket types** — req/rep, pub/sub, push/pull, dealer/router, xpub/xsub, pair
+- **All socket types** — req/rep, pub/sub, push/pull, dealer/router, xpub/xsub, pair + draft types (client/server, radio/dish, scatter/gather, peer, channel)
 - **Async-native** — built on [Async](https://github.com/socketry/async) fibers, also works with plain threads
 - **Ruby-idiomatic API** — messages as `Array<String>`, errors as exceptions, timeouts as `IO::TimeoutError`
 - **All transports** — tcp, ipc, inproc
@@ -112,6 +112,11 @@ end
 | Pipeline | `PUSH`, `PULL` | unidirectional |
 | Routing | `DEALER`, `ROUTER` | bidirectional |
 | Exclusive pair | `PAIR` | bidirectional |
+| Client/Server | `CLIENT`, `SERVER` | bidirectional |
+| Group messaging | `RADIO`, `DISH` | unidirectional |
+| Pipeline (draft) | `SCATTER`, `GATHER` | unidirectional |
+| Peer-to-peer | `PEER` | bidirectional |
+| Channel (draft) | `CHANNEL` | bidirectional |
 
 All classes live under `OMQ::`. For the purists, `ØMQ` is an alias:
 

data/lib/omq/channel.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module OMQ
+  class CHANNEL < Socket
+    include ZMTP::Readable
+    include ZMTP::Writable
+    include ZMTP::SingleFrame
+
+    def initialize(endpoints = nil, linger: 0)
+      _init_engine(:CHANNEL, linger: linger)
+      _attach(endpoints, default: :connect)
+    end
+  end
+end

data/lib/omq/client_server.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module OMQ
+  class CLIENT < Socket
+    include ZMTP::Readable
+    include ZMTP::Writable
+    include ZMTP::SingleFrame
+
+    def initialize(endpoints = nil, linger: 0)
+      _init_engine(:CLIENT, linger: linger)
+      _attach(endpoints, default: :connect)
+    end
+  end
+
+  class SERVER < Socket
+    include ZMTP::Readable
+    include ZMTP::Writable
+    include ZMTP::SingleFrame
+
+    def initialize(endpoints = nil, linger: 0)
+      _init_engine(:SERVER, linger: linger)
+      _attach(endpoints, default: :bind)
+    end
+
+    # Sends a message to a specific peer by routing ID.
+    #
+    # @param routing_id [String] 4-byte routing ID
+    # @param message [String] message body
+    # @return [self]
+    #
+    def send_to(routing_id, message)
+      parts = [routing_id.b.freeze, message.b.freeze]
+      with_timeout(@options.write_timeout) { @engine.enqueue_send(parts) }
+      self
+    end
+  end
+end

data/lib/omq/peer.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module OMQ
+  class PEER < Socket
+    include ZMTP::Readable
+    include ZMTP::Writable
+    include ZMTP::SingleFrame
+
+    def initialize(endpoints = nil, linger: 0)
+      _init_engine(:PEER, linger: linger)
+      _attach(endpoints, default: :connect)
+    end
+
+    # Sends a message to a specific peer by routing ID.
+    #
+    # @param routing_id [String] 4-byte routing ID
+    # @param message [String] message body
+    # @return [self]
+    #
+    def send_to(routing_id, message)
+      parts = [routing_id.b.freeze, message.b.freeze]
+      with_timeout(@options.write_timeout) { @engine.enqueue_send(parts) }
+      self
+    end
+  end
+end

data/lib/omq/radio_dish.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module OMQ
+  class RADIO < Socket
+    include ZMTP::Writable
+
+    def initialize(endpoints = nil, linger: 0)
+      _init_engine(:RADIO, linger: linger)
+      _attach(endpoints, default: :bind)
+    end
+
+    # Publishes a message to a group.
+    #
+    # @param group [String] group name
+    # @param body [String] message body
+    # @return [self]
+    #
+    def publish(group, body)
+      with_timeout(@options.write_timeout) do
+        @engine.enqueue_send([group.b.freeze, body.b.freeze])
+      end
+      self
+    end
+
+    # Sends a message to a group.
+    #
+    # @param message [String] message body (requires group: kwarg)
+    # @param group [String] group name
+    # @return [self]
+    #
+    def send(message, group: nil)
+      raise ArgumentError, "RADIO requires a group (use group: kwarg, publish, or << [group, body])" unless group
+      publish(group, message)
+    end
+
+    # Sends a message to a group via [group, body] array.
+    #
+    # @param message [Array<String>] [group, body]
+    # @return [self]
+    #
+    def <<(message)
+      raise ArgumentError, "RADIO requires [group, body] array" unless message.is_a?(Array) && message.size == 2
+      publish(message[0], message[1])
+    end
+  end
+
+  class DISH < Socket
+    include ZMTP::Readable
+
+    def initialize(endpoints = nil, linger: 0, group: nil)
+      _init_engine(:DISH, linger: linger)
+      _attach(endpoints, default: :connect)
+      join(group) if group
+    end
+
+    # Joins a group.
+    #
+    # @param group [String]
+    # @return [void]
+    #
+    def join(group)
+      @engine.routing.join(group)
+    end
+
+    # Leaves a group.
+    #
+    # @param group [String]
+    # @return [void]
+    #
+    def leave(group)
+      @engine.routing.leave(group)
+    end
+  end
+end

data/lib/omq/scatter_gather.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module OMQ
+  class SCATTER < Socket
+    include ZMTP::Writable
+    include ZMTP::SingleFrame
+
+    def initialize(endpoints = nil, linger: 0, send_hwm: nil, send_timeout: nil)
+      _init_engine(:SCATTER, linger: linger, send_hwm: send_hwm, send_timeout: send_timeout)
+      _attach(endpoints, default: :connect)
+    end
+  end
+
+  class GATHER < Socket
+    include ZMTP::Readable
+    include ZMTP::SingleFrame
+
+    def initialize(endpoints = nil, linger: 0, recv_hwm: nil, recv_timeout: nil)
+      _init_engine(:GATHER, linger: linger, recv_hwm: recv_hwm, recv_timeout: recv_timeout)
+      _attach(endpoints, default: :bind)
+    end
+  end
+end

data/lib/omq/version.rb

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

data/lib/omq/zmtp/codec/command.rb

@@ -101,6 +101,24 @@ module OMQ
           new("CANCEL", prefix.b)
         end
 
+        # Builds a JOIN command (RADIO/DISH group subscription).
+        #
+        # @param group [String] group name
+        # @return [Command]
+        #
+        def self.join(group)
+          new("JOIN", group.b)
+        end
+
+        # Builds a LEAVE command (RADIO/DISH group unsubscription).
+        #
+        # @param group [String] group name
+        # @return [Command]
+        #
+        def self.leave(group)
+          new("LEAVE", group.b)
+        end
+
         # Builds a PING command.
         #
         # @param ttl [Numeric] time-to-live in seconds (sent as deciseconds)

data/lib/omq/zmtp/routing/channel.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module OMQ
+  module ZMTP
+    module Routing
+      # CHANNEL socket routing: exclusive 1-to-1 bidirectional.
+      #
+      class Channel
+
+        # @param engine [Engine]
+        #
+        def initialize(engine)
+          @engine     = engine
+          @connection = nil
+          @recv_queue = Async::LimitedQueue.new(engine.options.recv_hwm)
+          @send_queue = Async::LimitedQueue.new(engine.options.send_hwm)
+          @tasks      = []
+        end
+
+        # @return [Async::LimitedQueue]
+        #
+        attr_reader :recv_queue, :send_queue
+
+        # @param connection [Connection]
+        # @raise [RuntimeError] if a connection already exists
+        #
+        def connection_added(connection)
+          raise "CHANNEL allows only one peer" if @connection
+          @connection = connection
+          task = @engine.start_recv_pump(connection, @recv_queue)
+          @tasks << task if task
+          start_send_pump(connection)
+        end
+
+        # @param connection [Connection]
+        #
+        def connection_removed(connection)
+          if @connection == connection
+            @connection = nil
+            @send_pump&.stop
+            @send_pump = nil
+          end
+        end
+
+        # @param parts [Array<String>]
+        #
+        def enqueue(parts)
+          @send_queue.enqueue(parts)
+        end
+
+        #
+        def stop
+          @tasks.each(&:stop)
+          @tasks.clear
+        end
+
+        private
+
+        def start_send_pump(conn)
+          @send_pump = Reactor.spawn_pump do
+            loop { conn.send_message(@send_queue.dequeue) }
+          rescue *ZMTP::CONNECTION_LOST
+            @engine.connection_lost(conn)
+          end
+          @tasks << @send_pump
+        end
+      end
+    end
+  end
+end

data/lib/omq/zmtp/routing/client.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module OMQ
+  module ZMTP
+    module Routing
+      # CLIENT socket routing: round-robin send, fair-queue receive.
+      #
+      # Same as DEALER — no envelope manipulation.
+      #
+      class Client
+        include RoundRobin
+
+        # @param engine [Engine]
+        #
+        def initialize(engine)
+          @engine     = engine
+          @recv_queue = Async::LimitedQueue.new(engine.options.recv_hwm)
+          @tasks      = []
+          init_round_robin(engine)
+        end
+
+        # @return [Async::LimitedQueue]
+        #
+        attr_reader :recv_queue, :send_queue
+
+        # @param connection [Connection]
+        #
+        def connection_added(connection)
+          @connections << connection
+          signal_connection_available
+          task = @engine.start_recv_pump(connection, @recv_queue)
+          @tasks << task if task
+          start_send_pump unless @send_pump_started
+        end
+
+        # @param connection [Connection]
+        #
+        def connection_removed(connection)
+          @connections.delete(connection)
+        end
+
+        # @param parts [Array<String>]
+        #
+        def enqueue(parts)
+          @send_queue.enqueue(parts)
+        end
+
+        #
+        def stop
+          @tasks.each(&:stop)
+          @tasks.clear
+        end
+      end
+    end
+  end
+end

data/lib/omq/zmtp/routing/dish.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module OMQ
+  module ZMTP
+    module Routing
+      # DISH socket routing: group-based receive from RADIO peers.
+      #
+      # Sends JOIN/LEAVE commands to connected RADIO peers.
+      # Receives two-frame messages (group + body) from RADIO.
+      #
+      class Dish
+
+        # @param engine [Engine]
+        #
+        def initialize(engine)
+          @engine      = engine
+          @connections = []
+          @recv_queue  = Async::LimitedQueue.new(engine.options.recv_hwm)
+          @groups      = Set.new
+          @tasks       = []
+        end
+
+        # @return [Async::LimitedQueue]
+        #
+        attr_reader :recv_queue
+
+        # @param connection [Connection]
+        #
+        def connection_added(connection)
+          @connections << connection
+          # Send existing group memberships to new peer
+          @groups.each do |group|
+            connection.send_command(Codec::Command.join(group))
+          end
+          task = @engine.start_recv_pump(connection, @recv_queue)
+          @tasks << task if task
+        end
+
+        # @param connection [Connection]
+        #
+        def connection_removed(connection)
+          @connections.delete(connection)
+        end
+
+        # DISH is read-only.
+        #
+        def enqueue(_parts)
+          raise "DISH sockets cannot send"
+        end
+
+        # Joins a group.
+        #
+        # @param group [String]
+        #
+        def join(group)
+          @groups << group
+          @connections.each do |conn|
+            conn.send_command(Codec::Command.join(group))
+          end
+        end
+
+        # Leaves a group.
+        #
+        # @param group [String]
+        #
+        def leave(group)
+          @groups.delete(group)
+          @connections.each do |conn|
+            conn.send_command(Codec::Command.leave(group))
+          end
+        end
+
+        def stop
+          @tasks.each(&:stop)
+          @tasks.clear
+        end
+      end
+    end
+  end
+end

data/lib/omq/zmtp/routing/gather.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module OMQ
+  module ZMTP
+    module Routing
+      # GATHER socket routing: fair-queue receive from SCATTER peers.
+      #
+      class Gather
+        # @param engine [Engine]
+        #
+        def initialize(engine)
+          @engine     = engine
+          @recv_queue = Async::LimitedQueue.new(engine.options.recv_hwm)
+          @tasks      = []
+        end
+
+        # @return [Async::LimitedQueue]
+        #
+        attr_reader :recv_queue
+
+        # @param connection [Connection]
+        #
+        def connection_added(connection)
+          task = @engine.start_recv_pump(connection, @recv_queue)
+          @tasks << task if task
+        end
+
+        # @param connection [Connection]
+        #
+        def connection_removed(connection)
+          # recv pump stops on CONNECTION_LOST
+        end
+
+        # GATHER is read-only.
+        #
+        def enqueue(_parts)
+          raise "GATHER sockets cannot send"
+        end
+
+        #
+        def stop
+          @tasks.each(&:stop)
+          @tasks.clear
+        end
+      end
+    end
+  end
+end

data/lib/omq/zmtp/routing/pair.rb

@@ -38,7 +38,11 @@ module OMQ
         # @param connection [Connection]
         #
         def connection_removed(connection)
-          @connection = nil if @connection == connection
+          if @connection == connection
+            @connection = nil
+            @send_pump&.stop
+            @send_pump = nil
+          end
         end
 
         # @param parts [Array<String>]
@@ -56,11 +60,12 @@ module OMQ
         private
 
         def start_send_pump(conn)
-          @tasks << Reactor.spawn_pump do
+          @send_pump = Reactor.spawn_pump do
             loop { conn.send_message(@send_queue.dequeue) }
           rescue *ZMTP::CONNECTION_LOST
             @engine.connection_lost(conn)
           end
+          @tasks << @send_pump
         end
       end
     end

data/lib/omq/zmtp/routing/peer.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module OMQ
+  module ZMTP
+    module Routing
+      # PEER socket routing: bidirectional multi-peer with auto-generated
+      # 4-byte routing IDs.
+      #
+      # Prepends routing ID on receive. Strips routing ID on send and
+      # routes to the identified connection.
+      #
+      class Peer
+        # @param engine [Engine]
+        #
+        def initialize(engine)
+          @engine                     = engine
+          @recv_queue                 = Async::LimitedQueue.new(engine.options.recv_hwm)
+          @send_queue                 = Async::LimitedQueue.new(engine.options.send_hwm)
+          @connections_by_routing_id  = {}
+          @tasks                      = []
+          @send_pump_started          = false
+        end
+
+        # @return [Async::LimitedQueue]
+        #
+        attr_reader :recv_queue, :send_queue
+
+        # @param connection [Connection]
+        #
+        def connection_added(connection)
+          routing_id = SecureRandom.bytes(4)
+          @connections_by_routing_id[routing_id] = connection
+
+          task = @engine.start_recv_pump(connection, @recv_queue,
+                   transform: ->(msg) { [routing_id, *msg] })
+          @tasks << task if task
+
+          start_send_pump unless @send_pump_started
+        end
+
+        # @param connection [Connection]
+        #
+        def connection_removed(connection)
+          @connections_by_routing_id.reject! { |_, c| c == connection }
+        end
+
+        # @param parts [Array<String>]
+        #
+        def enqueue(parts)
+          @send_queue.enqueue(parts)
+        end
+
+        def stop
+          @tasks.each(&:stop)
+          @tasks.clear
+        end
+
+        private
+
+        def start_send_pump
+          @send_pump_started = true
+          @tasks << Reactor.spawn_pump do
+            loop do
+              parts      = @send_queue.dequeue
+              routing_id = parts.first
+              conn       = @connections_by_routing_id[routing_id]
+              next unless conn # silently drop if peer gone
+              conn.send_message(parts[1..])
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omq/zmtp/routing/push.rb

@@ -32,6 +32,7 @@ module OMQ
           @connections << connection
           signal_connection_available
           start_send_pump unless @send_pump_started
+          start_monitor(connection)
         end
 
         # @param connection [Connection]
@@ -51,6 +52,21 @@ module OMQ
           @tasks.each(&:stop)
           @tasks.clear
         end
+
+        private
+
+        # Monitors a connection for disconnection.
+        # Write-only sockets have no recv pump, so without this monitor
+        # a dead peer is only detected on the next send — which may
+        # succeed if the kernel send buffer absorbs the data.
+        #
+        def start_monitor(conn)
+          @tasks << Reactor.spawn_pump do
+            conn.receive_message # blocks until peer disconnects
+          rescue *ZMTP::CONNECTION_LOST
+            @engine.connection_lost(conn)
+          end
+        end
       end
     end
   end

data/lib/omq/zmtp/routing/radio.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module OMQ
+  module ZMTP
+    module Routing
+      # RADIO socket routing: group-based fan-out to DISH peers.
+      #
+      # Like PUB/FanOut but with exact group matching and JOIN/LEAVE
+      # commands instead of SUBSCRIBE/CANCEL.
+      #
+      # Messages are sent as two frames on the wire:
+      #   group (MORE=1) + body (MORE=0)
+      #
+      class Radio
+
+        # @param engine [Engine]
+        #
+        def initialize(engine)
+          @engine            = engine
+          @connections       = []
+          @groups            = {} # connection => Set of joined groups
+          @send_queue        = Async::LimitedQueue.new(engine.options.send_hwm)
+          @send_pump_started = false
+          @tasks             = []
+        end
+
+        # @return [Async::LimitedQueue]
+        #
+        attr_reader :send_queue
+
+        # RADIO is write-only.
+        #
+        def recv_queue
+          raise "RADIO sockets cannot receive"
+        end
+
+        # @param connection [Connection]
+        #
+        def connection_added(connection)
+          @connections << connection
+          @groups[connection] = Set.new
+          start_group_listener(connection)
+          start_send_pump unless @send_pump_started
+        end
+
+        # @param connection [Connection]
+        #
+        def connection_removed(connection)
+          @connections.delete(connection)
+          @groups.delete(connection)
+        end
+
+        # Enqueues a message for sending.
+        #
+        # @param parts [Array<String>] [group, body]
+        #
+        def enqueue(parts)
+          @send_queue.enqueue(parts)
+        end
+
+        def stop
+          @tasks.each(&:stop)
+          @tasks.clear
+        end
+
+        private
+
+        def start_send_pump
+          @send_pump_started = true
+          @tasks << Reactor.spawn_pump do
+            loop do
+              parts = @send_queue.dequeue
+              group = parts[0]
+              body  = parts[1] || "".b
+              @connections.each do |conn|
+                next unless @groups[conn]&.include?(group)
+                begin
+                  # Wire format: group frame (MORE) + body frame
+                  conn.send_message([group, body])
+                rescue *ZMTP::CONNECTION_LOST
+                  # connection dead — will be cleaned up
+                end
+              end
+            end
+          end
+        end
+
+        def start_group_listener(conn)
+          @tasks << Reactor.spawn_pump do
+            loop do
+              frame = conn.read_frame
+              next unless frame.command?
+              cmd = Codec::Command.from_body(frame.body)
+              case cmd.name
+              when "JOIN"  then @groups[conn]&.add(cmd.data)
+              when "LEAVE" then @groups[conn]&.delete(cmd.data)
+              end
+            end
+          rescue *ZMTP::CONNECTION_LOST
+            @engine.connection_lost(conn)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omq/zmtp/routing/scatter.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module OMQ
+  module ZMTP
+    module Routing
+      # SCATTER socket routing: round-robin send to GATHER peers.
+      #
+      class Scatter
+        include RoundRobin
+
+        # @param engine [Engine]
+        #
+        def initialize(engine)
+          @engine = engine
+          @tasks  = []
+          init_round_robin(engine)
+        end
+
+        # @return [Async::LimitedQueue]
+        #
+        attr_reader :send_queue
+
+        # SCATTER is write-only.
+        #
+        def recv_queue
+          raise "SCATTER sockets cannot receive"
+        end
+
+        # @param connection [Connection]
+        #
+        def connection_added(connection)
+          @connections << connection
+          signal_connection_available
+          start_send_pump unless @send_pump_started
+          start_monitor(connection)
+        end
+
+        # @param connection [Connection]
+        #
+        def connection_removed(connection)
+          @connections.delete(connection)
+        end
+
+        # @param parts [Array<String>]
+        #
+        def enqueue(parts)
+          @send_queue.enqueue(parts)
+        end
+
+        #
+        def stop
+          @tasks.each(&:stop)
+          @tasks.clear
+        end
+
+        private
+
+        def start_monitor(conn)
+          @tasks << Reactor.spawn_pump do
+            conn.receive_message
+          rescue *ZMTP::CONNECTION_LOST
+            @engine.connection_lost(conn)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omq/zmtp/routing/server.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module OMQ
+  module ZMTP
+    module Routing
+      # SERVER socket routing: identity-based routing with auto-generated
+      # 4-byte routing IDs.
+      #
+      # Prepends routing ID on receive. Strips routing ID on send and
+      # routes to the identified connection.
+      #
+      class Server
+        # @param engine [Engine]
+        #
+        def initialize(engine)
+          @engine                     = engine
+          @recv_queue                 = Async::LimitedQueue.new(engine.options.recv_hwm)
+          @send_queue                 = Async::LimitedQueue.new(engine.options.send_hwm)
+          @connections_by_routing_id  = {}
+          @tasks                      = []
+          @send_pump_started          = false
+        end
+
+        # @return [Async::LimitedQueue]
+        #
+        attr_reader :recv_queue, :send_queue
+
+        # @param connection [Connection]
+        #
+        def connection_added(connection)
+          routing_id = SecureRandom.bytes(4)
+          @connections_by_routing_id[routing_id] = connection
+
+          task = @engine.start_recv_pump(connection, @recv_queue,
+                   transform: ->(msg) { [routing_id, *msg] })
+          @tasks << task if task
+
+          start_send_pump unless @send_pump_started
+        end
+
+        # @param connection [Connection]
+        #
+        def connection_removed(connection)
+          @connections_by_routing_id.reject! { |_, c| c == connection }
+        end
+
+        # @param parts [Array<String>]
+        #
+        def enqueue(parts)
+          @send_queue.enqueue(parts)
+        end
+
+        def stop
+          @tasks.each(&:stop)
+          @tasks.clear
+        end
+
+        private
+
+        def start_send_pump
+          @send_pump_started = true
+          @tasks << Reactor.spawn_pump do
+            loop do
+              parts      = @send_queue.dequeue
+              routing_id = parts.first
+              conn       = @connections_by_routing_id[routing_id]
+              next unless conn # silently drop if peer gone
+              conn.send_message(parts[1..])
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omq/zmtp/routing.rb

@@ -28,8 +28,16 @@ module OMQ
         when :SUB    then Sub
         when :XPUB   then XPub
         when :XSUB   then XSub
-        when :PUSH   then Push
-        when :PULL   then Pull
+        when :PUSH    then Push
+        when :PULL    then Pull
+        when :CLIENT  then Client
+        when :SERVER  then Server
+        when :RADIO   then Radio
+        when :DISH    then Dish
+        when :SCATTER then Scatter
+        when :GATHER  then Gather
+        when :PEER    then Peer
+        when :CHANNEL then Channel
         else raise ArgumentError, "unknown socket type: #{socket_type}"
         end
       end

data/lib/omq/zmtp/single_frame.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module OMQ
+  module ZMTP
+    # Mixin that rejects multipart messages.
+    #
+    # All draft socket types (CLIENT, SERVER, RADIO, DISH, SCATTER,
+    # GATHER, PEER, CHANNEL) require single-frame messages for
+    # thread-safe atomic operations.
+    #
+    module SingleFrame
+      def send(message)
+        if message.is_a?(Array) && message.size > 1
+          raise ArgumentError, "#{self.class} does not support multipart messages"
+        end
+        super
+      end
+    end
+  end
+end

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

@@ -17,7 +17,7 @@ module OMQ
       module Inproc
         # Socket types that exchange commands (SUBSCRIBE/CANCEL) over inproc.
         #
-        COMMAND_TYPES = %i[PUB SUB XPUB XSUB].freeze
+        COMMAND_TYPES = %i[PUB SUB XPUB XSUB RADIO DISH].freeze
 
         # Global registry of bound inproc endpoints.
         #

data/lib/omq/zmtp/valid_peers.rb

@@ -14,8 +14,16 @@ module OMQ
       SUB:    %i[PUB XPUB].freeze,
       XPUB:   %i[SUB XSUB].freeze,
       XSUB:   %i[PUB XPUB].freeze,
-      PUSH:   %i[PULL].freeze,
-      PULL:   %i[PUSH].freeze,
+      PUSH:    %i[PULL].freeze,
+      PULL:    %i[PUSH].freeze,
+      CLIENT:  %i[SERVER].freeze,
+      SERVER:  %i[CLIENT].freeze,
+      RADIO:   %i[DISH].freeze,
+      DISH:    %i[RADIO].freeze,
+      SCATTER: %i[GATHER].freeze,
+      GATHER:  %i[SCATTER].freeze,
+      PEER:    %i[PEER].freeze,
+      CHANNEL: %i[CHANNEL].freeze,
     }.freeze
   end
 end

data/lib/omq/zmtp.rb

@@ -63,6 +63,15 @@ require_relative "zmtp/routing/xpub"
 require_relative "zmtp/routing/xsub"
 require_relative "zmtp/routing/push"
 require_relative "zmtp/routing/pull"
+require_relative "zmtp/routing/scatter"
+require_relative "zmtp/routing/gather"
+require_relative "zmtp/routing/channel"
+require_relative "zmtp/routing/client"
+require_relative "zmtp/routing/server"
+require_relative "zmtp/routing/radio"
+require_relative "zmtp/routing/dish"
+require_relative "zmtp/routing/peer"
+require_relative "zmtp/single_frame"
 require_relative "zmtp/engine"
 require_relative "zmtp/readable"
 require_relative "zmtp/writable"

data/lib/omq.rb

@@ -17,6 +17,11 @@ require_relative "omq/router_dealer"
 require_relative "omq/pub_sub"
 require_relative "omq/push_pull"
 require_relative "omq/pair"
+require_relative "omq/scatter_gather"
+require_relative "omq/channel"
+require_relative "omq/client_server"
+require_relative "omq/radio_dish"
+require_relative "omq/peer"
 
 # For the purists.
 ØMQ = OMQ

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omq
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.5.0
 platform: ruby
 authors:
 - Patrik Wenger
@@ -51,11 +51,16 @@ files:
 - README.md
 - exe/omqcat
 - lib/omq.rb
+- lib/omq/channel.rb
+- lib/omq/client_server.rb
 - lib/omq/pair.rb
+- lib/omq/peer.rb
 - lib/omq/pub_sub.rb
 - lib/omq/push_pull.rb
+- lib/omq/radio_dish.rb
 - lib/omq/req_rep.rb
 - lib/omq/router_dealer.rb
+- lib/omq/scatter_gather.rb
 - lib/omq/socket.rb
 - lib/omq/version.rb
 - lib/omq/zmtp.rb
@@ -70,19 +75,28 @@ files:
 - lib/omq/zmtp/reactor.rb
 - lib/omq/zmtp/readable.rb
 - lib/omq/zmtp/routing.rb
+- lib/omq/zmtp/routing/channel.rb
+- lib/omq/zmtp/routing/client.rb
 - lib/omq/zmtp/routing/dealer.rb
+- lib/omq/zmtp/routing/dish.rb
 - lib/omq/zmtp/routing/fan_out.rb
+- lib/omq/zmtp/routing/gather.rb
 - lib/omq/zmtp/routing/pair.rb
+- lib/omq/zmtp/routing/peer.rb
 - lib/omq/zmtp/routing/pub.rb
 - lib/omq/zmtp/routing/pull.rb
 - lib/omq/zmtp/routing/push.rb
+- lib/omq/zmtp/routing/radio.rb
 - lib/omq/zmtp/routing/rep.rb
 - lib/omq/zmtp/routing/req.rb
 - lib/omq/zmtp/routing/round_robin.rb
 - lib/omq/zmtp/routing/router.rb
+- lib/omq/zmtp/routing/scatter.rb
+- lib/omq/zmtp/routing/server.rb
 - lib/omq/zmtp/routing/sub.rb
 - lib/omq/zmtp/routing/xpub.rb
 - lib/omq/zmtp/routing/xsub.rb
+- lib/omq/zmtp/single_frame.rb
 - lib/omq/zmtp/transport/inproc.rb
 - lib/omq/zmtp/transport/ipc.rb
 - lib/omq/zmtp/transport/tcp.rb