omq 0.10.0 → 0.12.0

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,140 +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
-                @connections.each do |conn|
-                  next unless @groups[conn]&.include?(group)
-                  begin
-                    conn.write_message([group, body])
-                    @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

data/lib/omq/scatter_gather.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module OMQ
-  class SCATTER < Socket
-    include Writable
-    include 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 Readable
-    include 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/single_frame.rb

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