nnq 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d4408e132c91a9ebf74a96a8c14f6004c5e05c4b9abdc959a798b98f7adbf32
-  data.tar.gz: ebc0be58942030dcd326664ddde9286d948e074c953ec06f9c238a59b6f3b02a
+  metadata.gz: ed71a88238bae0611223d36bb3ec0a39795388d7b90227fb690cfc924cf85198
+  data.tar.gz: cda3bfff65005960b91672cd1c6e2a61e8fce104e202ed928932e7b0404d7eda
 SHA512:
-  metadata.gz: dc12b86758f90e1c36aba100962fc89d8cabbc93d72e9e28d4f7973a90cb1b9fab1ab38908cd3988f1b264f3bff2de34818043e5026cdc5ad655312e374fd150
-  data.tar.gz: 7679994454867fa4fcc35d3c16e7c49ffe275ba9cdaf66fbcd428e3fef8b0e89df440918232b0968e38448033198be6f91616aac678ed65bd9c5158a9cda4702
+  metadata.gz: 87ddb00a39836f3699dbd5f17a18b34dbd1c0c18d284ad1cf0b14d6271e565444ffce926ce2514c912423f943ef9a994ebb79eb3620b238f872f840124e3ad38
+  data.tar.gz: 193a8a3a1830f18aba6399990a7f1ea81639165c6ffc072691874ca972e21732f4edaf6fff3a82c3bf40b1d3a117ff04adc381e1a3f65d2f2ca677b091ae9d9d

data/CHANGELOG.md

@@ -1,5 +1,46 @@
 # Changelog
 
+## 0.4.0 — 2026-04-09
+
+- `Socket#all_peers_gone` — `Async::Promise` resolving the first time
+  the connection set becomes empty after at least one peer connected.
+  Edge-triggered, ported from OMQ.
+- `Socket#close_read` — closes the recv side only. Buffered messages
+  drain, then `#receive` returns `nil`. Send side stays operational.
+- `Socket#reconnect_enabled` / `#reconnect_enabled=` — flipped by
+  transient-mode consumers before draining to prevent the background
+  reconnect loop from revivifying a dying socket.
+- `Socket#monitor` / `NNQ::MonitorEvent` — lifecycle event stream
+  emitting `:listening`, `:connect_delayed`, `:connect_retried`,
+  `:connected`, `:handshake_succeeded`/`_failed`, `:disconnected`,
+  `:closed`, and (when `verbose: true`) `:message_sent` /
+  `:message_received`. Ported from OMQ, minus the heartbeat/mechanism
+  events nnq doesn't have.
+- Background reconnect — `NNQ::Engine::Reconnect` runs a `transient: true`
+  task per dialed endpoint, retrying with exponential back-off bounded
+  by `options.reconnect_interval` (Numeric or Range). `connect` becomes
+  non-blocking for `tcp://` and `ipc://`; `inproc://` stays synchronous.
+  `CONNECTION_FAILED` / `CONNECTION_LOST` mutable-at-load-time registries
+  let plugins append transport-specific error classes.
+- `NNQ::PULL#receive` honors `options.read_timeout` via
+  `Fiber.scheduler.with_timeout`. Previously the option was declared
+  but inert.
+- `NNQ.freeze_for_ractors!` — freezes `Engine::CONNECTION_FAILED`,
+  `Engine::CONNECTION_LOST`, and `Engine::TRANSPORTS` so NNQ sockets
+  can be used from non-main Ractors. Required for nnq-cli's `pipe -P N`
+  parallel worker mode.
+
+## 0.3.0 — 2026-04-09
+
+- `Socket#peer_connected` — `Async::Promise` that resolves with the
+  first connected peer (or `nil` on close without any peers). Ported
+  from OMQ. Held on `SocketLifecycle`, resolved by `ConnectionLifecycle`
+  on first `ready!`, and edge-triggered so callers don't need to poll.
+- `bench/` — main throughput suite ported from OMQ. Four patterns
+  (push/pull, req/rep, pair, pub/sub) across inproc, ipc, and tcp.
+  Calibration-driven burst sizing, fastest-of-3 reporting, regression
+  report with `--update-readme` to regenerate README tables.
+
 ## 0.2.0 — 2026-04-09
 
 - `NNQ::PUB` / `NNQ::SUB` with local prefix filtering (pub0/sub0).

