kafka_protocol/messages/
join_group_response.rs

1//! JoinGroupResponse
2//!
3//! See the schema for this message [here](https://github.com/apache/kafka/blob/trunk/clients/src/main/resources/common/message/JoinGroupResponse.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-9
21#[non_exhaustive]
22#[derive(Debug, Clone, PartialEq)]
23pub struct JoinGroupResponse {
24    /// The duration in milliseconds for which the request was throttled due to a quota violation, or zero if the request did not violate any quota.
25    ///
26    /// Supported API versions: 2-9
27    pub throttle_time_ms: i32,
28
29    /// The error code, or 0 if there was no error.
30    ///
31    /// Supported API versions: 0-9
32    pub error_code: i16,
33
34    /// The generation ID of the group.
35    ///
36    /// Supported API versions: 0-9
37    pub generation_id: i32,
38
39    /// The group protocol name.
40    ///
41    /// Supported API versions: 7-9
42    pub protocol_type: Option<StrBytes>,
43
44    /// The group protocol selected by the coordinator.
45    ///
46    /// Supported API versions: 0-9
47    pub protocol_name: Option<StrBytes>,
48
49    /// The leader of the group.
50    ///
51    /// Supported API versions: 0-9
52    pub leader: StrBytes,
53
54    /// True if the leader must skip running the assignment.
55    ///
56    /// Supported API versions: 9
57    pub skip_assignment: bool,
58
59    /// The member ID assigned by the group coordinator.
60    ///
61    /// Supported API versions: 0-9
62    pub member_id: StrBytes,
63
64    ///
65    ///
66    /// Supported API versions: 0-9
67    pub members: Vec<JoinGroupResponseMember>,
68
69    /// Other tagged fields
70    pub unknown_tagged_fields: BTreeMap<i32, Bytes>,
71}
72
73impl JoinGroupResponse {
74    /// Sets `throttle_time_ms` to the passed value.
75    ///
76    /// The duration in milliseconds for which the request was throttled due to a quota violation, or zero if the request did not violate any quota.
77    ///
78    /// Supported API versions: 2-9
79    pub fn with_throttle_time_ms(mut self, value: i32) -> Self {
80        self.throttle_time_ms = value;
81        self
82    }
83    /// Sets `error_code` to the passed value.
84    ///
85    /// The error code, or 0 if there was no error.
86    ///
87    /// Supported API versions: 0-9
88    pub fn with_error_code(mut self, value: i16) -> Self {
89        self.error_code = value;
90        self
91    }
92    /// Sets `generation_id` to the passed value.
93    ///
94    /// The generation ID of the group.
95    ///
96    /// Supported API versions: 0-9
97    pub fn with_generation_id(mut self, value: i32) -> Self {
98        self.generation_id = value;
99        self
100    }
101    /// Sets `protocol_type` to the passed value.
102    ///
103    /// The group protocol name.
104    ///
105    /// Supported API versions: 7-9
106    pub fn with_protocol_type(mut self, value: Option<StrBytes>) -> Self {
107        self.protocol_type = value;
108        self
109    }
110    /// Sets `protocol_name` to the passed value.
111    ///
112    /// The group protocol selected by the coordinator.
113    ///
114    /// Supported API versions: 0-9
115    pub fn with_protocol_name(mut self, value: Option<StrBytes>) -> Self {
116        self.protocol_name = value;
117        self
118    }
119    /// Sets `leader` to the passed value.
120    ///
121    /// The leader of the group.
122    ///
123    /// Supported API versions: 0-9
124    pub fn with_leader(mut self, value: StrBytes) -> Self {
125        self.leader = value;
126        self
127    }
128    /// Sets `skip_assignment` to the passed value.
129    ///
130    /// True if the leader must skip running the assignment.
131    ///
132    /// Supported API versions: 9
133    pub fn with_skip_assignment(mut self, value: bool) -> Self {
134        self.skip_assignment = value;
135        self
136    }
137    /// Sets `member_id` to the passed value.
138    ///
139    /// The member ID assigned by the group coordinator.
140    ///
141    /// Supported API versions: 0-9
142    pub fn with_member_id(mut self, value: StrBytes) -> Self {
143        self.member_id = value;
144        self
145    }
146    /// Sets `members` to the passed value.
147    ///
148    ///
149    ///
150    /// Supported API versions: 0-9
151    pub fn with_members(mut self, value: Vec<JoinGroupResponseMember>) -> Self {
152        self.members = value;
153        self
154    }
155    /// Sets unknown_tagged_fields to the passed value.
156    pub fn with_unknown_tagged_fields(mut self, value: BTreeMap<i32, Bytes>) -> Self {
157        self.unknown_tagged_fields = value;
158        self
159    }
160    /// Inserts an entry into unknown_tagged_fields.
161    pub fn with_unknown_tagged_field(mut self, key: i32, value: Bytes) -> Self {
162        self.unknown_tagged_fields.insert(key, value);
163        self
164    }
165}
166
167#[cfg(feature = "broker")]
168impl Encodable for JoinGroupResponse {
169    fn encode<B: ByteBufMut>(&self, buf: &mut B, version: i16) -> Result<()> {
170        if version < 0 || version > 9 {
171            bail!("specified version not supported by this message type");
172        }
173        if version >= 2 {
174            types::Int32.encode(buf, &self.throttle_time_ms)?;
175        }
176        types::Int16.encode(buf, &self.error_code)?;
177        types::Int32.encode(buf, &self.generation_id)?;
178        if version >= 7 {
179            types::CompactString.encode(buf, &self.protocol_type)?;
180        }
181        if version >= 6 {
182            types::CompactString.encode(buf, &self.protocol_name)?;
183        } else {
184            types::String.encode(buf, &self.protocol_name)?;
185        }
186        if version >= 6 {
187            types::CompactString.encode(buf, &self.leader)?;
188        } else {
189            types::String.encode(buf, &self.leader)?;
190        }
191        if version >= 9 {
192            types::Boolean.encode(buf, &self.skip_assignment)?;
193        } else {
194            if self.skip_assignment {
195                bail!("A field is set that is not available on the selected protocol version");
196            }
197        }
198        if version >= 6 {
199            types::CompactString.encode(buf, &self.member_id)?;
200        } else {
201            types::String.encode(buf, &self.member_id)?;
202        }
203        if version >= 6 {
204            types::CompactArray(types::Struct { version }).encode(buf, &self.members)?;
205        } else {
206            types::Array(types::Struct { version }).encode(buf, &self.members)?;
207        }
208        if version >= 6 {
209            let num_tagged_fields = self.unknown_tagged_fields.len();
210            if num_tagged_fields > std::u32::MAX as usize {
211                bail!(
212                    "Too many tagged fields to encode ({} fields)",
213                    num_tagged_fields
214                );
215            }
216            types::UnsignedVarInt.encode(buf, num_tagged_fields as u32)?;
217
218            write_unknown_tagged_fields(buf, 0.., &self.unknown_tagged_fields)?;
219        }
220        Ok(())
221    }
222    fn compute_size(&self, version: i16) -> Result<usize> {
223        let mut total_size = 0;
224        if version >= 2 {
225            total_size += types::Int32.compute_size(&self.throttle_time_ms)?;
226        }
227        total_size += types::Int16.compute_size(&self.error_code)?;
228        total_size += types::Int32.compute_size(&self.generation_id)?;
229        if version >= 7 {
230            total_size += types::CompactString.compute_size(&self.protocol_type)?;
231        }
232        if version >= 6 {
233            total_size += types::CompactString.compute_size(&self.protocol_name)?;
234        } else {
235            total_size += types::String.compute_size(&self.protocol_name)?;
236        }
237        if version >= 6 {
238            total_size += types::CompactString.compute_size(&self.leader)?;
239        } else {
240            total_size += types::String.compute_size(&self.leader)?;
241        }
242        if version >= 9 {
243            total_size += types::Boolean.compute_size(&self.skip_assignment)?;
244        } else {
245            if self.skip_assignment {
246                bail!("A field is set that is not available on the selected protocol version");
247            }
248        }
249        if version >= 6 {
250            total_size += types::CompactString.compute_size(&self.member_id)?;
251        } else {
252            total_size += types::String.compute_size(&self.member_id)?;
253        }
254        if version >= 6 {
255            total_size +=
256                types::CompactArray(types::Struct { version }).compute_size(&self.members)?;
257        } else {
258            total_size += types::Array(types::Struct { version }).compute_size(&self.members)?;
259        }
260        if version >= 6 {
261            let num_tagged_fields = self.unknown_tagged_fields.len();
262            if num_tagged_fields > std::u32::MAX as usize {
263                bail!(
264                    "Too many tagged fields to encode ({} fields)",
265                    num_tagged_fields
266                );
267            }
268            total_size += types::UnsignedVarInt.compute_size(num_tagged_fields as u32)?;
269
270            total_size += compute_unknown_tagged_fields_size(&self.unknown_tagged_fields)?;
271        }
272        Ok(total_size)
273    }
274}
275
276#[cfg(feature = "client")]
277impl Decodable for JoinGroupResponse {
278    fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<Self> {
279        if version < 0 || version > 9 {
280            bail!("specified version not supported by this message type");
281        }
282        let throttle_time_ms = if version >= 2 {
283            types::Int32.decode(buf)?
284        } else {
285            0
286        };
287        let error_code = types::Int16.decode(buf)?;
288        let generation_id = types::Int32.decode(buf)?;
289        let protocol_type = if version >= 7 {
290            types::CompactString.decode(buf)?
291        } else {
292            None
293        };
294        let protocol_name = if version >= 6 {
295            types::CompactString.decode(buf)?
296        } else {
297            types::String.decode(buf)?
298        };
299        let leader = if version >= 6 {
300            types::CompactString.decode(buf)?
301        } else {
302            types::String.decode(buf)?
303        };
304        let skip_assignment = if version >= 9 {
305            types::Boolean.decode(buf)?
306        } else {
307            false
308        };
309        let member_id = if version >= 6 {
310            types::CompactString.decode(buf)?
311        } else {
312            types::String.decode(buf)?
313        };
314        let members = if version >= 6 {
315            types::CompactArray(types::Struct { version }).decode(buf)?
316        } else {
317            types::Array(types::Struct { version }).decode(buf)?
318        };
319        let mut unknown_tagged_fields = BTreeMap::new();
320        if version >= 6 {
321            let num_tagged_fields = types::UnsignedVarInt.decode(buf)?;
322            for _ in 0..num_tagged_fields {
323                let tag: u32 = types::UnsignedVarInt.decode(buf)?;
324                let size: u32 = types::UnsignedVarInt.decode(buf)?;
325                let unknown_value = buf.try_get_bytes(size as usize)?;
326                unknown_tagged_fields.insert(tag as i32, unknown_value);
327            }
328        }
329        Ok(Self {
330            throttle_time_ms,
331            error_code,
332            generation_id,
333            protocol_type,
334            protocol_name,
335            leader,
336            skip_assignment,
337            member_id,
338            members,
339            unknown_tagged_fields,
340        })
341    }
342}
343
344impl Default for JoinGroupResponse {
345    fn default() -> Self {
346        Self {
347            throttle_time_ms: 0,
348            error_code: 0,
349            generation_id: -1,
350            protocol_type: None,
351            protocol_name: Some(Default::default()),
352            leader: Default::default(),
353            skip_assignment: false,
354            member_id: Default::default(),
355            members: Default::default(),
356            unknown_tagged_fields: BTreeMap::new(),
357        }
358    }
359}
360
361impl Message for JoinGroupResponse {
362    const VERSIONS: VersionRange = VersionRange { min: 0, max: 9 };
363    const DEPRECATED_VERSIONS: Option<VersionRange> = None;
364}
365
366/// Valid versions: 0-9
367#[non_exhaustive]
368#[derive(Debug, Clone, PartialEq)]
369pub struct JoinGroupResponseMember {
370    /// The group member ID.
371    ///
372    /// Supported API versions: 0-9
373    pub member_id: StrBytes,
374
375    /// The unique identifier of the consumer instance provided by end user.
376    ///
377    /// Supported API versions: 5-9
378    pub group_instance_id: Option<StrBytes>,
379
380    /// The group member metadata.
381    ///
382    /// Supported API versions: 0-9
383    pub metadata: Bytes,
384
385    /// Other tagged fields
386    pub unknown_tagged_fields: BTreeMap<i32, Bytes>,
387}
388
389impl JoinGroupResponseMember {
390    /// Sets `member_id` to the passed value.
391    ///
392    /// The group member ID.
393    ///
394    /// Supported API versions: 0-9
395    pub fn with_member_id(mut self, value: StrBytes) -> Self {
396        self.member_id = value;
397        self
398    }
399    /// Sets `group_instance_id` to the passed value.
400    ///
401    /// The unique identifier of the consumer instance provided by end user.
402    ///
403    /// Supported API versions: 5-9
404    pub fn with_group_instance_id(mut self, value: Option<StrBytes>) -> Self {
405        self.group_instance_id = value;
406        self
407    }
408    /// Sets `metadata` to the passed value.
409    ///
410    /// The group member metadata.
411    ///
412    /// Supported API versions: 0-9
413    pub fn with_metadata(mut self, value: Bytes) -> Self {
414        self.metadata = value;
415        self
416    }
417    /// Sets unknown_tagged_fields to the passed value.
418    pub fn with_unknown_tagged_fields(mut self, value: BTreeMap<i32, Bytes>) -> Self {
419        self.unknown_tagged_fields = value;
420        self
421    }
422    /// Inserts an entry into unknown_tagged_fields.
423    pub fn with_unknown_tagged_field(mut self, key: i32, value: Bytes) -> Self {
424        self.unknown_tagged_fields.insert(key, value);
425        self
426    }
427}
428
429#[cfg(feature = "broker")]
430impl Encodable for JoinGroupResponseMember {
431    fn encode<B: ByteBufMut>(&self, buf: &mut B, version: i16) -> Result<()> {
432        if version < 0 || version > 9 {
433            bail!("specified version not supported by this message type");
434        }
435        if version >= 6 {
436            types::CompactString.encode(buf, &self.member_id)?;
437        } else {
438            types::String.encode(buf, &self.member_id)?;
439        }
440        if version >= 5 {
441            if version >= 6 {
442                types::CompactString.encode(buf, &self.group_instance_id)?;
443            } else {
444                types::String.encode(buf, &self.group_instance_id)?;
445            }
446        }
447        if version >= 6 {
448            types::CompactBytes.encode(buf, &self.metadata)?;
449        } else {
450            types::Bytes.encode(buf, &self.metadata)?;
451        }
452        if version >= 6 {
453            let num_tagged_fields = self.unknown_tagged_fields.len();
454            if num_tagged_fields > std::u32::MAX as usize {
455                bail!(
456                    "Too many tagged fields to encode ({} fields)",
457                    num_tagged_fields
458                );
459            }
460            types::UnsignedVarInt.encode(buf, num_tagged_fields as u32)?;
461
462            write_unknown_tagged_fields(buf, 0.., &self.unknown_tagged_fields)?;
463        }
464        Ok(())
465    }
466    fn compute_size(&self, version: i16) -> Result<usize> {
467        let mut total_size = 0;
468        if version >= 6 {
469            total_size += types::CompactString.compute_size(&self.member_id)?;
470        } else {
471            total_size += types::String.compute_size(&self.member_id)?;
472        }
473        if version >= 5 {
474            if version >= 6 {
475                total_size += types::CompactString.compute_size(&self.group_instance_id)?;
476            } else {
477                total_size += types::String.compute_size(&self.group_instance_id)?;
478            }
479        }
480        if version >= 6 {
481            total_size += types::CompactBytes.compute_size(&self.metadata)?;
482        } else {
483            total_size += types::Bytes.compute_size(&self.metadata)?;
484        }
485        if version >= 6 {
486            let num_tagged_fields = self.unknown_tagged_fields.len();
487            if num_tagged_fields > std::u32::MAX as usize {
488                bail!(
489                    "Too many tagged fields to encode ({} fields)",
490                    num_tagged_fields
491                );
492            }
493            total_size += types::UnsignedVarInt.compute_size(num_tagged_fields as u32)?;
494
495            total_size += compute_unknown_tagged_fields_size(&self.unknown_tagged_fields)?;
496        }
497        Ok(total_size)
498    }
499}
500
501#[cfg(feature = "client")]
502impl Decodable for JoinGroupResponseMember {
503    fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<Self> {
504        if version < 0 || version > 9 {
505            bail!("specified version not supported by this message type");
506        }
507        let member_id = if version >= 6 {
508            types::CompactString.decode(buf)?
509        } else {
510            types::String.decode(buf)?
511        };
512        let group_instance_id = if version >= 5 {
513            if version >= 6 {
514                types::CompactString.decode(buf)?
515            } else {
516                types::String.decode(buf)?
517            }
518        } else {
519            None
520        };
521        let metadata = if version >= 6 {
522            types::CompactBytes.decode(buf)?
523        } else {
524            types::Bytes.decode(buf)?
525        };
526        let mut unknown_tagged_fields = BTreeMap::new();
527        if version >= 6 {
528            let num_tagged_fields = types::UnsignedVarInt.decode(buf)?;
529            for _ in 0..num_tagged_fields {
530                let tag: u32 = types::UnsignedVarInt.decode(buf)?;
531                let size: u32 = types::UnsignedVarInt.decode(buf)?;
532                let unknown_value = buf.try_get_bytes(size as usize)?;
533                unknown_tagged_fields.insert(tag as i32, unknown_value);
534            }
535        }
536        Ok(Self {
537            member_id,
538            group_instance_id,
539            metadata,
540            unknown_tagged_fields,
541        })
542    }
543}
544
545impl Default for JoinGroupResponseMember {
546    fn default() -> Self {
547        Self {
548            member_id: Default::default(),
549            group_instance_id: None,
550            metadata: Default::default(),
551            unknown_tagged_fields: BTreeMap::new(),
552        }
553    }
554}
555
556impl Message for JoinGroupResponseMember {
557    const VERSIONS: VersionRange = VersionRange { min: 0, max: 9 };
558    const DEPRECATED_VERSIONS: Option<VersionRange> = None;
559}
560
561impl HeaderVersion for JoinGroupResponse {
562    fn header_version(version: i16) -> i16 {
563        if version >= 6 {
564            1
565        } else {
566            0
567        }
568    }
569}
kafka_protocol/messages/join_group_response.rs

kafka_protocol/messages/
join_group_response.rs
