nnq 0.6.1 → 0.8.1

data/lib/nnq/routing/req_raw.rb

@@ -48,6 +48,16 @@ module NNQ
       end
 
 
+      # Inproc fast-path hook.
+      def direct_recv_for(conn)
+        transform = lambda do |wire_bytes|
+          header, payload = parse_backtrace(wire_bytes)
+          header ? [conn, header, payload] : nil
+        end
+        [@recv_queue, transform]
+      end
+
+
       def close
         @recv_queue.enqueue(nil)
       end

data/lib/nnq/routing/respondent.rb

@@ -71,6 +71,16 @@ module NNQ
       end
 
 
+      # Inproc fast-path hook.
+      def direct_recv_for(conn)
+        transform = lambda do |body|
+          btrace, payload = parse_backtrace(body)
+          btrace ? [conn, btrace, payload] : nil
+        end
+        [@recv_queue, transform]
+      end
+
+
       def connection_removed(conn)
         @mutex.synchronize do
           @pending = nil if @pending && @pending[0] == conn

data/lib/nnq/routing/respondent_raw.rb

@@ -47,6 +47,16 @@ module NNQ
       end
 
 
+      # Inproc fast-path hook.
+      def direct_recv_for(conn)
+        transform = lambda do |wire_bytes|
+          header, payload = parse_backtrace(wire_bytes)
+          header ? [conn, header, payload] : nil
+        end
+        [@recv_queue, transform]
+      end
+
+
       def close
         @recv_queue.enqueue(nil)
       end

data/lib/nnq/routing/sub.rb

@@ -38,6 +38,13 @@ module NNQ
       end
 
 
+      # Inproc fast-path hook: filter via the subscription list in the
+      # transform, then enqueue only matching bodies.
+      def direct_recv_for(_conn)
+        [@queue, ->(body) { matches?(body) ? body : nil }]
+      end
+
+
       # @return [String, nil]
       def receive
         @queue.dequeue

data/lib/nnq/routing/surveyor.rb

@@ -24,7 +24,6 @@ module NNQ
       def initialize(engine)
         @engine     = engine
         @queues     = {} # conn => Async::LimitedQueue
-        @pump_tasks = {} # conn => Async::Task
         @recv_queue = Async::Queue.new
         @current_id = nil
         @mutex      = Mutex.new
@@ -68,7 +67,7 @@ module NNQ
         return if body.bytesize < 4
 
         id      = body.unpack1("N")
-        payload = body.byteslice(4..)
+        payload = body.byteslice(4..).freeze
 
         @mutex.synchronize do
           return unless @current_id == id
@@ -78,6 +77,21 @@ module NNQ
       end
 
 
+      # Inproc fast-path hook. Transform filters replies by current
+      # survey id and strips the 4-byte header, mirroring #enqueue.
+      def direct_recv_for(_conn)
+        mutex = @mutex
+        transform = lambda do |body|
+          next nil if body.bytesize < 4
+          id      = body.unpack1("N")
+          payload = body.byteslice(4..).freeze
+          match   = mutex.synchronize { @current_id == id }
+          match ? payload : nil
+        end
+        [@recv_queue, transform]
+      end
+
+
       # Strips the 4-byte survey id for verbose trace previews.
       def preview_body(wire)
         wire.byteslice(4..) || wire
@@ -85,21 +99,14 @@ module NNQ
 
 
       def connection_added(conn)
-        queue             = Async::LimitedQueue.new(@engine.options.send_hwm)
-        @queues[conn]     = queue
-        @pump_tasks[conn] = spawn_pump(conn, queue)
+        queue         = Async::LimitedQueue.new(@engine.options.send_hwm)
+        @queues[conn] = queue
+        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
 
 
@@ -109,8 +116,6 @@ module NNQ
 
 
       def close
-        @pump_tasks.each_value(&:stop)
-        @pump_tasks.clear
         @queues.clear
         @recv_queue.enqueue(nil)
       end

data/lib/nnq/routing/surveyor_raw.rb

@@ -23,7 +23,6 @@ module NNQ
       def initialize(engine)
         @engine     = engine
         @queues     = {} # conn => Async::LimitedQueue
-        @pump_tasks = {} # conn => Async::Task
         @recv_queue = Async::LimitedQueue.new(engine.options.recv_hwm)
       end
 
@@ -47,6 +46,16 @@ module NNQ
       end
 
 
