omq 0.5.0 → 0.6.0

data/lib/omq/zmtp/routing/scatter.rb

@@ -16,37 +16,44 @@ module OMQ
           init_round_robin(engine)
         end
 
+
         # @return [Async::LimitedQueue]
         #
         attr_reader :send_queue
 
+
         # SCATTER is write-only.
         #
         def recv_queue
           raise "SCATTER sockets cannot receive"
         end
 
+
         # @param connection [Connection]
         #
         def connection_added(connection)
           @connections << connection
           signal_connection_available
           start_send_pump unless @send_pump_started
-          start_monitor(connection)
+          start_reaper(connection)
         end
 
+
         # @param connection [Connection]
         #
         def connection_removed(connection)
           @connections.delete(connection)
         end
 
+
         # @param parts [Array<String>]
         #
         def enqueue(parts)
           @send_queue.enqueue(parts)
         end
 
+
+        # Stops all background tasks (send pump, reapers).
         #
         def stop
           @tasks.each(&:stop)
@@ -55,8 +62,14 @@ module OMQ
 
         private
 
-        def start_monitor(conn)
-          @tasks << Reactor.spawn_pump do
+
+        # Detects peer disconnection on write-only sockets by
+        # blocking on a receive that only returns on disconnect.
+        #
+        # @param conn [Connection]
+        #
+        def start_reaper(conn)
+          @tasks << Reactor.spawn_pump(annotation: "reaper") do
             conn.receive_message
           rescue *ZMTP::CONNECTION_LOST
             @engine.connection_lost(conn)

data/lib/omq/zmtp/routing/server.rb

@@ -21,6 +21,7 @@ module OMQ
           @connections_by_routing_id  = {}
           @tasks                      = []
           @send_pump_started          = false
+          @send_pump_idle             = true
         end
 
         # @return [Async::LimitedQueue]
@@ -59,15 +60,36 @@ module OMQ
 
         private
 
+        def send_pump_idle? = @send_pump_idle
+
+
         def start_send_pump
           @send_pump_started = true
-          @tasks << Reactor.spawn_pump do
+          @tasks << @engine.spawn_pump_task(annotation: "send pump") do
             loop do
-              parts      = @send_queue.dequeue
-              routing_id = parts.first
-              conn       = @connections_by_routing_id[routing_id]
-              next unless conn # silently drop if peer gone
-              conn.send_message(parts[1..])
+              @send_pump_idle = true
+              batch = [@send_queue.dequeue]
+              @send_pump_idle = false
+              Routing.drain_send_queue(@send_queue, batch)
+
+              written = Set.new
+              batch.each do |parts|
+                routing_id = parts.first
+                conn       = @connections_by_routing_id[routing_id]
+                next unless conn # silently drop if peer gone
+                begin
+                  conn.write_message(parts[1..])
+                  written << conn
+                rescue *ZMTP::CONNECTION_LOST
+                  # will be cleaned up
+                end
+              end
+
+              written.each do |conn|
+                conn.flush
+              rescue *ZMTP::CONNECTION_LOST
+                # will be cleaned up
+              end
             end
           end
         end

data/lib/omq/zmtp/routing/xsub.rb

@@ -19,6 +19,7 @@ module OMQ
           @send_queue        = Async::LimitedQueue.new(engine.options.send_hwm)
           @tasks             = []
           @send_pump_started = false
+          @send_pump_idle    = true
         end
 
         # @return [Async::LimitedQueue]
@@ -54,11 +55,16 @@ module OMQ
 
         private
 
+        def send_pump_idle? = @send_pump_idle
+
+
         def start_send_pump
           @send_pump_started = true
-          @tasks << Reactor.spawn_pump do
+          @tasks << @engine.spawn_pump_task(annotation: "send pump") do
             loop do
+              @send_pump_idle = true
               parts = @send_queue.dequeue
+              @send_pump_idle = false
               frame = parts.first&.b
               next if frame.nil? || frame.empty?
 

