omq 0.22.1 → 0.24.0

data/lib/omq/transport/inproc/{direct_pipe.rb → pipe.rb}

@@ -14,7 +14,7 @@ module OMQ
       # This reduces inproc from 3 queue hops to 2 (send_queue →
       # recv_queue), eliminating the internal pipe queue in between.
       #
-      class DirectPipe
+      class Pipe
         # @return [String] peer's socket type
         #
         attr_reader :peer_socket_type
@@ -39,7 +39,7 @@ module OMQ
         attr_reader :peer_identity
 
 
-        # @return [DirectPipe, nil] the other end of this pipe pair
+        # @return [Pipe, nil] the other end of this pipe pair
         #
         attr_accessor :peer
 
@@ -50,12 +50,6 @@ module OMQ
         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
@@ -75,18 +69,27 @@ module OMQ
         end
 
 
-        # Sets the direct recv queue. Drains any messages that were
-        # buffered before the queue was available.
+        # Wires up the direct recv fast-path. Called once by the recv
+        # pump when the receiving side of an inproc pipe pair is set up.
+        # After this, peer-side {#send_message} calls enqueue straight
+        # into +queue+ instead of hopping through the intermediate pipe
+        # queue and a recv pump fiber.
         #
-        # @param queue [Async::LimitedQueue, nil]
+        # Drains any messages the peer buffered into +@pending_direct+
+        # before the queue was available.
+        #
+        # @param queue [Async::LimitedQueue]
+        # @param transform [Proc, nil] optional per-message transform
         # @return [void]
         #
-        def direct_recv_queue=(queue)
-          @direct_recv_queue = queue
-          if queue && @pending_direct
-            @pending_direct.each { |msg| queue.enqueue(msg) }
-            @pending_direct = nil
-          end
+        def wire_direct_recv(queue, transform)
+          @direct_recv_transform = transform
+          @direct_recv_queue     = queue
+
+          return unless @pending_direct
+
+          @pending_direct.each { |msg| queue.enqueue(msg) }
+          @pending_direct = nil
         end
 
 
@@ -97,6 +100,7 @@ module OMQ
         #
         def send_message(parts)
           raise IOError, "closed" if @closed
+
           if @direct_recv_queue
             @direct_recv_queue.enqueue(apply_transform(parts))
           elsif @send_queue
@@ -112,7 +116,7 @@ module OMQ
 
         # Batched form, for parity with Protocol::ZMTP::Connection. The
         # work-stealing pumps call this when they dequeue more than one
-        # message at once; DirectPipe just loops — no mutex to amortize.
+        # message at once; Pipe just loops — no mutex to amortize.
         #
         # @param messages [Array<Array<String>>]
         # @return [void]
@@ -145,14 +149,13 @@ module OMQ
         #
         def receive_message
           loop do
-            item = @receive_queue.dequeue
-
-            raise EOFError, "connection closed" if item.nil?
+            item = @receive_queue.dequeue or raise EOFError, "connection closed"
 
             if item.is_a?(Array) && item.first == :command
               if block_given?
                 yield Protocol::ZMTP::Codec::Frame.new(item[1].to_body, command: true)
               end
+
               next
             end
 
@@ -179,8 +182,7 @@ module OMQ
         # @return [Protocol::ZMTP::Codec::Frame]
         #
         def read_frame
-          item = @receive_queue.dequeue
-          raise EOFError, "connection closed" if item.nil?
+          item = @receive_queue.dequeue or raise EOFError, "connection closed"
 
           if item.is_a?(Array) && item.first == :command
             Protocol::ZMTP::Codec::Frame.new(item[1].to_body, command: true)
@@ -206,7 +208,7 @@ module OMQ
 
         def apply_transform(parts)
           if @direct_recv_transform
-            @direct_recv_transform.call(parts).freeze
+            @direct_recv_transform.call(parts)
           else
             parts
           end

data/lib/omq/transport/inproc.rb

@@ -2,7 +2,7 @@
 
 require "async"
 require "async/queue"
-require_relative "inproc/direct_pipe"
+require_relative "inproc/pipe"
 
 module OMQ
   module Transport
@@ -15,6 +15,9 @@ module OMQ
     # prevent shared mutable state without copying.
     #
     module Inproc
+      Engine.transports["inproc"] = self
+
+
       # Socket types that exchange commands (SUBSCRIBE/CANCEL) over inproc.
       #
       COMMAND_TYPES = %i[PUB SUB XPUB XSUB RADIO DISH].freeze
@@ -28,14 +31,19 @@ module OMQ
 
 
       class << self
