omq 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f11ba4b6d749acef6ad97b6f328aec61aba341ba5759660e23c896af2d96054d
-  data.tar.gz: cf91d6bc140f04d000b5add87322ba9f39ea3b5790f75e4b22144b429284b4c7
+  metadata.gz: fb02b0e08db21f4d0db4bb376a35759ca709ef80d175a306179c3710e8048e9d
+  data.tar.gz: 41bfa63e9868e6a5d10c97e9751ebe227f8937be734d9f9bc5c618619cb1906c
 SHA512:
-  metadata.gz: 4ecc0a3992c75679ea9cebd9872bdb7a7c9d3f3e86eaccd82dccc7717a84591c5d8493ab0629b14dfdaea35e30b0bae27c6c142841e2f1c61a04a4ef09805b54
-  data.tar.gz: 7789734d032134883b3ae71ba0af36a7f89d67625d4e879e03f1be81d3ae83b3f1afcda0610bb203ff25a62ecdfac90a4f56b08b5a8127cbab94b1e305261278
+  metadata.gz: cf95700a644923f1598944501e10775de5ba0cfd277c375f3701c93e09a5e1928e495acea2e09eb5224f87143e55526f851852c2ba67d92409a5e0da62ec5266
+  data.tar.gz: 9b299ca752fee2e1cba919d65bd7a377494e8067d111f27ac53c8dc2a35b3c9c3d0547386e38417656f58b746ea3dda6ea5b8292e1d9f9230736150561aad1b8

data/CHANGELOG.md

@@ -1,5 +1,36 @@
 # Changelog
 
+## 0.2.0 — 2026-03-26
+
+### Changed
+
+- `mechanism` option now holds the mechanism instance directly
+  (`Mechanism::Null.new` by default). For CURVE, use
+  `OMQ::Curve.server(pub, sec)` or `OMQ::Curve.client(pub, sec, server_key: k)`.
+- Removed `curve_server`, `curve_server_key`, `curve_public_key`,
+  `curve_secret_key`, `curve_authenticator` socket options
+
+## 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 +56,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,13 +30,7 @@ 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=
-      curve_public_key        curve_public_key=
-      curve_secret_key        curve_secret_key=
-      curve_authenticator     curve_authenticator=
     ].each do |method|
       define_method(method) { |*args| @options.public_send(method, *args) }
     end

data/lib/omq/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OMQ
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 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
@@ -257,7 +260,7 @@ module OMQ
           socket_type:       @socket_type.to_s,
           identity:          @options.identity,
           as_server:         as_server,
-          mechanism:          build_mechanism,
+          mechanism:          @options.mechanism,
           heartbeat_interval: @options.heartbeat_interval,
           heartbeat_ttl:      @options.heartbeat_ttl,
           heartbeat_timeout:  @options.heartbeat_timeout,
@@ -268,58 +271,40 @@ 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
       end
 
 
-      def build_mechanism
-        case @options.mechanism
-        when :null
-          Mechanism::Null.new
-        when :curve
-          unless defined?(Mechanism::Curve)
-            raise LoadError, "require 'omq-curve' to use CURVE security"
-          end
-          Mechanism::Curve.new(
-            server_key:    @options.curve_server_key,
-            public_key:    @options.curve_public_key,
-            secret_key:    @options.curve_secret_key,
-            as_server:     @options.curve_server,
-            authenticator: @options.curve_authenticator,
-          )
-        else
-          raise ArgumentError, "unknown mechanism: #{@options.mechanism}"
-        end
-      end
-
       def transport_for(endpoint)
         case endpoint
         when /\Atcp:\/\//    then Transport::TCP

data/lib/omq/zmtp/options.rb

@@ -25,13 +25,7 @@ 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)
-        @curve_public_key       = nil  # 32-byte binary (our permanent public key)
-        @curve_secret_key       = nil  # 32-byte binary (our permanent secret key)
-        @curve_authenticator    = nil  # nil = allow all, Set = allowlist, #call = custom
+        @mechanism              = Mechanism::Null.new
       end
 
       attr_accessor :send_hwm,  :recv_hwm,
@@ -41,11 +35,7 @@ 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,
-                    :curve_authenticator
+                    :mechanism
 
       alias_method :router_mandatory?, :router_mandatory
       alias_method :recv_timeout,      :read_timeout

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.2.0
 platform: ruby
 authors:
 - Patrik Wenger