nnq 0.4.0 → 0.5.0

data/lib/nnq/options.rb

@@ -18,14 +18,21 @@ module NNQ
     attr_accessor :reconnect_interval
     attr_accessor :max_message_size
     attr_accessor :send_hwm
+    attr_accessor :survey_time
 
-    def initialize(linger: nil, send_hwm: DEFAULT_HWM)
+
+    # @param linger [Numeric] linger period in seconds on close
+    #   (default Float::INFINITY = wait forever, matching libzmq).
+    #   Pass 0 for immediate drop-on-close.
+    def initialize(linger: Float::INFINITY, send_hwm: DEFAULT_HWM)
       @linger             = linger
       @read_timeout       = nil
       @write_timeout      = nil
       @reconnect_interval = 0.1
       @max_message_size   = nil
       @send_hwm           = send_hwm
+      @survey_time        = 1.0
     end
+
   end
 end

data/lib/nnq/pair.rb

@@ -8,8 +8,9 @@ module NNQ
   # peer. First peer to connect wins; subsequent peers are dropped
   # until the current one disconnects. No SP header on the wire.
   #
-  class PAIR < Socket
+  class PAIR0 < Socket
     def send(body)
+      body = frozen_binary(body)
       Reactor.run { @engine.routing.send(body) }
     end
 
@@ -21,6 +22,7 @@ module NNQ
 
     private
 
+
     def protocol
       Protocol::SP::Protocols::PAIR_V0
     end
@@ -30,4 +32,7 @@ module NNQ
       Routing::Pair.new(engine)
     end
   end
+
+
+  PAIR = PAIR0
 end

data/lib/nnq/pub_sub.rb

@@ -10,14 +10,16 @@ module NNQ
   # a slow peer drops messages instead of blocking fast peers.
   # Defaults to listening.
   #
-  class PUB < Socket
+  class PUB0 < Socket
     def send(body)
+      body = frozen_binary(body)
       Reactor.run { @engine.routing.send(body) }
     end
 
 
     private
 
+
     def protocol
       Protocol::SP::Protocols::PUB_V0
     end
@@ -34,7 +36,7 @@ module NNQ
   # are delivered — matching nng (unlike pre-4.x ZeroMQ). Defaults
   # to dialing.
   #
-  class SUB < Socket
+  class SUB0 < Socket
     # Subscribes to +prefix+. Bytes-level match. The empty string
     # matches everything.
     #
@@ -60,6 +62,7 @@ module NNQ
 
     private
 
+
     def protocol
       Protocol::SP::Protocols::SUB_V0
     end
@@ -69,4 +72,8 @@ module NNQ
       Routing::Sub.new
     end
   end
+
+
+  PUB = PUB0
+  SUB = SUB0
 end

data/lib/nnq/push_pull.rb

@@ -9,14 +9,16 @@ module NNQ
   # bounded send queue (`send_hwm`); per-peer send pumps work-steal from
   # it. Defaults to dialing.
   #
-  class PUSH < Socket
+  class PUSH0 < Socket
     def send(body)
+      body = frozen_binary(body)
       Reactor.run { @engine.routing.send(body) }
     end
 
 
     private
 
+
     def protocol
       Protocol::SP::Protocols::PUSH_V0
     end
@@ -32,7 +34,7 @@ module NNQ
   # from all live PUSH peers into one unbounded receive queue. Defaults
   # to listening.
   #
-  class PULL < Socket
+  class PULL0 < Socket
     def receive
       Reactor.run do
         if (timeout = @engine.options.read_timeout)
@@ -46,6 +48,7 @@ module NNQ
 
     private
 
+
     def protocol
       Protocol::SP::Protocols::PULL_V0
     end
@@ -55,4 +58,8 @@ module NNQ
       Routing::Pull.new
     end
   end
+
+
+  PUSH = PUSH0
+  PULL = PULL0
 end

data/lib/nnq/reactor.rb

@@ -22,11 +22,14 @@ module NNQ
     @root_task  = nil
     @work_queue = nil
 
+
     class << self
       def root_task
         return @root_task if @root_task
+
         @mutex.synchronize do
           return @root_task if @root_task
+
           ready       = Thread::Queue.new
           @work_queue = Async::Queue.new
           @thread     = Thread.new { run_reactor(ready) }
@@ -34,6 +37,7 @@ module NNQ
           @root_task  = ready.pop
           at_exit { stop! }
         end
+
         @root_task
       end
 
@@ -42,12 +46,10 @@ module NNQ
         if Async::Task.current?
           yield
         else
-          result = Thread::Queue.new
+          result = Async::Promise.new
           root_task # ensure started
           @work_queue.push([block, result])
-          status, value = result.pop
-          raise value if status == :error
-          value
+          result.wait
         end
       end
 
