zzq 0.1.1 → 0.2.0

data/ext/zzq_native/src/broker.rs

@@ -0,0 +1,163 @@
+//! `ZZQ::Native::Broker`: a running broker.
+
+use std::sync::{Arc, Mutex, OnceLock, PoisonError};
+
+use rb_sys::VALUE;
+use zzq_broker::{Broker, FilePersistence, QoS, Stats};
+
+use crate::error::Error;
+use crate::op::{self, Out};
+use crate::rb::{self, DataType, RbResult, RubyErr};
+use crate::{context, options};
+
+static TYPE: DataType = DataType::new::<NativeBroker>(c"ZZQ::Native::Broker");
+static CLASS: OnceLock<usize> = OnceLock::new();
+
+#[derive(Debug)]
+struct NativeBroker {
+    /// `None` once shut down.
+    broker: Mutex<Option<Arc<Broker>>>,
+    /// Flushed after a shutdown, so a broker started next on the same
+    /// file finds every retained message.
+    store: Option<Arc<FilePersistence>>,
+}
+
+fn get(value: VALUE) -> RbResult<Arc<Broker>> {
+    let native: &NativeBroker = unsafe { TYPE.get(value) }?;
+    native
+        .broker
+        .lock()
+        .unwrap_or_else(PoisonError::into_inner)
+        .clone()
+        .ok_or_else(|| Error::Broker(zzq_broker::Error::Closed).into())
+}
+
+/// A Ruby object for a running broker.
+pub fn wrap(b: Broker, store: Option<Arc<FilePersistence>>) -> RbResult<VALUE> {
+    let native = NativeBroker {
+        broker: Mutex::new(Some(Arc::new(b))),
+        store,
+    };
+    TYPE.wrap(*CLASS.get().expect("registered") as VALUE, native)
+}
+
+pub fn stats_hash(s: &Stats) -> RbResult<VALUE> {
+    let h = rb::hash_new()?;
+    for (key, value) in [
+        ("connections", s.connections),
+        ("sessions", s.sessions),
+        ("subscriptions", s.subscriptions),
+        ("retained", s.retained),
+        ("publishes", s.publishes),
+        ("deliveries", s.deliveries),
+        ("dropped_buffer_full", s.dropped_buffer_full),
+        ("dropped_offline", s.dropped_offline),
+        ("dropped_queue_full", s.dropped_queue_full),
+        ("dropped_too_large", s.dropped_too_large),
+        ("dropped_expired", s.dropped_expired),
+        ("retained_rejected", s.retained_rejected),
+    ] {
+        rb::hash_aset(h, rb::symbol(key)?, rb::u64_value(value))?;
+    }
+    Ok(h)
+}
+
+fn start(opts: VALUE) -> RbResult<VALUE> {
+    let (opts, store) = options::broker(opts)?;
+    let ctx = context::get()?;
+    op::new(async move { Ok(Out::Broker(Broker::new(&ctx, opts).await?, store)) })
+}
+
+fn bind(this: VALUE, uri: VALUE) -> RbResult<VALUE> {
+    let b = get(this)?;
+    let uri = rb::value_to_string(uri)?;
+    op::new(async move { Ok(Out::Endpoint(b.bind(&uri).await?.to_string())) })
+}
+
+fn publish(
+    this: VALUE,
+    topic: VALUE,
+    payload: VALUE,
+    qos: VALUE,
+    retain: VALUE,
+) -> RbResult<VALUE> {
+    let b = get(this)?;
+    let qos: QoS = options::qos(rb::value_to_i64(qos)?)?;
+    let retain = rb::value_to_bool(retain)?;
+    let topic = rb::string_value(topic)?;
+    let payload = rb::string_value(payload)?;
+    // No calls into Ruby while the string slices are in use.
+    let (topic, payload) = unsafe { (rb::string_bytes(topic), rb::string_bytes(payload)) };
+    let topic = std::str::from_utf8(topic).map_err(|_| RubyErr::arg("topic must be UTF-8"))?;
+    let res = if retain {
+        b.publish_retained(topic, payload, qos)
+    } else {
+        b.publish(topic, payload, qos)
+    };
+    res.map_err(Error::from)?;
+    Ok(rb::qnil())
+}
+
+fn stats(this: VALUE) -> RbResult<VALUE> {
+    let b = get(this)?;
+    op::new(async move { Ok(Out::Stats(b.stats().await?)) })
+}
+
+/// An op that waits for the shutdown, or nil if an op still holds the
+/// broker: it stops once that op is done.
+fn shutdown(this: VALUE) -> RbResult<VALUE> {
+    let native: &NativeBroker = unsafe { TYPE.get(this) }?;
+    let taken = native
+        .broker
+        .lock()
+        .unwrap_or_else(PoisonError::into_inner)
+        .take();
+    let store = native.store.clone();
+    match taken.map(Arc::try_unwrap) {
+        Some(Ok(b)) => op::new(async move {
+            b.shutdown().await;
+            if let Some(store) = store {
+                store.flush();
+            }
+            Ok(Out::Nil)
+        }),
+        _ => Ok(rb::qnil()),
+    }
+}
+
+unsafe extern "C" fn broker_start(_class: VALUE, opts: VALUE) -> VALUE {
+    rb::wrap(|| start(opts))
+}
+
+unsafe extern "C" fn broker_bind(this: VALUE, uri: VALUE) -> VALUE {
+    rb::wrap(|| bind(this, uri))
+}
+
+unsafe extern "C" fn broker_publish(
+    this: VALUE,
+    topic: VALUE,
+    payload: VALUE,
+    qos: VALUE,
+    retain: VALUE,
+) -> VALUE {
+    rb::wrap(|| publish(this, topic, payload, qos, retain))
+}
+
+unsafe extern "C" fn broker_stats(this: VALUE) -> VALUE {
+    rb::wrap(|| stats(this))
+}
+
+unsafe extern "C" fn broker_shutdown(this: VALUE) -> VALUE {
+    rb::wrap(|| shutdown(this))
+}
+
+pub fn register(native: VALUE) -> RbResult<()> {
+    let class = rb::define_class_under(native, c"Broker")?;
+    let _ = CLASS.set(class as usize);
+    rb::define_singleton_method(class, c"start", broker_start as *const (), 1)?;
+    rb::define_method(class, c"bind", broker_bind as *const (), 1)?;
+    rb::define_method(class, c"publish", broker_publish as *const (), 4)?;
+    rb::define_method(class, c"stats", broker_stats as *const (), 0)?;
+    rb::define_method(class, c"shutdown", broker_shutdown as *const (), 0)?;
+    Ok(())
+}

