omq 0.22.1 → 0.24.0

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, body]
+          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.1"
+  VERSION = "0.24.0"
 end

data/lib/omq/writable.rb

@@ -9,19 +9,25 @@ module OMQ
     include QueueWritable
 
 
-    EMPTY_PART = "".b.freeze
-
-
     # Sends a message.
     #
+    # Caller owns the message parts. Don't mutate them after sending — especially
+    # with inproc transport or PUB fan-out, where a single reference can be shared
+    # across peers and read later by the send pump.
+    #
     # @param message [String, Array<String>] message parts
     # @return [self]
     # @raise [IO::TimeoutError] if write_timeout exceeded
     #
     def send(message)
-      parts = freeze_message(message)
+      parts = message.is_a?(Array) ? message : [message]
+      raise ArgumentError, "message has no parts" if parts.empty?
 
-      Reactor.run timeout: @options.write_timeout do |task|
+      if @engine.on_io_thread?
+        Reactor.run(timeout: @options.write_timeout) { @engine.enqueue_send(parts) }
+      elsif (timeout = @options.write_timeout)
+        Async::Task.current.with_timeout(timeout, IO::TimeoutError) { @engine.enqueue_send(parts) }
+      else
         @engine.enqueue_send(parts)
       end
 
@@ -48,42 +54,5 @@ module OMQ
       true
     end
 
-
-    private
-
-
-    # Converts a message into a frozen array of frozen binary strings.
-    #
-    # @param message [String, Array<String>]
-    # @return [Array<String>] frozen array of frozen binary strings
-    #
-    def freeze_message(message)
-      parts = message.is_a?(Array) ? message : [message]
-      raise ArgumentError, "message has no parts" if parts.empty?
-
-      all_ready = parts.all? { |p| p.is_a?(String) && p.frozen? && p.encoding == Encoding::BINARY }
-
-      # Already a frozen array of frozen binary strings → return as-is.
-      return parts if all_ready && parts.frozen?
-
-      # Items are ready; just freeze the outer array.
-      return parts.freeze if all_ready
-
-      # Items need conversion. Mutate in place when we can.
-      if parts.frozen?
-        parts.map { |p| frozen_binary(p) }.freeze
-      else
-        parts.map! { |p| frozen_binary(p) }.freeze
-      end
-    end
-
-
-    def frozen_binary(obj)
-      return EMPTY_PART if obj.nil?
-      s = obj.to_s
-      return s if s.frozen? && s.encoding == Encoding::BINARY
-      s.b.freeze
-    end
-
   end
 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.1
+  version: 0.24.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/inproc/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