omq 0.11.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b736b6b715f5c4f330d21be278450600b2642239b8bea9e85957f516e89211ed
-  data.tar.gz: 34c057a32055e7333e4299e85c0fee9e798b43ea34d021f237ba6778338b65f1
+  metadata.gz: d5ea3ce51d24a9181cfe7a4c1f2680ed57c5dbba078010a54de5b1c13d27d484
+  data.tar.gz: 97f7e7fcb27a250e71af4732ff06298e7311af052a9d9a6b3868d73059373174
 SHA512:
-  metadata.gz: e95a6df6d4eb56ac1fc0586f61cfdb77d0afe9de620d3e540ffbae1256c2fe6526556485215eda3de20c8f34a332f51a68e5bb075087665049c0219bb07f6960
-  data.tar.gz: 8b5c8d38b7523e9c6ab30e17c21b0cf4adb2086e1bdde90298f62e42f4b8f2336cdd95c47293c3fb24fa41f376aed8a2ec6d1121fc56d41aa83d4afdc289d707
+  metadata.gz: 9f60b7d45d1b3783b2bde482a6f826ec3b89bfff6a9532836dbd2a8a22622709e7c298cc7c2abae6e596641973636b8972efa92de7258bd1e4164ff62d782237
+  data.tar.gz: 7024b97bb46c9005b73bc7959cc4138bd5498a514af26253441613aa05206d357d1fbd002afff5820c9a3baff0c4351d66bcf1aa738955783272a2c2b459a697

data/CHANGELOG.md

@@ -1,5 +1,100 @@
 # Changelog
 