data/ext/zzq_native/src/client.rs

@@ -0,0 +1,294 @@
+//! `ZZQ::Native::Client`: a connected client.
+//!
+//! Publishes go through a [`Handle`] and copy the Ruby string straight
+//! into the send queue. Receiving takes what the inbox holds without a
+//! stored future. Only once the inbox is empty does a future wait, kept in
+//! `recv`, so that a wake reaches the fiber waiting for it.
+
+use std::future::Future;
+use std::pin::{Pin, pin};
+use std::sync::{Arc, Mutex, OnceLock, PoisonError};
+use std::task::{Context, Poll, Waker};
+
+use rb_sys::VALUE;
+use zzq_client::{Client, Handle, Message, QoS, ReasonCode, SubscriptionOptions};
+
+use crate::error::{self, Error};
+use crate::op::{self, Out};
+use crate::rb::{self, DataType, RbResult, RubyErr};
+use crate::{context, options, wake};
+
+static TYPE: DataType = DataType::new::<NativeClient>(c"ZZQ::Native::Client");
+static CLASS: OnceLock<usize> = OnceLock::new();
+/// `ZZQ::Message` and a frozen empty Array for messages without
+/// Subscription Identifiers.
+static MESSAGE: OnceLock<(usize, usize)> = OnceLock::new();
+
+type Recv = Pin<Box<dyn Future<Output = Option<Message>> + Send>>;
+
+struct NativeClient {
+    handle: Handle,
+    client: Arc<tokio::sync::Mutex<Client>>,
+    /// The wait for the next message, once the inbox ran empty.
+    recv: Mutex<Option<Recv>>,
+    session_present: bool,
+    assigned_client_id: Option<String>,
+}
+
+impl std::fmt::Debug for NativeClient {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("NativeClient")
+            .field("session_present", &self.session_present)
+            .finish_non_exhaustive()
+    }
+}
+
+fn get(value: VALUE) -> RbResult<&'static NativeClient> {
+    unsafe { TYPE.get(value) }
+}
+
+/// A Ruby object for a connected client.
+pub fn wrap(c: Client) -> RbResult<VALUE> {
+    let connected = c.connected();
+    let native = NativeClient {
+        handle: c.handle(),
+        session_present: connected.session_present,
+        assigned_client_id: connected.assigned_client_id.clone(),
+        client: Arc::new(tokio::sync::Mutex::new(c)),
+        recv: Mutex::new(None),
+    };
+    TYPE.wrap(*CLASS.get().expect("registered") as VALUE, native)
+}
+
+fn connect(uri: VALUE, opts: VALUE) -> RbResult<VALUE> {
+    let uri = rb::value_to_string(uri)?;
+    let opts = options::client(opts)?;
+    let ctx = context::get()?;
+    op::new(async move { Ok(Out::Client(Client::connect(&ctx, &uri, opts).await?)) })
+}
+
+fn publish(
+    this: VALUE,
+    topic: VALUE,
+    payload: VALUE,
+    qos: VALUE,
+    retain: VALUE,
+) -> RbResult<VALUE> {
+    let c = get(this)?;
+    let qos = options::qos(rb::value_to_i64(qos)?)?;
+    let retain = rb::value_to_bool(retain)?;
+    let topic = rb::string_value(topic)?;
+    let payload = rb::string_value(payload)?;
+    // No calls into Ruby while the string slices are in use.
+    let (topic, payload) = unsafe { (rb::string_bytes(topic), rb::string_bytes(payload)) };
+    let topic = std::str::from_utf8(topic).map_err(|_| RubyErr::arg("topic must be UTF-8"))?;
+    let queued = {
+        let fut = pin!(c.handle.enqueue(topic, payload, qos, retain));
+        fut.poll(&mut Context::from_waker(Waker::noop()))
+    };
+    match queued {
+        Poll::Ready(Ok(_)) if qos == QoS::AtMostOnce => Ok(rb::qnil()),
+        Poll::Ready(Ok(acked)) => op::acked(acked),
+        Poll::Ready(Err(e)) => Err(Error::from(e).into()),
+        Poll::Pending => {
+            // The queue is full: wait with a copy.
+            let (topic, payload, h) = (topic.to_owned(), payload.to_vec(), c.handle.clone());
+            op::new(async move {
+                h.enqueue(&topic, &payload, qos, retain).await?.await?;
+                Ok(Out::Nil)
+            })
+        }
+    }
+}
+
+fn subscribe(this: VALUE, filters: VALUE, sub_id: VALUE) -> RbResult<VALUE> {
+    let h = get(this)?.handle.clone();
+    let sub_id = u32::try_from(rb::value_to_i64(sub_id)?)
+        .map_err(|_| RubyErr::arg("subscription_id out of range"))?;
+    let mut parsed = Vec::new();
+    for f in rb::array_entries(filters)? {
+        let [filter, qos, no_local, rap, rh] = rb::array_entries(f)?[..] else {
+            return Err(RubyErr::arg("expected [filter, qos, no_local, rap, rh]"));
+        };
+        let opts = SubscriptionOptions {
+            qos: options::qos(rb::value_to_i64(qos)?)?,
+            no_local: rb::value_to_bool(no_local)?,
+            retain_as_published: rb::value_to_bool(rap)?,
+            retain_handling: u8::try_from(rb::value_to_i64(rh)?)
+                .ok()
+                .filter(|n| *n <= 2)
+                .ok_or_else(|| RubyErr::arg("retain_handling must be 0, 1 or 2"))?,
+        };
+        parsed.push((rb::value_to_string(filter)?, opts));
+    }
+    op::new(async move {
+        let refs: Vec<_> = parsed.iter().map(|(f, o)| (f.as_str(), *o)).collect();
+        Ok(Out::Codes(h.subscribe_with(&refs, sub_id).await?))
+    })
+}
+
+fn unsubscribe(this: VALUE, filters: VALUE) -> RbResult<VALUE> {
+    let h = get(this)?.handle.clone();
+    let filters = rb::array_entries(filters)?
+        .into_iter()
+        .map(rb::value_to_string)
+        .collect::<RbResult<Vec<_>>>()?;
+    op::new(async move {
+        let refs: Vec<_> = filters.iter().map(String::as_str).collect();
+        Ok(Out::Codes(h.unsubscribe(&refs).await?))
+    })
+}
+
+/// Up to `max` messages as an Array, `PENDING` if none came yet, or nil
+/// once the client is closed.
+fn receive(this: VALUE, wake: VALUE, max: VALUE) -> RbResult<VALUE> {
+    let c = get(this)?;
+    let wake = wake::get(wake)?;
+    let max = usize::try_from(rb::value_to_i64(max)?).unwrap_or(1).max(1);
+    let mut got = Vec::new();
+    let mut slot = c.recv.lock().unwrap_or_else(PoisonError::into_inner);
+    if let Some(fut) = slot.as_mut() {
+        let Poll::Ready(m) = wake.poll(fut.as_mut()) else {
+            return Ok(op::pending());
+        };
+        *slot = None;
+        match m {
+            Some(m) => got.push(m),
+            None => return Ok(rb::qnil()),
+        }
+    }
+    {
+        let Ok(mut client) = c.client.try_lock() else {
+            return Err(error::zzq("another receive is in progress"));
+        };
+        let mut cx = Context::from_waker(Waker::noop());
+        while got.len() < max {
+            match pin!(client.recv()).poll(&mut cx) {
+                Poll::Ready(Some(m)) => got.push(m),
+                Poll::Ready(None) if got.is_empty() => return Ok(rb::qnil()),
+                Poll::Ready(None) | Poll::Pending => break,
+            }
+        }
+    }
+    if got.is_empty() {
+        let Ok(mut client) = c.client.clone().try_lock_owned() else {
+            return Err(error::zzq("another receive is in progress"));
+        };
+        let mut fut: Recv = Box::pin(async move { client.recv().await });
+        match wake.poll(fut.as_mut()) {
+            Poll::Pending => {
+                *slot = Some(fut);
+                return Ok(op::pending());
+            }
+            Poll::Ready(None) => return Ok(rb::qnil()),
+            Poll::Ready(Some(m)) => got.push(m),
+        }
+    }
+    drop(slot);
+    messages(got)
+}
+
+fn messages(got: Vec<Message>) -> RbResult<VALUE> {
+    let &(class, no_ids) = MESSAGE.get().expect("registered");
+    let array = rb::array_new_capa(got.len())?;
+    for m in got {
+        let ids = if m.subscription_ids.is_empty() {
+            no_ids as VALUE
+        } else {
+            let ids = rb::array_new_capa(m.subscription_ids.len())?;
+            for id in &m.subscription_ids {
+                rb::array_push(ids, rb::u64_value((*id).into()))?;
+            }
+            rb::freeze(ids)
+        };
+        let args = [
+            rb::interned_utf8_string(m.topic.as_str())?,
+            rb::new_binary_string(&m.payload)?,
+            rb::u64_value(m.qos as u64),
+            rb::bool_value(m.retain),
+            ids,
+        ];
+        rb::array_push(array, rb::call(class as VALUE, c"new", &args)?)?;
+    }
+    Ok(array)
+}
+
+fn disconnect(this: VALUE, reason: VALUE) -> RbResult<VALUE> {
+    let h = get(this)?.handle.clone();
+    let reason = u8::try_from(rb::value_to_i64(reason)?)
+        .map_err(|_| RubyErr::arg("reason code out of range"))?;
+    op::new(async move {
+        h.disconnect_with(ReasonCode::from(reason)).await;
+        Ok(Out::Nil)
+    })
+}
+
+unsafe extern "C" fn client_connect(_class: VALUE, uri: VALUE, opts: VALUE) -> VALUE {
+    rb::wrap(|| connect(uri, opts))
+}
+
+unsafe extern "C" fn client_publish(
+    this: VALUE,
+    topic: VALUE,
+    payload: VALUE,
+    qos: VALUE,
+    retain: VALUE,
+) -> VALUE {
+    rb::wrap(|| publish(this, topic, payload, qos, retain))
+}
+
+unsafe extern "C" fn client_subscribe(this: VALUE, filters: VALUE, sub_id: VALUE) -> VALUE {
+    rb::wrap(|| subscribe(this, filters, sub_id))
+}
+
+unsafe extern "C" fn client_unsubscribe(this: VALUE, filters: VALUE) -> VALUE {
+    rb::wrap(|| unsubscribe(this, filters))
+}
+
+unsafe extern "C" fn client_receive(this: VALUE, wake: VALUE, max: VALUE) -> VALUE {
+    rb::wrap(|| receive(this, wake, max))
+}
+
+unsafe extern "C" fn client_disconnect(this: VALUE, reason: VALUE) -> VALUE {
+    rb::wrap(|| disconnect(this, reason))
+}
+
+unsafe extern "C" fn client_session_present(this: VALUE) -> VALUE {
+    rb::wrap(|| Ok(rb::bool_value(get(this)?.session_present)))
+}
+
+unsafe extern "C" fn client_assigned_client_id(this: VALUE) -> VALUE {
+    rb::wrap(|| match &get(this)?.assigned_client_id {
+        Some(id) => rb::new_utf8_string(id),
+        None => Ok(rb::qnil()),
+    })
+}
+
+pub fn register(zzq: VALUE, native: VALUE) -> RbResult<()> {
+    let message = rb::const_get(zzq, c"Message")?;
+    let no_ids = rb::freeze(rb::array_new_capa(0)?);
+    rb::define_const(native, c"NO_SUBSCRIPTION_IDS", no_ids)?;
+    let _ = MESSAGE.set((message as usize, no_ids as usize));
+
+    let class = rb::define_class_under(native, c"Client")?;
+    let _ = CLASS.set(class as usize);
+    rb::define_singleton_method(class, c"connect", client_connect as *const (), 2)?;
+    rb::define_method(class, c"publish", client_publish as *const (), 4)?;
+    rb::define_method(class, c"subscribe", client_subscribe as *const (), 2)?;
+    rb::define_method(class, c"unsubscribe", client_unsubscribe as *const (), 1)?;
+    rb::define_method(class, c"receive", client_receive as *const (), 2)?;
+    rb::define_method(class, c"disconnect", client_disconnect as *const (), 1)?;
+    rb::define_method(
+        class,
+        c"session_present?",
+        client_session_present as *const (),
+        0,
+    )?;
+    rb::define_method(
+        class,
+        c"assigned_client_id",
+        client_assigned_client_id as *const (),
+        0,
+    )?;
+    Ok(())
+}

