prosody 0.5.1 → 0.6.0

data/ext/prosody/src/handler/state/set.rs

@@ -0,0 +1,98 @@
+//! Native handle for a presence-only ordered set of `String` members.
+//!
+//! A set stores membership only. Member traversal reuses the map key cursor,
+//! since both yield bare `String` keys.
+
+use super::{NativeMapKeyScan, key_query, outcome_symbol, run_state, wrapped_class};
+use crate::bridge::Bridge;
+use magnus::{Error, Module, RHash, RModule, Ruby, StaticSymbol, method};
+use opentelemetry::propagation::TextMapCompositePropagator;
+use prosody::consumer::event_context::DynSetState;
+use std::sync::Arc;
+
+/// Native set handle, wrapped by `Prosody::SetState`.
+#[magnus::wrap(class = "Prosody::NativeSetState")]
+pub struct NativeSetState {
+    state: Arc<dyn DynSetState>,
+    bridge: Bridge,
+    propagator: Arc<TextMapCompositePropagator>,
+}
+
+impl NativeSetState {
+    pub(crate) fn new(
+        state: Arc<dyn DynSetState>,
+        bridge: Bridge,
+        propagator: Arc<TextMapCompositePropagator>,
+    ) -> Self {
+        Self {
+            state,
+            bridge,
+            propagator,
+        }
+    }
+
+    fn contains(ruby: &Ruby, this: &Self, member: String) -> Result<bool, Error> {
+        run_op!(ruby, this, &this.state, contains(member))
+    }
+
+    fn contains_many(ruby: &Ruby, this: &Self, members: Vec<String>) -> Result<Vec<bool>, Error> {
+        run_op!(ruby, this, &this.state, contains_many(members))
+    }
+
+    fn is_empty(ruby: &Ruby, this: &Self) -> Result<bool, Error> {
+        run_op!(ruby, this, &this.state, is_empty())
+    }
+
+    fn insert(ruby: &Ruby, this: &Self, member: String) -> Result<(), Error> {
+        run_op!(ruby, this, &this.state, insert(member))
+    }
+
+    fn remove(ruby: &Ruby, this: &Self, member: String) -> Result<(), Error> {
+        run_op!(ruby, this, &this.state, remove(member))
+    }
+
+    fn clear(ruby: &Ruby, this: &Self) -> Result<(), Error> {
+        run_op!(ruby, this, &this.state, clear())
+    }
+
+    fn keys(
+        ruby: &Ruby,
+        this: &Self,
+        direction: StaticSymbol,
+        options: RHash,
+    ) -> Result<NativeMapKeyScan, Error> {
+        let query = key_query(ruby, direction, options)?;
+        Ok(NativeMapKeyScan::new(
+            this.state.keys().with_query(query).stream(),
+            this.bridge.clone(),
+            Arc::clone(&this.propagator),
+        ))
+    }
+
+    fn commit(ruby: &Ruby, this: &Self) -> Result<StaticSymbol, Error> {
+        let outcome = run_op!(ruby, this, &this.state, commit())?;
+        Ok(outcome_symbol(ruby, outcome))
+    }
+
+    fn rollback(ruby: &Ruby, this: &Self) -> Result<StaticSymbol, Error> {
+        let state = Arc::clone(&this.state);
+        let outcome = run_state(ruby, &this.bridge, &this.propagator, async move {
+            Ok(state.rollback().await)
+        })?;
+        Ok(outcome_symbol(ruby, outcome))
+    }
+
+    pub(super) fn register(ruby: &Ruby, module: RModule) -> Result<(), Error> {
+        let class = wrapped_class(ruby, module, "Prosody::NativeSetState")?;
+        class.define_method("contains", method!(NativeSetState::contains, 1))?;
+        class.define_method("contains_many", method!(NativeSetState::contains_many, 1))?;
+        class.define_method("is_empty", method!(NativeSetState::is_empty, 0))?;
+        class.define_method("insert", method!(NativeSetState::insert, 1))?;
+        class.define_method("remove", method!(NativeSetState::remove, 1))?;
+        class.define_method("clear", method!(NativeSetState::clear, 0))?;
+        class.define_method("keys", method!(NativeSetState::keys, 2))?;
+        class.define_method("commit", method!(NativeSetState::commit, 0))?;
+        class.define_method("rollback", method!(NativeSetState::rollback, 0))?;
+        Ok(())
+    }
+}

data/ext/prosody/src/lib.rs

@@ -8,19 +8,20 @@
 //! provides client functionality for interacting with message brokers,
 //! manages message handling, and includes logging and scheduling capabilities.
 
-// Temporarily removing allows to see what lints we have
-
-#![allow(clippy::multiple_crate_versions, missing_docs)]
+#![expect(
+    clippy::multiple_crate_versions,
+    reason = "the dependency graph resolves some crates at two versions"
+)]
 #![recursion_limit = "256"]
 
 use crate::bridge::Bridge;
+use crate::util::report;
+use magnus::RModule;
 use magnus::value::Lazy;
-use magnus::{Error, RModule, Ruby};
-use mimalloc::MiMalloc;
-use std::io::{self, Write};
+use rustfs_mimalloc::MiMalloc;
 use std::process;
 use std::sync::{LazyLock, OnceLock};
