omq-cli 0.7.1 → 0.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a03141c60a8af670aa4de42bc5b5d286fbf3a975c5a455e9276bc2d4b87a0fb8
-  data.tar.gz: 2755cb1054df95a64b5faebe481e93ac2e3f391e878f54b5a30a17514dde399a
+  metadata.gz: 5af8706d0afd5ad199301ec7b37a47a232c5732a930eada3696a9f60a31aecc4
+  data.tar.gz: 6e5b15d9bb2af20181cccbc71d5b4d432938660a8e052d62598c18386ddf2a5d
 SHA512:
-  metadata.gz: f245e7f524d745382074347852f1d34e5e1f46e633fe024b7888c05942a399639e69e876ae92c5ace5172800b0dc6a3bd8cd088d3b52f389ea0fb212e0f8da58
-  data.tar.gz: 34992fe5962fd2639b0c3e92597e3d2d6a134f3ac4fecadfa3d64b1d566994cf9f8ef36ce08fc929ab97bfcf7a7b4dd7f9c1de241b8c87e2a207ce17a838c7d2
+  metadata.gz: 8d35e218e4327b8a0c22c6ce15d9d205f62feffeec2fa2afd21cda6fcef96724645ea76922f0d0dd67099883b2795a0443211bbabf729c4c857e77e1a3b4299b
+  data.tar.gz: 34af31e1dc6605c6b90bc7dcb3f519755d13a12e71f4417de7a5d07f71617610fc6d728f57f1be5f51bda6923d49fc1a6fc8cb1cbc6234d31c37ad392b8c3452

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 0.7.2 — 2026-04-07
+
+### Changed
+
+- **Cleaned up pipe.rb** — removed unused `@fmt` formatters, dead `log` method,
+  and `with_timeout` wrapper. Moved `preresolve_tcp` and `start_log_consumer` to
+  `PipeWorker` class methods.
+- **Guard `with_timeout(nil)`** — `Fiber.scheduler.with_timeout(nil)` fires
+  immediately in Async; peer-wait and pipe sequential mode now skip the timeout
+  wrapper when `config.timeout` is nil.
+
 ## 0.7.1 — 2026-04-07
 
 ### Fixed

data/lib/omq/cli/base_runner.rb

@@ -107,12 +107,18 @@ module OMQ
 
 
       def wait_for_peer
-        with_timeout(config.timeout) do
+        wait_body = proc do
           @sock.peer_connected.wait
           log "Peer connected"
           wait_for_subscriber
           apply_grace_period
         end
+
+        if config.timeout
+          Fiber.scheduler.with_timeout(config.timeout, &wait_body)
+        else
+          wait_body.call
+        end
       end
 
 
@@ -133,18 +139,6 @@ module OMQ
       end
 
 
-      # ── Timeout helper ──────────────────────────────────────────────
-
-
-      def with_timeout(seconds)
-        if seconds
-          Async::Task.current.with_timeout(seconds) { yield }
-        else
-          yield
-        end
-      end
-
-
       # ── Socket setup ────────────────────────────────────────────────
 
 

data/lib/omq/cli/pipe.rb

@@ -11,8 +11,7 @@ module OMQ
 
       # @param config [Config] frozen CLI configuration
       def initialize(config)
-        @config = config
-        @fmt    = Formatter.new(config.format, compress: config.compress)
+        @config  = config
         @fmt_in  = Formatter.new(config.format, compress: config.compress_in || config.compress)
         @fmt_out = Formatter.new(config.format, compress: config.compress_out || config.compress)
       end
@@ -43,30 +42,27 @@ module OMQ
       end
 
 
-      def attach_endpoints(sock, endpoints)
-        SocketSetup.attach_endpoints(sock, endpoints, verbose: config.verbose >= 1)
-      end
-
-
       # ── Sequential ───────────────────────────────────────────────────
 
 
       def run_sequential(task)
         in_eps, out_eps = resolve_endpoints
-        @pull, @push = build_pull_push(
-          { linger: config.linger, recv_timeout: config.timeout },
-          { linger: config.linger, send_timeout: config.timeout },
-          in_eps, out_eps
-        )
+        @pull, @push = build_pull_push(in_eps, out_eps)
         compile_expr
         @sock = @pull  # for eval instance_exec
         start_event_monitors if config.verbose >= 2
