Skip to main content

kafka_client_engine/
config.rs

1//! Public engine defaults compiled before bounded host resources start.
2
3use std::time::Duration;
4
5mod classic_group_config;
6mod compression;
7#[cfg(test)]
8mod compression_test;
9mod consumer_fetch;
10mod consumer_limits;
11mod group_consumer_operations;
12mod producer_limits;
13mod read_isolation;
14mod security;
15mod transaction;
16mod validated;
17mod validation;
18pub use classic_group_config::EngineClassicGroupConfig;
19pub(crate) use classic_group_config::ValidatedClassicGroupConfig;
20pub use compression::ProducerCompression;
21pub use consumer_fetch::EngineConsumerFetchConfig;
22pub(crate) use consumer_fetch::{ConsumerFetchConfigError, ValidatedConsumerFetchConfig};
23pub use consumer_limits::EngineConsumerLimits;
24pub(crate) use consumer_limits::{
25    ConsumerLimitsError, ValidatedConsumerLimits, validate_consumer_fetch_envelope,
26};
27pub use group_consumer_operations::EngineGroupConsumerOperationConfig;
28pub(crate) use group_consumer_operations::ValidatedGroupConsumerOperationConfig;
29pub use producer_limits::EngineProducerLimits;
30pub use read_isolation::ConsumerReadIsolation;
31pub use security::{EngineSasl, EngineSaslMechanism, EngineSecurity, EngineTls};
32pub(crate) use validated::ValidatedEngineConfig;
33pub(crate) use validation::EngineConfigError;
34
35#[cfg(test)]
36mod classic_group_config_test;
37#[cfg(test)]
38mod consumer_fetch_test;
39#[cfg(test)]
40mod consumer_limits_test;
41#[cfg(test)]
42mod group_consumer_operations_test;
43#[cfg(test)]
44mod producer_limits_test;
45#[cfg(test)]
46mod read_isolation_test;
47#[cfg(test)]
48mod security_test;
49#[cfg(test)]
50mod transaction_test;
51#[cfg(test)]
52mod validation_test;
53
54const DEFAULT_DELIVERY_TIMEOUT: Duration = Duration::from_secs(30);
55const DEFAULT_ADMIN_TIMEOUT: Duration = Duration::from_secs(30);
56const DEFAULT_PRODUCER_RETRIES: u32 = 3;
57const DEFAULT_PRODUCER_RETRY_BACKOFF: Duration = Duration::from_millis(100);
58const DEFAULT_COMPRESSION_WORKERS: usize = 2;
59const DEFAULT_TURN_BUDGET: usize = 64;
60
61/// Engine construction inputs compiled before any host thread starts.
62#[derive(Debug, Clone, PartialEq, Eq)]
63pub struct EngineConfig {
64    bootstrap_servers: Vec<String>,
65    client_id: Option<String>,
66    delivery_timeout: Duration,
67    admin_timeout: Duration,
68    producer_limits: EngineProducerLimits,
69    producer_compression: ProducerCompression,
70    assigned_consumer_read_isolation: ConsumerReadIsolation,
71    security: EngineSecurity,
72    assigned_consumer_fetch: EngineConsumerFetchConfig,
73    assigned_consumer_limits: EngineConsumerLimits,
74    producer_retry_max: u32,
75    producer_retry_backoff: Duration,
76}
77
78impl EngineConfig {
79    /// Creates an engine configuration with engine-owned execution defaults.
80    pub fn new(bootstrap_servers: Vec<String>) -> Self {
81        Self {
82            bootstrap_servers,
83            client_id: None,
84            delivery_timeout: DEFAULT_DELIVERY_TIMEOUT,
85            admin_timeout: DEFAULT_ADMIN_TIMEOUT,
86            producer_limits: EngineProducerLimits::default(),
87            producer_compression: ProducerCompression::None,
88            assigned_consumer_read_isolation: ConsumerReadIsolation::default(),
89            security: EngineSecurity::default(),
90            assigned_consumer_fetch: EngineConsumerFetchConfig::default(),
91            assigned_consumer_limits: EngineConsumerLimits::default(),
92            producer_retry_max: DEFAULT_PRODUCER_RETRIES,
93            producer_retry_backoff: DEFAULT_PRODUCER_RETRY_BACKOFF,
94        }
95    }
96
97    /// Replaces the end-to-end default producer delivery timeout.
98    #[must_use]
99    pub const fn with_delivery_timeout(mut self, delivery_timeout: Duration) -> Self {
100        self.delivery_timeout = delivery_timeout;
101        self
102    }
103
104    /// Replaces the end-to-end default admin operation timeout.
105    #[must_use]
106    pub const fn with_admin_timeout(mut self, admin_timeout: Duration) -> Self {
107        self.admin_timeout = admin_timeout;
108        self
109    }
110
111    /// Replaces the provisional bounded producer resource contract.
112    #[must_use]
113    pub const fn with_producer_limits(mut self, producer_limits: EngineProducerLimits) -> Self {
114        self.producer_limits = producer_limits;
115        self
116    }
117
118    /// Selects the `RecordBatch` compression policy before the host starts.
119    #[must_use]
120    pub const fn with_producer_compression(
121        mut self,
122        producer_compression: ProducerCompression,
123    ) -> Self {
124        self.producer_compression = producer_compression;
125        self
126    }
127
128    /// Selects immutable record visibility for the sole assigned consumer.
129    #[must_use]
130    pub const fn with_assigned_consumer_read_isolation(
131        mut self,
132        read_isolation: ConsumerReadIsolation,
133    ) -> Self {
134        self.assigned_consumer_read_isolation = read_isolation;
135        self
136    }
137
138    /// Replaces the complete transport and broker-authentication policy.
139    #[must_use]
140    pub fn with_security(mut self, security: EngineSecurity) -> Self {
141        self.security = security;
142        self
143    }
144
145    /// Replaces the optional identity retained for future header propagation.
146    ///
147    /// The pinned driver does not currently write this value into Kafka
148    /// request headers.
149    #[must_use]
150    pub fn with_client_id(mut self, client_id: Option<String>) -> Self {
151        self.client_id = client_id;
152        self
153    }
154
155    /// Replaces the sole assigned consumer's broker Fetch policy.
156    #[must_use]
157    pub const fn with_assigned_consumer_fetch(mut self, fetch: EngineConsumerFetchConfig) -> Self {
158        self.assigned_consumer_fetch = fetch;
159        self
160    }
161
162    /// Replaces the sole assigned consumer's bounded resource capacities.
163    #[must_use]
164    pub const fn with_assigned_consumer_limits(mut self, limits: EngineConsumerLimits) -> Self {
165        self.assigned_consumer_limits = limits;
166        self
167    }
168
169    /// Replaces bounded definitely-unsent retry intent.
170    #[must_use]
171    pub const fn with_producer_retry(mut self, max_retries: u32, backoff: Duration) -> Self {
172        self.producer_retry_max = max_retries;
173        self.producer_retry_backoff = backoff;
174        self
175    }
176
177    /// Returns configured logical bootstrap endpoints.
178    pub fn bootstrap_servers(&self) -> &[String] {
179        &self.bootstrap_servers
180    }
181
182    /// Returns the retained client identity, when configured.
183    ///
184    /// The returned value does not imply request-header propagation.
185    pub fn client_id(&self) -> Option<&str> {
186        self.client_id.as_deref()
187    }
188
189    /// Returns the engine-owned default delivery timeout.
190    pub const fn delivery_timeout(&self) -> Duration {
191        self.delivery_timeout
192    }
193
194    /// Returns the engine-owned default admin operation timeout.
195    pub const fn admin_timeout(&self) -> Duration {
196        self.admin_timeout
197    }
198
199    /// Returns the provisional bounded producer limits.
200    pub const fn producer_limits(&self) -> EngineProducerLimits {
201        self.producer_limits
202    }
203
204    /// Returns the configured producer compression policy.
205    pub const fn producer_compression(&self) -> ProducerCompression {
206        self.producer_compression
207    }
208
209    /// Returns immutable record visibility for the sole assigned consumer.
210    pub const fn assigned_consumer_read_isolation(&self) -> ConsumerReadIsolation {
211        self.assigned_consumer_read_isolation
212    }
213
214    /// Returns the complete transport and broker-authentication policy.
215    pub const fn security(&self) -> &EngineSecurity {
216        &self.security
217    }
218
219    /// Returns the sole assigned consumer's raw broker Fetch policy.
220    pub const fn assigned_consumer_fetch(&self) -> EngineConsumerFetchConfig {
221        self.assigned_consumer_fetch
222    }
223
224    /// Returns the sole assigned consumer's raw resource capacities.
225    pub const fn assigned_consumer_limits(&self) -> EngineConsumerLimits {
226        self.assigned_consumer_limits
227    }
228
229    /// Returns the maximum definitely-unsent retries per producer batch.
230    pub const fn producer_retry_max(&self) -> u32 {
231        self.producer_retry_max
232    }
233
234    /// Returns the fixed delay between definitely-unsent producer attempts.
235    pub const fn producer_retry_backoff(&self) -> Duration {
236        self.producer_retry_backoff
237    }
238}