-        # Binds an engine to an inproc endpoint.
+        # @return [Hash{String => Engine}] bound inproc endpoints
+        #
+        attr_reader :registry
+
+
+        # Creates a bound inproc listener.
         #
         # @param endpoint [String] e.g. "inproc://my-endpoint"
         # @param engine [Engine] the owning engine
         # @return [Listener]
         # @raise [ArgumentError] if endpoint is already bound
         #
-        def bind(endpoint, engine)
+        def listener(endpoint, engine, **)
           @mutex.synchronize do
             if @registry.key?(endpoint)
               raise ArgumentError, "endpoint already bound: #{endpoint}"
@@ -57,7 +65,7 @@ module OMQ
         # @param engine [Engine] the connecting engine
         # @return [void]
         #
-        def connect(endpoint, engine)
+        def connect(endpoint, engine, **)
           bound_engine = @mutex.synchronize { @registry[endpoint] }
           bound_engine ||= await_bind(endpoint, engine) or return
           establish_link(engine, bound_engine, endpoint)
@@ -114,8 +122,8 @@ module OMQ
         end
 
 
-        # Decides whether a DirectPipe pair needs command queues.
-        # DirectPipe's fast path skips queues entirely; command queues
+        # Decides whether a Pipe pair needs command queues.
+        # Pipe's fast path skips queues entirely; command queues
         # are only needed for socket types that exchange ZMTP commands
         # (e.g. ROUTER/DEALER identity, PUB/SUB subscriptions) or when
         # either side enables QoS ≥ 1.
@@ -129,11 +137,11 @@ module OMQ
         end
 
 
-        # Builds a bidirectional {DirectPipe} pair for client + server.
+        # Builds a bidirectional {Pipe} pair for client + server.
         # When +needs_cmds+ is false the pipes have no command queues
         # (fast path — all traffic bypasses Async::Queue entirely).
         #
-        # @return [Array(DirectPipe, DirectPipe)] client, server
+        # @return [Array(Pipe, Pipe)] client, server
         #
         def make_pipe_pair(ce, se, ct, st, needs_cmds)
           if needs_cmds
@@ -141,12 +149,12 @@ module OMQ
             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 = Pipe.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 = Pipe.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

data/lib/omq/transport/ipc.rb

@@ -11,14 +11,17 @@ module OMQ
     # (paths starting with @).
     #
     module IPC
+      Engine.transports["ipc"] = self
+
+
       class << self
-        # Binds an IPC server.
+        # Creates a bound IPC listener.
         #
         # @param endpoint [String] e.g. "ipc:///tmp/my.sock" or "ipc://@abstract"
         # @param engine [Engine]
         # @return [Listener]
         #
-        def bind(endpoint, engine)
+        def listener(endpoint, engine, **)
           path      = parse_path(endpoint)
           sock_path = to_socket_path(path)
 
@@ -31,18 +34,14 @@ module OMQ
         end
 
 
-        # Connects to an IPC endpoint.
+        # Creates an IPC dialer for an endpoint.
         #
         # @param endpoint [String]
         # @param engine [Engine]
-        # @return [void]
+        # @return [Dialer]
         #
-        def connect(endpoint, engine)
-          path = parse_path(endpoint)
-          sock_path = to_socket_path(path)
-          sock = UNIXSocket.new(sock_path)
-          apply_buffer_sizes(sock, engine.options)
-          engine.handle_connected(IO::Stream::Buffered.wrap(sock), endpoint: endpoint)
+        def dialer(endpoint, engine, **)
+          Dialer.new(endpoint, engine)
         end
 
 
@@ -63,9 +62,6 @@ module OMQ
         end
 
 
-        private
-
-
         # Extracts path from "ipc://path".
         #
         def parse_path(endpoint)
@@ -92,6 +88,38 @@ module OMQ
       end
 
 
+      # An IPC dialer — stateful factory for outgoing connections.
+      #
+      class Dialer
+        # @return [String] the endpoint this dialer connects to
+        #
+        attr_reader :endpoint
+
+
+        # @param endpoint [String]
+        # @param engine [Engine]
+        #
+        def initialize(endpoint, engine)
+          @endpoint = endpoint
+          @engine   = engine
+        end
+
+
+        # Establishes a Unix socket connection to the endpoint.
+        #
+        # @return [void]
+        #
+        def connect
+          path      = IPC.parse_path(@endpoint)
+          sock_path = IPC.to_socket_path(path)
+          sock      = UNIXSocket.new(sock_path)
+          IPC.apply_buffer_sizes(sock, @engine.options)
+          @engine.handle_connected(IO::Stream::Buffered.wrap(sock), endpoint: @endpoint)
+        end
+
+      end
+
+
       # A bound IPC listener.
       #
       class Listener

