kafka_protocol/messages/
create_delegation_token_request.rs

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

kafka_protocol/messages/
create_delegation_token_request.rs