data/ext/zzq_native/src/context.rs

@@ -0,0 +1,51 @@
+//! The one `zzq_tokio::Context` that clients and brokers of this process
+//! share.
+
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::{Mutex, PoisonError};
+
+use zzq_client::{Config, Context};
+
+use crate::error::Error;
+
+static IO_THREADS: AtomicUsize = AtomicUsize::new(1);
+static CONTEXT: Mutex<Option<(u32, Context)>> = Mutex::new(None);
+
+/// The shared context, started on first use. A forked child gets its own:
+/// the parent's lane threads do not exist in it.
+pub fn get() -> Result<Context, Error> {
+    let pid = std::process::id();
+    let mut slot = CONTEXT.lock().unwrap_or_else(PoisonError::into_inner);
+    if let Some((owner, ctx)) = slot.as_ref()
+        && *owner == pid
+    {
+        return Ok(ctx.clone());
+    }
+    // Dropping the parent's context would wait for threads this process
+    // does not have.
+    std::mem::forget(slot.take());
+    let config = Config {
+        io_threads: IO_THREADS.load(Ordering::Relaxed),
+        ..Config::default()
+    };
+    let ctx = Context::with_config(&config).map_err(zzq_client::Error::from)?;
+    *slot = Some((pid, ctx.clone()));
+    Ok(ctx)
+}
+
+pub fn io_threads() -> usize {
+    IO_THREADS.load(Ordering::Relaxed)
+}
+
+/// Sets the lane count, unless the context runs already.
+pub fn set_io_threads(n: usize) -> bool {
+    let slot = CONTEXT.lock().unwrap_or_else(PoisonError::into_inner);
+    if slot
+        .as_ref()
+        .is_some_and(|(owner, _)| *owner == std::process::id())
+    {
+        return false;
+    }
+    IO_THREADS.store(n.max(1), Ordering::Relaxed);
+    true
+}

