omq-rs 0.2.4 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 17a5d6530e2931083cc91a2f7335fffaa8a65dda79524c15e1e27b95c2c3f1fb
-  data.tar.gz: 88dadfe3d76e53acfaa726b8c1d0484b60ca5594659293476153b6d76f878416
+  metadata.gz: '068794048e18d65087a2f7feef656c5a69fce269140007ba804ff5394f417b22'
+  data.tar.gz: b80f54254186826e27d4c77ad024877150c083a253e2742cc73c3b1baf935797
 SHA512:
-  metadata.gz: d56a6e15bdcaaf835d5b0064c2171cc6397f45811f21d0706b59490f60c7eebcf1a0073e401b7da24d50dcad54a9ebc9dac2bdadfb51395df1f8f3f7b1613b07
-  data.tar.gz: bfc0e4c6d32cc26da88127e46fa2a387a10cd00372a67a49c2324b8c1946936399c0ebc380c1cb2b6eb9f590073a0e9c579f92eb81d60094501a720a6eabbff6
+  metadata.gz: 8a5c55beafa7d9db560069671d08a03080d746017c053b7f67608a795d73f41c9d98f515f32f4efdc55c9f5b133057be9ad6a7787cfe10d3bd967baec9f29563
+  data.tar.gz: 5428836642e04134201da527aedf24fb24dcaddb69650aeb264c1aeecec7110d7accebaa8c8f7d84cd353dab5013d2ff8e5b9f6b6492a26120c6365461776f0d

data/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## [Unreleased]
 
+## [0.2.5] - 2026-10-15
+
+### Fixed
+
+- Admit REQ/REP messages when Ruby receives them, so prefetched requests
+  cannot redirect replies or advance request/reply state.
+- Capture REP reply destinations at application send and preserve them
+  across backpressure retries.
+- Require `omq-tokio` 0.28.1 and `omq-proto` 0.32.1 to reject unrelated
+  REQ replies and REP requests without a body frame.
+
 ## [0.2.4] - 2026-10-15
 
 ### Fixed

data/ext/omq_rs_native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "omq_rs_native"
-version = "0.2.4"
+version = "0.2.5"
 edition = "2024"
 rust-version = "1.93"
 license = "ISC"
@@ -20,8 +20,8 @@ zstd = ["omq-tokio/zstd"]
 ws = ["omq-tokio/ws"]
 
 [dependencies]
-omq-proto = { version = "0.32.0", default-features = false }
-omq-tokio = { version = "0.28.0", default-features = false }
+omq-proto = { version = "0.32.1", default-features = false }
+omq-tokio = { version = "0.28.1", default-features = false }
 yring = { version = "0.3.20", features = ["async"] }
 
 bytes = "1.12.0"

data/ext/omq_rs_native/src/runtime.rs

@@ -129,6 +129,7 @@ pub struct Materialized {
     pub send_notify: Arc<PipeNotify>,
     pub recv_space: Arc<tokio::sync::Notify>,
     pub send_pump: JoinHandle<()>,
+    pub send_waiting: tokio::sync::watch::Sender<bool>,
     pub recv_pump: JoinHandle<()>,
 
     pub monitor_rx: flume::Receiver<MonitorEventData>,
@@ -294,7 +295,7 @@ async fn push_to_ring(
     }
 }
 
