omq 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd6af0ae414feae27d1119fe4f1144b680e7e039229d512fe2915cd0289fc4dc
-  data.tar.gz: b68f9a321eb93350fc175bd603f8d4c29e23518b6b2dfd2a13072eade5904c8f
+  metadata.gz: 0dc74658712882f8d0eb8f58b0c9a37c959d50c87116677d23be39904f7002e7
+  data.tar.gz: 1ba17796cac6b1cd594ebbee874428e0675153d461d168e0f69f07abab608ef8
 SHA512:
-  metadata.gz: 3e17e9b4d867a7d2972b8caa4eff31dfd3c77095c60e9e5d9fdb53bc2646458dbfff244228065c145f0eb818d32f68bc196a7d0099fa4a5f2f02142f4c9a94b2
-  data.tar.gz: d0a7cc664076ea333433e5e14b5d1701219e4bf15200302cf0ab4420e928d50b2fe8d08d35889d69de6f35f7715b40f423195d33055a67f15af18404ee850536
+  metadata.gz: 3628a755a53010690ae407ac790eb83ef7592ac5cac34bddff8a62782c20cb6092c3dd300ae71a2dfff324eaf8457ba319305b6892ca259f8990ce63267c74e0
+  data.tar.gz: 76502cad1a484cf8224285fbf4259e9ba8e5daa396caa42ac3716b50ada2e72a4c31b8d256208ab7410f5e48727216fee526efbf6166e3a1a32bb7bc1701cacb

data/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## 0.4.2 — 2026-03-27
+
+### Fixed
+
+- Send pump dies permanently on connection loss — `rescue` was outside
+  the loop, so a single `CONNECTION_LOST` killed the pump and all
+  subsequent messages queued but never sent
+- NULL handshake deadlocks with buffered IO — missing `io.flush` after
+  greeting and READY writes caused both peers to block on read
+- Inproc DirectPipe drops messages when send pump runs before
+  `direct_recv_queue` is wired — now buffers to `@pending_direct` and
+  drains on assignment
+- HWM and timeout options set after construction had no effect because
+  `Async::LimitedQueue` was already allocated with the default
+
+### Added
+
+- `send_hwm:`, `send_timeout:` constructor kwargs for `PUSH`
+- `recv_hwm:`, `recv_timeout:` constructor kwargs for `PULL`
+
+### Changed
+
+- Use `Async::Clock.now` instead of `Process.clock_gettime` internally
+
 ## 0.4.1 — 2026-03-27
 
 ### Improved
