omq-backend-rust 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a08620eb9fd1a781752e72f44186bbaee5fcefd37d92560901aa8fb7c6e4f269
-  data.tar.gz: 891cc692da98d5cd7e2daf2a461e06b4c7b41de91f88964d1d9f7cbc20616f9a
+  metadata.gz: b22c5a39d466ddff0ea811bfadff93fe58e64c3ea08bb213f61419e5efd13cc6
+  data.tar.gz: '09ef0d2306516c3809a957f61e234360d9f2bbe34b0389cf874c8d5cdc87abc8'
 SHA512:
-  metadata.gz: 37745e0ab15d9dabd1ec62262c821951ee489a6bc11f86eee30c355b9fff07909246800e2ac6184379d46bd958258c411a5be55fadaf052af92c7ef01d3e024f
-  data.tar.gz: 2b89190343754d64b322efa8cbb08f880900324247b87d7b0cbb4df6c5af195caa1da41d3909a32168e8f5ad12f3a82714648a43521e789ea70ff5b053c514c9
+  metadata.gz: bae7c0181f01e714d3fbbb11546bb84dc6642d77661734e5d5eaa5467af153a5437b0a9af1ff0d1b8f894609928d7952a83bcb492ef299e327253acdc6a1f85d
+  data.tar.gz: b787de3962b49bf2c784596f8fd82901e0323e74270915ba051359eb73a46022389726cea92b1a6364c7780eaf296a457d8355d90507503a5690f4de4de8410b

data/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## [Unreleased]
 
+## [0.1.7] - 2026-08-02
+
+### Added
+
+- Restored Rust/Ruby backend interop coverage.
+
+### Changed
+
+- Updated to `omq-tokio` 0.21.0.
+
+### Fixed
+
+- Drained the Ruby-to-Tokio send pump before native socket close.
+- Released Rust send ring slots before awaiting native sends, avoiding
+  high-throughput stalls under `omq-tokio` 0.21.0 backpressure.
+- Waited for Rust peer registration before resolving `peer_connected`.
+
 ## [0.1.6] - 2026-08-01
 
 ### Added

data/ext/omq_backend_rust/Cargo.toml

@@ -19,7 +19,7 @@ zstd    = ["omq-tokio/zstd"]
 
 [dependencies]
 omq-proto = { version = "=0.25.0", default-features = false }
-omq-tokio = { version = "=0.20.3", default-features = false }
+omq-tokio = { version = "=0.21.0", default-features = false }
 tokio     = { version = "1.52.0", features = ["rt", "rt-multi-thread", "time", "sync", "io-util", "net"] }
 yring     = { version = "0.3.11", features = ["async"] }
 

data/ext/omq_backend_rust/src/runtime.rs

