omq 0.22.0 → 0.23.0

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
 

data/lib/omq/transport/udp.rb

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+require "socket"
+require "uri"
+require "set"
+
+module OMQ
+  module Transport
+    # UDP transport for RADIO/DISH sockets.
+    #
+    # Connectionless, datagram-based. No ZMTP handshake.
+    # DISH binds and receives; RADIO connects and sends.
+    #
+    # Wire format per datagram:
+    #   flags (1 byte = 0x01) | group_size (1 byte) | group (n bytes) | body
+    #
+    module UDP
+      Engine.transports["udp"] = self
+
+
+      MAX_DATAGRAM_SIZE = 65507
+
+      class << self
+        # Creates a bound UDP listener for a DISH socket.
+        #
+        # @param endpoint [String] e.g. "udp://*:5555" or "udp://127.0.0.1:5555"
+        # @param engine [Engine]
+        # @return [Listener]
+        #
+        def listener(endpoint, engine, **)
+          host, port = parse_endpoint(endpoint)
+          host = "0.0.0.0" if host == "*"
+          socket = UDPSocket.new
+          socket.bind(host, port)
+          Listener.new(endpoint, socket, engine)
+        end
+
+
+        # Creates a UDP dialer for a RADIO socket.
+        #
+        # @param endpoint [String] e.g. "udp://127.0.0.1:5555"
+        # @param engine [Engine]
+        # @return [Dialer]
+        #
+        def dialer(endpoint, engine, **)
+          Dialer.new(endpoint, engine)
+        end
+
+
+        # @param endpoint [String]
+        # @return [Array(String, Integer)]
+        #
+        def parse_endpoint(endpoint)
+          uri = URI.parse(endpoint)
+          [uri.hostname, uri.port]
+        end
+
+
+        # Encodes a group + body into a UDP datagram.
+        #
+        # @param group [String]
+        # @param body [String]
+        # @return [String] binary datagram
+        #
+        def encode_datagram(group, body)
+          g = group.b
+          b = body.b
+          [0x01, g.bytesize].pack("CC") + g + b
+        end
+
+
+        # Decodes a UDP datagram into [group, body].
+        #
+        # @param data [String] raw datagram bytes
+        # @return [Array(String, String), nil] nil if malformed
+        #
+        def decode_datagram(data)
+          return nil if data.bytesize < 2
+          return nil unless data.getbyte(0) & 0x01 == 0x01
+          gs = data.getbyte(1)
+          return nil if data.bytesize < 2 + gs
+          group = data.byteslice(2, gs)
+          body  = data.byteslice(2 + gs, data.bytesize - 2 - gs)
+          [group, body]
+        end
+      end
+
+
+      # A UDP dialer — registers a single RadioConnection with the engine.
+      #
+      # UDP is connectionless; #connect is a one-shot registration.
+      # The reconnect loop will break out after the first successful call.
+      #
+      class Dialer
+        # @return [String] the endpoint this dialer sends to
+        #
+        attr_reader :endpoint
+
+
+        # @param endpoint [String]
+        # @param engine [Engine]
+        #
+        def initialize(endpoint, engine)
+          @endpoint = endpoint
+          @engine   = engine
+        end
+
+
+        # Registers a RadioConnection with the engine.
+        #
+        # @return [void]
+        #
+        def connect
+          host, port = UDP.parse_endpoint(@endpoint)
+          socket     = UDPSocket.new
+          conn       = RadioConnection.new(socket, host, port)
+          @engine.connection_ready(conn, endpoint: @endpoint)
+        end
+
+      end
+
+
+      # Outgoing UDP connection for RADIO sockets.
+      #
+      # Intentionally does not implement #read_frame — this signals
+      # Routing::Radio to skip the group listener and use ANY_GROUPS.
+      #
+      class RadioConnection
+        # @param socket [UDPSocket]
+        # @param host [String]
+        # @param port [Integer]
+        #
+        def initialize(socket, host, port)
+          @socket = socket
+          @host   = host
+          @port   = port
+        end
+
+
+        # Encodes and sends a datagram.
+        #
+        # @param parts [Array<String>] [group, body]
+        #
+        def write_message(parts)
+          group, body = parts
+          datagram = UDP.encode_datagram(group.to_s, body.to_s)
+          @socket.send(datagram, 0, @host, @port)
+        rescue Errno::ECONNREFUSED, Errno::ENETUNREACH
+          # UDP fire-and-forget — drop silently
+        end
+
+        alias send_message write_message
+
+        # No-op; UDP datagrams are sent immediately.
+        def flush
+        end
+
+
+        # Whether this connection uses CURVE encryption.
+        #
+        # @return [Boolean] always false
+        def curve?
+          false
+        end
+
+
+        # Closes the underlying UDP socket.
+        def close
+          @socket.close rescue nil
+        end
+      end
+
+
+      # Incoming UDP connection for DISH sockets.
+      #
+      # Tracks joined groups locally. JOIN/LEAVE commands from the
+      # DISH routing strategy are intercepted via #send_command and
+      # never transmitted on the wire.
+      #
+      class DishConnection
+        # @param socket [UDPSocket] bound socket
+        #
+        def initialize(socket)
+          @socket = socket
+          @groups = Set.new
+        end
+
+
+        # Receives one matching datagram, blocking until available.
+        #
+        # Async-safe: rescues IO::WaitReadable and yields to the
+        # fiber scheduler via #wait_readable.
+        #
+        # @return [Array<String>] [group, body], both binary-frozen
+        #
+        def receive_message
+          loop do
+            data, = @socket.recvfrom_nonblock(MAX_DATAGRAM_SIZE)
+            parts = UDP.decode_datagram(data)
+            next unless parts
+            group, body = parts
+            next unless @groups.include?(group.b)
+            return [group.b.freeze, body.b.freeze]
+          rescue IO::WaitReadable
+            @socket.wait_readable
+            retry
+          end
+        end
+
+
+        # Handles JOIN/LEAVE commands locally; nothing is sent on the wire.
+        #
+        # @param cmd [Protocol::ZMTP::Codec::Command]
+        #
+        def send_command(cmd)
+          case cmd.name
+          when "JOIN"
+            @groups << cmd.data.b.freeze
+          when "LEAVE"
+            @groups.delete(cmd.data.b)
+          end
+        end
+
+
+        # Whether this connection uses CURVE encryption.
+        #
+        # @return [Boolean] always false
+        def curve?
+          false
+        end
+
+
+        # Closes the underlying UDP socket.
+        def close
+          @socket.close rescue nil
+        end
+      end
+
+
+      # Bound UDP listener for DISH sockets.
+      #
+      # Unlike TCP/IPC listeners, there is no accept loop — a single
+      # DishConnection is registered directly with the engine, bypassing
+      # the ZMTP handshake path.
+      #
+      class Listener
+        # @return [String] bound endpoint
+        #
+        attr_reader :endpoint
+
+        # @param endpoint [String]
+        # @param socket [UDPSocket]
+        # @param engine [Engine]
+        #
+        def initialize(endpoint, socket, engine)
+          @endpoint = endpoint
+          @socket   = socket
+          @engine   = engine
+        end
+
+
+        # Registers a DishConnection with the engine.
+        # The on_accepted block is intentionally ignored — no ZMTP handshake.
+        #
+        # @param parent_task [Async::Task] (unused)
+        #
+        def start_accept_loops(parent_task, &_on_accepted)
+          conn = DishConnection.new(@socket)
+          @engine.connection_ready(conn, endpoint: @endpoint)
+        end
+
+
+        # Stops the listener.
+        #
+        def stop
+          @socket.close rescue nil
+        end
+      end
+    end
+  end
+end

