omq-cli 0.16.2 → 0.17.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 65853ffed26725eec94127f166458f4358e3bc0217ac608f729361f76bf81595
-  data.tar.gz: 85378ff431328f8e8c0ca03c7f9ea561771d598fa4c25c2824c3f8e4aa8b310d
+  metadata.gz: 9328ae563951fd25f16f512790bdcc70cf041c8ffabae24622d6ab3ffa1dfffe
+  data.tar.gz: 933eb13378689905ffe1b908b7ca4f5dae8a3b678832aad20e29de37d0d6748d
 SHA512:
-  metadata.gz: 4d5f29b3fe396efb10031ff2d98ba97424798a3345c13be6f8c419affcce467a3c1196faa6b31a9c741ce3577328e9e9e2df86a031cd1fb2e9865cf162945ce4
-  data.tar.gz: 95e41fe15805c6d123f60cbe8fe451749b21e8666165ec5390553bdf141c398a51706351bb387e46ac797d71fdf984b87187c72cdf4095aefb980ffbdaf69734
+  metadata.gz: 60e516ab7792ecef5f47d18b84bac5b25f5a4287152d54ed06a649fd6f1b190c7bef32ae833dd92b7c832037bef473691942104d00d1ff6d511d84133c455cca
+  data.tar.gz: e6ff35c82124cc0791703248a50b85bfc9f744971777dc485089d9aa47f7598e43646e7fd450b9293fc64ad4ef2479dc8fcb1ba2e0fb6bb4cbd85b2f6036d3f0

data/CHANGELOG.md

@@ -1,5 +1,53 @@
 # Changelog
 
+## 0.17.1 — 2026-05-04
+
+- bump deps
+
+## 0.17.0 — 2026-04-25
+
+- **LZ4 compression via `--lz4`.** Complements Zstd with a
+  lower-CPU, lower-memory codec (no entropy stage, ~16 KiB of
+  encoder state per connection). Uses the `lz4+tcp://` transport
+  from `omq-lz4`. The existing `--compress` flag now accepts a
+  codec-aware `SPEC`:
+  ```
+  --compress=zstd            # zstd at default level
+  --compress=zstd:3          # zstd level 3
+  --compress=zstd:-1         # zstd level -1
+  --compress=lz4             # lz4 (no level)
+  --compress=19              # back-compat: zstd level 19
+  ```
+  `Config.compress` becomes a tri-state symbol
+  (`nil` / `:zstd` / `:lz4`); `SocketSetup.compress_url` picks
+  `zstd+tcp://` or `lz4+tcp://` accordingly. Adds `omq-lz4` as a
+  runtime dependency.
+- **`omq pipe`: `-z` / `-Z` / `--compress` are modal with
+  `--in` / `--out`.** Placing a compression flag after `--in`
+  compresses only the PULL side; after `--out` only the PUSH
+  side. A flag before any `--in`/`--out` still applies globally
+  (backwards compatible). New `Config` fields
+  `in_compress` / `in_compress_level` /
+  `out_compress` / `out_compress_level` carry the per-side
+  state; `SocketSetup.resolve_compress(config, side)` is the
+  single resolution point, and `SocketSetup.attach_endpoints`
+  takes a `side:` kwarg.
+- **Bind-mode senders with piped stdin now wait for a peer.**
+  `seq 10 | omq push -b tcp://…` previously bound, drained all
+  messages into HWM, then exited before any consumer connected.
+  Non-tty stdin now counts as a bounded send plan in
+  `BaseRunner#bounded_or_scheduled_send?`, matching the existing
+  behaviour for `-d` / `-F` / `-E`. Interactive-tty senders still
+  go through unwaited so typing isn't gated on a peer.
+
+## 0.16.4 — 2026-04-20
+
+- **Use omq ~> v0.26.2
+
+## 0.16.3 — 2026-04-20
+
+- **Use omq ~> v0.26.1
+
 ## 0.16.2 — 2026-04-18
 
 - **Use omq ~> v0.24.0 and omq-ffi >= v0.3.1**