@@ -299,20 +299,15 @@ pub fn materialize(
     let job: Job = Box::new(move || {
         let sock = Arc::new(InnerSocket::new(socket_type, options));
 
-        const SEND_YIELD_INTERVAL: u32 = 256;
         let s = sock.clone();
         let sn = send_notify.clone();
         let send_pump = tokio::spawn(async move {
-            futures::pin_mut!(send_cons);
-            let mut batch = 0u32;
+            let mut send_cons = send_cons;
             while let Some(msg) = futures::StreamExt::next(&mut send_cons).await {
-                let _ = s.send(msg).await;
+                send_cons.release();
                 sn.notify();
-                batch += 1;
-                if batch >= SEND_YIELD_INTERVAL {
-                    batch = 0;
-                    tokio::task::yield_now().await;
-                }
+                let _ = s.send(msg).await;
+                tokio::task::yield_now().await;
             }
             sn.notify();
         });
@@ -343,6 +338,7 @@ pub fn materialize(
         });
 
         let monitor_sock = sock.clone();
+        let peer_ready_sock = sock.clone();
         let monitor_pump = tokio::spawn(async move {
             let mut stream = monitor_sock.monitor();
             let mut peer_count: u32 = 0;
@@ -359,6 +355,7 @@ pub fn materialize(
                                 had_peers = true;
                                 if !peer_connected_fired {
                                     peer_connected_fired = true;
+                                    let _ = peer_ready_sock.connections().await;
                                     peer_connected_notify.force_wake();
                                 }
                             }
@@ -374,6 +371,12 @@ pub fn materialize(
                                     subscriber_joined_notify.force_wake();
                                 }
                             }
+                            omq_tokio::MonitorEvent::JoinReceived { .. } => {
+                                if !subscriber_joined_fired {
+                                    subscriber_joined_fired = true;
+                                    subscriber_joined_notify.force_wake();
+                                }
+                            }
                             _ => {}
                         }
 
@@ -432,24 +435,59 @@ pub fn destroy_socket(
     io_threads: usize,
     sock: Arc<InnerSocket>,
     send_prod: Mutex<yring::AsyncProducer<omq_tokio::Message>>,
-    send_pump: JoinHandle<()>,
+    mut send_pump: JoinHandle<()>,
     recv_pump: JoinHandle<()>,
     monitor_pump: JoinHandle<()>,
     linger: Option<Duration>,
 ) {
     recv_pump.abort();
     monitor_pump.abort();
-    send_pump.abort();
-    drop(send_prod);
     let Ok(handle) = (|| -> std::result::Result<Handle, ()> { Ok(ensure_runtime(io_threads)) })()
     else {
+        send_pump.abort();
+        drop(send_prod);
         return;
     };
     let close_timeout = linger
         .unwrap_or(Duration::from_secs(30))
         .max(Duration::from_millis(10));
-    handle.spawn(async move {
+    let fut = async move {
+        drop(send_prod);
+        if tokio::time::timeout(close_timeout, &mut send_pump)
+            .await
+            .is_err()
+        {
+            send_pump.abort();
+            let _ = send_pump.await;
+        }
+
         let s = Arc::try_unwrap(sock).unwrap_or_else(|arc| (*arc).clone());
         let _ = tokio::time::timeout(close_timeout, s.close()).await;
+    };
+
+    let (otx, orx) = flume::bounded::<()>(1);
+    handle.spawn(async move {
+        fut.await;
+        let _ = otx.send(());
     });
+
+    struct RecvBox {
+        rx: flume::Receiver<()>,
+    }
+
+    extern "C" fn blocking_recv(data: *mut libc::c_void) -> *mut libc::c_void {
+        let rd = unsafe { &mut *(data as *mut RecvBox) };
+        let _ = rd.rx.recv();
+        std::ptr::null_mut()
+    }
+
+    let mut rd = RecvBox { rx: orx };
+    unsafe {
+        rb_sys::rb_thread_call_without_gvl(
+            Some(blocking_recv),
+            &mut rd as *mut RecvBox as *mut libc::c_void,
+            None,
+            std::ptr::null_mut(),
+        );
+    }
 }

data/lib/omq/rust/engine.rb

@@ -19,7 +19,7 @@ module OMQ
         @peer_connected = Async::Promise.new
         @all_peers_gone = Async::Promise.new
         @subscriber_joined = Async::Promise.new
-        @connections    = []
+        @connections    = {}
         @closed         = false
         @parent_task    = nil
         @on_io_thread   = false
@@ -222,6 +222,7 @@ module OMQ
             monitor_io.wait_readable
             monitor_io.read_nonblock(256, exception: false)
             while (data = @native.try_recv_monitor)
+              track_connection_event(data)
               @monitor_queue.enqueue(MonitorEvent.new(**data))
             end
           end
@@ -229,6 +230,23 @@ module OMQ
       end
 
 
+      def track_connection_event(data)
+        detail = data[:detail] || {}
+        connection_id = detail[:connection_id]
+
+        case data[:type]
+        when :handshake_succeeded
+          @connections[connection_id || Object.new] = true
+        when :disconnected
+          if connection_id
+            @connections.delete(connection_id)
+          else
+            @connections.shift
+          end
+        end
+      end
+
+
       def extract_options
         h = {}
         h["send_hwm"]           = @options.send_hwm

data/lib/omq/rust/version.rb

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

metadata

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