-        with_timeout(config.timeout) do
+        wait_body = proc do
           Barrier do |barrier|
             barrier.async(annotation: "wait push peer") { @push.peer_connected.wait }
             barrier.async(annotation: "wait pull peer") { @pull.peer_connected.wait }
           end
         end
+
+        if config.timeout
+          Fiber.scheduler.with_timeout(config.timeout, &wait_body)
+        else
+          wait_body.call
+        end
         setup_sequential_transient(task)
         @sock.instance_exec(&@recv_begin_proc) if @recv_begin_proc
         sequential_message_loop
@@ -87,13 +83,13 @@ module OMQ
       end
 
 
-      def build_pull_push(pull_opts, push_opts, in_eps, out_eps)
-        pull = OMQ::PULL.new(**pull_opts)
-        push = OMQ::PUSH.new(**push_opts)
+      def build_pull_push(in_eps, out_eps)
+        pull = OMQ::PULL.new(linger: config.linger, recv_timeout: config.timeout)
+        push = OMQ::PUSH.new(linger: config.linger, send_timeout: config.timeout)
         apply_socket_options(pull)
         apply_socket_options(push)
-        attach_endpoints(pull, in_eps)
-        attach_endpoints(push, out_eps)
+        SocketSetup.attach_endpoints(pull, in_eps, verbose: config.verbose >= 1)
+        SocketSetup.attach_endpoints(push, out_eps, verbose: config.verbose >= 1)
         [pull, push]
       end
 
@@ -117,8 +113,7 @@ module OMQ
           parts = @fmt_in.decompress(parts)
           parts = eval_recv_expr(parts)
           if parts && !parts.empty?
-            out = @fmt_out.compress(parts)
-            @push.send(out)
+            @push.send(@fmt_out.compress(parts))
           end
           i += 1
           break if n && n > 0 && i >= n
@@ -132,143 +127,26 @@ module OMQ
       def run_parallel(task)
         OMQ.freeze_for_ractors!
         in_eps, out_eps = resolve_endpoints
-        in_eps  = preresolve_tcp(in_eps)
-        out_eps = preresolve_tcp(out_eps)
-        workers = spawn_workers(config, in_eps, out_eps)
+        in_eps  = PipeWorker.preresolve_tcp(in_eps)
+        out_eps = PipeWorker.preresolve_tcp(out_eps)
+        log_port, log_thread = PipeWorker.start_log_consumer
+        workers = config.parallel.times.map do
+          ::Ractor.new(config, in_eps, out_eps, log_port) do |cfg, ins, outs, lport|
+            PipeWorker.new(cfg, ins, outs, lport).call
+          end
+        end
         workers.each do |w|
           w.join
         rescue ::Ractor::RemoteError => e
           $stderr.write("omq: Ractor error: #{e.cause&.message || e.message}\n")
         end
+      ensure
+        log_port.close
+        log_thread.join
       end
 
 
