use kafka_client_core::Moment;
use crate::producer::{
host_turn::ProducerTurnOutcome,
ingress::{ProducerShardLockError, ProducerShardOwner},
};
use super::{EngineHostError, EngineHostResources, produce};
const PRODUCE_COMPLETION_BUDGET: usize = 64;
const PRODUCE_ADMISSION_BUDGET: usize = 64;
pub(super) struct ProducerProgress {
pub(super) outcome: Option<ProducerTurnOutcome>,
pub(super) unsettled: usize,
pub(super) driver_progress: bool,
}
pub(super) fn drive(
resources: &mut EngineHostResources,
now: Moment,
) -> Result<ProducerProgress, EngineHostError> {
let mut data = match resources.producer.try_data() {
Ok(data) => data,
Err(ProducerShardLockError::Contended) => return Ok(ProducerProgress::contended()),
Err(ProducerShardLockError::Poisoned) => {
return Err(EngineHostError::ProducerLockPoisoned);
}
};
if resources.control.shutdown_requested() {
resources.producer.close_locked_admission(&mut data);
}
resources.control.record_producer_turn();
let mut outcome = data
.turn(now, resources.budget)
.map_err(EngineHostError::Producer)?;
if let Some(deadline) = resources.produce_calls.next_refresh_deadline() {
outcome.next_deadline = Some(
outcome
.next_deadline
.map_or(deadline, |current| current.min(deadline)),
);
}
let driver = resources
.driver
.as_ref()
.ok_or(EngineHostError::DriverOwnerMissing)?;
let identity_progress = produce::admit_identity(
driver,
&mut resources.producer_identity_calls,
&mut data,
now,
)?;
let partitioning_progress =
produce::admit_partitioning(driver, &mut resources.producer_partitioning_call, &mut data)?;
let retained_partitioning_deadline = resources
.producer_partitioning_call
.as_ref()
.map(produce::ProducerPartitioningCall::deadline);
let produce_progress = admit_ready(
driver,
&mut resources.produce_calls,
&mut data,
now,
retained_partitioning_deadline,
)?;
Ok(ProducerProgress {
outcome: Some(outcome),
unsettled: data
.unsettled_completions()
.saturating_add(usize::from(resources.producer_partitioning_call.is_some())),
driver_progress: identity_progress || partitioning_progress || produce_progress,
})
}
fn admit_ready(
driver: &crate::driver::DriverOwner,
calls: &mut crate::driver::TrackedProduceCalls,
data: &mut crate::producer::ingress::ProducerShardData,
now: Moment,
retained_partitioning_deadline: Option<crate::clock::OperationDeadline>,
) -> Result<bool, EngineHostError> {
let mut progress = false;
for _attempt in 0..PRODUCE_ADMISSION_BUDGET {
if !admit_after_partitioning(driver, calls, data, now, retained_partitioning_deadline)? {
break;
}
progress = true;
}
Ok(progress)
}
pub(super) fn admit_after_partitioning(
driver: &crate::driver::DriverOwner,
calls: &mut crate::driver::TrackedProduceCalls,
data: &mut crate::producer::ingress::ProducerShardData,
now: Moment,
retained_partitioning_deadline: Option<crate::clock::OperationDeadline>,
) -> Result<bool, EngineHostError> {
if let Some(ready_deadline) = data.next_produce_submission_deadline() {
if retained_partitioning_deadline == Some(ready_deadline)
|| data.has_pending_produce_submission_at(ready_deadline)
{
return Ok(false);
}
}
produce::admit_one(driver, calls, data, now)
}
pub(super) fn apply_completions(
driver: &crate::driver::DriverOwner,
producer: &ProducerShardOwner,
identity_calls: &mut crate::driver::TrackedProducerIdentityCalls,
partitioning_call: &mut Option<produce::ProducerPartitioningCall>,
calls: &mut crate::driver::TrackedProduceCalls,
now: Moment,
) -> Result<bool, EngineHostError> {
let mut data = match producer.try_data() {
Ok(data) => data,
Err(ProducerShardLockError::Contended) => return Ok(false),
Err(ProducerShardLockError::Poisoned) => {
return Err(EngineHostError::ProducerLockPoisoned);
}
};
let identity = produce::apply_identity_ready(identity_calls, &mut data, now)?;
let partitioning = produce::apply_partitioning_ready(partitioning_call, &mut data)?;
let produce = produce::apply_ready(driver, calls, &mut data, now, PRODUCE_COMPLETION_BUDGET)?;
Ok(identity || partitioning || produce)
}
impl ProducerProgress {
const fn contended() -> Self {
Self {
outcome: None,
unsettled: usize::MAX,
driver_progress: false,
}
}
}