@@ -61,23 +63,22 @@ module NNQ
         @work_queue = nil
       end
 
+
       private
 
+
       def run_reactor(ready)
         Async do |task|
           ready.push(task)
+
           loop do
-            item = @work_queue.dequeue
-            break if item.nil?
+            item = @work_queue.dequeue or break
             block, result = item
-            task.async do
-              result.push([:ok, block.call])
-            rescue => e
-              result.push([:error, e])
-            end
+            task.async { result.fulfill { block.call } }
           end
         end
       end
+
     end
   end
 end

data/lib/nnq/req_rep.rb

@@ -9,16 +9,18 @@ module NNQ
   # request per socket. #send_request blocks until the matching reply
   # comes back.
   #
-  class REQ < Socket
+  class REQ0 < Socket
     # Sends +body+ as a request, blocks until the matching reply
     # arrives. Returns the reply body (without the id header).
     def send_request(body)
+      body = frozen_binary(body)
       Reactor.run { @engine.routing.send_request(body) }
     end
 
 
     private
 
+
     def protocol
       Protocol::SP::Protocols::REQ_V0
     end
@@ -33,7 +35,7 @@ module NNQ
   # REP (nng rep0): server side of request/reply. Strict alternation
   # of #receive then #send_reply, per request.
   #
-  class REP < Socket
+  class REP0 < Socket
     # Blocks until the next request arrives. Returns the request body.
     def receive
       Reactor.run { @engine.routing.receive }
@@ -42,12 +44,14 @@ module NNQ
 
     # Routes +body+ back to the pipe the most recent #receive came from.
     def send_reply(body)
+      body = frozen_binary(body)
       Reactor.run { @engine.routing.send_reply(body) }
     end
 
 
     private
 
+
     def protocol
       Protocol::SP::Protocols::REP_V0
     end
@@ -57,4 +61,8 @@ module NNQ
       Routing::Rep.new(engine)
     end
   end
+
+
+  REQ = REQ0
+  REP = REP0
 end

data/lib/nnq/routing/backtrace.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module NNQ
+  module Routing
+    # Shared backtrace parsing for SP protocols that use the
+    # request-id / hop-stack wire format (REQ/REP, SURVEYOR/RESPONDENT).
+    #
+    # Wire format: one or more 4-byte big-endian words. The terminal
+    # word (request or survey id) has its high bit set (0x80). Preceding
+    # words (hop ids added by devices) have the high bit clear.
+    #
+    module Backtrace
+      MAX_HOPS = 8 # nng's default ttl
+
+      # Reads 4-byte BE words off the front of +body+, stopping at the
+      # first one whose top byte has its high bit set. Returns
+      # [backtrace_bytes, remaining_payload] or nil on malformed input.
+      def parse_backtrace(body)
+        offset = 0
+        hops   = 0
+
+        while hops < MAX_HOPS
+          return nil if body.bytesize - offset < 4
+
+          word    = body.byteslice(offset, 4)
+          offset += 4
+          hops   += 1
+
+          if word.getbyte(0) & 0x80 != 0
+            return [body.byteslice(0, offset), body.byteslice(offset..)]
+          end
+        end
+
+        nil # exceeded TTL without finding terminator
+      end
+
+    end
+  end
+end

data/lib/nnq/routing/bus.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "async"
+require "async/queue"
+require "async/limited_queue"
+
+module NNQ
+  module Routing
+    # BUS0: best-effort bidirectional mesh.
+    #
+    # Send side: fan-out to all connected peers. Each peer gets its own
+    # bounded send queue and pump fiber — a slow peer drops messages
+    # instead of blocking fast ones (same as PUB). Send never blocks.
+    #
+    # Recv side: all incoming messages are pushed into a shared
+    # unbounded queue (same as PULL).
+    #
+    # No SP headers in cooked mode — body on the wire is the user
+    # payload.
+    #
+    class Bus
+      def initialize(engine)
+        @engine     = engine
+        @queues     = {} # conn => Async::LimitedQueue
+        @pump_tasks = {} # conn => Async::Task
+        @recv_queue = Async::Queue.new
+      end
+
+
+      # Broadcasts +body+ to every connected peer. Non-blocking per
+      # peer: drops when a peer's queue is at HWM.
+      #
+      # @param body [String]
+      def send(body)
+        @queues.each_value do |queue|
+          queue.enqueue(body) unless queue.limited?
+        end
+      end
+
+
+      # Called by the engine recv loop with each received message.
+      def enqueue(body, _conn = nil)
+        @recv_queue.enqueue(body)
+      end
+
+
+      # @return [String, nil] message body, or nil once the socket is closed
+      def receive
+        @recv_queue.dequeue
+      end
+
+
+      def connection_added(conn)
+        queue = Async::LimitedQueue.new(@engine.options.send_hwm)
+        @queues[conn]     = queue
+        @pump_tasks[conn] = spawn_pump(conn, queue)
+      end
+
+
+      def connection_removed(conn)
+        @queues.delete(conn)
+        task = @pump_tasks.delete(conn)
+        return unless task
+        return if task == Async::Task.current
+        task.stop
+      rescue IOError, Errno::EPIPE
+      end
+
+
+      def send_queue_drained?
+        @queues.each_value.all? { |q| q.empty? }
+      end
+
+
+      def close
+        @pump_tasks.each_value(&:stop)
+        @pump_tasks.clear
+        @queues.clear
+        @recv_queue.enqueue(nil)
+      end
+
+
+      def close_read
+        @recv_queue.enqueue(nil)
+      end
+
+
+      private
+
+
+      def spawn_pump(conn, queue)
+        annotation = "nnq bus pump #{conn.endpoint}"
+        parent     = @engine.connections[conn]&.barrier || @engine.barrier
+
+        @engine.spawn_task(annotation:, parent:) do
+          loop do
+            body = queue.dequeue
+            conn.send_message(body)
+            @engine.emit_verbose_msg_sent(body)
+          rescue EOFError, IOError, Errno::EPIPE, Errno::ECONNRESET
+            break
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/nnq/routing/pair.rb

