use std::time::Duration;
mod classic_group_config;
mod compression;
#[cfg(test)]
mod compression_test;
mod consumer_fetch;
mod consumer_limits;
mod group_consumer_operations;
mod producer_limits;
mod read_isolation;
mod security;
mod transaction;
mod validated;
mod validation;
pub use classic_group_config::EngineClassicGroupConfig;
pub(crate) use classic_group_config::ValidatedClassicGroupConfig;
pub use compression::ProducerCompression;
pub use consumer_fetch::EngineConsumerFetchConfig;
pub(crate) use consumer_fetch::{ConsumerFetchConfigError, ValidatedConsumerFetchConfig};
pub use consumer_limits::EngineConsumerLimits;
pub(crate) use consumer_limits::{
ConsumerLimitsError, ValidatedConsumerLimits, validate_consumer_fetch_envelope,
};
pub use group_consumer_operations::EngineGroupConsumerOperationConfig;
pub(crate) use group_consumer_operations::ValidatedGroupConsumerOperationConfig;
pub use producer_limits::EngineProducerLimits;
pub use read_isolation::ConsumerReadIsolation;
pub use security::{EngineSasl, EngineSaslMechanism, EngineSecurity, EngineTls};
pub(crate) use validated::ValidatedEngineConfig;
pub(crate) use validation::EngineConfigError;
#[cfg(test)]
mod classic_group_config_test;
#[cfg(test)]
mod consumer_fetch_test;
#[cfg(test)]
mod consumer_limits_test;
#[cfg(test)]
mod group_consumer_operations_test;
#[cfg(test)]
mod producer_limits_test;
#[cfg(test)]
mod read_isolation_test;
#[cfg(test)]
mod security_test;
#[cfg(test)]
mod transaction_test;
#[cfg(test)]
mod validation_test;
const DEFAULT_DELIVERY_TIMEOUT: Duration = Duration::from_secs(30);
const DEFAULT_ADMIN_TIMEOUT: Duration = Duration::from_secs(30);
const DEFAULT_PRODUCER_RETRIES: u32 = 3;
const DEFAULT_PRODUCER_RETRY_BACKOFF: Duration = Duration::from_millis(100);
const DEFAULT_COMPRESSION_WORKERS: usize = 2;
const DEFAULT_TURN_BUDGET: usize = 64;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct EngineConfig {
bootstrap_servers: Vec<String>,
client_id: Option<String>,
delivery_timeout: Duration,
admin_timeout: Duration,
producer_limits: EngineProducerLimits,
producer_compression: ProducerCompression,
assigned_consumer_read_isolation: ConsumerReadIsolation,
security: EngineSecurity,
assigned_consumer_fetch: EngineConsumerFetchConfig,
assigned_consumer_limits: EngineConsumerLimits,
producer_retry_max: u32,
producer_retry_backoff: Duration,
}
impl EngineConfig {
pub fn new(bootstrap_servers: Vec<String>) -> Self {
Self {
bootstrap_servers,
client_id: None,
delivery_timeout: DEFAULT_DELIVERY_TIMEOUT,
admin_timeout: DEFAULT_ADMIN_TIMEOUT,
producer_limits: EngineProducerLimits::default(),
producer_compression: ProducerCompression::None,
assigned_consumer_read_isolation: ConsumerReadIsolation::default(),
security: EngineSecurity::default(),
assigned_consumer_fetch: EngineConsumerFetchConfig::default(),
assigned_consumer_limits: EngineConsumerLimits::default(),
producer_retry_max: DEFAULT_PRODUCER_RETRIES,
producer_retry_backoff: DEFAULT_PRODUCER_RETRY_BACKOFF,
}
}
#[must_use]
pub const fn with_delivery_timeout(mut self, delivery_timeout: Duration) -> Self {
self.delivery_timeout = delivery_timeout;
self
}
#[must_use]
pub const fn with_admin_timeout(mut self, admin_timeout: Duration) -> Self {
self.admin_timeout = admin_timeout;
self
}
#[must_use]
pub const fn with_producer_limits(mut self, producer_limits: EngineProducerLimits) -> Self {
self.producer_limits = producer_limits;
self
}
#[must_use]
pub const fn with_producer_compression(
mut self,
producer_compression: ProducerCompression,
) -> Self {
self.producer_compression = producer_compression;
self
}
#[must_use]
pub const fn with_assigned_consumer_read_isolation(
mut self,
read_isolation: ConsumerReadIsolation,
) -> Self {
self.assigned_consumer_read_isolation = read_isolation;
self
}
#[must_use]
pub fn with_security(mut self, security: EngineSecurity) -> Self {
self.security = security;
self
}
#[must_use]
pub fn with_client_id(mut self, client_id: Option<String>) -> Self {
self.client_id = client_id;
self
}
#[must_use]
pub const fn with_assigned_consumer_fetch(mut self, fetch: EngineConsumerFetchConfig) -> Self {
self.assigned_consumer_fetch = fetch;
self
}
#[must_use]
pub const fn with_assigned_consumer_limits(mut self, limits: EngineConsumerLimits) -> Self {
self.assigned_consumer_limits = limits;
self
}
#[must_use]
pub const fn with_producer_retry(mut self, max_retries: u32, backoff: Duration) -> Self {
self.producer_retry_max = max_retries;
self.producer_retry_backoff = backoff;
self
}
pub fn bootstrap_servers(&self) -> &[String] {
&self.bootstrap_servers
}
pub fn client_id(&self) -> Option<&str> {
self.client_id.as_deref()
}
pub const fn delivery_timeout(&self) -> Duration {
self.delivery_timeout
}
pub const fn admin_timeout(&self) -> Duration {
self.admin_timeout
}
pub const fn producer_limits(&self) -> EngineProducerLimits {
self.producer_limits
}
pub const fn producer_compression(&self) -> ProducerCompression {
self.producer_compression
}
pub const fn assigned_consumer_read_isolation(&self) -> ConsumerReadIsolation {
self.assigned_consumer_read_isolation
}
pub const fn security(&self) -> &EngineSecurity {
&self.security
}
pub const fn assigned_consumer_fetch(&self) -> EngineConsumerFetchConfig {
self.assigned_consumer_fetch
}
pub const fn assigned_consumer_limits(&self) -> EngineConsumerLimits {
self.assigned_consumer_limits
}
pub const fn producer_retry_max(&self) -> u32 {
self.producer_retry_max
}
pub const fn producer_retry_backoff(&self) -> Duration {
self.producer_retry_backoff
}
}