omq-cli 0.1.0

data/lib/omq/cli/formatter.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module OMQ
+  module CLI
+    # Handles encoding/decoding messages in the configured format,
+    # plus optional Zstandard compression.
+    class Formatter
+      def initialize(format, compress: false)
+        @format   = format
+        @compress = compress
+      end
+
+
+      def encode(parts)
+        case @format
+        when :ascii
+          parts.map { |p| p.b.gsub(/[^[:print:]\t]/, ".") }.join("\t") + "\n"
+        when :quoted
+          parts.map { |p| p.b.dump[1..-2] }.join("\t") + "\n"
+        when :raw
+          parts.each_with_index.map do |p, i|
+            ZMTP::Codec::Frame.new(p.to_s, more: i < parts.size - 1).to_wire
+          end.join
+        when :jsonl
+          JSON.generate(parts) + "\n"
+        when :msgpack
+          MessagePack.pack(parts)
+        when :marshal
+          parts.map(&:inspect).join("\t") + "\n"
+        end
+      end
+
+
+      def decode(line)
+        case @format
+        when :ascii, :marshal
+          line.chomp.split("\t")
+        when :quoted
+          line.chomp.split("\t").map { |p| "\"#{p}\"".undump }
+        when :raw
+          [line]
+        when :jsonl
+          arr = JSON.parse(line.chomp)
+          abort "JSON Lines input must be an array of strings" unless arr.is_a?(Array) && arr.all? { |e| e.is_a?(String) }
+          arr
+        end
+      end
+
+
+      def decode_marshal(io)
+        Marshal.load(io)
+      rescue EOFError, TypeError
+        nil
+      end
+
+
+      def decode_msgpack(io)
+        @msgpack_unpacker ||= MessagePack::Unpacker.new(io)
+        @msgpack_unpacker.read
+      rescue EOFError
+        nil
+      end
+
+
+      def compress(parts)
+        @compress ? parts.map { |p| Zstd.compress(p) } : parts
+      end
+
+
+      def decompress(parts)
+        @compress ? parts.map { |p| Zstd.decompress(p) } : parts
+      end
+    end
+  end
+end

data/lib/omq/cli/pair.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module OMQ
+  module CLI
+    class PairRunner < BaseRunner
+      private
+
+
+      def run_loop(task)
+        receiver = task.async do
+          n = config.count
+          i = 0
+          loop do
+            parts = recv_msg
+            break if parts.nil?
+            parts = eval_recv_expr(parts)
+            output(parts)
+            i += 1
+            break if n && n > 0 && i >= n
+          end
+        end
+
+        sender = task.async do
+          run_send_logic
+        end
+
+        wait_for_loops(receiver, sender)
+      end
+    end
+  end
+end

data/lib/omq/cli/peer.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module OMQ
+  module CLI
+    class PeerRunner < ServerRunner
+    end
+  end
+end

data/lib/omq/cli/pipe.rb

