omq 0.12.0 → 0.13.0

data/lib/omq/routing/xsub.rb

@@ -5,45 +5,57 @@ module OMQ
     # XSUB socket routing: like SUB but subscriptions sent as data messages.
     #
     # Subscriptions are sent as data frames: \x01 + prefix for subscribe,
-    # \x00 + prefix for unsubscribe.
+    # \x00 + prefix for unsubscribe. Each connected PUB gets its own send
+    # queue so subscription commands are delivered independently per peer.
     #
     class XSub
 
       # @param engine [Engine]
       #
       def initialize(engine)
-        @engine            = engine
-        @connections       = []
-        @recv_queue        = Routing.build_queue(engine.options.recv_hwm, engine.options.on_mute)
-        @send_queue        = Routing.build_queue(engine.options.send_hwm, :block)
-        @tasks             = []
-        @send_pump_started = false
-        @send_pump_idle    = true
+        @engine          = engine
+        @connections     = Set.new
+        @recv_queue      = FairQueue.new
+        @conn_queues     = {}  # connection => per-connection send queue
+        @conn_send_tasks = {}  # connection => send pump task
+        @tasks           = []
       end
 
-      # @return [Async::LimitedQueue]
+      # @return [FairQueue]
       #
-      attr_reader :recv_queue, :send_queue
+      attr_reader :recv_queue
 
       # @param connection [Connection]
       #
       def connection_added(connection)
         @connections << connection
-        task = @engine.start_recv_pump(connection, @recv_queue)
+
+        conn_q    = Routing.build_queue(@engine.options.recv_hwm, @engine.options.on_mute)
+        signaling = SignalingQueue.new(conn_q, @recv_queue)
+        @recv_queue.add_queue(connection, conn_q)
+        task = @engine.start_recv_pump(connection, signaling)
         @tasks << task if task
-        start_send_pump unless @send_pump_started
+
+        q = Routing.build_queue(@engine.options.send_hwm, :block)
+        @conn_queues[connection] = q
+        start_conn_send_pump(connection, q)
       end
 
       # @param connection [Connection]
       #
       def connection_removed(connection)
         @connections.delete(connection)
+        @recv_queue.remove_queue(connection)
+        @conn_queues.delete(connection)
+        @conn_send_tasks.delete(connection)&.stop
       end
 
+      # Enqueues a subscription command (fan-out to all connected PUBs).
+      #
       # @param parts [Array<String>]
       #
       def enqueue(parts)
-        @send_queue.enqueue(parts)
+        @connections.each { |conn| @conn_queues[conn]&.enqueue(parts) }
       end
 
       #
@@ -52,31 +64,35 @@ module OMQ
         @tasks.clear
       end
 
-      def send_pump_idle? = @send_pump_idle
+      # True when all per-connection send queues are empty.
+      #
+      def send_queues_drained?
+        @conn_queues.values.all?(&:empty?)
+      end
 
       private
 
-      def start_send_pump
-        @send_pump_started = true
-        @tasks << @engine.spawn_pump_task(annotation: "send pump") do
+      def start_conn_send_pump(conn, q)
+        task = @engine.spawn_pump_task(annotation: "send pump") do
           loop do
-            @send_pump_idle = true
-            parts = @send_queue.dequeue
-            @send_pump_idle = false
+            parts = q.dequeue
             frame = parts.first&.b
             next if frame.nil? || frame.empty?
-
             flag   = frame.getbyte(0)
             prefix = frame.byteslice(1..) || "".b
-
-            case flag
-            when 0x01
-              @connections.each { |c| c.send_command(Protocol::ZMTP::Codec::Command.subscribe(prefix)) }
-            when 0x00
-              @connections.each { |c| c.send_command(Protocol::ZMTP::Codec::Command.cancel(prefix)) }
+            begin
+              case flag
+              when 0x01 then conn.send_command(Protocol::ZMTP::Codec::Command.subscribe(prefix))
+              when 0x00 then conn.send_command(Protocol::ZMTP::Codec::Command.cancel(prefix))
+              end
+            rescue Protocol::ZMTP::Error, *CONNECTION_LOST
+              @engine.connection_lost(conn)
+              break
             end
           end
         end
+        @conn_send_tasks[conn] = task
+        @tasks << task
       end
     end
   end

data/lib/omq/routing.rb