-      def spawn_workers(config, in_eps, out_eps)
-        config.parallel.times.map do
-          ::Ractor.new(config, in_eps, out_eps) do |cfg, ins, outs|
-            Async do
-              pull = OMQ::PULL.new(linger: cfg.linger)
-              push = OMQ::PUSH.new(linger: cfg.linger)
-              pull.recv_timeout      = cfg.timeout if cfg.timeout
-              push.send_timeout      = cfg.timeout if cfg.timeout
-              pull.reconnect_interval = cfg.reconnect_ivl if cfg.reconnect_ivl
-              push.reconnect_interval = cfg.reconnect_ivl if cfg.reconnect_ivl
-              pull.heartbeat_interval = cfg.heartbeat_ivl if cfg.heartbeat_ivl
-              push.heartbeat_interval = cfg.heartbeat_ivl if cfg.heartbeat_ivl
-              pull.send_hwm          = cfg.send_hwm if cfg.send_hwm
-              pull.recv_hwm          = cfg.recv_hwm if cfg.recv_hwm
-              push.send_hwm          = cfg.send_hwm if cfg.send_hwm
-              push.recv_hwm          = cfg.recv_hwm if cfg.recv_hwm
-              pull.sndbuf            = cfg.sndbuf if cfg.sndbuf
-              pull.rcvbuf            = cfg.rcvbuf if cfg.rcvbuf
-              push.sndbuf            = cfg.sndbuf if cfg.sndbuf
-              push.rcvbuf            = cfg.rcvbuf if cfg.rcvbuf
-
-              OMQ::CLI::SocketSetup.attach_endpoints(pull, ins, verbose: cfg.verbose >= 1)
-              OMQ::CLI::SocketSetup.attach_endpoints(push, outs, verbose: cfg.verbose >= 1)
-
-              Barrier do |barrier|
-                barrier.async { pull.peer_connected.wait }
-                barrier.async { push.peer_connected.wait }
-              end
-
-              begin_proc, end_proc, eval_proc =
-                OMQ::CLI::ExpressionEvaluator.compile_inside_ractor(cfg.recv_expr)
-
-              fmt_in  = OMQ::CLI::Formatter.new(cfg.format, compress: cfg.compress_in || cfg.compress)
-              fmt_out = OMQ::CLI::Formatter.new(cfg.format, compress: cfg.compress_out || cfg.compress)
-
-              _ctx = Object.new
-              _ctx.instance_exec(&begin_proc) if begin_proc
-
-              n_count = cfg.count
-              begin
-                if eval_proc
-                  if n_count && n_count > 0
-                    n_count.times do
-                      parts = pull.receive
-                      break if parts.nil?
-                      parts = OMQ::CLI::ExpressionEvaluator.normalize_result(
-                        _ctx.instance_exec(fmt_in.decompress(parts), &eval_proc)
-                      )
-                      next if parts.nil?
-                      push << fmt_out.compress(parts) unless parts.empty?
-                    end
-                  else
-                    loop do
-                      parts = pull.receive
-                      break if parts.nil?
-                      parts = OMQ::CLI::ExpressionEvaluator.normalize_result(
-                        _ctx.instance_exec(fmt_in.decompress(parts), &eval_proc)
-                      )
-                      next if parts.nil?
-                      push << fmt_out.compress(parts) unless parts.empty?
-                    end
-                  end
-                else
-                  if n_count && n_count > 0
-                    n_count.times do
-                      parts = pull.receive
-                      break if parts.nil?
-                      push << fmt_out.compress(fmt_in.decompress(parts))
-                    end
-                  else
-                    loop do
-                      parts = pull.receive
-                      break if parts.nil?
-                      push << fmt_out.compress(fmt_in.decompress(parts))
-                    end
-                  end
-                end
-              rescue IO::TimeoutError, Async::TimeoutError
-                # recv timed out — fall through to END block
-              end
-
-              if end_proc
-                out = OMQ::CLI::ExpressionEvaluator.normalize_result(
-                  _ctx.instance_exec(&end_proc)
-                )
-                push << fmt_out.compress(out) if out && !out.empty?
-              end
-            ensure
-              pull&.close
-              push&.close
-            end
-          end
-        end
-      end
-
-
-      # ── Shared helpers ────────────────────────────────────────────────
-
-
-      # Resolves TCP hostnames to IP addresses so Ractors don't touch
-      # Resolv::DefaultResolver (which is not shareable).
-      #
-      def preresolve_tcp(endpoints)
-        endpoints.flat_map do |ep|
-          url = ep.url
-          if url.start_with?("tcp://")
-            host, port = OMQ::Transport::TCP.parse_endpoint(url)
-            Addrinfo.getaddrinfo(host, port, nil, :STREAM).map do |addr|
-              ip = addr.ip_address
-              ip = "[#{ip}]" if ip.include?(":")
-              Endpoint.new("tcp://#{ip}:#{addr.ip_port}", ep.bind?)
-            end
-          else
-            ep
-          end
-        end
-      end
-
-
-      def with_timeout(seconds)
-        if seconds
-          Async::Task.current.with_timeout(seconds) { yield }
-        else
-          yield
-        end
-      end
+      # ── Expression eval ──────────────────────────────────────────────
 
 
       def compile_expr