@@ -0,0 +1,265 @@
+# frozen_string_literal: true
+
+module OMQ
+  module CLI
+    class PipeRunner
+      attr_reader :config
+
+
+      def initialize(config)
+        @config = config
+        @fmt    = Formatter.new(config.format, compress: config.compress)
+      end
+
+
+      def call(task)
+        if config.parallel
+          run_parallel
+        else
+          run_sequential(task)
+        end
+      end
+
+
+      private
+
+
+      def resolve_endpoints
+        if config.in_endpoints.any?
+          [config.in_endpoints, config.out_endpoints]
+        else
+          [[config.endpoints[0]], [config.endpoints[1]]]
+        end
+      end
+
+
+      def attach_endpoints(sock, endpoints)
+        endpoints.each { |ep| ep.bind? ? sock.bind(ep.url) : sock.connect(ep.url) }
+      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
+
+        attach_endpoints(@pull, in_eps)
+        attach_endpoints(@push, out_eps)
+
+        compile_expr
+        @sock = @pull  # for eval instance_exec
+
+        with_timeout(config.timeout) do
+          @push.peer_connected.wait
+          @pull.peer_connected.wait
+        end
+
+        if 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
+
+        n = config.count
+        i = 0
+        loop do
+          parts = @pull.receive
+          break if parts.nil?
+          parts = @fmt.decompress(parts)
+          parts = eval_recv_expr(parts)
+          if parts && !parts.empty?
+            @push.send(@fmt.compress(parts))
+          end
+          i += 1
+          break if n && n > 0 && i >= n
+        end
+
+        @sock.instance_exec(&@recv_end_proc) if @recv_end_proc
+      ensure
+        @pull&.close
+        @push&.close
+      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
+
+              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
+                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
+                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
+                end
+                if parts && !parts.empty?
+                  push.send(formatter.compress(parts))
+                end
+                i += 1
+                break if cfg.count && cfg.count > 0 && i >= cfg.count
+              end
+
+              end_proc&.call
+            rescue Async::TimeoutError
+              # exit cleanly on timeout
+            ensure
+              pull&.close
+              push&.close
+            end
+          end
+        end
+
+        workers.each do |w|
+          w.value
+        rescue Ractor::RemoteError => e
+          $stderr.puts "omq: Ractor error: #{e.cause&.message || e.message}"
+        end
+      end
+
+
+      def with_timeout(seconds)
+        if seconds
+          Async::Task.current.with_timeout(seconds) { yield }
+        else
+          yield
+        end
+      end
+
+
+      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]
+      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
+      end
+
+
+      def log(msg)
+        $stderr.puts(msg) if config.verbose
+      end
+    end
+  end
+end

data/lib/omq/cli/pub_sub.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module OMQ
+  module CLI
+    class PubRunner < BaseRunner
+      def run_loop(task) = run_send_logic
+    end
+
+
+    class SubRunner < BaseRunner
+      def run_loop(task) = run_recv_logic
+    end
+  end
+end

data/lib/omq/cli/push_pull.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module OMQ
+  module CLI
+    class PushRunner < BaseRunner
+      def run_loop(task) = run_send_logic
+    end
+
+
+    class PullRunner < BaseRunner
+      def run_loop(task) = run_recv_logic
+    end
+  end
+end

data/lib/omq/cli/radio_dish.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module OMQ
+  module CLI
+    class RadioRunner < BaseRunner
+      def run_loop(task) = run_send_logic
+
+
+      private
+
+
+      def send_msg(parts)
+        return if parts.empty?
+        parts = [Marshal.dump(parts)] if config.format == :marshal
+        parts = @fmt.compress(parts)
+        group = config.group || parts.shift
+        @sock.publish(group, parts.first || "")
+        transient_ready!
+      end
+    end
+
+
+    class DishRunner < BaseRunner
+      def run_loop(task) = run_recv_logic
+    end
+  end
+end

data/lib/omq/cli/req_rep.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module OMQ
+  module CLI
+    class ReqRunner < BaseRunner
+      private
+
+
+      def run_loop(task)
+        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
+        end
+      end
+    end
+
+
+    class RepRunner < BaseRunner
+      private
+
+
+      def run_loop(task)
+        n = config.count
+        i = 0
+        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
+          i += 1
+          break if n && n > 0 && i >= n
+        end
+      end
+    end
+  end
+end

data/lib/omq/cli/router_dealer.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module OMQ
+  module CLI
+    class DealerRunner < PairRunner
+    end
+
+
+    class RouterRunner < BaseRunner
+      private
+
+
+      def run_loop(task)
+        receiver = task.async do
+          n = config.count
+          i = 0
+          loop do
+            parts = recv_msg_raw
+            break if parts.nil?
+            identity = parts.shift
+            parts.shift if parts.first == ""
+            parts = @fmt.decompress(parts)
+            result = eval_recv_expr([display_routing_id(identity), *parts])
+            output(result)
+            i += 1
+            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
+      end
+    end
+  end
+end

data/lib/omq/cli/scatter_gather.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module OMQ
+  module CLI
+    class ScatterRunner < BaseRunner
+      def run_loop(task) = run_send_logic
+    end
+
+
+    class GatherRunner < BaseRunner
+      def run_loop(task) = run_recv_logic
+    end
+  end
+end

data/lib/omq/cli/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module OMQ
+  module CLI
+    VERSION = "0.1.0"
+  end
+end