+      # Inproc fast-path hook.
+      def direct_recv_for(conn)
+        transform = lambda do |wire_bytes|
+          header, payload = parse_backtrace(wire_bytes)
+          header ? [conn, header, payload] : nil
+        end
+        [@recv_queue, transform]
+      end
+
+
       def preview_body(wire)
         _, payload = parse_backtrace(wire)
         payload || wire
@@ -54,21 +63,14 @@ module NNQ
 
 
       def connection_added(conn)
-        queue             = Async::LimitedQueue.new(@engine.options.send_hwm)
-        @queues[conn]     = queue
-        @pump_tasks[conn] = spawn_pump(conn, queue)
+        queue         = Async::LimitedQueue.new(@engine.options.send_hwm)
+        @queues[conn] = queue
+        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
 
 
@@ -78,8 +80,6 @@ module NNQ
 
 
       def close
-        @pump_tasks.each_value(&:stop)
-        @pump_tasks.clear
         @queues.clear
         @recv_queue.enqueue(nil)
       end

data/lib/nnq/socket.rb

@@ -2,11 +2,6 @@
 
 require "async/queue"
 
-require_relative "options"
-require_relative "engine"
-require_relative "monitor_event"
-require_relative "reactor"
-
 module NNQ
   # Socket base class. Subclasses (PUSH, PULL, ...) wire up a routing
   # strategy and the SP protocol id.
@@ -50,15 +45,15 @@ module NNQ
     end
 
 
-    def bind(endpoint)
+    def bind(endpoint, **opts)
       ensure_parent_task
-      Reactor.run { @engine.bind(endpoint) }
+      Reactor.run { @engine.bind(endpoint, **opts) }
     end
 
 
-    def connect(endpoint)
+    def connect(endpoint, **opts)
       ensure_parent_task
-      Reactor.run { @engine.connect(endpoint) }
+      Reactor.run { @engine.connect(endpoint, **opts) }
     end
 
 
@@ -140,16 +135,21 @@ module NNQ
     end
 
 
-    # Coerces +body+ to a frozen binary string. Called by every send
-    # method so a caller can't mutate the string after it's been
-    # enqueued (the body sits in a send queue or per-peer queue until
-    # the pump writes it, and an unfrozen caller-owned buffer could be
-    # appended to mid-flight).
+    # Coerces +body+ to a frozen `Encoding::BINARY`-tagged String and
+    # returns it. Every send method runs its body through this so the
+    # receiver sees a uniform frozen+BINARY contract across transports
+    # (mutation bugs raise `FrozenError` instead of silently corrupting
+    # a shared reference on the inproc fast path).
     #
-    # Fast-path: already frozen + binary → returned as-is.
-    def frozen_binary(body)
-      return body if body.frozen? && body.encoding == Encoding::BINARY
-      body.b.freeze
+    # Fast-path: unfrozen non-BINARY strings are re-tagged in place
+    # (force_encoding is a flag flip, no copy). The pathological case
+    # of a frozen non-BINARY body (e.g. a `# frozen_string_literal: true`
+    # literal) can't be re-tagged in place — the inproc {Pipe} handles
+    # that with a copy so the receive contract stays uniform.
+    def coerce_binary(body)
+      body = body.to_str unless body.is_a?(String)
+      body.force_encoding(Encoding::BINARY) unless body.frozen? || body.encoding == Encoding::BINARY
+      body.freeze
     end
 
 

data/lib/nnq/surveyor_respondent.rb

@@ -16,7 +16,7 @@ module NNQ
     # Cooked: broadcasts +body+ as a survey to all connected respondents.
     def send_survey(body)
       raise Error, "SURVEYOR#send_survey not available in raw mode" if raw?
-      body = frozen_binary(body)
+      body = coerce_binary(body)
       Reactor.run { @engine.routing.send_survey(body) }
     end
 
@@ -26,7 +26,7 @@ module NNQ
     # protocol-sp header kwarg — no concat). Raises in cooked mode.
     def send(body, header:)
       raise Error, "SURVEYOR#send not available in cooked mode" unless raw?
-      body = frozen_binary(body)
+      body = coerce_binary(body)
       Reactor.run { @engine.routing.send(body, header: header) }
     end
 
@@ -70,7 +70,7 @@ module NNQ
     # recent survey. Raises in raw mode.
     def send_reply(body)
       raise Error, "RESPONDENT#send_reply not available in raw mode" if raw?
