kafka_client_engine/config/
classic_group_config.rs1use std::time::Duration;
4
5use kafka_client_core::{ClassicGroupTiming, ClassicHeartbeatPolicy, ClassicRejoinPolicy};
6
7#[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 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 pub const fn session_timeout(self) -> Duration {
40 self.session_timeout
41 }
42
43 pub const fn rebalance_timeout(self) -> Duration {
45 self.rebalance_timeout
46 }
47
48 pub const fn heartbeat_interval(self) -> Duration {
50 self.heartbeat_interval
51 }
52
53 pub const fn heartbeat_attempt_timeout(self) -> Duration {
55 self.heartbeat_attempt_timeout
56 }
57
58 pub const fn rejoin_backoff(self) -> Duration {
60 self.rejoin_backoff
61 }
62
63 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}