data/lib/omq/cli/base_runner.rb

@@ -155,7 +155,11 @@ module OMQ
 
 
       def bounded_or_scheduled_send?
-        config.interval || config.data || config.file || @send_eval_proc
+        return true if config.interval || config.data || config.file || @send_eval_proc
+        # Piped stdin (non-tty) is also a bounded send plan: we read
+        # until EOF and exit. Without a peer wait, a bind-mode sender
+        # dumps straight into HWM and closes before any peer connects.
+        !config.stdin_is_tty
       end
 
 
@@ -533,7 +537,9 @@ module OMQ
       def set_process_title(endpoints: nil)
         eps = endpoints || config.endpoints
         title = ["omq", config.type_name]
-        title << "-z" if config.compress
+        if (flag = SocketSetup.compress_flag(config))
+          title << flag
+        end
         title << "-P#{config.parallel}" if config.parallel
         eps.each do |ep|
           title << (ep.respond_to?(:url) ? ep.url : ep.to_s)

data/lib/omq/cli/cli_parser.rb

@@ -144,12 +144,26 @@ module OMQ
 
         -- Compression ----------------------------------------------
 
-          # -z rewrites tcp:// endpoints to zstd+tcp:// (the dedicated
-          # compressed TCP transport from omq-zstd). Both peers must
-          # pass -z; non-TCP endpoints are unaffected.
+          # -z / -Z / --lz4 rewrite tcp:// endpoints to zstd+tcp:// or
+          # lz4+tcp:// (dedicated compressed transports from omq-zstd
+          # and omq-lz4). Both peers must agree on the codec; non-TCP
+          # endpoints are unaffected.
           omq pull --bind tcp://:5557 -z &
           echo "compressible data" | omq push --connect tcp://localhost:5557 -z
 
+          # LZ4: no entropy stage, ~4–8× faster encode than zstd,
+          # ~3× less memory. Pick it when CPU or RAM is tighter than
+          # bandwidth.
+          omq pull --bind tcp://:5557 --lz4 &
+          echo "hello" | omq push --connect tcp://localhost:5557 --lz4
+
+          # Explicit spec form (same for -e, -f, or --compress):
+          omq pull -b tcp://:5557 --compress=zstd:3
+          omq pull -b tcp://:5557 --compress=lz4
+
+          # Pipe with asymmetric codecs (decompresses lz4 in, re-emits zstd out):
+          omq pipe --in --lz4 -c tcp://src:5555 --out -z -c tcp://dst:6666
+
         -- CURVE Encryption -----------------------------------------
 
           # server (prints OMQ_SERVER_KEY=...)
@@ -245,8 +259,12 @@ module OMQ
         sndbuf:           nil,
         rcvbuf:           nil,
         conflate:         false,
-        compress:         false,
-        compress_level:   nil,
+        compress:         nil,   # nil | :zstd | :lz4
+        compress_level:   nil,   # Integer (zstd only)
+        in_compress:        nil,
+        in_compress_level:  nil,
+        out_compress:       nil,
+        out_compress_level: nil,
         send_expr:        nil,
         recv_expr:        nil,
         parallel:         nil,
@@ -405,18 +423,26 @@ module OMQ
           o.separator "\nDelivery:"
           o.on("--conflate", "Keep only last message per subscriber (PUB/RADIO)") { opts[:conflate] = true }
 
-          o.separator "\nCompression:"
-          o.on("-z", "Zstd compression (level -3, fast)") do
-            opts[:compress] = true
-            opts[:compress_level] = -3
-          end
-          o.on("-Z", "Zstd compression (level 3, better ratio)") do
-            opts[:compress] = true
-            opts[:compress_level] = 3
+          o.separator "\nCompression (modal with --in/--out for pipe):"
+          set_compress = lambda do |codec, level|
+            case pipe_side
+            when :in
+              opts[:in_compress] = codec
+              opts[:in_compress_level] = level
+            when :out
+              opts[:out_compress] = codec
+              opts[:out_compress_level] = level
+            else
+              opts[:compress] = codec
+              opts[:compress_level] = level
+            end
           end
