omq 0.8.0 → 0.10.0

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

@@ -1,100 +0,0 @@
-# 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
-          @send_pump_idle             = true
-        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) 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)
-          @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 send_pump_idle? = @send_pump_idle
-
-
-        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 = 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/pub.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-module OMQ
-  module ZMTP
-    module Routing
-      # PUB socket routing: fan-out to all subscribers.
-      #
-      # Listens for SUBSCRIBE/CANCEL commands from peers.
-      # Drops messages if a subscriber's connection write fails.
-      #
-      class Pub
-        include FanOut
-
-        # @param engine [Engine]
-        #
-        def initialize(engine)
-          @engine = engine
-          @tasks  = []
-          init_fan_out(engine)
-        end
-
-        # @return [Async::LimitedQueue]
-        #
-        attr_reader :send_queue
-
-        # PUB is write-only.
-        #
-        def recv_queue
-          raise "PUB sockets cannot receive"
-        end
-
-        # @param connection [Connection]
-        #
-        def connection_added(connection)
-          @connections << connection
-          @subscriptions[connection] = Set.new
-          start_subscription_listener(connection)
-          start_send_pump unless @send_pump_started
-        end
-
-        # @param connection [Connection]
-        #
-        def connection_removed(connection)
-          @connections.delete(connection)
-          @subscriptions.delete(connection)
-        end
-
-        # @param parts [Array<String>]
-        #
-        def enqueue(parts)
-          @send_queue.enqueue(parts)
-        end
-
-        #
-        def stop
-          @tasks.each(&:stop)
-          @tasks.clear
-        end
-      end
-    end
-  end
-end

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

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module OMQ
-  module ZMTP
-    module Routing
-      # PULL socket routing: fair-queue receive from PUSH peers.
-      #
-      class Pull
-        # @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 EOFError
-        end
-
-        # PULL is read-only.
-        #
-        def enqueue(_parts)
-          raise "PULL sockets cannot send"
-        end
-
-        #
-        def stop
-          @tasks.each(&:stop)
-          @tasks.clear
-        end
-      end
-    end
-  end
-end

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

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-module OMQ
-  module ZMTP
-    module Routing
-      # PUSH socket routing: round-robin send to PULL peers.
-      #
-      class Push
-        include RoundRobin
-
-        # @param engine [Engine]
-        #
-        def initialize(engine)
-          @engine = engine
-          @tasks  = []
-          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_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)
-          @tasks.clear
-        end
-
-        private
-
-
-        # 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_reaper(conn)
-          @tasks << Reactor.spawn_pump(annotation: "reaper") do
-            conn.receive_message # blocks until peer disconnects
-          rescue *ZMTP::CONNECTION_LOST
-            @engine.connection_lost(conn)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,139 +0,0 @@
-# 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
-          @conflate          = engine.options.conflate
-          @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 << @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 = 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(annotation: "recv 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

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-module OMQ
-  module ZMTP
-    module Routing
-      # REP socket routing: fair-queue receive, reply routed back to sender.
-      #
-      # REP strips the routing envelope (everything up to and including the
-      # empty delimiter) on receive, saves it internally, and restores it
-      # on send.
-      #
-      class Rep
-        # @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)
-          @pending_replies   = []
-          @tasks             = []
-          @send_pump_started = false
-          @send_pump_idle    = true
-        end
-
-        # @return [Async::LimitedQueue]
-        #
-        attr_reader :recv_queue, :send_queue
-
-        # @param connection [Connection]
-        #
-        def connection_added(connection)
-          task = @engine.start_recv_pump(connection, @recv_queue) do |msg|
-            delimiter = msg.index(&:empty?) || msg.size
-            envelope  = msg[0, delimiter]
-            body      = msg[(delimiter + 1)..] || []
-            @pending_replies << { conn: connection, envelope: envelope }
-            body
-          end
-          @tasks << task if task
-          start_send_pump unless @send_pump_started
-        end
-
-        # @param connection [Connection]
-        #
-        def connection_removed(connection)
-          # Remove any pending replies for this connection
-          @pending_replies.reject! { |r| r[:conn] == connection }
-        end
-
-        # Enqueues a reply for sending.
-        #
-        # @param parts [Array<String>]
-        #
-        def enqueue(parts)
-          @send_queue.enqueue(parts)
-        end
-
-        def stop
-          @tasks.each(&:stop)
-          @tasks.clear
-        end
-
-        private
-
-        def send_pump_idle? = @send_pump_idle
-
-
-        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 = 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
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-module OMQ
-  module ZMTP
-    module Routing
-      # REQ socket routing: round-robin send with strict send/recv alternation.
-      #
-      # REQ prepends an empty delimiter frame on send and strips it on receive.
-      #
-      class Req
-        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
-          task = @engine.start_recv_pump(connection, @recv_queue) do |msg|
-            msg.first&.empty? ? msg[1..] : msg
-          end
-          @tasks << task if task
-          start_send_pump unless @send_pump_started
-        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
-
-        # REQ prepends empty delimiter frame on the wire.
-        #
-        def transform_send(parts) = ["".b, *parts]
-
-      end
-    end
-  end
-end