@@ -4,6 +4,9 @@ require "async"
 require "async/queue"
 require "async/limited_queue"
 require_relative "drop_queue"
+require_relative "routing/fair_queue"
+require_relative "routing/fair_recv"
+require_relative "routing/conn_send_pump"
 
 module OMQ
   # Routing strategies for each ZMQ socket type.

data/lib/omq/socket.rb

@@ -47,7 +47,7 @@ module OMQ
     # @return [Socket]
     #
     def self.bind(endpoint, **opts)
-      new(nil, **opts).tap { |s| s.bind(endpoint) }
+      new("@#{endpoint}", **opts)
     end
 
 
@@ -58,7 +58,7 @@ module OMQ
     # @return [Socket]
     #
     def self.connect(endpoint, **opts)
-      new(nil, **opts).tap { |s| s.connect(endpoint) }
+      new(">#{endpoint}", **opts)
     end
 
 

data/lib/omq/transport/inproc/direct_pipe.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module OMQ
+  module Transport
+    module Inproc
+      # A direct in-process pipe that transfers Ruby arrays through queues.
+      #
+      # Implements the same interface as Connection so routing strategies
+      # can use it transparently.
+      #
+      # When a routing strategy sets {#direct_recv_queue} on a pipe,
+      # {#send_message} enqueues directly into the peer's recv queue,
+      # bypassing the intermediate pipe queues and the recv pump task.
+      # This reduces inproc from 3 queue hops to 2 (send_queue →
+      # recv_queue), eliminating the internal pipe queue in between.
+      #
+      class DirectPipe
+        # @return [String] peer's socket type
+        #
+        attr_reader :peer_socket_type
+
+
+        # @return [String] peer's identity
+        #
+        attr_reader :peer_identity
+
+
+        # @return [DirectPipe, nil] the other end of this pipe pair
+        #
+        attr_accessor :peer
+
+
+        # @return [Async::LimitedQueue, nil] when set, {#send_message}
+        #   enqueues directly here instead of using the internal queue
+        #
+        attr_reader :direct_recv_queue
+
+
+        # @return [Proc, nil] optional transform applied before
+        #   enqueuing into {#direct_recv_queue}
+        #
+        attr_accessor :direct_recv_transform
+
+
+        # @param send_queue [Async::Queue, nil] outgoing command queue
+        #   (nil for non-PUB/SUB types that don't exchange commands)
+        # @param receive_queue [Async::Queue, nil] incoming command queue
+        # @param peer_identity [String]
+        # @param peer_type [String]
+        #
+        def initialize(send_queue: nil, receive_queue: nil, peer_identity:, peer_type:)
+          @send_queue            = send_queue
+          @receive_queue         = receive_queue
+          @peer_identity         = peer_identity || "".b
+          @peer_socket_type      = peer_type
+          @closed                = false
+          @peer                  = nil
+          @direct_recv_queue     = nil
+          @direct_recv_transform = nil
+          @pending_direct        = nil
+        end
+
+
+        # Sets the direct recv queue. Drains any messages that were
+        # buffered before the queue was available.
+        #
+        def direct_recv_queue=(queue)
+          @direct_recv_queue = queue
+          if queue && @pending_direct
+            @pending_direct.each { |msg| queue.enqueue(msg) }
+            @pending_direct = nil
+          end
+        end
+
+
+        # Sends a multi-frame message.
+        #
+        # @param parts [Array<String>]
+        # @return [void]
+        #
+        def send_message(parts)
+          raise IOError, "closed" if @closed
+          if @direct_recv_queue
+            @direct_recv_queue.enqueue(apply_transform(parts))
+          elsif @send_queue
+            @send_queue.enqueue(parts)
+          else
+            (@pending_direct ||= []) << apply_transform(parts)
+          end
+        end
+
+
+        alias write_message send_message
+
+
+        # No-op — inproc has no IO buffer to flush.
+        #
+        def flush = nil
+
+
+        # Receives a multi-frame message.
+        #
+        # @return [Array<String>]
+        # @raise [EOFError] if closed
+        #
+        def receive_message
+          loop do
+            item = @receive_queue.dequeue
+            raise EOFError, "connection closed" if item.nil?
+            if item.is_a?(Array) && item.first == :command
+              yield Protocol::ZMTP::Codec::Frame.new(item[1].to_body, command: true) if block_given?
+              next
+            end
+            return item
+          end
+        end
+
+
+        # Sends a command via the internal command queue.
+        # Only available for PUB/SUB-family pipes.
+        #
+        # @param command [Protocol::ZMTP::Codec::Command]
+        #
+        def send_command(command)
+          raise IOError, "closed" if @closed
+          @send_queue.enqueue([:command, command])
+        end
+
+
+        # Reads one command frame from the internal command queue.
+        # Used by PUB/XPUB subscription listeners.
+        #
+        # @return [Protocol::ZMTP::Codec::Frame]
+        #
+        def read_frame
+          loop do
+            item = @receive_queue.dequeue
+            raise EOFError, "connection closed" if item.nil?
+            if item.is_a?(Array) && item.first == :command
+              return Protocol::ZMTP::Codec::Frame.new(item[1].to_body, command: true)
+            end
+          end
+        end
+
+
+        # Closes this pipe end.
+        #
+        def close
+          return if @closed
+          @closed = true
+          @send_queue&.enqueue(nil) # close sentinel
+        end
+
+        private
+
+        def apply_transform(parts)
+          @direct_recv_transform ? @direct_recv_transform.call(parts).freeze : parts
+        end
+      end
+    end
+  end
+end