-      body = frozen_binary(body)
+      body = coerce_binary(body)
       Reactor.run { @engine.routing.send_reply(body) }
     end
 
@@ -78,7 +78,7 @@ module NNQ
     # Raw: writes +body+ with +header+ back to +to+. Raises in cooked mode.
     def send(body, to:, header:)
       raise Error, "RESPONDENT#send not available in cooked mode" unless raw?
-      body = frozen_binary(body)
+      body = coerce_binary(body)
       Reactor.run { @engine.routing.send(body, to: to, header: header) }
     end
 

data/lib/nnq/transport/inproc/pipe.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module NNQ
+  module Transport
+    module Inproc
+      # Queue-based in-process pipe. Duck-types {NNQ::Connection} so
+      # routing strategies, the recv loop, and the send pump work
+      # against it unchanged.
+      #
+      # No wire framing: bodies are transferred as frozen Strings
+      # through a pair of {Async::Queue} (one per direction). When an
+      # SP backtrace header is supplied (REQ/REP/SURVEYOR paths), it's
+      # prepended before enqueue so {#receive_message} returns an
+      # already-prefixed body — matching the TCP/IPC framing semantic
+      # so routing's `parse_backtrace` parses the same layout either
+      # way.
+      #
+      # Direct-recv fast path: when a routing strategy calls
+      # {#wire_direct_recv} on the peer side of a pipe pair, subsequent
+      # {#send_message} calls enqueue straight into the consumer's
+      # recv queue — the intermediate pipe queue and the recv pump
+      # fiber are both skipped. Cuts three fiber hops to one and is
+      # what lets inproc PUSH/PULL clear 1M msg/s on YJIT.
+      #
+      # Wiring happens synchronously inside {Transport::Inproc.connect}
+      # (before the call returns to the caller), so there's no window
+      # in which a send can precede a wire — no pending buffer needed.
+      #
+      # Close protocol: {#close} enqueues a `nil` sentinel onto the
+      # send side (or the direct queue if wired). The peer's recv loop
+      # sees `nil`, raises `EOFError`, and unwinds via its connection
+      # supervisor.
+      class Pipe
+        # @return [String, nil] endpoint URI this pipe was established on
+        attr_reader :endpoint
+
+        # @return [Pipe, nil] the other end of the pair
+        attr_accessor :peer
+
+        # @return [Async::Queue, nil] when non-nil, {#send_message}
+        #   enqueues here instead of into @send_queue.
+        attr_reader :direct_recv_queue
+
+
+        def initialize(send_queue:, recv_queue:, endpoint:)
+          @send_queue            = send_queue
+          @recv_queue            = recv_queue
+          @endpoint              = endpoint
+          @closed                = false
+          @peer                  = nil
+          @direct_recv_queue     = nil
+          @direct_recv_transform = nil
+        end
+
+
+        # Wires the direct-recv fast path. After this call, messages
+        # sent on this pipe bypass the intermediate pipe queue and
+        # land directly in +queue+.
+        #
+        # @param queue [Async::Queue]
+        # @param transform [Proc, nil] optional per-message transform;
+        #   return nil to drop the message (used by filter/parse
+        #   strategies like SUB or REP).
+        def wire_direct_recv(queue, transform)
+          @direct_recv_transform = transform
+          @direct_recv_queue     = queue
+        end
+
+
+        def send_message(body, header: nil)
+          raise ClosedError, "connection closed" if @closed
+
+          # Socket#coerce_binary tags mutable bodies BINARY in place;
+          # the pathological case of a frozen non-BINARY body (e.g. a
+          # `# frozen_string_literal: true` literal) can't be re-tagged
+          # in place, so copy it here to keep the receiver contract
+          # uniform with TCP/IPC.
+          body = body.b.freeze if body.encoding != Encoding::BINARY
+          wire = header ? (header + body).freeze : body
+
+          if (q = @direct_recv_queue)
+            item = @direct_recv_transform ? @direct_recv_transform.call(wire) : wire
+            q.enqueue(item) unless item.nil?
+          else
+            @send_queue.enqueue(wire)
+          end
+        end
+
+
+        alias write_message send_message
+
+
+        def write_messages(bodies)
+          raise ClosedError, "connection closed" if @closed
+
+          if bodies.any? { |b| b.encoding != Encoding::BINARY }
+            bodies = bodies.map { |b| b.encoding == Encoding::BINARY ? b : b.b.freeze }
+          end
+
+          if (q = @direct_recv_queue)
+            transform = @direct_recv_transform
+            bodies.each do |body|
+              item = transform ? transform.call(body) : body
+              q.enqueue(item) unless item.nil?
+            end
+          else
+            bodies.each { |body| @send_queue.enqueue(body) }
+          end
+        end
+
+
+        # No-op — Async::Queue has no IO buffer to flush.
+        def flush
+          nil
+        end
+
+
+        def receive_message
+          item = @recv_queue.dequeue
+          raise EOFError, "connection closed" if item.nil?
+          item
+        end
+
+
+        def closed?
+          @closed
+        end
+
+
+        def close
+          return if @closed
+          @closed = true
+          # Close sentinel goes on whichever queue the peer is reading.
+          # When direct-wired, @send_queue is unused; hit the direct
+          # queue so the consumer unblocks.
+          (@direct_recv_queue || @send_queue).enqueue(nil)
+        end
+
+      end
+    end
+  end
+end