data/lib/nnq/engine/connection_lifecycle.rb

@@ -71,23 +71,26 @@ module NNQ
         sp.handshake!
         ready!(NNQ::Connection.new(sp, endpoint: @endpoint))
         @conn
-      rescue
+      rescue => e
+        @engine.emit_monitor_event(:handshake_failed, endpoint: @endpoint, detail: { error: e })
         io.close rescue nil
         transition!(:closed) unless @state == :closed
         raise
       end
 
 
-      # Transitions to :closed, removing the connection from the engine
-      # and notifying the routing strategy. Idempotent.
+      # Unexpected loss of an established connection. Tears down and
+      # asks the engine to schedule a reconnect (if the endpoint is in
+      # the dialed set and reconnect is still enabled).
       def lost!
+        ep = @endpoint
         tear_down!
+        @engine.maybe_reconnect(ep)
       end
 
 
-      # Alias for lost!. Kept as a separate method for parity with OMQ,
-      # where the distinction drives reconnect scheduling. nnq has no
-      # reconnect yet, so the two behave identically.
+      # Deliberate close (engine shutdown or routing eviction). Does
+      # not trigger reconnect.
       def close!
         tear_down!
       end
@@ -102,9 +105,13 @@ module NNQ
         begin
           @engine.routing.connection_added(conn) if @engine.routing.respond_to?(:connection_added)
         rescue ConnectionRejected
+          @engine.emit_monitor_event(:connection_rejected, endpoint: @endpoint)
           tear_down!
           raise
         end
+        @engine.lifecycle.peer_connected.resolve(conn) unless @engine.lifecycle.peer_connected.resolved?
+        @engine.emit_monitor_event(:handshake_succeeded, endpoint: @endpoint)
+        @engine.emit_monitor_event(:connected, endpoint: @endpoint)
         @engine.new_pipe.signal
       end
 
@@ -116,6 +123,8 @@ module NNQ
           @engine.connections.delete(@conn)
           @engine.routing.connection_removed(@conn) if @engine.routing.respond_to?(:connection_removed)
           @conn.close rescue nil
+          @engine.emit_monitor_event(:disconnected, endpoint: @endpoint)
+          @engine.resolve_all_peers_gone_if_empty
         end
       end
 