data/lib/omq/zmtp/routing.rb

@@ -12,6 +12,25 @@ module OMQ
     # the socket's send/recv queues.
     #
     module Routing
+      # Maximum messages to drain from the send queue per flush cycle.
+      MAX_SEND_BATCH = 64
+
+      # Drains up to +max+ additional messages from +queue+ into +batch+
+      # without blocking. Call after the initial blocking dequeue.
+      #
+      # @param queue [Async::LimitedQueue]
+      # @param batch [Array]
+      # @param max [Integer]
+      # @return [void]
+      #
+      def self.drain_send_queue(queue, batch, max = MAX_SEND_BATCH)
+        while batch.size < max
+          msg = queue.dequeue(timeout: 0)
+          break unless msg
+          batch << msg
+        end
+      end
+
       # Returns the routing strategy class for a socket type.
       #
       # @param socket_type [Symbol] e.g. :PAIR, :REQ

data/lib/omq/zmtp/transport/inproc.rb

@@ -46,6 +46,7 @@ module OMQ
             Listener.new(endpoint)
           end
 
+
           # Connects to a bound inproc endpoint.
           #
           # @param endpoint [String] e.g. "inproc://my-endpoint"
@@ -76,6 +77,7 @@ module OMQ
             establish_link(engine, bound_engine, endpoint)
           end
 
+
           # Removes a bound endpoint from the registry.
           #
           # @param endpoint [String]
@@ -85,6 +87,7 @@ module OMQ
             @mutex.synchronize { @registry.delete(endpoint) }
           end
 
+
           # Resets the registry. Used in tests.
           #
           # @return [void]
@@ -96,8 +99,17 @@ module OMQ
             end
           end
 
+
           private
 
+
+          # Wires up a client-server inproc pipe pair after validating
+          # that the two socket types are compatible.
+          #
+          # @param client_engine [Engine] the connecting engine
+          # @param server_engine [Engine] the bound engine
+          # @param endpoint [String] the inproc endpoint name
+          #
           def establish_link(client_engine, server_engine, endpoint)
             client_type = client_engine.socket_type
             server_type = server_engine.socket_type
@@ -138,8 +150,15 @@ module OMQ
             server_engine.connection_ready(server_pipe, endpoint: endpoint)
           end
 
+
+          # Spawns a background task that periodically retries
+          # #establish_link until the endpoint appears in the registry.
+          #
+          # @param endpoint [String] the inproc endpoint name
+          # @param engine [Engine] the connecting engine
+          #
           def start_connect_retry(endpoint, engine)
-            Reactor.spawn_pump do
+            Reactor.spawn_pump(annotation: "reconnect") do
               ri  = engine.options.reconnect_interval
               ivl = ri.is_a?(Range) ? ri.begin : ri
               loop do
@@ -161,12 +180,14 @@ module OMQ
           #
           attr_reader :endpoint
 
+
           # @param endpoint [String]
           #
           def initialize(endpoint)
             @endpoint = endpoint
           end
 
+
           # Stops the listener by removing it from the registry.
           #
           # @return [void]
@@ -183,32 +204,38 @@ module OMQ
         #
         # When a routing strategy sets {#direct_recv_queue} on a pipe,
         # {#send_message} enqueues directly into the peer's recv queue,
-        # bypassing the intermediate internal queues and the recv pump
-        # task entirely.  This reduces inproc from 3 queue hops to 1.
+        # bypassing the intermediate pipe queues and the recv pump task.
+        # This reduces inproc from 3 queue hops to 2 (send_queue →
+        # recv_queue), eliminating the internal pipe queue in between.
         #
         class DirectPipe
           # @return [String] peer's socket type
           #
           attr_reader :peer_socket_type
 
+
           # @return [String] peer's identity
           #
           attr_reader :peer_identity
 
+
           # @return [DirectPipe, nil] the other end of this pipe pair
           #
           attr_accessor :peer
 
