kafka_protocol/messages/
delete_acls_request.rs

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

kafka_protocol/messages/
delete_acls_request.rs
