prosody 0.5.1 → 0.6.0

data/ext/prosody/src/client/config/state.rs

@@ -0,0 +1,323 @@
+//! Conversion of the keyed-state options into a [`KeyedStateConfiguration`].
+//!
+//! This module parses each declared state collection and registers its
+//! descriptor. It also maps the cache, read cache, and subsystem options.
+
+use super::NativeConfiguration;
+use crate::util::seconds;
+use prosody::consumer::KeyedStateConfiguration;
+use prosody::consumer::kafka_state::{message_deque_state, message_map_state, message_state};
+use prosody::loader::KafkaLoader;
+use prosody::state::ReadCachePolicy;
+use prosody::state::descriptor::{StateDescriptor, deque_state, map_state, set_state, value_state};
+use prosody::state::order_codec::Utf8KeyCodec;
+use prosody::subsystem::SubsystemName;
+use prosody::timers::duration::CompactDuration;
+use prosody::{ByteSize, JsonCodec};
+use serde::Deserialize;
+use std::num::NonZeroUsize;
+use std::path::PathBuf;
+
+/// Declares one keyed-state collection to register before subscribe.
+#[derive(Clone, Debug, Deserialize)]
+pub(super) struct StateCollectionConfig {
+    /// The collection name. Prosody requires it to be non-empty and unique.
+    name: String,
+
+    /// The collection kind: `"value"`, `"map"`, `"set"`, or `"deque"`.
+    kind: String,
+
+    /// The item payload: `"json"` or `"message"`. A set stores membership
+    /// only, so it has no payload.
+    payload: Option<String>,
+
+    /// Optional per-write TTL in whole seconds.
+    ttl_seconds: Option<u32>,
+
+    /// Optional opt-out of transactional staging.
+    read_uncommitted: Option<bool>,
+
+    /// Whether other consumer groups may read this JSON or set collection.
+    published: Option<bool>,
+
+    /// Optional map or set keyset bound (`0..=4096`). Prosody enforces the
+    /// ceiling.
+    keyset_limit: Option<usize>,
+
+    /// Optional deque-only window capacity. Runtime-only and not persisted.
+    capacity: Option<NonZeroUsize>,
+}
+
+/// A read cache option: `false` disables the cache, and a number sets the
+/// TTL in seconds.
+#[derive(Clone, Copy, Debug, Deserialize)]
+#[serde(untagged)]
+pub(crate) enum ReadCacheConfig {
+    Disabled(bool),
+    Ttl(f64),
+}
+
+/// The kind of a keyed-state collection.
+enum CollectionKind {
+    /// A single-value collection.
+    Value,
+    /// A `String`-keyed ordered map.
+    Map,
+    /// A presence-only ordered set of `String` members.
+    Set,
+    /// A deque.
+    Deque,
+}
+
+/// The item payload of a value, map, or deque collection.
+enum CollectionPayload {
+    /// JSON values.
+    Json,
+    /// The full Kafka message the handler received.
+    Message,
+}
+
+/// Parses a collection-kind token.
+///
+/// # Errors
+///
+/// Returns a permanent-category error naming the field if the token is not
+/// `"value"`, `"map"`, `"set"`, or `"deque"`.
+fn parse_kind(index: usize, kind: &str) -> Result<CollectionKind, String> {
+    match kind {
+        "value" => Ok(CollectionKind::Value),
+        "map" => Ok(CollectionKind::Map),
+        "set" => Ok(CollectionKind::Set),
+        "deque" => Ok(CollectionKind::Deque),
+        other => Err(format!(
+            "state_collections[{index}].kind: expected \"value\", \"map\", \"set\", or \"deque\", \
+             got {other:?}"
+        )),
+    }
+}
+
+/// Parses a collection-payload token.
+///
+/// # Errors
+///
+/// Returns a permanent-category error naming the field if the token is not
+/// `"json"` or `"message"`.
+fn parse_payload(index: usize, payload: &str) -> Result<CollectionPayload, String> {
+    match payload {
+        "json" => Ok(CollectionPayload::Json),
+        "message" => Ok(CollectionPayload::Message),
+        other => Err(format!(
+            "state_collections[{index}].payload: expected \"json\" or \"message\", got {other:?}"
+        )),
+    }
+}
+
+/// Applies the options that every collection kind takes: TTL, commit mode,
+/// and publication.
+fn with_def<D: StateDescriptor>(descriptor: D, collection: &StateCollectionConfig) -> D {
+    let mut descriptor = descriptor;
+    if let Some(ttl) = collection.ttl_seconds {
+        descriptor = descriptor.ttl(CompactDuration::new(ttl));
+    }
+    if collection.read_uncommitted == Some(true) {
+        descriptor = descriptor.read_uncommitted();
+    }
+    if let Some(published) = collection.published {
+        descriptor = descriptor.published(published);
+    }
+    descriptor
+}
+
+/// Maps one collection into its descriptor. Values, maps, and deques hold
+/// JSON or messages. Sets have no payload.
+///
+/// # Errors
+///
+/// Returns a permanent-category error when a host value cannot be mapped into
+/// a Prosody type.
+fn register_state_collection(
+    keyed: &mut KeyedStateConfiguration,
+    index: usize,
+    collection: &StateCollectionConfig,
+) -> Result<(), String> {
+    let kind = parse_kind(index, &collection.kind)?;
+    let payload = collection
+        .payload
+        .as_deref()
+        .map(|payload| parse_payload(index, payload))
+        .transpose()?;
+    let keyset_limit = keyset_limit(collection.keyset_limit, &kind, index)?;
+    let capacity = capacity(collection.capacity, &kind, index)?;
+
+    let name = collection.name.as_str();
+    match (kind, payload) {
+        (CollectionKind::Value, Some(CollectionPayload::Json)) => {
+            let _ = keyed.register(with_def(value_state::<JsonCodec>(name), collection));
+        }
+        (CollectionKind::Map, Some(CollectionPayload::Json)) => {
+            let mut descriptor = with_def(map_state::<Utf8KeyCodec, JsonCodec>(name), collection);
+            if let Some(limit) = keyset_limit {
+                descriptor = descriptor.keyset_limit(limit);
+            }
+            let _ = keyed.register(descriptor);
+        }
+        (CollectionKind::Deque, Some(CollectionPayload::Json)) => {
+            let mut descriptor = with_def(deque_state::<JsonCodec>(name), collection);
+            if let Some(capacity) = capacity {
+                descriptor = descriptor.capacity(capacity);
+            }
+            let _ = keyed.register(descriptor);
+        }
+        (CollectionKind::Value, Some(CollectionPayload::Message)) => {
+            let descriptor = message_state::<KafkaLoader<JsonCodec>>(name);
+            let _ = keyed.register(with_def(descriptor, collection));
+        }
+        (CollectionKind::Map, Some(CollectionPayload::Message)) => {
+            let descriptor = message_map_state::<Utf8KeyCodec, KafkaLoader<JsonCodec>>(name);
+            let mut descriptor = with_def(descriptor, collection);
+            if let Some(limit) = keyset_limit {
+                descriptor = descriptor.keyset_limit(limit);
+            }
+            let _ = keyed.register(descriptor);
+        }
+        (CollectionKind::Deque, Some(CollectionPayload::Message)) => {
+            let descriptor = message_deque_state::<KafkaLoader<JsonCodec>>(name);
+            let mut descriptor = with_def(descriptor, collection);
+            if let Some(capacity) = capacity {
+                descriptor = descriptor.capacity(capacity);
+            }
+            let _ = keyed.register(descriptor);
+        }
+        (CollectionKind::Set, None) => {
+            let mut descriptor = with_def(set_state::<Utf8KeyCodec>(name), collection);
+            if let Some(limit) = keyset_limit {
+                descriptor = descriptor.keyset_limit(limit);
+            }
+            let _ = keyed.register(descriptor);
+        }
+        (CollectionKind::Set, Some(_)) => {
+            return Err(format!(
+                "state_collections[{index}].payload: omit it for a set collection"
+            ));
+        }
+        (CollectionKind::Value | CollectionKind::Map | CollectionKind::Deque, None) => {
+            return Err(format!(
+                "state_collections[{index}].payload: required for value, map, and deque \
+                 collections"
+            ));
+        }
+    }
+
+    Ok(())
+}
+
+/// Rejects a keyset limit on a collection that is not a map or a set.
+fn keyset_limit(
+    value: Option<usize>,
+    kind: &CollectionKind,
+    index: usize,
+) -> Result<Option<usize>, String> {
+    if value.is_some() && !matches!(kind, CollectionKind::Map | CollectionKind::Set) {
+        return Err(format!(
+            "state_collections[{index}].keyset_limit: only valid for map and set collections"
+        ));
+    }
+    Ok(value)
+}
+
+/// Rejects a capacity on a collection that is not a deque.
+fn capacity(
+    value: Option<NonZeroUsize>,
+    kind: &CollectionKind,
+    index: usize,
+) -> Result<Option<NonZeroUsize>, String> {
+    if value.is_some() && !matches!(kind, CollectionKind::Deque) {
+        return Err(format!(
+            "state_collections[{index}].capacity: only valid for deque collections"
+        ));
+    }
+    Ok(value)
+}
+
+/// Converts a read cache option into a core policy. An absent option inherits
+/// the default.
+///
+/// # Errors
+///
+/// Returns an error that names `option` for `true` or an invalid duration.
+pub(crate) fn read_cache_policy(
+    option: &str,
+    config: Option<ReadCacheConfig>,
+) -> Result<ReadCachePolicy, String> {
+    match config {
+        None => Ok(ReadCachePolicy::Inherit),
+        Some(ReadCacheConfig::Disabled(false)) => Ok(ReadCachePolicy::Disabled),
+        Some(ReadCacheConfig::Disabled(true)) => Err(format!(
+            "{option}: true is ambiguous; use a duration or false"
+        )),
+        Some(ReadCacheConfig::Ttl(value)) => seconds(option, value).map(ReadCachePolicy::Ttl),
+    }
+}
+
+/// Builds the `KeyedStateConfiguration` by mapping each declared collection.
+/// The normal Prosody construction path validates the result.
+///
+/// # Errors
+///
+/// Returns an error if a host value cannot be mapped.
+pub(super) fn build_keyed_state_config(
+    config: &NativeConfiguration,
+) -> Result<KeyedStateConfiguration, String> {
+    let mut builder = KeyedStateConfiguration::builder();
+
+    if let Some(dir) = &config.state_cache_dir {
+        builder.cache_dir(PathBuf::from(dir));
+    }
+
+    if let Some(size) = &config.state_owned_cache_size {
+        let size = size
+            .parse::<ByteSize>()
+            .map_err(|error| format!("state_owned_cache_size: {error}"))?;
+        builder.owned_cache_size(Some(size));
+    }
+
+    if let Some(size) = &config.state_memtable_size {
+        let size = size
+            .parse::<ByteSize>()
+            .map_err(|error| format!("state_memtable_size: {error}"))?;
+        builder.memtable_size(Some(size));
+    }
+
+    if let Some(size) = &config.state_read_cache_size {
+        let size = size
+            .parse::<ByteSize>()
+            .map_err(|error| format!("state_read_cache_size: {error}"))?;
+        builder.read_cache_size(Some(size));
+    }
+
+    match read_cache_policy("state_read_cache", config.state_read_cache)? {
+        ReadCachePolicy::Inherit => {}
+        ReadCachePolicy::Disabled => {
+            builder.read_cache_ttl(None);
+        }
+        ReadCachePolicy::Ttl(ttl) => {
+            builder.read_cache_ttl(Some(ttl));
+        }
+    }
+
+    if let Some(subsystem) = &config.subsystem {
+        builder.subsystem(Some(
+            SubsystemName::try_new(subsystem).map_err(|error| error.to_string())?,
+        ));
+    }
+
+    let mut keyed = builder.build().map_err(|error| error.to_string())?;
+
+    if let Some(collections) = &config.state_collections {
+        for (index, collection) in collections.iter().enumerate() {
+            register_state_collection(&mut keyed, index, collection)?;
+        }
+    }
+
+    Ok(keyed)
+}

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

