omq 0.10.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a81ea3e22e2133f508016129454fca72393068b259400e3d47aaf92d0948136
-  data.tar.gz: 71839df55e8ae9edb9db9710b77c5449853cde909c60867958a46e8350f27ead
+  metadata.gz: b736b6b715f5c4f330d21be278450600b2642239b8bea9e85957f516e89211ed
+  data.tar.gz: 34c057a32055e7333e4299e85c0fee9e798b43ea34d021f237ba6778338b65f1
 SHA512:
-  metadata.gz: 9e9d603fb6f44b53626e37d88da5dea1297f932bfbc7b3af0b32e5ab4ebdc6c2151f4b7482bca70d5060d31ffc49ba3c771603b6ed1b4dd17ed51733339de67d
-  data.tar.gz: b40525791795b8e040a4a275a628c1cdca42eab43fcabfab76407de97f669ff9c1b21d05490509c0e0f5cd0b53505c7f85281343b2c312bdb89fd3eee7d4af75
+  metadata.gz: e95a6df6d4eb56ac1fc0586f61cfdb77d0afe9de620d3e540ffbae1256c2fe6526556485215eda3de20c8f34a332f51a68e5bb075087665049c0219bb07f6960
+  data.tar.gz: 8b5c8d38b7523e9c6ab30e17c21b0cf4adb2086e1bdde90298f62e42f4b8f2336cdd95c47293c3fb24fa41f376aed8a2ec6d1121fc56d41aa83d4afdc289d707

data/CHANGELOG.md

@@ -1,6 +1,68 @@
 # Changelog
 