data/lib/omq/transport/tcp.rb

@@ -9,14 +9,17 @@ module OMQ
     # TCP transport using Ruby sockets with Async.
     #
     module TCP
+      Engine.transports["tcp"] = self
+
+
       class << self
-        # Binds a TCP server.
+        # Creates a bound TCP listener.
         #
         # @param endpoint [String] e.g. "tcp://127.0.0.1:5555" or "tcp://*:0"
         # @param engine [Engine]
         # @return [Listener]
         #
-        def bind(endpoint, engine)
+        def listener(endpoint, engine, **)
           host, port  = self.parse_endpoint(endpoint)
           lookup_host = normalize_bind_host(host)
 
@@ -34,6 +37,17 @@ module OMQ
         end
 
 
+        # Creates a TCP dialer for an endpoint.
+        #
+        # @param endpoint [String] e.g. "tcp://127.0.0.1:5555"
+        # @param engine [Engine]
+        # @return [Dialer]
+        #
+        def dialer(endpoint, engine, **)
+          Dialer.new(endpoint, engine)
+        end
+
+
         # Validates that the endpoint's host can be resolved.
         #
         # @param endpoint [String]
@@ -46,21 +60,6 @@ module OMQ
         end
 
 
-        # Connects to a TCP endpoint.
-        #
-        # @param endpoint [String] e.g. "tcp://127.0.0.1:5555"
-        # @param engine [Engine]
-        # @return [void]
-        #
-        def connect(endpoint, engine)
-          host, port = self.parse_endpoint(endpoint)
-          host       = normalize_connect_host(host)
-          sock       = ::Socket.tcp(host, port, connect_timeout: connect_timeout(engine.options))
-          apply_buffer_sizes(sock, engine.options)
-          engine.handle_connected(IO::Stream::Buffered.wrap(sock), endpoint: endpoint)
-        end
-
-
         # Normalizes the bind host:
         #   "*"                    → nil (dual-stack wildcard via AI_PASSIVE)
         #   "" / nil / "localhost" → loopback_host (::1 on IPv6-capable hosts, else 127.0.0.1)
@@ -142,6 +141,42 @@ module OMQ
       end
 
 
+      # A TCP dialer — stateful factory for outgoing connections.
+      #
+      # Created once per {Engine#connect}, stored in +@dialers[endpoint]+.
+      # Reconnect calls {#connect} directly — no transport lookup or opts
+      # replay needed.
+      #
+      class Dialer
+        # @return [String] the endpoint this dialer connects to
+        #
+        attr_reader :endpoint
+
+
+        # @param endpoint [String] e.g. "tcp://127.0.0.1:5555"
+        # @param engine [Engine]
+        #
+        def initialize(endpoint, engine)
+          @endpoint = endpoint
+          @engine   = engine
+        end
+
+
+        # Establishes a TCP connection to the endpoint.
+        #
+        # @return [void]
+        #
+        def connect
+          host, port = TCP.parse_endpoint(@endpoint)
+          host       = TCP.normalize_connect_host(host)
+          sock       = ::Socket.tcp(host, port, connect_timeout: TCP.connect_timeout(@engine.options))
+          TCP.apply_buffer_sizes(sock, @engine.options)
+          @engine.handle_connected(IO::Stream::Buffered.wrap(sock), endpoint: @endpoint)
+        end
+
+      end
+
+
       # A bound TCP listener.
       #
       class Listener
@@ -168,7 +203,7 @@ module OMQ
           @servers  = servers
           @port     = port
           @engine   = engine
-          @tasks    = []
+          @barrier  = nil
         end
 
 
@@ -179,10 +214,11 @@ module OMQ
         # @yieldparam io [IO::Stream::Buffered]
         #
         def start_accept_loops(parent_task)
-          @tasks = @servers.map do |server|
-            # TODO: use this server's exact host:port (@endpoint might not be unique)
-            annotation = "tcp accept #{@endpoint}"
-            parent_task.async(transient: true, annotation:) do
+          @barrier = Async::Barrier.new(parent: parent_task)
+
+          @servers.each do |server|
+            annotation = "tcp accept #{server.local_address.inspect_sockaddr}"
+            @barrier.async(transient: true, annotation:) do
               loop do
                 client, _addr = server.accept
                 TCP.apply_buffer_sizes(client, @engine.options)
@@ -207,7 +243,7 @@ module OMQ
         # @return [void]
         #
         def stop
-          @tasks.each(&:stop)
+          @barrier&.stop
           @servers.each { |s| s.close rescue nil }
         end