omq-backend-rust 0.1.4 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f88c907143589e86949e595e966f073a907bde07f345f9bc6dff8e66202a8f8f
-  data.tar.gz: d61cde4ecb12f9a31dd213405eab776f192884b2346be18d2da9eeea8d131669
+  metadata.gz: a08620eb9fd1a781752e72f44186bbaee5fcefd37d92560901aa8fb7c6e4f269
+  data.tar.gz: 891cc692da98d5cd7e2daf2a461e06b4c7b41de91f88964d1d9f7cbc20616f9a
 SHA512:
-  metadata.gz: 3be9baa628d9715360d9388bd2bdeb77fc6d1fc45e3dbb135f72d0834ed21b3e4fae4c5e086fa596a84789efc5211cdf7d7afce3084a1eb3c6d9d4796899e01b
-  data.tar.gz: 16079c0457a106b79144d2e217e281e9cd1d629fd62d4c5ca2bb81637079092b6e652a26df06f31945a7293b05b8e99678782d70a1a0ac53695e270bd9461898
+  metadata.gz: 37745e0ab15d9dabd1ec62262c821951ee489a6bc11f86eee30c355b9fff07909246800e2ac6184379d46bd958258c411a5be55fadaf052af92c7ef01d3e024f
+  data.tar.gz: 2b89190343754d64b322efa8cbb08f880900324247b87d7b0cbb4df6c5af195caa1da41d3909a32168e8f5ad12f3a82714648a43521e789ea70ff5b053c514c9

data/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 ## [Unreleased]
 
+## [0.1.6] - 2026-08-01
+
+### Added
+
+- Updated to `omq-tokio` 0.20.3 and `omq-proto` 0.25.0.
+- Enabled OMQ.rs `zstd+tcp://` by default.
+- Forwarded compression bind/connect kwargs to current OMQ.rs options:
+  `dict:`, `auto_dict:`, `compression_threshold:`, `max_recv_dict_size:`,
+  `compression_offload_threshold:`, and zstd `level:`.
+
+## [0.1.5] - 2026-07-31
+
+### Fixed
+
+- Used `IO#wait_readable` for Rust backend receive waits and routed
+  `close_read` wakeups through the native receive notifier.
+- Updated to `omq-tokio` 0.20.2, fixing large byte-stream `PUB` fan-out
+  delivery over IPC and TCP.
+
 ## [0.1.4] - 2026-07-30
 
 ### Fixed

data/README.md