data/lib/nnq/engine/reconnect.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module NNQ
+  class Engine
+    # Connection errors that should trigger a reconnect retry rather
+    # than propagate. Mutable at load time so plugins (e.g. a future
+    # TLS transport) can append their own error classes; frozen on
+    # first {Engine#connect}.
+    CONNECTION_FAILED = [
+      Errno::ECONNREFUSED,
+      Errno::EHOSTUNREACH,
+      Errno::ENETUNREACH,
+      Errno::ENOENT,
+      Errno::EPIPE,
+      Errno::ETIMEDOUT,
+      Socket::ResolutionError,
+    ]
+
+    # Errors that indicate an established connection went away. Used
+    # by the recv loop and pumps to silently terminate (the connection
+    # lifecycle's #lost! handler decides whether to reconnect).
+    CONNECTION_LOST = [
+      EOFError,
+      IOError,
+      Errno::ECONNRESET,
+      Errno::EPIPE,
+    ]
+
+
+    # Schedules reconnect attempts with exponential back-off.
+    #
+    # Runs a background task that loops until a connection is
+    # established or the engine is closed. Caller is non-blocking:
+    # {Engine#connect} returns immediately and the actual dial happens
+    # inside the task.
+    #
+    class Reconnect
+      # @param endpoint [String]
+      # @param options [Options]
+      # @param parent_task [Async::Task]
+      # @param engine [Engine]
+      # @param delay [Numeric, nil] initial delay (defaults to reconnect_interval)
+      def self.schedule(endpoint, options, parent_task, engine, delay: nil)
+        new(engine, endpoint, options).run(parent_task, delay: delay)
+      end
+
+
+      def initialize(engine, endpoint, options)
+        @engine   = engine
+        @endpoint = endpoint
+        @options  = options
+      end
+
+
+      def run(parent_task, delay: nil)
+        delay, max_delay = init_delay(delay)
+
+        task = parent_task.async(transient: true, annotation: "nnq reconnect #{@endpoint}") do
+          loop do
+            break if @engine.closed?
+            sleep delay if delay > 0
+            break if @engine.closed?
+            begin
+              @engine.transport_for(@endpoint).connect(@endpoint, @engine)
+              break
+            rescue *CONNECTION_FAILED, *CONNECTION_LOST => e
+              delay = next_delay(delay, max_delay)
+              @engine.emit_monitor_event(:connect_retried, endpoint: @endpoint, detail: { interval: delay, error: e })
+            end
+          end
+        rescue Async::Stop
+        end
+        @engine.tasks << task
+      end
+
+
+      private
+
+
+      def init_delay(delay)
+        ri = @options.reconnect_interval
+        if ri.is_a?(Range)
+          [delay || ri.begin, ri.end]
+        else
+          [delay || ri, nil]
+        end
+      end
+
+
+      def next_delay(delay, max_delay)
+        ri = @options.reconnect_interval
+        if ri.is_a?(Range)
+          delay = delay * 2
+          delay = [delay, max_delay].min if max_delay
+          delay = ri.begin if delay == 0
+          delay
+        else
+          ri
+        end
+      end
+    end
+  end
+end

data/lib/nnq/engine/socket_lifecycle.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "async/promise"
+
 module NNQ
   class Engine
     # Owns the socket-level state: `:new → :open → :closing → :closed`
@@ -31,11 +33,28 @@ module NNQ
       # @return [Boolean] true if parent_task is the shared Reactor thread
       attr_reader :on_io_thread
 
+      # @return [Async::Promise] resolves with the first connected peer
+      #   (or nil if the socket closes before anyone connects)
+      attr_reader :peer_connected
+
+      # @return [Async::Promise] resolves with true the first time the
+      #   connection set becomes empty after at least one peer connected.
+      #   Edge-triggered: does not re-arm on reconnect.
+      attr_reader :all_peers_gone
+
+      # @return [Boolean] when false, the engine must not schedule new
+      #   reconnect attempts. Default true. nnq has no automatic
+      #   reconnect loop yet, so this currently just records intent.
+      attr_accessor :reconnect_enabled
+
 
       def initialize
-        @state        = :new
-        @parent_task  = nil
-        @on_io_thread = false
+        @state             = :new
+        @parent_task       = nil
+        @on_io_thread      = false
+        @peer_connected    = Async::Promise.new
+        @all_peers_gone    = Async::Promise.new
+        @reconnect_enabled = true
       end
 
 
@@ -74,6 +93,16 @@ module NNQ
       end
 
 
+      # Resolves `all_peers_gone` if we had peers and now have none.
+      # Idempotent.
+      # @param connections [Hash] current connection map
+      def resolve_all_peers_gone_if_empty(connections)
+        return unless @peer_connected.resolved? && connections.empty?
+        return if @all_peers_gone.resolved?
+        @all_peers_gone.resolve(true)
+      end
+
+
       private
 
       def transition!(new_state)

data/lib/nnq/engine.rb

@@ -2,12 +2,15 @@
 
 require "async"
 require "async/clock"
