omq 0.5.0 → 0.6.0

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

@@ -14,7 +14,8 @@ module OMQ
           @connection = nil
           @recv_queue = Async::LimitedQueue.new(engine.options.recv_hwm)
           @send_queue = Async::LimitedQueue.new(engine.options.send_hwm)
-          @tasks      = []
+          @tasks          = []
+          @send_pump_idle = true
         end
 
         # @return [Async::LimitedQueue]
@@ -56,9 +57,19 @@ module OMQ
 
         private
 
+        def send_pump_idle? = @send_pump_idle
+
+
         def start_send_pump(conn)
-          @send_pump = Reactor.spawn_pump do
-            loop { conn.send_message(@send_queue.dequeue) }
+          @send_pump = @engine.spawn_pump_task(annotation: "send pump") do
+            loop do
+              @send_pump_idle = true
+              batch = [@send_queue.dequeue]
+              @send_pump_idle = false
+              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

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

@@ -12,6 +12,8 @@ module OMQ
       # their #initialize.
       #
       module FanOut
+        attr_reader :subscriber_joined
+
         private
 
         def init_fan_out(engine)
@@ -19,6 +21,9 @@ module OMQ
           @subscriptions      = {} # connection => Set of prefixes
           @send_queue         = Async::LimitedQueue.new(engine.options.send_hwm)
           @send_pump_started  = false
+          @send_pump_idle     = true
+          @conflate           = engine.options.conflate
+          @subscriber_joined  = Async::Promise.new
         end
 
         # @return [Boolean] whether the connection is subscribed to the topic
@@ -38,6 +43,7 @@ module OMQ
         #
         def on_subscribe(conn, prefix)
           @subscriptions[conn] << prefix
+          @subscriber_joined.resolve(conn) unless @subscriber_joined.resolved?
         end
 
         # Called when a cancel command is received from a peer.
@@ -50,26 +56,62 @@ module OMQ
           @subscriptions[conn]&.delete(prefix)
         end
 
+        # @return [Boolean] true when the send pump is idle (not sending a batch)
+        def send_pump_idle? = @send_pump_idle
+
+
         def start_send_pump
           @send_pump_started = true
