omq 0.22.0 → 0.23.0

data/lib/omq/radio_dish.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+# OMQ RADIO/DISH socket types with UDP transport (ZeroMQ RFC 48).
+#
+# Not loaded by +require "omq"+; opt in with:
+#
+#   require "omq/radio_dish"
+#
+# Loading this file also registers the +udp://+ transport.
+
+require "omq"
+require_relative "routing/radio"
+require_relative "routing/dish"
+require_relative "transport/udp"
+
+module OMQ
+  # Group-based publisher socket (ZeroMQ RFC 48).
+  #
+  # Sends messages to DISH peers that have joined the target group.
+  # Supports both TCP and UDP transports.
+  class RADIO < Socket
+    include Writable
+
+    # Creates a new RADIO socket.
+    #
+    # @param endpoints [String, Array<String>, nil] endpoint(s) to bind to
+    # @param linger [Numeric] linger period in seconds (Float::INFINITY = wait forever, 0 = drop)
+    # @param on_mute [Symbol] behaviour when HWM is reached (+:drop_newest+ or +:block+)
+    # @param conflate [Boolean] if true, keep only the latest message per group per peer
+    # @param backend [Object, nil] optional transport backend
+    def initialize(endpoints = nil, linger: Float::INFINITY, on_mute: :drop_newest, conflate: false, backend: nil)
+      init_engine(:RADIO, on_mute: on_mute, conflate: conflate, backend: backend)
+      @options.linger = linger
+      attach_endpoints(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)
+      parts = [group.b.freeze, body.b.freeze]
+      Reactor.run timeout: @options.write_timeout do
+        @engine.enqueue_send(parts)
+      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
+
+
+  # Group-based subscriber socket (ZeroMQ RFC 48).
+  #
+  # Receives messages from RADIO peers for joined groups.
+  # Supports both TCP and UDP transports.
+  class DISH < Socket
+    include Readable
+
+    # Creates a new DISH socket.
+    #
+    # @param endpoints [String, Array<String>, nil] endpoint(s) to connect to
+    # @param linger [Numeric] linger period in seconds (Float::INFINITY = wait forever, 0 = drop)
+    # @param group [String, nil] initial group to join
+    # @param on_mute [Symbol] behaviour when HWM is reached (+:block+ or +:drop_newest+)
+    # @param backend [Object, nil] optional transport backend
+    def initialize(endpoints = nil, linger: Float::INFINITY, group: nil, on_mute: :block, backend: nil)
+      init_engine(:DISH, on_mute: on_mute, backend: backend)
+      @options.linger = linger
+      attach_endpoints(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
+
+
+  Routing.register(:RADIO, Routing::Radio)
+  Routing.register(:DISH,  Routing::Dish)
+end

data/lib/omq/reactor.rb

@@ -25,6 +25,11 @@ module OMQ
 
 
     class << self
+      # @return [Hash{Numeric => Integer}] linger value → active socket count
+      #
+      attr_reader :lingers
+
+
       # Returns the root Async task inside the shared IO thread.
       # Starts the thread exactly once (double-checked lock).
       #
@@ -69,7 +74,7 @@ module OMQ
         else
           result = Async::Promise.new
           root_task # ensure started
-          @work_queue.push([block, result, timeout])
+          @work_queue << [block, result, timeout]
           result.wait
         end
       end
@@ -89,9 +94,12 @@ module OMQ
       # @param seconds [Numeric, nil] linger value
       #
       def untrack_linger(seconds)
-        key = seconds || 0
+        key            = seconds || 0
         @lingers[key] -= 1
-        @lingers.delete(key) if @lingers[key] <= 0
+
+        if @lingers[key] <= 0
+          @lingers.delete(key)
+        end
       end
 
 
@@ -103,13 +111,14 @@ module OMQ
         return unless @thread&.alive?
 
         max_linger = @lingers.empty? ? 0 : @lingers.keys.max
-        @work_queue&.push(nil)
+
+        @work_queue << nil if @work_queue
         @thread&.join(max_linger + 1)
 
         @thread     = nil
         @root_task  = nil
         @work_queue = nil
-        @lingers    = Hash.new(0)
+        @lingers.clear
       end
 
 

data/lib/omq/routing/channel.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module OMQ
+  module Routing
+    # CHANNEL socket routing: exclusive 1-to-1 bidirectional.
+    #
+    class Channel
+      # @return [Async::LimitedQueue]
+      #
+      attr_reader :recv_queue
+
+
+      # @param engine [Engine]
+      #
+      def initialize(engine)
+        @engine        = engine
+        @connection    = nil
+        @recv_queue    = Routing.build_queue(engine.options.recv_hwm, :block)
+        @send_queue    = nil
+        @staging_queue = Routing.build_queue(engine.options.send_hwm, :block)
+      end
+
+
+      # Dequeues the next received message. Blocks until one is available.
+      #
+      # @return [Array<String>, nil]
+      #
+      def dequeue_recv
+        @recv_queue.dequeue
+      end
+
+
+      # Wakes a blocked {#dequeue_recv} with a nil sentinel.
+      #
+      # @return [void]
+      #
+      def unblock_recv
+        @recv_queue.enqueue(nil)
+      end
+
+
+      # @param connection [Connection]
+      # @raise [RuntimeError] if a connection already exists
+      #
+      def connection_added(connection)
+        raise "CHANNEL allows only one peer" if @connection
+        @connection = connection
+
+        @engine.start_recv_pump(connection, @recv_queue)
+
+        unless connection.is_a?(Transport::Inproc::DirectPipe)
+          @send_queue = Routing.build_queue(@engine.options.send_hwm, :block)
+          while (msg = @staging_queue.dequeue(timeout: 0))
+            @send_queue.enqueue(msg)
+          end
+          start_send_pump(connection)
+        end
+      end
+
+
+      # @param connection [Connection]
+      #
+      def connection_removed(connection)
+        if @connection == connection
+          @connection = nil
+          @send_queue = nil
+        end
+      end
+
+
+      # @param parts [Array<String>]
+      #
+      def enqueue(parts)
+        conn = @connection
+        if conn.is_a?(Transport::Inproc::DirectPipe) && conn.direct_recv_queue
+          conn.send_message(parts)
+        elsif @send_queue
+          @send_queue.enqueue(parts)
+        else
+          @staging_queue.enqueue(parts)
+        end
+      end
+
+
+      # True when the staging and send queues are empty.
+      #
+      def send_queues_drained?
+        @staging_queue.empty? && (@send_queue.nil? || @send_queue.empty?)
+      end
+
+
+      private
+
+
+      def start_send_pump(conn)
+        @engine.spawn_conn_pump_task(conn, annotation: "send pump") do
+          batch = []
+
+          loop do
+            Routing.dequeue_batch(@send_queue, batch)
+            batch.each { |parts| conn.write_message(parts) }
+            conn.flush
+            batch.clear
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/omq/routing/client.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module OMQ
+  module Routing
+    # CLIENT socket routing: round-robin send, fair-queue receive.
+    #
+    # Same as DEALER — no envelope manipulation.
+    #
+    class Client
+      include RoundRobin
+
+
+      # @return [Async::LimitedQueue]
+      #
+      attr_reader :recv_queue
+
+
+      # @param engine [Engine]
+      #
+      def initialize(engine)
+        @engine     = engine
+        @recv_queue = Routing.build_queue(engine.options.recv_hwm, :block)
+        init_round_robin(engine)
+      end
+
+
+      # Dequeues the next received message. Blocks until one is available.
+      #
+      # @return [Array<String>, nil]
+      #
+      def dequeue_recv
+        @recv_queue.dequeue
+      end
+
+
+      # Wakes a blocked {#dequeue_recv} with a nil sentinel.
+      #
+      # @return [void]
+      #
+      def unblock_recv
+        @recv_queue.enqueue(nil)
+      end
+
+
+      # @param connection [Connection]
+      #
+      def connection_added(connection)
+        @connections << connection
+        @engine.start_recv_pump(connection, @recv_queue)
+        add_round_robin_send_connection(connection)
+      end
+
+
+      # @param connection [Connection]
+      #
+      def connection_removed(connection)
+        @connections.delete(connection)
+        remove_round_robin_send_connection(connection)
+      end
+
+
+      # @param parts [Array<String>]
+      #
+      def enqueue(parts)
+        enqueue_round_robin(parts)
+      end
+
+    end
+  end
+end

data/lib/omq/routing/conn_send_pump.rb

@@ -8,19 +8,20 @@ module OMQ
     # include the RoundRobin mixin.
     #
     module ConnSendPump
-      # Spawns the pump task and registers it in +tasks+.
+      # Spawns the pump task on the connection's lifecycle barrier so it
+      # is torn down with the rest of the connection's pumps.
       #
       # @param engine [Engine]
       # @param conn [Connection]
       # @param q [Async::LimitedQueue]
-      # @param tasks [Array]
       # @return [Async::Task]
       #
-      def self.start(engine, conn, q, tasks)
-        task = engine.spawn_conn_pump_task(conn, annotation: "send pump") do
+      def self.start(engine, 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)
 
             if batch.size == 1
               conn.write_message batch.first
@@ -30,12 +31,13 @@ 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
-
-        tasks << task
-        task
       end
 
     end

data/lib/omq/routing/dealer.rb

@@ -20,7 +20,6 @@ module OMQ
       def initialize(engine)
         @engine     = engine
         @recv_queue = Routing.build_queue(engine.options.recv_hwm, :block)
-        @tasks      = []
         init_round_robin(engine)
       end
 
@@ -46,8 +45,7 @@ module OMQ
       # @param connection [Connection]
       #
       def connection_added(connection)
-        task = @engine.start_recv_pump(connection, @recv_queue)
-        @tasks << task if task
+        @engine.start_recv_pump(connection, @recv_queue)
         add_round_robin_send_connection(connection)
       end
 
@@ -66,16 +64,6 @@ module OMQ
         enqueue_round_robin(parts)
       end
 
-
-      # Stops all background tasks.
-      #
-      # @return [void]
-      #
-      def stop
-        @tasks.each(&:stop)
-        @tasks.clear
-      end
-
     end
   end
 end

data/lib/omq/routing/dish.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module OMQ
+  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
+      # @return [Async::LimitedQueue]
+      #
+      attr_reader :recv_queue
+
+
+      # @param engine [Engine]
+      #
+      def initialize(engine)
+        @engine      = engine
+        @connections = []
+        @recv_queue  = Routing.build_queue(engine.options.recv_hwm, :block)
+        @groups      = Set.new
+      end
+
+
+      # Dequeues the next received message. Blocks until one is available.
+      #
+      # @return [Array<String>, nil]
+      #
+      def dequeue_recv
+        @recv_queue.dequeue
+      end
+
+
+      # Wakes a blocked {#dequeue_recv} with a nil sentinel.
+      #
+      # @return [void]
+      #
+      def unblock_recv
+        @recv_queue.enqueue(nil)
+      end
+
+
+      # @param connection [Connection]
+      #
+      def connection_added(connection)
+        @connections << connection
+        @groups.each do |group|
+          connection.send_command(Protocol::ZMTP::Codec::Command.join(group))
+        end
+        @engine.start_recv_pump(connection, @recv_queue)
+      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(Protocol::ZMTP::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(Protocol::ZMTP::Codec::Command.leave(group))
+        end
+      end
+
+    end
+  end
+end

data/lib/omq/routing/fan_out.rb

@@ -41,7 +41,6 @@ module OMQ
         @subscriptions      = {} # connection => Set of prefixes
         @subscribe_all      = Set.new # connections subscribed to "" (match-all fast path)
         @conn_queues        = {} # connection => per-connection send queue
-        @conn_send_tasks    = {} # connection => send pump task
         @conflate           = engine.options.conflate
         @subscriber_joined  = Async::Promise.new
         @latest             = {} if @conflate
@@ -96,7 +95,8 @@ module OMQ
       end
 
 
-      # Stops the per-connection send pump and removes the queue.
+      # Removes the per-connection send queue. The pump itself is torn
+      # down by the per-connection lifecycle barrier.
       # Call from #connection_removed.
       #
       # @param conn [Connection]
@@ -104,7 +104,6 @@ module OMQ
       def remove_fan_out_send_connection(conn)
         @subscribe_all.delete(conn)
         @conn_queues.delete(conn)
-        @conn_send_tasks.delete(conn)&.stop
       end
 
 
@@ -130,7 +129,7 @@ module OMQ
 
 
       def start_subscription_listener(conn)
-        @tasks << @engine.spawn_conn_pump_task(conn, annotation: "subscription listener") do
+        @engine.spawn_conn_pump_task(conn, annotation: "subscription listener") do
           loop do
             frame = conn.read_frame
 
@@ -160,13 +159,10 @@ module OMQ
         use_wire = conn.respond_to?(:write_wire) && !conn.encrypted?
 
         if @conflate
-          task = start_conn_send_pump_conflate(conn, q)
+          start_conn_send_pump_conflate(conn, q)
         else
-          task = start_conn_send_pump_normal(conn, q, use_wire)
+          start_conn_send_pump_normal(conn, q, use_wire)
         end
-
-        @conn_send_tasks[conn] = task
-        @tasks << task
       end
 
 
@@ -181,14 +177,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
@@ -227,14 +225,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/gather.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module OMQ
+  module Routing
+    # GATHER socket routing: fair-queue receive from SCATTER peers.
+    #
+    class Gather
+      # @return [Async::LimitedQueue]
+      #
+      attr_reader :recv_queue
+
+
+      # @param engine [Engine]
+      #
+      def initialize(engine)
+        @engine     = engine
+        @recv_queue = Routing.build_queue(engine.options.recv_hwm, :block)
+      end
+
+
+      # Dequeues the next received message. Blocks until one is available.
+      #
+      # @return [Array<String>, nil]
+      #
+      def dequeue_recv
+        @recv_queue.dequeue
+      end
+
+
+      # Wakes a blocked {#dequeue_recv} with a nil sentinel.
+      #
+      # @return [void]
+      #
+      def unblock_recv
+        @recv_queue.enqueue(nil)
+      end
+
+
+      # @param connection [Connection]
+      #
+      def connection_added(connection)
+        @engine.start_recv_pump(connection, @recv_queue)
+      end
+
+
+      # @param connection [Connection]
+      #
+      def connection_removed(connection)
+      end
+
+
+      # GATHER is read-only.
+      #
+      def enqueue(_parts)
+        raise "GATHER sockets cannot send"
+      end
+
+    end
+  end
+end