+require "set"
 require "protocol/sp"
 require_relative "error"
 require_relative "connection"
+require_relative "monitor_event"
 require_relative "reactor"
 require_relative "engine/socket_lifecycle"
 require_relative "engine/connection_lifecycle"
+require_relative "engine/reconnect"
 require_relative "transport/tcp"
 require_relative "transport/ipc"
 require_relative "transport/inproc"
@@ -47,20 +50,54 @@ module NNQ
     # @return [Async::Condition] signaled when a new pipe is registered
     attr_reader :new_pipe
 
+    # @return [Set<String>] endpoints we have called #connect on; used
+    #   to decide whether to schedule a reconnect after a connection
+    #   is lost.
+    attr_reader :dialed
+
+    # @return [Array<Async::Task>] transient tasks owned by the engine
+    #   (currently just background reconnect loops). Stopped at #close.
+    attr_reader :tasks
+
+
+    # @return [Async::Queue, nil] monitor event queue (set by Socket#monitor)
+    attr_accessor :monitor_queue
+    attr_accessor :verbose_monitor
+
 
     # @param protocol [Integer] our SP protocol id (e.g. Protocols::PUSH_V0)
     # @param options [Options]
     # @yieldparam engine [Engine] used by the caller to build a routing
     #   strategy with access to the engine's connection map
     def initialize(protocol:, options:)
-      @protocol      = protocol
-      @options       = options
-      @connections   = {}
-      @listeners     = []
-      @lifecycle     = SocketLifecycle.new
-      @last_endpoint = nil
-      @new_pipe      = Async::Condition.new
-      @routing       = yield(self)
+      @protocol        = protocol
+      @options         = options
+      @connections     = {}
+      @listeners       = []
+      @lifecycle       = SocketLifecycle.new
+      @last_endpoint   = nil
+      @new_pipe        = Async::Condition.new
+      @monitor_queue   = nil
+      @verbose_monitor = false
+      @dialed          = Set.new
+      @tasks           = []
+      @routing         = yield(self)
+    end
+
+
+    # Emits a monitor event to the attached queue (if any).
+    def emit_monitor_event(type, endpoint: nil, detail: nil)
+      return unless @monitor_queue
+      @monitor_queue.enqueue(MonitorEvent.new(type: type, endpoint: endpoint, detail: detail))
+    rescue Async::Stop
+    end
+
+
+    # Emits a verbose-only monitor event. Only forwarded when
+    # {Socket#monitor} was called with +verbose: true+.
+    def emit_verbose_monitor_event(type, **detail)
+      return unless @verbose_monitor
+      emit_monitor_event(type, detail: detail)
     end
 
 
@@ -75,11 +112,45 @@ module NNQ
     def closed? = @lifecycle.closed?
 
 
+    # @return [Async::Promise] resolves with the first connected peer
+    def peer_connected = @lifecycle.peer_connected
+
+
+    # @return [Async::Promise] resolves when all peers have disconnected
+    #   (edge-triggered, after at least one peer connected)
+    def all_peers_gone = @lifecycle.all_peers_gone
+
+
+    # Called by ConnectionLifecycle teardown. Resolves `all_peers_gone`
+    # if the connection set is now empty and we had peers.
+    def resolve_all_peers_gone_if_empty
+      @lifecycle.resolve_all_peers_gone_if_empty(@connections)
+    end
+
+
+    # @return [Boolean]
+    def reconnect_enabled = @lifecycle.reconnect_enabled
+
+
+    # Disables or re-enables automatic reconnect. nnq has no reconnect
+    # loop yet, so this is forward-looking — {TransientMonitor} flips
+    # it before draining.
+    def reconnect_enabled=(value)
+      @lifecycle.reconnect_enabled = value
+    end
+
+
+    # Closes only the recv side. Buffered messages drain, then
+    # {Socket#receive} returns nil. Send side remains operational.
+    def close_read
+      @routing.close_read if @routing.respond_to?(:close_read)
+    end
+
+
     # Stores the parent Async task that long-lived NNQ fibers will
     # attach to. The caller (Socket) is responsible for picking the
     # right one (the user's current task, or Reactor.root_task).