+
           # @return [Async::LimitedQueue, nil] when set, {#send_message}
           #   enqueues directly here instead of using the internal queue
           #
           attr_reader :direct_recv_queue
 
+
           # @return [Proc, nil] optional transform applied before
           #   enqueuing into {#direct_recv_queue}
           #
           attr_accessor :direct_recv_transform
 
+
           # @param send_queue [Async::Queue, nil] outgoing command queue
           #   (nil for non-PUB/SUB types that don't exchange commands)
           # @param receive_queue [Async::Queue, nil] incoming command queue
@@ -227,6 +254,7 @@ module OMQ
             @pending_direct        = nil
           end
 
+
           # Sets the direct recv queue. Drains any messages that were
           # buffered before the queue was available.
           #
@@ -240,6 +268,7 @@ module OMQ
             end
           end
 
+
           # Sends a multi-frame message.
           #
           # When {#direct_recv_queue} is set (inproc fast path), the
@@ -252,16 +281,27 @@ module OMQ
           def send_message(parts)
             raise IOError, "closed" if @closed
             if @direct_recv_queue
-              msg = @direct_recv_transform ? @direct_recv_transform.call(parts) : parts
+              msg = @direct_recv_transform ? @direct_recv_transform.call(parts).freeze : parts
               @direct_recv_queue.enqueue(msg)
             elsif @send_queue
               @send_queue.enqueue(parts)
             else
-              msg = @direct_recv_transform ? @direct_recv_transform.call(parts) : parts
+              msg = @direct_recv_transform ? @direct_recv_transform.call(parts).freeze : parts
               (@pending_direct ||= []) << msg
             end
           end
 
+
+          alias write_message send_message
+
+
+          # No-op — inproc has no IO buffer to flush.
+          #
+          # @return [void]
+          #
+          def flush = nil
+
+
           # Receives a multi-frame message.
           #
           # @return [Array<String>]
@@ -273,6 +313,7 @@ module OMQ
             msg
           end
 
+
           # Sends a command via the internal command queue.
           # Only available for PUB/SUB-family pipes.
           #
@@ -284,6 +325,7 @@ module OMQ
             @send_queue.enqueue([:command, command])
           end
 
+
           # Reads one command frame from the internal command queue.
           # Used by PUB/XPUB subscription listeners.
           #
@@ -300,6 +342,7 @@ module OMQ
             end
           end
 
+
           # Closes this pipe end.
           #
           # @return [void]

data/lib/omq/zmtp/transport/ipc.rb

@@ -28,16 +28,11 @@ module OMQ
 
             server = UNIXServer.new(sock_path)
 
-            accept_task = Reactor.spawn_pump do
+            accept_task = Reactor.spawn_pump(annotation: "ipc accept #{endpoint}") do
               loop do
                 client = server.accept
-                Reactor.run do
+                Async::Task.current.defer_stop do
                   engine.handle_accepted(IO::Stream::Buffered.wrap(client), endpoint: endpoint)
-                rescue ProtocolError, *ZMTP::CONNECTION_LOST
-                  # peer disconnected during handshake
-                rescue
-                  client&.close rescue nil
-                  raise
                 end
               end
             rescue IOError
@@ -92,6 +87,12 @@ module OMQ
           #
           attr_reader :endpoint
 
+
+          # @param endpoint [String] the IPC endpoint URI
+          # @param server [UNIXServer]
+          # @param accept_task [#stop] the accept loop handle
+          # @param path [String] filesystem or abstract namespace path
+          #
           def initialize(endpoint, server, accept_task, path)
             @endpoint = endpoint
             @server = server
@@ -99,6 +100,7 @@ module OMQ
             @path = path
           end
 
+
           # Stops the listener.
           #
           def stop

data/lib/omq/zmtp/transport/tcp.rb

@@ -25,16 +25,11 @@ module OMQ
             host_part   = host.include?(":") ? "[#{host}]" : host
             resolved    = "tcp://#{host_part}:#{actual_port}"
 
