prosody 0.5.1 → 0.6.0

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

@@ -0,0 +1,170 @@
+//! Conversion of [`NativeConfiguration`] into the Kafka producer, Kafka
+//! consumer, Cassandra, and telemetry emitter builders.
+
+use super::{NativeConfiguration, ProbePort};
+use crate::util::seconds;
+use prosody::cassandra::config::CassandraConfigurationBuilder;
+use prosody::consumer::ConsumerConfigurationBuilder;
+use prosody::producer::ProducerConfigurationBuilder;
+use prosody::telemetry::emitter::TelemetryEmitterConfiguration;
+
+impl<'a> TryFrom<&'a NativeConfiguration> for ProducerConfigurationBuilder {
+    type Error = String;
+
+    /// Reads the Kafka producer settings.
+    fn try_from(config: &'a NativeConfiguration) -> Result<Self, Self::Error> {
+        let mut builder = Self::default();
+
+        if let Some(bootstrap_servers) = &config.bootstrap_servers {
+            builder.bootstrap_servers(bootstrap_servers.clone());
+        }
+
+        if let Some(send_timeout) = &config.send_timeout {
+            builder.send_timeout(seconds("send_timeout", *send_timeout)?);
+        }
+
+        if let Some(idempotence_cache_size) = &config.idempotence_cache_size {
+            builder.idempotence_cache_size(*idempotence_cache_size as usize);
+        }
+
+        if let Some(source_system) = &config.source_system {
+            builder.source_system(source_system.clone());
+        }
+
+        if let Some(mock) = &config.mock {
+            builder.mock(*mock);
+        }
+
+        Ok(builder)
+    }
+}
+
+impl<'a> TryFrom<&'a NativeConfiguration> for ConsumerConfigurationBuilder {
+    type Error = String;
+
+    /// Reads the Kafka consumer settings.
+    fn try_from(config: &'a NativeConfiguration) -> Result<Self, Self::Error> {
+        let mut builder = Self::default();
+
+        if let Some(bootstrap_servers) = &config.bootstrap_servers {
+            builder.bootstrap_servers(bootstrap_servers.clone());
+        }
+
+        if let Some(group_id) = &config.group_id {
+            builder.group_id(group_id.clone());
+        }
+
+        if let Some(subscribed_topics) = &config.subscribed_topics {
+            builder.subscribed_topics(subscribed_topics.clone());
+        }
+
+        if let Some(allowed_events) = &config.allowed_events {
+            builder.allowed_events(allowed_events.clone());
+        }
+
+        if let Some(max_uncommitted) = &config.max_uncommitted {
+            builder.max_uncommitted(*max_uncommitted as usize);
+        }
+
+        if let Some(stall_threshold) = &config.stall_threshold {
+            builder.stall_threshold(seconds("stall_threshold", *stall_threshold)?);
+        }
+
+        if let Some(shutdown_timeout) = &config.shutdown_timeout {
+            builder.shutdown_timeout(seconds("shutdown_timeout", *shutdown_timeout)?);
+        }
+
+        if let Some(poll_interval) = &config.poll_interval {
+            builder.poll_interval(seconds("poll_interval", *poll_interval)?);
+        }
+
+        if let Some(commit_interval) = &config.commit_interval {
+            builder.commit_interval(seconds("commit_interval", *commit_interval)?);
+        }
+
+        if let Some(statistics_interval) = &config.statistics_interval {
+            builder.statistics_interval(seconds("statistics_interval", *statistics_interval)?);
+        }
+
+        if let Some(mock) = &config.mock {
+            builder.mock(*mock);
+        }
+
+        if let Some(probe_port) = &config.probe_port {
+            match probe_port {
+                ProbePort::Unconfigured => {}
+                ProbePort::Disabled => {
+                    builder.probe_port(None);
+                }
+                ProbePort::Configured(port) => {
+                    builder.probe_port(*port);
+                }
+            }
+        }
+
+        if let Some(slab_size) = &config.slab_size {
+            builder.slab_size(seconds("slab_size", *slab_size)?);
+        }
+
+        Ok(builder)
+    }
+}
+
+impl<'a> TryFrom<&'a NativeConfiguration> for CassandraConfigurationBuilder {
+    type Error = String;
+
+    /// Reads the Cassandra settings.
+    fn try_from(config: &'a NativeConfiguration) -> Result<Self, Self::Error> {
+        let mut builder = Self::default();
+
+        if let Some(nodes) = &config.cassandra_nodes {
+            builder.nodes(nodes.clone());
+        }
+
+        if let Some(keyspace) = &config.cassandra_keyspace {
+            builder.keyspace(keyspace.clone());
+        }
+
+        if let Some(datacenter) = &config.cassandra_datacenter {
+            builder.datacenter(Some(datacenter.clone()));
+        }
+
+        if let Some(rack) = &config.cassandra_rack {
+            builder.rack(Some(rack.clone()));
+        }
+
+        if let Some(user) = &config.cassandra_user {
+            builder.user(Some(user.clone()));
+        }
+
+        if let Some(password) = &config.cassandra_password {
+            builder.password(Some(password.clone()));
+        }
+
+        if let Some(retention) = &config.cassandra_retention {
+            builder.retention(seconds("cassandra_retention", *retention)?);
+        }
+
+        Ok(builder)
+    }
+}
+
+impl<'a> TryFrom<&'a NativeConfiguration> for TelemetryEmitterConfiguration {
+    type Error = String;
+
+    /// Reads the telemetry emitter settings. Environment variables fill unset
+    /// fields.
+    fn try_from(config: &'a NativeConfiguration) -> Result<Self, Self::Error> {
+        let mut builder = Self::builder();
+
+        if let Some(topic) = &config.telemetry_topic {
+            builder.topic(topic.clone());
+        }
+
+        if let Some(enabled) = &config.telemetry_enabled {
+            builder.enabled(*enabled);
+        }
+
+        builder.build().map_err(|e| e.to_string())
+    }
+}

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

