omq-rs 0.2.5 → 0.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '068794048e18d65087a2f7feef656c5a69fce269140007ba804ff5394f417b22'
-  data.tar.gz: b80f54254186826e27d4c77ad024877150c083a253e2742cc73c3b1baf935797
+  metadata.gz: 39bae86e920966ad2f4ec940ffb54a150447afd6950b6692105b67414c93658f
+  data.tar.gz: 706fef1a060bf0bdd1b120d75e0094b883d30c91e21d91bcfa25829e9034213f
 SHA512:
-  metadata.gz: 8a5c55beafa7d9db560069671d08a03080d746017c053b7f67608a795d73f41c9d98f515f32f4efdc55c9f5b133057be9ad6a7787cfe10d3bd967baec9f29563
-  data.tar.gz: 5428836642e04134201da527aedf24fb24dcaddb69650aeb264c1aeecec7110d7accebaa8c8f7d84cd353dab5013d2ff8e5b9f6b6492a26120c6365461776f0d
+  metadata.gz: 1ac452e8ed4a8e39e6a35a494fb6c425794ec40ee443184c78a5c8392317880d41d60a74caa8d748ad19bc263fc943d18f04254b23cd8559a63fda8faf8fd0e9
+  data.tar.gz: 4dbfc59cbdd388c5f3e478b62d1ddcc83bd8f96e29eebf5c7d09cefbed1c7319de37bd1750b8bd59a189c3c0749886b8c1f57dbd243e00fc8492db10846b3fd2

data/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 ## [Unreleased]
 
+## [0.2.7] - 2026-10-20
+
+### Changed
+
+- Bundle `omq-tokio` 0.30.0 and `omq-proto` 0.34.0 with adaptive Zstd
+  levels, handshake flood limits, and wakeup and lifecycle fixes.
+
+### Fixed
+
+- Socket construction no longer releases the GVL under the materialization
+  lock, and close serializes with wrapper setup.
+
+## [0.2.6] - 2026-10-16
+
+### Changed
+
+- Require `omq-tokio` 0.29.0 and `omq-proto` 0.33.0 with the latest PEER
+  limits and fan-out send readiness fixes.
+
 ## [0.2.5] - 2026-10-15
 
 ### Fixed

data/ext/omq_rs_native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "omq_rs_native"
-version = "0.2.5"
+version = "0.2.7"
 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.1", default-features = false }
-omq-tokio = { version = "0.28.1", default-features = false }
+omq-proto = { version = "0.34.0", default-features = false }
+omq-tokio = { version = "0.30.0", default-features = false }
 yring = { version = "0.3.20", features = ["async"] }
 
 bytes = "1.12.0"

data/ext/omq_rs_native/src/auth.rs

@@ -10,13 +10,18 @@ use crate::notify::PipeNotify;
 use crate::options::parse_curve_public_key;
 use crate::rb::{self, RbResult};
 