data/lib/omq/transport/inproc.rb

@@ -2,6 +2,7 @@
 
 require "async"
 require "async/queue"
+require_relative "inproc/direct_pipe"
 
 module OMQ
   module Transport
@@ -54,25 +55,7 @@ module OMQ
         #
         def connect(endpoint, engine)
           bound_engine = @mutex.synchronize { @registry[endpoint] }
-
-          unless bound_engine
-            # Endpoint not bound yet. Wait with timeout derived from
-            # reconnect_interval. If it doesn't appear, silently return —
-            # matching ZMQ 4.x behavior where inproc connect to an
-            # unbound endpoint succeeds but messages go nowhere.
-            # A background task retries periodically.
-            ri      = engine.options.reconnect_interval
-            timeout = ri.is_a?(Range) ? ri.begin : ri
-            promise = Async::Promise.new
-            @mutex.synchronize { @waiters[endpoint] << promise }
-            unless promise.wait?(timeout: timeout)
-              @mutex.synchronize { @waiters[endpoint].delete(promise) }
-              start_connect_retry(endpoint, engine)
-              return
-            end
-            bound_engine = @mutex.synchronize { @registry[endpoint] }
-          end
-
+          bound_engine ||= await_bind(endpoint, engine) or return
           establish_link(engine, bound_engine, endpoint)
         end
 
@@ -112,42 +95,51 @@ module OMQ
         def establish_link(client_engine, server_engine, endpoint)
           client_type = client_engine.socket_type
           server_type = server_engine.socket_type
-
           unless Protocol::ZMTP::VALID_PEERS[client_type]&.include?(server_type)
             raise Protocol::ZMTP::Error,
                   "incompatible socket types: #{client_type} cannot connect to #{server_type}"
           end
+          needs_cmds = needs_commands?(client_engine, server_engine, client_type, server_type)
+          client_pipe, server_pipe = make_pipe_pair(client_engine, server_engine, client_type, server_type, needs_cmds)
+          client_engine.connection_ready(client_pipe, endpoint: endpoint)
+          server_engine.connection_ready(server_pipe, endpoint: endpoint)
+        end
 
-          # PUB/SUB-family types exchange commands (SUBSCRIBE/CANCEL)
-          # over inproc. QoS >= 1 needs command queues for ACK/NACK.
-          needs_commands = COMMAND_TYPES.include?(client_type) ||
-                           COMMAND_TYPES.include?(server_type) ||
-                           client_engine.options.qos >= 1 ||
-                           server_engine.options.qos >= 1
+        def needs_commands?(ce, se, ct, st)
+          COMMAND_TYPES.include?(ct) || COMMAND_TYPES.include?(st) ||
+            ce.options.qos >= 1 || se.options.qos >= 1
+        end
 
-          if needs_commands
+        def make_pipe_pair(ce, se, ct, st, needs_cmds)
+          if needs_cmds
             a_to_b = Async::Queue.new
             b_to_a = Async::Queue.new
           end
