omq 0.23.0 → 0.26.2

data/lib/omq/routing/xsub.rb

@@ -43,7 +43,7 @@ module OMQ
       end
 
 
-      # @param connection [Connection]
+      # @param connection [Protocol::ZMTP::Connection]
       #
       def connection_added(connection)
         @connections << connection
@@ -56,7 +56,7 @@ module OMQ
       end
 
 
-      # @param connection [Connection]
+      # @param connection [Protocol::ZMTP::Connection]
       #
       def connection_removed(connection)
         @connections.delete(connection)

data/lib/omq/socket.rb

@@ -36,7 +36,7 @@ module OMQ
 
 
     # @return [Engine] the socket's engine. Exposed for peer tooling
-    #   (omq-cli, omq-ffi, omq-ractor) that needs to reach into the
+    #   (omq-cli, omq-ractor) that needs to reach into the
     #   socket's internals — not part of the stable user API.
     #
     attr_reader :engine
@@ -318,6 +318,7 @@ module OMQ
       when nil, :ruby
         Engine.new(socket_type, @options)
       when :ffi
+        require "omq/ffi" unless defined?(FFI::Engine)
         FFI::Engine.new(socket_type, @options)
       else
         raise ArgumentError, "unknown backend: #{backend}"

data/lib/omq/transport/inproc/{direct_pipe.rb → pipe.rb}

@@ -14,7 +14,7 @@ module OMQ
       # This reduces inproc from 3 queue hops to 2 (send_queue →
       # recv_queue), eliminating the internal pipe queue in between.
       #
-      class DirectPipe
+      class Pipe
         # @return [String] peer's socket type
         #
         attr_reader :peer_socket_type
@@ -39,7 +39,7 @@ module OMQ
         attr_reader :peer_identity
 
 
-        # @return [DirectPipe, nil] the other end of this pipe pair
+        # @return [Pipe, nil] the other end of this pipe pair
         #
         attr_accessor :peer
 
@@ -85,6 +85,7 @@ module OMQ
         def wire_direct_recv(queue, transform)
           @direct_recv_transform = transform
           @direct_recv_queue     = queue
+
           return unless @pending_direct
 
           @pending_direct.each { |msg| queue.enqueue(msg) }
@@ -99,6 +100,20 @@ module OMQ
         #
         def send_message(parts)
           raise IOError, "closed" if @closed
+
+          # Writable#send guarantees frozen parts, but a frozen non-BINARY
+          # part (e.g. a `# frozen_string_literal: true` literal) can't be
+          # re-tagged in place. Inproc receivers see the parts directly, so
+          # upgrade that one case to fresh BINARY copies to keep the
+          # receive contract uniform with TCP/IPC.
+          #
+          # Non-String parts pass through untouched — plugins like
+          # omq-ractor's ShareableConnection carry arbitrary Ruby objects
+          # over inproc.
+          if parts.any? { |p| p.is_a?(String) && p.encoding != Encoding::BINARY }
+            parts = parts.map { |p| !p.is_a?(String) || p.encoding == Encoding::BINARY ? p : p.b.freeze }.freeze
+          end
+
           if @direct_recv_queue
             @direct_recv_queue.enqueue(apply_transform(parts))
           elsif @send_queue
@@ -114,7 +129,7 @@ module OMQ
 
         # Batched form, for parity with Protocol::ZMTP::Connection. The
         # work-stealing pumps call this when they dequeue more than one
-        # message at once; DirectPipe just loops — no mutex to amortize.
+        # message at once; Pipe just loops — no mutex to amortize.
         #
         # @param messages [Array<Array<String>>]
         # @return [void]
@@ -147,14 +162,13 @@ module OMQ
         #
         def receive_message
           loop do
-            item = @receive_queue.dequeue
-
-            raise EOFError, "connection closed" if item.nil?
+            item = @receive_queue.dequeue or raise EOFError, "connection closed"
 
             if item.is_a?(Array) && item.first == :command
               if block_given?
                 yield Protocol::ZMTP::Codec::Frame.new(item[1].to_body, command: true)
               end
+
               next
             end
 
@@ -181,8 +195,7 @@ module OMQ
         # @return [Protocol::ZMTP::Codec::Frame]
         #
         def read_frame
-          item = @receive_queue.dequeue
-          raise EOFError, "connection closed" if item.nil?
+          item = @receive_queue.dequeue or raise EOFError, "connection closed"
 
           if item.is_a?(Array) && item.first == :command
             Protocol::ZMTP::Codec::Frame.new(item[1].to_body, command: true)