-## Unreleased
+## 0.11.0
+
+### Added
+
+- **`backend:` kwarg** — all socket types accept `backend: :ffi` to use
+  the libzmq FFI backend (via the [omq-ffi](https://github.com/paddor/omq-ffi)
+  gem). Default is `:ruby` (pure Ruby ZMTP). Enables interop testing and
+  access to libzmq-specific features without changing the socket API.
+- **TLS transport (`tls+tcp://`)** — TLS v1.3 on top of TCP using Ruby's
+  stdlib `openssl`. Set `socket.tls_context` to an `OpenSSL::SSL::SSLContext`
+  before bind/connect. Per-socket (not per-endpoint), frozen on first use.
+  SNI set automatically from the endpoint hostname. Bad TLS handshakes are
+  dropped without killing the accept loop. `OpenSSL::SSL::SSLError` added
+  to `CONNECTION_LOST` for automatic reconnection on TLS failures.
+  Accompanied by a draft RFC (`rfc/zmtp-tls.md`) defining the transport
+  mapping for ZMTP 3.1 over TLS.
+- **PUB/RADIO fan-out pre-encoding** — ZMTP frames are encoded once per
+  message and written as raw wire bytes to all non-CURVE subscribers.
+  Eliminates redundant `Frame.new` + `#to_wire` calls during fan-out.
+  CURVE connections (which encrypt at the ZMTP level) still encode
+  per-connection. TLS, NULL, and PLAIN all benefit since TLS encrypts
+  below ZMTP. Requires protocol-zmtp `Frame.encode_message` and
+  `Connection#write_wire`.
+- **CURVE benchmarks** — all per-pattern benchmarks now include CURVE
+  (via rbnacl) alongside inproc, ipc, tcp, and tls transports.
+- **Engine `connection_wrapper` hook** — optional proc on Engine that wraps
+  new connections (both inproc and tcp/ipc) at creation time. Used by the
+  omq-ractor gem for per-connection serialization (Marshal for tcp/ipc,
+  `Ractor.make_shareable` for inproc).
+- **Queue-style interface** — readable sockets gain `#dequeue(timeout:)`,
+  `#pop`, `#wait`, and `#each`; writable sockets gain `#enqueue` and
+  `#push`. Inspired by `Async::Queue`. `#wait` blocks indefinitely
+  (ignores `read_timeout`); `#each` returns gracefully on timeout.
+- **Recv pump fairness** — each connection yields to the fiber scheduler
+  after 64 messages or 1 MB (whichever comes first). Prevents a fast or
+  large-message connection from starving slower peers when the consumer
+  keeps up. Byte counting gracefully handles non-string messages (e.g.
+  deserialized objects from connection wrappers).
+- **Per-pattern benchmark suite** — `bench/{push_pull,req_rep,router_dealer,dealer_dealer,pub_sub,pair}/omq.rb`
+  with shared helpers (`bench_helper.rb`) and UnicodePlot braille line
+  charts (`plot.rb`). Each benchmark measures throughput (msg/s) and
+  bandwidth (MB/s) across transports (inproc, ipc, tcp, tls, curve),
+  message sizes (64 B–64 KB), and peer counts (1, 3). Plots are written to per-directory
+  `README.md` files for easy diffing across versions.
+
+### Changed
+
+- **SUB/XSUB `prefix:` kwarg renamed to `subscribe:`** — aligns with
+  ZeroMQ conventions. `subscribe: nil` (no subscription) remains the
+  default; pass `subscribe: ''` to subscribe to everything, or
+  `subscribe: 'topic.'` for a prefix filter.
+- **Scenario benchmarks moved to `bench/scenarios/`** — broker,
+  draft_types, flush_batching, hwm_backpressure, large_messages,
+  multiframe, pubsub_fanout, ractors_vs_async, ractors_vs_fork,
+  reconnect_storm, and reqrep_throughput moved from `bench/` top level.
+
+### Removed
+
+- **Old flat benchmarks** — `bench/throughput.rb`, `bench/latency.rb`,
+  `bench/pipeline_mbps.rb`, `bench/run_all.sh` replaced by per-pattern
+  benchmarks.
+- **`bench/cli/`** — CLI-specific benchmarks (fib pipeline, latency,
+  throughput shell scripts) moved to the omq-cli repository.
 
 ## 0.10.0 — 2026-04-01
 

data/README.md

@@ -9,9 +9,9 @@
 
 OMQ builds ZeroMQ socket patterns on top of [protocol-zmtp](https://github.com/paddor/protocol-zmtp) (a pure Ruby [ZMTP 3.1](https://rfc.zeromq.org/spec/23/) codec) using [Async](https://github.com/socketry/async) fibers. It speaks native ZeroMQ on the wire and interoperates with libzmq, pyzmq, CZMQ, and everything else in the ZMQ ecosystem.
 
-> **234k msg/s** inproc | **49k msg/s** ipc | **36k msg/s** tcp
+> **980k msg/s** inproc | **38k msg/s** ipc | **31k msg/s** tcp
 >
-> **12 µs** inproc latency | **51 µs** ipc | **62 µs** tcp
+> **10 µs** inproc latency | **71 µs** ipc | **82 µs** tcp
 >
 > Ruby 4.0 + YJIT on a Linux VM — see [`bench/`](bench/) for full results
 
@@ -30,7 +30,7 @@ See [GETTING_STARTED.md](GETTING_STARTED.md) for a ~30 min walkthrough of all ma
 ## Highlights
 
 - **Zero dependencies on C** — no extensions, no FFI, no libzmq. `gem install` just works everywhere
-- **Fast** — YJIT-optimized hot paths, batched sends, 234k msg/s inproc with 12 µs latency
+- **Fast** — YJIT-optimized hot paths, batched sends, recv prefetching, direct-pipe inproc bypass. 980k msg/s inproc, 10 µs latency
 - **[`omq` CLI](https://github.com/paddor/omq-cli)** — `gem install omq-cli` for a command-line tool with Ruby eval, Ractor parallelism, and script handlers
 - **Every socket pattern** — req/rep, pub/sub, push/pull, dealer/router, xpub/xsub, pair, and all draft types
 - **Every transport** — tcp, ipc (Unix domain sockets), inproc (in-process queues)
@@ -125,6 +125,26 @@ pull.close
 
 The IO thread runs all pumps, reconnection, and heartbeating in the background. When you're inside an `Async` block, OMQ uses the existing reactor instead.
 
+### Queue Interface
+
+All sockets expose an `Async::Queue`-inspired interface:
+
+| Async::Queue | OMQ Socket | Notes |
+|---|---|---|
+| `enqueue(item)` / `push(item)` | `enqueue(msg)` / `push(msg)` | Also: `send(msg)`, `<< msg` |
+| `dequeue(timeout:)` / `pop(timeout:)` | `dequeue(timeout:)` / `pop(timeout:)` | Defaults to socket's `read_timeout` |
+| `wait` | `wait` | Blocks indefinitely (ignores `read_timeout`) |
+| `each` | `each` | Yields messages; returns on close or timeout |
+
+```ruby
+pull = OMQ::PULL.bind('inproc://work')
+
+# iterate messages like a queue
+pull.each do |msg|
+  puts msg.first
+end
+```
+
 ## Socket Types
 
 All sockets are thread-safe. Default HWM is 1000 messages per socket. Classes live under `OMQ::` (alias: `ØMQ`).
@@ -163,6 +183,11 @@ echo "hello" | omq req -c tcp://localhost:5555
 
 See the [omq-cli README](https://github.com/paddor/omq-cli) for full documentation.
 
+## Companion Gems
+
+- **[omq-ffi](https://github.com/paddor/omq-ffi)** — libzmq FFI backend. Same OMQ socket API, but backed by libzmq instead of the pure Ruby ZMTP stack. Useful for interop testing and when you need libzmq-specific features. Requires libzmq installed.
+- **[omq-ractor](https://github.com/paddor/omq-ractor)** — bridge OMQ sockets into Ruby Ractors for true parallel processing across cores. I/O stays on the main Ractor, worker Ractors do pure computation.
+
 ## Development
 
 ```sh

data/lib/omq/channel.rb

@@ -6,8 +6,8 @@ module OMQ
     include Writable
     include SingleFrame
 
-    def initialize(endpoints = nil, linger: 0)
-      _init_engine(:CHANNEL, linger: linger)
+    def initialize(endpoints = nil, linger: 0, backend: nil)
+      _init_engine(:CHANNEL, linger: linger, backend: backend)
       _attach(endpoints, default: :connect)
     end
   end

data/lib/omq/client_server.rb

@@ -6,8 +6,8 @@ module OMQ
     include Writable
     include SingleFrame
 
-    def initialize(endpoints = nil, linger: 0)
-      _init_engine(:CLIENT, linger: linger)
+    def initialize(endpoints = nil, linger: 0, backend: nil)
+      _init_engine(:CLIENT, linger: linger, backend: backend)
       _attach(endpoints, default: :connect)
     end
   end
@@ -17,8 +17,8 @@ module OMQ
     include Writable
     include SingleFrame
 
-    def initialize(endpoints = nil, linger: 0)
-      _init_engine(:SERVER, linger: linger)
+    def initialize(endpoints = nil, linger: 0, backend: nil)
+      _init_engine(:SERVER, linger: linger, backend: backend)
       _attach(endpoints, default: :bind)
     end
 

data/lib/omq/engine.rb

@@ -64,6 +64,11 @@ module OMQ
 
     attr_writer :reconnect_enabled
 
+    # Optional proc that wraps new connections (e.g. for serialization).
+    # Called with the raw connection; must return the (possibly wrapped) connection.
+    #
+    attr_accessor :connection_wrapper
+
 
     # Spawns an inproc reconnect retry task under @parent_task.
     #
@@ -184,6 +189,7 @@ module OMQ
     # @return [void]
     #
     def connection_ready(pipe, endpoint: nil)
+      pipe = @connection_wrapper.call(pipe) if @connection_wrapper
       @connections << pipe
       @connection_endpoints[pipe] = endpoint if endpoint
       @routing.connection_added(pipe)
@@ -262,6 +268,13 @@ module OMQ
     # @yield [msg] optional per-message transform
     # @return [#stop, nil] pump task handle, or nil for DirectPipe bypass
     #
+    # Fairness limits for the recv pump. Yield to the scheduler
+    # after reading this many messages or bytes from one connection,
+    # whichever comes first. Prevents a fast or large-message
+    # connection from starving slower peers.
+    RECV_FAIRNESS_MESSAGES = 64
+    RECV_FAIRNESS_BYTES    = 1 << 20 # 1 MB
+
     def start_recv_pump(conn, recv_queue, &transform)
       if conn.is_a?(Transport::Inproc::DirectPipe) && conn.peer
         conn.peer.direct_recv_queue = recv_queue
@@ -270,11 +283,18 @@ module OMQ
       end
 
       if transform
-        @parent_task.async(transient: true, annotation: "recv pump") do
+        @parent_task.async(transient: true, annotation: "recv pump") do |task|
           loop do
-            msg = conn.receive_message
-            msg = transform.call(msg).freeze
-            recv_queue.enqueue(msg)
+            count = 0
+            bytes = 0
+            while count < RECV_FAIRNESS_MESSAGES && bytes < RECV_FAIRNESS_BYTES
+              msg = conn.receive_message
+              msg = transform.call(msg).freeze
+              recv_queue.enqueue(msg)
+              count += 1
+              bytes += msg.is_a?(Array) && msg.first.is_a?(String) ? msg.sum(&:bytesize) : 0
+            end
+            task.yield
           end
         rescue Async::Stop
         rescue Protocol::ZMTP::Error, *CONNECTION_LOST
@@ -283,9 +303,17 @@ module OMQ
           signal_fatal_error(error)
         end
       else
-        @parent_task.async(transient: true, annotation: "recv pump") do
+        @parent_task.async(transient: true, annotation: "recv pump") do |task|
           loop do
-            recv_queue.enqueue(conn.receive_message)
+            count = 0
+            bytes = 0
+            while count < RECV_FAIRNESS_MESSAGES && bytes < RECV_FAIRNESS_BYTES
+              msg = conn.receive_message
+              recv_queue.enqueue(msg)
+              count += 1
+              bytes += msg.is_a?(Array) && msg.first.is_a?(String) ? msg.sum(&:bytesize) : 0
+            end
+            task.yield
           end
         rescue Async::Stop
         rescue Protocol::ZMTP::Error, *CONNECTION_LOST
@@ -485,6 +513,7 @@ module OMQ
       )
       conn.handshake!
       start_heartbeat(conn)
+      conn = @connection_wrapper.call(conn) if @connection_wrapper
       @connections << conn
       @connection_endpoints[conn] = endpoint if endpoint
       @connection_promises[conn]  = done if done
@@ -572,24 +601,31 @@ module OMQ
     # resolution failures during reconnect are retried with backoff.
     #
     def validate_endpoint!(endpoint)
-      return unless endpoint.start_with?("tcp://")
-      host = URI.parse(endpoint.sub("tcp://", "http://")).hostname
+      case endpoint
+      when /\Atcp:\/\//
+        host = URI.parse(endpoint.sub("tcp://", "http://")).hostname
+      when /\Atls\+tcp:\/\//
+        host = URI.parse("http://#{endpoint.delete_prefix("tls+tcp://")}").hostname
+      else
+        return
+      end
       Addrinfo.getaddrinfo(host, nil, nil, :STREAM) if host
     end
 
 
     def transport_for(endpoint)
       case endpoint
-      when /\Atcp:\/\//    then Transport::TCP
-      when /\Aipc:\/\//    then Transport::IPC
-      when /\Ainproc:\/\// then Transport::Inproc
+      when /\Atls\+tcp:\/\// then Transport::TLS
+      when /\Atcp:\/\//      then Transport::TCP
+      when /\Aipc:\/\//      then Transport::IPC
+      when /\Ainproc:\/\//   then Transport::Inproc
       else raise ArgumentError, "unsupported transport: #{endpoint}"
       end
     end
 
 
     def extract_tcp_port(endpoint)
-      return nil unless endpoint&.start_with?("tcp://")
+      return nil unless endpoint&.start_with?("tcp://") || endpoint&.start_with?("tls+tcp://")
       port = endpoint.split(":").last.to_i
       port.positive? ? port : nil
     end
@@ -602,6 +638,31 @@ module OMQ
     #
     def start_accept_loops(listener)
       case listener
+      when Transport::TLS::Listener
+        tasks = listener.servers.map do |server|
+          @parent_task.async(transient: true, annotation: "tls accept #{listener.endpoint}") do
+            loop do
+              client = server.accept
+              Async::Task.current.defer_stop do
+                ssl            = OpenSSL::SSL::SSLSocket.new(client, listener.ssl_context)
+                ssl.sync_close = true
+                ssl.accept
+                handle_accepted(IO::Stream::Buffered.wrap(ssl), endpoint: listener.endpoint)
+              rescue OpenSSL::SSL::SSLError
+                # Bad certificate, protocol mismatch, etc. — drop this
+                # connection but keep the accept loop running.
+                ssl&.close rescue nil
+              end
+            end
+          rescue Async::Stop
+          rescue IOError
+            # server closed
+          ensure
+            server.close rescue nil
+          end
+        end
+        listener.accept_tasks = tasks
+
       when Transport::TCP::Listener
         tasks = listener.servers.map do |server|
           @parent_task.async(transient: true, annotation: "tcp accept #{listener.endpoint}") do

data/lib/omq/options.rb

@@ -26,6 +26,7 @@ module OMQ
       @max_message_size      = nil  # bytes, nil = unlimited
       @conflate              = false
       @mechanism             = Protocol::ZMTP::Mechanism::Null.new
+      @tls_context           = nil  # OpenSSL::SSL::SSLContext for tls+tcp://
     end
 
     attr_accessor :send_hwm,  :recv_hwm,
@@ -35,7 +36,8 @@ module OMQ
                   :reconnect_interval,
                   :heartbeat_interval,    :heartbeat_ttl,    :heartbeat_timeout,
                   :max_message_size,
-                  :mechanism
+                  :mechanism,
+                  :tls_context
 
     alias_method :router_mandatory?, :router_mandatory
     alias_method :recv_timeout,      :read_timeout

data/lib/omq/pair.rb

@@ -5,8 +5,8 @@ module OMQ
     include Readable
     include Writable
 
-    def initialize(endpoints = nil, linger: 0)
-      _init_engine(:PAIR, linger: linger)
+    def initialize(endpoints = nil, linger: 0, backend: nil)
+      _init_engine(:PAIR, linger: linger, backend: backend)
       _attach(endpoints, default: :connect)
     end
   end

data/lib/omq/peer.rb

@@ -6,8 +6,8 @@ module OMQ
     include Writable
     include SingleFrame
 
-    def initialize(endpoints = nil, linger: 0)
-      _init_engine(:PEER, linger: linger)
+    def initialize(endpoints = nil, linger: 0, backend: nil)
+      _init_engine(:PEER, linger: linger, backend: backend)
       _attach(endpoints, default: :connect)
     end
 

data/lib/omq/pub_sub.rb

@@ -4,8 +4,8 @@ module OMQ
   class PUB < Socket
     include Writable
 
-    def initialize(endpoints = nil, linger: 0, conflate: false)
-      _init_engine(:PUB, linger: linger, conflate: conflate)
+    def initialize(endpoints = nil, linger: 0, conflate: false, backend: nil)
+      _init_engine(:PUB, linger: linger, conflate: conflate, backend: backend)
       _attach(endpoints, default: :bind)
     end
   end
@@ -21,13 +21,13 @@ module OMQ
 
     # @param endpoints [String, nil]
     # @param linger [Integer]
-    # @param prefix [String, nil] subscription prefix; +nil+ (default)
+    # @param subscribe [String, nil] subscription prefix; +nil+ (default)
     #   means no subscription — call {#subscribe} explicitly.
     #
-    def initialize(endpoints = nil, linger: 0, prefix: nil)
-      _init_engine(:SUB, linger: linger)
+    def initialize(endpoints = nil, linger: 0, subscribe: nil, backend: nil)
+      _init_engine(:SUB, linger: linger, backend: backend)
       _attach(endpoints, default: :connect)
-      subscribe(prefix) unless prefix.nil?
+      self.subscribe(subscribe) unless subscribe.nil?
     end
 
     # Subscribes to a topic prefix.
@@ -53,8 +53,8 @@ module OMQ
     include Readable
     include Writable
 
-    def initialize(endpoints = nil, linger: 0)
-      _init_engine(:XPUB, linger: linger)
+    def initialize(endpoints = nil, linger: 0, backend: nil)
+      _init_engine(:XPUB, linger: linger, backend: backend)
       _attach(endpoints, default: :bind)
     end
   end
@@ -65,13 +65,13 @@ module OMQ
 
     # @param endpoints [String, nil]
     # @param linger [Integer]
-    # @param prefix [String, nil] subscription prefix; +nil+ (default)
+    # @param subscribe [String, nil] subscription prefix; +nil+ (default)
     #   means no subscription — send a subscribe frame explicitly.
     #
-    def initialize(endpoints = nil, linger: 0, prefix: nil)
-      _init_engine(:XSUB, linger: linger)
+    def initialize(endpoints = nil, linger: 0, subscribe: nil, backend: nil)
+      _init_engine(:XSUB, linger: linger, backend: backend)
       _attach(endpoints, default: :connect)
-      send("\x01#{prefix}".b) unless prefix.nil?
+      send("\x01#{subscribe}".b) unless subscribe.nil?
     end
   end
 end

data/lib/omq/push_pull.rb

@@ -4,8 +4,8 @@ module OMQ
   class PUSH < Socket
     include Writable
 
-    def initialize(endpoints = nil, linger: 0, send_hwm: nil, send_timeout: nil)
-      _init_engine(:PUSH, linger: linger, send_hwm: send_hwm, send_timeout: send_timeout)
+    def initialize(endpoints = nil, linger: 0, send_hwm: nil, send_timeout: nil, backend: nil)
+      _init_engine(:PUSH, linger: linger, send_hwm: send_hwm, send_timeout: send_timeout, backend: backend)
       _attach(endpoints, default: :connect)
     end
   end
@@ -13,8 +13,8 @@ module OMQ
   class PULL < Socket
     include Readable
 
-    def initialize(endpoints = nil, linger: 0, recv_hwm: nil, recv_timeout: nil)
-      _init_engine(:PULL, linger: linger, recv_hwm: recv_hwm, recv_timeout: recv_timeout)
+    def initialize(endpoints = nil, linger: 0, recv_hwm: nil, recv_timeout: nil, backend: nil)
+      _init_engine(:PULL, linger: linger, recv_hwm: recv_hwm, recv_timeout: recv_timeout, backend: backend)
       _attach(endpoints, default: :bind)
     end
   end

data/lib/omq/queue_interface.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module OMQ
+  # Async::Queue-compatible read interface.
+  #
+  # Automatically included by {Readable}. Provides #dequeue, #pop,
+  # #wait, and #each so sockets can be used where an Async::Queue
+  # is expected.
+  #
+  module QueueReadable
+    # Dequeues the next message.
+    #
+    # @param timeout [Numeric, nil] timeout in seconds (overrides
+    #   the socket's +read_timeout+ for this call)
+    # @return [Array<String>] message parts
+    # @raise [IO::TimeoutError] if timeout exceeded
+    #
+    def dequeue(timeout: @options.read_timeout)
+      msg = @recv_mutex.synchronize { @recv_buffer.shift }
+      return msg if msg
+
+      batch = Reactor.run { with_timeout(timeout) { @engine.dequeue_recv_batch(Readable::RECV_BATCH_SIZE) } }
+      msg = batch.shift
+      @recv_mutex.synchronize { @recv_buffer.concat(batch) } unless batch.empty?
+      msg
+    end
+
+    alias_method :pop, :dequeue
+
+    # Waits for the next message indefinitely (ignores read_timeout).
+    #
+    # @return [Array<String>] message parts
+    #
+    def wait
+      dequeue(timeout: nil)
+    end
+
+    # Yields each received message until the socket is closed or
+    # a receive timeout expires.
+    #
+    # @yield [Array<String>] message parts
+    # @return [void]
+    #
+    def each
+      while (msg = receive)
+        yield msg
+      end
+    rescue IO::TimeoutError
+      nil
+    end
+  end
+
+
+  # Async::Queue-compatible write interface.
+  #
+  # Automatically included by {Writable}. Provides #enqueue, #push,
+  # and #signal so sockets can be used where an Async::Queue is
+  # expected.
+  #
+  module QueueWritable
+    # Enqueues one or more messages for sending.
+    #
+    # @param messages [String, Array<String>]
+    # @return [self]
+    #
+    def enqueue(*messages)
+      messages.each { |msg| send(msg) }
+      self
+    end
+
+    alias_method :push, :enqueue
+  end
+end

data/lib/omq/radio_dish.rb

@@ -4,8 +4,8 @@ module OMQ
   class RADIO < Socket
     include Writable
 
-    def initialize(endpoints = nil, linger: 0, conflate: false)
-      _init_engine(:RADIO, linger: linger, conflate: conflate)
+    def initialize(endpoints = nil, linger: 0, conflate: false, backend: nil)
+      _init_engine(:RADIO, linger: linger, conflate: conflate, backend: backend)
       _attach(endpoints, default: :bind)
     end
 
@@ -47,8 +47,8 @@ module OMQ
   class DISH < Socket
     include Readable
 
-    def initialize(endpoints = nil, linger: 0, group: nil)
-      _init_engine(:DISH, linger: linger)
+    def initialize(endpoints = nil, linger: 0, group: nil, backend: nil)
+      _init_engine(:DISH, linger: linger, backend: backend)
       _attach(endpoints, default: :connect)
       join(group) if group
     end

data/lib/omq/readable.rb

@@ -6,6 +6,8 @@ module OMQ
   # Pure Ruby Readable mixin. Dequeues messages from the engine's recv queue.
   #
   module Readable
+    include QueueReadable
+
     # Maximum messages to prefetch from the recv queue per drain.
     RECV_BATCH_SIZE = 64
 

data/lib/omq/req_rep.rb

@@ -5,8 +5,8 @@ module OMQ
     include Readable
     include Writable
 
-    def initialize(endpoints = nil, linger: 0)
-      _init_engine(:REQ, linger: linger)
+    def initialize(endpoints = nil, linger: 0, backend: nil)
+      _init_engine(:REQ, linger: linger, backend: backend)
       _attach(endpoints, default: :connect)
     end
   end
@@ -15,8 +15,8 @@ module OMQ
     include Readable
     include Writable
 
-    def initialize(endpoints = nil, linger: 0)
-      _init_engine(:REP, linger: linger)
+    def initialize(endpoints = nil, linger: 0, backend: nil)
+      _init_engine(:REP, linger: linger, backend: backend)
       _attach(endpoints, default: :bind)
     end
   end

data/lib/omq/router_dealer.rb

@@ -5,8 +5,8 @@ module OMQ
     include Readable
     include Writable
 
-    def initialize(endpoints = nil, linger: 0)
-      _init_engine(:DEALER, linger: linger)
+    def initialize(endpoints = nil, linger: 0, backend: nil)
+      _init_engine(:DEALER, linger: linger, backend: backend)
       _attach(endpoints, default: :connect)
     end
   end
@@ -17,8 +17,8 @@ module OMQ
     include Readable
     include Writable
 
-    def initialize(endpoints = nil, linger: 0)
-      _init_engine(:ROUTER, linger: linger)
+    def initialize(endpoints = nil, linger: 0, backend: nil)
+      _init_engine(:ROUTER, linger: linger, backend: backend)
       _attach(endpoints, default: :bind)
     end
 

data/lib/omq/routing/fan_out.rb

@@ -91,11 +91,20 @@ module OMQ
               end
             else
               batch.each do |parts|
-                topic = parts.first || EMPTY_BINARY
+                topic      = parts.first || EMPTY_BINARY
+                wire_bytes = nil
+
                 @connections.each do |conn|
                   next unless subscribed?(conn, topic)
                   begin
-                    conn.write_message(parts)
+                    if conn.respond_to?(:curve?) && conn.curve?
+                      conn.write_message(parts)
+                    elsif conn.respond_to?(:write_wire)
+                      wire_bytes ||= Protocol::ZMTP::Codec::Frame.encode_message(parts)
+                      conn.write_wire(wire_bytes)
+                    else
+                      conn.write_message(parts)
+                    end
                     @written << conn
                   rescue *CONNECTION_LOST
                   end

data/lib/omq/routing/radio.rb

@@ -98,12 +98,22 @@ module OMQ
               end
             else
               batch.each do |parts|
-                group = parts[0]
-                body  = parts[1] || EMPTY_BINARY
+                group      = parts[0]
+                body       = parts[1] || EMPTY_BINARY
+                msg        = [group, body]
+                wire_bytes = nil
+
                 @connections.each do |conn|
                   next unless @groups[conn]&.include?(group)
                   begin
-                    conn.write_message([group, body])
+                    if conn.respond_to?(:curve?) && conn.curve?
+                      conn.write_message(msg)
+                    elsif conn.respond_to?(:write_wire)
+                      wire_bytes ||= Protocol::ZMTP::Codec::Frame.encode_message(msg)
+                      conn.write_wire(wire_bytes)
+                    else
+                      conn.write_message(msg)
+                    end
                     @written << conn
                   rescue *CONNECTION_LOST
                   end

data/lib/omq/scatter_gather.rb

@@ -5,8 +5,8 @@ module OMQ
     include Writable
     include SingleFrame
 
-    def initialize(endpoints = nil, linger: 0, send_hwm: nil, send_timeout: nil)
-      _init_engine(:SCATTER, linger: linger, send_hwm: send_hwm, send_timeout: send_timeout)
+    def initialize(endpoints = nil, linger: 0, send_hwm: nil, send_timeout: nil, backend: nil)
+      _init_engine(:SCATTER, linger: linger, send_hwm: send_hwm, send_timeout: send_timeout, backend: backend)
       _attach(endpoints, default: :connect)
     end
   end
@@ -15,8 +15,8 @@ module OMQ
     include Readable
     include SingleFrame
 
-    def initialize(endpoints = nil, linger: 0, recv_hwm: nil, recv_timeout: nil)
-      _init_engine(:GATHER, linger: linger, recv_hwm: recv_hwm, recv_timeout: recv_timeout)
+    def initialize(endpoints = nil, linger: 0, recv_hwm: nil, recv_timeout: nil, backend: nil)
+      _init_engine(:GATHER, linger: linger, recv_hwm: recv_hwm, recv_timeout: recv_timeout, backend: backend)
       _attach(endpoints, default: :bind)
     end
   end

data/lib/omq/socket.rb

@@ -36,7 +36,8 @@ module OMQ
       :heartbeat_ttl,         :heartbeat_ttl=,
       :heartbeat_timeout,     :heartbeat_timeout=,
       :max_message_size,      :max_message_size=,
-      :mechanism,             :mechanism=
+      :mechanism,             :mechanism=,
+      :tls_context,           :tls_context=
 
 
     # Creates a new socket and binds it to the given endpoint.
@@ -224,7 +225,8 @@ module OMQ
     # @param linger [Integer]
     #
     def _init_engine(socket_type, linger:, send_hwm: nil, recv_hwm: nil,
-                     send_timeout: nil, recv_timeout: nil, conflate: false)
+                     send_timeout: nil, recv_timeout: nil, conflate: false,
+                     backend: nil)
       @options = Options.new(linger: linger)
       @options.send_hwm      = send_hwm     if send_hwm
       @options.recv_hwm      = recv_hwm     if recv_hwm
@@ -233,7 +235,11 @@ module OMQ
       @options.conflate       = conflate
       @recv_buffer = []
       @recv_mutex  = Mutex.new
-      @engine      = Engine.new(socket_type, @options)
+      @engine      = case backend
+                     when nil, :ruby then Engine.new(socket_type, @options)
+                     when :ffi       then FFI::Engine.new(socket_type, @options)
+                     else raise ArgumentError, "unknown backend: #{backend}"
+                     end
     end
   end
 end

data/lib/omq/transport/tls.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require "socket"
+require "uri"
+require "openssl"
+require "io/stream"
+
+module OMQ
+  module Transport
+    # TLS transport — TLS v1.3 on top of TCP.
+    #
+    # Requires the socket's +tls_context+ to be set to an
+    # +OpenSSL::SSL::SSLContext+ before bind or connect.
+    #
+    module TLS
+      TLS_PREFIX = "tls+tcp://"
+
+      class << self
+        # Binds a TLS server.
+        #
+        # @param endpoint [String] e.g. "tls+tcp://127.0.0.1:5555" or "tls+tcp://*:0"
+        # @param engine [Engine]
+        # @return [Listener]
+        #
+        def bind(endpoint, engine)
+          ctx = require_context!(engine)
+          host, port = 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  = "#{TLS_PREFIX}#{host_part}:#{actual_port}"
+          Listener.new(resolved, servers, actual_port, ctx)
+        end
+
+        # Connects to a TLS endpoint.
+        #
+        # @param endpoint [String] e.g. "tls+tcp://127.0.0.1:5555"
+        # @param engine [Engine]
+        # @return [void]
+        #
+        def connect(endpoint, engine)
+          ctx = require_context!(engine)
+          host, port = parse_endpoint(endpoint)
+          tcp_sock   = TCPSocket.new(host, port)
+
+          ssl            = OpenSSL::SSL::SSLSocket.new(tcp_sock, ctx)
+          ssl.sync_close = true
+          ssl.hostname   = host
+          ssl.connect
+
+          engine.handle_connected(IO::Stream::Buffered.wrap(ssl), endpoint: endpoint)
+        rescue
+          tcp_sock&.close unless ssl&.sync_close
+          raise
+        end
+
+        private
+
+        # Validates and freezes the TLS context from engine options.
+        #
+        # The context SHOULD have min_version set to TLS1_3_VERSION.
+        # We cannot validate this because SSLContext#min_version is
+        # write-only in Ruby's OpenSSL binding.
+        #
+        # @return [OpenSSL::SSL::SSLContext]
+        # @raise [ArgumentError] if no context is set
+        #
+        def require_context!(engine)
+          ctx = engine.options.tls_context
+          raise ArgumentError, "tls_context must be set for tls+tcp:// endpoints" unless ctx
+          ctx.freeze unless ctx.frozen?
+          ctx
+        end
+
+        # Parses a tls+tcp:// endpoint URI into host and port.
+        #
+        # @param endpoint [String]
+        # @return [Array(String, Integer)]
+        #
+        def parse_endpoint(endpoint)
+          uri = URI.parse("http://#{endpoint.delete_prefix(TLS_PREFIX)}")
+          [uri.hostname, uri.port]
+        end
+      end
+
+      # A bound TLS listener.
+      #
+      class Listener
+        # @return [String] resolved endpoint with actual port
+        attr_reader :endpoint
+
+        # @return [Integer] bound port
+        attr_reader :port
+
+        # @return [Array<TCPServer>] bound server sockets
+        attr_reader :servers
+
+        # @return [OpenSSL::SSL::SSLContext]
+        attr_reader :ssl_context
+
+
+        # @param endpoint [String] resolved endpoint URI
+        # @param servers [Array<TCPServer>]
+        # @param port [Integer] bound port number
+        # @param ssl_context [OpenSSL::SSL::SSLContext]
+        #
+        def initialize(endpoint, servers, port, ssl_context)
+          @endpoint    = endpoint
+          @servers     = servers
+          @port        = port
+          @ssl_context = ssl_context
+          @tasks       = []
+        end
+
+
+        # Registers accept loop tasks owned by the engine.
+        #
+        # @param tasks [Array<Async::Task>]
+        #
+        def accept_tasks=(tasks)
+          @tasks = tasks
+        end
+
+
+        # Stops the listener.
+        #
+        def stop
+          @tasks.each(&:stop)
+          @servers.each { |s| s.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.10.0"
+  VERSION = "0.11.0"
 end

data/lib/omq/writable.rb

@@ -6,6 +6,7 @@ module OMQ
   # Pure Ruby Writable mixin. Enqueues messages to the engine's send path.
   #
   module Writable
+    include QueueWritable
     # Sends a message.
     #
     # @param message [String, Array<String>] message parts

data/lib/omq.rb

@@ -8,6 +8,7 @@
 
 require "protocol/zmtp"
 require "io/stream"
+require "openssl"
 
 require_relative "omq/version"
 
@@ -26,6 +27,7 @@ module OMQ
     Errno::ECONNABORTED,
     Errno::ENOTCONN,
     IO::Stream::ConnectionResetError,
+    OpenSSL::SSL::SSLError,
   ].freeze
 
   # Errors raised when a peer cannot be reached.
@@ -42,6 +44,7 @@ end
 # Transport
 require_relative "omq/transport/inproc"
 require_relative "omq/transport/tcp"
+require_relative "omq/transport/tls"
 require_relative "omq/transport/ipc"
 
 # Core
@@ -71,6 +74,7 @@ require_relative "omq/routing/dish"
 require_relative "omq/routing/peer"
 require_relative "omq/single_frame"
 require_relative "omq/engine"
+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.10.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Patrik Wenger
@@ -73,6 +73,7 @@ files:
 - 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
@@ -106,6 +107,7 @@ files:
 - lib/omq/transport/inproc.rb
 - lib/omq/transport/ipc.rb
 - lib/omq/transport/tcp.rb
+- lib/omq/transport/tls.rb
 - lib/omq/version.rb
 - lib/omq/writable.rb
 homepage: https://github.com/zeromq/omq