data/ext/zzq_native/src/error.rs

@@ -0,0 +1,117 @@
+//! Rust errors as `ZZQ::Error` and its subclasses, which `lib/zzq/errors.rb`
+//! defines before the extension loads.
+
+use std::sync::OnceLock;
+
+use rb_sys::VALUE;
+
+use crate::rb::{self, RbResult, RubyErr};
+
+/// An error from the client or the broker crate.
+#[derive(Debug)]
+pub enum Error {
+    Client(zzq_client::Error),
+    Broker(zzq_broker::Error),
+}
+
+impl From<zzq_client::Error> for Error {
+    fn from(e: zzq_client::Error) -> Self {
+        Error::Client(e)
+    }
+}
+
+impl From<zzq_broker::Error> for Error {
+    fn from(e: zzq_broker::Error) -> Self {
+        Error::Broker(e)
+    }
+}
+
+struct Classes {
+    error: VALUE,
+    closed: VALUE,
+    transport: VALUE,
+    protocol: VALUE,
+    invalid_topic: VALUE,
+    too_large: VALUE,
+    refused: VALUE,
+    rejected: VALUE,
+}
+
+unsafe impl Send for Classes {}
+unsafe impl Sync for Classes {}
+
+static CLASSES: OnceLock<Classes> = OnceLock::new();
+
+pub fn init(zzq: VALUE) -> RbResult<()> {
+    let classes = Classes {
+        error: rb::const_get(zzq, c"Error")?,
+        closed: rb::const_get(zzq, c"ClosedError")?,
+        transport: rb::const_get(zzq, c"TransportError")?,
+        protocol: rb::const_get(zzq, c"ProtocolError")?,
+        invalid_topic: rb::const_get(zzq, c"InvalidTopic")?,
+        too_large: rb::const_get(zzq, c"TooLarge")?,
+        refused: rb::const_get(zzq, c"ConnectionRefused")?,
+        rejected: rb::const_get(zzq, c"Rejected")?,
+    };
+    let _ = CLASSES.set(classes);
+    Ok(())
+}
+
+fn classes() -> &'static Classes {
+    CLASSES.get().expect("error classes loaded")
+}
+
+/// `ZZQ::Error` with `message`.
+pub fn zzq(message: impl Into<String>) -> RubyErr {
+    RubyErr::new(classes().error, message)
+}
+
+/// The message of `e` and of each error that caused it.
+fn chain(e: &dyn std::error::Error) -> String {
+    let mut message = e.to_string();
+    let mut source = e.source();
+    while let Some(s) = source {
+        message.push_str(": ");
+        message.push_str(&s.to_string());
+        source = s.source();
+    }
+    message
+}
+
+/// An exception that carries the reason code.
+fn with_code(class: VALUE, message: &str, code: zzq_client::ReasonCode) -> RubyErr {
+    let built = rb::new_utf8_string(message).and_then(|m| {
+        let code = rb::u64_value(u8::from(code).into());
+        rb::call(class, c"new", &[m, code])
+    });
+    match built {
+        Ok(exc) => RubyErr::Exception(exc),
+        Err(e) => e,
+    }
+}
+
+impl From<Error> for RubyErr {
+    fn from(e: Error) -> Self {
+        use zzq_client::Error as C;
+        let c = classes();
+        let message = match &e {
+            Error::Client(e) => chain(e),
+            Error::Broker(e) => chain(e),
+        };
+        let class = match e {
+            Error::Client(C::Refused(code)) => return with_code(c.refused, &message, code),
+            Error::Client(C::Rejected(code)) => return with_code(c.rejected, &message, code),
+            Error::Client(C::Transport(_)) | Error::Broker(zzq_broker::Error::Transport(_)) => {
+                c.transport
+            }
+            Error::Client(C::Protocol(_)) => c.protocol,
+            Error::Client(C::InvalidTopic(_))
+            | Error::Broker(zzq_broker::Error::InvalidTopic(_)) => c.invalid_topic,
+            Error::Client(C::TooLarge | C::TooLong(_))
+            | Error::Broker(zzq_broker::Error::TooLarge) => c.too_large,
+            Error::Client(C::Closed) | Error::Broker(zzq_broker::Error::Closed) => c.closed,
+            _ => c.error,
+        };
+        RubyErr::new(class, message)
+    }
+}