+/// Handshake facts handed to the Ruby auth callback as a hash.
+struct AuthPeer {
+    public_key: [u8; 32],
+    identity: Option<Bytes>,
+    peer_address: Option<String>,
+    username: Option<String>,
+    password: Option<String>,
+}
+
 enum AuthRequest {
     Check {
-        public_key: [u8; 32],
-        identity: Option<Bytes>,
-        peer_address: Option<String>,
-        username: Option<String>,
-        password: Option<String>,
+        peer: AuthPeer,
         reply: flume::Sender<bool>,
     },
     Stop,
@@ -85,78 +90,18 @@ fn wait_for_request(data: &WorkerData) -> Option<AuthRequest> {
 unsafe extern "C" fn auth_worker_main(data: *mut c_void) -> VALUE {
     let data = unsafe { Box::from_raw(data.cast::<WorkerData>()) };
     let _ = catch_unwind(AssertUnwindSafe(|| {
-        while let Some(AuthRequest::Check {
-            public_key,
-            identity,
-            peer_address,
-            username,
-            password,
-            reply,
-        }) = wait_for_request(&data)
-        {
-            let accepted = invoke_callback(
-                data.callback,
-                public_key,
-                identity.as_ref(),
-                peer_address.as_deref(),
-                username.as_deref(),
-                password.as_deref(),
-            );
+        while let Some(AuthRequest::Check { peer, reply }) = wait_for_request(&data) {
+            let accepted = invoke_callback(data.callback, &peer);
             let _ = reply.send(accepted);
         }
     }));
     rb::qnil()
 }
 
-fn invoke_callback(
-    callback: VALUE,
-    public_key: [u8; 32],
-    identity: Option<&Bytes>,
-    peer_address: Option<&str>,
-    username: Option<&str>,
-    password: Option<&str>,
-) -> bool {
-    let result = (|| -> RbResult<VALUE> {
-        let peer = rb::hash_new()?;
-        let key = if username.is_some() {
-            rb::qnil()
-        } else {
-            #[cfg(feature = "curve")]
-            {
-                let key = omq_proto::CurvePublicKey::from_bytes(public_key)
-                    .to_z85()
-                    .into_bytes();
-                rb::new_binary_string(&key)?
-            }
-            #[cfg(not(feature = "curve"))]
-            {
-                let _ = public_key;
-                rb::qnil()
-            }
-        };
-        rb::hash_aset(peer, rb::symbol("public_key")?, key)?;
-        let identity = match identity {
-            Some(value) => rb::new_binary_string(value)?,
-            None => rb::qnil(),
-        };
-        rb::hash_aset(peer, rb::symbol("identity")?, identity)?;
-        let peer_address = match peer_address {
-            Some(value) => rb::new_utf8_string(value)?,
-            None => rb::qnil(),
-        };
-        rb::hash_aset(peer, rb::symbol("peer_address")?, peer_address)?;
-        let username = match username {
-            Some(value) => rb::new_utf8_string(value)?,
-            None => rb::qnil(),
-        };
-        rb::hash_aset(peer, rb::symbol("username")?, username)?;
-        let password = match password {
-            Some(value) => rb::new_utf8_string(value)?,
-            None => rb::qnil(),
-        };
-        rb::hash_aset(peer, rb::symbol("password")?, password)?;
-        rb::call_method_1(callback, c"call", peer)
-    })();
+/// Call the Ruby callback with the peer hash; any truthy result accepts.
+/// A raised exception rejects the peer and clears Ruby's error state.
+fn invoke_callback(callback: VALUE, peer: &AuthPeer) -> bool {
+    let result = peer_hash(peer).and_then(|hash| rb::call_method_1(callback, c"call", hash));
 
     if let Ok(value) = result {
         value != rb::qfalse() && value != rb::qnil()
@@ -166,6 +111,54 @@ fn invoke_callback(
     }
 }
 
+fn peer_hash(peer: &AuthPeer) -> RbResult<VALUE> {
+    let hash = rb::hash_new()?;
+
+    // PLAIN peers carry a username; only CURVE peers expose a public key.
+    let key = if peer.username.is_some() {
+        rb::qnil()
+    } else {
+        #[cfg(feature = "curve")]
+        {
+            let key = omq_proto::CurvePublicKey::from_bytes(peer.public_key)
+                .to_z85()
+                .into_bytes();
+            rb::new_binary_string(&key)?
+        }
+        #[cfg(not(feature = "curve"))]
+        {
+            let _ = peer.public_key;
+            rb::qnil()
+        }
+    };
+    rb::hash_aset(hash, rb::symbol("public_key")?, key)?;
+
+    let identity = match &peer.identity {
+        Some(value) => rb::new_binary_string(value)?,
+        None => rb::qnil(),
+    };
+    rb::hash_aset(hash, rb::symbol("identity")?, identity)?;
+
+    let peer_address = match &peer.peer_address {
+        Some(value) => rb::new_utf8_string(value)?,
+        None => rb::qnil(),
+    };
+    rb::hash_aset(hash, rb::symbol("peer_address")?, peer_address)?;
+
+    let username = match &peer.username {
+        Some(value) => rb::new_utf8_string(value)?,
+        None => rb::qnil(),
+    };
+    rb::hash_aset(hash, rb::symbol("username")?, username)?;
+
+    let password = match &peer.password {
+        Some(value) => rb::new_utf8_string(value)?,
+        None => rb::qnil(),
+    };
+    rb::hash_aset(hash, rb::symbol("password")?, password)?;
+    Ok(hash)
+}
+
 #[cfg(feature = "curve")]
 pub fn allowed_keys(value: VALUE) -> RbResult<omq_proto::Authenticator> {
     let count = rb::array_len(value)?;
@@ -207,11 +200,13 @@ pub fn callback(callback: VALUE) -> RbResult<(omq_proto::Authenticator, AuthWork
     let authenticator = omq_proto::Authenticator::new(move |peer| {
         let (reply, result) = flume::bounded(1);
         let request = AuthRequest::Check {
-            public_key: peer.public_key,
-            identity: peer.identity.clone(),
-            peer_address: peer.peer_address.clone(),
-            username: peer.username.clone(),
-            password: peer.password.clone(),
+            peer: AuthPeer {
+                public_key: peer.public_key,
+                identity: peer.identity.clone(),
+                peer_address: peer.peer_address.clone(),
+                username: peer.username.clone(),
+                password: peer.password.clone(),
+            },
             reply,
         };
         if auth_sender.send(request).is_err() {

data/ext/omq_rs_native/src/options.rs

@@ -6,15 +6,28 @@ use rb_sys::VALUE;
 
 use crate::rb::{self, RbResult, RubyErr};
 
-#[expect(
-    clippy::too_many_lines,
-    reason = "flat option mapping mirrors omq-proto Options fields"
-)]
 pub fn build_options(hash: VALUE) -> RbResult<omq_tokio::Options> {
     rb::check_hash(hash)?;
 
+    // Groups run in a fixed order, so the first invalid option reported
+    // stays the same. Each maps fields one to one onto omq-proto Options.
     let mut opts = omq_tokio::Options::default();
+    apply_queue_options(hash, &mut opts)?;
+    apply_timing_options(hash, &mut opts)?;
+    apply_transport_options(hash, &mut opts)?;
+    apply_compression_options(hash, &mut opts)?;
+    apply_policy_options(hash, &mut opts)?;
+    if let Some(mechanism_type) = mechanism_type(hash)? {
+        apply_mechanism(hash, &mechanism_type, &mut opts)?;
+    }
+
+    opts.validate()
+        .map_err(|error| RubyErr::arg(error.to_string()))?;
+    Ok(opts)
+}
 
+/// Queue limits, receive rate limits, workload, linger, and identity.
+fn apply_queue_options(hash: VALUE, opts: &mut omq_tokio::Options) -> RbResult<()> {
     if let Some(v) = get_opt_u32(hash, "send_hwm")? {
         opts.send_hwm = v;
     }
@@ -56,6 +69,11 @@ pub fn build_options(hash: VALUE) -> RbResult<omq_tokio::Options> {
     if let Some(v) = get_opt_bool(hash, "conflate")? {
         opts.conflate = v;
     }
+    Ok(())
+}
+
+/// Heartbeat and handshake timing.
+fn apply_timing_options(hash: VALUE, opts: &mut omq_tokio::Options) -> RbResult<()> {
     if let Some(v) = get_opt_duration(hash, "heartbeat_interval")? {
         opts.heartbeat_interval = Some(v);
     }
@@ -71,6 +89,11 @@ pub fn build_options(hash: VALUE) -> RbResult<omq_tokio::Options> {
     if let Some(v) = get_opt_usize(hash, "max_pending_handshakes")? {
         opts.max_pending_handshakes = v;
     }
+    Ok(())
+}
+
+/// Message size limits, buffers, framing thresholds, and delivery flags.
+fn apply_transport_options(hash: VALUE, opts: &mut omq_tokio::Options) -> RbResult<()> {
     if let Some(v) = get_opt_usize(hash, "max_message_size")? {
         opts.max_message_size = Some(v);
     }
@@ -95,6 +118,11 @@ pub fn build_options(hash: VALUE) -> RbResult<omq_tokio::Options> {
     if let Some(v) = get_opt_bool(hash, "reconnect_stop_conn_refused")? {
         opts.reconnect_stop_conn_refused = v;
     }
+    Ok(())
+}
+
+/// Compression dictionary, training, level, and offload.
+fn apply_compression_options(hash: VALUE, opts: &mut omq_tokio::Options) -> RbResult<()> {
     if let Some(v) = get_opt_bytes(hash, "compression_dict")? {
         opts.compression_dict = (!v.is_empty()).then(|| Bytes::from(v));
     }
@@ -115,8 +143,14 @@ pub fn build_options(hash: VALUE) -> RbResult<omq_tokio::Options> {
         opts.max_recv_dict_size = Some(v);
     }
     if let Some(v) = get_opt_i64(hash, "compression_offload_threshold")? {
+        // Negative disables offload.
         opts.compression_offload_threshold = if v < 0 { None } else { Some(v as usize) };
     }
+    Ok(())
+}
+
+/// Mute and reconnect policies.
+fn apply_policy_options(hash: VALUE, opts: &mut omq_tokio::Options) -> RbResult<()> {
     if let Some(v) = get_opt_string(hash, "on_mute")? {
         opts.on_mute = match v.as_str() {
             "drop_newest" | "drop" => omq_tokio::OnMute::DropNewest,
@@ -143,37 +177,37 @@ pub fn build_options(hash: VALUE) -> RbResult<omq_tokio::Options> {
             max: duration_from_seconds("reconnect_interval max", max)?,
         };
     }
+    Ok(())
+}
 
-    let mut mechanism_type = get_opt_string(hash, "mechanism_type")?;
-    if mechanism_type.is_none() {
-        let curve = option_present(
-            hash,
-            &[
-                "curve_server",
-                "curve_publickey",
-                "curve_public_key",
-                "curve_secretkey",
-                "curve_secret_key",
-                "curve_serverkey",
-                "curve_server_key",
-            ],
-        )?;
-        let plain = option_present(hash, &["plain_server", "plain_username", "plain_password"])?;
-        mechanism_type = if curve {
-            Some("curve".to_owned())
-        } else if plain {
-            Some("plain".to_owned())
-        } else {
-            None
-        };
-    }
-    if let Some(mechanism_type) = mechanism_type {
-        apply_mechanism(hash, &mechanism_type, &mut opts)?;
-    }
-
-    opts.validate()
-        .map_err(|error| RubyErr::arg(error.to_string()))?;
-    Ok(opts)
+/// Explicit `mechanism_type`, or one inferred from CURVE or PLAIN keys.
+/// CURVE wins when both kinds of keys are present.
+fn mechanism_type(hash: VALUE) -> RbResult<Option<String>> {
+    if let Some(mechanism_type) = get_opt_string(hash, "mechanism_type")? {
+        return Ok(Some(mechanism_type));
+    }
+
+    let curve = option_present(
+        hash,
+        &[
+            "curve_server",
+            "curve_publickey",
+            "curve_public_key",
+            "curve_secretkey",
+            "curve_secret_key",
+            "curve_serverkey",
+            "curve_server_key",
+        ],
+    )?;
+    let plain = option_present(hash, &["plain_server", "plain_username", "plain_password"])?;
+
+    Ok(if curve {
+        Some("curve".to_owned())
+    } else if plain {
+        Some("plain".to_owned())
+    } else {
+        None
+    })
 }
 
 fn apply_mechanism(hash: VALUE, mech_type: &str, opts: &mut omq_tokio::Options) -> RbResult<()> {
@@ -181,75 +215,12 @@ fn apply_mechanism(hash: VALUE, mech_type: &str, opts: &mut omq_tokio::Options)
         "null" => {}
 
         #[cfg(feature = "curve")]
-        "curve" => {
-            let is_server =
-                get_opt_bool_alias(hash, &["curve_server", "mechanism_server"])?.unwrap_or(false);
-            let pub_key = get_opt_bytes_alias(
-                hash,
-                &[
-                    "curve_publickey",
-                    "curve_public_key",
-                    "mechanism_public_key",
-                ],
-            )?;
-            let sec_key = get_opt_bytes_alias(
-                hash,
-                &[
-                    "curve_secretkey",
-                    "curve_secret_key",
-                    "mechanism_secret_key",
-                ],
-            )?;
-
-            if is_server {
-                let public = parse_curve_public_key(
-                    &pub_key
-                        .ok_or_else(|| RubyErr::arg("CURVE server requires curve_publickey"))?,
-                    "curve_publickey",
-                )?;
-                let secret = curve_secret_key(
-                    &sec_key
-                        .ok_or_else(|| RubyErr::arg("CURVE server requires curve_secretkey"))?,
-                    "curve_secretkey",
-                )?;
-                opts.mechanism = omq_proto::MechanismSetup::CurveServer {
-                    our_keypair: omq_proto::CurveKeypair { public, secret },
-                    options: omq_proto::CurveServerOptions::default(),
-                };
-            } else {
-                let server_key = get_opt_bytes_alias(
-                    hash,
-                    &[
-                        "curve_serverkey",
-                        "curve_server_key",
-                        "mechanism_server_key",
-                    ],
-                )?;
-                let public = parse_curve_public_key(
-                    &pub_key
-                        .ok_or_else(|| RubyErr::arg("CURVE client requires curve_publickey"))?,
-                    "curve_publickey",
-                )?;
-                let secret = curve_secret_key(
-                    &sec_key
-                        .ok_or_else(|| RubyErr::arg("CURVE client requires curve_secretkey"))?,
-                    "curve_secretkey",
-                )?;
-                let server_public = parse_curve_public_key(
-                    &server_key
-                        .ok_or_else(|| RubyErr::arg("CURVE client requires curve_serverkey"))?,
-                    "curve_serverkey",
-                )?;
-                opts.mechanism = omq_proto::MechanismSetup::CurveClient {
-                    our_keypair: omq_proto::CurveKeypair { public, secret },
-                    server_public,
-                };
-            }
-        }
+        "curve" => apply_curve_mechanism(hash, opts)?,
 
         #[cfg(feature = "plain")]
         "plain" => {
             if get_opt_bool_alias(hash, &["plain_server", "mechanism_server"])?.unwrap_or(false) {
+                // Fail closed until an authenticator is installed on the socket.
                 opts.mechanism = omq_proto::MechanismSetup::PlainServer {
                     authenticator: omq_proto::Authenticator::new(|_| false),
                 };
@@ -269,6 +240,70 @@ fn apply_mechanism(hash: VALUE, mech_type: &str, opts: &mut omq_tokio::Options)
     Ok(())
 }
 
+#[cfg(feature = "curve")]
+fn apply_curve_mechanism(hash: VALUE, opts: &mut omq_tokio::Options) -> RbResult<()> {
+    let is_server =
+        get_opt_bool_alias(hash, &["curve_server", "mechanism_server"])?.unwrap_or(false);
+    let pub_key = get_opt_bytes_alias(
+        hash,
+        &[
+            "curve_publickey",
+            "curve_public_key",
+            "mechanism_public_key",
+        ],
+    )?;
+    let sec_key = get_opt_bytes_alias(
+        hash,
+        &[
+            "curve_secretkey",
+            "curve_secret_key",
+            "mechanism_secret_key",
+        ],
+    )?;
+
+    if is_server {
+        let public = parse_curve_public_key(
+            &pub_key.ok_or_else(|| RubyErr::arg("CURVE server requires curve_publickey"))?,
+            "curve_publickey",
+        )?;
+        let secret = curve_secret_key(
+            &sec_key.ok_or_else(|| RubyErr::arg("CURVE server requires curve_secretkey"))?,
+            "curve_secretkey",
+        )?;
+        opts.mechanism = omq_proto::MechanismSetup::CurveServer {
+            our_keypair: omq_proto::CurveKeypair { public, secret },
+            options: omq_proto::CurveServerOptions::default(),
+        };
+        return Ok(());
+    }
+
+    let server_key = get_opt_bytes_alias(
+        hash,
+        &[
+            "curve_serverkey",
+            "curve_server_key",
+            "mechanism_server_key",
+        ],
+    )?;
+    let public = parse_curve_public_key(
+        &pub_key.ok_or_else(|| RubyErr::arg("CURVE client requires curve_publickey"))?,
+        "curve_publickey",
+    )?;
+    let secret = curve_secret_key(
+        &sec_key.ok_or_else(|| RubyErr::arg("CURVE client requires curve_secretkey"))?,
+        "curve_secretkey",
+    )?;
+    let server_public = parse_curve_public_key(
+        &server_key.ok_or_else(|| RubyErr::arg("CURVE client requires curve_serverkey"))?,
+        "curve_serverkey",
+    )?;
+    opts.mechanism = omq_proto::MechanismSetup::CurveClient {
+        our_keypair: omq_proto::CurveKeypair { public, secret },
+        server_public,
+    };
+    Ok(())
+}
+
 #[cfg(feature = "curve")]
 pub(crate) fn parse_curve_public_key(
     bytes: &[u8],

data/ext/omq_rs_native/src/runtime.rs

@@ -11,12 +11,10 @@ use tokio::task::JoinHandle;
 
 use crate::notify::PipeNotify;
 
-type Job = Box<dyn FnOnce() + Send + 'static>;
-
 struct RuntimeState {
     pid: u32,
     handle: Handle,
-    submit: flume::Sender<Job>,
+    _keepalive: flume::Sender<()>,
 }
 
 static RUNTIME: Mutex<Option<RuntimeState>> = Mutex::new(None);
@@ -34,7 +32,7 @@ pub fn ensure_runtime(io_threads: usize) -> Handle {
     {
         return rt.handle.clone();
     }
-    let (tx, rx) = flume::unbounded::<Job>();
+    let (tx, rx) = flume::bounded::<()>(1);
     let (handle_tx, handle_rx) = flume::bounded::<Handle>(1);
     let n = io_threads.max(1);
     thread::Builder::new()
@@ -54,9 +52,7 @@ pub fn ensure_runtime(io_threads: usize) -> Handle {
             };
             let _ = handle_tx.send(rt.handle().clone());
             rt.block_on(async move {
-                while let Ok(job) = rx.recv_async().await {
-                    job();
-                }
+                let _ = rx.recv_async().await;
             });
         })
         .expect("omq-rs: spawn tokio thread");
@@ -64,23 +60,11 @@ pub fn ensure_runtime(io_threads: usize) -> Handle {
     *guard = Some(RuntimeState {
         pid,
         handle: handle.clone(),
-        submit: tx,
+        _keepalive: tx,
     });
     handle
 }
 
-fn submit_job(io_threads: usize) -> flume::Sender<Job> {
-    let guard = RUNTIME.lock().unwrap();
-    if let Some(ref rt) = *guard
-        && rt.pid == std::process::id()
-    {
-        return rt.submit.clone();
-    }
-    drop(guard);
-    ensure_runtime(io_threads);
-    RUNTIME.lock().unwrap().as_ref().unwrap().submit.clone()
-}
-
 fn recv_blocking<T>(rx: flume::Receiver<T>, missing: &'static str) -> T {
     struct RecvBox<U> {
         rx: flume::Receiver<U>,
@@ -128,16 +112,14 @@ pub struct Materialized {
     pub recv_notify: Arc<PipeNotify>,
     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>,
     pub monitor_notify: Arc<PipeNotify>,
     pub peer_connected_notify: Arc<PipeNotify>,
     pub all_peers_gone_notify: Arc<PipeNotify>,
     pub subscriber_joined_notify: Arc<PipeNotify>,
-    pub monitor_pump: JoinHandle<()>,
+    pub tasks: SocketTasks,
 }
 
 #[derive(Clone)]
@@ -154,17 +136,24 @@ pub enum MonitorValue {
     Text(String),
 }
 
-#[expect(
-    clippy::too_many_lines,
-    reason = "one exhaustive match keeps monitor event conversion auditable"
-)]
+/// Map a monitor event to the Ruby-facing name, endpoint, and detail pairs.
+/// Event kinds this binding does not know map to "unknown".
 fn convert_monitor_event(event: &omq_tokio::MonitorEvent) -> MonitorEventData {
-    use omq_tokio::MonitorEvent::{
-        Accepted, Closed, ConnectDelayed, Connected, Disconnected, HandshakeFailed,
-        HandshakeSucceeded, JoinReceived, LeaveReceived, Listening, SubscribeReceived,
-        UnsubscribeReceived,
-    };
-    match event {
+    connection_event(event)
+        .or_else(|| attempt_event(event))
+        .or_else(|| subscription_event(event))
+        .unwrap_or_else(|| MonitorEventData {
+            event_type: "unknown",
+            endpoint: None,
+            detail: vec![],
+        })
+}
+
+/// Listener and connection lifecycle events.
+fn connection_event(event: &omq_tokio::MonitorEvent) -> Option<MonitorEventData> {
+    use omq_tokio::MonitorEvent::{Accepted, Connected, Disconnected, Listening};
+
+    let data = match event {
         Listening { endpoint } => MonitorEventData {
             event_type: "listening",
             endpoint: Some(endpoint.to_string()),
@@ -188,6 +177,29 @@ fn convert_monitor_event(event: &omq_tokio::MonitorEvent) -> MonitorEventData {
             endpoint: Some(endpoint.to_string()),
             detail: vec![("connection_id", MonitorValue::Integer(*connection_id))],
         },
+        Disconnected {
+            endpoint,
+            peer,
+            reason,
+        } => MonitorEventData {
+            event_type: "disconnected",
+            endpoint: Some(endpoint.to_string()),
+            detail: vec![
+                ("reason", MonitorValue::Text(format!("{reason:?}"))),
+                ("connection_id", MonitorValue::Integer(peer.connection_id)),
+            ],
+        },
+        _ => return None,
+    };
+
+    Some(data)
+}
+
+/// Connect retries and handshake outcomes.
+fn attempt_event(event: &omq_tokio::MonitorEvent) -> Option<MonitorEventData> {
+    use omq_tokio::MonitorEvent::{ConnectDelayed, HandshakeFailed, HandshakeSucceeded};
+
+    let data = match event {
         HandshakeSucceeded { endpoint, peer } => {
             let mut detail = vec![("connection_id", MonitorValue::Integer(peer.connection_id))];
             if let Some(ref ident) = peer.peer_identity
@@ -223,18 +235,19 @@ fn convert_monitor_event(event: &omq_tokio::MonitorEvent) -> MonitorEventData {
                 ("attempt", MonitorValue::Integer(u64::from(*attempt))),
             ],
         },
-        Disconnected {
-            endpoint,
-            peer,
-            reason,
-        } => MonitorEventData {
-            event_type: "disconnected",
-            endpoint: Some(endpoint.to_string()),
-            detail: vec![
-                ("reason", MonitorValue::Text(format!("{reason:?}"))),
-                ("connection_id", MonitorValue::Integer(peer.connection_id)),
-            ],
-        },
+        _ => return None,
+    };
+
+    Some(data)
+}
+
+/// Subscription and group traffic, plus socket close.
+fn subscription_event(event: &omq_tokio::MonitorEvent) -> Option<MonitorEventData> {
+    use omq_tokio::MonitorEvent::{
+        Closed, JoinReceived, LeaveReceived, SubscribeReceived, UnsubscribeReceived,
+    };
+
+    let data = match event {
         SubscribeReceived { prefix } => MonitorEventData {
             event_type: "subscribe_received",
             endpoint: None,
@@ -260,12 +273,10 @@ fn convert_monitor_event(event: &omq_tokio::MonitorEvent) -> MonitorEventData {
             endpoint: None,
             detail: vec![],
         },
-        _ => MonitorEventData {
-            event_type: "unknown",
-            endpoint: None,
-            detail: vec![],
-        },
-    }
+        _ => return None,
+    };
+
+    Some(data)
 }
 
 async fn push_to_ring(
@@ -295,142 +306,188 @@ async fn push_to_ring(
     }
 }
 
-#[expect(clippy::too_many_arguments, clippy::too_many_lines)]
+/// Pump ends and wake signals between the Ruby-facing rings and the socket.
+pub struct PumpChannels {
+    pub send_cons: yring::AsyncConsumer<omq_tokio::Message>,
+    pub send_notify: Arc<PipeNotify>,
+    pub send_waiting: tokio::sync::watch::Sender<bool>,
+    pub recv_prod: yring::Producer<omq_tokio::Message>,
+    pub recv_notify: Arc<PipeNotify>,
+    pub recv_space: Arc<tokio::sync::Notify>,
+}
+
+/// Where the monitor pump reports events and one-shot peer milestones.
+pub struct MonitorSinks {
+    pub events: flume::Sender<MonitorEventData>,
+    pub notify: Arc<PipeNotify>,
+    pub peer_connected: Arc<PipeNotify>,
+    pub all_peers_gone: Arc<PipeNotify>,
+    pub subscriber_joined: Arc<PipeNotify>,
+}
+
+/// Background tasks owned by one materialized socket.
+pub struct SocketTasks {
+    pub send: JoinHandle<()>,
+    pub recv: JoinHandle<()>,
+    pub monitor: JoinHandle<()>,
+}
+
 pub fn materialize(
     io_threads: usize,
     socket_type: omq_tokio::SocketType,
     options: omq_tokio::Options,
-    send_cons: yring::AsyncConsumer<omq_tokio::Message>,
-    mut recv_prod: yring::Producer<omq_tokio::Message>,
-    recv_notify: Arc<PipeNotify>,
-    send_notify: Arc<PipeNotify>,
+    pumps: PumpChannels,
+    monitor: MonitorSinks,
+) -> (Arc<InnerSocket>, SocketTasks) {
+    // Construction only spawns tasks. Keep the GVL while the caller holds
+    // its materialization lock; waiting without it would let close take
+    // the GVL and block on that same lock.
+    let handle = ensure_runtime(io_threads);
+    let _guard = handle.enter();
+    let sock = Arc::new(InnerSocket::new(socket_type, options));
+
+    let send_pump = tokio::spawn(run_send_pump(
+        sock.clone(),
+        pumps.send_cons,
+        pumps.send_notify,
+        pumps.send_waiting,
+    ));
+    let recv_pump = tokio::spawn(run_recv_pump(
+        sock.clone(),
+        pumps.recv_prod,
+        pumps.recv_notify,
+        pumps.recv_space,
+    ));
+
+    // Subscribe here, not inside the task: the broadcast receiver keeps
+    // events emitted before the task first runs.
+    let stream = sock.monitor();
+    let monitor_pump = tokio::spawn(run_monitor_pump(sock.clone(), stream, monitor));
+
+    let tasks = SocketTasks {
+        send: send_pump,
+        recv: recv_pump,
+        monitor: monitor_pump,
+    };
+    (sock, tasks)
+}
+
+/// Feed queued Ruby sends to the socket with a drain budget. REP instead
+/// only watches send capacity.
+async fn run_send_pump(
+    s: Arc<InnerSocket>,
+    mut send_cons: yring::AsyncConsumer<omq_tokio::Message>,
+    sn: Arc<PipeNotify>,
     send_waiting: tokio::sync::watch::Sender<bool>,
-    recv_space: Arc<tokio::sync::Notify>,
-    monitor_tx: flume::Sender<MonitorEventData>,
-    monitor_notify: Arc<PipeNotify>,
-    peer_connected_notify: Arc<PipeNotify>,
-    all_peers_gone_notify: Arc<PipeNotify>,
-    subscriber_joined_notify: Arc<PipeNotify>,
-) -> (
-    Arc<InnerSocket>,
-    JoinHandle<()>,
-    JoinHandle<()>,
-    JoinHandle<()>,
 ) {
-    let (otx, orx) = flume::bounded(1);
-    let tx = submit_job(io_threads);
-    let job: Job = Box::new(move || {
-        let sock = Arc::new(InnerSocket::new(socket_type, options));
-
-        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 {
-                let byte_len = msg.byte_len();
-                send_cons.release();
-                sn.notify();
-                let _ = s.send(msg).await;
-                if !budget.account(byte_len) {
-                    budget.reset();
+    if s.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 budget = omq_proto::flow::DrainBudget::new(256, 1024 * 1024);
+    while let Some(msg) = futures::StreamExt::next(&mut send_cons).await {
+        let byte_len = msg.byte_len();
+        // Release the ring slot before the send so Ruby can refill while
+        // this message is in flight.
+        send_cons.release();
+        sn.notify();
+        let _ = s.send(msg).await;
+        if !budget.account(byte_len) {
+            budget.reset();
+            tokio::task::yield_now().await;
+        }
+    }
+    sn.notify();
+}
+
+/// Move received messages into the Ruby ring in budgeted batches, waking
+/// the reader once per batch.
+async fn run_recv_pump(
+    s: Arc<InnerSocket>,
+    mut recv_prod: yring::Producer<omq_tokio::Message>,
+    rn: Arc<PipeNotify>,
+    rs: Arc<tokio::sync::Notify>,
+) {
+    loop {
+        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 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;
                 }
             }
-            sn.notify();
-        });
-
-        let s = sock.clone();
-        let rn = recv_notify.clone();
-        let rs = recv_space.clone();
-        let recv_pump = tokio::spawn(async move {
-            loop {
-                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 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,
-                            }
-                        }
+            Err(omq_tokio::Error::Closed) => break,
+            Err(_) => {}
+        }
+    }
+}
+
+/// Forward monitor events to Ruby and fire the one-shot peer milestones.
+async fn run_monitor_pump(
+    peer_ready_sock: Arc<InnerSocket>,
+    mut stream: omq_tokio::MonitorStream,
+    sinks: MonitorSinks,
+) {
+    let mut peer_count: u32 = 0;
+    let mut had_peers = false;
+    let mut peer_connected_fired = false;
+    let mut subscriber_joined_fired = false;
 
-                        recv_prod.flush();
-                        rn.force_wake();
-                        if !more {
-                            tokio::task::yield_now().await;
+    loop {
+        match stream.recv().await {
+            Ok(event) => {
+                match &event {
+                    omq_tokio::MonitorEvent::HandshakeSucceeded { .. } => {
+                        peer_count += 1;
+                        had_peers = true;
+                        if !peer_connected_fired {
+                            peer_connected_fired = true;
+                            let _ = peer_ready_sock.connections().await;
+                            sinks.peer_connected.force_wake();
                         }
                     }
-                    Err(omq_tokio::Error::Closed) => break,
-                    Err(_) => {}
-                }
-            }
-        });
-
-        let mut stream = sock.monitor();
-        let peer_ready_sock = sock.clone();
-        let monitor_pump = tokio::spawn(async move {
-            let mut peer_count: u32 = 0;
-            let mut had_peers = false;
-            let mut peer_connected_fired = false;
-            let mut subscriber_joined_fired = false;
-
-            loop {
-                match stream.recv().await {
-                    Ok(event) => {
-                        match &event {
-                            omq_tokio::MonitorEvent::HandshakeSucceeded { .. } => {
-                                peer_count += 1;
-                                had_peers = true;
-                                if !peer_connected_fired {
-                                    peer_connected_fired = true;
-                                    let _ = peer_ready_sock.connections().await;
-                                    peer_connected_notify.force_wake();
-                                }
-                            }
-                            omq_tokio::MonitorEvent::Disconnected { .. } => {
-                                peer_count = peer_count.saturating_sub(1);
-                                if had_peers && peer_count == 0 {
-                                    all_peers_gone_notify.force_wake();
-                                }
-                            }
-                            omq_tokio::MonitorEvent::SubscribeReceived { .. }
-                            | omq_tokio::MonitorEvent::JoinReceived { .. }
-                                if !subscriber_joined_fired =>
-                            {
-                                subscriber_joined_fired = true;
-                                subscriber_joined_notify.force_wake();
-                            }
-                            _ => {}
+                    omq_tokio::MonitorEvent::Disconnected { .. } => {
+                        peer_count = peer_count.saturating_sub(1);
+                        if had_peers && peer_count == 0 {
+                            sinks.all_peers_gone.force_wake();
                         }
-
-                        let data = convert_monitor_event(&event);
-                        let _ = monitor_tx.try_send(data);
-                        monitor_notify.notify();
                     }
-                    Err(omq_tokio::MonitorRecvError::Lagged(_)) => {}
-                    Err(_) => break,
+                    omq_tokio::MonitorEvent::SubscribeReceived { .. }
+                    | omq_tokio::MonitorEvent::JoinReceived { .. }
+                        if !subscriber_joined_fired =>
+                    {
+                        subscriber_joined_fired = true;
+                        sinks.subscriber_joined.force_wake();
+                    }
+                    _ => {}
                 }
-            }
-        });
 
-        let _ = otx.send((sock, send_pump, recv_pump, monitor_pump));
-    });
-    tx.send(job).expect("omq-rs: tokio runtime gone");
-
-    recv_blocking(orx, "omq-rs: materialize failed")
+                let data = convert_monitor_event(&event);
+                let _ = sinks.events.try_send(data);
+                sinks.notify.notify();
+            }
+            Err(omq_tokio::MonitorRecvError::Lagged(_)) => {}
+            Err(_) => break,
+        }
+    }
 }
 
 async fn watch_rep_send_capacity(
@@ -454,15 +511,21 @@ async fn watch_rep_send_capacity(
     }
 }
 
+/// Stop the pumps and close the socket, giving queued sends up to the
+/// linger time (30 s when unset, at least 10 ms) to flush.
 pub fn destroy_socket(
     io_threads: usize,
     sock: Arc<InnerSocket>,
     send_prod: Mutex<yring::AsyncProducer<omq_tokio::Message>>,
-    mut send_pump: JoinHandle<()>,
-    recv_pump: JoinHandle<()>,
-    monitor_pump: JoinHandle<()>,
+    tasks: SocketTasks,
     linger: Option<Duration>,
 ) {
+    let SocketTasks {
+        send: mut send_pump,
+        recv: recv_pump,
+        monitor: monitor_pump,
+    } = tasks;
+
     recv_pump.abort();
     monitor_pump.abort();
     if sock.socket_type() == omq_tokio::SocketType::Rep {

data/ext/omq_rs_native/src/socket.rs

@@ -344,7 +344,18 @@ fn rust_socket_materialize_impl(rb_self: &RustSocket) -> RbResult<()> {
     }
 
     #[cfg(feature = "plain")]
-    if rb_self
+    ensure_plain_auth_configured(rb_self)?;
+
+    let opts = rb_self.options.lock().unwrap().take().unwrap_or_default();
+    *slot = Some(spawn_materialized(rb_self.socket_type, opts));
+    Ok(())
+}
+
+/// A PLAIN server without an installed authenticator would reject every
+/// client; fail loudly at materialization instead.
+#[cfg(feature = "plain")]
+fn ensure_plain_auth_configured(rb_self: &RustSocket) -> RbResult<()> {
+    let plain_server = rb_self
         .options
         .lock()
         .unwrap()
@@ -354,15 +365,21 @@ fn rust_socket_materialize_impl(rb_self: &RustSocket) -> RbResult<()> {
                 options.mechanism,
                 omq_proto::MechanismSetup::PlainServer { .. }
             )
-        })
-        && !rb_self.plain_auth_configured.load(Ordering::Acquire)
-    {
+        });
+    if plain_server && !rb_self.plain_auth_configured.load(Ordering::Acquire) {
         return Err(RubyErr::runtime(
             "PLAIN server requires explicit authentication via set_plain_auth",
         ));
     }
+    Ok(())
+}
 
-    let opts = rb_self.options.lock().unwrap().take().unwrap_or_default();
+/// Build the Ruby-facing rings and signals, then create the socket and
+/// its pumps on the runtime.
+fn spawn_materialized(
+    socket_type: omq_tokio::SocketType,
+    opts: omq_tokio::Options,
+) -> Materialized {
     let send_cap = opts.send_hwm.max(1) as usize;
     let recv_cap = opts.recv_hwm.max(1) as usize;
     let (send_prod, send_cons) = yring::async_spsc(send_cap);
@@ -378,41 +395,38 @@ fn rust_socket_materialize_impl(rb_self: &RustSocket) -> RbResult<()> {
     let all_peers_gone_notify = Arc::new(PipeNotify::new());
     let subscriber_joined_notify = Arc::new(PipeNotify::new());
 
-    let (socket, send_pump, recv_pump, monitor_pump) = runtime::materialize(
-        io_threads(),
-        rb_self.socket_type,
-        opts,
+    let pumps = runtime::PumpChannels {
         send_cons,
+        send_notify: send_notify.clone(),
+        send_waiting: send_waiting.clone(),
         recv_prod,
-        recv_notify.clone(),
-        send_notify.clone(),
-        send_waiting.clone(),
-        recv_space.clone(),
-        monitor_tx,
-        monitor_notify.clone(),
-        peer_connected_notify.clone(),
-        all_peers_gone_notify.clone(),
-        subscriber_joined_notify.clone(),
-    );
+        recv_notify: recv_notify.clone(),
+        recv_space: recv_space.clone(),
+    };
+    let monitor = runtime::MonitorSinks {
+        events: monitor_tx,
+        notify: monitor_notify.clone(),
+        peer_connected: peer_connected_notify.clone(),
+        all_peers_gone: all_peers_gone_notify.clone(),
+        subscriber_joined: subscriber_joined_notify.clone(),
+    };
+    let (socket, tasks) = runtime::materialize(io_threads(), socket_type, opts, pumps, monitor);
 
-    *slot = Some(Materialized {
+    Materialized {
         socket,
         send_prod: Mutex::new(send_prod),
         recv_cons: Mutex::new(recv_cons),
         recv_notify,
         send_notify,
         recv_space,
-        send_pump,
         send_waiting,
-        recv_pump,
         monitor_rx,
         monitor_notify,
         peer_connected_notify,
         all_peers_gone_notify,
         subscriber_joined_notify,
-        monitor_pump,
-    });
-    Ok(())
+        tasks,
+    }
 }
 
 unsafe extern "C" fn rust_socket_materialize(rb_self: VALUE) -> VALUE {
@@ -931,15 +945,7 @@ fn rust_socket_close_impl(rb_self: &RustSocket, wait_for_auth_worker: bool) {
         m.subscriber_joined_notify.force_wake();
         m.monitor_notify.force_wake();
         let linger = *rb_self.linger.lock().unwrap();
-        runtime::destroy_socket(
-            io_threads(),
-            m.socket,
-            m.send_prod,
-            m.send_pump,
-            m.recv_pump,
-            m.monitor_pump,
-            linger,
-        );
+        runtime::destroy_socket(io_threads(), m.socket, m.send_prod, m.tasks, linger);
     }
 }
 
@@ -1085,33 +1091,55 @@ pub fn register(native: VALUE) -> RbResult<()> {
         rb::undef_alloc_func(class)?;
         rb::define_singleton_method_1(class, c"new", rust_socket_new)?;
         rb::define_method_1(class, c"set_options", rust_socket_set_options)?;
-        #[cfg(feature = "curve")]
-        {
-            rb::define_method_1(
-                class,
-                c"set_curve_auth_keys",
-                rust_socket_set_curve_auth_keys,
-            )?;
-            rb::define_method_1(
-                class,
-                c"set_curve_auth_callback",
-                rust_socket_set_curve_auth_callback,
-            )?;
-            rb::define_method_0(class, c"clear_curve_auth", rust_socket_clear_curve_auth)?;
-        }
-        #[cfg(feature = "plain")]
-        {
-            rb::define_method_1(
-                class,
-                c"set_plain_auth_credentials",
-                rust_socket_set_plain_auth_credentials,
-            )?;
-            rb::define_method_1(
-                class,
-                c"set_plain_auth_callback",
-                rust_socket_set_plain_auth_callback,
-            )?;
-        }
+    }
+
+    #[cfg(feature = "curve")]
+    register_curve_auth_methods(class)?;
+    #[cfg(feature = "plain")]
+    register_plain_auth_methods(class)?;
+    register_io_methods(class)?;
+
+    Ok(())
+}
+
+#[cfg(feature = "curve")]
+fn register_curve_auth_methods(class: VALUE) -> RbResult<()> {
+    unsafe {
+        rb::define_method_1(
+            class,
+            c"set_curve_auth_keys",
+            rust_socket_set_curve_auth_keys,
+        )?;
+        rb::define_method_1(
+            class,
+            c"set_curve_auth_callback",
+            rust_socket_set_curve_auth_callback,
+        )?;
+        rb::define_method_0(class, c"clear_curve_auth", rust_socket_clear_curve_auth)?;
+    }
+    Ok(())
+}
+
+#[cfg(feature = "plain")]
+fn register_plain_auth_methods(class: VALUE) -> RbResult<()> {
+    unsafe {
+        rb::define_method_1(
+            class,
+            c"set_plain_auth_credentials",
+            rust_socket_set_plain_auth_credentials,
+        )?;
+        rb::define_method_1(
+            class,
+            c"set_plain_auth_callback",
+            rust_socket_set_plain_auth_callback,
+        )?;
+    }
+    Ok(())
+}
+
+/// Lifecycle, endpoint, message, readiness fd, and subscription methods.
+fn register_io_methods(class: VALUE) -> RbResult<()> {
+    unsafe {
         rb::define_method_0(class, c"materialize", rust_socket_materialize)?;
         rb::define_method_1(class, c"bind", rust_socket_bind)?;
         rb::define_method_1(class, c"connect", rust_socket_connect)?;

data/lib/omq/rs/socket.rb

@@ -671,11 +671,13 @@ module OMQ
       #
       # @return [nil]
       def close
-        return if closed?
+        @materialize_lock.synchronize do
+          return if closed?
 
-        @native.close
-        close_wrapper(@recv_io)
-        close_wrapper(@send_io)
+          @native.close
+          close_wrapper(@recv_io)
+          close_wrapper(@send_io)
+        end
         nil
       end
 

data/lib/omq/rs/version.rb

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

metadata

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