@@ -13,9 +13,8 @@
 use crate::bridge::Bridge;
 use crate::client::config::NativeConfiguration;
 use crate::handler::RubyHandler;
-use crate::published::{NativePublishedDeque, NativePublishedMap, NativePublishedValue};
 use crate::tracing_util::extract_opentelemetry_context;
-use crate::util::ensure_runtime_context;
+use crate::util::{ForkGuard, ensure_runtime_context};
 use crate::{BRIDGE, ROOT_MOD, id};
 use educe::Educe;
 use futures::FutureExt;
@@ -28,10 +27,9 @@ use magnus::{
 use opentelemetry::propagation::TextMapCompositePropagator;
 use prosody::cassandra::config::CassandraConfigurationBuilder;
 use prosody::high_level::ConsumerBuilders;
-use prosody::high_level::erased::{
-    ErasedConsumerState, ErasedReadCache, SharedHighLevelClient, new_erased,
-};
+use prosody::high_level::erased::{ErasedConsumerState, SharedHighLevelClient, new_erased};
 use prosody::high_level::mode::Mode;
+use prosody::producer::ProducerConfigurationBuilder;
 use prosody::propagator::new_propagator;
 use prosody::requester::ResponseError;
 use prosody::subsystem::SubsystemName;
@@ -45,11 +43,12 @@ use tracing_opentelemetry::OpenTelemetrySpanExt;
 
 /// Configuration types and conversion between Ruby and Rust representations
 mod config;
+mod readers;
 mod request;
 mod support;
 
 pub use support::init;
-use support::{read_cache, response_error, shutdown, validate_handler};
+use support::{response_error, shutdown, validate_handler};
 
 type Shutdown = Shared<BoxFuture<'static, Result<(), Arc<str>>>>;
 
@@ -72,8 +71,8 @@ pub struct Client {
     bridge: Bridge,
     /// OpenTelemetry propagator for distributed tracing
     propagator: Arc<TextMapCompositePropagator>,
-    /// PID at construction time, used to detect post-fork usage
-    pid: u32,
+    /// Refuses use in a forked child process
+    fork: ForkGuard,
 }
 
 impl Client {
@@ -108,16 +107,12 @@ impl Client {
         };
 
         let config_hash: Value = config_obj.funcall(id!(ruby, "to_hash"), ())?;
-        let native_config = NativeConfiguration::from_value(ruby, config_hash)?;
+        let native_config: NativeConfiguration = deserialize(ruby, config_hash)?;
         let config_ref = &native_config;
+        let arg_error = |error: String| Error::new(ruby.exception_arg_error(), error);
 
-        let mode: Mode = config_ref
-            .try_into()
-            .map_err(|error: String| Error::new(ruby.exception_arg_error(), error))?;
-
-        let consumer_builders: ConsumerBuilders = config_ref
-            .try_into()
-            .map_err(|error: String| Error::new(ruby.exception_arg_error(), error))?;
+        let mode: Mode = config_ref.try_into().map_err(arg_error)?;
+        let consumer_builders: ConsumerBuilders = config_ref.try_into().map_err(arg_error)?;
 
         let bridge = BRIDGE
             .get()
@@ -126,13 +121,20 @@ impl Client {
                 "Bridge not initialized",
             ))?
             .clone();
-        let cassandra = Into::<CassandraConfigurationBuilder>::into(config_ref);
-        let mut producer = config_ref.into();
+        let cassandra: CassandraConfigurationBuilder = config_ref.try_into().map_err(arg_error)?;
+        let mut producer: ProducerConfigurationBuilder =
+            config_ref.try_into().map_err(arg_error)?;
         let client = bridge
             .wait_for(
                 ruby,
                 async move {
-                    new_erased(mode, &mut producer, &consumer_builders, &cassandra).await
+                    Box::pin(new_erased(
+                        mode,
+                        &mut producer,
+                        &consumer_builders,
+                        &cassandra,
+                    ))
+                    .await
                 },
                 Span::current(),
             )?
@@ -143,21 +145,10 @@ impl Client {
             inner: client,
             bridge,
             propagator: Arc::new(new_propagator()),
-            pid: std::process::id(),
+            fork: ForkGuard::new("Prosody::Client"),
         })
     }
 