+## Unreleased
+
+### Added
+
+- **QoS infrastructure** — `Options#qos` attribute (default 0) and inproc
+  command queue support for QoS-enabled connections. The
+  [omq-qos](https://github.com/paddor/omq-qos) gem activates delivery
+  guarantees via prepends.
+- **REQ send/recv ordering** — REQ sockets now enforce strict
+  send/recv/send/recv alternation. Calling `#send` twice without a
+  `#receive` in between raises `SocketError`.
+- **DirectPipe command frame support** — `DirectPipe#receive_message`
+  accepts a block for command frames, matching the `Protocol::ZMTP::Connection`
+  interface. Enables inproc transports to handle ACK/NACK and other
+  command-level protocols.
+
+### Fixed
+
+- **`send_pump_idle?` visibility** — moved above `private` in `RoundRobin`
+  and `FanOut` so `Engine#drain_send_queues` can call it during socket close.
+
+- **`Socket#monitor`** — observe connection lifecycle events via a
+  block-based API. Returns an `Async::Task` that yields `MonitorEvent`
+  (Data.define) instances for `:listening`, `:accepted`, `:connected`,
+  `:connect_delayed`, `:connect_retried`, `:handshake_succeeded`,
+  `:handshake_failed`, `:accept_failed`, `:bind_failed`, `:disconnected`,
+  `:closed`, and `:monitor_stopped`. Event types align with libzmq's
+  `zmq_socket_monitor` where applicable. Pattern-matchable, zero overhead
+  when no monitor is attached.
+- **Pluggable transport registry** — `Engine.transports` is a scheme →
+  module hash. Built-in transports (`tcp`, `ipc`, `inproc`) are registered
+  at load time. External gems register via
+  `OMQ::Engine.transports["scheme"] = MyTransport`. Each transport
+  implements `.bind(endpoint, engine)` → Listener, `.connect(endpoint,
+  engine)`, and optionally `.validate_endpoint!(endpoint)`. Listeners
+  implement `#start_accept_loops(parent_task, &on_accepted)`, `#stop`,
+  `#endpoint`, and optionally `#port`.
+- **Mutable error lists** — `CONNECTION_LOST` and `CONNECTION_FAILED` are
+  no longer frozen at load time. Transport plugins can append error classes
+  (e.g. `OpenSSL::SSL::SSLError`) before the first `#bind`/`#connect`,
+  which freezes both arrays.
+
+- **`on_mute` option** — controls behavior when a socket enters the mute state
+  (HWM full). PUB, XPUB, and RADIO default to `on_mute: :drop_newest` — slow
+  subscribers are skipped in the fan-out rather than blocking the publisher.
+  SUB, XSUB, and DISH accept `on_mute: :drop_newest` or `:drop_oldest` to
+  drop messages on the receive side instead of applying backpressure. All other
+  socket types default to `:block` (existing behavior).
+- **`DropQueue`** — bounded queue with `:drop_newest` (tail drop) and
+  `:drop_oldest` (head drop) strategies. Used by recv queues when `on_mute`
+  is a drop strategy.
+- **`Routing.build_queue`** — factory method for building send/recv queues
+  based on HWM and mute strategy. Supports HWM of `0` or `nil` for unbounded
+  queues.
+
+### Changed
+
+- **`max_message_size` defaults to 1 MiB** — frames exceeding this limit cause
+  the connection to be dropped before the body is read from the wire, preventing
+  a malicious peer from causing arbitrary memory allocation. Set `socket.max_message_size = nil`
+  to restore the previous unlimited behavior.
+- **Accept loops moved into Listeners** — `TCP::Listener` and
+  `IPC::Listener` now own their accept loop logic via
+  `#start_accept_loops(parent_task, &on_accepted)`. Engine delegates
+  via duck-type check. This enables external transports to define
+  custom accept behavior without modifying Engine.
+- `Engine#transport_for` uses registry lookup instead of `case/when`.
+- `Engine#validate_endpoint!` delegates to transport module.
+- `Engine#bind` reads `listener.port` instead of parsing the endpoint
+  string.
+
+### Removed
+
+- **Draft socket types extracted** — `RADIO`, `DISH`, `CLIENT`, `SERVER`,
+  `SCATTER`, `GATHER`, `CHANNEL`, and `PEER` are no longer bundled with `omq`.
+  Use the [omq-draft](https://github.com/paddor/omq-draft) gem and require
+  the relevant entry point (`omq/draft/radiodish`, `omq/draft/clientserver`,
+  etc.).
+- **UDP transport extracted** — `udp://` endpoints are provided by
+  `omq-draft` (via `require "omq/draft/radiodish"`). No longer registered by
+  default.
+- **`Routing.for` plugin registry** — draft socket type removal added
+  `Routing.register(socket_type, strategy_class)` for external gems to
+  register routing strategies. Unknown types fall through the built-in
+  `case` to this registry before raising `ArgumentError`.
+
+- **TLS transport** — extracted to the
+  [omq-transport-tls](https://github.com/paddor/omq-transport-tls) gem.
+  (Experimental) `require "omq/transport/tls"` to restore `tls+tcp://` support.
+- `tls_context` / `tls_context=` removed from `Options` and `Socket`
+  (provided by omq-transport-tls).
+- `OpenSSL::SSL::SSLError` removed from `CONNECTION_LOST` (added back
+  by omq-transport-tls).
+- TLS benchmark transport removed from `bench_helper.rb` and `plot.rb`.
+
 ## 0.11.0
 
 ### Added

data/README.md

@@ -147,7 +147,7 @@ end
 
 ## Socket Types
 
-All sockets are thread-safe. Default HWM is 1000 messages per socket. Classes live under `OMQ::` (alias: `ØMQ`).
+All sockets are thread-safe. Default HWM is 1000 messages per socket. Default `max_message_size` is **1 MiB** — frames larger than this cause the connection to be dropped before the body is read from the wire. Set `socket.max_message_size = nil` to disable the limit or raise it as needed. Classes live under `OMQ::` (alias: `ØMQ`).
 
 #### Standard (multipart messages)
 
@@ -162,6 +162,8 @@ All sockets are thread-safe. Default HWM is 1000 messages per socket. Classes li
 
 #### Draft (single-frame only)
 
+These require the `omq-draft` gem.
+
 | Pattern | Send | Receive | When HWM full |
 |---------|------|---------|---------------|
 | **CLIENT** / **SERVER** | Round-robin / routing-ID | Fair-queue | Block |

data/lib/omq/drop_queue.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module OMQ
+  # A bounded queue that drops messages when full instead of blocking.
+  #
+  # Two drop strategies:
+  #   :drop_newest — discard the incoming message (tail drop)
+  #   :drop_oldest — discard the head, then enqueue the new message
+  #
+  # Used by SUB/XSUB/DISH recv queues when on_mute is a drop strategy.
+  #
+  class DropQueue
+    # @param limit [Integer] maximum number of items
+    # @param strategy [Symbol] :drop_newest or :drop_oldest
+    #
+    def initialize(limit, strategy: :drop_newest)
+      @queue    = Thread::SizedQueue.new(limit)
+      @strategy = strategy
+    end
+
+    # Enqueues an item. Drops according to the configured strategy if full.
+    #
+    # @param item [Object]
+    # @return [void]
+    #
+    def enqueue(item)
+      @queue.push(item, true)
+    rescue ThreadError
+      return if @strategy == :drop_newest
+
+      # :drop_oldest — discard head, enqueue new
+      @queue.pop(true) rescue nil
+      retry
+    end
+
+    # Removes and returns the next item, blocking if empty.
+    #
+    # @return [Object]
+    #
+    def dequeue(timeout: nil)
+      if timeout
+        @queue.pop(timeout: timeout)
+      else
+        @queue.pop
+      end
+    end
+
+    # @return [Boolean]
+    #
+    def empty?
+      @queue.empty?
+    end
+  end
+end

data/lib/omq/engine.rb

@@ -9,6 +9,17 @@ module OMQ
   # OMQ::Socket instance. Each socket type creates one Engine.
   #
   class Engine
+    # Scheme → transport module registry.
+    # Plugins add entries via +Engine.transports["scheme"] = MyTransport+.
+    #
+    @transports = {}
+
+    class << self
+      # @return [Hash{String => Module}] registered transports
+      attr_reader :transports
+    end
+
+
     # @return [Symbol] socket type (e.g. :REQ, :PAIR)
     #
     attr_reader :socket_type
@@ -57,12 +68,13 @@ module OMQ
       @on_io_thread         = false
       @connection_promises  = {} # connection => Async::Promise
       @fatal_error          = nil
+      @monitor_queue        = nil
     end
 
 
     attr_reader :peer_connected, :all_peers_gone, :connections, :parent_task
 
-    attr_writer :reconnect_enabled
+    attr_writer :reconnect_enabled, :monitor_queue
 
     # Optional proc that wraps new connections (e.g. for serialization).
     # Called with the raw connection; must return the (possibly wrapped) connection.
@@ -92,12 +104,17 @@ module OMQ
     # @raise [ArgumentError] on unsupported transport
     #
     def bind(endpoint)
+      freeze_error_lists!
       transport = transport_for(endpoint)
       listener  = transport.bind(endpoint, self)
       start_accept_loops(listener)
       @listeners << listener
       @last_endpoint = listener.endpoint
-      @last_tcp_port = extract_tcp_port(listener.endpoint)
+      @last_tcp_port = listener.respond_to?(:port) ? listener.port : nil
+      emit_monitor_event(:listening, endpoint: listener.endpoint)
+    rescue => error
+      emit_monitor_event(:bind_failed, endpoint: endpoint, detail: { error: error })
+      raise
     end
 
 
@@ -107,6 +124,7 @@ module OMQ
     # @return [void]
     #
     def connect(endpoint)
+      freeze_error_lists!
       validate_endpoint!(endpoint)
       @connected_endpoints << endpoint
       if endpoint.start_with?("inproc://")
@@ -115,6 +133,7 @@ module OMQ
         transport.connect(endpoint, self)
       else
         # TCP/IPC connect in background — never blocks the caller
+        emit_monitor_event(:connect_delayed, endpoint: endpoint)
         schedule_reconnect(endpoint, delay: 0)
       end
     end
@@ -168,6 +187,7 @@ module OMQ
     # @return [void]
     #
     def handle_accepted(io, endpoint: nil)
+      emit_monitor_event(:accepted, endpoint: endpoint)
       spawn_connection(io, as_server: true, endpoint: endpoint)
     end
 
@@ -178,6 +198,7 @@ module OMQ
     # @return [void]
     #
     def handle_connected(io, endpoint: nil)
+      emit_monitor_event(:connected, endpoint: endpoint)
       spawn_connection(io, as_server: false, endpoint: endpoint)
     end
 
@@ -194,6 +215,7 @@ module OMQ
       @connection_endpoints[pipe] = endpoint if endpoint
       @routing.connection_added(pipe)
       @peer_connected.resolve(pipe)
+      emit_monitor_event(:handshake_succeeded, endpoint: endpoint)
     end
 
 
@@ -335,6 +357,7 @@ module OMQ
       @connections.delete(connection)
       @routing.connection_removed(connection)
       connection.close
+      emit_monitor_event(:disconnected, endpoint: endpoint)
 
       # Signal the connection task to exit.
       done = @connection_promises.delete(connection)
@@ -393,6 +416,8 @@ module OMQ
       @routing.stop rescue nil
       @tasks.each { |t| t.stop rescue nil }
       @tasks.clear
+      emit_monitor_event(:closed)
+      close_monitor_queue
     end
 
 
@@ -519,8 +544,10 @@ module OMQ
       @connection_promises[conn]  = done if done
       @routing.connection_added(conn)
       @peer_connected.resolve(conn)
+      emit_monitor_event(:handshake_succeeded, endpoint: endpoint)
       conn
-    rescue Protocol::ZMTP::Error, *CONNECTION_LOST
+    rescue Protocol::ZMTP::Error, *CONNECTION_LOST => error
+      emit_monitor_event(:handshake_failed, endpoint: endpoint, detail: { error: error })
       conn&.close
       raise
     end
@@ -585,6 +612,7 @@ module OMQ
             delay = [delay * 2, max_delay].min if max_delay
             # After first attempt with delay: 0, use the configured interval
             delay = ri.is_a?(Range) ? ri.begin : ri if delay == 0
+            emit_monitor_event(:connect_retried, endpoint: endpoint, detail: { interval: delay })
           end
         end
       rescue Async::Stop
@@ -601,102 +629,55 @@ module OMQ
     # resolution failures during reconnect are retried with backoff.
     #
     def validate_endpoint!(endpoint)
-      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
+      transport = transport_for(endpoint)
+      transport.validate_endpoint!(endpoint) if transport.respond_to?(:validate_endpoint!)
     end
 
 
+
     def transport_for(endpoint)
-      case endpoint
-      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}"
+      scheme = endpoint[/\A([^:]+):\/\//, 1]
+      self.class.transports[scheme] or
+        raise ArgumentError, "unsupported transport: #{endpoint}"
+    end
+
+
+    # Delegates accept loop startup to the listener.
+    #
+    # Stream-based listeners (TCP, IPC, TLS, …) implement
+    # +#start_accept_loops+. Inproc listeners do not — connections
+    # are established synchronously during +connect+.
+    #
+    def start_accept_loops(listener)
+      return unless listener.respond_to?(:start_accept_loops)
+      listener.start_accept_loops(@parent_task) do |io|
+        handle_accepted(io, endpoint: listener.endpoint)
       end
     end
 
 
-    def extract_tcp_port(endpoint)
-      return nil unless endpoint&.start_with?("tcp://") || endpoint&.start_with?("tls+tcp://")
-      port = endpoint.split(":").last.to_i
-      port.positive? ? port : nil
+    def freeze_error_lists!
+      return if OMQ::CONNECTION_LOST.frozen?
+      OMQ::CONNECTION_LOST.freeze
+      OMQ::CONNECTION_FAILED.freeze
     end
 
 
-    # Spawns accept loops for a listener under @parent_task.
-    #
-    # TCP listeners have multiple server sockets (IPv4/IPv6);
-    # IPC listeners have one. Inproc listeners have none.
-    #
-    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
-            loop do
-              client = server.accept
-              Async::Task.current.defer_stop do
-                handle_accepted(IO::Stream::Buffered.wrap(client), endpoint: listener.endpoint)
-              end
-            end
-          rescue Async::Stop
-          rescue IOError
-            # server closed
-          ensure
-            server.close rescue nil
-          end
-        end
-        listener.accept_tasks = tasks
+    def emit_monitor_event(type, endpoint: nil, detail: nil)
+      return unless @monitor_queue
+      @monitor_queue.push(MonitorEvent.new(type: type, endpoint: endpoint, detail: detail))
+    rescue Async::Stop, ClosedQueueError
+    end
 
-      when Transport::IPC::Listener
-        task = @parent_task.async(transient: true, annotation: "ipc accept #{listener.endpoint}") do
-          loop do
-            client = listener.server.accept
-            Async::Task.current.defer_stop do
-              handle_accepted(IO::Stream::Buffered.wrap(client), endpoint: listener.endpoint)
-            end
-          end
-        rescue Async::Stop
-        rescue IOError
-          # server closed
-        ensure
-          listener.server.close rescue nil
-        end
-        listener.accept_task = task
-      end
+
+    def close_monitor_queue
+      return unless @monitor_queue
+      @monitor_queue.push(nil)
     end
   end
+
+  # Register built-in transports.
+  Engine.transports["tcp"]    = Transport::TCP
+  Engine.transports["ipc"]    = Transport::IPC
+  Engine.transports["inproc"] = Transport::Inproc
 end

data/lib/omq/monitor_event.rb

@@ -0,0 +1,16 @@
+# 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

data/lib/omq/options.rb

@@ -23,10 +23,11 @@ module OMQ
       @heartbeat_interval    = nil   # seconds, nil = disabled
       @heartbeat_ttl         = nil   # seconds, nil = use heartbeat_interval
       @heartbeat_timeout     = nil   # seconds, nil = use heartbeat_interval
-      @max_message_size      = nil  # bytes, nil = unlimited
+      @max_message_size      = 1 << 20  # bytes (1 MiB default)
       @conflate              = false
+      @on_mute               = :block   # :block, :drop_newest, :drop_oldest
       @mechanism             = Protocol::ZMTP::Mechanism::Null.new
-      @tls_context           = nil  # OpenSSL::SSL::SSLContext for tls+tcp://
+      @qos                   = 0       # 0 = fire-and-forget, 1 = at-least-once (see omq-qos gem)
     end
 
     attr_accessor :send_hwm,  :recv_hwm,
@@ -36,8 +37,9 @@ module OMQ
                   :reconnect_interval,
                   :heartbeat_interval,    :heartbeat_ttl,    :heartbeat_timeout,
                   :max_message_size,
+                  :on_mute,
                   :mechanism,
-                  :tls_context
+                  :qos
 
     alias_method :router_mandatory?, :router_mandatory
     alias_method :recv_timeout,      :read_timeout

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, backend: nil)
-      _init_engine(:PUB, linger: linger, conflate: conflate, backend: backend)
+    def initialize(endpoints = nil, linger: 0, on_mute: :drop_newest, conflate: false, backend: nil)
+      _init_engine(:PUB, linger: linger, on_mute: on_mute, conflate: conflate, backend: backend)
       _attach(endpoints, default: :bind)
     end
   end
@@ -23,9 +23,10 @@ module OMQ
     # @param linger [Integer]
     # @param subscribe [String, nil] subscription prefix; +nil+ (default)
     #   means no subscription — call {#subscribe} explicitly.
+    # @param on_mute [Symbol] :block (default), :drop_newest, or :drop_oldest
     #
-    def initialize(endpoints = nil, linger: 0, subscribe: nil, backend: nil)
-      _init_engine(:SUB, linger: linger, backend: backend)
+    def initialize(endpoints = nil, linger: 0, subscribe: nil, on_mute: :block, backend: nil)
+      _init_engine(:SUB, linger: linger, on_mute: on_mute, backend: backend)
       _attach(endpoints, default: :connect)
       self.subscribe(subscribe) unless subscribe.nil?
     end
@@ -53,8 +54,8 @@ module OMQ
     include Readable
     include Writable
 
-    def initialize(endpoints = nil, linger: 0, backend: nil)
-      _init_engine(:XPUB, linger: linger, backend: backend)
+    def initialize(endpoints = nil, linger: 0, on_mute: :drop_newest, backend: nil)
+      _init_engine(:XPUB, linger: linger, on_mute: on_mute, backend: backend)
       _attach(endpoints, default: :bind)
     end
   end
@@ -68,8 +69,8 @@ module OMQ
     # @param subscribe [String, nil] subscription prefix; +nil+ (default)
     #   means no subscription — send a subscribe frame explicitly.
     #
-    def initialize(endpoints = nil, linger: 0, subscribe: nil, backend: nil)
-      _init_engine(:XSUB, linger: linger, backend: backend)
+    def initialize(endpoints = nil, linger: 0, subscribe: nil, on_mute: :block, backend: nil)
+      _init_engine(:XSUB, linger: linger, on_mute: on_mute, backend: backend)
       _attach(endpoints, default: :connect)
       send("\x01#{subscribe}".b) unless subscribe.nil?
     end

data/lib/omq/routing/dealer.rb

@@ -13,7 +13,7 @@ module OMQ
       #
       def initialize(engine)
         @engine     = engine
-        @recv_queue = Async::LimitedQueue.new(engine.options.recv_hwm)
+        @recv_queue = Routing.build_queue(engine.options.recv_hwm, :block)
         @tasks      = []
         init_round_robin(engine)
       end

data/lib/omq/routing/fan_out.rb

@@ -13,12 +13,16 @@ module OMQ
     module FanOut
       attr_reader :subscriber_joined
 
+      # @return [Boolean] true when the send pump is idle (not sending a batch)
+      def send_pump_idle? = @send_pump_idle
+
       private
 
       def init_fan_out(engine)
         @connections        = []
         @subscriptions      = {} # connection => Set of prefixes
-        @send_queue         = Async::LimitedQueue.new(engine.options.send_hwm)
+        @send_queue         = Routing.build_queue(engine.options.send_hwm, :block)
+        @on_mute            = engine.options.on_mute
         @send_pump_started  = false
         @send_pump_idle     = true
         @conflate           = engine.options.conflate
@@ -57,8 +61,14 @@ module OMQ
         @subscriptions[conn]&.delete(prefix)
       end
 
-      # @return [Boolean] true when the send pump is idle (not sending a batch)
-      def send_pump_idle? = @send_pump_idle
+      # Returns true if the connection is muted (recv queue full) and
+      # the on_mute strategy says to drop rather than block.
+      #
+      def muted?(conn)
+        return false if @on_mute == :block
+        q = conn.direct_recv_queue if conn.respond_to?(:direct_recv_queue)
+        q&.respond_to?(:limited?) && q.limited?
+      end
 
 
       def start_send_pump
@@ -83,6 +93,7 @@ module OMQ
                 end
               end
               @latest.each do |conn, parts|
+                next if muted?(conn)
                 begin
                   conn.write_message(parts)
                   @written << conn
@@ -96,6 +107,7 @@ module OMQ
 
                 @connections.each do |conn|
                   next unless subscribed?(conn, topic)
+                  next if muted?(conn)
                   begin
                     if conn.respond_to?(:curve?) && conn.curve?
                       conn.write_message(parts)

data/lib/omq/routing/pair.rb

@@ -14,8 +14,8 @@ module OMQ
       def initialize(engine)
         @engine     = engine
         @connection = nil
-        @recv_queue = Async::LimitedQueue.new(engine.options.recv_hwm)
-        @send_queue = Async::LimitedQueue.new(engine.options.send_hwm)
+        @recv_queue = Routing.build_queue(engine.options.recv_hwm, :block)
+        @send_queue = Routing.build_queue(engine.options.send_hwm, :block)
         @tasks          = []
         @send_pump_idle = true
       end

data/lib/omq/routing/pull.rb

@@ -9,7 +9,7 @@ module OMQ
       #
       def initialize(engine)
         @engine     = engine
-        @recv_queue = Async::LimitedQueue.new(engine.options.recv_hwm)
+        @recv_queue = Routing.build_queue(engine.options.recv_hwm, :block)
         @tasks      = []
       end
 

data/lib/omq/routing/push.rb

@@ -76,6 +76,8 @@ module OMQ
           @engine.connection_lost(conn)
         end
       end
+
+
     end
   end
 end

data/lib/omq/routing/rep.rb

@@ -15,8 +15,8 @@ module OMQ
 
       def initialize(engine)
         @engine            = engine
-        @recv_queue        = Async::LimitedQueue.new(engine.options.recv_hwm)
-        @send_queue        = Async::LimitedQueue.new(engine.options.send_hwm)
+        @recv_queue        = Routing.build_queue(engine.options.recv_hwm, :block)
+        @send_queue        = Routing.build_queue(engine.options.send_hwm, :block)
         @pending_replies   = []
         @tasks             = []
         @send_pump_started = false