@@ -208,7 +221,7 @@ module OMQ
 
         def apply_transform(parts)
           if @direct_recv_transform
-            @direct_recv_transform.call(parts).freeze
+            @direct_recv_transform.call(parts)
           else
             parts
           end

data/lib/omq/transport/inproc.rb

@@ -2,7 +2,7 @@
 
 require "async"
 require "async/queue"
-require_relative "inproc/direct_pipe"
+require_relative "inproc/pipe"
 
 module OMQ
   module Transport
@@ -11,8 +11,8 @@ module OMQ
     # Both peers are Ruby backend sockets in the same process (native
     # ZMQ's inproc registry is separate and unreachable). Messages are
     # transferred as Ruby arrays — no ZMTP framing, no byte
-    # serialization. String parts are frozen by Writable#send to
-    # prevent shared mutable state without copying.
+    # serialization. Parts are already frozen by Writable#send, so the
+    # receiver sees the same immutable contract as ZMTP transports.
     #
     module Inproc
       Engine.transports["inproc"] = self
@@ -122,8 +122,8 @@ module OMQ
         end
 
 
-        # Decides whether a DirectPipe pair needs command queues.
-        # DirectPipe's fast path skips queues entirely; command queues
+        # Decides whether a Pipe pair needs command queues.
+        # Pipe's fast path skips queues entirely; command queues
         # are only needed for socket types that exchange ZMTP commands
         # (e.g. ROUTER/DEALER identity, PUB/SUB subscriptions) or when
         # either side enables QoS ≥ 1.
@@ -132,16 +132,28 @@ module OMQ
         #
         def needs_commands?(ce, se, ct, st)
           return true if COMMAND_TYPES.include?(ct) || COMMAND_TYPES.include?(st)
-          return true if ce.options.qos >= 1 || se.options.qos >= 1
+          return true if qos_enabled?(ce.options) || qos_enabled?(se.options)
           false
         end
 
 
-        # Builds a bidirectional {DirectPipe} pair for client + server.
+        # QoS integration: core +Options#qos+ defaults to Integer +0+.
+        # When the omq-qos extension is loaded, +#qos+ holds either
+        # +nil+ (QoS 0) or an +OMQ::QoS+ instance (levels 1–3). Treat
+        # both Integer 0 and nil as disabled.
+        def qos_enabled?(options)
+          q = options.qos
+          return false if q.nil?
+          return q != 0 if q.is_a?(Integer)
+          true
+        end
+
+
+        # Builds a bidirectional {Pipe} pair for client + server.
         # When +needs_cmds+ is false the pipes have no command queues
         # (fast path — all traffic bypasses Async::Queue entirely).
         #
-        # @return [Array(DirectPipe, DirectPipe)] client, server
+        # @return [Array(Pipe, Pipe)] client, server
         #
         def make_pipe_pair(ce, se, ct, st, needs_cmds)
           if needs_cmds
@@ -149,12 +161,12 @@ module OMQ
             b_to_a = Async::Queue.new
           end
 
-          client = DirectPipe.new(send_queue: needs_cmds ? a_to_b : nil,
-                                  receive_queue: needs_cmds ? b_to_a : nil,
-                                  peer_identity: se.options.identity, peer_type: st.to_s)
-          server = DirectPipe.new(send_queue: needs_cmds ? b_to_a : nil,
-                                  receive_queue: needs_cmds ? a_to_b : nil,
-                                  peer_identity: ce.options.identity, peer_type: ct.to_s)
+          client = Pipe.new(send_queue: needs_cmds ? a_to_b : nil,
+                            receive_queue: needs_cmds ? b_to_a : nil,
+                            peer_identity: se.options.identity, peer_type: st.to_s)
+          server = Pipe.new(send_queue: needs_cmds ? b_to_a : nil,
+                            receive_queue: needs_cmds ? a_to_b : nil,
+                            peer_identity: ce.options.identity, peer_type: ct.to_s)
 
           client.peer = server
           server.peer = client

data/lib/omq/transport/udp.rb

@@ -200,7 +200,7 @@ module OMQ
             next unless parts
             group, body = parts
             next unless @groups.include?(group.b)
-            return [group.b.freeze, body.b.freeze]
+            return [group, body]
           rescue IO::WaitReadable
             @socket.wait_readable
             retry

data/lib/omq/version.rb

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