-use tokio::runtime::Runtime;
+use tokio::runtime::{Builder, Runtime};
 
 mod admin;
 mod bridge;
@@ -33,6 +34,13 @@ mod scheduler;
 mod tracing_util;
 mod util;
 
+/// Stack size of each Tokio worker thread.
+///
+/// Core futures are large, most of all in debug builds. A timer write that
+/// polls through the Cassandra driver can overflow the Tokio default of
+/// 2 MiB. The size applies to every build.
+const WORKER_STACK_SIZE: usize = 8 * 1024 * 1024;
+
 #[global_allocator]
 static GLOBAL: MiMalloc = MiMalloc;
 
@@ -47,14 +55,18 @@ pub static TRACING_INIT: OnceLock<()> = OnceLock::new();
 ///
 /// This runtime powers all async operations in the extension, including
 /// message processing, scheduling, and communication with Ruby.
-static RUNTIME: LazyLock<Runtime> = LazyLock::new(|| match Runtime::new() {
-    Ok(runtime) => runtime,
-    Err(error) => {
-        drop(writeln!(
-            io::stderr().lock(),
-            "failed to create Tokio runtime: {error:#}"
-        ));
-        process::abort();
+static RUNTIME: LazyLock<Runtime> = LazyLock::new(|| {
+    let runtime = Builder::new_multi_thread()
+        .enable_all()
+        .thread_stack_size(WORKER_STACK_SIZE)
+        .build();
+
+    match runtime {
+        Ok(runtime) => runtime,
+        Err(error) => {
+            report(format_args!("failed to create Tokio runtime: {error:#}"));
+            process::abort();
+        }
     }
 });
 
@@ -62,32 +74,38 @@ static RUNTIME: LazyLock<Runtime> = LazyLock::new(|| match Runtime::new() {
 ///
 /// This is lazily initialized during extension startup and provides
 /// access to the `Prosody` module in Ruby.
-#[allow(clippy::expect_used)]
+#[expect(
+    clippy::expect_used,
+    reason = "magnus Lazy takes an infallible initializer"
+)]
 pub static ROOT_MOD: Lazy<RModule> = Lazy::new(|ruby| {
     ruby.define_module("Prosody")
         .expect("Failed to define Prosody module")
 });
 
-/// Initializes the Prosody Ruby extension.
-///
-/// This function initializes the various components of the extension.
+/// The extension entry point that Ruby calls when it loads the library.
 ///
-/// # Arguments
-///
-/// * `ruby` - Reference to the Ruby VM instance
-///
-/// # Errors
-///
-/// Returns a Magnus error if any initialization step fails, such as
-/// defining Ruby classes or configuring components.
-#[magnus::init]
-fn init(ruby: &Ruby) -> Result<(), Error> {
-    admin::init(ruby)?;
-    bridge::init(ruby)?;
-    handler::init(ruby)?;
-    published::init(ruby)?;
-    client::init(ruby)?;
-    util::init(ruby)?;
+/// `#[magnus::init]` generates the exported `Init_prosody` function beside
+/// `init`. The module is private, so that generated function is not public
+/// API.
+mod entry {
+    use magnus::{Error, Ruby};
 
-    Ok(())
+    /// Initializes the Prosody Ruby extension.
+    ///
+    /// # Errors
+    ///
+    /// Returns a Magnus error if any initialization step fails, such as
+    /// defining Ruby classes or configuring components.
+    #[magnus::init]
+    fn init(ruby: &Ruby) -> Result<(), Error> {
+        crate::admin::init(ruby)?;
+        crate::bridge::init(ruby)?;
+        crate::handler::init(ruby)?;
+        crate::published::init(ruby)?;
+        crate::client::init(ruby)?;
+        crate::util::init(ruby)?;
+
+        Ok(())
+    }
 }

data/ext/prosody/src/logging.rs

@@ -8,12 +8,10 @@
 //! It uses bump allocation for efficient string formatting and concurrent
 //! processing for high-throughput logging scenarios.
 
-#![allow(clippy::print_stderr)]
-
 use crate::ROOT_MOD;
 use crate::bridge::Bridge;
 use crate::id;
-use crate::util::ThreadSafeValue;
+use crate::util::{ThreadSafeValue, report};
 use bumpalo::Bump;
 use bumpalo::collections::string::String as BumpString;
 use educe::Educe;
@@ -113,12 +111,12 @@ async fn log_event(bridge: Bridge, logger: Arc<ThreadSafeValue>, (level, msg): (
             };
 
             if let Err(error) = logger.get(ruby).funcall::<_, _, Value>(method, (msg,)) {
-                eprintln!("failed to log to Ruby: {error:#}");
+                report(format_args!("failed to log to Ruby: {error:#}"));
             }
         })
         .await
     {
-        eprintln!("failed to log to Ruby: {error:#}");
+        report(format_args!("failed to log to Ruby: {error:#}"));
     }
 }
 
@@ -150,7 +148,9 @@ impl<S: Subscriber> Layer<S> for Logger {
             event.record(&mut visitor);
 
             if let Err(error) = self.tx.send((*metadata.level(), visitor.to_string())) {
-                eprintln!("failed to send log message: {error:#}; message: {visitor}");
+                report(format_args!(
+                    "failed to send log message: {error:#}; message: {visitor}"
+                ));
             }
         });
     }