@@ -285,9 +163,7 @@ module OMQ
       end
 
 
-      def log(msg)
-        $stderr.write("#{msg}\n") if config.verbose >= 1
-      end
+      # ── Event monitoring ─────────────────────────────────────────────
 
 
       def start_event_monitors

data/lib/omq/cli/pipe_worker.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+module OMQ
+  module CLI
+    # Worker that runs inside a Ractor for pipe -P parallel mode.
+    # Each worker owns its own Async reactor, PULL socket, and PUSH socket.
+    #
+    class PipeWorker
+      # Starts a Ractor::Port and a consumer thread that drains log
+      # messages to stderr sequentially. Returns [port, thread].
+      #
+      def self.start_log_consumer
+        port = Ractor::Port.new
+        thread = Thread.new(port) do |p|
+          loop do
+            $stderr.write("#{p.receive}\n")
+          rescue Ractor::ClosedError
+            break
+          end
+        end
+        [port, thread]
+      end
+
+
+      # Resolves TCP hostnames to IP addresses so Ractors don't touch
+      # Resolv::DefaultResolver (which is not shareable).
+      #
+      def self.preresolve_tcp(endpoints)
+        endpoints.flat_map do |ep|
+          url = ep.url
+          if url.start_with?("tcp://")
+            host, port = OMQ::Transport::TCP.parse_endpoint(url)
+            Addrinfo.getaddrinfo(host, port, nil, :STREAM).map do |addr|
+              ip = addr.ip_address
+              ip = "[#{ip}]" if ip.include?(":")
+              Endpoint.new("tcp://#{ip}:#{addr.ip_port}", ep.bind?)
+            end
+          else
+            ep
+          end
+        end
+      end
+
+
+      def initialize(config, in_eps, out_eps, log_port)
+        @config   = config
+        @in_eps   = in_eps
+        @out_eps  = out_eps
+        @log_port = log_port
+      end
+
+
+      def call
+        Async do
+          setup_sockets
+          log_endpoints if @config.verbose >= 1
+          start_monitors if @config.verbose >= 2
+          wait_for_peers
+          compile_expr
+          run_message_loop
+          run_end_block
+        ensure
+          @pull&.close
+          @push&.close
+        end
+      end
+
+
+      private
+
+
+      def setup_sockets
+        @pull = OMQ::PULL.new(linger: @config.linger)
+        @push = OMQ::PUSH.new(linger: @config.linger)
+        @pull.recv_timeout      = @config.timeout if @config.timeout
+        @push.send_timeout      = @config.timeout if @config.timeout
+        apply_socket_options(@pull)
+        apply_socket_options(@push)
+        OMQ::CLI::SocketSetup.attach_endpoints(@pull, @in_eps, verbose: false)
+        OMQ::CLI::SocketSetup.attach_endpoints(@push, @out_eps, verbose: false)
+      end
+
+
+      def apply_socket_options(sock)
+        sock.reconnect_interval = @config.reconnect_ivl if @config.reconnect_ivl
+        sock.heartbeat_interval = @config.heartbeat_ivl if @config.heartbeat_ivl
+        sock.send_hwm           = @config.send_hwm if @config.send_hwm
+        sock.recv_hwm           = @config.recv_hwm if @config.recv_hwm
+        sock.sndbuf             = @config.sndbuf if @config.sndbuf
+        sock.rcvbuf             = @config.rcvbuf if @config.rcvbuf
+      end
+
+
+      def log_endpoints
+        @in_eps.each { |ep| @log_port.send(ep.bind? ? "Bound to #{ep.url}" : "Connecting to #{ep.url}") }
+        @out_eps.each { |ep| @log_port.send(ep.bind? ? "Bound to #{ep.url}" : "Connecting to #{ep.url}") }
+      end
+
+
+      def start_monitors
+        trace = @config.verbose >= 3
+        [@pull, @push].each do |sock|
+          sock.monitor(verbose: trace) do |event|
+            @log_port.send(format_event(event))
+          end
+        end
+      end
+
+
+      def format_event(event)
+        case event.type
+        when :message_sent
+          "omq: >> #{msg_preview(event.detail[:parts])}"
+        when :message_received
+          "omq: << #{msg_preview(event.detail[:parts])}"
+        else
+          ep = event.endpoint ? " #{event.endpoint}" : ""
+          detail = event.detail ? " #{event.detail}" : ""
+          "omq: #{event.type}#{ep}#{detail}"
+        end
+      end
+
+
+      def msg_preview(parts)
+        parts.map { |p|
+          bytes = p.b
+          preview = bytes[0, 10].gsub(/[^[:print:]]/, ".")
+          bytes.bytesize > 10 ? "#{preview}... (#{bytes.bytesize}B)" : preview
+        }.join(" | ")
+      end
+
+
+      def wait_for_peers
+        Barrier do |barrier|
+          barrier.async { @pull.peer_connected.wait }
+          barrier.async { @push.peer_connected.wait }
+        end
+      end
+
+
+      def compile_expr
+        @begin_proc, @end_proc, @eval_proc =
+          OMQ::CLI::ExpressionEvaluator.compile_inside_ractor(@config.recv_expr)
+        @fmt_in  = OMQ::CLI::Formatter.new(@config.format, compress: @config.compress_in || @config.compress)
+        @fmt_out = OMQ::CLI::Formatter.new(@config.format, compress: @config.compress_out || @config.compress)
+        @ctx = Object.new
+        @ctx.instance_exec(&@begin_proc) if @begin_proc
+      end
+
+
+      def run_message_loop
+        n = @config.count
+        if @eval_proc
+          if n && n > 0
+            n.times do
+              parts = @pull.receive
+              break if parts.nil?
+              parts = OMQ::CLI::ExpressionEvaluator.normalize_result(
+                @ctx.instance_exec(@fmt_in.decompress(parts), &@eval_proc)
+              )
+              next if parts.nil?
+              @push << @fmt_out.compress(parts) unless parts.empty?
+            end
+          else
+            loop do
+              parts = @pull.receive
+              break if parts.nil?
+              parts = OMQ::CLI::ExpressionEvaluator.normalize_result(
+                @ctx.instance_exec(@fmt_in.decompress(parts), &@eval_proc)
+              )
+              next if parts.nil?
+              @push << @fmt_out.compress(parts) unless parts.empty?
+            end
+          end
+        else
+          if n && n > 0
+            n.times do
+              parts = @pull.receive
+              break if parts.nil?
+              @push << @fmt_out.compress(@fmt_in.decompress(parts))
+            end
+          else
+            loop do
+              parts = @pull.receive
+              break if parts.nil?
+              @push << @fmt_out.compress(@fmt_in.decompress(parts))
+            end
+          end
+        end
+      rescue IO::TimeoutError, Async::TimeoutError
+        # recv timed out — fall through to END block
+      end
+
+
+      def run_end_block
+        return unless @end_proc
+        out = OMQ::CLI::ExpressionEvaluator.normalize_result(
+          @ctx.instance_exec(&@end_proc)
+        )
+        @push << @fmt_out.compress(out) if out && !out.empty?
+      end
+    end
+  end
+end

data/lib/omq/cli/version.rb

@@ -2,6 +2,6 @@
 
 module OMQ
   module CLI
-    VERSION = "0.7.1"
+    VERSION = "0.7.2"
   end
 end

data/lib/omq/cli.rb

@@ -18,6 +18,7 @@ require_relative "cli/req_rep"
 require_relative "cli/pair"
 require_relative "cli/router_dealer"
 require_relative "cli/client_server"
+require_relative "cli/pipe_worker"
 require_relative "cli/pipe"
 
 module OMQ

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omq-cli
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.7.2
 platform: ruby
 authors:
 - Patrik Wenger
@@ -166,6 +166,7 @@ files:
 - lib/omq/cli/formatter.rb
 - lib/omq/cli/pair.rb
 - lib/omq/cli/pipe.rb
+- lib/omq/cli/pipe_worker.rb
 - lib/omq/cli/pub_sub.rb
 - lib/omq/cli/push_pull.rb
 - lib/omq/cli/radio_dish.rb