data/lib/omq/writable.rb

@@ -9,19 +9,45 @@ module OMQ
     include QueueWritable
 
 
-    EMPTY_PART = "".b.freeze
-
-
     # Sends a message.
     #
-    # @param message [String, Array<String>] message parts
+    # Parts must be String-like (respond to `#to_str`). Use an empty
+    # string to send an empty frame — `nil` raises `NoMethodError` so
+    # accidental nils surface instead of silently producing a zero-byte
+    # frame. Invariants after `#send` returns:
+    #
+    # * every part is a frozen String
+    # * unfrozen String parts are re-tagged to `Encoding::BINARY` in
+    #   place (a flag flip, no copy)
+    # * the parts array (if the caller passed one) is frozen
+    #
+    # The receiver always gets frozen `BINARY`-tagged parts — on TCP/IPC
+    # via byteslice on the wire, on inproc via {Pipe#send_message} which
+    # duplicates the one pathological case (frozen non-BINARY parts) so
+    # the receiver sees BINARY like every other transport.
+    #
+    # @param message [String, #to_str, Array<String, #to_str>]
     # @return [self]
     # @raise [IO::TimeoutError] if write_timeout exceeded
+    # @raise [NoMethodError] if a part is not String-like
     #
     def send(message)
-      parts = freeze_message(message)
+      parts = message.is_a?(Array) ? message : [message]
+      raise ArgumentError, "message has no parts" if parts.empty?
+
+      parts = parts.map { |p| p.to_str } if parts.any? { |p| !p.is_a?(String) }
 
-      Reactor.run timeout: @options.write_timeout do |task|
+      parts.each do |part|
+        part.force_encoding(Encoding::BINARY) unless part.frozen? || part.encoding == Encoding::BINARY
+        part.freeze
+      end
+      parts.freeze
+
+      if @engine.on_io_thread?
+        Reactor.run(timeout: @options.write_timeout) { @engine.enqueue_send(parts) }
+      elsif (timeout = @options.write_timeout)
+        Async::Task.current.with_timeout(timeout, IO::TimeoutError) { @engine.enqueue_send(parts) }
+      else
         @engine.enqueue_send(parts)
       end
 
@@ -48,42 +74,5 @@ module OMQ
       true
     end
 
-
-    private
-
-
-    # Converts a message into a frozen array of frozen binary strings.
-    #
-    # @param message [String, Array<String>]
-    # @return [Array<String>] frozen array of frozen binary strings
-    #
-    def freeze_message(message)
-      parts = message.is_a?(Array) ? message : [message]
-      raise ArgumentError, "message has no parts" if parts.empty?
-
-      all_ready = parts.all? { |p| p.is_a?(String) && p.frozen? && p.encoding == Encoding::BINARY }
-
-      # Already a frozen array of frozen binary strings → return as-is.
-      return parts if all_ready && parts.frozen?
-
-      # Items are ready; just freeze the outer array.
-      return parts.freeze if all_ready
-
-      # Items need conversion. Mutate in place when we can.
-      if parts.frozen?
-        parts.map { |p| frozen_binary(p) }.freeze
-      else
-        parts.map! { |p| frozen_binary(p) }.freeze
-      end
-    end
-
-
-    def frozen_binary(obj)
-      return EMPTY_PART if obj.nil?
-      s = obj.to_s
-      return s if s.frozen? && s.encoding == Encoding::BINARY
-      s.b.freeze
-    end
-
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omq
 version: !ruby/object:Gem::Version
-  version: 0.23.0
+  version: 0.26.2
 platform: ruby
 authors:
 - Patrik Wenger
@@ -76,6 +76,9 @@ files:
 - lib/omq/engine/reconnect.rb
 - lib/omq/engine/recv_pump.rb
 - lib/omq/engine/socket_lifecycle.rb
+- lib/omq/ffi.rb
+- lib/omq/ffi/engine.rb
+- lib/omq/ffi/libzmq.rb
 - lib/omq/options.rb
 - lib/omq/pair.rb
 - lib/omq/peer.rb
@@ -114,7 +117,7 @@ files:
 - lib/omq/single_frame.rb
 - lib/omq/socket.rb
 - lib/omq/transport/inproc.rb
-- lib/omq/transport/inproc/direct_pipe.rb
+- lib/omq/transport/inproc/pipe.rb
 - lib/omq/transport/ipc.rb
 - lib/omq/transport/tcp.rb
 - lib/omq/transport/udp.rb