@@ -22,6 +22,7 @@ module NNQ
     class Pair
       include SendPump
 
+
       def initialize(engine)
         init_send_pump(engine)
         @recv_queue = Async::Queue.new
@@ -41,7 +42,7 @@ module NNQ
       end
 
 
-      # Called by the recv loop with each frame off the wire.
+      # Called by the recv loop with each message off the wire.
       def enqueue(body, _conn = nil)
         @recv_queue.enqueue(body)
       end
@@ -52,6 +53,7 @@ module NNQ
       # without ever exposing it to pumps.
       def connection_added(conn)
         raise ConnectionRejected, "PAIR socket already has a peer" if @peer
+
         @peer = conn
         spawn_send_pump_for(conn)
       end
@@ -73,6 +75,7 @@ module NNQ
       def close_read
         @recv_queue.enqueue(nil)
       end
+
     end
   end
 end

data/lib/nnq/routing/pub.rb

@@ -60,7 +60,7 @@ module NNQ
 
       # True once every peer's queue is empty. Engine linger polls this.
       def send_queue_drained?
-        @queues.each_value.all?(&:empty?)
+        @queues.each_value.all? { |q| q.empty? }
       end
 
 
@@ -70,21 +70,25 @@ module NNQ
         @queues.clear
       end
 
+
       private
 
+
       def spawn_pump(conn, queue)
-        @engine.spawn_task(annotation: "nnq pub pump #{conn.endpoint}") do
+        annotation = "nnq pub pump #{conn.endpoint}"
+        parent     = @engine.connections[conn]&.barrier || @engine.barrier
+
+        @engine.spawn_task(annotation:, parent:) do
           loop do
             body = queue.dequeue
             conn.send_message(body)
-            @engine.emit_verbose_monitor_event(:message_sent, body: body)
+            @engine.emit_verbose_msg_sent(body)
           rescue EOFError, IOError, Errno::EPIPE, Errno::ECONNRESET
             break
           end
-        ensure
-          @engine.handle_connection_lost(conn)
         end
       end
+
     end
   end
 end

data/lib/nnq/routing/pull.rb

@@ -6,7 +6,7 @@ module NNQ
   module Routing
     # PULL side: an unbounded queue of received messages. Per-connection
     # recv fibers (spawned by the Engine when each pipe is established)
-    # call {#enqueue} on each frame; user code calls {#receive}.
+    # call {#enqueue} on each message; user code calls {#receive}.
     #
     # No HWM, no prefetch buffer — TCP throttles the senders directly
     # via the kernel buffer.
@@ -41,6 +41,7 @@ module NNQ
       def close_read
         @queue.enqueue(nil)
       end
+
     end
   end
 end

data/lib/nnq/routing/push.rb

@@ -17,6 +17,7 @@ module NNQ
     class Push
       include SendPump
 
+
       def initialize(engine)
         init_send_pump(engine)
       end
@@ -38,6 +39,7 @@ module NNQ
       def connection_removed(conn)
         remove_send_pump_for(conn)
       end
+
     end
   end
 end

data/lib/nnq/routing/rep.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "async/queue"
+require_relative "backtrace"
 
 module NNQ
   module Routing
@@ -27,7 +28,8 @@ module NNQ
     # - TTL cap on the backtrace stack: 8 hops, matching nng's default.
     #
     class Rep
-      MAX_HOPS = 8 # nng's default ttl
+      include Backtrace
+
 
       def initialize(engine)
         @engine     = engine