data/lib/omq/version.rb

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

data/lib/omq.rb

@@ -1,74 +1,12 @@
 # frozen_string_literal: true
 
-# OMQ — pure Ruby ZeroMQ (ZMTP 3.1).
-#
-# Socket types live directly under OMQ:: for a clean API:
-#   OMQ::PUSH, OMQ::PULL, OMQ::PUB, OMQ::SUB, etc.
-#
-
 require "protocol/zmtp"
 require "io/stream"
 
-require_relative "omq/version"
-require_relative "omq/monitor_event"
-
-module OMQ
-  # When OMQ_DEBUG is set, silent rescue clauses print the exception
-  # to stderr so transport/engine bugs surface immediately.
-  DEBUG = !!ENV["OMQ_DEBUG"]
-
-
-  # Raised when an internal pump task crashes unexpectedly.
-  # The socket is no longer usable; the original error is available via #cause.
-  #
-  class SocketDeadError < RuntimeError
-  end
-
-
-  # Errors raised when a peer disconnects or resets the connection.
-  # Not frozen at load time — transport plugins append to this before
-  # the first bind/connect, which freezes both arrays.
-  CONNECTION_LOST = [
-    EOFError,
-    IOError,
-    Errno::EPIPE,
-    Errno::ECONNRESET,
-    Errno::ECONNABORTED,
-    Errno::ENOTCONN,
-    IO::Stream::ConnectionResetError,
-  ]
-
-
-  # Errors raised when a peer cannot be reached.
-  CONNECTION_FAILED = [
-    Errno::ECONNREFUSED,
-    Errno::ENOENT,
-    Errno::ETIMEDOUT,
-    Errno::EHOSTUNREACH,
-    Errno::ENETUNREACH,
-    Errno::EPROTOTYPE, # IPC: existing socket file is SOCK_DGRAM, not SOCK_STREAM
-    Socket::ResolutionError,
-  ]
-
-
-  # Freezes module-level state so OMQ sockets can be used inside Ractors.
-  # Call this once before spawning any Ractors that create OMQ sockets.
-  #
-  def self.freeze_for_ractors!
-    CONNECTION_LOST.freeze
-    CONNECTION_FAILED.freeze
-    Engine.transports.freeze
-    Routing.registry.freeze
-  end
-end
-
-
-# Transport
-require_relative "omq/transport/inproc"
-require_relative "omq/transport/tcp"
-require_relative "omq/transport/ipc"
 
 # Core
