omq 0.11.0 → 0.13.0

data/lib/omq/routing/channel.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-module OMQ
-  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          = []
-        @send_pump_idle = true
-      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) unless connection.is_a?(Transport::Inproc::DirectPipe)
-      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)
-        conn = @connection
-        if conn.is_a?(Transport::Inproc::DirectPipe) && conn.direct_recv_queue
-          conn.send_message(parts)
-        else
-          @send_queue.enqueue(parts)
-        end
-      end
-
-      #
-      def stop
-        @tasks.each(&:stop)
-        @tasks.clear
-      end
-
-      def send_pump_idle? = @send_pump_idle
-
-      private
-
-      def start_send_pump(conn)
-        @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 *CONNECTION_LOST
-          @engine.connection_lost(conn)
-        end
-        @tasks << @send_pump
-      end
-    end
-  end
-end

data/lib/omq/routing/client.rb

@@ -1,56 +0,0 @@
-# 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
-
-      # @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
-        update_direct_pipe
-        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)
-        update_direct_pipe
-      end
-
-      # @param parts [Array<String>]
-      #
-      def enqueue(parts)
-        enqueue_round_robin(parts)
-      end
-
-      #
-      def stop
-        @tasks.each(&:stop)
-        @tasks.clear
-      end
-    end
-  end
-end

data/lib/omq/routing/dish.rb

@@ -1,78 +0,0 @@
-# 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
-
-      # @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(Protocol::ZMTP::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(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
-
-      def stop
-        @tasks.each(&:stop)
-        @tasks.clear
-      end
-    end
-  end
-end

data/lib/omq/routing/gather.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module OMQ
-  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

data/lib/omq/routing/peer.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-require "securerandom"
-
-module OMQ
-  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  = {}
-        @routing_id_by_connection   = {}
-        @tasks                      = []
-        @send_pump_started          = false
-        @send_pump_idle             = true
-        @written                    = Set.new
-      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
-        @routing_id_by_connection[connection]  = routing_id
-
-        task = @engine.start_recv_pump(connection, @recv_queue) do |msg|
-          [routing_id, *msg]
-        end
-        @tasks << task if task
-
-        start_send_pump unless @send_pump_started
-      end
-
-      # @param connection [Connection]
-      #
-      def connection_removed(connection)
-        routing_id = @routing_id_by_connection.delete(connection)
-        @connections_by_routing_id.delete(routing_id) if routing_id
-      end
-
-      # @param parts [Array<String>]
-      #
-      def enqueue(parts)
-        @send_queue.enqueue(parts)
-      end
-
-      def stop
-        @tasks.each(&:stop)
-        @tasks.clear
-      end
-
-      def send_pump_idle? = @send_pump_idle
-
-      private
-
-      def start_send_pump
-        @send_pump_started = true
-        @tasks << @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)
-
-            @written.clear
-            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 *CONNECTION_LOST
-                # will be cleaned up
-              end
-            end
-
-            @written.each do |conn|
-              conn.flush
-            rescue *CONNECTION_LOST
-              # will be cleaned up
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/omq/routing/radio.rb

@@ -1,150 +0,0 @@
-# frozen_string_literal: true
-
-module OMQ
-  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
-        @conflate          = engine.options.conflate
-        @tasks             = []
-        @written           = Set.new
-        @latest            = {} if @conflate
-      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 << @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)
-
-            @written.clear
-
-            if @conflate
-              # Keep only the last matching message per connection.
-              @latest.clear
-              batch.each do |parts|
-                group = parts[0]
-                body  = parts[1] || EMPTY_BINARY
-                @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 *CONNECTION_LOST
-                end
-              end
-            else
-              batch.each do |parts|
-                group      = parts[0]
-                body       = parts[1] || EMPTY_BINARY
-                msg        = [group, body]
-                wire_bytes = nil
-
-                @connections.each do |conn|
-                  next unless @groups[conn]&.include?(group)
-                  begin
-                    if conn.respond_to?(:curve?) && conn.curve?
-                      conn.write_message(msg)
-                    elsif conn.respond_to?(:write_wire)
-                      wire_bytes ||= Protocol::ZMTP::Codec::Frame.encode_message(msg)
-                      conn.write_wire(wire_bytes)
-                    else
-                      conn.write_message(msg)
-                    end
-                    @written << conn
-                  rescue *CONNECTION_LOST
-                  end
-                end
-              end
-            end
-
-            @written.each do |conn|
-              conn.flush
-            rescue *CONNECTION_LOST
-            end
-          end
-        end
-      end
-
-
-      def start_group_listener(conn)
-        @tasks << @engine.spawn_pump_task(annotation: "group 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 "JOIN"  then @groups[conn]&.add(cmd.data)
-            when "LEAVE" then @groups[conn]&.delete(cmd.data)
-            end
-          end
-        rescue *CONNECTION_LOST
-          @engine.connection_lost(conn)
-        end
-      end
-    end
-  end
-end

data/lib/omq/routing/scatter.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-module OMQ
-  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
-        update_direct_pipe
-        start_send_pump unless @send_pump_started
-        start_reaper(connection)
-      end
-
-
-      # @param connection [Connection]
-      #
-      def connection_removed(connection)
-        @connections.delete(connection)
-        update_direct_pipe
-      end
-
-
-      # @param parts [Array<String>]
-      #
-      def enqueue(parts)
-        enqueue_round_robin(parts)
-      end
-
-
-      # Stops all background tasks (send pump, reapers).
-      #
-      def stop
-        @tasks.each(&:stop)
-        @tasks.clear
-      end
-
-      private
-
-
-      # Detects peer disconnection on write-only sockets by
-      # blocking on a receive that only returns on disconnect.
-      #
-      # @param conn [Connection]
-      #
-      def start_reaper(conn)
-        return if conn.is_a?(Transport::Inproc::DirectPipe)
-        @tasks << @engine.spawn_pump_task(annotation: "reaper") do
-          conn.receive_message
-        rescue *CONNECTION_LOST
-          @engine.connection_lost(conn)
-        end
-      end
-    end
-  end
-end

data/lib/omq/routing/server.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-require "securerandom"
-
-module OMQ
-  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  = {}
-        @routing_id_by_connection   = {}
-        @tasks                      = []
-        @send_pump_started          = false
-        @send_pump_idle             = true
-        @written                    = Set.new
-      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
-        @routing_id_by_connection[connection]  = routing_id
-
-        task = @engine.start_recv_pump(connection, @recv_queue) do |msg|
-          [routing_id, *msg]
-        end
-        @tasks << task if task
-
-        start_send_pump unless @send_pump_started
-      end
-
-      # @param connection [Connection]
-      #
-      def connection_removed(connection)
-        routing_id = @routing_id_by_connection.delete(connection)
-        @connections_by_routing_id.delete(routing_id) if routing_id
-      end
-
-      # @param parts [Array<String>]
-      #
-      def enqueue(parts)
-        @send_queue.enqueue(parts)
-      end
-
-      def stop
-        @tasks.each(&:stop)
-        @tasks.clear
-      end
-
-      def send_pump_idle? = @send_pump_idle
-
-      private
-
-      def start_send_pump
-        @send_pump_started = true
-        @tasks << @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)
-
-            @written.clear
-            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 *CONNECTION_LOST
-                # will be cleaned up
-              end
-            end
-
-            @written.each do |conn|
-              conn.flush
-            rescue *CONNECTION_LOST
-              # will be cleaned up
-            end
-          end
-        end
-      end
-    end
-  end
-end