kafka_protocol/messages/
alter_configs_request.rs

1//! AlterConfigsRequest
2//!
3//! See the schema for this message [here](https://github.com/apache/kafka/blob/trunk/clients/src/main/resources/common/message/AlterConfigsRequest.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-2
21#[non_exhaustive]
22#[derive(Debug, Clone, PartialEq)]
23pub struct AlterConfigsRequest {
24    /// The updates for each resource.
25    ///
26    /// Supported API versions: 0-2
27    pub resources: Vec<AlterConfigsResource>,
28
29    /// True if we should validate the request, but not change the configurations.
30    ///
31    /// Supported API versions: 0-2
32    pub validate_only: bool,
33
34    /// Other tagged fields
35    pub unknown_tagged_fields: BTreeMap<i32, Bytes>,
36}
37
38impl AlterConfigsRequest {
39    /// Sets `resources` to the passed value.
40    ///
41    /// The updates for each resource.
42    ///
43    /// Supported API versions: 0-2
44    pub fn with_resources(mut self, value: Vec<AlterConfigsResource>) -> Self {
45        self.resources = value;
46        self
47    }
48    /// Sets `validate_only` to the passed value.
49    ///
50    /// True if we should validate the request, but not change the configurations.
51    ///
52    /// Supported API versions: 0-2
53    pub fn with_validate_only(mut self, value: bool) -> Self {
54        self.validate_only = value;
55        self
56    }
57    /// Sets unknown_tagged_fields to the passed value.
58    pub fn with_unknown_tagged_fields(mut self, value: BTreeMap<i32, Bytes>) -> Self {
59        self.unknown_tagged_fields = value;
60        self
61    }
62    /// Inserts an entry into unknown_tagged_fields.
63    pub fn with_unknown_tagged_field(mut self, key: i32, value: Bytes) -> Self {
64        self.unknown_tagged_fields.insert(key, value);
65        self
66    }
67}
68
69#[cfg(feature = "client")]
70impl Encodable for AlterConfigsRequest {
71    fn encode<B: ByteBufMut>(&self, buf: &mut B, version: i16) -> Result<()> {
72        if version >= 2 {
73            types::CompactArray(types::Struct { version }).encode(buf, &self.resources)?;
74        } else {
75            types::Array(types::Struct { version }).encode(buf, &self.resources)?;
76        }
77        types::Boolean.encode(buf, &self.validate_only)?;
78        if version >= 2 {
79            let num_tagged_fields = self.unknown_tagged_fields.len();
80            if num_tagged_fields > std::u32::MAX as usize {
81                bail!(
82                    "Too many tagged fields to encode ({} fields)",
83                    num_tagged_fields
84                );
85            }
86            types::UnsignedVarInt.encode(buf, num_tagged_fields as u32)?;
87
88            write_unknown_tagged_fields(buf, 0.., &self.unknown_tagged_fields)?;
89        }
90        Ok(())
91    }
92    fn compute_size(&self, version: i16) -> Result<usize> {
93        let mut total_size = 0;
94        if version >= 2 {
95            total_size +=
96                types::CompactArray(types::Struct { version }).compute_size(&self.resources)?;
97        } else {
98            total_size += types::Array(types::Struct { version }).compute_size(&self.resources)?;
99        }
100        total_size += types::Boolean.compute_size(&self.validate_only)?;
101        if version >= 2 {
102            let num_tagged_fields = self.unknown_tagged_fields.len();
103            if num_tagged_fields > std::u32::MAX as usize {
104                bail!(
105                    "Too many tagged fields to encode ({} fields)",
106                    num_tagged_fields
107                );
108            }
109            total_size += types::UnsignedVarInt.compute_size(num_tagged_fields as u32)?;
110
111            total_size += compute_unknown_tagged_fields_size(&self.unknown_tagged_fields)?;
112        }
113        Ok(total_size)
114    }
115}
116
117#[cfg(feature = "broker")]
118impl Decodable for AlterConfigsRequest {
119    fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<Self> {
120        let resources = if version >= 2 {
121            types::CompactArray(types::Struct { version }).decode(buf)?
122        } else {
123            types::Array(types::Struct { version }).decode(buf)?
124        };
125        let validate_only = types::Boolean.decode(buf)?;
126        let mut unknown_tagged_fields = BTreeMap::new();
127        if version >= 2 {
128            let num_tagged_fields = types::UnsignedVarInt.decode(buf)?;
129            for _ in 0..num_tagged_fields {
130                let tag: u32 = types::UnsignedVarInt.decode(buf)?;
131                let size: u32 = types::UnsignedVarInt.decode(buf)?;
132                let unknown_value = buf.try_get_bytes(size as usize)?;
133                unknown_tagged_fields.insert(tag as i32, unknown_value);
134            }
135        }
136        Ok(Self {
137            resources,
138            validate_only,
139            unknown_tagged_fields,
140        })
141    }
142}
143
144impl Default for AlterConfigsRequest {
145    fn default() -> Self {
146        Self {
147            resources: Default::default(),
148            validate_only: false,
149            unknown_tagged_fields: BTreeMap::new(),
150        }
151    }
152}
153
154impl Message for AlterConfigsRequest {
155    const VERSIONS: VersionRange = VersionRange { min: 0, max: 2 };
156    const DEPRECATED_VERSIONS: Option<VersionRange> = None;
157}
158
159/// Valid versions: 0-2
160#[non_exhaustive]
161#[derive(Debug, Clone, PartialEq)]
162pub struct AlterConfigsResource {
163    /// The resource type.
164    ///
165    /// Supported API versions: 0-2
166    pub resource_type: i8,
167
168    /// The resource name.
169    ///
170    /// Supported API versions: 0-2
171    pub resource_name: StrBytes,
172
173    /// The configurations.
174    ///
175    /// Supported API versions: 0-2
176    pub configs: Vec<AlterableConfig>,
177
178    /// Other tagged fields
179    pub unknown_tagged_fields: BTreeMap<i32, Bytes>,
180}
181
182impl AlterConfigsResource {
183    /// Sets `resource_type` to the passed value.
184    ///
185    /// The resource type.
186    ///
187    /// Supported API versions: 0-2
188    pub fn with_resource_type(mut self, value: i8) -> Self {
189        self.resource_type = value;
190        self
191    }
192    /// Sets `resource_name` to the passed value.
193    ///
194    /// The resource name.
195    ///
196    /// Supported API versions: 0-2
197    pub fn with_resource_name(mut self, value: StrBytes) -> Self {
198        self.resource_name = value;
199        self
200    }
201    /// Sets `configs` to the passed value.
202    ///
203    /// The configurations.
204    ///
205    /// Supported API versions: 0-2
206    pub fn with_configs(mut self, value: Vec<AlterableConfig>) -> Self {
207        self.configs = value;
208        self
209    }
210    /// Sets unknown_tagged_fields to the passed value.
211    pub fn with_unknown_tagged_fields(mut self, value: BTreeMap<i32, Bytes>) -> Self {
212        self.unknown_tagged_fields = value;
213        self
214    }
215    /// Inserts an entry into unknown_tagged_fields.
216    pub fn with_unknown_tagged_field(mut self, key: i32, value: Bytes) -> Self {
217        self.unknown_tagged_fields.insert(key, value);
218        self
219    }
220}
221
222#[cfg(feature = "client")]
223impl Encodable for AlterConfigsResource {
224    fn encode<B: ByteBufMut>(&self, buf: &mut B, version: i16) -> Result<()> {
225        types::Int8.encode(buf, &self.resource_type)?;
226        if version >= 2 {
227            types::CompactString.encode(buf, &self.resource_name)?;
228        } else {
229            types::String.encode(buf, &self.resource_name)?;
230        }
231        if version >= 2 {
232            types::CompactArray(types::Struct { version }).encode(buf, &self.configs)?;
233        } else {
234            types::Array(types::Struct { version }).encode(buf, &self.configs)?;
235        }
236        if version >= 2 {
237            let num_tagged_fields = self.unknown_tagged_fields.len();
238            if num_tagged_fields > std::u32::MAX as usize {
239                bail!(
240                    "Too many tagged fields to encode ({} fields)",
241                    num_tagged_fields
242                );
243            }
244            types::UnsignedVarInt.encode(buf, num_tagged_fields as u32)?;
245
246            write_unknown_tagged_fields(buf, 0.., &self.unknown_tagged_fields)?;
247        }
248        Ok(())
249    }
250    fn compute_size(&self, version: i16) -> Result<usize> {
251        let mut total_size = 0;
252        total_size += types::Int8.compute_size(&self.resource_type)?;
253        if version >= 2 {
254            total_size += types::CompactString.compute_size(&self.resource_name)?;
255        } else {
256            total_size += types::String.compute_size(&self.resource_name)?;
257        }
258        if version >= 2 {
259            total_size +=
260                types::CompactArray(types::Struct { version }).compute_size(&self.configs)?;
261        } else {
262            total_size += types::Array(types::Struct { version }).compute_size(&self.configs)?;
263        }
264        if version >= 2 {
265            let num_tagged_fields = self.unknown_tagged_fields.len();
266            if num_tagged_fields > std::u32::MAX as usize {
267                bail!(
268                    "Too many tagged fields to encode ({} fields)",
269                    num_tagged_fields
270                );
271            }
272            total_size += types::UnsignedVarInt.compute_size(num_tagged_fields as u32)?;
273
274            total_size += compute_unknown_tagged_fields_size(&self.unknown_tagged_fields)?;
275        }
276        Ok(total_size)
277    }
278}
279
280#[cfg(feature = "broker")]
281impl Decodable for AlterConfigsResource {
282    fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<Self> {
283        let resource_type = types::Int8.decode(buf)?;
284        let resource_name = if version >= 2 {
285            types::CompactString.decode(buf)?
286        } else {
287            types::String.decode(buf)?
288        };
289        let configs = if version >= 2 {
290            types::CompactArray(types::Struct { version }).decode(buf)?
291        } else {
292            types::Array(types::Struct { version }).decode(buf)?
293        };
294        let mut unknown_tagged_fields = BTreeMap::new();
295        if version >= 2 {
296            let num_tagged_fields = types::UnsignedVarInt.decode(buf)?;
297            for _ in 0..num_tagged_fields {
298                let tag: u32 = types::UnsignedVarInt.decode(buf)?;
299                let size: u32 = types::UnsignedVarInt.decode(buf)?;
300                let unknown_value = buf.try_get_bytes(size as usize)?;
301                unknown_tagged_fields.insert(tag as i32, unknown_value);
302            }
303        }
304        Ok(Self {
305            resource_type,
306            resource_name,
307            configs,
308            unknown_tagged_fields,
309        })
310    }
311}
312
313impl Default for AlterConfigsResource {
314    fn default() -> Self {
315        Self {
316            resource_type: 0,
317            resource_name: Default::default(),
318            configs: Default::default(),
319            unknown_tagged_fields: BTreeMap::new(),
320        }
321    }
322}
323
324impl Message for AlterConfigsResource {
325    const VERSIONS: VersionRange = VersionRange { min: 0, max: 2 };
326    const DEPRECATED_VERSIONS: Option<VersionRange> = None;
327}
328
329/// Valid versions: 0-2
330#[non_exhaustive]
331#[derive(Debug, Clone, PartialEq)]
332pub struct AlterableConfig {
333    /// The configuration key name.
334    ///
335    /// Supported API versions: 0-2
336    pub name: StrBytes,
337
338    /// The value to set for the configuration key.
339    ///
340    /// Supported API versions: 0-2
341    pub value: Option<StrBytes>,
342
343    /// Other tagged fields
344    pub unknown_tagged_fields: BTreeMap<i32, Bytes>,
345}
346
347impl AlterableConfig {
348    /// Sets `name` to the passed value.
349    ///
350    /// The configuration key name.
351    ///
352    /// Supported API versions: 0-2
353    pub fn with_name(mut self, value: StrBytes) -> Self {
354        self.name = value;
355        self
356    }
357    /// Sets `value` to the passed value.
358    ///
359    /// The value to set for the configuration key.
360    ///
361    /// Supported API versions: 0-2
362    pub fn with_value(mut self, value: Option<StrBytes>) -> Self {
363        self.value = value;
364        self
365    }
366    /// Sets unknown_tagged_fields to the passed value.
367    pub fn with_unknown_tagged_fields(mut self, value: BTreeMap<i32, Bytes>) -> Self {
368        self.unknown_tagged_fields = value;
369        self
370    }
371    /// Inserts an entry into unknown_tagged_fields.
372    pub fn with_unknown_tagged_field(mut self, key: i32, value: Bytes) -> Self {
373        self.unknown_tagged_fields.insert(key, value);
374        self
375    }
376}
377
378#[cfg(feature = "client")]
379impl Encodable for AlterableConfig {
380    fn encode<B: ByteBufMut>(&self, buf: &mut B, version: i16) -> Result<()> {
381        if version >= 2 {
382            types::CompactString.encode(buf, &self.name)?;
383        } else {
384            types::String.encode(buf, &self.name)?;
385        }
386        if version >= 2 {
387            types::CompactString.encode(buf, &self.value)?;
388        } else {
389            types::String.encode(buf, &self.value)?;
390        }
391        if version >= 2 {
392            let num_tagged_fields = self.unknown_tagged_fields.len();
393            if num_tagged_fields > std::u32::MAX as usize {
394                bail!(
395                    "Too many tagged fields to encode ({} fields)",
396                    num_tagged_fields
397                );
398            }
399            types::UnsignedVarInt.encode(buf, num_tagged_fields as u32)?;
400
401            write_unknown_tagged_fields(buf, 0.., &self.unknown_tagged_fields)?;
402        }
403        Ok(())
404    }
405    fn compute_size(&self, version: i16) -> Result<usize> {
406        let mut total_size = 0;
407        if version >= 2 {
408            total_size += types::CompactString.compute_size(&self.name)?;
409        } else {
410            total_size += types::String.compute_size(&self.name)?;
411        }
412        if version >= 2 {
413            total_size += types::CompactString.compute_size(&self.value)?;
414        } else {
415            total_size += types::String.compute_size(&self.value)?;
416        }
417        if version >= 2 {
418            let num_tagged_fields = self.unknown_tagged_fields.len();
419            if num_tagged_fields > std::u32::MAX as usize {
420                bail!(
421                    "Too many tagged fields to encode ({} fields)",
422                    num_tagged_fields
423                );
424            }
425            total_size += types::UnsignedVarInt.compute_size(num_tagged_fields as u32)?;
426
427            total_size += compute_unknown_tagged_fields_size(&self.unknown_tagged_fields)?;
428        }
429        Ok(total_size)
430    }
431}
432
433#[cfg(feature = "broker")]
434impl Decodable for AlterableConfig {
435    fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<Self> {
436        let name = if version >= 2 {
437            types::CompactString.decode(buf)?
438        } else {
439            types::String.decode(buf)?
440        };
441        let value = if version >= 2 {
442            types::CompactString.decode(buf)?
443        } else {
444            types::String.decode(buf)?
445        };
446        let mut unknown_tagged_fields = BTreeMap::new();
447        if version >= 2 {
448            let num_tagged_fields = types::UnsignedVarInt.decode(buf)?;
449            for _ in 0..num_tagged_fields {
450                let tag: u32 = types::UnsignedVarInt.decode(buf)?;
451                let size: u32 = types::UnsignedVarInt.decode(buf)?;
452                let unknown_value = buf.try_get_bytes(size as usize)?;
453                unknown_tagged_fields.insert(tag as i32, unknown_value);
454            }
455        }
456        Ok(Self {
457            name,
458            value,
459            unknown_tagged_fields,
460        })
461    }
462}
463
464impl Default for AlterableConfig {
465    fn default() -> Self {
466        Self {
467            name: Default::default(),
468            value: Some(Default::default()),
469            unknown_tagged_fields: BTreeMap::new(),
470        }
471    }
472}
473
474impl Message for AlterableConfig {
475    const VERSIONS: VersionRange = VersionRange { min: 0, max: 2 };
476    const DEPRECATED_VERSIONS: Option<VersionRange> = None;
477}
478
479impl HeaderVersion for AlterConfigsRequest {
480    fn header_version(version: i16) -> i16 {
481        if version >= 2 {
482            2
483        } else {
484            1
485        }
486    }
487}
kafka_protocol/messages/alter_configs_request.rs

kafka_protocol/messages/
alter_configs_request.rs
