omq 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f11ba4b6d749acef6ad97b6f328aec61aba341ba5759660e23c896af2d96054d
-  data.tar.gz: cf91d6bc140f04d000b5add87322ba9f39ea3b5790f75e4b22144b429284b4c7
+  metadata.gz: 9e1ab1933600879bdce366be75711129dd5ed1fd24f78026544a53a80db2ea1e
+  data.tar.gz: 89978df5161c8df19c4bdbf485ca3d28a75af4bb83760c0076917585abfc1adc
 SHA512:
-  metadata.gz: 4ecc0a3992c75679ea9cebd9872bdb7a7c9d3f3e86eaccd82dccc7717a84591c5d8493ab0629b14dfdaea35e30b0bae27c6c142841e2f1c61a04a4ef09805b54
-  data.tar.gz: 7789734d032134883b3ae71ba0af36a7f89d67625d4e879e03f1be81d3ae83b3f1afcda0610bb203ff25a62ecdfac90a4f56b08b5a8127cbab94b1e305261278
+  metadata.gz: 817ea2eb9ab32b4300b3e74bfa6d81bb2d7d003ab3986bfe8b1a5cb3caed6cd2fad69c3391f6a091019b637edacbbdb3457ed92d16f7776d0b93b2bc68063289
+  data.tar.gz: c32130ffee59d23d7b82c239212691846fcbc88cb7e5dcda1762e0a21db1d30e789f7368205ce07f3f2dfbf79fab3e799660e54b91c2b5439736617bf9be9507

data/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 0.1.1 — 2026-03-26
+
+### Fixed
+
+- Handle `Errno::EPIPE`, `Errno::ECONNRESET`, `Errno::ECONNABORTED`,
+  `Errno::EHOSTUNREACH`, `Errno::ENETUNREACH`, `Errno::ENOTCONN`, and
+  `IO::Stream::ConnectionResetError` in accept loops, connect, reconnect,
+  and recv/send pumps — prevents unhandled exceptions when peers disconnect
+  during handshake or become unreachable
+- Use `TCPSocket.new` instead of `Socket.tcp` for reliable cross-host
+  connections with io-stream
+
+### Changed
+
+- TCP/IPC `#connect` is now non-blocking — returns immediately and
+  establishes the connection in the background, like libzmq
+- Consolidated connection error handling via `ZMTP::CONNECTION_LOST` and
+  `ZMTP::CONNECTION_FAILED` constants
+- Removed `connect_timeout` option (no longer needed since connect is
+  non-blocking)
+
 ## 0.1.0 — 2026-03-25
 
 Initial release. Pure Ruby implementation of ZMTP 3.1 (ZeroMQ) using Async.
@@ -25,6 +46,5 @@ Initial release. Pure Ruby implementation of ZMTP 3.1 (ZeroMQ) using Async.
 - Per-socket send/receive HWM (high-water mark)
 - Linger on close (drain send queue before closing)
 - `max_message_size` enforcement
-- `connect_timeout` for TCP
 - Works inside Async reactors or standalone (shared IO thread)