+require_relative "omq/version"
+require_relative "omq/constants"
 require_relative "omq/reactor"
 require_relative "omq/options"
 require_relative "omq/routing"
@@ -86,6 +24,13 @@ require_relative "omq/routing/xsub"
 require_relative "omq/routing/push"
 require_relative "omq/routing/pull"
 require_relative "omq/engine"
+
+# Transport
+require_relative "omq/transport/inproc"
+require_relative "omq/transport/tcp"
+require_relative "omq/transport/ipc"
+
+# Mixins
 require_relative "omq/queue_interface"
 require_relative "omq/readable"
 require_relative "omq/writable"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omq
 version: !ruby/object:Gem::Version
-  version: 0.22.0
+  version: 0.23.0
 platform: ruby
 authors:
 - Patrik Wenger
@@ -65,6 +65,9 @@ files:
 - LICENSE
 - README.md
 - lib/omq.rb
+- lib/omq/channel.rb
+- lib/omq/client_server.rb
+- lib/omq/constants.rb
 - lib/omq/drop_queue.rb
 - lib/omq/engine.rb
 - lib/omq/engine/connection_lifecycle.rb
@@ -73,37 +76,48 @@ files:
 - lib/omq/engine/reconnect.rb
 - lib/omq/engine/recv_pump.rb
 - lib/omq/engine/socket_lifecycle.rb
-- lib/omq/monitor_event.rb
 - lib/omq/options.rb
 - lib/omq/pair.rb
+- lib/omq/peer.rb
 - lib/omq/pub_sub.rb
 - lib/omq/push_pull.rb
 - lib/omq/queue_interface.rb
+- lib/omq/radio_dish.rb
 - lib/omq/reactor.rb
 - lib/omq/readable.rb
 - lib/omq/req_rep.rb
 - lib/omq/router_dealer.rb
 - lib/omq/routing.rb
+- lib/omq/routing/channel.rb
+- lib/omq/routing/client.rb
 - lib/omq/routing/conn_send_pump.rb
 - lib/omq/routing/dealer.rb
+- lib/omq/routing/dish.rb
 - lib/omq/routing/fan_out.rb
+- lib/omq/routing/gather.rb
 - lib/omq/routing/pair.rb
+- lib/omq/routing/peer.rb
 - lib/omq/routing/pub.rb
 - lib/omq/routing/pull.rb
 - lib/omq/routing/push.rb
+- lib/omq/routing/radio.rb
 - lib/omq/routing/rep.rb
 - lib/omq/routing/req.rb
 - lib/omq/routing/round_robin.rb
 - lib/omq/routing/router.rb
+- lib/omq/routing/scatter.rb
+- lib/omq/routing/server.rb
 - lib/omq/routing/sub.rb
 - lib/omq/routing/xpub.rb
 - lib/omq/routing/xsub.rb
+- lib/omq/scatter_gather.rb
 - lib/omq/single_frame.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/transport/udp.rb
 - lib/omq/version.rb
 - lib/omq/writable.rb
 homepage: https://github.com/zeromq/omq

data/lib/omq/monitor_event.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module OMQ
-  # Lifecycle event emitted by {Socket#monitor}.
-  #
-  # @!attribute [r] type
-  #   @return [Symbol] event type (:listening, :connected, :disconnected, etc.)
-  # @!attribute [r] endpoint
-  #   @return [String, nil] the endpoint involved
-  # @!attribute [r] detail
-  #   @return [Hash, nil] extra context (e.g. { error: }, { interval: }, etc.)
-  #
-  MonitorEvent = Data.define(:type, :endpoint, :detail) do
-    def initialize(type:, endpoint: nil, detail: nil) = super
-  end
-end