@@ -0,0 +1,184 @@
+//! Conversion of [`NativeConfiguration`] into the retry, failure topic,
+//! scheduler, monopolization, defer, timeout, and deduplication middleware
+//! builders.
+
+use super::NativeConfiguration;
+use crate::util::seconds;
+use prosody::consumer::middleware::deduplication::DeduplicationConfigurationBuilder;
+use prosody::consumer::middleware::defer::DeferConfigurationBuilder;
+use prosody::consumer::middleware::monopolization::MonopolizationConfigurationBuilder;
+use prosody::consumer::middleware::retry::RetryConfigurationBuilder;
+use prosody::consumer::middleware::scheduler::SchedulerConfigurationBuilder;
+use prosody::consumer::middleware::timeout::TimeoutConfigurationBuilder;
+use prosody::consumer::middleware::topic::FailureTopicConfigurationBuilder;
+use std::num::NonZeroUsize;
+
+impl<'a> TryFrom<&'a NativeConfiguration> for RetryConfigurationBuilder {
+    type Error = String;
+
+    /// Reads the retry settings.
+    fn try_from(config: &'a NativeConfiguration) -> Result<Self, Self::Error> {
+        let mut builder = Self::default();
+
+        if let Some(retry_base) = &config.retry_base {
+            builder.base(seconds("retry_base", *retry_base)?);
+        }
+
+        if let Some(max_retries) = &config.max_retries {
+            builder.max_retries(*max_retries);
+        }
+
+        if let Some(max_retry_delay) = &config.max_retry_delay {
+            builder.max_delay(seconds("max_retry_delay", *max_retry_delay)?);
+        }
+
+        Ok(builder)
+    }
+}
+
+impl<'a> From<&'a NativeConfiguration> for FailureTopicConfigurationBuilder {
+    /// Reads the failure topic setting.
+    fn from(config: &'a NativeConfiguration) -> Self {
+        let mut builder = Self::default();
+
+        if let Some(failure_topic) = &config.failure_topic {
+            builder.failure_topic(failure_topic.clone());
+        }
+
+        builder
+    }
+}
+
+impl<'a> TryFrom<&'a NativeConfiguration> for SchedulerConfigurationBuilder {
+    type Error = String;
+
+    /// Reads the scheduler settings.
+    fn try_from(config: &'a NativeConfiguration) -> Result<Self, Self::Error> {
+        let mut builder = Self::default();
+
+        if let Some(max_concurrency) = &config.max_concurrency {
+            builder.max_concurrency(*max_concurrency as usize);
+        }
+
+        if let Some(failure_weight) = &config.scheduler_failure_weight {
+            builder.failure_weight(*failure_weight);
+        }
+
+        if let Some(max_wait) = &config.scheduler_max_wait {
+            builder.max_wait(seconds("scheduler_max_wait", *max_wait)?);
+        }
+
+        if let Some(wait_weight) = &config.scheduler_wait_weight {
+            builder.wait_weight(*wait_weight);
+        }
+
+        if let Some(cache_size) = &config.scheduler_cache_size {
+            builder.cache_size(*cache_size as usize);
+        }
+
+        Ok(builder)
+    }
+}
+
+impl<'a> TryFrom<&'a NativeConfiguration> for MonopolizationConfigurationBuilder {
+    type Error = String;
+
+    /// Reads the monopolization settings.
+    fn try_from(config: &'a NativeConfiguration) -> Result<Self, Self::Error> {
+        let mut builder = Self::default();
+
+        if let Some(enabled) = &config.monopolization_enabled {
+            builder.enabled(*enabled);
+        }
+
+        if let Some(threshold) = &config.monopolization_threshold {
+            builder.monopolization_threshold(*threshold);
+        }
+
+        if let Some(window) = &config.monopolization_window {
+            builder.window_duration(seconds("monopolization_window", *window)?);
+        }
+
+        if let Some(cache_size) = &config.monopolization_cache_size {
+            builder.cache_size(*cache_size as usize);
+        }
+
+        Ok(builder)
+    }
+}
+
+impl<'a> TryFrom<&'a NativeConfiguration> for DeferConfigurationBuilder {
+    type Error = String;
+
+    /// Reads the defer settings.
+    fn try_from(config: &'a NativeConfiguration) -> Result<Self, Self::Error> {
+        let mut builder = Self::default();
+
+        if let Some(enabled) = &config.defer_enabled {
+            builder.enabled(*enabled);
+        }
+
+        if let Some(base) = &config.defer_base {
+            builder.base(seconds("defer_base", *base)?);
+        }
+
+        if let Some(max_delay) = &config.defer_max_delay {
+            builder.max_delay(seconds("defer_max_delay", *max_delay)?);
+        }
+
+        if let Some(failure_threshold) = &config.defer_failure_threshold {
+            builder.failure_threshold(*failure_threshold);
+        }
+
+        if let Some(failure_window) = &config.defer_failure_window {
+            builder.failure_window(seconds("defer_failure_window", *failure_window)?);
+        }
+
+        if let Some(store_cache_size) = &config.defer_store_cache_size {
+            builder.store_cache_size(*store_cache_size as usize);
+        }
+
+        Ok(builder)
+    }
+}
+
+impl<'a> TryFrom<&'a NativeConfiguration> for TimeoutConfigurationBuilder {
+    type Error = String;
+
+    /// Reads the handler timeout setting.
+    fn try_from(config: &'a NativeConfiguration) -> Result<Self, Self::Error> {
+        let mut builder = Self::default();
+
+        if let Some(timeout) = &config.timeout {
+            builder.timeout(Some(seconds("timeout", *timeout)?));
+        }
+
+        Ok(builder)
+    }
+}
+
+impl<'a> TryFrom<&'a NativeConfiguration> for DeduplicationConfigurationBuilder {
+    type Error = String;
+
+    /// Reads the deduplication settings. Core deduplication is mandatory, so an
+    /// `idempotence_cache_size` of `0` fails.
+    fn try_from(config: &'a NativeConfiguration) -> Result<Self, Self::Error> {
+        let mut builder = Self::default();
+
+        if let Some(cache_capacity) = &config.idempotence_cache_size {
+            let cache_capacity = NonZeroUsize::new(*cache_capacity as usize)
+                .ok_or_else(|| "idempotence_cache_size must be greater than 0".to_owned())?;
+            builder.cache_capacity(cache_capacity);
+        }
+
+        if let Some(version) = &config.idempotence_version {
+            builder.version(version.clone());
+        }
+
+        if let Some(ttl) = &config.idempotence_ttl {
+            builder.ttl(seconds("idempotence_ttl", *ttl)?);
+        }
+
+        Ok(builder)
+    }
+}