-    def capture_parent_task(task)
-      on_io_thread = task.equal?(Reactor.root_task)
+    def capture_parent_task(task, on_io_thread:)
       @lifecycle.capture_parent_task(task, on_io_thread: on_io_thread)
     end
 
@@ -93,17 +164,42 @@ module NNQ
       end
       @listeners << listener
       @last_endpoint = listener.endpoint
+      emit_monitor_event(:listening, endpoint: @last_endpoint)
     end
 
 
-    # Connects to +endpoint+. Synchronous on first attempt; reconnect
-    # is wired in Phase 1.1.
+    # Connects to +endpoint+. Non-blocking for tcp:// and ipc:// — the
+    # actual dial happens inside a background reconnect task that
+    # retries with exponential back-off until the peer becomes
+    # reachable. Inproc connect is synchronous and instant.
     def connect(endpoint)
-      transport = transport_for(endpoint)
-      transport.connect(endpoint, self)
+      @dialed << endpoint
       @last_endpoint = endpoint
-    rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH => e
-      raise Error, "could not connect to #{endpoint}: #{e.class}: #{e.message}"
+      if endpoint.start_with?("inproc://")
+        transport_for(endpoint).connect(endpoint, self)
+      else
+        emit_monitor_event(:connect_delayed, endpoint: endpoint)
+        Reconnect.schedule(endpoint, @options, @lifecycle.parent_task, self, delay: 0)
+      end
+    end
+
+
+    # Schedules a reconnect for +endpoint+ if auto-reconnect is enabled
+    # and the endpoint is still in the dialed set. Called from the
+    # connection lifecycle's `lost!` path.
+    def maybe_reconnect(endpoint)
+      return unless endpoint && @dialed.include?(endpoint)
+      return unless @lifecycle.alive? && @lifecycle.reconnect_enabled
+      return if endpoint.start_with?("inproc://")
+      Reconnect.schedule(endpoint, @options, @lifecycle.parent_task, self)
+    end
+
+
+    # Public so {Reconnect} can dial directly without re-deriving the
+    # transport from the URL each iteration.
+    def transport_for(endpoint)
+      scheme = endpoint[/\A([a-z+]+):\/\//i, 1] or raise Error, "no scheme: #{endpoint}"
+      TRANSPORTS[scheme] or raise Error, "unsupported transport: #{scheme}"
     end
 
 
@@ -146,6 +242,8 @@ module NNQ
       return unless @lifecycle.alive?
       @lifecycle.start_closing!
       @listeners.each(&:stop)
+      @tasks.each { |t| t.stop rescue nil }
+      @tasks.clear
       drain_send_queue(@options.linger)
       @routing.close if @routing.respond_to?(:close)
       # Tear down each remaining connection via its lifecycle. The
@@ -153,6 +251,11 @@ module NNQ
       @connections.values.each(&:close!)
       @lifecycle.finish_closing!
       @new_pipe.signal
+      # Unblock anyone waiting on peer_connected when the socket is
+      # closed before a peer ever arrived.
+      @lifecycle.peer_connected.resolve(nil) unless @lifecycle.peer_connected.resolved?
+      emit_monitor_event(:closed)
+      close_monitor_queue
     end
 
 
@@ -165,6 +268,12 @@ module NNQ
 
     private
 
+    def close_monitor_queue
+      return unless @monitor_queue
+      @monitor_queue.enqueue(nil)
+    end
+
+
     def drain_send_queue(timeout)
       return unless @routing.respond_to?(:send_queue_drained?)
       return if @connections.empty?
@@ -180,19 +289,14 @@ module NNQ
       @lifecycle.parent_task.async(annotation: "nnq recv #{conn.endpoint}") do
         loop do
           body = conn.receive_message
+          emit_verbose_monitor_event(:message_received, body: body)
           @routing.enqueue(body, conn)
-        rescue EOFError, IOError, Errno::ECONNRESET, Async::Stop
+        rescue *CONNECTION_LOST, Async::Stop
           break
         end
       ensure
         handle_connection_lost(conn)
       end
     end
-
-
-    def transport_for(endpoint)
-      scheme = endpoint[/\A([a-z+]+):\/\//i, 1] or raise Error, "no scheme: #{endpoint}"
-      TRANSPORTS[scheme] or raise Error, "unsupported transport: #{scheme}"
-    end
   end
 end

data/lib/nnq/monitor_event.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module NNQ
+  # Lifecycle event emitted by {Socket#monitor}.
+  #
+  # @!attribute [r] type
+  #   @return [Symbol] event type (:listening, :connected, :disconnected, ...)
+  # @!attribute [r] endpoint
+  #   @return [String, nil] the endpoint involved
+  # @!attribute [r] detail
+  #   @return [Hash, nil] extra context
+  #
+  MonitorEvent = Data.define(:type, :endpoint, :detail) do
+    def initialize(type:, endpoint: nil, detail: nil) = super
+  end
+end

data/lib/nnq/push_pull.rb

@@ -34,7 +34,13 @@ module NNQ
   #
   class PULL < Socket
     def receive
-      Reactor.run { @engine.routing.receive }
+      Reactor.run do
+        if (timeout = @engine.options.read_timeout)
+          Fiber.scheduler.with_timeout(timeout) { @engine.routing.receive }
+        else
+          @engine.routing.receive
+        end
+      end
     end
 
 

data/lib/nnq/routing/pair.rb

@@ -67,6 +67,12 @@ module NNQ
         super
         @recv_queue.enqueue(nil) # wake any waiter
       end
+
+
+      # Wake recv side without tearing down the send pump.
+      def close_read
+        @recv_queue.enqueue(nil)
+      end
     end
   end
 end

data/lib/nnq/routing/pub.rb

@@ -77,6 +77,7 @@ module NNQ
           loop do
             body = queue.dequeue
             conn.send_message(body)
+            @engine.emit_verbose_monitor_event(:message_sent, body: body)
           rescue EOFError, IOError, Errno::EPIPE, Errno::ECONNRESET
             break
           end

data/lib/nnq/routing/pull.rb

@@ -33,6 +33,14 @@ module NNQ
       def close
         @queue.enqueue(nil)
       end
+
+
+      # Wakes any waiters with nil, leaving the send side untouched
+      # (PULL has no send side — close_read is identical to close here,
+      # but kept separate for the `Socket#close_read` contract).
+      def close_read
+        @queue.enqueue(nil)
+      end
     end
   end
 end

data/lib/nnq/routing/rep.rb

@@ -89,6 +89,11 @@ module NNQ
       end
 
 
+      def close_read
+        @recv_queue.enqueue(nil)
+      end
+
+
       private
 
       # Reads 4-byte BE words off the front of +body+, stopping at the

data/lib/nnq/routing/send_pump.rb

@@ -123,6 +123,7 @@ module NNQ
           conn.write_messages(batch)
         end
         conn.flush
+        batch.each { |body| @engine.emit_verbose_monitor_event(:message_sent, body: body) }
       end
     end
   end

data/lib/nnq/routing/sub.rb

@@ -48,6 +48,11 @@ module NNQ
         @queue.enqueue(nil)
       end
 
+
+      def close_read
+        @queue.enqueue(nil)
+      end
+
       private
 
       def matches?(body)

data/lib/nnq/socket.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
 
+require "async/queue"
+
 require_relative "options"
 require_relative "engine"
+require_relative "monitor_event"
 require_relative "reactor"
 
 module NNQ
@@ -57,6 +60,57 @@ module NNQ
     def connection_count = @engine.connections.size
 
 
+    # Resolves with the first connected peer (or nil on close without
+    # any peers). Block on `.wait` to wait until a connection is ready.
+    def peer_connected = @engine.peer_connected
+
+
+    # Resolves with `true` the first time all peers have disconnected
+    # (after at least one peer was connected). Edge-triggered.
+    def all_peers_gone = @engine.all_peers_gone
+
+
+    def reconnect_enabled  = @engine.reconnect_enabled
+    def reconnect_enabled=(value)
+      @engine.reconnect_enabled = value
+    end
+
+
+    # Closes the recv side only. Buffered messages drain, then
+    # {#receive} returns nil. Send side stays open.
+    def close_read
+      Reactor.run { @engine.close_read }
+      nil
+    end
+
+
+    # Yields lifecycle events for this socket until it's closed or
+    # the returned task is stopped.
+    #
+    # @param verbose [Boolean] when true, also emits :message_sent /
+    #   :message_received events
+    # @yield [event]
+    # @yieldparam event [MonitorEvent]
+    # @return [Async::Task]
+    def monitor(verbose: false, &block)
+      ensure_parent_task
+      queue = Async::Queue.new
+      @engine.monitor_queue   = queue
+      @engine.verbose_monitor = verbose
+      Reactor.run do
+        @engine.spawn_task(annotation: "nnq monitor") do
+          while (event = queue.dequeue)
+            block.call(event)
+          end
+        rescue Async::Stop
+        ensure
+          @engine.monitor_queue = nil
+          block.call(MonitorEvent.new(type: :monitor_stopped))
+        end
+      end
+    end
+
+
     private
 
     def ensure_parent_task
@@ -65,9 +119,9 @@ module NNQ
       # that Reactor wraps each dispatched block in. Inside an Async
       # reactor, the current task is the right parent.
       if Async::Task.current?
-        @engine.capture_parent_task(Async::Task.current)
+        @engine.capture_parent_task(Async::Task.current, on_io_thread: false)
       else
-        @engine.capture_parent_task(Reactor.root_task)
+        @engine.capture_parent_task(Reactor.root_task, on_io_thread: true)
       end
     end
 

data/lib/nnq/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module NNQ
-  VERSION = "0.2.0"
+  VERSION = "0.4.0"
 end

data/lib/nnq.rb

@@ -3,6 +3,14 @@
 require "protocol/sp"
 
 module NNQ
+  # Freezes module-level state so NNQ sockets can be used inside Ractors.
+  # Call this once before spawning any Ractors that create NNQ sockets.
+  #
+  def self.freeze_for_ractors!
+    Engine::CONNECTION_FAILED.freeze
+    Engine::CONNECTION_LOST.freeze
+    Engine::TRANSPORTS.freeze
+  end
 end
 
 require_relative "nnq/version"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nnq
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Patrik Wenger
@@ -52,8 +52,8 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.1'
 description: Pure Ruby implementation of nanomsg's Scalability Protocols (SP) on top
-  of async + io-stream. No HWM, opportunistic batching, wire-compatible with libnng
-  over inproc/ipc/tcp.
+  of async + io-stream. Per-socket HWM, opportunistic batching, wire-compatible with
+  libnng over inproc/ipc/tcp.
 email:
 - paddor@gmail.com
 executables: []
@@ -67,8 +67,10 @@ files:
 - lib/nnq/connection.rb
 - lib/nnq/engine.rb
 - lib/nnq/engine/connection_lifecycle.rb
+- lib/nnq/engine/reconnect.rb
 - lib/nnq/engine/socket_lifecycle.rb
 - lib/nnq/error.rb
+- lib/nnq/monitor_event.rb
 - lib/nnq/options.rb
 - lib/nnq/pair.rb
 - lib/nnq/pub_sub.rb