prosody 0.5.1 → 0.6.0

data/ext/prosody/src/client/request.rs

@@ -22,7 +22,7 @@ struct NativeExciseRequest {
 }
 
 pub(super) fn request(ruby: &Ruby, this: &Client, request: Value) -> Result<Value, Error> {
-    Client::check_fork(ruby, this)?;
+    this.fork.check(ruby)?;
     let _guard = ensure_runtime_context(ruby);
     let request: NativeRequest = deserialize(ruby, request)?;
     let (subsystems, timeout) = request_parameters(ruby, request.subsystems, request.timeout)?;
@@ -57,7 +57,7 @@ pub(super) fn request(ruby: &Ruby, this: &Client, request: Value) -> Result<Valu
 }
 
 pub(super) fn request_excise(ruby: &Ruby, this: &Client, request: Value) -> Result<Value, Error> {
-    Client::check_fork(ruby, this)?;
+    this.fork.check(ruby)?;
     let _guard = ensure_runtime_context(ruby);
     let request: NativeExciseRequest = deserialize(ruby, request)?;
     let (subsystems, timeout) = request_parameters(ruby, request.subsystems, request.timeout)?;

data/ext/prosody/src/client/support.rs

@@ -1,7 +1,7 @@
 use super::{
-    Arc, Class, Client, Duration, ErasedReadCache, Error, FutureExt, Module, Object, RClass,
-    RModule, ROOT_MOD, ReprValue, ResponseError, Ruby, RubyHandler, SharedHighLevelClient,
-    Shutdown, Value, function, id, kwargs, method, request,
+    Arc, Class, Client, Error, FutureExt, Module, Object, RClass, RModule, ROOT_MOD, ReprValue,
+    ResponseError, Ruby, RubyHandler, SharedHighLevelClient, Shutdown, Value, function, id, kwargs,
+    method, readers, request,
 };
 
 pub(super) fn validate_handler(ruby: &Ruby, handler: Value) -> Result<(), Error> {
@@ -24,29 +24,6 @@ pub(super) fn shutdown(client: &SharedHighLevelClient<RubyHandler>) -> Shutdown
     .shared()
 }
 
-pub(super) fn read_cache(
-    ruby: &Ruby,
-    seconds: Option<f64>,
-    disabled: bool,
-) -> Result<ErasedReadCache, Error> {
-    match (seconds, disabled) {
-        (None, false) => Ok(ErasedReadCache::Inherit),
-        (None, true) => Ok(ErasedReadCache::Disabled),
-        (Some(seconds), false) => Duration::try_from_secs_f64(seconds)
-            .map(ErasedReadCache::Ttl)
-            .map_err(|_| {
-                Error::new(
-                    ruby.exception_arg_error(),
-                    "read_cache must be finite and non-negative",
-                )
-            }),
-        (Some(_), true) => Err(Error::new(
-            ruby.exception_arg_error(),
-            "read_cache cannot specify a TTL and be disabled",
-        )),
-    }
-}
-
 /// Initializes the client module in Ruby.
 ///
 /// Defines the `Prosody::Client` class and its methods, making the client
@@ -77,10 +54,10 @@ pub fn init(ruby: &Ruby) -> Result<(), Error> {
     )?;
     class.define_method(id!(ruby, "subscribe"), method!(Client::subscribe, 1))?;
     class.define_method(
-        id!(ruby, "assigned_partitions"),
-        method!(Client::assigned_partitions, 0),
+        id!(ruby, "assigned_partition_count"),
+        method!(Client::assigned_partition_count, 0),
     )?;
-    class.define_method(id!(ruby, "is_stalled?"), method!(Client::is_stalled, 0))?;
+    class.define_method(id!(ruby, "stalled?"), method!(Client::is_stalled, 0))?;
     class.define_method(id!(ruby, "unsubscribe"), method!(Client::unsubscribe, 0))?;
     class.define_method(id!(ruby, "shutdown"), method!(Client::shutdown, 0))?;
     class.define_method(
@@ -89,15 +66,19 @@ pub fn init(ruby: &Ruby) -> Result<(), Error> {
     )?;
     class.define_method(
         id!(ruby, "published_value"),
-        method!(Client::published_value, 4),
+        method!(readers::published_value, 3),
     )?;
     class.define_method(
         id!(ruby, "published_map"),
-        method!(Client::published_map, 4),
+        method!(readers::published_map, 3),
+    )?;
+    class.define_method(
+        id!(ruby, "published_set"),
+        method!(readers::published_set, 3),
     )?;
     class.define_method(
         id!(ruby, "published_deque"),
-        method!(Client::published_deque, 4),
+        method!(readers::published_deque, 3),
     )?;
 
     Ok(())

data/ext/prosody/src/gvl.rs

@@ -54,7 +54,6 @@ use tracing::error;
 ///
 /// Adapted from: <https://github.com/temporalio/sdk-ruby/blob/main/temporalio/ext/src/util.rs>,
 /// plus various examples in the Rust/Ruby ecosystem.
-#[allow(unsafe_code)]
 pub(crate) fn without_gvl<F, R, U>(func: F, unblock: U) -> Result<R, GvlError>
 where
     F: FnOnce() -> R,
@@ -76,20 +75,22 @@ where
         let result = catch_unwind(AssertUnwindSafe(|| (*func)())).map_err(|_| GvlError::Panicked);
 
         // SAFETY: We box the result, returning a raw pointer. The caller
-        // will Box::from_raw it exactly once after `rb_thread_call_without_gvl`.
+        // will Box::from_raw it exactly once after
+        // `rb_thread_call_without_gvl`.
         Box::into_raw(Box::new(result)).cast::<c_void>()
     }
 
     // SAFETY: Another FFI callback. Ruby may call this multiple times, so we do
     // NOT call `Box::from_raw` here. Instead, we just dereference the pointer
-    // each time. We also catch any panic and abort to avoid unwinding across FFI.
+    // each time. We also catch any panic and abort to avoid unwinding across
+    // FFI.
     unsafe extern "C" fn anon_unblock<U>(data: *mut c_void)
     where
         U: FnMut() + Send,
     {
         // We take a pointer to `U`; we do NOT consume the Box here.
-        // Note that `&mut *ptr` is not automatically UnwindSafe, so we wrap the call
-        // in `AssertUnwindSafe`.
+        // Note that `&mut *ptr` is not automatically UnwindSafe, so we wrap the
+        // call in `AssertUnwindSafe`.
         let closure_ptr = data.cast::<U>();
 
         if catch_unwind(AssertUnwindSafe(|| {
@@ -117,7 +118,8 @@ where
     // - Call `anon_func` once, passing `func_ptr`.
     // - Potentially call `anon_unblock` multiple times with `unblock_ptr`.
     // After `rb_thread_call_without_gvl` returns, we are guaranteed that Ruby
-    // won't call `anon_unblock` again, so we can safely free the unblock closure.
+    // won't call `anon_unblock` again, so we can safely free the unblock
+    // closure.
     let raw_result = unsafe {
         rb_thread_call_without_gvl(
             Some(anon_func::<F, R>),

data/ext/prosody/src/handler/{context.rs → context/mod.rs}

@@ -3,18 +3,16 @@
 //! This module provides a Ruby-compatible wrapper around the Prosody library's
 //! `MessageContext`, allowing Ruby code to interact with message context
 //! information from Kafka messages and schedule timer events.
+//! The `vending` submodule owns the keyed-state vend methods.
 
 use crate::bridge::Bridge;
-use crate::handler::state::{
-    NativeJsonDequeState, NativeJsonMapState, NativeJsonValueState, NativeMessageDequeState,
-    NativeMessageMapState, NativeMessageValueState, state_error,
-};
 use crate::tracing_util::extract_opentelemetry_context;
 use crate::{ROOT_MOD, id};
 use educe::Educe;
 use magnus::value::ReprValue;
 use magnus::{Error, Module, RClass, Ruby, Value, method};
 use opentelemetry::propagation::TextMapCompositePropagator;
+use prosody::consumer::DemandType;
 use prosody::consumer::event_context::BoxEventContext;
 use prosody::timers::TimerType;
 use prosody::timers::datetime::CompactDateTime;
@@ -22,6 +20,8 @@ use std::sync::Arc;
 use tracing::{Span, debug, info_span};
 use tracing_opentelemetry::OpenTelemetrySpanExt;
 
+mod vending;
+
 /// Nanosecond threshold for rounding Ruby Time objects to the nearest second.
 /// At 0.5 seconds, times round up; below 0.5 seconds, they round down.
 const NANOSECOND_ROUNDING_THRESHOLD: u32 = 500_000_000;
@@ -49,6 +49,9 @@ pub struct Context {
     /// OpenTelemetry propagator for distributed tracing
     #[educe(Debug(ignore))]
     propagator: Arc<TextMapCompositePropagator>,
+
+    /// Whether this dispatch is a normal delivery or a retry after a failure.
+    demand: DemandType,
 }
 
 impl Context {
@@ -59,18 +62,41 @@ impl Context {
     /// * `inner` - The Prosody event context to wrap
     /// * `bridge` - The bridge for handling async operations
     /// * `propagator` - Shared OpenTelemetry propagator for distributed tracing
+    /// * `demand` - The demand this dispatch serves
     pub fn new(
         inner: BoxEventContext<serde_json::Value>,
         bridge: Bridge,
         propagator: Arc<TextMapCompositePropagator>,
+        demand: DemandType,
     ) -> Self {
         Self {
             inner,
             bridge,
             propagator,
+            demand,
         }
     }
 
+    /// Returns the dispatch demand as a `Prosody::Demand`.
+    ///
+    /// A normal delivery has kind `:normal` and 0 retries. A retry after a
+    /// failure has kind `:failure` and a retry count that starts at 1. The
+    /// count is an estimate.
+    ///
+    /// # Errors
+    ///
+    /// Returns a Ruby error if `Prosody::Demand` cannot be built.
+    fn demand(ruby: &Ruby, this: &Self) -> Result<Value, Error> {
+        let (kind, retries) = match this.demand {
+            DemandType::Normal => ("normal", 0),
+            DemandType::Failure { retry: retries } => ("failure", retries),
+        };
+        let class: RClass = ruby.get_inner(&ROOT_MOD).const_get(id!(ruby, "Demand"))?;
+        // `Data.new` maps positional members to keywords; `new_instance` would
+        // bypass it and call `initialize` with positional arguments.
+        class.funcall(id!(ruby, "new"), (ruby.sym_new(kind), retries))
+    }
+
     /// Check if cancellation has been requested.
     ///
     /// Cancellation includes both message-level cancellation (e.g., timeout)
@@ -312,8 +338,8 @@ impl Context {
                 )
             })?;
 
-        // Convert CompactDateTime objects to Ruby Time objects using idiomatic iterator
-        // pattern
+        // Convert CompactDateTime objects to Ruby Time objects using idiomatic
+        // iterator pattern
         let ruby_array = ruby.ary_try_from_iter(
             scheduled_times
                 .into_iter()
@@ -322,131 +348,6 @@ impl Context {
 
         Ok(ruby_array.as_value())
     }
-
-    /// Vends the handle for the named JSON value collection.
-    ///
-    /// Vending verifies the collection's registration (core-side); no span is
-    /// opened here — vended handles outlive the call, and every operation opens
-    /// its own span.
-    ///
-    /// # Errors
-    ///
-    /// Returns a permanent state error if the name is unregistered or its
-    /// registered identity mismatches.
-    #[allow(clippy::needless_pass_by_value, reason = "Magnus method argument type")]
-    fn value_state(ruby: &Ruby, this: &Self, name: String) -> Result<NativeJsonValueState, Error> {
-        let handle = this
-            .inner
-            .value_state(&name)
-            .map_err(|error| state_error(ruby, &error))?;
-        Ok(NativeJsonValueState::new(
-            Arc::from(handle),
-            this.bridge.clone(),
-            Arc::clone(&this.propagator),
-        ))
-    }
-
-    /// Vends the handle for the named JSON map collection.
-    ///
-    /// # Errors
-    ///
-    /// See [`value_state`](Self::value_state).
-    #[allow(clippy::needless_pass_by_value, reason = "Magnus method argument type")]
-    fn map_state(ruby: &Ruby, this: &Self, name: String) -> Result<NativeJsonMapState, Error> {
-        let handle = this
-            .inner
-            .map_state(&name)
-            .map_err(|error| state_error(ruby, &error))?;
-        Ok(NativeJsonMapState::new(
-            Arc::from(handle),
-            this.bridge.clone(),
-            Arc::clone(&this.propagator),
-        ))
-    }
-
-    /// Vends the handle for the named JSON deque collection.
-    ///
-    /// # Errors
-    ///
-    /// See [`value_state`](Self::value_state).
-    #[allow(clippy::needless_pass_by_value, reason = "Magnus method argument type")]
-    fn deque_state(ruby: &Ruby, this: &Self, name: String) -> Result<NativeJsonDequeState, Error> {
-        let handle = this
-            .inner
-            .deque_state(&name)
-            .map_err(|error| state_error(ruby, &error))?;
-        Ok(NativeJsonDequeState::new(
-            Arc::from(handle),
-            this.bridge.clone(),
-            Arc::clone(&this.propagator),
-        ))
-    }
-
-    /// Vends the handle for the named Kafka-message value collection.
-    ///
-    /// # Errors
-    ///
-    /// See [`value_state`](Self::value_state).
-    #[allow(clippy::needless_pass_by_value, reason = "Magnus method argument type")]
-    fn message_value_state(
-        ruby: &Ruby,
-        this: &Self,
-        name: String,
-    ) -> Result<NativeMessageValueState, Error> {
-        let handle = this
-            .inner
-            .message_value_state(&name)
-            .map_err(|error| state_error(ruby, &error))?;
-        Ok(NativeMessageValueState::new(
-            Arc::from(handle),
-            this.bridge.clone(),
-            Arc::clone(&this.propagator),
-        ))
-    }
-
-    /// Vends the handle for the named Kafka-message map collection.
-    ///
-    /// # Errors
-    ///
-    /// See [`value_state`](Self::value_state).
-    #[allow(clippy::needless_pass_by_value, reason = "Magnus method argument type")]
-    fn message_map_state(
-        ruby: &Ruby,
-        this: &Self,
-        name: String,
-    ) -> Result<NativeMessageMapState, Error> {
-        let handle = this
-            .inner
-            .message_map_state(&name)
-            .map_err(|error| state_error(ruby, &error))?;
-        Ok(NativeMessageMapState::new(
-            Arc::from(handle),
-            this.bridge.clone(),
-            Arc::clone(&this.propagator),
-        ))
-    }
-
-    /// Vends the handle for the named Kafka-message deque collection.
-    ///
-    /// # Errors
-    ///
-    /// See [`value_state`](Self::value_state).
-    #[allow(clippy::needless_pass_by_value, reason = "Magnus method argument type")]
-    fn message_deque_state(
-        ruby: &Ruby,
-        this: &Self,
-        name: String,
-    ) -> Result<NativeMessageDequeState, Error> {
-        let handle = this
-            .inner
-            .message_deque_state(&name)
-            .map_err(|error| state_error(ruby, &error))?;
-        Ok(NativeMessageDequeState::new(
-            Arc::from(handle),
-            this.bridge.clone(),
-            Arc::clone(&this.propagator),
-        ))
-    }
 }
 
 /// Initializes the Context class in Ruby.
@@ -471,6 +372,7 @@ pub fn init(ruby: &Ruby) -> Result<(), Error> {
         method!(Context::should_cancel, 0),
     )?;
     class.define_method(id!(ruby, "on_cancel"), method!(Context::on_cancel, 0))?;
+    class.define_method(id!(ruby, "demand"), method!(Context::demand, 0))?;
 
     // Timer scheduling methods
     class.define_method(id!(ruby, "schedule"), method!(Context::schedule, 1))?;
@@ -485,24 +387,7 @@ pub fn init(ruby: &Ruby) -> Result<(), Error> {
     )?;
     class.define_method(id!(ruby, "scheduled"), method!(Context::scheduled, 0))?;
 
-    // Keyed-state vend methods
-    class.define_method(id!(ruby, "value_state"), method!(Context::value_state, 1))?;
-    class.define_method(id!(ruby, "map_state"), method!(Context::map_state, 1))?;
-    class.define_method(id!(ruby, "deque_state"), method!(Context::deque_state, 1))?;
-    class.define_method(
-        id!(ruby, "message_value_state"),
-        method!(Context::message_value_state, 1),
-    )?;
-    class.define_method(
-        id!(ruby, "message_map_state"),
-        method!(Context::message_map_state, 1),
-    )?;
-    class.define_method(
-        id!(ruby, "message_deque_state"),
-        method!(Context::message_deque_state, 1),
-    )?;
-
-    Ok(())
+    vending::define_methods(ruby, class)
 }
 
 /// Converts a Ruby Time object to `CompactDateTime`.
@@ -571,7 +456,8 @@ fn time_to_compact_datetime(ruby: &Ruby, ruby_time: Value) -> Result<CompactDate
 /// Returns an error if the Ruby Time class cannot be accessed or if
 /// creating the Time object fails.
 fn compact_datetime_to_time(ruby: &Ruby, compact_time: CompactDateTime) -> Result<Value, Error> {
-    // Direct access to epoch seconds - CompactDateTime has no sub-second precision
+    // Direct access to epoch seconds - CompactDateTime has no sub-second
+    // precision
     let epoch_seconds = i64::from(compact_time.epoch_seconds());
 
     // Create Ruby Time with zero nanoseconds (CompactDateTime precision limit)

data/ext/prosody/src/handler/context/vending.rs

@@ -0,0 +1,138 @@
+//! Keyed-state vending for `Prosody::Context`.
+//!
+//! Each vend method opens the handle for one registered collection in the
+//! current event and wraps it in its native handle class. Vending verifies the
+//! collection's registration in core. It opens no span: vended handles outlive
+//! the call, and every handle operation opens its own span.
+
+use super::Context;
+use crate::bridge::Bridge;
+use crate::handler::state::{
+    NativeJsonDequeState, NativeJsonMapState, NativeJsonValueState, NativeMessageDequeState,
+    NativeMessageMapState, NativeMessageValueState, NativeSetState, state_error,
+};
+use crate::id;
+use magnus::{Error, Module, RClass, RString, Ruby, method};
+use opentelemetry::propagation::TextMapCompositePropagator;
+use prosody::consumer::event_context::ErasedStateError;
+use std::sync::Arc;
+
+/// Wraps a core handle in its native handle class.
+///
+/// # Errors
+///
+/// Returns a permanent state error if the name is unregistered or its
+/// registered identity mismatches.
+fn vend<T: ?Sized, N>(
+    ruby: &Ruby,
+    this: &Context,
+    handle: Result<Box<T>, ErasedStateError>,
+    new: fn(Arc<T>, Bridge, Arc<TextMapCompositePropagator>) -> N,
+) -> Result<N, Error> {
+    let handle = handle.map_err(|error| state_error(ruby, &error))?;
+    Ok(new(
+        Arc::from(handle),
+        this.bridge.clone(),
+        Arc::clone(&this.propagator),
+    ))
+}
+
+fn value_state(ruby: &Ruby, this: &Context, name: RString) -> Result<NativeJsonValueState, Error> {
+    vend(
+        ruby,
+        this,
+        this.inner.value_state(&name.to_string()?),
+        NativeJsonValueState::new,
+    )
+}
+
+fn map_state(ruby: &Ruby, this: &Context, name: RString) -> Result<NativeJsonMapState, Error> {
+    vend(
+        ruby,
+        this,
+        this.inner.map_state(&name.to_string()?),
+        NativeJsonMapState::new,
+    )
+}
+
+fn set_state(ruby: &Ruby, this: &Context, name: RString) -> Result<NativeSetState, Error> {
+    vend(
+        ruby,
+        this,
+        this.inner.set_state(&name.to_string()?),
+        NativeSetState::new,
+    )
+}
+
+fn deque_state(ruby: &Ruby, this: &Context, name: RString) -> Result<NativeJsonDequeState, Error> {
+    vend(
+        ruby,
+        this,
+        this.inner.deque_state(&name.to_string()?),
+        NativeJsonDequeState::new,
+    )
+}
+
+fn message_value_state(
+    ruby: &Ruby,
+    this: &Context,
+    name: RString,
+) -> Result<NativeMessageValueState, Error> {
+    vend(
+        ruby,
+        this,
+        this.inner.message_value_state(&name.to_string()?),
+        NativeMessageValueState::new,
+    )
+}
+
+fn message_map_state(
+    ruby: &Ruby,
+    this: &Context,
+    name: RString,
+) -> Result<NativeMessageMapState, Error> {
+    vend(
+        ruby,
+        this,
+        this.inner.message_map_state(&name.to_string()?),
+        NativeMessageMapState::new,
+    )
+}
+
+fn message_deque_state(
+    ruby: &Ruby,
+    this: &Context,
+    name: RString,
+) -> Result<NativeMessageDequeState, Error> {
+    vend(
+        ruby,
+        this,
+        this.inner.message_deque_state(&name.to_string()?),
+        NativeMessageDequeState::new,
+    )
+}
+
+/// Registers the keyed-state vend methods on the `Prosody::Context` class.
+///
+/// # Errors
+///
+/// Returns a Magnus error if a method definition fails.
+pub(super) fn define_methods(ruby: &Ruby, class: RClass) -> Result<(), Error> {
+    class.define_method(id!(ruby, "value_state"), method!(value_state, 1))?;
+    class.define_method(id!(ruby, "map_state"), method!(map_state, 1))?;
+    class.define_method(id!(ruby, "set_state"), method!(set_state, 1))?;
+    class.define_method(id!(ruby, "deque_state"), method!(deque_state, 1))?;
+    class.define_method(
+        id!(ruby, "message_value_state"),
+        method!(message_value_state, 1),
+    )?;
+    class.define_method(
+        id!(ruby, "message_map_state"),
+        method!(message_map_state, 1),
+    )?;
+    class.define_method(
+        id!(ruby, "message_deque_state"),
+        method!(message_deque_state, 1),
+    )?;
+    Ok(())
+}

data/ext/prosody/src/handler/message.rs

@@ -7,6 +7,7 @@ use crate::{ROOT_MOD, id};
 use educe::Educe;
 use magnus::value::ReprValue;
 use magnus::{Error, Module, RClass, Ruby, Value, method};
+use prosody::SourceSystem;
 use prosody::consumer::Keyed;
 use prosody::consumer::message::ConsumerMessage;
 use serde_magnus::serialize;
@@ -118,6 +119,17 @@ impl Message {
         serialize(ruby, this.inner.payload())
     }
 
+    /// Returns the producer's source system, or `None` when the record has
+    /// no source system header.
+    fn source_system(&self) -> Option<&str> {
+        self.inner.source_system().map(SourceSystem::as_str)
+    }
+
+    /// Reports whether the producer requested a response to this record.
+    fn response_requested(&self) -> bool {
+        self.inner.response_requested()
+    }
+
     /// Clones the wrapped `ConsumerMessage` for a message-collection write.
     ///
     /// The wrapper holds the real `ConsumerMessage`, so a message write clones
@@ -157,6 +169,14 @@ impl ExciseMessage {
                 (epoch_micros, ruby.to_symbol("microsecond")),
             )
     }
+
+    fn source_system(&self) -> Option<&str> {
+        self.inner.source_system().map(SourceSystem::as_str)
+    }
+
+    fn response_requested(&self) -> bool {
+        self.inner.response_requested()
+    }
 }
 
 impl From<ConsumerMessage<serde_json::Value>> for Message {
@@ -199,6 +219,14 @@ pub fn init(ruby: &Ruby) -> Result<(), Error> {
     class.define_method(id!(ruby, "key"), method!(Message::key, 0))?;
     class.define_method(id!(ruby, "timestamp"), method!(Message::timestamp, 0))?;
     class.define_method(id!(ruby, "payload"), method!(Message::payload, 0))?;
+    class.define_method(
+        id!(ruby, "source_system"),
+        method!(Message::source_system, 0),
+    )?;
+    class.define_method(
+        id!(ruby, "response_requested?"),
+        method!(Message::response_requested, 0),
+    )?;
 
     let class = module.define_class(id!(ruby, "ExciseMessage"), ruby.class_object())?;
     class.define_method(id!(ruby, "topic"), method!(ExciseMessage::topic, 0))?;
@@ -206,6 +234,14 @@ pub fn init(ruby: &Ruby) -> Result<(), Error> {
     class.define_method(id!(ruby, "offset"), method!(ExciseMessage::offset, 0))?;
     class.define_method(id!(ruby, "key"), method!(ExciseMessage::key, 0))?;
     class.define_method(id!(ruby, "timestamp"), method!(ExciseMessage::timestamp, 0))?;
+    class.define_method(
+        id!(ruby, "source_system"),
+        method!(ExciseMessage::source_system, 0),
+    )?;
+    class.define_method(
+        id!(ruby, "response_requested?"),
+        method!(ExciseMessage::response_requested, 0),
+    )?;
 
     Ok(())
 }