-          o.on("--compress=LEVEL", Integer, "Zstd compression with custom level (e.g. 19, -1)") do |v|
-            opts[:compress] = true
-            opts[:compress_level] = v
+          o.on("-z",    "Zstd compression (level -3, fast)")        { set_compress.call(:zstd, -3) }
+          o.on("-Z",    "Zstd compression (level 3, better ratio)") { set_compress.call(:zstd, 3) }
+          o.on("--lz4", "LZ4 compression (FAST)")                   { set_compress.call(:lz4, nil) }
+          o.on("--compress=SPEC", "Explicit codec[:level], e.g. zstd, zstd:3, zstd:-1, lz4") do |v|
+            codec, level = parse_compress_spec(v)
+            set_compress.call(codec, level)
           end
 
           o.separator "\nProcessing (-e = incoming, -E = outgoing):"
@@ -499,6 +525,30 @@ module OMQ
       end
 
 
+      # Parses a --compress SPEC string.
+      #
+      # Accepted forms:
+      #   "zstd"         → [:zstd, nil]  (SocketSetup picks the default)
+      #   "zstd:3"       → [:zstd, 3]
+      #   "zstd:-1"      → [:zstd, -1]
+      #   "lz4"          → [:lz4, nil]
+      #   "-1" | "19"    → [:zstd, N]    (back-compat with 0.16.x --compress=LEVEL)
+      #
+      # Aborts on anything else (including "lz4:N", since the lz4+tcp
+      # transport has no compression-level knob).
+      #
+      def parse_compress_spec(str)
+        case str
+        when /\Azstd\z/            then [:zstd, nil]
+        when /\Azstd:(-?\d+)\z/    then [:zstd, $1.to_i]
+        when /\Alz4\z/             then [:lz4, nil]
+        when /\A-?\d+\z/           then [:zstd, str.to_i]
+        else
+          abort "invalid --compress spec: #{str} (use zstd, zstd:LEVEL, or lz4)"
+        end
+      end
+
+
       # Parses a byte size string with an optional K/M/G suffix (binary,
       # i.e. 1K = 1024 bytes).
       #
@@ -547,7 +597,7 @@ module OMQ
             abort "pipe requires exactly 2 endpoints (pull-side and push-side), or use --in/--out" if opts[:endpoints].size != 2
           end
         else
-          abort "--in/--out are only valid for pipe" if opts[:in_endpoints].any? || opts[:out_endpoints].any?
+          abort "--in/--out are only valid for pipe" if opts[:in_endpoints].any? || opts[:out_endpoints].any? || opts[:in_compress] || opts[:out_compress]
           abort "At least one --connect or --bind is required" if opts[:connects].empty? && opts[:binds].empty?
         end
         abort "--data and --file are mutually exclusive"        if opts[:data] && opts[:file]

data/lib/omq/cli/config.rb

@@ -45,6 +45,10 @@ module OMQ
       :conflate,
       :compress,
       :compress_level,
+      :in_compress,
+      :in_compress_level,
+      :out_compress,
+      :out_compress_level,
       :send_expr,
       :recv_expr,
       :parallel,

data/lib/omq/cli/pipe.rb

@@ -91,7 +91,8 @@ module OMQ
           SocketSetup.attach_endpoints sock, in_eps,
             config:     config,
             verbose:    config.verbose,
-            timestamps: config.timestamps
+            timestamps: config.timestamps,
+            side:       :in
         end
 
         push = OMQ::PUSH.new(**kwargs).tap do |sock|
@@ -99,7 +100,8 @@ module OMQ
           SocketSetup.attach_endpoints sock, out_eps,
             config:     config,
             verbose:    config.verbose,
