omq-cli 0.2.0 → 0.3.0

data/lib/omq/cli/pipe.rb

@@ -2,19 +2,27 @@
 
 module OMQ
   module CLI
+    # Runner for the virtual "pipe" socket type (PULL -> eval -> PUSH).
+    # Supports sequential and parallel (Ractor-based) processing modes.
     class PipeRunner
+      # @return [Config] frozen CLI configuration
       attr_reader :config
 
 
+      # @param config [Config] frozen CLI configuration
       def initialize(config)
         @config = config
         @fmt    = Formatter.new(config.format, compress: config.compress)
       end
 
 
+      # Runs the pipe in sequential or parallel mode based on config.
+      #
+      # @param task [Async::Task] the parent async task
+      # @return [void]
       def call(task)
         if config.parallel
-          run_parallel
+          run_parallel(task)
         else
           run_sequential(task)
         end
@@ -34,41 +42,64 @@ module OMQ
 
 
       def attach_endpoints(sock, endpoints)
-        endpoints.each { |ep| ep.bind? ? sock.bind(ep.url) : sock.connect(ep.url) }
+        SocketSetup.attach_endpoints(sock, endpoints)
       end
 
 
-      def run_sequential(task)
-        in_eps, out_eps = resolve_endpoints
-
-        @pull = OMQ::PULL.new(linger: config.linger, recv_timeout: config.timeout)
-        @push = OMQ::PUSH.new(linger: config.linger, send_timeout: config.timeout)
-        @pull.reconnect_interval  = config.reconnect_ivl if config.reconnect_ivl
-        @push.reconnect_interval  = config.reconnect_ivl if config.reconnect_ivl
-        @pull.heartbeat_interval  = config.heartbeat_ivl if config.heartbeat_ivl
-        @push.heartbeat_interval  = config.heartbeat_ivl if config.heartbeat_ivl
+      # ── Sequential ───────────────────────────────────────────────────
 
-        attach_endpoints(@pull, in_eps)
-        attach_endpoints(@push, out_eps)
 
+      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
+        )
         compile_expr
         @sock = @pull  # for eval instance_exec
-
         with_timeout(config.timeout) do
           @push.peer_connected.wait
           @pull.peer_connected.wait
         end
+        setup_sequential_transient(task)
+        @sock.instance_exec(&@recv_begin_proc) if @recv_begin_proc
+        sequential_message_loop
+        @sock.instance_exec(&@recv_end_proc) if @recv_end_proc
+      ensure
+        @pull&.close
+        @push&.close
+      end
 
-        if config.transient
-          task.async do
-            @pull.all_peers_gone.wait
-            @pull.reconnect_enabled = false
-            @pull.close_read
-          end
+
+      def apply_socket_intervals(sock)
+        sock.reconnect_interval = config.reconnect_ivl if config.reconnect_ivl
+        sock.heartbeat_interval = config.heartbeat_ivl if config.heartbeat_ivl
+      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)
+        apply_socket_intervals(pull)
+        apply_socket_intervals(push)
+        attach_endpoints(pull, in_eps)
+        attach_endpoints(push, out_eps)
+        [pull, push]
+      end
+
+
+      def setup_sequential_transient(task)
+        return unless config.transient
+        task.async do
+          @pull.all_peers_gone.wait
+          @pull.reconnect_enabled = false
+          @pull.close_read
         end
+      end
 
-        @sock.instance_exec(&@recv_begin_proc) if @recv_begin_proc
 
+      def sequential_message_loop
         n = config.count
         i = 0
         loop do
@@ -76,114 +107,141 @@ module OMQ
           break if parts.nil?
           parts = @fmt.decompress(parts)
           parts = eval_recv_expr(parts)
-          if parts && !parts.empty?
-            @push.send(@fmt.compress(parts))
-          end
+          @push.send(@fmt.compress(parts)) if parts && !parts.empty?
           i += 1
           break if n && n > 0 && i >= n
         end
+      end
 
-        @sock.instance_exec(&@recv_end_proc) if @recv_end_proc
+
+      # ── Parallel ─────────────────────────────────────────────────────
+
+
+      def run_parallel(task)
+        in_eps, out_eps = resolve_endpoints
+        pairs = build_socket_pairs(config.parallel, in_eps, out_eps)
+        wait_for_pairs(pairs)
+        setup_parallel_transient(task, pairs)
+        workers = spawn_workers(pairs, build_worker_data)
+        join_workers(workers)
       ensure
