krabka_protocol/opt/rustwide/workdir/generated/
BrokerHeartbeatRequest.owned.rs

1// AUTO-GENERATED by krabka-protocol-codegen against a9ce3221537b8653448750697915607dc7936cf3. Do not edit.
2
3use bytes::{Buf, BufMut};
4
5use crate::{
6    Decode, Encode, ProtocolError, UnknownTaggedFields,
7    codegen_helpers::is_default,
8    primitives::{
9        array::{
10            array_len_prefix_len, get_array_len, get_nullable_array_len,
11            nullable_array_len_prefix_len, put_array_len, put_nullable_array_len,
12        },
13        fixed::{get_bool, get_i32, get_i64, put_bool, put_i32, put_i64},
14        uuid::{Uuid, get_uuid, put_uuid},
15    },
16    tagged_fields::{WriteTaggedFields, encode_to_bytes, read_tagged_fields, tagged_fields_len},
17};
18pub const API_KEY: i16 = 63;
19pub const MIN_VERSION: i16 = 0;
20pub const MAX_VERSION: i16 = 2;
21pub const LATEST_STABLE_VERSION: i16 = 2;
22pub const FLEXIBLE_MIN: i16 = 0;
23#[inline]
24#[must_use]
25pub fn is_flexible(version: i16) -> bool {
26    version >= FLEXIBLE_MIN
27}
28#[derive(Debug, Clone, PartialEq, Eq)]
29pub struct BrokerHeartbeatRequest {
30    pub broker_id: i32,
31    pub broker_epoch: i64,
32    pub current_metadata_offset: i64,
33    pub want_fence: bool,
34    pub want_shut_down: bool,
35    pub offline_log_dirs: Vec<Uuid>,
36    pub cordoned_log_dirs: Option<Vec<Uuid>>,
37    pub unknown_tagged_fields: UnknownTaggedFields,
38}
39impl Default for BrokerHeartbeatRequest {
40    fn default() -> Self {
41        Self {
42            broker_id: 0i32,
43            broker_epoch: -1i64,
44            current_metadata_offset: 0i64,
45            want_fence: false,
46            want_shut_down: false,
47            offline_log_dirs: Vec::new(),
48            cordoned_log_dirs: None,
49            unknown_tagged_fields: UnknownTaggedFields::default(),
50        }
51    }
52}
53impl Encode for BrokerHeartbeatRequest {
54    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
55        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
56            return Err(ProtocolError::UnsupportedVersion {
57                api_key: API_KEY,
58                version,
59            });
60        }
61        let flex = is_flexible(version);
62        if version >= 0 {
63            put_i32(buf, self.broker_id);
64        }
65        if version >= 0 {
66            put_i64(buf, self.broker_epoch);
67        }
68        if version >= 0 {
69            put_i64(buf, self.current_metadata_offset);
70        }
71        if version >= 0 {
72            put_bool(buf, self.want_fence);
73        }
74        if version >= 0 {
75            put_bool(buf, self.want_shut_down);
76        }
77        if flex {
78            let mut tagged = WriteTaggedFields::new();
79            if version >= 1 && !(is_default(&self.offline_log_dirs)) {
80                let payload = encode_to_bytes(
81                    {
82                        let prefix = array_len_prefix_len((self.offline_log_dirs).len(), flex);
83                        let body: usize = (self.offline_log_dirs).iter().map(|_| 16).sum();
84                        prefix + body
85                    },
86                    |b| {
87                        {
88                            put_array_len(b, (self.offline_log_dirs).len(), flex)?;
89                            for it in &self.offline_log_dirs {
90                                put_uuid(b, *it);
91                            }
92                        }
93                        Ok(())
94                    },
95                )?;
96                tagged.add(0, payload);
97            }
98            if version >= 2 && self.cordoned_log_dirs.is_some() {
99                let payload = encode_to_bytes(
100                    {
101                        let opt: Option<&Vec<_>> = (self.cordoned_log_dirs).as_ref();
102                        let prefix = nullable_array_len_prefix_len(opt.map(Vec::len), flex);
103                        let body: usize = opt.map_or(0, |v| v.iter().map(|_| 16).sum());
104                        prefix + body
105                    },
106                    |b| {
107                        {
108                            let len = (self.cordoned_log_dirs).as_ref().map(Vec::len);
109                            put_nullable_array_len(b, len, flex)?;
110                            if let Some(v) = &self.cordoned_log_dirs {
111                                for it in v {
112                                    put_uuid(b, *it);
113                                }
114                            }
115                        }
116                        Ok(())
117                    },
118                )?;
119                tagged.add(1, payload);
120            }
121            tagged.write(buf, &self.unknown_tagged_fields)?;
122        }
123        Ok(())
124    }
125    fn encoded_len(&self, version: i16) -> usize {
126        let flex = is_flexible(version);
127        let mut n: usize = 0;
128        if version >= 0 {
129            n += 4;
130        }
131        if version >= 0 {
132            n += 8;
133        }
134        if version >= 0 {
135            n += 8;
136        }
137        if version >= 0 {
138            n += 1;
139        }
140        if version >= 0 {
141            n += 1;
142        }
143        if flex {
144            let mut known_pairs: Vec<(u32, usize)> = Vec::new();
145            if version >= 1 && !(is_default(&self.offline_log_dirs)) {
146                known_pairs.push((0, {
147                    let prefix = array_len_prefix_len((self.offline_log_dirs).len(), flex);
148                    let body: usize = (self.offline_log_dirs).iter().map(|_| 16).sum();
149                    prefix + body
150                }));
151            }
152            if version >= 2 && self.cordoned_log_dirs.is_some() {
153                known_pairs.push((1, {
154                    let opt: Option<&Vec<_>> = (self.cordoned_log_dirs).as_ref();
155                    let prefix = nullable_array_len_prefix_len(opt.map(Vec::len), flex);
156                    let body: usize = opt.map_or(0, |v| v.iter().map(|_| 16).sum());
157                    prefix + body
158                }));
159            }
160            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
161        }
162        n
163    }
164}
165impl Decode<'_> for BrokerHeartbeatRequest {
166    fn decode<B: Buf>(buf: &mut B, version: i16) -> Result<Self, ProtocolError> {
167        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
168            return Err(ProtocolError::UnsupportedVersion {
169                api_key: API_KEY,
170                version,
171            });
172        }
173        let flex = is_flexible(version);
174        let mut out = Self::default();
175        if version >= 0 {
176            out.broker_id = get_i32(buf)?;
177        }
178        if version >= 0 {
179            out.broker_epoch = get_i64(buf)?;
180        }
181        if version >= 0 {
182            out.current_metadata_offset = get_i64(buf)?;
183        }
184        if version >= 0 {
185            out.want_fence = get_bool(buf)?;
186        }
187        if version >= 0 {
188            out.want_shut_down = get_bool(buf)?;
189        }
190        if flex {
191            let mut tag_offline_log_dirs = None;
192            let mut tag_cordoned_log_dirs = None;
193            out.unknown_tagged_fields = read_tagged_fields(buf, |tag, payload| match tag {
194                0 if version >= 1 => {
195                    tag_offline_log_dirs = Some({
196                        let b: &mut &[u8] = payload;
197                        {
198                            let n = get_array_len(b, flex)?;
199                            let mut v = Vec::with_capacity(n);
200                            for _ in 0..n {
201                                v.push(get_uuid(b)?);
202                            }
203                            v
204                        }
205                    });
206                    Ok(true)
207                }
208                0 => Err(ProtocolError::TagNotValidForVersion { tag: 0, version }),
209                1 if version >= 2 => {
210                    tag_cordoned_log_dirs = Some({
211                        let b: &mut &[u8] = payload;
212                        {
213                            let opt = get_nullable_array_len(b, flex)?;
214                            match opt {
215                                None => None,
216                                Some(n) => {
217                                    let mut v = Vec::with_capacity(n);
218                                    for _ in 0..n {
219                                        v.push(get_uuid(b)?);
220                                    }
221                                    Some(v)
222                                }
223                            }
224                        }
225                    });
226                    Ok(true)
227                }
228                1 => Err(ProtocolError::TagNotValidForVersion { tag: 1, version }),
229                _ => Ok(false),
230            })?;
231            if let Some(v) = tag_offline_log_dirs {
232                out.offline_log_dirs = v;
233            }
234            if let Some(v) = tag_cordoned_log_dirs {
235                out.cordoned_log_dirs = v;
236            }
237        }
238        Ok(out)
239    }
240}
241#[cfg(test)]
242impl BrokerHeartbeatRequest {
243    #[must_use]
244    pub fn populated(version: i16) -> Self {
245        let mut m = Self::default();
246        if version >= 0 {
247            m.broker_id = 1i32;
248        }
249        if version >= 0 {
250            m.broker_epoch = 1i64;
251        }
252        if version >= 0 {
253            m.current_metadata_offset = 1i64;
254        }
255        if version >= 0 {
256            m.want_fence = true;
257        }
258        if version >= 0 {
259            m.want_shut_down = true;
260        }
261        if version >= 1 {
262            m.offline_log_dirs = vec![Uuid([1u8; 16])];
263        }
264        if version >= 2 {
265            m.cordoned_log_dirs = Some(vec![Uuid([1u8; 16])]);
266        }
267        m
268    }
269}
270/// Default JSON payload matching `Self::default()` for JVM oracle differential testing.
271/// Only includes fields valid for the given version.
272#[must_use]
273#[allow(unused_comparisons)]
274pub fn default_json(version: i16) -> ::serde_json::Value {
275    let mut obj = ::serde_json::Map::new();
276    obj.insert("brokerId".to_owned(), ::serde_json::json!(0));
277    obj.insert("brokerEpoch".to_owned(), ::serde_json::json!(-1));
278    obj.insert("currentMetadataOffset".to_owned(), ::serde_json::json!(0));
279    obj.insert("wantFence".to_owned(), ::serde_json::Value::Bool(false));
280    obj.insert("wantShutDown".to_owned(), ::serde_json::Value::Bool(false));
281    if version >= 1 {
282        obj.insert(
283            "offlineLogDirs".to_owned(),
284            ::serde_json::Value::Array(vec![]),
285        );
286    }
287    if version >= 2 {
288        obj.insert("cordonedLogDirs".to_owned(), ::serde_json::Value::Null);
289    }
290    ::serde_json::Value::Object(obj)
291}
292/// A message with a non-default value in every tagged field, at every depth, for
293/// the JVM oracle differential sweep. The value is the same at every version.
294#[must_use]
295pub fn tagged_fixture() -> BrokerHeartbeatRequest {
296    BrokerHeartbeatRequest {
297        offline_log_dirs: vec![Uuid([1u8; 16])],
298        cordoned_log_dirs: Some(vec![Uuid([1u8; 16])]),
299        ..BrokerHeartbeatRequest::default()
300    }
301}
302/// The JSON form of `tagged_fixture()` that Kafka's JSON converter reads at
303/// `version`. It holds only the fields that the schema declares at that version.
304#[must_use]
305pub fn tagged_fixture_json(version: i16) -> ::serde_json::Value {
306    let mut m = ::serde_json::Map::new();
307    m.insert("brokerId".to_owned(), ::serde_json::json!(0));
308    m.insert("brokerEpoch".to_owned(), ::serde_json::json!(-1));
309    m.insert("currentMetadataOffset".to_owned(), ::serde_json::json!(0));
310    m.insert("wantFence".to_owned(), ::serde_json::Value::Bool(false));
311    m.insert("wantShutDown".to_owned(), ::serde_json::Value::Bool(false));
312    if version >= 1 {
313        m.insert(
314            "offlineLogDirs".to_owned(),
315            ::serde_json::Value::Array(vec![::serde_json::Value::String(
316                "AQEBAQEBAQEBAQEBAQEBAQ".to_owned(),
317            )]),
318        );
319    }
320    if version == 2 {
321        m.insert(
322            "cordonedLogDirs".to_owned(),
323            ::serde_json::Value::Array(vec![::serde_json::Value::String(
324                "AQEBAQEBAQEBAQEBAQEBAQ".to_owned(),
325            )]),
326        );
327    }
328    ::serde_json::Value::Object(m)
329}
330impl crate::ProtocolRequest for BrokerHeartbeatRequest {
331    const API_KEY: i16 = API_KEY;
332    const MIN_VERSION: i16 = MIN_VERSION;
333    const MAX_VERSION: i16 = MAX_VERSION;
334    const LATEST_STABLE_VERSION: i16 = LATEST_STABLE_VERSION;
335    const FLEXIBLE_MIN: i16 = FLEXIBLE_MIN;
336    type Response = super::broker_heartbeat_response::BrokerHeartbeatResponse;
337}
krabka_protocol/opt/rustwide/workdir/generated/BrokerHeartbeatRequest.owned.rs

krabka_protocol/opt/rustwide/workdir/generated/
BrokerHeartbeatRequest.owned.rs
