omq 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d2e17e1a12c0f44bec5af914b8df2f810029e75c7da17e79e862428a7b0aa99d
-  data.tar.gz: 4a8d06116bad67adc4411cb3281302fd6190ecce46ceb47f21cc15a32c3e9006
+  metadata.gz: 852e5a45a7b9f61b32004aa2079e1289291c3ac2ecc5efeb78911d88d3b63b2e
+  data.tar.gz: b475a15807b8e98d4a852ec78b07ecaa4a0b15e68d3aec2fd9b2702533cb5d5f
 SHA512:
-  metadata.gz: 1dad86f1ad0648690bc5a01d3b7258b89f301d4768bac0831495d27f0a0e3c84f5a30af049732f8cc6885bcd6105654d41708d519da69c30a62739ca58a27418
-  data.tar.gz: a71f54aa26dd3e7dea3b249d027c03aeff896c7ded7b0581067fbda609d114c976c8d35a5f7f7e630cbbc34fbb839c7d43f6d445e8f2bb50f1348cb46f8d0e51
+  metadata.gz: 0afb8f440937ae11bebe4ce3ecc1df599103f27300ed721b14437d708bd1cba1cd5b0aeb6873bd7281d054c42f6353abc29b1c8c542f4708152c2ad6b047b5f0
+  data.tar.gz: b3477d54c520f7ed09dc4647b84841c9937d863036c4301afc3110bd959fd794bbd91db56d0204f317cd66ef62bf63ad8b1772521dc48f96912ae01e9bea8f81

data/CHANGELOG.md

@@ -1,5 +1,42 @@
 # Changelog
 