@@ -58,6 +58,18 @@ SCATTER/GATHER, CHANNEL.
 - **NULL** (default)
 - **CURVE** (CurveZMQ, via [Nuckle](https://github.com/paddor/nuckle))
 
+## Compressed transports
+
+The Rust backend supports `lz4+tcp://` and `zstd+tcp://`. Compression
+configuration uses the same bind/connect kwargs as the Ruby transports:
+`level:` for zstd compression level (`-8..4`), `dict:` for a static
+send-side dictionary, and `auto_dict: true` for automatic dictionary
+training.
+
+Automatic dictionary training is off by default.
+OMQ.rs stores compression configuration per socket, so pass these kwargs on
+the first `bind` or `connect` for a Rust-backed socket.
+
 ## Development
 
 ```sh

data/ext/omq_backend_rust/Cargo.toml

@@ -11,16 +11,17 @@ name       = "omq_backend_rust"
 crate-type = ["cdylib"]
 
 [features]
-default = ["plain", "curve", "lz4"]
+default = ["plain", "curve", "lz4", "zstd"]
 plain   = ["omq-tokio/plain"]
 curve   = ["omq-tokio/curve"]
 lz4     = ["omq-tokio/lz4"]
+zstd    = ["omq-tokio/zstd"]
 
 [dependencies]
-omq-proto = { version = "=0.24.1", default-features = false }
-omq-tokio = { version = "=0.20.1", default-features = false }
+omq-proto = { version = "=0.25.0", default-features = false }
+omq-tokio = { version = "=0.20.3", default-features = false }
 tokio     = { version = "1.52.0", features = ["rt", "rt-multi-thread", "time", "sync", "io-util", "net"] }
-yring     = { version = "0.3.8", features = ["async"] }
+yring     = { version = "0.3.11", features = ["async"] }
 
 bytes   = "1.12.0"
 flume   = { version = "0.12", default-features = false, features = ["async"] }

data/ext/omq_backend_rust/src/options.rs

@@ -48,6 +48,29 @@ pub fn build_options(ruby: &Ruby, hash: RHash) -> Result<omq_tokio::Options, Err
     if let Some(v) = get_opt::<i64>(ruby, hash, "rcvbuf")? {
         opts.recv_buffer_size = Some(v as usize);
     }
+    if let Some(v) = get_opt_bytes(ruby, hash, "compression_dict")? {
+        if !v.is_empty() {
+            opts.compression_dict = Some(Bytes::from(v));
+        }
+    }
+    if let Some(v) = get_opt::<bool>(ruby, hash, "compression_auto_train")? {
+        opts.compression_auto_train = v;
+    }
+    if let Some(v) = get_opt::<i64>(ruby, hash, "compression_threshold")? {
+        opts.compression_threshold = Some(v as usize);
+    }
+    if let Some(v) = get_opt::<i64>(ruby, hash, "compression_level")? {
+        opts.compression_level = Some(v as i32);
+    }
+    if let Some(v) = get_opt::<i64>(ruby, hash, "compression_dict_capacity")? {
+        opts.compression_dict_capacity = Some(v as usize);
+    }
+    if let Some(v) = get_opt::<i64>(ruby, hash, "max_recv_dict_size")? {
+        opts.max_recv_dict_size = Some(v as usize);
+    }
+    if let Some(v) = get_opt::<i64>(ruby, hash, "compression_offload_threshold")? {
+        opts.compression_offload_threshold = if v < 0 { None } else { Some(v as usize) };
+    }
     if let Some(v) = get_opt::<String>(ruby, hash, "on_mute")? {
         opts.on_mute = match v.as_str() {
             "drop_newest" | "drop" => omq_tokio::OnMute::DropNewest,

data/ext/omq_backend_rust/src/socket.rs

@@ -250,6 +250,13 @@ fn rust_socket_try_recv_batch(ruby: &Ruby, rb_self: &RustSocket) -> Result<Optio
     }
 }
 
+fn rust_socket_wake_recv(rb_self: &RustSocket) {
+    let mat_guard = rb_self.materialized.read().unwrap();
+    if let Some(mat) = mat_guard.as_ref() {
+        mat.recv_notify.force_wake();
+    }
+}
+
 fn rust_socket_recv_fd(ruby: &Ruby, rb_self: &RustSocket) -> Result<i32, Error> {
     let mat_guard = rb_self.materialized.read().unwrap();
     let mat = mat_guard
@@ -442,6 +449,7 @@ pub fn register(ruby: &Ruby) -> Result<(), Error> {
     class.define_method("enqueue_send", method!(rust_socket_enqueue_send, 1))?;
     class.define_method("try_recv", method!(rust_socket_try_recv, 0))?;
     class.define_method("try_recv_batch", method!(rust_socket_try_recv_batch, 0))?;
+    class.define_method("wake_recv", method!(rust_socket_wake_recv, 0))?;
     class.define_method("recv_fd", method!(rust_socket_recv_fd, 0))?;
     class.define_method("send_fd", method!(rust_socket_send_fd, 0))?;
     class.define_method(

data/lib/omq/rust/engine.rb

@@ -25,8 +25,7 @@ module OMQ
         @on_io_thread   = false
         @materialized   = false
         @recv_sentinels = 0
-        @recv_sentinel_r = nil
-        @recv_sentinel_w = nil
+        @compression_options = {}
 
         @native = Native::RustSocket.new(socket_type.to_s)
 
@@ -49,16 +48,18 @@ module OMQ
       end
 
 
-      def bind(endpoint, parent: nil, **)
+      def bind(endpoint, parent: nil, **opts)
         capture_parent_task(parent: parent)
+        apply_endpoint_options!(opts)
         ensure_materialized
         resolved = @native.bind(endpoint)
         URI.parse(resolved)
       end
 
 
-      def connect(endpoint, parent: nil, **)
+      def connect(endpoint, parent: nil, **opts)
         capture_parent_task(parent: parent)
+        apply_endpoint_options!(opts)
         ensure_materialized
         @native.connect(endpoint)
         URI.parse(endpoint)
@@ -104,25 +105,20 @@ module OMQ
         return take_recv_sentinel if @recv_sentinels.positive?
 
         loop do
-          readable = IO.select([@recv_signal_r, @recv_sentinel_r]).first
+          @recv_signal_r.wait_readable
+          @recv_signal_r.read_nonblock(256, exception: false)
 
-          if readable.include?(@recv_signal_r)
-            @recv_signal_r.read_nonblock(256, exception: false)
-            msg = try_recv_batch
-            return msg
-          end
+          msg = try_recv_batch
+          return msg if msg
 
-          if readable.include?(@recv_sentinel_r)
-            @recv_sentinel_r.read_nonblock(256, exception: false)
-            return take_recv_sentinel if @recv_sentinels.positive?
-          end
+          return take_recv_sentinel if @recv_sentinels.positive?
         end
       end
 
 
       def dequeue_recv_sentinel
         @recv_sentinels += 1
-        @recv_sentinel_w&.write_nonblock(".", exception: false) rescue nil
+        @native.wake_recv if @materialized
         nil
       end
 
@@ -134,8 +130,6 @@ module OMQ
         @peer_connected.resolve(nil) unless @peer_connected.resolved?
         @all_peers_gone.resolve(nil) unless @all_peers_gone.resolved?
         @subscriber_joined.resolve(nil) unless @subscriber_joined.resolved?
-        @recv_sentinel_r&.close rescue nil
-        @recv_sentinel_w&.close rescue nil
         @native.close
       end
 
@@ -183,7 +177,6 @@ module OMQ
         @native.set_options(extract_options)
         @native.materialize
         @recv_signal_r = IO.for_fd(@native.recv_fd, autoclose: false)
-        ensure_recv_sentinel_pipe
         @materialized  = true
 
         @routing.replay_pending(@native)
@@ -196,13 +189,6 @@ module OMQ
       end
 
 
-      def ensure_recv_sentinel_pipe
-        return if @recv_sentinel_r
-
-        @recv_sentinel_r, @recv_sentinel_w = IO.pipe
-      end
-
-
       def take_recv_sentinel
         @recv_sentinels -= 1
         nil
@@ -258,6 +244,7 @@ module OMQ
         h["sndbuf"]             = @options.sndbuf
         h["rcvbuf"]             = @options.rcvbuf
         h["on_mute"]            = @options.on_mute.to_s
+        h.merge!(@compression_options)
 
         ri = @options.reconnect_interval
         if ri.is_a?(Range)
@@ -273,6 +260,88 @@ module OMQ
       end
 
 
+      def apply_endpoint_options!(opts)
+        compression = extract_endpoint_compression_options(opts)
+        return if compression.empty?
+
+        if @materialized
+          existing = compression.keys.to_h do |key|
+            [key, @compression_options.fetch(key, default_compression_option(key))]
+          end
+          return if compression == existing
+
+          raise ArgumentError,
+            "Rust backend compression options must be set before first bind/connect"
+        end
+
+        @compression_options.merge!(compression)
+      end
+
+
+      def extract_endpoint_compression_options(opts)
+        out = {}
+
+        if opts.key?(:level)
+          validate_zstd_level!(opts[:level])
+          out["compression_level"] = opts[:level]
+        end
+        out["compression_dict"] = opts[:dict].b if opts.key?(:dict) && opts[:dict]
+
+        if opts.key?(:auto_dict)
+          auto_dict = opts[:auto_dict]
+          if auto_dict && opts[:dict]
+            raise ArgumentError, "cannot combine auto_dict: and dict:"
+          end
+
+          case auto_dict
+          when nil, false
+            out["compression_auto_train"] = false
+          when true
+            out["compression_auto_train"] = true
+          when Hash
+            if auto_dict.key?(:trigger)
+              raise ArgumentError,
+                "Rust backend does not support auto_dict: trigger"
+            end
+            validate_positive!("auto_dict capacity", auto_dict[:capacity]) if auto_dict[:capacity]
+            out["compression_auto_train"] = true
+            out["compression_dict_capacity"] = auto_dict[:capacity] if auto_dict[:capacity]
+          else
+            raise TypeError, "auto_dict: must be true, false, or a Hash; got #{auto_dict.class}"
+          end
+        end
+
+        if opts.key?(:compression_threshold)
+          out["compression_threshold"] = opts[:compression_threshold]
+        end
+        out["max_recv_dict_size"] = opts[:max_recv_dict_size] if opts.key?(:max_recv_dict_size)
+        if opts.key?(:compression_offload_threshold)
+          out["compression_offload_threshold"] = opts[:compression_offload_threshold] || -1
+        end
+
+        out
+      end
+
+
+      def default_compression_option(key)
+        key == "compression_auto_train" ? false : nil
+      end
+
+
+      def validate_positive!(label, value)
+        return if value.respond_to?(:positive?) && value.positive?
+
+        raise ArgumentError, "#{label} must be positive"
+      end
+
+
+      def validate_zstd_level!(level)
+        return if level.is_a?(Integer) && (-8..4).cover?(level)
+
+        raise ArgumentError, "zstd compression level must be -8..4, got #{level.inspect}"
+      end
+
+
       def extract_mechanism(h)
         mech = @options.mechanism
         case mech

data/lib/omq/rust/version.rb

@@ -2,6 +2,6 @@
 
 module OMQ
   module Rust
-    VERSION = "0.1.4"
+    VERSION = "0.1.6"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omq-backend-rust
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.6
 platform: ruby
 authors:
 - Patrik Wenger