use std::time::Duration;
use kafka_client_core::{
ByteCount, ProducerBatchPolicy, ProducerRetryPolicy, ProducerRetryPolicyError,
};
use crate::{
driver::{EngineSecurityError, validate_security},
producer::{ProducerHostLimitError, ProducerHostLimits, host_turn::ProducerTurnBudget},
};
use super::{
ConsumerFetchConfigError, ConsumerLimitsError, DEFAULT_COMPRESSION_WORKERS,
DEFAULT_TURN_BUDGET, EngineConfig, ValidatedEngineConfig, validate_consumer_fetch_envelope,
};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum EngineConfigError {
EmptyBootstrap,
ClientIdTooLong,
Security(EngineSecurityError),
ZeroDeliveryTimeout,
ZeroAdminTimeout,
DurationOverflow,
RetainedBytes,
BatchBytes,
RequestBytes,
CompressionBytes,
BatchPolicy,
RetryPolicy(ProducerRetryPolicyError),
Producer(ProducerHostLimitError),
ConsumerFetch(ConsumerFetchConfigError),
ConsumerLimits(ConsumerLimitsError),
TurnBudget,
}
impl EngineConfig {
pub(crate) fn validate(&self) -> Result<ValidatedEngineConfig, EngineConfigError> {
if self.bootstrap_servers().is_empty() {
return Err(EngineConfigError::EmptyBootstrap);
}
if self
.client_id()
.is_some_and(|client_id| i16::try_from(client_id.len()).is_err())
{
return Err(EngineConfigError::ClientIdTooLong);
}
let security = validate_security(self.security()).map_err(EngineConfigError::Security)?;
if self.delivery_timeout().is_zero() {
return Err(EngineConfigError::ZeroDeliveryTimeout);
}
duration_ticks(self.delivery_timeout())?;
if self.admin_timeout().is_zero() {
return Err(EngineConfigError::ZeroAdminTimeout);
}
duration_ticks(self.admin_timeout())?;
let host_limits = self.producer_host_limits()?;
let assigned_consumer_fetch = self
.assigned_consumer_fetch()
.validate()
.map_err(EngineConfigError::ConsumerFetch)?;
let assigned_consumer_limits = self
.assigned_consumer_limits()
.validate()
.map_err(EngineConfigError::ConsumerLimits)?;
validate_consumer_fetch_envelope(
assigned_consumer_limits,
assigned_consumer_fetch.partition_max_bytes(),
)
.map_err(EngineConfigError::ConsumerLimits)?;
let validated_host = host_limits
.validate()
.map_err(EngineConfigError::Producer)?;
drop(validated_host);
let Some(turn_budget) = ProducerTurnBudget::try_new(
DEFAULT_TURN_BUDGET,
DEFAULT_TURN_BUDGET,
DEFAULT_TURN_BUDGET,
DEFAULT_TURN_BUDGET,
DEFAULT_TURN_BUDGET,
DEFAULT_TURN_BUDGET,
) else {
return Err(EngineConfigError::TurnBudget);
};
Ok(ValidatedEngineConfig {
host_limits,
turn_budget,
security,
assigned_consumer_fetch,
assigned_consumer_limits,
})
}
fn producer_host_limits(&self) -> Result<ProducerHostLimits, EngineConfigError> {
let limits = self.producer_limits();
let _retained_bytes =
u64::try_from(limits.retained_bytes()).map_err(|_| EngineConfigError::RetainedBytes)?;
let _waiting_bytes =
u64::try_from(limits.waiting_bytes()).map_err(|_| EngineConfigError::RetainedBytes)?;
let batch_bytes =
u64::try_from(limits.batch_bytes()).map_err(|_| EngineConfigError::BatchBytes)?;
let _request_bytes =
u64::try_from(limits.request_bytes()).map_err(|_| EngineConfigError::RequestBytes)?;
let linger_ticks = duration_ticks(limits.linger())?;
let batch_policy = ProducerBatchPolicy::try_new(
limits.batch_records(),
ByteCount::new(batch_bytes),
linger_ticks,
)
.map_err(|_| EngineConfigError::BatchPolicy)?;
let retry_policy = if self.producer_retry_max == 0 {
ProducerRetryPolicy::none()
} else {
let retry_ticks = duration_ticks(self.producer_retry_backoff)?;
ProducerRetryPolicy::try_fixed(self.producer_retry_max, retry_ticks)
.map_err(EngineConfigError::RetryPolicy)?
};
let compression = self.producer_compression().core();
let compressed = compression != kafka_client_core::CompressionPolicy::None;
let compression_byte_capacity = if compressed {
limits
.retained_bytes()
.checked_add(limits.retained_bytes())
.ok_or(EngineConfigError::CompressionBytes)?
} else {
0
};
Ok(ProducerHostLimits {
retained_bytes: limits.retained_bytes(),
completion_capacity: limits.in_flight_records(),
waiting_record_capacity: limits.waiting_records(),
waiting_byte_capacity: limits.waiting_bytes(),
record_capacity: limits.in_flight_records(),
batch_capacity: limits.in_flight_records(),
timer_capacity: limits.in_flight_records(),
encoded_byte_capacity: limits.retained_bytes(),
max_wire_batch_bytes: limits.batch_bytes(),
max_request_bytes: limits.request_bytes(),
max_in_flight_requests_per_broker: limits.max_in_flight_requests_per_broker(),
batch_policy,
retry_policy,
compression,
compression_worker_count: if compressed {
DEFAULT_COMPRESSION_WORKERS
} else {
0
},
compression_job_capacity: if compressed {
limits.in_flight_records()
} else {
0
},
compression_byte_capacity,
})
}
}
pub(super) fn duration_ticks(duration: Duration) -> Result<u64, EngineConfigError> {
u64::try_from(duration.as_nanos()).map_err(|_| EngineConfigError::DurationOverflow)
}