kafka_client_engine/
config.rs1use 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#[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 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 #[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 #[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 #[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 #[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 #[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 #[must_use]
140 pub fn with_security(mut self, security: EngineSecurity) -> Self {
141 self.security = security;
142 self
143 }
144
145 #[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 #[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 #[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 #[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 pub fn bootstrap_servers(&self) -> &[String] {
179 &self.bootstrap_servers
180 }
181
182 pub fn client_id(&self) -> Option<&str> {
186 self.client_id.as_deref()
187 }
188
189 pub const fn delivery_timeout(&self) -> Duration {
191 self.delivery_timeout
192 }
193
194 pub const fn admin_timeout(&self) -> Duration {
196 self.admin_timeout
197 }
198
199 pub const fn producer_limits(&self) -> EngineProducerLimits {
201 self.producer_limits
202 }
203
204 pub const fn producer_compression(&self) -> ProducerCompression {
206 self.producer_compression
207 }
208
209 pub const fn assigned_consumer_read_isolation(&self) -> ConsumerReadIsolation {
211 self.assigned_consumer_read_isolation
212 }
213
214 pub const fn security(&self) -> &EngineSecurity {
216 &self.security
217 }
218
219 pub const fn assigned_consumer_fetch(&self) -> EngineConsumerFetchConfig {
221 self.assigned_consumer_fetch
222 }
223
224 pub const fn assigned_consumer_limits(&self) -> EngineConsumerLimits {
226 self.assigned_consumer_limits
227 }
228
229 pub const fn producer_retry_max(&self) -> u32 {
231 self.producer_retry_max
232 }
233
234 pub const fn producer_retry_backoff(&self) -> Duration {
236 self.producer_retry_backoff
237 }
238}