+## 0.8.0 — 2026-03-31
+
+### Breaking
+
+- **CURVE mechanism moved to protocol-zmtp** — `OMQ::ZMTP::Mechanism::Curve`
+  is now `Protocol::ZMTP::Mechanism::Curve` with a required `crypto:` parameter.
+  Pass `crypto: RbNaCl` (libsodium) or `crypto: Nuckle` (pure Ruby). The
+  omq-curve and omq-kurve gems are superseded.
+
+  ```ruby
+  # Before (omq-curve)
+  require "omq/curve"
+  rep.mechanism = OMQ::Curve.server(pub, sec)
+
+  # After (protocol-zmtp + any NaCl backend)
+  require "protocol/zmtp/mechanism/curve"
+  require "nuckle"  # or: require "rbnacl"
+  rep.mechanism = Protocol::ZMTP::Mechanism::Curve.server(pub, sec, crypto: Nuckle)
+  ```
+
+### Changed
+
+- **Protocol layer extracted into protocol-zmtp gem** — Codec (Frame,
+  Greeting, Command), Connection, Mechanism::Null, Mechanism::Curve,
+  ValidPeers, and Z85 now live in the
+  [protocol-zmtp](https://github.com/paddor/protocol-zmtp) gem. OMQ
+  re-exports them under `OMQ::ZMTP::` for backwards compatibility.
+  protocol-zmtp has zero runtime dependencies.
+- **Unified CURVE mechanism** — one implementation with a pluggable
+  `crypto:` backend replaces the two near-identical copies in omq-curve
+  (RbNaCl) and omq-kurve (Nuckle). 1,088 → 467 lines (57% reduction).
+- **Heartbeat ownership** — `Connection#start_heartbeat` removed.
+  Connection tracks timestamps only; the engine drives the PING/PONG loop.
+- **CI no longer needs libsodium** — CURVE tests use
+  [nuckle](https://github.com/paddor/nuckle) (pure Ruby) by default.
+  Cross-backend interop tests run when rbnacl is available.
+
 ## 0.7.0 — 2026-03-30
 
 ### Breaking
@@ -502,4 +539,4 @@ Initial release. Pure Ruby implementation of ZMTP 3.1 (ZeroMQ) using Async.
 - Linger on close (drain send queue before closing)
 - `max_message_size` enforcement
 - Works inside Async reactors or standalone (shared IO thread)
-- Optional CURVE encryption via the [omq-curve](https://github.com/zeromq/omq-curve) gem
+- Optional CURVE encryption via the [protocol-zmtp](https://github.com/paddor/protocol-zmtp) gem

data/lib/omq/version.rb

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

data/lib/omq/zmtp/engine.rb

@@ -432,17 +432,14 @@ module OMQ
       def setup_connection(io, as_server:, endpoint: nil, done: nil)
         conn = Connection.new(
           io,
-          socket_type:        @socket_type.to_s,
-          identity:           @options.identity,
-          as_server:          as_server,
-          mechanism:          @options.mechanism,
-          heartbeat_interval: @options.heartbeat_interval,
-          heartbeat_ttl:      @options.heartbeat_ttl,
-          heartbeat_timeout:  @options.heartbeat_timeout,
-          max_message_size:   @options.max_message_size,
+          socket_type:      @socket_type.to_s,
+          identity:         @options.identity,
+          as_server:        as_server,
+          mechanism:        @options.mechanism&.dup,
+          max_message_size: @options.max_message_size,
         )
         conn.handshake!
-        conn.start_heartbeat
+        start_heartbeat(conn)
         @connections << conn
         @connection_endpoints[conn] = endpoint if endpoint
         @connection_promises[conn]  = done if done
@@ -454,6 +451,35 @@ module OMQ
       end
 
 
+      # Spawns a heartbeat task for the connection.
+      # The connection only tracks timestamps — the engine drives the loop.
+      #
+      # @param conn [Connection]
+      # @return [void]
+      #
+      def start_heartbeat(conn)
+        interval = @options.heartbeat_interval
+        return unless interval
+
+        ttl     = @options.heartbeat_ttl || interval
+        timeout = @options.heartbeat_timeout || interval
+        conn.touch_heartbeat
+
+        @tasks << Reactor.spawn_pump(annotation: "heartbeat") do
+          loop do
+            sleep interval
+            conn.send_command(Codec::Command.ping(ttl: ttl, context: "".b))
+            if conn.heartbeat_expired?(timeout)
+              conn.close
+              break
+            end
+          end
+        rescue *CONNECTION_LOST
+          # connection closed
+        end
+      end
+
+
       # Spawns a background task that reconnects to the given endpoint
       # with exponential back-off based on the reconnect_interval option.
       #

data/lib/omq/zmtp.rb

@@ -1,13 +1,26 @@
 # frozen_string_literal: true
 
+require "protocol/zmtp"
+require "io/stream"
+
 module OMQ
   # ZMTP 3.1 protocol internals.
   #
-  # These classes implement the wire protocol, transports, and routing
-  # strategies. They are not part of the public API.
+  # The wire protocol (codec, connection, mechanisms) lives in the
+  # protocol-zmtp gem. This module re-exports those classes under the
+  # OMQ::ZMTP namespace and adds the transport/routing/engine layers.
   #
   module ZMTP
-    require "io/stream"
+    # Re-export protocol-zmtp classes
+    Codec         = Protocol::ZMTP::Codec
+    Connection    = Protocol::ZMTP::Connection
+    ProtocolError = Protocol::ZMTP::Error
+    VALID_PEERS   = Protocol::ZMTP::VALID_PEERS
+
+    module Mechanism
+      Null  = Protocol::ZMTP::Mechanism::Null
+      Curve = Protocol::ZMTP::Mechanism::Curve if defined?(Protocol::ZMTP::Mechanism::Curve)
+    end
 
     # Errors raised when a peer disconnects or resets the connection.
     CONNECTION_LOST = [
@@ -32,24 +45,14 @@ module OMQ
   end
 end
 
-# Constants
-require_relative "zmtp/valid_peers"
-
-# Codec
-require_relative "zmtp/codec"
-
 # Transport
 require_relative "zmtp/transport/inproc"
 require_relative "zmtp/transport/tcp"
 require_relative "zmtp/transport/ipc"
 
-# Mechanisms
-require_relative "zmtp/mechanism/null"
-
 # Core
 require_relative "zmtp/reactor"
 require_relative "zmtp/options"
-require_relative "zmtp/connection"
 require_relative "zmtp/routing"
 require_relative "zmtp/routing/round_robin"
 require_relative "zmtp/routing/fan_out"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omq
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Patrik Wenger
@@ -9,6 +9,20 @@ bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: protocol-zmtp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: async
   requirement: !ruby/object:Gem::Requirement
@@ -83,13 +97,7 @@ files:
 - lib/omq/socket.rb
 - lib/omq/version.rb
 - lib/omq/zmtp.rb
-- lib/omq/zmtp/codec.rb
-- lib/omq/zmtp/codec/command.rb
-- lib/omq/zmtp/codec/frame.rb
-- lib/omq/zmtp/codec/greeting.rb
-- lib/omq/zmtp/connection.rb
 - lib/omq/zmtp/engine.rb
-- lib/omq/zmtp/mechanism/null.rb
 - lib/omq/zmtp/options.rb
 - lib/omq/zmtp/reactor.rb
 - lib/omq/zmtp/readable.rb
@@ -119,7 +127,6 @@ files:
 - lib/omq/zmtp/transport/inproc.rb
 - lib/omq/zmtp/transport/ipc.rb
 - lib/omq/zmtp/transport/tcp.rb
-- lib/omq/zmtp/valid_peers.rb
 - lib/omq/zmtp/writable.rb
 homepage: https://github.com/zeromq/omq
 licenses:

data/lib/omq/zmtp/codec/command.rb

@@ -1,210 +0,0 @@
-# frozen_string_literal: true
-
-module OMQ
-  module ZMTP
-    module Codec
-      # ZMTP command encode/decode.
-      #
-      # Command frame body format:
-      #   1 byte:    command name length
-      #   N bytes:   command name
-      #   remaining: command data
-      #
-      # READY command data = property list:
-      #   1 byte:  property name length
-      #   N bytes: property name
-      #   4 bytes: property value length (big-endian)
-      #   N bytes: property value
-      #
-      class Command
-        # @return [String] command name (e.g. "READY", "SUBSCRIBE")
-        #
-        attr_reader :name
-
-        # @return [String] command data (binary)
-        #
-        attr_reader :data
-
-        # @param name [String] command name
-        # @param data [String] command data
-        #
-        def initialize(name, data = "".b)
-          @name = name
-          @data = data.b
-        end
-
-        # Encodes as a command frame body.
-        #
-        # @return [String] binary body (name-length + name + data)
-        #
-        def to_body
-          name_bytes = @name.b
-          name_bytes.bytesize.chr.b + name_bytes + @data
-        end
-
-        # Encodes as a complete command Frame.
-        #
-        # @return [Frame]
-        #
-        def to_frame
-          Frame.new(to_body, command: true)
-        end
-
-        # Decodes a command from a frame body.
-        #
-        # @param body [String] binary frame body
-        # @return [Command]
-        # @raise [ProtocolError] on malformed command
-        #
-        def self.from_body(body)
-          body = body.b
-          raise ProtocolError, "command body too short" if body.bytesize < 1
-
-          name_len = body.getbyte(0)
-
-          raise ProtocolError, "command name truncated" if body.bytesize < 1 + name_len
-
-          name = body.byteslice(1, name_len)
-          data = body.byteslice(1 + name_len..)
-          new(name, data)
-        end
-
-        # Builds a READY command with Socket-Type and Identity properties.
-        #
-        # @param socket_type [String] e.g. "REQ", "REP", "PAIR"
-        # @param identity [String] peer identity (can be empty)
-        # @return [Command]
-        #
-        def self.ready(socket_type:, identity: "")
-          props = encode_properties(
-            "Socket-Type" => socket_type,
-            "Identity"    => identity,
-          )
-          new("READY", props)
-        end
-
-        # Builds a SUBSCRIBE command.
-        #
-        # @param prefix [String] subscription prefix
-        # @return [Command]
-        #
-        def self.subscribe(prefix)
-          new("SUBSCRIBE", prefix.b)
-        end
-
-        # Builds a CANCEL command (unsubscribe).
-        #
-        # @param prefix [String] subscription prefix to cancel
-        # @return [Command]
-        #
-        def self.cancel(prefix)
-          new("CANCEL", prefix.b)
-        end
-
-        # Builds a JOIN command (RADIO/DISH group subscription).
-        #
-        # @param group [String] group name
-        # @return [Command]
-        #
-        def self.join(group)
-          new("JOIN", group.b)
-        end
-
-        # Builds a LEAVE command (RADIO/DISH group unsubscription).
-        #
-        # @param group [String] group name
-        # @return [Command]
-        #
-        def self.leave(group)
-          new("LEAVE", group.b)
-        end
-
-        # Builds a PING command.
-        #
-        # @param ttl [Numeric] time-to-live in seconds (sent as deciseconds)
-        # @param context [String] optional context bytes (up to 16 bytes)
-        # @return [Command]
-        #
-        def self.ping(ttl: 0, context: "".b)
-          ttl_ds = (ttl * 10).to_i
-          new("PING", [ttl_ds].pack("n") + context.b)
-        end
-
-        # Builds a PONG command.
-        #
-        # @param context [String] context bytes from the PING
-        # @return [Command]
-        #
-        def self.pong(context: "".b)
-          new("PONG", context.b)
-        end
-
-        # Extracts TTL (in seconds) and context from a PING command's data.
-        #
-        # @return [Array(Numeric, String)] [ttl_seconds, context_bytes]
-        #
-        def ping_ttl_and_context
-          ttl_ds  = @data.unpack1("n")
-          context = @data.bytesize > 2 ? @data.byteslice(2..) : "".b
-          [ttl_ds / 10.0, context]
-        end
-
-        # Parses READY command data as a property list.
-        #
-        # @return [Hash<String, String>] property name => value
-        # @raise [ProtocolError] on malformed properties
-        #
-        def properties
-          self.class.decode_properties(@data)
-        end
-
-        # Encodes a hash of properties into ZMTP property list format.
-        #
-        # @param props [Hash<String, String>]
-        # @return [String] binary property list
-        #
-        def self.encode_properties(props)
-          parts = props.map do |name, value|
-            name_bytes  = name.b
-            value_bytes = value.b
-            name_bytes.bytesize.chr.b + name_bytes + [value_bytes.bytesize].pack("N") + value_bytes
-          end
-          parts.join
-        end
-
-        # Decodes a ZMTP property list from binary data.
-        #
-        # @param data [String] binary property list
-        # @return [Hash<String, String>] property name => value
-        # @raise [ProtocolError] on malformed properties
-        #
-        def self.decode_properties(data)
-          result = {}
-          offset = 0
-
-          while offset < data.bytesize
-            raise ProtocolError, "property name truncated" if offset + 1 > data.bytesize
-            name_len = data.getbyte(offset)
-            offset += 1
-
-            raise ProtocolError, "property name truncated" if offset + name_len > data.bytesize
-            name = data.byteslice(offset, name_len)
-            offset += name_len
-
-            raise ProtocolError, "property value length truncated" if offset + 4 > data.bytesize
-            value_len = data.byteslice(offset, 4).unpack1("N")
-            offset += 4
-
-            raise ProtocolError, "property value truncated" if offset + value_len > data.bytesize
-            value = data.byteslice(offset, value_len)
-            offset += value_len
-
-            result[name] = value
-          end
-
-          result
-        end
-      end
-    end
-  end
-end

data/lib/omq/zmtp/codec/frame.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-module OMQ
-  module ZMTP
-    module Codec
-      # ZMTP frame encode/decode.
-      #
-      # Wire format:
-      #   Byte 0:   flags (bit 0=MORE, bit 1=LONG, bit 2=COMMAND)
-      #   Next 1-8: size (1-byte if short, 8-byte big-endian if LONG)
-      #   Next N:   body
-      #
-      class Frame
-        FLAGS_MORE    = 0x01
-        FLAGS_LONG    = 0x02
-        FLAGS_COMMAND = 0x04
-
-        # Short frame: 1-byte size, max body 255 bytes.
-        #
-        SHORT_MAX = 255
-
-        # @return [String] frame body (binary)
-        #
-        attr_reader :body
-
-        # @param body [String] frame body
-        # @param more [Boolean] more frames follow
-        # @param command [Boolean] this is a command frame
-        #
-        def initialize(body, more: false, command: false)
-          @body    = body.b
-          @more    = more
-          @command = command
-        end
-
-        # @return [Boolean] true if more frames follow in this message
-        #
-        def more?    = @more
-
-        # @return [Boolean] true if this is a command frame
-        #
-        def command? = @command
-
-        # Encodes to wire bytes.
-        #
-        # @return [String] binary wire representation (flags + size + body)
-        #
-        def to_wire
-          size  = @body.bytesize
-          flags = 0
-          flags |= FLAGS_MORE if @more
-          flags |= FLAGS_COMMAND if @command
-
-          if size > SHORT_MAX
-            (flags | FLAGS_LONG).chr.b + [size].pack("Q>") + @body
-          else
-            flags.chr.b + size.chr.b + @body
-          end
-        end
-
-        # Reads one frame from an IO-like object.
-        #
-        # @param io [#read_exactly] must support read_exactly(n)
-        # @return [Frame]
-        # @raise [ProtocolError] on invalid frame
-        # @raise [EOFError] if the connection is closed
-        #
-        def self.read_from(io)
-          flags = io.read_exactly(1).getbyte(0)
-
-          more    = (flags & FLAGS_MORE) != 0
-          long    = (flags & FLAGS_LONG) != 0
-          command = (flags & FLAGS_COMMAND) != 0
-
-          size = if long
-                   io.read_exactly(8).unpack1("Q>")
-                 else
-                   io.read_exactly(1).getbyte(0)
-                 end
-
-          body = size > 0 ? io.read_exactly(size) : "".b
-
-          new(body, more: more, command: command)
-        end
-
-      end
-    end
-  end
-end

data/lib/omq/zmtp/codec/greeting.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module OMQ
-  module ZMTP
-    module Codec
-      # ZMTP 3.1 greeting encode/decode.
-      #
-      # The greeting is always exactly 64 bytes:
-      #   Offset  Bytes  Field
-      #   0       1      0xFF (signature start)
-      #   1-8     8      0x00 padding
-      #   9       1      0x7F (signature end)
-      #   10      1      major version
-      #   11      1      minor version
-      #   12-31   20     mechanism (null-padded ASCII)
-      #   32      1      as-server flag (0x00 or 0x01)
-      #   33-63   31     filler (0x00)
-      #
-      module Greeting
-        SIZE             = 64
-        SIGNATURE_START  = 0xFF
-        SIGNATURE_END    = 0x7F
-        VERSION_MAJOR    = 3
-        VERSION_MINOR    = 1
-        MECHANISM_OFFSET = 12
-        MECHANISM_LENGTH = 20
-        AS_SERVER_OFFSET = 32
-
-        # Encodes a ZMTP 3.1 greeting.
-        #
-        # @param mechanism [String] security mechanism name (e.g. "NULL")
-        # @param as_server [Boolean] whether this peer is the server
-        # @return [String] 64-byte binary greeting
-        #
-        def self.encode(mechanism: "NULL", as_server: false)
-          buf = "\xFF".b + ("\x00" * 8) + "\x7F".b
-          buf << [VERSION_MAJOR, VERSION_MINOR].pack("CC")
-          buf << mechanism.b.ljust(MECHANISM_LENGTH, "\x00")
-          buf << (as_server ? "\x01" : "\x00")
-          buf << ("\x00" * 31)
-        end
-
-        # Decodes a ZMTP greeting.
-        #
-        # @param data [String] 64-byte binary greeting
-        # @return [Hash] { major:, minor:, mechanism:, as_server: }
-        # @raise [ProtocolError] on invalid greeting
-        #
-        def self.decode(data)
-          raise ProtocolError, "greeting too short (#{data.bytesize} bytes)" if data.bytesize < SIZE
-
-          data = data.b
-
-          unless data.getbyte(0) == SIGNATURE_START && data.getbyte(9) == SIGNATURE_END
-            raise ProtocolError, "invalid greeting signature"
-          end
-
-          major = data.getbyte(10)
-          minor = data.getbyte(11)
-
-          unless major >= 3
-            raise ProtocolError, "unsupported ZMTP version #{major}.#{minor} (need >= 3.0)"
-          end
-
-          mechanism = data.byteslice(MECHANISM_OFFSET, MECHANISM_LENGTH).delete("\x00")
-          as_server = data.getbyte(AS_SERVER_OFFSET) == 1
-
-          {
-            major:     major,
-            minor:     minor,
-            mechanism: mechanism,
-            as_server: as_server,
-          }
-        end
-      end
-    end
-  end
-end

data/lib/omq/zmtp/codec.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module OMQ
-  module ZMTP
-    # ZMTP 3.1 wire protocol codec.
-    #
-    module Codec
-    end
-
-    # Raised on ZMTP protocol violations.
-    #
-    class ProtocolError < RuntimeError; end
-  end
-end
-
-require_relative "codec/greeting"
-require_relative "codec/frame"
-require_relative "codec/command"

data/lib/omq/zmtp/connection.rb

@@ -1,282 +0,0 @@
-# frozen_string_literal: true
-
-module OMQ
-  module ZMTP
-    # Manages one ZMTP peer connection over any transport IO.
-    #
-    # Delegates the security handshake to a Mechanism object (Null, Curve, etc.),
-    # then provides message send/receive and command send/receive on top of the
-    # framing codec.
-    #
-    class Connection
-      # @return [String] peer's socket type (from READY handshake)
-      #
-      attr_reader :peer_socket_type
-
-
-      # @return [String] peer's identity (from READY handshake)
-      #
-      attr_reader :peer_identity
-
-
-      # @return [Object] transport IO (#read, #write, #close)
-      #
-      attr_reader :io
-
-
-      # @param io [#read, #write, #close] transport IO
-      # @param socket_type [String] our socket type name (e.g. "REQ")
-      # @param identity [String] our identity
-      # @param as_server [Boolean] whether we are the server side
-      # @param mechanism [Mechanism::Null, Mechanism::Curve] security mechanism
-      # @param heartbeat_interval [Numeric, nil] heartbeat interval in seconds
-      # @param heartbeat_ttl [Numeric, nil] TTL to send in PING
-      # @param heartbeat_timeout [Numeric, nil] timeout for PONG
-      # @param max_message_size [Integer, nil] max frame size in bytes, nil = unlimited
-      #
-      def initialize(io, socket_type:, identity: "", as_server: false,
-                     mechanism: nil,
-                     heartbeat_interval: nil, heartbeat_ttl: nil, heartbeat_timeout: nil,
-                     max_message_size: nil)
-        @io                  = io
-        @socket_type         = socket_type
-        @identity            = identity
-        @as_server           = as_server
-        @mechanism           = mechanism || Mechanism::Null.new
-        @peer_socket_type    = nil
-        @peer_identity       = nil
-        @mutex               = Mutex.new
-        @heartbeat_interval  = heartbeat_interval
-        @heartbeat_ttl       = heartbeat_ttl || heartbeat_interval
-        @heartbeat_timeout   = heartbeat_timeout || heartbeat_interval
-        @last_received_at    = nil
-        @heartbeat_task      = nil
-        @max_message_size    = max_message_size
-      end
-
-
-      # Performs the full ZMTP handshake via the configured mechanism.
-      #
-      # @return [void]
-      # @raise [ProtocolError] on handshake failure
-      #
-      def handshake!
-        result = @mechanism.handshake!(
-          @io,
-          as_server:   @as_server,
-          socket_type: @socket_type,
-          identity:    @identity,
-        )
-
-        @peer_socket_type = result[:peer_socket_type]
-        @peer_identity    = result[:peer_identity]
-
-        unless @peer_socket_type
-          raise ProtocolError, "peer READY missing Socket-Type"
-        end
-
-        unless ZMTP::VALID_PEERS[@socket_type.to_sym]&.include?(@peer_socket_type.to_sym)
-          raise ProtocolError,
-                "incompatible socket types: #{@socket_type} cannot connect to #{@peer_socket_type}"
-        end
-      end
-
-
-      # Sends a multi-frame message (write + flush).
-      #
-      # @param parts [Array<String>] message frames
-      # @return [void]
-      #
-      def send_message(parts)
-        @mutex.synchronize do
-          write_frames(parts)
-          @io.flush
-        end
-      end
-
-
-      # Writes a multi-frame message to the buffer without flushing.
-      # Call {#flush} after batching writes.
-      #
-      # @param parts [Array<String>] message frames
-      # @return [void]
-      #
-      def write_message(parts)
-        @mutex.synchronize do
-          write_frames(parts)
-        end
-      end
-
-
-      # Flushes the write buffer to the underlying IO.
-      #
-      # @return [void]
-      #
-      def flush
-        @mutex.synchronize do
-          @io.flush
-        end
-      end
-
-
-      # Receives a multi-frame message.
-      # PING/PONG commands are handled automatically by #read_frame.
-      #
-      # @return [Array<String>] message frames
-      # @raise [EOFError] if connection is closed
-      #
-      def receive_message
-        frames = []
-        loop do
-          frame = read_frame
-          if frame.command?
-            yield frame if block_given?
-            next
-          end
-          frames << frame.body.freeze
-          break unless frame.more?
-        end
-        frames.freeze
-      end
-
-
-      # Starts the heartbeat sender task. Call after handshake.
-      #
-      # @return [#stop, nil] the heartbeat task, or nil if disabled
-      #
-      def start_heartbeat
-        return nil unless @heartbeat_interval
-        @last_received_at = monotonic_now
-        @heartbeat_task = Reactor.spawn_pump(annotation: "heartbeat") do
-          loop do
-            sleep @heartbeat_interval
-            # Send PING with TTL
-            send_command(Codec::Command.ping(
-              ttl:     @heartbeat_ttl || 0,
-              context: "".b,
-            ))
-            # Check if peer has gone silent
-            if @heartbeat_timeout && @last_received_at
-              elapsed = monotonic_now - @last_received_at
-              if elapsed > @heartbeat_timeout
-                close
-                break
-              end
-            end
-          end
-        rescue *ZMTP::CONNECTION_LOST
-          # connection closed
-        end
-      end
-
-
-      # Sends a command.
-      #
-      # @param command [Codec::Command]
-      # @return [void]
-      #
-      def send_command(command)
-        @mutex.synchronize do
-          if @mechanism.encrypted?
-            @io.write(@mechanism.encrypt(command.to_body, command: true))
-          else
-            @io.write(command.to_frame.to_wire)
-          end
-          @io.flush
-        end
-      end
-
-
-      # Reads one frame from the wire. Handles PING/PONG automatically.
-      # When using an encrypted mechanism, MESSAGE commands are decrypted
-      # back to ZMTP frames transparently.
-      #
-      # @return [Codec::Frame]
-      # @raise [EOFError] if connection is closed
-      #
-      def read_frame
-        loop do
-          frame = Codec::Frame.read_from(@io)
-          touch_heartbeat
-
-          # When CURVE is active, every wire frame is a MESSAGE envelope
-          # (data frame with "\x07MESSAGE" prefix). Decrypt to recover the
-          # inner ZMTP frame. This check only runs when encrypted? is true,
-          # so user data frames are never misdetected.
-          if @mechanism.encrypted? && frame.body.bytesize > 8 && frame.body.byteslice(0, 8) == "\x07MESSAGE".b
-            frame = @mechanism.decrypt(frame)
-          end
-
-          if @max_message_size && !frame.command? && frame.body.bytesize > @max_message_size
-            close
-            raise ProtocolError, "frame size #{frame.body.bytesize} exceeds max_message_size #{@max_message_size}"
-          end
-          if frame.command?
-            cmd = Codec::Command.from_body(frame.body)
-            case cmd.name
-            when "PING"
-              _, context = cmd.ping_ttl_and_context
-              send_command(Codec::Command.pong(context: context))
-              next
-            when "PONG"
-              next
-            end
-          end
-          return frame
-        end
-      end
-
-
-      # Closes the connection.
-      #
-      # @return [void]
-      #
-      def close
-        @heartbeat_task&.stop rescue nil
-        @io.close
-      rescue IOError
-        # already closed
-      end
-
-
-      private
-
-
-      # Writes message parts as ZMTP frames, encrypting if needed.
-      #
-      # @param parts [Array<String>] message frames
-      #
-      def write_frames(parts)
-        parts.each_with_index do |part, i|
-          more = i < parts.size - 1
-          if @mechanism.encrypted?
-            @io.write(@mechanism.encrypt(part.b, more: more))
-          else
-            @io.write(Codec::Frame.new(part, more: more).to_wire)
-          end
-        end
-      end
-
-
-      def touch_heartbeat
-        @last_received_at = monotonic_now if @heartbeat_interval
-      end
-
-
-      def monotonic_now
-        Async::Clock.now
-      end
-
-
-      # Sends one frame to the wire.
-      #
-      # @param frame [Codec::Frame]
-      # @return [void]
-      #
-      def send_frame(frame)
-        @mutex.synchronize { @io.write(frame.to_wire) }
-      end
-
-    end
-  end
-end

data/lib/omq/zmtp/mechanism/null.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-module OMQ
-  module ZMTP
-    module Mechanism
-      # NULL security mechanism — no encryption, no authentication.
-      #
-      # Performs the ZMTP 3.1 greeting exchange and READY command handshake.
-      #
-      class Null
-        MECHANISM_NAME = "NULL"
-
-        # Performs the full NULL handshake over +io+.
-        #
-        # 1. Exchange 64-byte greetings
-        # 2. Validate peer greeting (version, mechanism)
-        # 3. Exchange READY commands (socket type + identity)
-        #
-        # @param io [#read, #write] transport IO
-        # @param as_server [Boolean]
-        # @param socket_type [String]
-        # @param identity [String]
-        # @return [Hash] { peer_socket_type:, peer_identity: }
-        # @raise [ProtocolError]
-        #
-        def handshake!(io, as_server:, socket_type:, identity:)
-          # Send our greeting
-          io.write(Codec::Greeting.encode(mechanism: MECHANISM_NAME, as_server: as_server))
-          io.flush
-
-          # Read peer greeting
-          greeting_data = io.read_exactly(Codec::Greeting::SIZE)
-          peer_greeting = Codec::Greeting.decode(greeting_data)
-
-          unless peer_greeting[:mechanism] == MECHANISM_NAME
-            raise ProtocolError, "unsupported mechanism: #{peer_greeting[:mechanism]}"
-          end
-
-          # Send our READY command
-          ready_cmd = Codec::Command.ready(socket_type: socket_type, identity: identity)
-          io.write(ready_cmd.to_frame.to_wire)
-          io.flush
-
-          # Read peer READY command
-          frame = Codec::Frame.read_from(io)
-          unless frame.command?
-            raise ProtocolError, "expected command frame, got data frame"
-          end
-
-          peer_cmd = Codec::Command.from_body(frame.body)
-          unless peer_cmd.name == "READY"
-            raise ProtocolError, "expected READY command, got #{peer_cmd.name}"
-          end
-
-          props = peer_cmd.properties
-          peer_socket_type = props["Socket-Type"]
-          peer_identity    = props["Identity"] || ""
-
-          unless peer_socket_type
-            raise ProtocolError, "peer READY missing Socket-Type"
-          end
-
-          { peer_socket_type: peer_socket_type, peer_identity: peer_identity }
-        end
-
-        # @return [Boolean] false — NULL does not encrypt frames
-        #
-        def encrypted? = false
-      end
-    end
-  end
-end

data/lib/omq/zmtp/valid_peers.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module OMQ
-  module ZMTP
-    # Valid socket type peer combinations per ZMTP spec.
-    #
-    VALID_PEERS = {
-      PAIR:   %i[PAIR].freeze,
-      REQ:    %i[REP ROUTER].freeze,
-      REP:    %i[REQ DEALER].freeze,
-      DEALER: %i[REP DEALER ROUTER].freeze,
-      ROUTER: %i[REQ DEALER ROUTER].freeze,
-      PUB:    %i[SUB XSUB].freeze,
-      SUB:    %i[PUB XPUB].freeze,
-      XPUB:   %i[SUB XSUB].freeze,
-      XSUB:   %i[PUB XPUB].freeze,
-      PUSH:    %i[PULL].freeze,
-      PULL:    %i[PUSH].freeze,
-      CLIENT:  %i[SERVER].freeze,
-      SERVER:  %i[CLIENT].freeze,
-      RADIO:   %i[DISH].freeze,
-      DISH:    %i[RADIO].freeze,
-      SCATTER: %i[GATHER].freeze,
-      GATHER:  %i[SCATTER].freeze,
-      PEER:    %i[PEER].freeze,
-      CHANNEL: %i[CHANNEL].freeze,
-    }.freeze
-  end
-end