omq-cli 0.2.0 → 0.3.0

data/lib/omq/cli/routing_helper.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module OMQ
+  module CLI
+    # Shared routing behaviour for socket types that address peers by ID
+    # (ROUTER, SERVER). Include in a runner to get display_routing_id,
+    # resolve_target, and a send_targeted_or_eval template method.
+    #
+    # Including class must implement #send_to_peer(routing_id, parts).
+    #
+    module RoutingHelper
+      # Format a raw routing ID for display: printable ASCII as-is,
+      # binary as a 0x-prefixed hex string.
+      #
+      def display_routing_id(id)
+        if id.bytes.all? { |b| b >= 0x20 && b <= 0x7E }
+          id
+        else
+          "0x#{id.unpack1("H*")}"
+        end
+      end
+
+
+      # Decode a target string: 0x-prefixed hex is converted to binary,
+      # plain strings are returned as-is.
+      #
+      def resolve_target(target)
+        if target.start_with?("0x")
+          [target[2..].delete(" ")].pack("H*")
+        else
+          target
+        end
+      end
+
+
+      # Send +parts+ to a peer, routing by identity or eval result.
+      #
+      # Template method: calls #send_to_peer(id, parts) which the
+      # including class must implement for its socket type.
+      #
+      def send_targeted_or_eval(parts)
+        if @send_eval_proc
+          parts = eval_send_expr(parts)
+          return unless parts
+          send_to_peer(resolve_target(parts.shift), parts)
+        elsif config.target
+          send_to_peer(resolve_target(config.target), parts)
+        else
+          send_msg(parts)
+        end
+      end
+
+
+      # Async sender shared by ROUTER and SERVER monitor mode.
+      #
+      def async_send_loop(task)
+        task.async do
+          n = config.count
+          i = 0
+          sleep(config.delay) if config.delay
+          if config.interval
+            interval_send_loop(n, i)
+          elsif config.data || config.file
+            parts = read_next
+            send_targeted_or_eval(parts) if parts
+          else
+            stdin_send_loop(n, i)
+          end
+        end
+      end
+
+
+      def interval_send_loop(n, i)
+        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
+      end
+
+
+      def stdin_send_loop(n, i)
+        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
+  end
+end

data/lib/omq/cli/scatter_gather.rb

@@ -2,13 +2,17 @@
 
 module OMQ
   module CLI
+    # Runner for SCATTER sockets (draft; fan-out send).
     class ScatterRunner < BaseRunner
       def run_loop(task) = run_send_logic
     end
 
 
+    # Runner for GATHER sockets (draft; fan-in receive).
     class GatherRunner < 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/socket_setup.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module OMQ
