kafka_protocol/messages/
leave_group_request.rs

1//! LeaveGroupRequest
2//!
3//! See the schema for this message [here](https://github.com/apache/kafka/blob/trunk/clients/src/main/resources/common/message/LeaveGroupRequest.json).
4// WARNING: the items of this module are generated and should not be edited directly
5#![allow(unused)]
6
7use std::borrow::Borrow;
8use std::collections::BTreeMap;
9
10use anyhow::{bail, Result};
11use bytes::Bytes;
12use uuid::Uuid;
13
14use crate::protocol::{
15    buf::{ByteBuf, ByteBufMut},
16    compute_unknown_tagged_fields_size, types, write_unknown_tagged_fields, Decodable, Decoder,
17    Encodable, Encoder, HeaderVersion, Message, StrBytes, VersionRange,
18};
19
20/// Valid versions: 0-5
21#[non_exhaustive]
22#[derive(Debug, Clone, PartialEq)]
23pub struct LeaveGroupRequest {
24    /// The ID of the group to leave.
25    ///
26    /// Supported API versions: 0-5
27    pub group_id: super::GroupId,
28
29    /// The member ID to remove from the group.
30    ///
31    /// Supported API versions: 0-2
32    pub member_id: StrBytes,
33
34    /// List of leaving member identities.
35    ///
36    /// Supported API versions: 3-5
37    pub members: Vec<MemberIdentity>,
38
39    /// Other tagged fields
40    pub unknown_tagged_fields: BTreeMap<i32, Bytes>,
41}
42
43impl LeaveGroupRequest {
44    /// Sets `group_id` to the passed value.
45    ///
46    /// The ID of the group to leave.
47    ///
48    /// Supported API versions: 0-5
49    pub fn with_group_id(mut self, value: super::GroupId) -> Self {
50        self.group_id = value;
51        self
52    }
53    /// Sets `member_id` to the passed value.
54    ///
55    /// The member ID to remove from the group.
56    ///
57    /// Supported API versions: 0-2
58    pub fn with_member_id(mut self, value: StrBytes) -> Self {
59        self.member_id = value;
60        self
61    }
62    /// Sets `members` to the passed value.
63    ///
64    /// List of leaving member identities.
65    ///
66    /// Supported API versions: 3-5
67    pub fn with_members(mut self, value: Vec<MemberIdentity>) -> Self {
68        self.members = value;
69        self
70    }
71    /// Sets unknown_tagged_fields to the passed value.
72    pub fn with_unknown_tagged_fields(mut self, value: BTreeMap<i32, Bytes>) -> Self {
73        self.unknown_tagged_fields = value;
74        self
75    }
76    /// Inserts an entry into unknown_tagged_fields.
77    pub fn with_unknown_tagged_field(mut self, key: i32, value: Bytes) -> Self {
78        self.unknown_tagged_fields.insert(key, value);
79        self
80    }
81}
82
83#[cfg(feature = "client")]
84impl Encodable for LeaveGroupRequest {
85    fn encode<B: ByteBufMut>(&self, buf: &mut B, version: i16) -> Result<()> {
86        if version < 0 || version > 5 {
87            bail!("specified version not supported by this message type");
88        }
89        if version >= 4 {
90            types::CompactString.encode(buf, &self.group_id)?;
91        } else {
92            types::String.encode(buf, &self.group_id)?;
93        }
94        if version <= 2 {
95            types::String.encode(buf, &self.member_id)?;
96        } else {
97            if !self.member_id.is_empty() {
98                bail!("A field is set that is not available on the selected protocol version");
99            }
100        }
101        if version >= 3 {
102            if version >= 4 {
103                types::CompactArray(types::Struct { version }).encode(buf, &self.members)?;
104            } else {
105                types::Array(types::Struct { version }).encode(buf, &self.members)?;
106            }
107        } else {
108            if !self.members.is_empty() {
109                bail!("A field is set that is not available on the selected protocol version");
110            }
111        }
112        if version >= 4 {
113            let num_tagged_fields = self.unknown_tagged_fields.len();
114            if num_tagged_fields > std::u32::MAX as usize {
115                bail!(
116                    "Too many tagged fields to encode ({} fields)",
117                    num_tagged_fields
118                );
119            }
120            types::UnsignedVarInt.encode(buf, num_tagged_fields as u32)?;
121
122            write_unknown_tagged_fields(buf, 0.., &self.unknown_tagged_fields)?;
123        }
124        Ok(())
125    }
126    fn compute_size(&self, version: i16) -> Result<usize> {
127        let mut total_size = 0;
128        if version >= 4 {
129            total_size += types::CompactString.compute_size(&self.group_id)?;
130        } else {
131            total_size += types::String.compute_size(&self.group_id)?;
132        }
133        if version <= 2 {
134            total_size += types::String.compute_size(&self.member_id)?;
135        } else {
136            if !self.member_id.is_empty() {
137                bail!("A field is set that is not available on the selected protocol version");
138            }
139        }
140        if version >= 3 {
141            if version >= 4 {
142                total_size +=
143                    types::CompactArray(types::Struct { version }).compute_size(&self.members)?;
144            } else {
145                total_size +=
146                    types::Array(types::Struct { version }).compute_size(&self.members)?;
147            }
148        } else {
149            if !self.members.is_empty() {
150                bail!("A field is set that is not available on the selected protocol version");
151            }
152        }
153        if version >= 4 {
154            let num_tagged_fields = self.unknown_tagged_fields.len();
155            if num_tagged_fields > std::u32::MAX as usize {
156                bail!(
157                    "Too many tagged fields to encode ({} fields)",
158                    num_tagged_fields
159                );
160            }
161            total_size += types::UnsignedVarInt.compute_size(num_tagged_fields as u32)?;
162
163            total_size += compute_unknown_tagged_fields_size(&self.unknown_tagged_fields)?;
164        }
165        Ok(total_size)
166    }
167}
168
169#[cfg(feature = "broker")]
170impl Decodable for LeaveGroupRequest {
171    fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<Self> {
172        if version < 0 || version > 5 {
173            bail!("specified version not supported by this message type");
174        }
175        let group_id = if version >= 4 {
176            types::CompactString.decode(buf)?
177        } else {
178            types::String.decode(buf)?
179        };
180        let member_id = if version <= 2 {
181            types::String.decode(buf)?
182        } else {
183            Default::default()
184        };
185        let members = if version >= 3 {
186            if version >= 4 {
187                types::CompactArray(types::Struct { version }).decode(buf)?
188            } else {
189                types::Array(types::Struct { version }).decode(buf)?
190            }
191        } else {
192            Default::default()
193        };
194        let mut unknown_tagged_fields = BTreeMap::new();
195        if version >= 4 {
196            let num_tagged_fields = types::UnsignedVarInt.decode(buf)?;
197            for _ in 0..num_tagged_fields {
198                let tag: u32 = types::UnsignedVarInt.decode(buf)?;
199                let size: u32 = types::UnsignedVarInt.decode(buf)?;
200                let unknown_value = buf.try_get_bytes(size as usize)?;
201                unknown_tagged_fields.insert(tag as i32, unknown_value);
202            }
203        }
204        Ok(Self {
205            group_id,
206            member_id,
207            members,
208            unknown_tagged_fields,
209        })
210    }
211}
212
213impl Default for LeaveGroupRequest {
214    fn default() -> Self {
215        Self {
216            group_id: Default::default(),
217            member_id: Default::default(),
218            members: Default::default(),
219            unknown_tagged_fields: BTreeMap::new(),
220        }
221    }
222}
223
224impl Message for LeaveGroupRequest {
225    const VERSIONS: VersionRange = VersionRange { min: 0, max: 5 };
226    const DEPRECATED_VERSIONS: Option<VersionRange> = None;
227}
228
229/// Valid versions: 0-5
230#[non_exhaustive]
231#[derive(Debug, Clone, PartialEq)]
232pub struct MemberIdentity {
233    /// The member ID to remove from the group.
234    ///
235    /// Supported API versions: 3-5
236    pub member_id: StrBytes,
237
238    /// The group instance ID to remove from the group.
239    ///
240    /// Supported API versions: 3-5
241    pub group_instance_id: Option<StrBytes>,
242
243    /// The reason why the member left the group.
244    ///
245    /// Supported API versions: 5
246    pub reason: Option<StrBytes>,
247
248    /// Other tagged fields
249    pub unknown_tagged_fields: BTreeMap<i32, Bytes>,
250}
251
252impl MemberIdentity {
253    /// Sets `member_id` to the passed value.
254    ///
255    /// The member ID to remove from the group.
256    ///
257    /// Supported API versions: 3-5
258    pub fn with_member_id(mut self, value: StrBytes) -> Self {
259        self.member_id = value;
260        self
261    }
262    /// Sets `group_instance_id` to the passed value.
263    ///
264    /// The group instance ID to remove from the group.
265    ///
266    /// Supported API versions: 3-5
267    pub fn with_group_instance_id(mut self, value: Option<StrBytes>) -> Self {
268        self.group_instance_id = value;
269        self
270    }
271    /// Sets `reason` to the passed value.
272    ///
273    /// The reason why the member left the group.
274    ///
275    /// Supported API versions: 5
276    pub fn with_reason(mut self, value: Option<StrBytes>) -> Self {
277        self.reason = value;
278        self
279    }
280    /// Sets unknown_tagged_fields to the passed value.
281    pub fn with_unknown_tagged_fields(mut self, value: BTreeMap<i32, Bytes>) -> Self {
282        self.unknown_tagged_fields = value;
283        self
284    }
285    /// Inserts an entry into unknown_tagged_fields.
286    pub fn with_unknown_tagged_field(mut self, key: i32, value: Bytes) -> Self {
287        self.unknown_tagged_fields.insert(key, value);
288        self
289    }
290}
291
292#[cfg(feature = "client")]
293impl Encodable for MemberIdentity {
294    fn encode<B: ByteBufMut>(&self, buf: &mut B, version: i16) -> Result<()> {
295        if version < 0 || version > 5 {
296            bail!("specified version not supported by this message type");
297        }
298        if version >= 3 {
299            if version >= 4 {
300                types::CompactString.encode(buf, &self.member_id)?;
301            } else {
302                types::String.encode(buf, &self.member_id)?;
303            }
304        } else {
305            if !self.member_id.is_empty() {
306                bail!("A field is set that is not available on the selected protocol version");
307            }
308        }
309        if version >= 3 {
310            if version >= 4 {
311                types::CompactString.encode(buf, &self.group_instance_id)?;
312            } else {
313                types::String.encode(buf, &self.group_instance_id)?;
314            }
315        } else {
316            if !self.group_instance_id.is_none() {
317                bail!("A field is set that is not available on the selected protocol version");
318            }
319        }
320        if version >= 5 {
321            types::CompactString.encode(buf, &self.reason)?;
322        }
323        if version >= 4 {
324            let num_tagged_fields = self.unknown_tagged_fields.len();
325            if num_tagged_fields > std::u32::MAX as usize {
326                bail!(
327                    "Too many tagged fields to encode ({} fields)",
328                    num_tagged_fields
329                );
330            }
331            types::UnsignedVarInt.encode(buf, num_tagged_fields as u32)?;
332
333            write_unknown_tagged_fields(buf, 0.., &self.unknown_tagged_fields)?;
334        }
335        Ok(())
336    }
337    fn compute_size(&self, version: i16) -> Result<usize> {
338        let mut total_size = 0;
339        if version >= 3 {
340            if version >= 4 {
341                total_size += types::CompactString.compute_size(&self.member_id)?;
342            } else {
343                total_size += types::String.compute_size(&self.member_id)?;
344            }
345        } else {
346            if !self.member_id.is_empty() {
347                bail!("A field is set that is not available on the selected protocol version");
348            }
349        }
350        if version >= 3 {
351            if version >= 4 {
352                total_size += types::CompactString.compute_size(&self.group_instance_id)?;
353            } else {
354                total_size += types::String.compute_size(&self.group_instance_id)?;
355            }
356        } else {
357            if !self.group_instance_id.is_none() {
358                bail!("A field is set that is not available on the selected protocol version");
359            }
360        }
361        if version >= 5 {
362            total_size += types::CompactString.compute_size(&self.reason)?;
363        }
364        if version >= 4 {
365            let num_tagged_fields = self.unknown_tagged_fields.len();
366            if num_tagged_fields > std::u32::MAX as usize {
367                bail!(
368                    "Too many tagged fields to encode ({} fields)",
369                    num_tagged_fields
370                );
371            }
372            total_size += types::UnsignedVarInt.compute_size(num_tagged_fields as u32)?;
373
374            total_size += compute_unknown_tagged_fields_size(&self.unknown_tagged_fields)?;
375        }
376        Ok(total_size)
377    }
378}
379
380#[cfg(feature = "broker")]
381impl Decodable for MemberIdentity {
382    fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<Self> {
383        if version < 0 || version > 5 {
384            bail!("specified version not supported by this message type");
385        }
386        let member_id = if version >= 3 {
387            if version >= 4 {
388                types::CompactString.decode(buf)?
389            } else {
390                types::String.decode(buf)?
391            }
392        } else {
393            Default::default()
394        };
395        let group_instance_id = if version >= 3 {
396            if version >= 4 {
397                types::CompactString.decode(buf)?
398            } else {
399                types::String.decode(buf)?
400            }
401        } else {
402            None
403        };
404        let reason = if version >= 5 {
405            types::CompactString.decode(buf)?
406        } else {
407            None
408        };
409        let mut unknown_tagged_fields = BTreeMap::new();
410        if version >= 4 {
411            let num_tagged_fields = types::UnsignedVarInt.decode(buf)?;
412            for _ in 0..num_tagged_fields {
413                let tag: u32 = types::UnsignedVarInt.decode(buf)?;
414                let size: u32 = types::UnsignedVarInt.decode(buf)?;
415                let unknown_value = buf.try_get_bytes(size as usize)?;
416                unknown_tagged_fields.insert(tag as i32, unknown_value);
417            }
418        }
419        Ok(Self {
420            member_id,
421            group_instance_id,
422            reason,
423            unknown_tagged_fields,
424        })
425    }
426}
427
428impl Default for MemberIdentity {
429    fn default() -> Self {
430        Self {
431            member_id: Default::default(),
432            group_instance_id: None,
433            reason: None,
434            unknown_tagged_fields: BTreeMap::new(),
435        }
436    }
437}
438
439impl Message for MemberIdentity {
440    const VERSIONS: VersionRange = VersionRange { min: 0, max: 5 };
441    const DEPRECATED_VERSIONS: Option<VersionRange> = None;
442}
443
444impl HeaderVersion for LeaveGroupRequest {
445    fn header_version(version: i16) -> i16 {
446        if version >= 4 {
447            2
448        } else {
449            1
450        }
451    }
452}
kafka_protocol/messages/leave_group_request.rs

kafka_protocol/messages/
leave_group_request.rs