+          client = DirectPipe.new(send_queue: needs_cmds ? a_to_b : nil,
+                                  receive_queue: needs_cmds ? b_to_a : nil,
+                                  peer_identity: se.options.identity, peer_type: st.to_s)
+          server = DirectPipe.new(send_queue: needs_cmds ? b_to_a : nil,
+                                  receive_queue: needs_cmds ? a_to_b : nil,
+                                  peer_identity: ce.options.identity, peer_type: ct.to_s)
+          client.peer = server
+          server.peer = client
+          [client, server]
+        end
 
-          client_pipe = DirectPipe.new(
-            send_queue:    needs_commands ? a_to_b : nil,
-            receive_queue: needs_commands ? b_to_a : nil,
-            peer_identity: server_engine.options.identity,
-            peer_type:     server_type.to_s,
-          )
-          server_pipe = DirectPipe.new(
-            send_queue:    needs_commands ? b_to_a : nil,
-            receive_queue: needs_commands ? a_to_b : nil,
-            peer_identity: client_engine.options.identity,
-            peer_type:     client_type.to_s,
-          )
-
-          client_pipe.peer = server_pipe
-          server_pipe.peer = client_pipe
-
-          client_engine.connection_ready(client_pipe, endpoint: endpoint)
-          server_engine.connection_ready(server_pipe, endpoint: endpoint)
+        def await_bind(endpoint, engine)
+          # Endpoint not bound yet — wait briefly then start background retry.
+          # Matches ZMQ 4.x: connect to unbound inproc succeeds silently.
+          ri      = engine.options.reconnect_interval
+          timeout = ri.is_a?(Range) ? ri.begin : ri
+          promise = Async::Promise.new
+          @mutex.synchronize { @waiters[endpoint] << promise }
+          if promise.wait?(timeout: timeout)
+            @mutex.synchronize { @registry[endpoint] }
+          else
+            @mutex.synchronize { @waiters[endpoint].delete(promise) }
+            start_connect_retry(endpoint, engine)
+            nil
+          end
         end
 
 
@@ -195,179 +187,6 @@ module OMQ
         end
       end
 