+  module CLI
+    # Stateless helper for socket construction and configuration.
+    # All methods are module-level so callers compose rather than inherit.
+    #
+    module SocketSetup
+      # Create and fully configure a socket from +klass+ and +config+.
+      #
+      def self.build(klass, config)
+        sock_opts              = { linger: config.linger }
+        sock_opts[:conflate]   = true if config.conflate && %w[pub radio].include?(config.type_name)
+        sock                   = klass.new(**sock_opts)
+        sock.recv_timeout      = config.timeout    if config.timeout
+        sock.send_timeout      = config.timeout    if config.timeout
+        sock.max_message_size  = config.recv_maxsz if config.recv_maxsz
+        sock.reconnect_interval  = config.reconnect_ivl if config.reconnect_ivl
+        sock.heartbeat_interval  = config.heartbeat_ivl if config.heartbeat_ivl
+        sock.identity            = config.identity      if config.identity
+        sock.router_mandatory    = true if config.type_name == "router"
+        sock
+      end
+
+
+      # Bind/connect +sock+ using URL strings from +config.binds+ / +config.connects+.
+      #
+      def self.attach(sock, config, verbose: false)
+        config.binds.each do |url|
+          sock.bind(url)
+          $stderr.puts "Bound to #{sock.last_endpoint}" if verbose
+        end
+        config.connects.each do |url|
+          sock.connect(url)
+          $stderr.puts "Connecting to #{url}" if verbose
+        end
+      end
+
+
+      # Bind/connect +sock+ from an Array of Endpoint objects.
+      # Used by PipeRunner, which works with structured endpoint lists.
+      #
+      def self.attach_endpoints(sock, endpoints)
+        endpoints.each { |ep| ep.bind? ? sock.bind(ep.url) : sock.connect(ep.url) }
+      end
+
+
+      # Subscribe or join groups on +sock+ according to +config+.
+      #
+      def self.setup_subscriptions(sock, config)
+        case config.type_name
+        when "sub"
+          prefixes = config.subscribes.empty? ? [""] : config.subscribes
+          prefixes.each { |p| sock.subscribe(p) }
+        when "dish"
+          config.joins.each { |g| sock.join(g) }
+        end
+      end
+
+
+      # Configure CURVE encryption on +sock+ using +config+ and env vars.
+      #
+      def self.setup_curve(sock, config)
+        server_key_z85 = config.curve_server_key || ENV["OMQ_SERVER_KEY"]
+        server_mode    = config.curve_server || (ENV["OMQ_SERVER_PUBLIC"] && ENV["OMQ_SERVER_SECRET"])
+
+        return unless server_key_z85 || server_mode
+
+        crypto = CLI.load_curve_crypto(config.curve_crypto || ENV["OMQ_CURVE_CRYPTO"], verbose: config.verbose)
+        require "protocol/zmtp/mechanism/curve"
+
+        if server_key_z85
+          server_key = Protocol::ZMTP::Z85.decode(server_key_z85)
+          client_key = crypto::PrivateKey.generate
+          sock.mechanism = Protocol::ZMTP::Mechanism::Curve.client(
+            public_key: client_key.public_key.to_s,
+            secret_key: client_key.to_s,
+            server_key: server_key,
+            crypto: crypto
+          )
+        elsif server_mode
+          if ENV["OMQ_SERVER_PUBLIC"] && ENV["OMQ_SERVER_SECRET"]
+            server_pub = Protocol::ZMTP::Z85.decode(ENV["OMQ_SERVER_PUBLIC"])
+            server_sec = Protocol::ZMTP::Z85.decode(ENV["OMQ_SERVER_SECRET"])
+          else
+            key        = crypto::PrivateKey.generate
+            server_pub = key.public_key.to_s
+            server_sec = key.to_s
+          end
+          sock.mechanism = Protocol::ZMTP::Mechanism::Curve.server(
+            public_key: server_pub,
+            secret_key: server_sec,
+            crypto: crypto
+          )
+          $stderr.puts "OMQ_SERVER_KEY='#{Protocol::ZMTP::Z85.encode(server_pub)}'"
+        end
+      end
+    end
+  end
+end

data/lib/omq/cli/transient_monitor.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module OMQ
+  module CLI
+    # Monitors peer-disconnect events for --transient mode.
+    #
+    # Starts an async task that waits until #ready! is called (signalling
+    # that at least one message has been exchanged), then waits for all
+    # peers to disconnect, disables reconnection, and either stops the
+    # task (send-only) or closes the read side of the socket (recv side).
+    #
+    class TransientMonitor
+      # @param sock [Object] the OMQ socket to monitor
+      # @param config [Config] frozen CLI configuration
+      # @param task [Async::Task] parent async task
+      # @param log_fn [Method] callable for verbose logging
+      def initialize(sock, config, task, log_fn)
+        @barrier = Async::Promise.new
+        task.async do
+          @barrier.wait
+          sock.all_peers_gone.wait unless sock.connection_count == 0
+          log_fn.call("All peers disconnected, exiting")
+          sock.reconnect_enabled = false
+          if config.send_only?
+            task.stop
+          else
+            sock.close_read
+          end
+        end
+      end
+
+
+      # Signal that the first message has been sent or received.
+      # Idempotent — safe to call multiple times.
+      #
+      def ready!
+        @barrier.resolve(true) unless @barrier.resolved?
+      end
+    end
+  end
+end

data/lib/omq/cli/version.rb

@@ -2,6 +2,6 @@
 
 module OMQ
   module CLI
-    VERSION = "0.2.0"
+    VERSION = "0.3.0"
   end
 end