-- Optional CURVE encryption via the `omq-curve` gem
+- Optional CURVE encryption via the [omq-curve](https://github.com/paddor/omq-curve) gem

data/lib/omq/socket.rb

@@ -30,7 +30,6 @@ module OMQ
       heartbeat_ttl           heartbeat_ttl=
       heartbeat_timeout       heartbeat_timeout=
       max_message_size        max_message_size=
-      connect_timeout         connect_timeout=
       mechanism               mechanism=
       curve_server            curve_server=
       curve_server_key        curve_server_key=

data/lib/omq/version.rb

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

data/lib/omq/zmtp/connection.rb

@@ -139,7 +139,7 @@ module OMQ
               end
             end
           end
-        rescue IOError, EOFError
+        rescue *ZMTP::CONNECTION_LOST
           # connection closed
         end
       end

data/lib/omq/zmtp/engine.rb

@@ -68,11 +68,14 @@ module OMQ
       #
       def connect(endpoint)
         @connected_endpoints << endpoint
-        transport = transport_for(endpoint)
-        transport.connect(endpoint, self)
-      rescue Errno::ECONNREFUSED, Errno::ENOENT, Errno::ETIMEDOUT, IOError, ProtocolError
-        # Server not up yet — schedule background reconnect
-        schedule_reconnect(endpoint)
+        if endpoint.start_with?("inproc://")
+          # Inproc connect is synchronous and instant
+          transport = transport_for(endpoint)
+          transport.connect(endpoint, self)
+        else
+          # TCP/IPC connect in background — never blocks the caller
+          schedule_reconnect(endpoint, delay: 0)
+        end
       end
 
       # Disconnects from an endpoint. Closes connections to that endpoint
@@ -183,7 +186,7 @@ module OMQ
             msg = transform ? transform.call(msg) : msg
             recv_queue.enqueue(msg)
           end
-        rescue EOFError, IOError
+        rescue *CONNECTION_LOST
           connection_lost(conn)
         end
       end
@@ -268,32 +271,34 @@ module OMQ
         @connections << conn
         @connection_endpoints[conn] = endpoint if endpoint
         @routing.connection_added(conn)
-      rescue ProtocolError, EOFError
+      rescue ProtocolError, *CONNECTION_LOST
         conn&.close
         raise
       end
 
-      def schedule_reconnect(endpoint)
+      def schedule_reconnect(endpoint, delay: nil)
         ri = @options.reconnect_interval
         if ri.is_a?(Range)
-          delay   = ri.begin
+          delay   ||= ri.begin
           max_delay = ri.end
         else
-          delay     = ri
+          delay   ||= ri
           max_delay = nil
         end
 
         @tasks << Reactor.spawn_pump do
           loop do
             break if @closed
-            sleep delay
+            sleep delay if delay > 0
             break if @closed
             begin
               transport = transport_for(endpoint)
               transport.connect(endpoint, self)
-              break # reconnected successfully
-            rescue Errno::ECONNREFUSED, Errno::ETIMEDOUT, IOError, ProtocolError
+              break # connected successfully
+            rescue *CONNECTION_LOST, *CONNECTION_FAILED, ProtocolError
               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
             end
           end
         end
@@ -306,7 +311,7 @@ module OMQ
           Mechanism::Null.new
         when :curve
           unless defined?(Mechanism::Curve)
-            raise LoadError, "require 'omq-curve' to use CURVE security"
+            raise LoadError, "require 'omq/curve' to use CURVE security"
           end
           Mechanism::Curve.new(
             server_key:    @options.curve_server_key,

data/lib/omq/zmtp/options.rb

@@ -25,7 +25,6 @@ module OMQ
         @heartbeat_ttl         = nil   # seconds, nil = use heartbeat_interval
         @heartbeat_timeout     = nil   # seconds, nil = use heartbeat_interval
         @max_message_size       = nil  # bytes, nil = unlimited
-        @connect_timeout        = 60   # seconds, nil = OS default
         @mechanism              = :null # :null or :curve
         @curve_server           = false
         @curve_server_key       = nil  # 32-byte binary (server's permanent public key)
@@ -41,7 +40,6 @@ module OMQ
                     :reconnect_interval,
                     :heartbeat_interval,    :heartbeat_ttl,    :heartbeat_timeout,
                     :max_message_size,
-                    :connect_timeout,
                     :mechanism,
                     :curve_server,          :curve_server_key,
                     :curve_public_key,      :curve_secret_key,

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

@@ -60,7 +60,7 @@ module OMQ
                 next unless subscribed?(conn, topic)
                 begin
                   conn.send_message(parts)
-                rescue IOError, EOFError
+                rescue *ZMTP::CONNECTION_LOST
                   # connection dead — will be cleaned up
                 end
               end
@@ -79,7 +79,7 @@ module OMQ
               when "CANCEL"    then on_cancel(conn, cmd.data)
               end
             end
-          rescue EOFError
+          rescue *ZMTP::CONNECTION_LOST
             @engine.connection_lost(conn)
           end
         end

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

@@ -58,7 +58,7 @@ module OMQ
         def start_send_pump(conn)
           @tasks << Reactor.spawn_pump do
             loop { conn.send_message(@send_queue.dequeue) }
-          rescue EOFError, IOError
+          rescue *ZMTP::CONNECTION_LOST
             @engine.connection_lost(conn)
           end
         end

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

@@ -73,7 +73,7 @@ module OMQ
               next unless reply_info
               reply_info[:conn].send_message([*reply_info[:envelope], "".b, *parts])
             end
-          rescue EOFError
+          rescue *ZMTP::CONNECTION_LOST
             # connection lost mid-write
           end
         end

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

@@ -59,7 +59,7 @@ module OMQ
               conn  = next_connection
               conn.send_message(transform_send(parts))
             end
-          rescue EOFError, IOError
+          rescue *ZMTP::CONNECTION_LOST
             # connection lost mid-write
           end
         end

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

@@ -33,9 +33,11 @@ module OMQ
                 client = server.accept
                 Reactor.run do
                   engine.handle_accepted(IO::Stream::Buffered.wrap(client, minimum_write_size: 0), endpoint: endpoint)
+                rescue ProtocolError, *ZMTP::CONNECTION_LOST
+                  # peer disconnected during handshake
                 rescue => e
-                  client.close rescue nil
-                  raise if !e.is_a?(ProtocolError) && !e.is_a?(EOFError)
+                  client&.close rescue nil
+                  raise
                 end
               end
             rescue IOError

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

@@ -30,9 +30,11 @@ module OMQ
                 client = server.accept
                 Reactor.run do
                   engine.handle_accepted(IO::Stream::Buffered.wrap(client, minimum_write_size: 0), endpoint: resolved)
+                rescue ProtocolError, *ZMTP::CONNECTION_LOST
+                  # peer disconnected during handshake
                 rescue => e
-                  client.close rescue nil
-                  raise if !e.is_a?(ProtocolError) && !e.is_a?(EOFError)
+                  client&.close rescue nil
+                  raise
                 end
               end
             rescue IOError
@@ -50,12 +52,7 @@ module OMQ
           #
           def connect(endpoint, engine)
             host, port = parse_endpoint(endpoint)
-            timeout = engine.options.connect_timeout
-            sock = if timeout
-                     ::Socket.tcp(host, port, connect_timeout: timeout)
-                   else
-                     TCPSocket.new(host, port)
-                   end
+            sock = TCPSocket.new(host, port)
             engine.handle_connected(IO::Stream::Buffered.wrap(sock, minimum_write_size: 0), endpoint: endpoint)
           end
 

data/lib/omq/zmtp.rb

@@ -7,6 +7,27 @@ module OMQ
   # strategies. They are not part of the public API.
   #
   module ZMTP
+    require "io/stream"
+
+    # Errors raised when a peer disconnects or resets the connection.
+    CONNECTION_LOST = [
+      EOFError,
+      IOError,
+      Errno::EPIPE,
+      Errno::ECONNRESET,
+      Errno::ECONNABORTED,
+      Errno::ENOTCONN,
+      IO::Stream::ConnectionResetError,
+    ].freeze
+
+    # Errors raised when a peer cannot be reached.
+    CONNECTION_FAILED = [
+      Errno::ECONNREFUSED,
+      Errno::ENOENT,
+      Errno::ETIMEDOUT,
+      Errno::EHOSTUNREACH,
+      Errno::ENETUNREACH,
+    ].freeze
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omq
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Patrik Wenger