omq 0.4.2 → 0.5.1

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

@@ -54,16 +54,28 @@ module OMQ
           @send_pump_started = true
           @tasks << Reactor.spawn_pump do
             loop do
-              parts = @send_queue.dequeue
-              topic = parts.first || "".b
-              @connections.each do |conn|
-                next unless subscribed?(conn, topic)
-                begin
-                  conn.send_message(parts)
-                rescue *ZMTP::CONNECTION_LOST
-                  # connection dead — will be cleaned up
+              batch = [@send_queue.dequeue]
+              Routing.drain_send_queue(@send_queue, batch)
+
+              written = Set.new
+              batch.each do |parts|
+                topic = parts.first || "".b
+                @connections.each do |conn|
+                  next unless subscribed?(conn, topic)
+                  begin
+                    conn.write_message(parts)
+                    written << conn
+                  rescue *ZMTP::CONNECTION_LOST
+                    # connection dead — will be cleaned up
+                  end
                 end
               end
+
+              written.each do |conn|
+                conn.flush
+              rescue *ZMTP::CONNECTION_LOST
+                # connection dead — will be cleaned up
+              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,17 @@ module OMQ
         private
 
         def start_send_pump(conn)
-          @tasks << Reactor.spawn_pump do
-            loop { conn.send_message(@send_queue.dequeue) }
+          @send_pump = Reactor.spawn_pump do
+            loop do
+              batch = [@send_queue.dequeue]
+              Routing.drain_send_queue(@send_queue, batch)
+              batch.each { |parts| conn.write_message(parts) }
+              conn.flush
+            end
           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,93 @@
+# 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
+              batch = [@send_queue.dequeue]
+              Routing.drain_send_queue(@send_queue, batch)
+
+              written = Set.new
+              batch.each do |parts|
+                routing_id = parts.first
+                conn       = @connections_by_routing_id[routing_id]
+                next unless conn # silently drop if peer gone
+                begin
+                  conn.write_message(parts[1..])
+                  written << conn
+                rescue *ZMTP::CONNECTION_LOST
+                  # will be cleaned up
+                end
+              end
+
+              written.each do |conn|
+                conn.flush
+              rescue *ZMTP::CONNECTION_LOST
+                # will be cleaned up
+              end
+            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,118 @@
+# 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
+              batch = [@send_queue.dequeue]
+              Routing.drain_send_queue(@send_queue, batch)
+
+              written = Set.new
+              batch.each do |parts|
+                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.write_message([group, body])
+                    written << conn
+                  rescue *ZMTP::CONNECTION_LOST
+                    # connection dead — will be cleaned up
+                  end
+                end
+              end
+
+              written.each do |conn|
+                conn.flush
+              rescue *ZMTP::CONNECTION_LOST
+                # connection dead — will be cleaned up
+              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/rep.rb

@@ -68,13 +68,28 @@ module OMQ
           @send_pump_started = true
           @tasks << Reactor.spawn_pump do
             loop do
-              parts = @send_queue.dequeue
-              reply_info = @pending_replies.shift
-              next unless reply_info
-              reply_info[:conn].send_message([*reply_info[:envelope], "".b, *parts])
+              batch = [@send_queue.dequeue]
+              Routing.drain_send_queue(@send_queue, batch)
+
+              written = Set.new
+              batch.each do |parts|
+                reply_info = @pending_replies.shift
+                next unless reply_info
+                conn = reply_info[:conn]
+                begin
+                  conn.write_message([*reply_info[:envelope], "".b, *parts])
+                  written << conn
+                rescue *ZMTP::CONNECTION_LOST
+                  # connection lost mid-write
+                end
+              end
+
+              written.each do |conn|
+                conn.flush
+              rescue *ZMTP::CONNECTION_LOST
+                # connection lost mid-flush
+              end
             end
-          rescue *ZMTP::CONNECTION_LOST
-            # connection lost mid-write
           end
         end
       end

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

@@ -55,8 +55,14 @@ module OMQ
           @send_pump_started = true
           @tasks << Reactor.spawn_pump do
             loop do
-              parts = @send_queue.dequeue
-              send_with_retry(parts)
+              batch = [@send_queue.dequeue]
+              Routing.drain_send_queue(@send_queue, batch)
+
+              if batch.size == 1
+                send_with_retry(batch[0])
+              else
+                send_batch(batch)
+              end
             end
           end
         end
@@ -68,6 +74,35 @@ module OMQ
           @engine.connection_lost(conn)
           retry
         end
+
+        def send_batch(batch)
+          written = Set.new
+          batch.each_with_index do |parts, i|
+            conn = next_connection
+            begin
+              conn.write_message(transform_send(parts))
+              written << conn
+            rescue *ZMTP::CONNECTION_LOST
+              @engine.connection_lost(conn)
+              # Flush what we've written so far
+              written.each do |c|
+                c.flush
+              rescue *ZMTP::CONNECTION_LOST
+                # will be cleaned up
+              end
+              written.clear
+              # Fall back to send_with_retry for this and remaining
+              send_with_retry(parts)
+              batch[(i + 1)..].each { |p| send_with_retry(p) }
+              return
+            end
+          end
+          written.each do |conn|
+            conn.flush
+          rescue *ZMTP::CONNECTION_LOST
+            # will be cleaned up
+          end
+        end
       end
     end
   end

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

@@ -52,6 +52,12 @@ module OMQ
         # @param parts [Array<String>]
         #
         def enqueue(parts)
+          if @engine.options.router_mandatory?
+            identity = parts.first
+            unless @connections_by_identity[identity]
+              raise SocketError, "no route to identity #{identity.inspect}"
+            end
+          end
           @send_queue.enqueue(parts)
         end
 
@@ -66,19 +72,27 @@ module OMQ
           @send_pump_started = true
           @tasks << Reactor.spawn_pump do
             loop do
-              parts = @send_queue.dequeue
-              identity = parts.first
-              conn = @connections_by_identity[identity]
+              batch = [@send_queue.dequeue]
+              Routing.drain_send_queue(@send_queue, batch)
 
-              unless conn
-                if @engine.options.router_mandatory?
-                  raise SocketError, "no route to identity #{identity.inspect}"
+              written = Set.new
+              batch.each do |parts|
+                identity = parts.first
+                conn     = @connections_by_identity[identity]
+                next unless conn # silently drop (peer may have disconnected)
+                begin
+                  conn.write_message(parts[1..])
+                  written << conn
+                rescue *ZMTP::CONNECTION_LOST
+                  # will be cleaned up
                 end
-                next # silently drop
               end
 
-              # Send everything after the identity frame
-              conn.send_message(parts[1..])
+              written.each do |conn|
+                conn.flush
+              rescue *ZMTP::CONNECTION_LOST
+                # will be cleaned up
+              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,93 @@
+# 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
+              batch = [@send_queue.dequeue]
+              Routing.drain_send_queue(@send_queue, batch)
+
+              written = Set.new
+              batch.each do |parts|
+                routing_id = parts.first
+                conn       = @connections_by_routing_id[routing_id]
+                next unless conn # silently drop if peer gone
+                begin
+                  conn.write_message(parts[1..])
+                  written << conn
+                rescue *ZMTP::CONNECTION_LOST
+                  # will be cleaned up
+                end
+              end
+
+              written.each do |conn|
+                conn.flush
+              rescue *ZMTP::CONNECTION_LOST
+                # will be cleaned up
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end