-        @pull&.close
-        @push&.close
+        pairs&.each do |pull, push|
+          pull&.close
+          push&.close
+        end
       end
 
 
-      def run_parallel
-        workers = config.parallel.times.map do
-          Ractor.new(config) do |cfg|
-            $VERBOSE = nil
-            Console.logger = Console::Logger.new(Console::Output::Null.new)
-
-            Sync do |task|
-              # Parse BEGIN/END blocks and per-message expression
-              begin_proc = end_proc = eval_proc = nil
-              if cfg.recv_expr
-                extract = ->(src, kw) {
-                  s = src.index(/#{kw}\s*\{/)
-                  return [src, nil] unless s
-                  i = src.index("{", s); d = 1; j = i + 1
-                  while j < src.length && d > 0
-                    d += 1 if src[j] == "{"; d -= 1 if src[j] == "}"
-                    j += 1
-                  end
-                  [src[0...s] + src[j..], src[(i + 1)..(j - 2)]]
-                }
-                expr, begin_body = extract.(cfg.recv_expr, "BEGIN")
-                expr, end_body   = extract.(expr, "END")
-                begin_proc = eval("proc { #{begin_body} }") if begin_body
-                end_proc   = eval("proc { #{end_body} }")   if end_body
-                if expr && !expr.strip.empty?
-                  ractor_expr = expr.gsub(/\$F\b/, "__F")
-                  eval_proc   = eval("proc { |__F| $_ = __F&.first; #{ractor_expr} }")
-                end
-              end
+      def build_socket_pairs(n_workers, in_eps, out_eps)
+        pull_opts = { linger: config.linger }
+        push_opts = { linger: config.linger }
+        pull_opts[:recv_timeout] = config.timeout if config.timeout
+        push_opts[:send_timeout] = config.timeout if config.timeout
+        n_workers.times.map { build_pull_push(pull_opts, push_opts, in_eps, out_eps) }
+      end
 
-              formatter = OMQ::CLI::Formatter.new(cfg.format, compress: cfg.compress)
-
-              pull = OMQ::PULL.new(linger: cfg.linger, recv_timeout: cfg.timeout)
-              push = OMQ::PUSH.new(linger: cfg.linger, send_timeout: 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
-              in_eps  = cfg.in_endpoints.any? ? cfg.in_endpoints : [cfg.endpoints[0]]
-              out_eps = cfg.out_endpoints.any? ? cfg.out_endpoints : [cfg.endpoints[1]]
-              in_eps.each  { |ep| pull.connect(ep.url) }
-              out_eps.each { |ep| push.connect(ep.url) }
-
-              if cfg.timeout
-                task.with_timeout(cfg.timeout) do
-                  push.peer_connected.wait
-                  pull.peer_connected.wait
+
+      def wait_for_pairs(pairs)
+        with_timeout(config.timeout) do
+          pairs.each do |pull, push|
+            push.peer_connected.wait
+            pull.peer_connected.wait
+          end
+        end
+      end
+
+
+      def setup_parallel_transient(task, pairs)
+        return unless config.transient
+        task.async do
+          pairs[0][0].all_peers_gone.wait
+          pairs.each do |pull, _|
+            pull.reconnect_enabled = false
+            pull.close_read
+          end
+        end
+      end
+
+
+      def build_worker_data
+        # Pack worker config into a shareable Hash passed via omq.data —
+        # Ruby 4.0 forbids Ractor blocks from closing over outer locals.
+        ::Ractor.make_shareable({
+          recv_src:   config.recv_expr,
+          fmt_format: config.format,
+          fmt_compr:  config.compress,
+          n_count:    config.count,
+        })
+      end
+
+
+      def spawn_workers(pairs, worker_data)
+        pairs.map do |pull, push|
+          OMQ::Ractor.new(pull, push, serialize: false, data: worker_data) do |omq|
+            pull_p, push_p = omq.sockets
+            d = omq.data
+
+            # Re-compile expression inside Ractor (Procs are not shareable)
+            begin_proc, end_proc, eval_proc =
+              OMQ::CLI::ExpressionEvaluator.compile_inside_ractor(d[:recv_src])
+
+            formatter = OMQ::CLI::Formatter.new(d[:fmt_format], compress: d[:fmt_compr])
+            # Use a dedicated context object so @ivar expressions in BEGIN/END/eval
+            # work inside Ractors (self in a Ractor is shareable; Object.new is not).
+            _ctx = Object.new
+            _ctx.instance_exec(&begin_proc) if begin_proc
+
+            n_count = d[:n_count]
+            if eval_proc
+              if n_count && n_count > 0
+                n_count.times do
+                  parts = pull_p.receive
+                  break if parts.nil?
+                  parts = OMQ::CLI::ExpressionEvaluator.normalize_result(
+                    _ctx.instance_exec(formatter.decompress(parts), &eval_proc)
+                  )
+                  next if parts.nil?
+                  push_p << formatter.compress(parts) unless parts.empty?
                 end
               else
-                push.peer_connected.wait
-                pull.peer_connected.wait
-              end
-
-              if cfg.transient
-                task.async do
-                  pull.all_peers_gone.wait
-                  pull.reconnect_enabled = false
-                  pull.close_read
+                loop do
+                  parts = pull_p.receive
+                  break if parts.nil?
+                  parts = OMQ::CLI::ExpressionEvaluator.normalize_result(
+                    _ctx.instance_exec(formatter.decompress(parts), &eval_proc)
+                  )
+                  next if parts.nil?
+                  push_p << formatter.compress(parts) unless parts.empty?
                 end
               end
-
-              begin_proc&.call
-
-              i = 0
-              loop do
-                parts = pull.receive
-                break if parts.nil?
-                parts = formatter.decompress(parts)
-                if eval_proc
-                  result = eval_proc.call(parts)
-                  parts = case result
-                          when nil    then nil
-                          when Array  then result
-                          when String then [result]
-                          else             [result.to_s]
-                          end
+            else
+              if n_count && n_count > 0
+                n_count.times do
+                  parts = pull_p.receive
+                  break if parts.nil?
+                  push_p << formatter.compress(formatter.decompress(parts))
                 end
-                if parts && !parts.empty?
-                  push.send(formatter.compress(parts))
+              else
+                loop do
+                  parts = pull_p.receive
+                  break if parts.nil?
+                  push_p << formatter.compress(formatter.decompress(parts))
                 end
-                i += 1
-                break if cfg.count && cfg.count > 0 && i >= cfg.count
               end
+            end
 
-              end_proc&.call
-            rescue Async::TimeoutError
-              # exit cleanly on timeout
-            ensure
-              pull&.close
-              push&.close
+            if end_proc
+              out = OMQ::CLI::ExpressionEvaluator.normalize_result(
+                _ctx.instance_exec(&end_proc)
+              )
+              push_p << formatter.compress(out) if out && !out.empty?
             end
           end
         end
+      end
 
+
+      def join_workers(workers)
         workers.each do |w|
           w.value
         rescue Ractor::RemoteError => e
@@ -192,6 +250,9 @@ module OMQ
       end
 
 
+      # ── Shared helpers ────────────────────────────────────────────────
+
+
       def with_timeout(seconds)
         if seconds
           Async::Task.current.with_timeout(seconds) { yield }
@@ -202,58 +263,16 @@ module OMQ
 
 
       def compile_expr
-        src = config.recv_expr
-        return unless src
-        expr, begin_body, end_body = extract_blocks(src)
-        @recv_begin_proc = eval("proc { #{begin_body} }") if begin_body
-        @recv_end_proc   = eval("proc { #{end_body} }")   if end_body
-        @recv_eval_proc  = eval("proc { $_ = $F&.first; #{expr} }") if expr && !expr.strip.empty?
-      end
-
-
-      def extract_blocks(expr)
-        begin_body = end_body = nil
-        expr, begin_body = extract_block(expr, "BEGIN")
-        expr, end_body   = extract_block(expr, "END")
-        [expr, begin_body, end_body]
-      end
-
-
-      def extract_block(expr, keyword)
-        start = expr.index(/#{keyword}\s*\{/)
-        return [expr, nil] unless start
-
-        i     = expr.index("{", start)
-        depth = 1
-        j     = i + 1
-        while j < expr.length && depth > 0
-          case expr[j]
-          when "{" then depth += 1
-          when "}" then depth -= 1
-          end
-          j += 1
-        end
-
-        body    = expr[(i + 1)..(j - 2)]
-        trimmed = expr[0...start] + expr[j..]
-        [trimmed, body]
+        @recv_evaluator  = ExpressionEvaluator.new(config.recv_expr, format: config.format)
+        @recv_begin_proc = @recv_evaluator.begin_proc
+        @recv_eval_proc  = @recv_evaluator.eval_proc
+        @recv_end_proc   = @recv_evaluator.end_proc
       end
 
 
       def eval_recv_expr(parts)
-        return parts unless @recv_eval_proc
-        $F = parts
-        result = @sock.instance_exec(&@recv_eval_proc)
-        return nil if result.nil? || result.equal?(@sock)
-        return [result] if config.format == :marshal
-        case result
-        when Array  then result
-        when String then [result]
-        else             [result.to_str]
-        end
-      rescue => e
-        $stderr.puts "omq: eval error: #{e.message} (#{e.class})"
-        exit 3
+        result = @recv_evaluator.call(parts, @sock)
+        result.equal?(ExpressionEvaluator::SENT) ? nil : result
       end
 
 

data/lib/omq/cli/pub_sub.rb

@@ -2,13 +2,17 @@
 
 module OMQ
   module CLI
+    # Runner for PUB sockets (publish messages to subscribers).
     class PubRunner < BaseRunner
       def run_loop(task) = run_send_logic
     end
 
 
+    # Runner for SUB sockets (subscribe and receive published messages).
     class SubRunner < BaseRunner
-      def run_loop(task) = run_recv_logic
+      def run_loop(task)
+        config.parallel ? run_parallel_recv(task) : run_recv_logic
+      end
     end
   end
 end

data/lib/omq/cli/push_pull.rb

@@ -2,13 +2,17 @@
 
 module OMQ
   module CLI
+    # Runner for PUSH sockets (send-only pipeline producer).
     class PushRunner < BaseRunner
       def run_loop(task) = run_send_logic
     end
 
 
+    # Runner for PULL sockets (receive-only pipeline consumer).
     class PullRunner < BaseRunner
-      def run_loop(task) = run_recv_logic
+      def run_loop(task)
+        config.parallel ? run_parallel_recv(task) : run_recv_logic
+      end
     end
   end
 end

data/lib/omq/cli/radio_dish.rb

@@ -2,6 +2,7 @@
 
 module OMQ
   module CLI
+    # Runner for RADIO sockets (draft; group-based publish).
     class RadioRunner < BaseRunner
       def run_loop(task) = run_send_logic
 
@@ -20,8 +21,11 @@ module OMQ
     end
 
 
+    # Runner for DISH sockets (draft; group-based subscribe).
     class DishRunner < BaseRunner
-      def run_loop(task) = run_recv_logic
+      def run_loop(task)
+        config.parallel ? run_parallel_recv(task) : run_recv_logic
+      end
     end
   end
 end

data/lib/omq/cli/req_rep.rb

@@ -2,6 +2,7 @@
 
 module OMQ
   module CLI
+    # Runner for REQ sockets (synchronous request-reply client).
     class ReqRunner < BaseRunner
       private
 
@@ -10,43 +11,31 @@ module OMQ
         n = config.count
         i = 0
         sleep(config.delay) if config.delay
-        if config.interval
-          loop do
-            parts = read_next
-            break unless parts
-            parts = eval_send_expr(parts)
-            next unless parts
-            send_msg(parts)
-            reply = recv_msg
-            break if reply.nil?
-            reply = eval_recv_expr(reply)
-            output(reply)
-            i += 1
-            break if n && n > 0 && i >= n
-            interval = config.interval
-            wait     = interval - (Time.now.to_f % interval)
-            sleep(wait) if wait > 0
-          end
-        else
-          loop do
-            parts = read_next
-            break unless parts
-            parts = eval_send_expr(parts)
-            next unless parts
-            send_msg(parts)
-            reply = recv_msg
-            break if reply.nil?
-            reply = eval_recv_expr(reply)
-            output(reply)
-            i += 1
-            break if n && n > 0 && i >= n
-            break if config.data || config.file
-          end
+        loop do
+          parts = read_next
+          break unless parts
+          parts = eval_send_expr(parts)
+          next unless parts
+          send_msg(parts)
+          reply = recv_msg
+          break if reply.nil?
+          output(eval_recv_expr(reply))
+          i += 1
+          break if n && n > 0 && i >= n
+          break if !config.interval && (config.data || config.file)
+          wait_for_interval if config.interval
         end
       end
+
+
+      def wait_for_interval
+        wait = config.interval - (Time.now.to_f % config.interval)
+        sleep(wait) if wait > 0
+      end
     end
 
 
+    # Runner for REP sockets (synchronous request-reply server).
     class RepRunner < BaseRunner
       private
 
@@ -57,27 +46,33 @@ module OMQ
         loop do
           msg = recv_msg
           break if msg.nil?
-          if config.recv_expr || @recv_eval_proc
-            reply = eval_recv_expr(msg)
-            unless reply.equal?(SENT)
-              output(reply)
-              send_msg(reply || [""])
-            end
-          elsif config.echo
-            output(msg)
-            send_msg(msg)
-          elsif config.data || config.file || !config.stdin_is_tty
-            reply = read_next
-            break unless reply
-            output(msg)
-            send_msg(reply)
-          else
-            abort "REP needs a reply source: --echo, --data, --file, -e, or stdin pipe"
-          end
+          break unless handle_rep_request(msg)
           i += 1
           break if n && n > 0 && i >= n
         end
       end
+
+
+      def handle_rep_request(msg)
+        if config.recv_expr || @recv_eval_proc
+          reply = eval_recv_expr(msg)
+          unless reply.equal?(SENT)
+            output(reply)
+            send_msg(reply || [""])
+          end
+        elsif config.echo
+          output(msg)
+          send_msg(msg)
+        elsif config.data || config.file || !config.stdin_is_tty
+          reply = read_next
+          return false unless reply
+          output(msg)
+          send_msg(reply)
+        else
+          abort "REP needs a reply source: --echo, --data, --file, -e, or stdin pipe"
+        end
+        true
+      end
     end
   end
 end

data/lib/omq/cli/router_dealer.rb

@@ -2,16 +2,22 @@
 
 module OMQ
   module CLI
-    class DealerRunner < PairRunner
-    end
-
-
+    # Runner for ROUTER sockets (identity-aware async routing).
     class RouterRunner < BaseRunner
+      include RoutingHelper
+
       private
 
 
       def run_loop(task)
-        receiver = task.async do
+        receiver = recv_async(task)
+        sender   = async_send_loop(task)
+        wait_for_loops(receiver, sender)
+      end
+
+
+      def recv_async(task)
+        task.async do
           n = config.count
           i = 0
           loop do
@@ -26,50 +32,11 @@ module OMQ
             break if n && n > 0 && i >= n
           end
         end
-
-        sender = task.async do
-          n = config.count
-          i = 0
-          sleep(config.delay) if config.delay
-          if config.interval
-            Async::Loop.quantized(interval: config.interval) do
-              parts = read_next
-              break unless parts
-              send_targeted_or_eval(parts)
-              i += 1
-              break if n && n > 0 && i >= n
-            end
-          elsif config.data || config.file
-            parts = read_next
-            send_targeted_or_eval(parts) if parts
-          else
-            loop do
-              parts = read_next
-              break unless parts
-              send_targeted_or_eval(parts)
-              i += 1
-              break if n && n > 0 && i >= n
-            end
-          end
-        end
-
-        wait_for_loops(receiver, sender)
       end
 
 
-      def send_targeted_or_eval(parts)
-        if @send_eval_proc
-          parts = eval_send_expr(parts)
-          return unless parts
-          identity = resolve_target(parts.shift)
-          payload  = @fmt.compress(parts)
-          @sock.send([identity, "", *payload])
-        elsif config.target
-          payload = @fmt.compress(parts)
-          @sock.send([resolve_target(config.target), "", *payload])
-        else
-          send_msg(parts)
-        end
+      def send_to_peer(id, parts)
+        @sock.send([id, "", *@fmt.compress(parts)])
       end
     end
   end