use std::collections::VecDeque;
use kafka_client_core::{AssignedConsumerMachine, GroupPositionMissingOffsetPolicy, ReadIsolation};
use crate::{
config::{ValidatedConsumerFetchConfig, ValidatedConsumerLimits},
consumer::{
assigned_event::AssignedConsumerEventStore, assigned_owner_model::fetch_isolation,
assigned_timers::AssignedTimers, fetch_execution::DirectFetchExecutor,
position_execution::PositionResolutionExecutor,
},
protocol::fetch::{FetchDecodeLimits, FetchRequestSettings},
};
use super::{
model::ClassicGroupFetchBuildError,
owner::{ClassicGroupFetchOwner, FIRST_GROUP_FETCH_EFFECTS, FIRST_GROUP_FETCH_PARTITIONS},
};
impl ClassicGroupFetchOwner {
pub(in crate::consumer::group) fn try_new() -> Result<Self, ClassicGroupFetchBuildError> {
Self::try_new_with_policies(
ReadIsolation::ReadUncommitted,
GroupPositionMissingOffsetPolicy::Error,
)
}
pub(in crate::consumer::group) fn try_new_with_read_isolation(
read_isolation: ReadIsolation,
) -> Result<Self, ClassicGroupFetchBuildError> {
Self::try_new_with_policies(read_isolation, GroupPositionMissingOffsetPolicy::Error)
}
pub(in crate::consumer::group) fn try_new_with_policies(
read_isolation: ReadIsolation,
missing_offset_policy: GroupPositionMissingOffsetPolicy,
) -> Result<Self, ClassicGroupFetchBuildError> {
Self::try_new_with_fetch_configuration(
read_isolation,
missing_offset_policy,
ValidatedConsumerFetchConfig::default(),
ValidatedConsumerLimits::default(),
)
}
pub(in crate::consumer::group) fn try_new_with_fetch_configuration(
read_isolation: ReadIsolation,
missing_offset_policy: GroupPositionMissingOffsetPolicy,
fetch: ValidatedConsumerFetchConfig,
limits: ValidatedConsumerLimits,
) -> Result<Self, ClassicGroupFetchBuildError> {
let mut effects = VecDeque::new();
let mut raw_position_deadlines = VecDeque::new();
let mut pending_positions = VecDeque::new();
let mut pending_fetches = VecDeque::new();
let mut reclaim_faults = Vec::new();
effects
.try_reserve_exact(FIRST_GROUP_FETCH_EFFECTS)
.map_err(|_error| ClassicGroupFetchBuildError::Allocation)?;
raw_position_deadlines
.try_reserve_exact(FIRST_GROUP_FETCH_PARTITIONS)
.map_err(|_error| ClassicGroupFetchBuildError::Allocation)?;
pending_positions
.try_reserve_exact(FIRST_GROUP_FETCH_PARTITIONS)
.map_err(|_error| ClassicGroupFetchBuildError::Allocation)?;
pending_fetches
.try_reserve_exact(FIRST_GROUP_FETCH_PARTITIONS)
.map_err(|_error| ClassicGroupFetchBuildError::Allocation)?;
reclaim_faults
.try_reserve_exact(limits.buffered_batches())
.map_err(|_error| ClassicGroupFetchBuildError::Allocation)?;
let events = AssignedConsumerEventStore::new(FIRST_GROUP_FETCH_PARTITIONS)
.map_err(|_error| ClassicGroupFetchBuildError::Allocation)?;
let mut fetches = DirectFetchExecutor::create_unbound(
limits.in_flight_fetches(),
limits.buffered_batches(),
limits.buffered_bytes(),
);
fetches
.try_enable_sessions(FIRST_GROUP_FETCH_PARTITIONS)
.map_err(|()| ClassicGroupFetchBuildError::Allocation)?;
let fetch_settings = FetchRequestSettings::new(
fetch.max_wait_ms(),
fetch.min_bytes(),
fetch.max_bytes(),
fetch.partition_max_bytes(),
0,
)
.with_isolation(fetch_isolation(read_isolation));
fetches.configure_broker_sessions(fetch_settings, fetch.attempt_timeout());
Ok(Self {
machine: AssignedConsumerMachine::with_read_isolation(read_isolation),
activation: None,
timers: AssignedTimers::new(FIRST_GROUP_FETCH_PARTITIONS),
positions: PositionResolutionExecutor::new(limits.in_flight_fetches()),
fetches,
events,
effects,
raw_position_deadlines,
pending_positions,
pending_fetches,
fetch_settings,
fetch_decode_limits: FetchDecodeLimits::default(),
fetch_attempt_timeout: fetch.attempt_timeout(),
missing_offset_policy,
read_isolation,
partition_capacity: FIRST_GROUP_FETCH_PARTITIONS,
effect_capacity: FIRST_GROUP_FETCH_EFFECTS,
delivery_capacity: limits.buffered_batches(),
hard_fetch_output_bytes: limits.max_batch_bytes(),
fault: None,
seek: None,
reclaim_faults,
reclaim_overflow: None,
})
}
}