@@ -46,7 +48,9 @@ module NNQ
         # again without replying is how users drop unwanted requests.
         @mutex.synchronize { @pending = nil }
         item = @recv_queue.dequeue
+
         return nil if item.nil?
+
         conn, btrace, body = item
         @mutex.synchronize { @pending = [conn, btrace] }
         body
@@ -69,7 +73,7 @@ module NNQ
       end
 
 
-      # Called by the engine recv loop with each received frame.
+      # Called by the engine recv loop with each received message.
       def enqueue(body, conn)
         btrace, payload = parse_backtrace(body)
         return unless btrace # malformed/over-TTL — drop
@@ -94,25 +98,6 @@ module NNQ
       end
 
 
-      private
-
-      # Reads 4-byte BE words off the front of +body+, stopping at the
-      # first one whose top byte has its high bit set. Returns
-      # [backtrace_bytes, remaining_payload] or nil on malformed input.
-      def parse_backtrace(body)
-        offset = 0
-        hops   = 0
-        while hops < MAX_HOPS
-          return nil if body.bytesize - offset < 4
-          word = body.byteslice(offset, 4)
-          offset += 4
-          hops   += 1
-          if word.getbyte(0) & 0x80 != 0
-            return [body.byteslice(0, offset), body.byteslice(offset..)]
-          end
-        end
-        nil # exceeded TTL without finding terminator
-      end
     end
   end
 end

data/lib/nnq/routing/req.rb

@@ -10,7 +10,7 @@ module NNQ
     # Wire format: each message body on the wire is `[4-byte BE
     # request_id][user_payload]`. The request id has the high bit set
     # (`0x80000000..0xFFFFFFFF`) — that's nng's marker for "this is the
-    # last (deepest) frame on the backtrace stack". Direct REQ→REP has
+    # last (deepest) word on the backtrace stack". Direct REQ→REP has
     # exactly one id.
     #
     # Semantics (cooked mode, what this implements):
@@ -66,7 +66,7 @@ module NNQ
       end
 
 
-      # Called by the engine recv loop with each received frame.
+      # Called by the engine recv loop with each received message.
       def enqueue(body, _conn)
         return if body.bytesize < 4
         id      = body.unpack1("N")
@@ -91,17 +91,21 @@ module NNQ
 
       private
 
+
       def pick_peer
         loop do
           conns = @engine.connections.keys
+
           if conns.empty?
             @engine.new_pipe.wait
             next
           end
+
           @next_idx = (@next_idx + 1) % conns.size
           return conns[@next_idx]
         end
       end
+
     end
   end
 end

data/lib/nnq/routing/respondent.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "async/queue"
+require_relative "backtrace"
+
+module NNQ
+  module Routing
+    # RESPONDENT: reply side of the survey0 pattern.
+    #
+    # Semantics mirror REP: strict alternation of #receive then
+    # #send_reply. The backtrace (survey ID + any hop IDs) is stripped
+    # on receive and echoed verbatim on reply.
+    #
+    class Respondent
+      include Backtrace
+
+
+      def initialize(engine)
+        @engine     = engine
+        @recv_queue = Async::Queue.new
+        @pending    = nil
+        @mutex      = Mutex.new
+      end
+
+
+      # Receives the next survey body. Stashes the backtrace +
+      # originating connection for the subsequent #send_reply.
+      #
+      # @return [String, nil] survey body, or nil if the socket was closed
+      def receive
+        @mutex.synchronize { @pending = nil }
+        item = @recv_queue.dequeue
+
+        return nil if item.nil?
+
+        conn, btrace, body = item
+        @mutex.synchronize { @pending = [conn, btrace] }
+        body
+      end
+
+
+      # Sends +body+ as the reply to the most recently received survey.
+      #
+      # @param body [String]
+      def send_reply(body)
+        conn, btrace = @mutex.synchronize do
+          raise Error, "RESPONDENT socket has no pending survey to reply to" unless @pending
+          taken    = @pending
+          @pending = nil
+          taken
+        end
+
+        return if conn.closed?
+        conn.send_message(btrace + body)
+      end
+
+
+      # Called by the engine recv loop with each received message.
+      def enqueue(body, conn)
+        btrace, payload = parse_backtrace(body)
+        return unless btrace # malformed/over-TTL — drop
+        @recv_queue.enqueue([conn, btrace, payload])
+      end
+
+
+      def connection_removed(conn)
+        @mutex.synchronize do
+          @pending = nil if @pending && @pending[0] == conn
+        end
+      end
+
+
+      def close
+        @recv_queue.enqueue(nil)
+      end
+
+
+      def close_read
+        @recv_queue.enqueue(nil)
+      end
+
+    end
+  end
+end