-            accept_task = Reactor.spawn_pump do
+            accept_task = Reactor.spawn_pump(annotation: "tcp accept #{resolved}") do
               loop do
                 client = server.accept
-                Reactor.run do
+                Async::Task.current.defer_stop do
                   engine.handle_accepted(IO::Stream::Buffered.wrap(client), endpoint: resolved)
-                rescue ProtocolError, *ZMTP::CONNECTION_LOST
-                  # peer disconnected during handshake
-                rescue
-                  client&.close rescue nil
-                  raise
                 end
               end
             rescue IOError
@@ -58,6 +53,11 @@ module OMQ
 
           private
 
+          # Parses a TCP endpoint URI into host and port.
+          #
+          # @param endpoint [String]
+          # @return [Array(String, Integer)]
+          #
           def parse_endpoint(endpoint)
             uri = URI.parse(endpoint)
             [uri.hostname, uri.port]
@@ -75,6 +75,12 @@ module OMQ
           #
           attr_reader :port
 
+
+          # @param endpoint [String] resolved endpoint URI
+          # @param server [TCPServer]
+          # @param accept_task [#stop] the accept loop handle
+          # @param port [Integer] bound port number
+          #
           def initialize(endpoint, server, accept_task, port)
             @endpoint    = endpoint
             @server      = server
@@ -82,6 +88,7 @@ module OMQ
             @port        = port
           end
 
+
           # Stops the listener.
           #
           def stop

data/lib/omq/zmtp/writable.rb

@@ -14,10 +14,7 @@ module OMQ
       # @raise [IO::TimeoutError] if write_timeout exceeded
       #
       def send(message)
-        parts = message.is_a?(Array) ? message : [message]
-        raise ArgumentError, "message has no parts" if parts.empty?
-        parts = parts.map { |p| p.b.freeze }
-
+        parts = freeze_message(message)
         with_timeout(@options.write_timeout) { @engine.enqueue_send(parts) }
         self
       end
@@ -31,6 +28,26 @@ module OMQ
         send(message)
       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?
+        if parts.frozen?
+          parts = parts.map { |p| p.to_str.b.freeze }
+        else
+          parts.map! { |p| p.to_str.b.freeze }
+        end
+        parts.freeze
+      end
+
+      public
+
       # Waits until the socket is writable.
       #
       # @param timeout [Numeric, nil] timeout in seconds

data/lib/omq.rb

@@ -10,6 +10,13 @@
 #
 
 require_relative "omq/version"
+
+module OMQ
+  # Raised when an internal pump task crashes unexpectedly.
+  # The socket is no longer usable; the original error is available via #cause.
+  #
+  class SocketDeadError < RuntimeError; end
+end
 require_relative "omq/zmtp"
 require_relative "omq/socket"
 require_relative "omq/req_rep"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omq
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Patrik Wenger
@@ -42,16 +42,31 @@ description: Pure Ruby implementation of the ZMTP 3.1 wire protocol (ZeroMQ) usi
 email:
 - paddor@gmail.com
 executables:
-- omqcat
+- omq
 extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
 - LICENSE
 - README.md
-- exe/omqcat
+- exe/omq
 - lib/omq.rb
 - lib/omq/channel.rb
+- lib/omq/cli.rb
+- lib/omq/cli/base_runner.rb
+- lib/omq/cli/channel.rb
+- lib/omq/cli/client_server.rb
+- lib/omq/cli/config.rb
+- lib/omq/cli/formatter.rb
+- lib/omq/cli/pair.rb
+- lib/omq/cli/peer.rb
+- lib/omq/cli/pipe.rb
+- lib/omq/cli/pub_sub.rb
+- lib/omq/cli/push_pull.rb
+- lib/omq/cli/radio_dish.rb
+- lib/omq/cli/req_rep.rb
+- lib/omq/cli/router_dealer.rb
+- lib/omq/cli/scatter_gather.rb
 - lib/omq/client_server.rb
 - lib/omq/pair.rb
 - lib/omq/peer.rb