-    fn check_fork(ruby: &Ruby, this: &Self) -> Result<(), Error> {
-        if std::process::id() != this.pid {
-            return Err(Error::new(
-                ruby.exception_runtime_error(),
-                "Prosody::Client cannot be used after fork. Create a new client in the child \
-                 process.",
-            ));
-        }
-        Ok(())
-    }
-
     /// Returns the current state of the consumer.
     ///
     /// The consumer can be in one of four states:
@@ -181,7 +172,7 @@ impl Client {
     /// build, with the full error message from the underlying
     /// `ModeConfigurationError`.
     pub fn consumer_state(ruby: &Ruby, this: &Self) -> Result<StaticSymbol, Error> {
-        Self::check_fork(ruby, this)?;
+        this.fork.check(ruby)?;
         let inner = this.inner.clone();
         let state: Result<&'static str, String> = this.bridge.wait_for(
             ruby,
@@ -227,7 +218,7 @@ impl Client {
         key: String,
         payload: Value,
     ) -> Result<(), Error> {
-        Self::check_fork(ruby, this)?;
+        this.fork.check(ruby)?;
         let _guard = ensure_runtime_context(ruby);
         let client = this.inner.clone();
         let value = deserialize(ruby, payload)?;
@@ -251,7 +242,7 @@ impl Client {
 
     /// Sends an excise record for a key.
     fn excise(ruby: &Ruby, this: &Self, topic: String, key: String) -> Result<(), Error> {
-        Self::check_fork(ruby, this)?;
+        this.fork.check(ruby)?;
         let _guard = ensure_runtime_context(ruby);
         let client = this.inner.clone();
         let context = extract_opentelemetry_context(ruby, &this.propagator)?;
@@ -274,7 +265,7 @@ impl Client {
     ///
     /// Returns an error if the handler is incomplete or subscription fails.
     fn subscribe(ruby: &Ruby, this: &Self, handler: Value) -> Result<(), Error> {
-        Self::check_fork(ruby, this)?;
+        this.fork.check(ruby)?;
         validate_handler(ruby, handler)?;
         let _guard = ensure_runtime_context(ruby);
         let wrapper = RubyHandler::new(this.bridge.clone(), ruby, handler)?;
@@ -304,8 +295,8 @@ impl Client {
     /// # Returns
     ///
     /// The number of assigned partitions as a u32.
-    pub fn assigned_partitions(ruby: &Ruby, this: &Self) -> Result<u32, Error> {
-        Self::check_fork(ruby, this)?;
+    pub fn assigned_partition_count(ruby: &Ruby, this: &Self) -> Result<u32, Error> {
+        this.fork.check(ruby)?;
         let inner = this.inner.clone();
         this.bridge.wait_for(
             ruby,
@@ -328,7 +319,7 @@ impl Client {
     ///
     /// `true` if the consumer is stalled, `false` otherwise.
     pub fn is_stalled(ruby: &Ruby, this: &Self) -> Result<bool, Error> {
-        Self::check_fork(ruby, this)?;
+        this.fork.check(ruby)?;
         let inner = this.inner.clone();
         this.bridge.wait_for(
             ruby,
@@ -351,7 +342,7 @@ impl Client {
     ///
     /// Returns an error if the unsubscribe operation fails.
     fn unsubscribe(ruby: &Ruby, this: &Self) -> Result<(), Error> {
-        Self::check_fork(ruby, this)?;
+        this.fork.check(ruby)?;
         let _guard = ensure_runtime_context(ruby);
         let client = this.inner.clone();
 
@@ -371,7 +362,7 @@ impl Client {
     ///
     /// Returns an error if shutdown fails.
     fn shutdown(ruby: &Ruby, this: &Self) -> Result<(), Error> {
-        Self::check_fork(ruby, this)?;
+        this.fork.check(ruby)?;
         let _guard = ensure_runtime_context(ruby);
         let shutdown = this.shutdown.clone();
 
@@ -395,81 +386,4 @@ impl Client {
     fn source_system(this: &Self) -> &str {
         this.inner.source_system()
     }
-
-    fn published_value(
-        ruby: &Ruby,
-        this: &Self,
-        subsystem: String,
-        name: String,
-        cache_seconds: Option<f64>,
-        cache_disabled: bool,
-    ) -> Result<NativePublishedValue, Error> {
-        Self::check_fork(ruby, this)?;
-        let cache = read_cache(ruby, cache_seconds, cache_disabled)?;
-        let inner = this.inner.clone();
-        let reader = this
-            .bridge
-            .wait_for(
-                ruby,
-                async move { inner.value_state(subsystem, name, cache).await },
-                Span::current(),
-            )?
-            .map_err(|error| Error::new(ruby.exception_runtime_error(), error.to_string()))?;
-        Ok(NativePublishedValue {
-            inner: reader,
-            bridge: this.bridge.clone(),
-        })
-    }
-
-    fn published_map(
-        ruby: &Ruby,
-        this: &Self,
-        subsystem: String,
-        name: String,
-        cache_seconds: Option<f64>,
-        cache_disabled: bool,
-    ) -> Result<NativePublishedMap, Error> {
-        Self::check_fork(ruby, this)?;
-        let cache = read_cache(ruby, cache_seconds, cache_disabled)?;
-        let inner = this.inner.clone();
-        let reader = this
-            .bridge
-            .wait_for(
-                ruby,
-                async move { inner.map_state(subsystem, name, cache).await },
-                Span::current(),
-            )?
-            .map_err(|error| Error::new(ruby.exception_runtime_error(), error.to_string()))?;
-        Ok(NativePublishedMap {
-            inner: reader,
-            bridge: this.bridge.clone(),
-            propagator: Arc::clone(&this.propagator),
-        })
-    }
-
-    fn published_deque(
-        ruby: &Ruby,
-        this: &Self,
-        subsystem: String,
-        name: String,
-        cache_seconds: Option<f64>,
-        cache_disabled: bool,
-    ) -> Result<NativePublishedDeque, Error> {
-        Self::check_fork(ruby, this)?;
-        let cache = read_cache(ruby, cache_seconds, cache_disabled)?;
-        let inner = this.inner.clone();
-        let reader = this
-            .bridge
-            .wait_for(
-                ruby,
-                async move { inner.deque_state(subsystem, name, cache).await },
-                Span::current(),
-            )?
-            .map_err(|error| Error::new(ruby.exception_runtime_error(), error.to_string()))?;
-        Ok(NativePublishedDeque {
-            inner: reader,
-            bridge: this.bridge.clone(),
-            propagator: Arc::clone(&this.propagator),
-        })
-    }
 }

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

@@ -0,0 +1,106 @@
+//! Published-state reader constructors for `Prosody::Client`.
+//!
+//! Each constructor opens a core reader through the bridge and wraps it in the
+//! matching native reader class.
+
+use super::config::read_cache_policy;
+use super::{Client, RubyHandler};
+use crate::handler::state_error;
+use crate::published::{
+    NativePublishedDeque, NativePublishedMap, NativePublishedSet, NativePublishedValue, Reads,
+};
+use magnus::{Error, Ruby, Value};
+use prosody::high_level::HighLevelClientError;
+use prosody::high_level::erased::{ErasedReadCache, ErasedReaderBuildError, SharedHighLevelClient};
+use serde_magnus::deserialize;
+use std::fmt::Display;
+use std::sync::Arc;
+use tracing::Span;
+
+/// Opens one published-state reader, and returns it with the client's
+/// bridge, propagator, and fork guard. `open` receives the shared client and
+/// the resolved cache policy. A state reader error raises the matching typed
+/// state error. Any other open failure raises `RuntimeError`.
+fn open_reader<F, Fut, R, E>(
+    ruby: &Ruby,
+    this: &Client,
+    read_cache: Value,
+    open: F,
+) -> Result<(R, Reads), Error>
+where
+    F: FnOnce(SharedHighLevelClient<RubyHandler>, ErasedReadCache) -> Fut,
+    Fut: Future<Output = Result<R, ErasedReaderBuildError<E>>> + Send + 'static,
+    R: Send,
+    E: Display + Send,
+{
+    this.fork.check(ruby)?;
+    let cache = read_cache_policy("read_cache", deserialize(ruby, read_cache)?)
+        .map_err(|error| Error::new(ruby.exception_arg_error(), error))?;
+    let reader = this
+        .bridge
+        .wait_for(ruby, open(this.inner.clone(), cache), Span::current())?
+        .map_err(|error| match error {
+            ErasedReaderBuildError::Client(HighLevelClientError::StateReader(error)) => {
+                state_error(ruby, &error.into())
+            }
+            error => Error::new(ruby.exception_runtime_error(), error.to_string()),
+        })?;
+    let reads = Reads {
+        bridge: this.bridge.clone(),
+        propagator: Arc::clone(&this.propagator),
+        fork: this.fork,
+    };
+    Ok((reader, reads))
+}
+
+pub(super) fn published_value(
+    ruby: &Ruby,
+    this: &Client,
+    subsystem: String,
+    name: String,
+    read_cache: Value,
+) -> Result<NativePublishedValue, Error> {
+    let (inner, reads) = open_reader(ruby, this, read_cache, |client, cache| async move {
+        client.value_state(subsystem, name, cache).await
+    })?;
+    Ok(NativePublishedValue { inner, reads })
+}
+
+pub(super) fn published_map(
+    ruby: &Ruby,
+    this: &Client,
+    subsystem: String,
+    name: String,
+    read_cache: Value,
+) -> Result<NativePublishedMap, Error> {
+    let (inner, reads) = open_reader(ruby, this, read_cache, |client, cache| async move {
+        client.map_state(subsystem, name, cache).await
+    })?;
+    Ok(NativePublishedMap { inner, reads })
+}
+
+pub(super) fn published_set(
+    ruby: &Ruby,
+    this: &Client,
+    subsystem: String,
+    name: String,
+    read_cache: Value,
+) -> Result<NativePublishedSet, Error> {
+    let (inner, reads) = open_reader(ruby, this, read_cache, |client, cache| async move {
+        client.set_state(subsystem, name, cache).await
+    })?;
+    Ok(NativePublishedSet { inner, reads })
+}
+
+pub(super) fn published_deque(
+    ruby: &Ruby,
+    this: &Client,
+    subsystem: String,
+    name: String,
+    read_cache: Value,
+) -> Result<NativePublishedDeque, Error> {
+    let (inner, reads) = open_reader(ruby, this, read_cache, |client, cache| async move {
+        client.deque_state(subsystem, name, cache).await
+    })?;
+    Ok(NativePublishedDeque { inner, reads })
+}