omq 0.5.1 → 0.6.1

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.1
+  version: 0.6.1
 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

data/exe/omqcat

@@ -1,532 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-Warning[:experimental] = false
-
-#
-# omqcat — command-line access to OMQ (ZeroMQ) sockets.
-#
-# Usage: omqcat TYPE [options]
-#
-# Examples:
-#   omqcat rep -b tcp://:5555 -D "pong"
-#   echo "ping" | omqcat req -c tcp://localhost:5555
-#   omqcat sub -c tcp://localhost:5556 -s "weather."
-#
-
-require "optparse"
-
-SOCKET_TYPE_NAMES = %w[req rep pub sub push pull pair dealer router].freeze
-
-
-# ── Option parsing ──────────────────────────────────────────────────
-
-opts = {
-  connects:     [],
-  binds:        [],
-  data:         nil,
-  file:         nil,
-  format:       :ascii,
-  subscribes:   [],
-  identity:     nil,
-  target:       nil,
-  interval:     nil,
-  count:        nil,
-  delay:        nil,
-  recv_timeout: nil,
-  send_timeout: nil,
-  compress:     false,
-  expr:         nil,
-  verbose:      false,
-  quiet:        false,
-}
-
-parser = OptionParser.new do |o|
-  o.banner = "Usage: omqcat TYPE [options]\n\n" \
-             "Types: #{SOCKET_TYPE_NAMES.join(', ')}\n\n"
-
-  o.separator "Connection:"
-  o.on("-c", "--connect URL", "Connect to endpoint (repeatable)")   { |v| opts[:connects] << v }
-  o.on("-b", "--bind URL",    "Bind to endpoint (repeatable)")      { |v| opts[:binds] << v }
-
-  o.separator "\nData source (REP: reply source):"
-  o.on(      "--echo",        "Echo received messages back (REP)")   { opts[:echo] = true }
-  o.on("-D", "--data DATA",   "Message data (literal string)")      { |v| opts[:data] = v }
-  o.on("-F", "--file FILE",   "Read message from file (- = stdin)") { |v| opts[:file] = v }
-
-  o.separator "\nFormat (input + output):"
-  o.on("-A", "--ascii",   "Tab-separated frames, safe ASCII (default)") { opts[:format] = :ascii }
-  o.on("-Q", "--quoted",  "C-style quoted with escapes")                { opts[:format] = :quoted }
-  o.on(      "--raw",     "Raw binary, no framing")                     { opts[:format] = :raw }
-  o.on("-J", "--jsonl",   "JSON Lines (array of strings per line)")     { opts[:format] = :jsonl }
-  o.on(      "--msgpack", "MessagePack arrays (binary stream)")         { opts[:format] = :msgpack }
-
-  o.separator "\nSubscription:"
-  o.on("-s", "--subscribe PREFIX", "Subscribe prefix (repeatable, SUB only)") { |v| opts[:subscribes] << v }
-
-  o.separator "\nIdentity/routing:"
-  o.on("--identity ID", "Set socket identity (DEALER/ROUTER)")  { |v| opts[:identity] = v }
-  o.on("--target ID",   "Target peer identity (ROUTER sending)") { |v| opts[:target] = v }
-
-  o.separator "\nTiming:"
-  o.on("-i", "--interval SECS", Float, "Repeat interval")          { |v| opts[:interval] = v }
-  o.on("-n", "--count COUNT",   Integer, "Max iterations (0=inf)") { |v| opts[:count] = v }
-  o.on("-d", "--delay SECS",    Float, "Delay before first send")  { |v| opts[:delay] = v }
-  o.on("-t", "--recv-timeout SECS", Float, "Receive timeout")      { |v| opts[:recv_timeout] = v }
-  o.on(      "--send-timeout SECS", Float, "Send timeout")         { |v| opts[:send_timeout] = v }
-
-  o.separator "\nCompression:"
-  o.on("-z", "--compress", "Zstandard compression per frame") { opts[:compress] = true }
-
-  o.separator "\nProcessing:"
-  o.on("-e", "--eval EXPR", "Eval Ruby for each message ($F = parts)") { |v| opts[:expr] = v }
-  o.on("-r", "--require LIB", "Require a Ruby library (repeatable)")   { |v| require v }
-
-  o.separator "\nCURVE encryption (requires omq-curve gem):"
-  o.on("--curve-server",         "Enable CURVE as server (generates keypair)") { opts[:curve_server] = true }
-  o.on("--curve-server-key KEY", "Enable CURVE as client (server's Z85 public key)") { |v| opts[:curve_server_key] = v }
-  o.separator "  Env vars: OMQ_SERVER_KEY (client), OMQ_SERVER_PUBLIC + OMQ_SERVER_SECRET (server)"
-
-  o.separator "\nOther:"
-  o.on("-v", "--verbose", "Print connection events to stderr") { opts[:verbose] = true }
-  o.on("-q", "--quiet",   "Suppress message output")           { opts[:quiet] = true }
-  o.on("-V", "--version")                                      { require "omq"; puts "omqcat #{OMQ::VERSION}"; exit }
-  o.on("-h", "--help")                                         { puts o; exit }
-end
-
-begin
-  parser.parse!
-rescue OptionParser::ParseError => e
-  abort e.message
-end
-
-type_name = ARGV.shift
-abort parser.to_s unless type_name
-abort "Unknown socket type: #{type_name}. Known: #{SOCKET_TYPE_NAMES.join(', ')}" unless SOCKET_TYPE_NAMES.include?(type_name.downcase)
-
-# ── Validation (fast, before loading gems) ──────────────────────────
-
-abort "At least one --connect or --bind is required"   if opts[:connects].empty? && opts[:binds].empty?
-abort "--data and --file are mutually exclusive"        if opts[:data] && opts[:file]
-abort "--subscribe is only valid for SUB"               if !opts[:subscribes].empty? && type_name.downcase != "sub"
-abort "--identity is only valid for DEALER/ROUTER"      if opts[:identity] && !%w[dealer router].include?(type_name.downcase)
-abort "--target is only valid for ROUTER"               if opts[:target] && type_name.downcase != "router"
-
-# ── Load gems ───────────────────────────────────────────────────────
-
-require "omq"
-require "async"
-require "json"
-require "console"
-
-HAS_MSGPACK = begin; require "msgpack"; true; rescue LoadError; false; end
-HAS_ZSTD    = begin; require "zstd-ruby"; true; rescue LoadError; false; end
-
-SOCKET_TYPES = {
-  "req"    => OMQ::REQ,    "rep"    => OMQ::REP,
-  "pub"    => OMQ::PUB,    "sub"    => OMQ::SUB,
-  "push"   => OMQ::PUSH,   "pull"   => OMQ::PULL,
-  "pair"   => OMQ::PAIR,
-  "dealer" => OMQ::DEALER,  "router" => OMQ::ROUTER,
-}.freeze
-
-SEND_ONLY = [OMQ::PUB, OMQ::PUSH].freeze
-RECV_ONLY = [OMQ::SUB, OMQ::PULL].freeze
-
-klass = SOCKET_TYPES[type_name.downcase]
-
-abort "--msgpack requires the msgpack gem"              if opts[:format] == :msgpack && !HAS_MSGPACK
-abort "--compress requires the zstd-ruby gem"           if opts[:compress] && !HAS_ZSTD
-
-(opts[:connects] + opts[:binds]).each do |url|
-  abort "inproc not supported, use tcp:// or ipc://" if url.include?("inproc://")
-end
-
-if RECV_ONLY.include?(klass) && (opts[:data] || opts[:file])
-  abort "--data/--file not valid for #{type_name} (receive-only)"
-end
-
-# ── URL normalization ───────────────────────────────────────────────
-
-normalize = ->(url) { url.sub(%r{\Atcp://:}, "tcp://*:") }
-opts[:connects].map!(&normalize)
-opts[:binds].map!(&normalize)
-
-# ── Format helpers ──────────────────────────────────────────────────
-
-def format_output(parts, fmt)
-  case fmt
-  when :ascii
-    parts.map { |p| p.b.gsub(/[^[:print:]\t]/, ".") }.join("\t") + "\n"
-  when :quoted
-    parts.map { |p|
-      p.b.gsub(/[^[:print:]]/) { |c|
-        case c
-        when "\n" then "\\n"
-        when "\r" then "\\r"
-        when "\t" then "\\t"
-        when "\\" then "\\\\"
-        else format("\\x%02x", c.ord)
-        end
-      }
-    }.join("\t") + "\n"
-  when :raw
-    parts.join
-  when :jsonl
-    JSON.generate(parts) + "\n"
-  when :msgpack
-    MessagePack.pack(parts)
-  end
-end
-
-def parse_input(line, fmt)
-  case fmt
-  when :ascii
-    line.chomp.split("\t")
-  when :quoted
-    line.chomp.split("\t").map { |p|
-      p.gsub(/\\(?:n|r|t|\\|x[0-9a-fA-F]{2})/) { |m|
-        case m
-        when "\\n" then "\n"
-        when "\\r" then "\r"
-        when "\\t" then "\t"
-        when "\\\\" then "\\"
-        else [m[2..].to_i(16)].pack("C")
-        end
-      }
-    }
-  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 read_message_msgpack(io)
-  @msgpack_unpacker ||= MessagePack::Unpacker.new(io)
-  @msgpack_unpacker.read
-rescue EOFError
-  nil
-end
-
-# ── Compression helpers ─────────────────────────────────────────────
-
-def compress_frames(parts)
-  parts.map { |p| Zstd.compress(p) }
-end
-
-def decompress_frames(parts)
-  parts.map { |p| Zstd.decompress(p) }
-end
-
-# ── CURVE setup ─────────────────────────────────────────────────────
-
-def setup_curve(sock, opts)
-  server_key_z85 = opts[:curve_server_key] || ENV["OMQ_SERVER_KEY"]
-  server_mode    = opts[:curve_server] || (ENV["OMQ_SERVER_PUBLIC"] && ENV["OMQ_SERVER_SECRET"])
-
-  if server_key_z85
-    # Client mode
-    require "omq/curve"
-    server_key = OMQ::Z85.decode(server_key_z85)
-    client_key = RbNaCl::PrivateKey.generate
-    sock.mechanism = OMQ::Curve.client(
-      client_key.public_key.to_s, client_key.to_s, server_key: server_key
-    )
-  elsif server_mode
-    # Server mode
-    require "omq/curve"
-    if ENV["OMQ_SERVER_PUBLIC"] && ENV["OMQ_SERVER_SECRET"]
-      server_pub = OMQ::Z85.decode(ENV["OMQ_SERVER_PUBLIC"])
-      server_sec = OMQ::Z85.decode(ENV["OMQ_SERVER_SECRET"])
-    else
-      key        = RbNaCl::PrivateKey.generate
-      server_pub = key.public_key.to_s
-      server_sec = key.to_s
-    end
-    sock.mechanism = OMQ::Curve.server(server_pub, server_sec)
-    $stderr.puts "OMQ_SERVER_KEY='#{OMQ::Z85.encode(server_pub)}'"
-  end
-rescue LoadError
-  abort "omq-curve gem required for CURVE encryption: gem install omq-curve"
-end
-
-# ── I/O helpers ─────────────────────────────────────────────────────
-
-def read_next(opts)
-  if opts[:data]
-    parse_input(opts[:data] + "\n", opts[:format])
-  elsif opts[:file]
-    @file_data ||= (opts[:file] == "-" ? $stdin.read : File.read(opts[:file])).chomp
-    parse_input(@file_data + "\n", opts[:format])
-  elsif opts[:format] == :msgpack
-    read_message_msgpack($stdin)
-  elsif opts[:format] == :raw
-    data = $stdin.read
-    return nil if data.nil? || data.empty?
-    [data]
-  else
-    line = $stdin.gets
-    return nil if line.nil?
-    parse_input(line, opts[:format])
-  end
-end
-
-def send_msg(sock, parts, opts)
-  return if parts.empty?
-  parts = compress_frames(parts) if opts[:compress]
-  sock.send(parts)
-end
-
-def recv_msg(sock, opts)
-  parts = sock.receive
-  parts = decompress_frames(parts) if opts[:compress]
-  parts
-end
-
-def eval_expr(parts, sock, opts)
-  return parts unless opts[:expr]
-  $F = parts
-  result = sock.instance_eval(opts[:expr], "-e") # rubocop:disable Security/Eval
-  case result
-  when nil    then nil
-  when Array  then result
-  when String then [result]
-  else [result.to_s]
-  end
-end
-
-def count_reached?(i, opts)
-  opts[:count] && opts[:count] > 0 && i >= opts[:count]
-end
-
-def output(parts, opts)
-  return if opts[:quiet]
-  parts = [""] if parts.nil?
-  $stdout.write(format_output(parts, opts[:format]))
-  $stdout.flush
-end
-
-def log(msg)
-  $stderr.puts(msg)
-end
-
-# ── Loop methods ────────────────────────────────────────────────────
-
-def send_loop(sock, opts)
-  i = 0
-  if opts[:data] || opts[:file]
-    loop do
-      parts = read_next(opts)
-      break unless parts
-      parts = eval_expr(parts, sock, opts)
-      sleep(opts[:delay]) if opts[:delay] && i == 0
-      send_msg(sock, parts, opts) if parts
-      i += 1
-      break if count_reached?(i, opts)
-      if opts[:interval]
-        sleep(opts[:interval])
-      else
-        break # single send without -i
-      end
-    end
-  else
-    loop do
-      parts = read_next(opts)
-      break unless parts
-      parts = eval_expr(parts, sock, opts)
-      sleep(opts[:delay]) if opts[:delay] && i == 0
-      send_msg(sock, parts, opts) if parts
-      i += 1
-      break if count_reached?(i, opts)
-      sleep(opts[:interval]) if opts[:interval]
-    end
-  end
-end
-
-def recv_loop(sock, opts)
-  i = 0
-  loop do
-    parts = recv_msg(sock, opts)
-    parts = eval_expr(parts, sock, opts)
-    output(parts, opts)
-    i += 1
-    break if count_reached?(i, opts)
-  end
-end
-
-def req_loop(sock, opts)
-  i = 0
-  loop do
-    parts = read_next(opts)
-    break unless parts
-    sleep(opts[:delay]) if opts[:delay] && i == 0
-    send_msg(sock, parts, opts)
-    reply = recv_msg(sock, opts)
-    reply = eval_expr(reply, sock, opts)
-    output(reply, opts)
-    i += 1
-    break if count_reached?(i, opts)
-    if opts[:interval]
-      sleep(opts[:interval])
-    elsif !opts[:data] && !opts[:file]
-      next # stdin mode: keep reading lines
-    else
-      break # single exchange with -D/-F and no -i
-    end
-  end
-end
-
-def rep_loop(sock, opts)
-  i = 0
-  loop do
-    msg = recv_msg(sock, opts)
-    if opts[:expr]
-      reply = eval_expr(msg, sock, opts)
-      output(reply, opts)
-      send_msg(sock, reply || [""], opts)
-    elsif opts[:echo]
-      output(msg, opts)
-      send_msg(sock, msg, opts)
-    elsif opts[:data] || opts[:file] || !$stdin.tty?
-      reply = read_next(opts)
-      break unless reply  # EOF on stdin/-F
-      output(msg, opts)
-      send_msg(sock, reply, opts)
-    else
-      abort "REP needs a reply source: --echo, --data, --file, -e, or stdin pipe"
-    end
-    i += 1
-    break if count_reached?(i, opts)
-  end
-end
-
-def pair_loop(sock, opts, task)
-  receiver = task.async do
-    i = 0
-    loop do
-      parts = recv_msg(sock, opts)
-      parts = eval_expr(parts, sock, opts)
-      output(parts, opts)
-      i += 1
-      break if count_reached?(i, opts)
-    end
-  end
-
-  sender = task.async do
-    i = 0
-    loop do
-      parts = read_next(opts)
-      break unless parts
-      parts = eval_expr(parts, sock, opts)
-      sleep(opts[:delay]) if opts[:delay] && i == 0
-      send_msg(sock, parts, opts) if parts
-      i += 1
-      break if count_reached?(i, opts)
-      break if (opts[:data] || opts[:file]) && !opts[:interval]
-      sleep(opts[:interval]) if opts[:interval]
-    end
-  end
-
-  if opts[:count] && opts[:count] > 0
-    receiver.wait
-    sender.stop
-  else
-    sender.wait
-    receiver.stop
-  end
-end
-
-def router_loop(sock, opts, task)
-  receiver = task.async do
-    i = 0
-    loop do
-      parts = recv_msg(sock, opts)
-      # parts = [identity, "", ...payload]
-      identity = parts.shift
-      parts.shift if parts.first == "" # remove empty delimiter
-      # Z85-encode binary identities for display
-      id_display = identity.bytes.all? { |b| b >= 0x20 && b <= 0x7E } ? identity : OMQ::Z85.encode(identity.ljust(((identity.bytesize + 3) / 4) * 4, "\x00"))
-      result = eval_expr([id_display, *parts], sock, opts)
-      output(result, opts)
-      i += 1
-      break if count_reached?(i, opts)
-    end
-  end
-
-  sender = task.async do
-    i = 0
-    loop do
-      parts = read_next(opts)
-      break unless parts
-      sleep(opts[:delay]) if opts[:delay] && i == 0
-      if opts[:target]
-        parts = [opts[:target], "", *parts]
-      end
-      send_msg(sock, parts, opts)
-      i += 1
-      break if count_reached?(i, opts)
-      break if (opts[:data] || opts[:file]) && !opts[:interval]
-      sleep(opts[:interval]) if opts[:interval]
-    end
-  end
-
-  # If count is set, the receiver will exit when count is reached.
-  # Otherwise, wait for Ctrl-C.
-  if opts[:count] && opts[:count] > 0
-    receiver.wait
-    sender.stop
-  else
-    sender.wait
-    receiver.stop
-  end
-end
-
-# ── Signal handling ─────────────────────────────────────────────────
-
-trap("INT")  { Process.exit!(0) }
-trap("TERM") { Process.exit!(0) }
-
-# Silence Async's noisy task warnings unless verbose.
-Console.logger = Console::Logger.new(Console::Output::Null.new) unless opts[:verbose]
-
-# ── Main ────────────────────────────────────────────────────────────
-
-Async do |task|
-  sock = klass.new(nil, linger: 1)
-  sock.recv_timeout = opts[:recv_timeout] if opts[:recv_timeout]
-  sock.send_timeout = opts[:send_timeout] if opts[:send_timeout]
-  sock.identity     = opts[:identity]     if opts[:identity]
-
-  setup_curve(sock, opts)
-
-  opts[:binds].each do |url|
-    sock.bind(url)
-    log "Bound to #{sock.last_endpoint}" if opts[:verbose]
-  end
-
-  opts[:connects].each do |url|
-    sock.connect(url)
-    log "Connecting to #{url}" if opts[:verbose]
-  end
-
-  if klass == OMQ::SUB
-    prefixes = opts[:subscribes].empty? ? [""] : opts[:subscribes]
-    prefixes.each { |p| sock.subscribe(p) }
-  end
-
-  sleep(opts[:delay]) if opts[:delay] && RECV_ONLY.include?(klass)
-
-  if    SEND_ONLY.include?(klass)  then send_loop(sock, opts)
-  elsif RECV_ONLY.include?(klass)  then recv_loop(sock, opts)
-  elsif klass == OMQ::REQ          then req_loop(sock, opts)
-  elsif klass == OMQ::REP          then rep_loop(sock, opts)
-  elsif klass == OMQ::ROUTER       then router_loop(sock, opts, task)
-  elsif opts[:data] || opts[:file] then send_loop(sock, opts)
-  else                                   pair_loop(sock, opts, task)
-  end
-
-ensure
-  sock&.close
-end