@@ -137,4 +161,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/paddor/omq-curve) gem
+- Optional CURVE encryption via the [omq-curve](https://github.com/zeromq/omq-curve) gem

data/README.md

@@ -1,6 +1,6 @@
 # OMQ! Where did the C dependency go?!
 
-[![CI](https://github.com/paddor/omq/actions/workflows/ci.yml/badge.svg)](https://github.com/paddor/omq/actions/workflows/ci.yml)
+[![CI](https://github.com/zeromq/omq/actions/workflows/ci.yml/badge.svg)](https://github.com/zeromq/omq/actions/workflows/ci.yml)
 [![Gem Version](https://img.shields.io/gem/v/omq?color=e9573f)](https://rubygems.org/gems/omq)
 [![License: ISC](https://img.shields.io/badge/License-ISC-blue.svg)](LICENSE)
 [![Ruby](https://img.shields.io/badge/Ruby-%3E%3D%203.3-CC342D?logo=ruby&logoColor=white)](https://www.ruby-lang.org)

data/lib/omq/push_pull.rb

@@ -4,8 +4,8 @@ module OMQ
   class PUSH < Socket
     include ZMTP::Writable
 
-    def initialize(endpoints = nil, linger: 0)
-      _init_engine(:PUSH, linger: linger)
+    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)
       _attach(endpoints, default: :connect)
     end
   end
@@ -13,8 +13,8 @@ module OMQ
   class PULL < Socket
     include ZMTP::Readable
 
-    def initialize(endpoints = nil, linger: 0)
-      _init_engine(:PULL, linger: linger)
+    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)
       _attach(endpoints, default: :bind)
     end
   end

data/lib/omq/socket.rb

@@ -164,8 +164,13 @@ module OMQ
     # @param socket_type [Symbol]
     # @param linger [Integer]
     #
-    def _init_engine(socket_type, linger:)
+    def _init_engine(socket_type, linger:, send_hwm: nil, recv_hwm: nil,
+                     send_timeout: nil, recv_timeout: nil)
       @options = ZMTP::Options.new(linger: linger)
+      @options.send_hwm     = send_hwm     if send_hwm
+      @options.recv_hwm     = recv_hwm     if recv_hwm
+      @options.send_timeout  = send_timeout if send_timeout
+      @options.recv_timeout  = recv_timeout if recv_timeout
       @engine  = ZMTP::Engine.new(socket_type, @options)
     end
   end

data/lib/omq/version.rb

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

data/lib/omq/zmtp/connection.rb

@@ -218,7 +218,7 @@ module OMQ
       end
 
       def monotonic_now
-        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        Async::Clock.now
       end
 
       # Sends one frame to the wire.

data/lib/omq/zmtp/engine.rb

@@ -243,11 +243,11 @@ module OMQ
       #
       def drain_send_queues(timeout)
         return unless @routing.respond_to?(:send_queue)
-        deadline = timeout ? Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout : nil
+        deadline = timeout ? Async::Clock.now + timeout : nil
 
         until @routing.send_queue.empty?
           if deadline
-            remaining = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            remaining = deadline - Async::Clock.now
             break if remaining <= 0
           end
           sleep 0.001

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

@@ -26,6 +26,7 @@ module OMQ
         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)
@@ -38,6 +39,7 @@ module OMQ
           # 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)

data/lib/omq/zmtp/routing/round_robin.rb

@@ -56,13 +56,18 @@ module OMQ
           @tasks << Reactor.spawn_pump do
             loop do
               parts = @send_queue.dequeue
-              conn  = next_connection
-              conn.send_message(transform_send(parts))
+              send_with_retry(parts)
             end
-          rescue *ZMTP::CONNECTION_LOST
-            # connection lost mid-write
           end
         end
+
+        def send_with_retry(parts)
+          conn = next_connection
+          conn.send_message(transform_send(parts))
+        rescue *ZMTP::CONNECTION_LOST
+          @engine.connection_lost(conn)
+          retry
+        end
       end
     end
   end

data/lib/omq/zmtp/transport/inproc.rb

@@ -202,7 +202,7 @@ module OMQ
           # @return [Async::LimitedQueue, nil] when set, {#send_message}
           #   enqueues directly here instead of using the internal queue
           #
-          attr_accessor :direct_recv_queue
+          attr_reader :direct_recv_queue
 
           # @return [Proc, nil] optional transform applied before
           #   enqueuing into {#direct_recv_queue}
@@ -224,6 +224,20 @@ module OMQ
             @peer                  = nil
             @direct_recv_queue     = nil
             @direct_recv_transform = nil
+            @pending_direct        = nil
+          end
+
+          # Sets the direct recv queue. Drains any messages that were
+          # buffered before the queue was available.
+          #
+          def direct_recv_queue=(queue)
+            @direct_recv_queue = queue
+            if queue && @pending_direct
+              @pending_direct.each do |msg|
+                queue.enqueue(msg)
+              end
+              @pending_direct = nil
+            end
           end
 
           # Sends a multi-frame message.
@@ -240,8 +254,11 @@ module OMQ
             if @direct_recv_queue
               msg = @direct_recv_transform ? @direct_recv_transform.call(parts) : parts
               @direct_recv_queue.enqueue(msg)
-            else
+            elsif @send_queue
               @send_queue.enqueue(parts)
+            else
+              msg = @direct_recv_transform ? @direct_recv_transform.call(parts) : parts
+              (@pending_direct ||= []) << msg
             end
           end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omq
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.2
 platform: ruby
 authors:
 - Patrik Wenger
@@ -88,7 +88,7 @@ files:
 - lib/omq/zmtp/transport/tcp.rb
 - lib/omq/zmtp/valid_peers.rb
 - lib/omq/zmtp/writable.rb
-homepage: https://github.com/paddor/omq
+homepage: https://github.com/zeromq/omq
 licenses:
 - ISC
 metadata: {}