-      # A direct in-process pipe that transfers Ruby arrays through queues.
-      #
-      # Implements the same interface as Connection so routing strategies
-      # can use it transparently.
-      #
-      # When a routing strategy sets {#direct_recv_queue} on a pipe,
-      # {#send_message} enqueues directly into the peer's recv queue,
-      # bypassing the intermediate pipe queues and the recv pump task.
-      # This reduces inproc from 3 queue hops to 2 (send_queue →
-      # recv_queue), eliminating the internal pipe queue in between.
-      #
-      class DirectPipe
-        # @return [String] peer's socket type
-        #
-        attr_reader :peer_socket_type
-
-
-        # @return [String] peer's identity
-        #
-        attr_reader :peer_identity
-
-
-        # @return [DirectPipe, nil] the other end of this pipe pair
-        #
-        attr_accessor :peer
-
-
-        # @return [Async::LimitedQueue, nil] when set, {#send_message}
-        #   enqueues directly here instead of using the internal queue
-        #
-        attr_reader :direct_recv_queue
-
-
-        # @return [Proc, nil] optional transform applied before
-        #   enqueuing into {#direct_recv_queue}
-        #
-        attr_accessor :direct_recv_transform
-
-
-        # @param send_queue [Async::Queue, nil] outgoing command queue
-        #   (nil for non-PUB/SUB types that don't exchange commands)
-        # @param receive_queue [Async::Queue, nil] incoming command queue
-        # @param peer_identity [String]
-        # @param peer_type [String]
-        #
-        def initialize(send_queue: nil, receive_queue: nil, peer_identity:, peer_type:)
-          @send_queue            = send_queue
-          @receive_queue         = receive_queue
-          @peer_identity         = peer_identity || "".b
-          @peer_socket_type      = peer_type
-          @closed                = false
-          @peer                  = nil
-          @direct_recv_queue     = nil
-          @direct_recv_transform = nil
-          @pending_direct        = nil
-        end
-
-
-        # Sets the direct recv queue. Drains any messages that were
-        # buffered before the queue was available.
-        #
-        def direct_recv_queue=(queue)
-          @direct_recv_queue = queue
-          if queue && @pending_direct
-            @pending_direct.each do |msg|
-              queue.enqueue(msg)
-            end
-            @pending_direct = nil
-          end
-        end
-
-
-        # Sends a multi-frame message.
-        #
-        # When {#direct_recv_queue} is set (inproc fast path), the
-        # message is delivered directly to the peer's recv queue,
-        # skipping the internal pipe queues and the recv pump.
-        #
-        # @param parts [Array<String>]
-        # @return [void]
-        #
-        def send_message(parts)
-          raise IOError, "closed" if @closed
-          if @direct_recv_queue
-            msg = @direct_recv_transform ? @direct_recv_transform.call(parts).freeze : parts
-            @direct_recv_queue.enqueue(msg)
-          elsif @send_queue
-            @send_queue.enqueue(parts)
-          else
-            msg = @direct_recv_transform ? @direct_recv_transform.call(parts).freeze : parts
-            (@pending_direct ||= []) << msg
-          end
-        end
-
-
-        alias write_message send_message
-
-
-        # No-op — inproc has no IO buffer to flush.
-        #
-        # @return [void]
-        #
-        def flush = nil
-
-
-        # Receives a multi-frame message.
-        #
-        # When a block is given, command items ([:command, cmd]) are
-        # yielded as command frames — matching the Protocol::ZMTP::Connection
-        # interface. Without a block, commands are silently skipped if
-        # the pipe has command queues.
-        #
-        # @return [Array<String>]
-        # @raise [EOFError] if closed
-        #
-        def receive_message
-          loop do
-            item = @receive_queue.dequeue
-            raise EOFError, "connection closed" if item.nil?
-
-            if item.is_a?(Array) && item.first == :command
-              if block_given?
-                cmd   = item[1]
-                frame = Protocol::ZMTP::Codec::Frame.new(cmd.to_body, command: true)
-                yield frame
-              end
-              next
-            end
-
-            return item
-          end
-        end
-
-
-        # Sends a command via the internal command queue.
-        # Only available for PUB/SUB-family pipes.
-        #
-        # @param command [Protocol::ZMTP::Codec::Command]
-        # @return [void]
-        #
-        def send_command(command)
-          raise IOError, "closed" if @closed
-          @send_queue.enqueue([:command, command])
-        end
-
-
-        # Reads one command frame from the internal command queue.
-        # Used by PUB/XPUB subscription listeners.
-        #
-        # @return [Protocol::ZMTP::Codec::Frame]
-        #
-        def read_frame
-          loop do
-            item = @receive_queue.dequeue
-            raise EOFError, "connection closed" if item.nil?
-            if item.is_a?(Array) && item.first == :command
-              cmd = item[1]
-              return Protocol::ZMTP::Codec::Frame.new(cmd.to_body, command: true)
-            end
-          end
-        end
-
-
-        # Closes this pipe end.
-        #
-        # @return [void]
-        #
-        def close
-          return if @closed
-          @closed = true
-          @send_queue&.enqueue(nil) # close sentinel
-        end
-      end
     end
   end
 end

data/lib/omq/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OMQ
-  VERSION = "0.12.0"
+  VERSION = "0.13.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omq
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.13.0
 platform: ruby
 authors:
 - Patrik Wenger
@@ -67,6 +67,10 @@ files:
 - lib/omq.rb
 - lib/omq/drop_queue.rb
 - lib/omq/engine.rb
+- lib/omq/engine/connection_setup.rb
+- lib/omq/engine/heartbeat.rb
+- lib/omq/engine/reconnect.rb
+- lib/omq/engine/recv_pump.rb
 - lib/omq/monitor_event.rb
 - lib/omq/options.rb
 - lib/omq/pair.rb
@@ -78,7 +82,10 @@ files:
 - lib/omq/req_rep.rb
 - lib/omq/router_dealer.rb
 - lib/omq/routing.rb
+- lib/omq/routing/conn_send_pump.rb
 - lib/omq/routing/dealer.rb
+- lib/omq/routing/fair_queue.rb
+- lib/omq/routing/fair_recv.rb
 - lib/omq/routing/fan_out.rb
 - lib/omq/routing/pair.rb
 - lib/omq/routing/pub.rb
@@ -93,6 +100,7 @@ files:
 - lib/omq/routing/xsub.rb
 - lib/omq/socket.rb
 - lib/omq/transport/inproc.rb
+- lib/omq/transport/inproc/direct_pipe.rb
 - lib/omq/transport/ipc.rb
 - lib/omq/transport/tcp.rb
 - lib/omq/version.rb