omq 0.17.9 → 0.19.0

data/lib/omq/transport/inproc.rb

@@ -37,7 +37,10 @@ module OMQ
         #
         def bind(endpoint, engine)
           @mutex.synchronize do
-            raise ArgumentError, "endpoint already bound: #{endpoint}" if @registry.key?(endpoint)
+            if @registry.key?(endpoint)
+              raise ArgumentError, "endpoint already bound: #{endpoint}"
+            end
+
             @registry[endpoint] = engine
 
             # Wake any pending connects
@@ -96,34 +99,55 @@ 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_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
 
 
+        # Decides whether a DirectPipe pair needs command queues.
+        # DirectPipe'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.
+        #
+        # @return [Boolean]
+        #
         def needs_commands?(ce, se, ct, st)
-          COMMAND_TYPES.include?(ct) || COMMAND_TYPES.include?(st) ||
-            ce.options.qos >= 1 || se.options.qos >= 1
+          return true if COMMAND_TYPES.include?(ct) || COMMAND_TYPES.include?(st)
+          return true if ce.options.qos >= 1 || se.options.qos >= 1
+          false
         end
 
 
+        # Builds a bidirectional {DirectPipe} 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
+        #
         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]
@@ -136,11 +160,20 @@ module OMQ
           ri      = engine.options.reconnect_interval
           timeout = ri.is_a?(Range) ? ri.begin : ri
           promise = Async::Promise.new
-          @mutex.synchronize { @waiters[endpoint] << promise }
+
+          @mutex.synchronize do
+            @waiters[endpoint] << promise
+          end
+
           if promise.wait?(timeout: timeout)
-            @mutex.synchronize { @registry[endpoint] }
+            @mutex.synchronize do
+              @registry[endpoint]
+            end
           else
-            @mutex.synchronize { @waiters[endpoint].delete(promise) }
+            @mutex.synchronize do
+              @waiters[endpoint].delete(promise)
+            end
+
             start_connect_retry(endpoint, engine)
             nil
           end
@@ -158,6 +191,7 @@ module OMQ
             loop do
               sleep ivl
               bound_engine = @mutex.synchronize { @registry[endpoint] }
+
               if bound_engine
                 establish_link(engine, bound_engine, endpoint)
                 break

data/lib/omq/transport/ipc.rb

@@ -19,7 +19,7 @@ module OMQ
         # @return [Listener]
         #
         def bind(endpoint, engine)
-          path = parse_path(endpoint)
+          path      = parse_path(endpoint)
           sock_path = to_socket_path(path)
 
           # Remove stale socket file for file-based paths
@@ -45,17 +45,31 @@ module OMQ
           engine.handle_connected(IO::Stream::Buffered.wrap(sock), endpoint: endpoint)
         end
 
+
+        # Applies SO_SNDBUF / SO_RCVBUF to +sock+ from the socket's
+        # {Options}. No-op when both are nil (OS default).
+        #
+        # @param sock [UNIXSocket, UNIXServer]
+        # @param options [Options]
+        #
         def apply_buffer_sizes(sock, options)
-          sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_SNDBUF, options.sndbuf) if options.sndbuf
-          sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_RCVBUF, options.rcvbuf) if options.rcvbuf
+          if options.sndbuf
+            sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_SNDBUF, options.sndbuf)
+          end
+
+          if options.rcvbuf
+            sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_RCVBUF, options.rcvbuf)
+          end
         end
 
+
         private
 
+
         # Extracts path from "ipc://path".
         #
         def parse_path(endpoint)