-#[expect(clippy::too_many_arguments)]
+#[expect(clippy::too_many_arguments, clippy::too_many_lines)]
 pub fn materialize(
     io_threads: usize,
     socket_type: omq_tokio::SocketType,
@@ -303,6 +304,7 @@ pub fn materialize(
     mut recv_prod: yring::Producer<omq_tokio::Message>,
     recv_notify: Arc<PipeNotify>,
     send_notify: Arc<PipeNotify>,
+    send_waiting: tokio::sync::watch::Sender<bool>,
     recv_space: Arc<tokio::sync::Notify>,
     monitor_tx: flume::Sender<MonitorEventData>,
     monitor_notify: Arc<PipeNotify>,
@@ -323,6 +325,12 @@ pub fn materialize(
         let s = sock.clone();
         let sn = send_notify.clone();
         let send_pump = tokio::spawn(async move {
+            if socket_type == omq_tokio::SocketType::Rep {
+                // REP submits at application send. Watch only failed sends;
+                // a successful retry cancels an obsolete capacity wait.
+                watch_rep_send_capacity(&s, &send_waiting, &sn).await;
+                return;
+            }
             let mut send_cons = send_cons;
             let mut budget = omq_proto::flow::DrainBudget::new(256, 1024 * 1024);
             while let Some(msg) = futures::StreamExt::next(&mut send_cons).await {
@@ -343,19 +351,27 @@ pub fn materialize(
         let rs = recv_space.clone();
         let recv_pump = tokio::spawn(async move {
             loop {
-                match s.recv().await {
+                match s.recv_for_external_recv().await {
                     Ok(msg) => {
+                        let mut budget = omq_proto::flow::DrainBudget::WORKER;
+                        let mut more = budget.account(msg.byte_len());
                         push_to_ring(&mut recv_prod, msg, &rs).await;
 
-                        while !recv_prod.is_full() {
-                            match s.try_recv() {
-                                Ok(msg) => push_to_ring(&mut recv_prod, msg, &rs).await,
+                        while more && !recv_prod.is_full() {
+                            match s.try_recv_for_external_recv() {
+                                Ok(msg) => {
+                                    more = budget.account(msg.byte_len());
+                                    push_to_ring(&mut recv_prod, msg, &rs).await;
+                                }
                                 Err(_) => break,
                             }
                         }
 
                         recv_prod.flush();
                         rn.force_wake();
+                        if !more {
+                            tokio::task::yield_now().await;
+                        }
                     }
                     Err(omq_tokio::Error::Closed) => break,
                     Err(_) => {}
@@ -417,6 +433,27 @@ pub fn materialize(
     recv_blocking(orx, "omq-rs: materialize failed")
 }
 
+async fn watch_rep_send_capacity(
+    socket: &InnerSocket,
+    requested: &tokio::sync::watch::Sender<bool>,
+    notify: &PipeNotify,
+) {
+    let mut waiting = requested.subscribe();
+    while waiting.wait_for(|requested| *requested).await.is_ok() {
+        tokio::select! {
+            () = socket.wait_send_ready() => {
+                requested.send_replace(false);
+                notify.force_wake();
+            }
+            changed = waiting.changed() => {
+                if changed.is_err() {
+                    break;
+                }
+            }
+        }
+    }
+}
+
 pub fn destroy_socket(
     io_threads: usize,
     sock: Arc<InnerSocket>,
@@ -428,6 +465,10 @@ pub fn destroy_socket(
 ) {
     recv_pump.abort();
     monitor_pump.abort();
+    if sock.socket_type() == omq_tokio::SocketType::Rep {
+        // This task only watches capacity; REP has no binding send backlog.
+        send_pump.abort();
+    }
     drop(recv_pump);
     drop(monitor_pump);
     let handle = ensure_runtime(io_threads);

data/ext/omq_rs_native/src/socket.rs

@@ -370,6 +370,7 @@ fn rust_socket_materialize_impl(rb_self: &RustSocket) -> RbResult<()> {
     let recv_notify = Arc::new(PipeNotify::new());
     let send_notify = Arc::new(PipeNotify::new());
     let recv_space = Arc::new(tokio::sync::Notify::new());
+    let (send_waiting, _) = tokio::sync::watch::channel(false);
 
     let (monitor_tx, monitor_rx) = flume::bounded(64);
     let monitor_notify = Arc::new(PipeNotify::new());
@@ -385,6 +386,7 @@ fn rust_socket_materialize_impl(rb_self: &RustSocket) -> RbResult<()> {
         recv_prod,
         recv_notify.clone(),
         send_notify.clone(),
+        send_waiting.clone(),
         recv_space.clone(),
         monitor_tx,
         monitor_notify.clone(),
@@ -401,6 +403,7 @@ fn rust_socket_materialize_impl(rb_self: &RustSocket) -> RbResult<()> {
         send_notify,
         recv_space,
         send_pump,
+        send_waiting,
         recv_pump,
         monitor_rx,
         monitor_notify,
@@ -581,6 +584,32 @@ unsafe extern "C" fn rust_socket_enqueue_send_routed(
     })
 }
 
+fn receive_message(
+    mat: &Materialized,
+    cons: &mut yring::Consumer<omq_tokio::Message>,
+) -> Option<omq_tokio::Message> {
+    let mut budget = omq_proto::flow::DrainBudget::WORKER;
+    loop {
+        let message = if let Some(message) = cons.prefetch_and_pop() {
+            message
+        } else {
+            mat.recv_notify.park_begin();
+            let message = cons.prefetch_and_pop()?;
+            mat.recv_notify.cancel_park();
+            message
+        };
+        mat.recv_space.notify_one();
+        let more = budget.account(message.byte_len());
+        if let Some(message) = mat.socket.prepare_external_recv(message) {
+            return Some(message);
+        }
+        if !more {
+            mat.recv_notify.force_wake();
+            return None;
+        }
+    }
+}
+
 fn rust_socket_try_recv_impl(rb_self: &RustSocket) -> RbResult<VALUE> {
     let mat_guard = rb_self.materialized.read().unwrap();
     let Some(mat) = mat_guard.as_ref() else {
@@ -588,19 +617,9 @@ fn rust_socket_try_recv_impl(rb_self: &RustSocket) -> RbResult<VALUE> {
     };
 
     let mut cons = mat.recv_cons.lock().unwrap();
-    if let Some(msg) = cons.prefetch_and_pop() {
-        mat.recv_space.notify_one();
-        message_to_ruby_parts(&msg)
-    } else {
-        mat.recv_notify.park_begin();
-        match cons.prefetch_and_pop() {
-            Some(msg) => {
-                mat.recv_notify.cancel_park();
-                mat.recv_space.notify_one();
-                message_to_ruby_parts(&msg)
-            }
-            None => Ok(rb::qnil()),
-        }
+    match receive_message(mat, &mut cons) {
+        Some(message) => message_to_ruby_parts(&message),
+        None => Ok(rb::qnil()),
     }
 }
 
@@ -618,19 +637,9 @@ fn rust_socket_try_recv_routed_impl(rb_self: &RustSocket) -> RbResult<VALUE> {
     };
 
     let mut cons = mat.recv_cons.lock().unwrap();
-    if let Some(msg) = cons.prefetch_and_pop() {
-        mat.recv_space.notify_one();
-        routed_message_to_ruby_parts(&msg)
-    } else {
-        mat.recv_notify.park_begin();
-        match cons.prefetch_and_pop() {
-            Some(msg) => {
-                mat.recv_notify.cancel_park();
-                mat.recv_space.notify_one();
-                routed_message_to_ruby_parts(&msg)
-            }
-            None => Ok(rb::qnil()),
-        }
+    match receive_message(mat, &mut cons) {
+        Some(message) => routed_message_to_ruby_parts(&message),
+        None => Ok(rb::qnil()),
     }
 }
 
@@ -648,6 +657,17 @@ fn rust_socket_try_recv_batch_impl(rb_self: &RustSocket) -> RbResult<VALUE> {
     };
 
     let mut cons = mat.recv_cons.lock().unwrap();
+    if matches!(
+        rb_self.socket_type,
+        omq_tokio::SocketType::Req | omq_tokio::SocketType::Rep
+    ) {
+        let Some(message) = receive_message(mat, &mut cons) else {
+            return Ok(rb::qnil());
+        };
+        let batch = rb::array_new_capa(1)?;
+        rb::array_push(batch, message_to_ruby_parts(&message)?)?;
+        return Ok(batch);
+    }
     let mut count = cons.prefetch();
     if count == 0 {
         mat.recv_notify.park_begin();
@@ -660,9 +680,14 @@ fn rust_socket_try_recv_batch_impl(rb_self: &RustSocket) -> RbResult<VALUE> {
 
     let batch = rb::array_new_capa(count)?;
     let mut popped = 0usize;
+    let mut budget = omq_proto::flow::DrainBudget::WORKER;
     while let Some(msg) = cons.pop() {
         rb::array_push(batch, message_to_ruby_parts(&msg)?)?;
         popped += 1;
+        if !budget.account(msg.byte_len()) {
+            mat.recv_notify.force_wake();
+            break;
+        }
     }
     cons.release();
 
@@ -978,6 +1003,32 @@ fn enqueue_message(rb_self: &RustSocket, msg: omq_tokio::Message) -> RbResult<VA
         .as_ref()
         .ok_or_else(|| RubyErr::runtime("socket not materialized"))?;
 
+    if rb_self.socket_type == omq_tokio::SocketType::Rep {
+        // Capture the application-admitted request before Ruby can receive
+        // another one. The ordinary send pump must not claim this route later.
+        mat.send_notify.park_begin();
+        return match mat.socket.try_send(msg) {
+            Ok(()) => {
+                mat.send_notify.cancel_park();
+                mat.send_waiting.send_if_modified(std::mem::take);
+                rb::symbol("ok")
+            }
+            Err(omq_tokio::TrySendError::Full(_)) => {
+                mat.send_waiting
+                    .send_if_modified(|waiting| !std::mem::replace(waiting, true));
+                rb::symbol("full")
+            }
+            Err(omq_tokio::TrySendError::Error(error)) => {
+                mat.send_notify.cancel_park();
+                Err(map_err(error))
+            }
+            Err(omq_tokio::TrySendError::Closed) => {
+                mat.send_notify.cancel_park();
+                Err(map_err(omq_tokio::Error::Closed))
+            }
+        };
+    }
+
     let mut prod = mat.send_prod.lock().unwrap();
     let returned = match prod.push(msg) {
         Ok(()) => {

data/lib/omq/rs/version.rb

@@ -5,6 +5,6 @@ module OMQ
   module Rust
     # Ruby binding version.
     # @return [String]
-    VERSION = "0.2.4"
+    VERSION = "0.2.5"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omq-rs
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.5
 platform: ruby
 authors:
 - Patrik Wenger