-          @tasks << Reactor.spawn_pump do
+          @tasks << @engine.spawn_pump_task(annotation: "send 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
+              @send_pump_idle = true
+              batch = [@send_queue.dequeue]
+              @send_pump_idle = false
+              Routing.drain_send_queue(@send_queue, batch)
+
+              written = Set.new
+
+              if @conflate
+                # Keep only the last matching message per connection.
+                latest = {} # conn => parts
+                batch.each do |parts|
+                  topic = parts.first || "".b
+                  @connections.each do |conn|
+                    next unless subscribed?(conn, topic)
+                    latest[conn] = parts
+                  end
                 end
+                latest.each do |conn, parts|
+                  begin
+                    conn.write_message(parts)
+                    written << conn
+                  rescue *ZMTP::CONNECTION_LOST
+                  end
+                end
+              else
+                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
+                    end
+                  end
+                end
+              end
+
+              written.each do |conn|
+                conn.flush
+              rescue *ZMTP::CONNECTION_LOST
               end
             end
           end
         end
 
         def start_subscription_listener(conn)
-          @tasks << Reactor.spawn_pump do
+          @tasks << Reactor.spawn_pump(annotation: "recv pump") do
             loop do
               frame = conn.read_frame
               next unless frame.command?

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

@@ -17,7 +17,8 @@ module OMQ
           @connection = nil
           @recv_queue = Async::LimitedQueue.new(engine.options.recv_hwm)
           @send_queue = Async::LimitedQueue.new(engine.options.send_hwm)
-          @tasks      = []
+          @tasks          = []
+          @send_pump_idle = true
         end
 
         # @return [Async::LimitedQueue]
@@ -59,9 +60,19 @@ module OMQ
 
         private
 
+        def send_pump_idle? = @send_pump_idle
+
+
         def start_send_pump(conn)
-          @send_pump = Reactor.spawn_pump do
-            loop { conn.send_message(@send_queue.dequeue) }
+          @send_pump = @engine.spawn_pump_task(annotation: "send pump") do
+            loop do
+              @send_pump_idle = true
+              batch = [@send_queue.dequeue]
+              @send_pump_idle = false
+              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

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

@@ -21,6 +21,7 @@ module OMQ
           @connections_by_routing_id  = {}
           @tasks                      = []
           @send_pump_started          = false
+          @send_pump_idle             = true
         end
 
         # @return [Async::LimitedQueue]
@@ -59,15 +60,36 @@ module OMQ
 
         private
 
+        def send_pump_idle? = @send_pump_idle
+
+
         def start_send_pump
           @send_pump_started = true
-          @tasks << Reactor.spawn_pump do
+          @tasks << @engine.spawn_pump_task(annotation: "send 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..])
+              @send_pump_idle = true
+              batch = [@send_queue.dequeue]
+              @send_pump_idle = false
+              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

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

@@ -16,37 +16,44 @@ module OMQ
           init_round_robin(engine)
         end
 
+
         # @return [Async::LimitedQueue]
         #
         attr_reader :send_queue
 
+
         # PUSH is write-only.
         #
         def recv_queue
           raise "PUSH 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)
+          start_reaper(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
 
+
+        # Stops all background tasks (send pump, reapers).
         #
         def stop
           @tasks.each(&:stop)
@@ -55,13 +62,13 @@ module OMQ
 
         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.
+
+        # Detects peer disconnection on write-only sockets. Without
+        # this, a dead peer is only noticed on the next send — which
+        # may succeed if the kernel send buffer absorbs the data.
         #
-        def start_monitor(conn)
-          @tasks << Reactor.spawn_pump do
+        def start_reaper(conn)
+          @tasks << Reactor.spawn_pump(annotation: "reaper") do
             conn.receive_message # blocks until peer disconnects
           rescue *ZMTP::CONNECTION_LOST
             @engine.connection_lost(conn)

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

@@ -21,6 +21,7 @@ module OMQ
           @groups            = {} # connection => Set of joined groups
           @send_queue        = Async::LimitedQueue.new(engine.options.send_hwm)
           @send_pump_started = false
+          @conflate          = engine.options.conflate
           @tasks             = []
         end
 
@@ -67,26 +68,58 @@ module OMQ
 
         def start_send_pump
           @send_pump_started = true
-          @tasks << Reactor.spawn_pump do
+          @tasks << @engine.spawn_pump_task(annotation: "send 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
+              @send_pump_idle = true
+              batch = [@send_queue.dequeue]
+              @send_pump_idle = false
+              Routing.drain_send_queue(@send_queue, batch)
+
+              written = Set.new
+
+              if @conflate
+                # Keep only the last matching message per connection.
+                latest = {} # conn => [group, body]
+                batch.each do |parts|
+                  group = parts[0]
+                  body  = parts[1] || "".b
+                  @connections.each do |conn|
+                    next unless @groups[conn]&.include?(group)
+                    latest[conn] = [group, body]
+                  end
+                end
+                latest.each do |conn, msg|
+                  begin
+                    conn.write_message(msg)
+                    written << conn
+                  rescue *ZMTP::CONNECTION_LOST
+                  end
                 end
+              else
+                batch.each do |parts|
+                  group = parts[0]
+                  body  = parts[1] || "".b
+                  @connections.each do |conn|
+                    next unless @groups[conn]&.include?(group)
+                    begin
+                      conn.write_message([group, body])
+                      written << conn
+                    rescue *ZMTP::CONNECTION_LOST
+                    end
+                  end
+                end
+              end
+
+              written.each do |conn|
+                conn.flush
+              rescue *ZMTP::CONNECTION_LOST
               end
             end
           end
         end
 
         def start_group_listener(conn)
-          @tasks << Reactor.spawn_pump do
+          @tasks << Reactor.spawn_pump(annotation: "recv pump") do
             loop do
               frame = conn.read_frame
               next unless frame.command?

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

@@ -19,6 +19,7 @@ module OMQ
           @pending_replies   = []
           @tasks             = []
           @send_pump_started = false
+          @send_pump_idle    = true
         end
 
         # @return [Async::LimitedQueue]
@@ -29,13 +30,11 @@ module OMQ
         #
         def connection_added(connection)
           transform = ->(msg) {
-            envelope = []
-            while msg.first && !msg.first.empty?
-              envelope << msg.shift
-            end
-            msg.shift # remove empty delimiter
+            delimiter = msg.index(&:empty?) || msg.size
+            envelope  = msg[0, delimiter]
+            body      = msg[(delimiter + 1)..] || []
             @pending_replies << { conn: connection, envelope: envelope }
-            msg
+            body
           }
           task = @engine.start_recv_pump(connection, @recv_queue, transform: transform)
           @tasks << task if task
@@ -64,17 +63,37 @@ module OMQ
 
         private
 
+        def send_pump_idle? = @send_pump_idle
+
+
         def start_send_pump
           @send_pump_started = true
-          @tasks << Reactor.spawn_pump do
+          @tasks << @engine.spawn_pump_task(annotation: "send 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])
+              @send_pump_idle = true
+              batch = [@send_queue.dequeue]
+              @send_pump_idle = false
+              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/req.rb

@@ -61,8 +61,7 @@ module OMQ
         # REQ strips the leading empty delimiter frame on receive.
         #
         def transform_recv(msg)
-          msg.shift if msg.first&.empty?
-          msg
+          msg.first&.empty? ? msg[1..] : msg
         end
       end
     end

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

@@ -15,20 +15,31 @@ module OMQ
       module RoundRobin
         private
 
+
+        # Initializes round-robin state for the including class.
+        #
+        # @param engine [Engine]
+        #
         def init_round_robin(engine)
           @connections          = []
           @cycle                = @connections.cycle
           @connection_available = Async::Promise.new
           @send_queue           = Async::LimitedQueue.new(engine.options.send_hwm)
           @send_pump_started    = false
+          @send_pump_idle       = true
         end
 
+
+        # Resolves the connection-available promise so blocked
+        # senders can proceed.
+        #
         def signal_connection_available
           unless @connection_available.resolved?
             @connection_available.resolve(true)
           end
         end
 
+
         # Blocks until a connection is available, then returns
         # the next one in round-robin order.
         #
@@ -43,6 +54,7 @@ module OMQ
           retry
         end
 
+
         # Transforms parts before sending. Override in subclasses
         # (e.g. REQ prepends an empty delimiter frame).
         #
@@ -51,16 +63,38 @@ module OMQ
         #
         def transform_send(parts) = parts
 
+
+        # Starts the background send pump that dequeues messages
+        # and dispatches them round-robin across connections.
+        #
+        # @return [Boolean] true when the send pump is idle (not sending a batch)
+        def send_pump_idle? = @send_pump_idle
+
+
         def start_send_pump
           @send_pump_started = true
-          @tasks << Reactor.spawn_pump do
+          @tasks << @engine.spawn_pump_task(annotation: "send pump") do
             loop do
-              parts = @send_queue.dequeue
-              send_with_retry(parts)
+              @send_pump_idle = true
+              batch = [@send_queue.dequeue]
+              @send_pump_idle = false
+              Routing.drain_send_queue(@send_queue, batch)
+
+              if batch.size == 1
+                send_with_retry(batch[0])
+              else
+                send_batch(batch)
+              end
             end
           end
         end
 
+
+        # Sends a single message, retrying on a new connection if
+        # the current one is lost.
+        #
+        # @param parts [Array<String>]
+        #
         def send_with_retry(parts)
           conn = next_connection
           conn.send_message(transform_send(parts))
@@ -68,6 +102,41 @@ module OMQ
           @engine.connection_lost(conn)
           retry
         end
+
+
+        # Sends a batch of messages, writing without flushing for
+        # throughput. Falls back to #send_with_retry on failure.
+        #
+        # @param batch [Array<Array<String>>]
+        #
+        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

@@ -21,6 +21,7 @@ module OMQ
           @connections_by_identity = {}
           @tasks                   = []
           @send_pump_started       = false
+          @send_pump_idle          = true
         end
 
         # @return [Async::LimitedQueue]
@@ -52,6 +53,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
 
@@ -62,23 +69,36 @@ module OMQ
 
         private
 
+        def send_pump_idle? = @send_pump_idle
+
+
         def start_send_pump
           @send_pump_started = true
-          @tasks << Reactor.spawn_pump do
+          @tasks << @engine.spawn_pump_task(annotation: "send pump") do
             loop do
-              parts = @send_queue.dequeue
-              identity = parts.first
-              conn = @connections_by_identity[identity]
+              @send_pump_idle = true
+              batch = [@send_queue.dequeue]
+              @send_pump_idle = false
+              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