-          endpoint.sub(%r{\Aipc://}, "")
+          endpoint.delete_prefix("ipc://")
         end
 
 
@@ -110,12 +124,15 @@ module OMQ
         # @param parent_task [Async::Task]
         # @yieldparam io [IO::Stream::Buffered]
         #
-        def start_accept_loops(parent_task, &on_accepted)
-          @task = parent_task.async(transient: true, annotation: "ipc accept #{@endpoint}") do
+        def start_accept_loops(parent_task)
+          annotation = "ipc accept #{@endpoint}"
+          @task = parent_task.async(transient: true, annotation:) do
             loop do
               client = @server.accept
               IPC.apply_buffer_sizes(client, @engine.options)
-              Async::Task.current.defer_stop { on_accepted.call(IO::Stream::Buffered.wrap(client)) }
+              Async::Task.current.defer_stop do
+                yield IO::Stream::Buffered.wrap(client)
+              end
             end
           rescue Async::Stop
           rescue IOError
@@ -135,11 +152,13 @@ module OMQ
         def stop
           @task&.stop
           @server.close rescue nil
+
           # Clean up socket file for file-based paths
           unless @path.start_with?("@")
             File.delete(@path) rescue nil
           end
         end
+
       end
     end
   end

data/lib/omq/transport/tcp.rb

@@ -17,23 +17,19 @@ module OMQ
         # @return [Listener]
         #
         def bind(endpoint, engine)
-          host, port = self.parse_endpoint(endpoint)
-          host = "0.0.0.0" if host == "*"
-
-          addrs = Addrinfo.getaddrinfo(host, port, nil, :STREAM, nil, ::Socket::AI_PASSIVE)
-          raise ::Socket::ResolutionError, "no addresses for #{host}" if addrs.empty?
-
-          servers     = []
-          actual_port = nil
-
-          addrs.each do |addr|
-            server = TCPServer.new(addr.ip_address, actual_port || port)
-            actual_port ||= server.local_address.ip_port
-            servers << server
-          end
-
-          host_part = host.include?(":") ? "[#{host}]" : host
-          resolved  = "tcp://#{host_part}:#{actual_port}"
+          host, port  = self.parse_endpoint(endpoint)
+          lookup_host = normalize_bind_host(host)
+
+          # Socket.tcp_server_sockets coordinates ephemeral ports across
+          # address families and sets IPV6_V6ONLY so IPv4 and IPv6
+          # wildcards don't collide on Linux.
+          servers = ::Socket.tcp_server_sockets(lookup_host, port)
+          raise ::Socket::ResolutionError, "no addresses for #{host.inspect}" if servers.empty?
+
+          actual_port  = servers.first.local_address.ip_port
+          display_host = host == "*" ? "*" : (lookup_host || "*")
+          host_part    = display_host.include?(":") ? "[#{display_host}]" : display_host
+          resolved     = "tcp://#{host_part}:#{actual_port}"
           Listener.new(resolved, servers, actual_port, engine)
         end
 
@@ -45,7 +41,8 @@ module OMQ
         #
         def validate_endpoint!(endpoint)
           host, _port = parse_endpoint(endpoint)
-          Addrinfo.getaddrinfo(host, nil, nil, :STREAM) if host
+          lookup_host = normalize_bind_host(host)
+          Addrinfo.getaddrinfo(lookup_host, nil, nil, :STREAM) if lookup_host
         end
 
 
@@ -57,12 +54,54 @@ module OMQ
         #
         def connect(endpoint, engine)
           host, port = self.parse_endpoint(endpoint)
-          sock = ::Socket.tcp(host, port, connect_timeout: connect_timeout(engine.options))
+          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)
+        #   else                   → unchanged
+        #
+        def normalize_bind_host(host)
+          case host
+          when "*" then nil
+          when nil, "", "localhost" then loopback_host
+          else host
+          end
+        end
+
+
+        # Normalizes the connect host: "", nil, "*", and "localhost" all
+        # map to the loopback host. Everything else is passed through so
+        # real hostnames still go through the resolver + Happy Eyeballs.
+        #
+        def normalize_connect_host(host)
+          case host
+          when nil, "", "*", "localhost" then loopback_host
+          else host
+          end
+        end
+
+
+        # Loopback address preference for bind/connect normalization.
+        # Returns "::1" when the host has at least one non-loopback,
+        # non-link-local IPv6 address, otherwise "127.0.0.1".
+        #
+        def loopback_host
+          @loopback_host ||= begin
+            has_ipv6 = ::Socket.getifaddrs.any? do |ifa|
+              addr = ifa.addr
+              addr&.ipv6? && !addr.ipv6_loopback? && !addr.ipv6_linklocal?
+            end
+            has_ipv6 ? "::1" : "127.0.0.1"
+          end
+        end
+
+
         # Connect timeout: cap each attempt at the reconnect interval so a
         # hung connect(2) (e.g. macOS kqueue + IPv6 ECONNREFUSED not delivered)
         # doesn't block the retry loop. Floor at 0.5s for real-network latency.
@@ -85,9 +124,20 @@ module OMQ
         end
 
 
+        # Applies SO_SNDBUF / SO_RCVBUF to +sock+ from the socket's
+        # {Options}. No-op when both are nil (OS default).
+        #
+        # @param sock [Socket, TCPSocket]
+        # @param options [Options]
+        #
         def apply_buffer_sizes(sock, options)
-          sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_SNDBUF, options.sndbuf) if options.sndbuf
-          sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_RCVBUF, options.rcvbuf) if options.rcvbuf
+          if options.sndbuf
+            sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_SNDBUF, options.sndbuf)
+          end
+
+          if options.rcvbuf
+            sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_RCVBUF, options.rcvbuf)
+          end
         end
       end
 