-            timestamps: config.timestamps
+            timestamps: config.timestamps,
+            side:       :out
         end
 
         [pull, push]
@@ -186,12 +188,22 @@ module OMQ
 
       def set_pipe_process_title
         in_eps, out_eps = resolve_endpoints
+        in_flag  = SocketSetup.compress_flag(config, side: :in)
+        out_flag = SocketSetup.compress_flag(config, side: :out)
         title = ["omq pipe"]
-        title << "-z" if config.compress
         title << "-P#{config.parallel}" if config.parallel
-        title.concat(in_eps.map(&:url))
-        title << "->"
-        title.concat(out_eps.map(&:url))
+        if in_flag && in_flag == out_flag
+          title << in_flag
+          title.concat(in_eps.map(&:url))
+          title << "->"
+          title.concat(out_eps.map(&:url))
+        else
+          title << "--in" << in_flag if in_flag
+          title.concat(in_eps.map(&:url))
+          title << "->"
+          title << out_flag if out_flag
+          title.concat(out_eps.map(&:url))
+        end
 
         Process.setproctitle(title.join(" "))
       end

data/lib/omq/cli/pipe_worker.rb

@@ -44,8 +44,8 @@ module OMQ
         OMQ::CLI::SocketSetup.apply_options(@pull, @config)
         OMQ::CLI::SocketSetup.apply_options(@push, @config)
         OMQ::CLI::SocketSetup.apply_recv_maxsz(@pull, @config)
-        OMQ::CLI::SocketSetup.attach_endpoints(@pull, @in_eps, config: @config, verbose: 0)
-        OMQ::CLI::SocketSetup.attach_endpoints(@push, @out_eps, config: @config, verbose: 0)
+        OMQ::CLI::SocketSetup.attach_endpoints(@pull, @in_eps, config: @config, verbose: 0, side: :in)
+        OMQ::CLI::SocketSetup.attach_endpoints(@push, @out_eps, config: @config, verbose: 0, side: :out)
       end
 
 

data/lib/omq/cli/socket_setup.rb

@@ -22,23 +22,67 @@ module OMQ
       # it entirely with --recv-maxsz 0.
       DEFAULT_RECV_MAXSZ = 1 << 20
 
-      # Upgrades a +tcp://+ URL to +zstd+tcp://+ when compression is enabled.
-      # Returns the URL unchanged for non-TCP or when compression is off.
+      # Default zstd level when the user picks zstd without specifying one
+      # (e.g. `--compress=zstd`). Matches the `-z` shortcut.
+      DEFAULT_ZSTD_LEVEL = -3
+
+      # Resolves compression state for a given pipe +side+ (:in, :out, or nil).
+      # Per-side settings (in_compress / out_compress) override the global
+      # +config.compress+. Returns +[codec, level]+ where codec is one of
+      # +nil+ (off), +:zstd+, or +:lz4+.
       #
-      def self.compress_url(url, config)
-        return url unless config.compress
+      def self.resolve_compress(config, side)
+        scoped =
+          case side
+          when :in  then !config.in_compress.nil?
+          when :out then !config.out_compress.nil?
+          end
+
+        if scoped && side == :in
+          [config.in_compress,  config.in_compress_level]
+        elsif scoped && side == :out
+          [config.out_compress, config.out_compress_level]
+        else
+          [config.compress, config.compress_level]
+        end
+      end
+
+
+      # Upgrades a +tcp://+ URL to the codec-specific variant
+      # (+zstd+tcp://+ or +lz4+tcp://+) when compression is enabled
+      # for the given +side+. Returns the URL unchanged for non-TCP or
+      # when compression is off.
+      #
+      def self.compress_url(url, config, side: nil)
+        codec, _ = resolve_compress(config, side)
+        return url if codec.nil?
         return url unless url.start_with?("tcp://")
 