data/lib/nnq/transport/inproc.rb

@@ -1,21 +1,24 @@
 # frozen_string_literal: true
 
-require "socket"
-require "io/stream"
+require "async/queue"
+
+require_relative "inproc/pipe"
 
 module NNQ
   module Transport
     # In-process transport. Both peers live in the same process and
-    # exchange frames over a Unix socketpair — no network, no address.
+    # exchange frozen Strings through a pair of {Async::Queue}s — no
+    # wire framing, no socketpair, no SP handshake.
     #
-    # Unlike omq's DirectPipe, inproc here still runs through
-    # Protocol::SP: the socketpair just replaces TCP. Kernel buffering
-    # across the pair is plenty to avoid contention for typical
-    # in-process message sizes, and reusing the SP handshake + framing
-    # keeps the transport ~40 LOC instead of a parallel Connection
-    # implementation.
+    # The historical implementation ran through a Unix `socketpair(2)`
+    # and the full SP protocol, making inproc roughly as expensive as
+    # IPC. Swapping to {Inproc::Pipe} (duck-types {NNQ::Connection})
+    # drops the kernel buffer copy, the framing encode/decode, and the
+    # handshake — inproc becomes a pure in-process queue transfer.
     #
     module Inproc
+      Engine.transports["inproc"] = self
+
       @registry = {}
       @mutex    = Mutex.new
 
@@ -26,7 +29,7 @@ module NNQ
         # @param endpoint [String] e.g. "inproc://my-endpoint"
         # @param engine [Engine]
         # @return [Listener]
-        def bind(endpoint, engine)
+        def bind(endpoint, engine, **)
           @mutex.synchronize do
             raise Error, "inproc endpoint already bound: #{endpoint}" if @registry.key?(endpoint)
             @registry[endpoint] = engine
@@ -36,28 +39,27 @@ module NNQ
         end
 
 
-        # Connects +engine+ to a bound inproc endpoint. Creates a Unix
-        # socketpair, hands one side to the bound engine (accepted),
-        # the other to the connecting engine (connected). Both sides
-        # run the normal SP handshake concurrently.
+        # Connects +engine+ to a bound inproc endpoint. Creates a Pipe
+        # pair — one queue per direction — and registers each side with
+        # its owning engine via {Engine#connection_ready}. No handshake
+        # runs; both ends are live as soon as the pipes are wired.
         #
         # @param endpoint [String]
         # @param engine [Engine]
         # @return [void]
-        def connect(endpoint, engine)
+        def connect(endpoint, engine, **)
           bound = @mutex.synchronize { @registry[endpoint] }
           raise Error, "inproc endpoint not bound: #{endpoint}" unless bound
 
-          a, b = UNIXSocket.pair
+          a_to_b = Async::Queue.new
+          b_to_a = Async::Queue.new
+          client = Pipe.new(send_queue: a_to_b, recv_queue: b_to_a, endpoint: endpoint)
+          server = Pipe.new(send_queue: b_to_a, recv_queue: a_to_b, endpoint: endpoint)
+          client.peer = server
+          server.peer = client
 