@@ -103,13 +153,13 @@ module OMQ
         #
         attr_reader :port
 
-        # @return [Array<TCPServer>] bound server sockets
+        # @return [Array<Socket>] bound server sockets
         #
         attr_reader :servers
 
 
         # @param endpoint [String] resolved endpoint URI
-        # @param servers [Array<TCPServer>]
+        # @param servers [Array<Socket>]
         # @param port [Integer] bound port number
         # @param engine [Engine]
         #
@@ -128,13 +178,17 @@ module OMQ
         # @param parent_task [Async::Task]
         # @yieldparam io [IO::Stream::Buffered]
         #
-        def start_accept_loops(parent_task, &on_accepted)
+        def start_accept_loops(parent_task)
           @tasks = @servers.map do |server|
-            parent_task.async(transient: true, annotation: "tcp accept #{@endpoint}") do
+            # TODO: use this server's exact host:port (@endpoint might not be unique)
+            annotation = "tcp accept #{@endpoint}"
+            parent_task.async(transient: true, annotation:) do
               loop do
-                client = server.accept
+                client, _addr = server.accept
                 TCP.apply_buffer_sizes(client, @engine.options)
-                Async::Task.current.defer_stop { on_accepted.call(IO::Stream::Buffered.wrap(client)) }
+                Async::Task.current.defer_stop do
+                  yield IO::Stream::Buffered.wrap(client)
+                end
               end
             rescue Async::Stop
             rescue IOError

data/lib/omq/version.rb

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

data/lib/omq/writable.rb

@@ -15,7 +15,11 @@ module OMQ
     #
     def send(message)
       parts = freeze_message(message)
-      Reactor.run { with_timeout(@options.write_timeout) { @engine.enqueue_send(parts) } }
+
+      Reactor.run timeout: @options.write_timeout do |task|
+        @engine.enqueue_send(parts)
+      end
+
       self
     end
 

data/lib/omq.rb

@@ -38,6 +38,7 @@ module OMQ
     IO::Stream::ConnectionResetError,
   ]
 
+
   # Errors raised when a peer cannot be reached.
   CONNECTION_FAILED = [
     Errno::ECONNREFUSED,
@@ -57,7 +58,7 @@ module OMQ
     CONNECTION_LOST.freeze
     CONNECTION_FAILED.freeze
     Engine.transports.freeze
-    Routing.instance_variable_get(:@registry).freeze
+    Routing.registry.freeze
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omq
 version: !ruby/object:Gem::Version
-  version: 0.17.9
+  version: 0.19.0
 platform: ruby
 authors:
 - Patrik Wenger
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '0.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '0.6'
 - !ruby/object:Gem::Dependency
   name: async
   requirement: !ruby/object:Gem::Requirement