data/ext/zzq_native/src/lib.rs

@@ -0,0 +1,52 @@
+//! Native part of the `zzq` gem: `ZZQ::Native`, which `lib/zzq` wraps.
+
+mod broker;
+mod client;
+mod context;
+mod error;
+mod op;
+mod options;
+mod rb;
+mod wake;
+
+use rb_sys::VALUE;
+
+use crate::rb::RbResult;
+
+unsafe extern "C" fn io_threads(_module: VALUE) -> VALUE {
+    rb::wrap(|| Ok(rb::u64_value(context::io_threads() as u64)))
+}
+
+unsafe extern "C" fn set_io_threads(_module: VALUE, n: VALUE) -> VALUE {
+    rb::wrap(|| {
+        let n = usize::try_from(rb::value_to_i64(n)?)
+            .map_err(|_| rb::RubyErr::arg("io_threads must be positive"))?;
+        if !context::set_io_threads(n) {
+            return Err(error::zzq(
+                "set io_threads before the first client or broker",
+            ));
+        }
+        Ok(rb::qnil())
+    })
+}
+
+/// Called once by Ruby when it loads the extension.
+#[unsafe(no_mangle)]
+pub extern "C" fn Init_zzq_native() {
+    if let Err(e) = init() {
+        rb::raise(e);
+    }
+}
+
+fn init() -> RbResult<()> {
+    let zzq = rb::define_module(c"ZZQ")?;
+    let native = rb::define_module_under(zzq, c"Native")?;
+    error::init(zzq)?;
+    rb::define_singleton_method(native, c"io_threads", io_threads as *const (), 0)?;
+    rb::define_singleton_method(native, c"io_threads=", set_io_threads as *const (), 1)?;
+    wake::register(native)?;
+    op::register(native)?;
+    client::register(zzq, native)?;
+    broker::register(native)?;
+    Ok(())
+}