-        url.sub("tcp://", "zstd+tcp://")
+        url.sub("tcp://", "#{codec}+tcp://")
       end
 
 
-      # Returns bind/connect kwargs for compression (level:) when enabled.
+      # Returns bind/connect kwargs for the chosen codec on the given
+      # +side+. Zstd accepts a +level:+; LZ4 takes no tuning knobs.
       #
-      def self.compress_opts(config)
-        return {} unless config.compress
+      def self.compress_opts(config, side: nil)
+        codec, level = resolve_compress(config, side)
+        case codec
+        when :zstd then { level: level || DEFAULT_ZSTD_LEVEL }
+        else            {}
+        end
+      end
 
-        { level: config.compress_level || -3 }
+
+      # Human-readable CLI flag for a resolved compress state, suitable
+      # for process titles and proctitle-like log lines.
+      #
+      def self.compress_flag(config, side: nil)
+        codec, level = resolve_compress(config, side)
+        case codec
+        when :zstd then level == 3 ? "-Z" : "-z"
+        when :lz4  then "--lz4"
+        end
       end
 
 
@@ -103,12 +147,14 @@ module OMQ
       # Bind/connect +sock+ from an Array of Endpoint objects.
       # Used by PipeRunner, which works with structured endpoint lists.
       # +verbose+ gates logging (>= 1), +timestamps+ controls prefix.
+      # +side+ selects per-socket compression (:in for PULL, :out for
+      # PUSH in a pipe); nil falls back to global compress settings.
       #
-      def self.attach_endpoints(sock, endpoints, config: nil, verbose: 0, timestamps: nil)
-        opts = config ? compress_opts(config) : {}
+      def self.attach_endpoints(sock, endpoints, config: nil, verbose: 0, timestamps: nil, side: nil)
+        opts = config ? compress_opts(config, side: side) : {}
 
         endpoints.each do |ep|
-          url = config ? compress_url(ep.url, config) : ep.url
+          url = config ? compress_url(ep.url, config, side: side) : ep.url
 
           if ep.bind?
             uri = sock.bind(url, **opts)

data/lib/omq/cli/version.rb

@@ -2,6 +2,6 @@
 
 module OMQ
   module CLI
-    VERSION = "0.16.2"
+    VERSION = "0.17.1"
   end
 end

data/lib/omq/cli.rb

@@ -207,6 +207,7 @@ module OMQ
       require "omq/channel"
       require "omq/peer"
       require "omq/zstd"
+      require "omq/lz4"
       require "async"
       require "json"
       require "console"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omq-cli
 version: !ruby/object:Gem::Version
-  version: 0.16.2
+  version: 0.17.1
 platform: ruby
 authors:
 - Patrik Wenger
@@ -15,34 +15,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.24'
+        version: '0.27'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.24'
+        version: '0.27'
 - !ruby/object:Gem::Dependency
-  name: omq-ffi
+  name: ffi
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.3'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.1
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.3'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.1
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: omq-zstd
   requirement: !ruby/object:Gem::Requirement
@@ -57,6 +51,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: omq-lz4
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
 - !ruby/object:Gem::Dependency
   name: msgpack
   requirement: !ruby/object:Gem::Requirement
@@ -88,8 +96,8 @@ dependencies:
 description: Command-line tool for sending and receiving ZeroMQ messages on any socket
   type (REQ/REP, PUB/SUB, PUSH/PULL, DEALER/ROUTER, and all draft types). Supports
   Ruby eval (-e/-E), script handlers (-r), pipe virtual socket with Ractor parallelism,
-  multiple formats (ASCII, JSON Lines, msgpack, Marshal), Zstd compression, and CURVE
-  encryption. Like nngcat from libnng, but with Ruby superpowers.
+  multiple formats (ASCII, JSON Lines, msgpack, Marshal), Zstd/LZ4 compression, and
+  CURVE encryption. Like nngcat from libnng, but with Ruby superpowers.
 email:
 - paddor@gmail.com
 executables: