Skip to main content

kafka_client_engine/config/
classic_group_config.rs

1//! Public raw classic-group timing and its validated core policy bundle.
2
3use std::time::Duration;
4
5use kafka_client_core::{ClassicGroupTiming, ClassicHeartbeatPolicy, ClassicRejoinPolicy};
6
7/// Session, rebalance, Heartbeat, and recovery timing compiled at registration.
8#[derive(Clone, Copy, Debug, Eq, PartialEq)]
9pub struct EngineClassicGroupConfig {
10    session_timeout: Duration,
11    rebalance_timeout: Duration,
12    heartbeat_interval: Duration,
13    heartbeat_attempt_timeout: Duration,
14    rejoin_backoff: Duration,
15    rejoin_attempt_timeout: Duration,
16}
17
18impl EngineClassicGroupConfig {
19    /// Creates raw classic-group timing for registration validation.
20    pub const fn new(
21        session_timeout: Duration,
22        rebalance_timeout: Duration,
23        heartbeat_interval: Duration,
24        heartbeat_attempt_timeout: Duration,
25        rejoin_backoff: Duration,
26        rejoin_attempt_timeout: Duration,
27    ) -> Self {
28        Self {
29            session_timeout,
30            rebalance_timeout,
31            heartbeat_interval,
32            heartbeat_attempt_timeout,
33            rejoin_backoff,
34            rejoin_attempt_timeout,
35        }
36    }
37
38    /// Returns the requested Kafka session timeout.
39    pub const fn session_timeout(self) -> Duration {
40        self.session_timeout
41    }
42
43    /// Returns the requested Kafka rebalance timeout.
44    pub const fn rebalance_timeout(self) -> Duration {
45        self.rebalance_timeout
46    }
47
48    /// Returns the requested delay between successful Heartbeats.
49    pub const fn heartbeat_interval(self) -> Duration {
50        self.heartbeat_interval
51    }
52
53    /// Returns the requested timeout for one Heartbeat attempt.
54    pub const fn heartbeat_attempt_timeout(self) -> Duration {
55        self.heartbeat_attempt_timeout
56    }
57
58    /// Returns the requested delay before a recoverable rejoin.
59    pub const fn rejoin_backoff(self) -> Duration {
60        self.rejoin_backoff
61    }
62
63    /// Returns the requested timeout for one internally retried Join cycle.
64    pub const fn rejoin_attempt_timeout(self) -> Duration {
65        self.rejoin_attempt_timeout
66    }
67
68    pub(crate) fn validate(self) -> Result<ValidatedClassicGroupConfig, ClassicGroupConfigError> {
69        let session_timeout_ms = whole_positive_milliseconds(self.session_timeout)
70            .ok_or(ClassicGroupConfigError::SessionTimeout)?;
71        let rebalance_timeout_ms = whole_positive_milliseconds(self.rebalance_timeout)
72            .ok_or(ClassicGroupConfigError::RebalanceTimeout)?;
73        let timing = ClassicGroupTiming::try_new(session_timeout_ms, rebalance_timeout_ms)
74            .map_err(|_error| ClassicGroupConfigError::KafkaTiming)?;
75        let heartbeat_interval = positive_ticks(self.heartbeat_interval)
76            .ok_or(ClassicGroupConfigError::HeartbeatInterval)?;
77        let heartbeat_attempt_timeout = positive_ticks(self.heartbeat_attempt_timeout)
78            .ok_or(ClassicGroupConfigError::HeartbeatAttemptTimeout)?;
79        let heartbeat =
80            ClassicHeartbeatPolicy::try_new(heartbeat_interval, heartbeat_attempt_timeout)
81                .map_err(|_error| ClassicGroupConfigError::Heartbeat)?;
82        let rejoin_backoff =
83            positive_ticks(self.rejoin_backoff).ok_or(ClassicGroupConfigError::RejoinBackoff)?;
84        let rejoin_attempt_timeout = positive_ticks(self.rejoin_attempt_timeout)
85            .ok_or(ClassicGroupConfigError::RejoinAttemptTimeout)?;
86        let rejoin = ClassicRejoinPolicy::try_new(rejoin_backoff, rejoin_attempt_timeout)
87            .map_err(|_error| ClassicGroupConfigError::Rejoin)?;
88        Ok(ValidatedClassicGroupConfig {
89            timing,
90            heartbeat,
91            rejoin,
92        })
93    }
94}
95
96impl Default for EngineClassicGroupConfig {
97    fn default() -> Self {
98        Self::new(
99            Duration::from_secs(10),
100            Duration::from_secs(30),
101            Duration::from_secs(3),
102            Duration::from_secs(10),
103            Duration::from_secs(1),
104            Duration::from_secs(30),
105        )
106    }
107}
108
109#[derive(Clone, Copy, Debug, Eq, PartialEq)]
110pub(crate) struct ValidatedClassicGroupConfig {
111    timing: ClassicGroupTiming,
112    heartbeat: ClassicHeartbeatPolicy,
113    rejoin: ClassicRejoinPolicy,
114}
115
116impl ValidatedClassicGroupConfig {
117    pub(crate) const fn timing(self) -> ClassicGroupTiming {
118        self.timing
119    }
120
121    pub(crate) const fn heartbeat(self) -> ClassicHeartbeatPolicy {
122        self.heartbeat
123    }
124
125    pub(crate) const fn rejoin(self) -> ClassicRejoinPolicy {
126        self.rejoin
127    }
128}
129
130impl Default for ValidatedClassicGroupConfig {
131    fn default() -> Self {
132        EngineClassicGroupConfig::default()
133            .validate()
134            .unwrap_or_else(|_error| unreachable!("fixed classic-group timing is valid"))
135    }
136}
137
138#[derive(Clone, Copy, Debug, Eq, PartialEq)]
139pub(crate) enum ClassicGroupConfigError {
140    SessionTimeout,
141    RebalanceTimeout,
142    KafkaTiming,
143    HeartbeatInterval,
144    HeartbeatAttemptTimeout,
145    Heartbeat,
146    RejoinBackoff,
147    RejoinAttemptTimeout,
148    Rejoin,
149}
150
151fn whole_positive_milliseconds(duration: Duration) -> Option<u64> {
152    if duration.is_zero() || duration.subsec_nanos() % 1_000_000 != 0 {
153        return None;
154    }
155    u64::try_from(duration.as_millis()).ok()
156}
157
158fn positive_ticks(duration: Duration) -> Option<u64> {
159    if duration.is_zero() {
160        return None;
161    }
162    u64::try_from(duration.as_nanos()).ok()
163}