-          # Handshake on the bound side must run concurrently with
-          # ours — if we called bound.handle_accepted synchronously
-          # it would block on reading our greeting before we've had
-          # a chance to write it.
-          bound.spawn_task(annotation: "nnq inproc accept #{endpoint}") do
-            bound.handle_accepted(IO::Stream::Buffered.wrap(b), endpoint: endpoint)
-          end
-          engine.handle_connected(IO::Stream::Buffered.wrap(a), endpoint: endpoint)
+          bound.connection_ready(server, endpoint: endpoint)
+          engine.connection_ready(client, endpoint: endpoint)
         end
 
 
@@ -84,7 +86,7 @@ module NNQ
         end
 
 
-        # No accept loop: inproc connects synchronously.
+        # No accept loop: inproc connects are fully synchronous.
         def start_accept_loop(_parent_task, &_on_accepted)
         end
 

data/lib/nnq/transport/ipc.rb

@@ -13,13 +13,16 @@ module NNQ
     # verbatim.
     #
     module IPC
+      Engine.transports["ipc"] = self
+
+
       class << self
         # Binds an IPC server.
         #
         # @param endpoint [String] e.g. "ipc:///tmp/nnq.sock" or "ipc://@abstract"
         # @param engine [Engine]
         # @return [Listener]
-        def bind(endpoint, engine)
+        def bind(endpoint, engine, **)
           path      = parse_path(endpoint)
           sock_path = to_socket_path(path)
 
@@ -35,7 +38,7 @@ module NNQ
         # @param endpoint [String]
         # @param engine [Engine]
         # @return [void]
-        def connect(endpoint, engine)
+        def connect(endpoint, engine, **)
           path      = parse_path(endpoint)
           sock_path = to_socket_path(path)
           sock      = UNIXSocket.new(sock_path)

data/lib/nnq/transport/tcp.rb

@@ -11,13 +11,16 @@ module NNQ
     # accept inside an Async fiber.
     #
     module TCP
+      Engine.transports["tcp"] = self
+
+
       class << self
         # Binds a TCP server to +endpoint+.
         #
         # @param endpoint [String] e.g. "tcp://127.0.0.1:5570" or "tcp://127.0.0.1:0"
         # @param engine [Engine]
         # @return [Listener]
-        def bind(endpoint, engine)
+        def bind(endpoint, engine, **)
           host, port = parse_endpoint(endpoint)
           host       = "0.0.0.0" if host == "*"
           server     = TCPServer.new(host, port)
@@ -34,7 +37,7 @@ module NNQ
         # @param endpoint [String]
         # @param engine [Engine]
         # @return [void]
-        def connect(endpoint, engine)
+        def connect(endpoint, engine, **)
           host, port = parse_endpoint(endpoint)
           sock       = ::Socket.tcp(host, port, connect_timeout: connect_timeout(engine.options))
 

data/lib/nnq/version.rb

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

data/lib/nnq.rb

@@ -1,23 +1,24 @@
 # frozen_string_literal: true
 
 require "protocol/sp"
+require "io/stream"
 
-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
 
+# Core
 require_relative "nnq/version"
-require_relative "nnq/error"
+require_relative "nnq/constants"
+require_relative "nnq/reactor"
 require_relative "nnq/options"
+require_relative "nnq/error"
 require_relative "nnq/connection"
 require_relative "nnq/engine"
+
+# Transport
+require_relative "nnq/transport/inproc"
+require_relative "nnq/transport/tcp"
+require_relative "nnq/transport/ipc"
+
+# Socket types
 require_relative "nnq/socket"
 require_relative "nnq/push_pull"
 require_relative "nnq/pair"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nnq
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.8.1
 platform: ruby
 authors:
 - Patrik Wenger
@@ -41,16 +41,16 @@ dependencies:
   name: protocol-sp
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: '0.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: '0.4'
 description: Pure Ruby implementation of nanomsg's Scalability Protocols (SP) on top
   of async + io-stream. Per-socket HWM, opportunistic batching, wire-compatible with
   libnng over inproc/ipc/tcp.
@@ -66,12 +66,12 @@ files:
 - lib/nnq.rb
 - lib/nnq/bus.rb
 - lib/nnq/connection.rb
+- lib/nnq/constants.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
@@ -97,6 +97,7 @@ files:
 - lib/nnq/socket.rb
 - lib/nnq/surveyor_respondent.rb
 - lib/nnq/transport/inproc.rb
+- lib/nnq/transport/inproc/pipe.rb
 - lib/nnq/transport/ipc.rb
 - lib/nnq/transport/tcp.rb
 - lib/nnq/version.rb