kacrab_protocol/generated/
create_delegation_token_response.rs

1//! Generated from CreateDelegationTokenResponse.json - DO NOT EDIT
2#![allow(
3    missing_docs,
4    clippy::all,
5    clippy::pedantic,
6    clippy::nursery,
7    clippy::arithmetic_side_effects,
8    reason = "Generated protocol modules mirror Kafka's schema shape and intentionally trade \
9              hand-written lint style for reproducible wire-code output."
10)]
11use bytes::{Bytes, BytesMut};
12
13use crate::*;
14
15#[derive(Debug, Clone, PartialEq)]
16pub struct CreateDelegationTokenResponseData {
17    /// The top-level error, or zero if there was no error.
18    pub error_code: i16,
19    /// The principal type of the token owner.
20    pub principal_type: KafkaString,
21    /// The name of the token owner.
22    pub principal_name: KafkaString,
23    /// The principal type of the requester of the token.
24    pub token_requester_principal_type: KafkaString,
25    /// The principal type of the requester of the token.
26    pub token_requester_principal_name: KafkaString,
27    /// When this token was generated.
28    pub issue_timestamp_ms: i64,
29    /// When this token expires.
30    pub expiry_timestamp_ms: i64,
31    /// The maximum lifetime of this token.
32    pub max_timestamp_ms: i64,
33    /// The token UUID.
34    pub token_id: KafkaString,
35    /// HMAC of the delegation token.
36    pub hmac: Bytes,
37    /// The duration in milliseconds for which the request was throttled due to a quota violation,
38    /// or zero if the request did not violate any quota.
39    pub throttle_time_ms: i32,
40    pub _unknown_tagged_fields: Vec<RawTaggedField>,
41}
42impl Default for CreateDelegationTokenResponseData {
43    fn default() -> Self {
44        Self {
45            error_code: 0_i16,
46            principal_type: KafkaString::default(),
47            principal_name: KafkaString::default(),
48            token_requester_principal_type: KafkaString::default(),
49            token_requester_principal_name: KafkaString::default(),
50            issue_timestamp_ms: 0_i64,
51            expiry_timestamp_ms: 0_i64,
52            max_timestamp_ms: 0_i64,
53            token_id: KafkaString::default(),
54            hmac: Bytes::new(),
55            throttle_time_ms: 0_i32,
56            _unknown_tagged_fields: Vec::new(),
57        }
58    }
59}
60impl CreateDelegationTokenResponseData {
61    pub fn with_error_code(mut self, value: i16) -> Self {
62        self.error_code = value;
63        self
64    }
65    pub fn with_principal_type(mut self, value: KafkaString) -> Self {
66        self.principal_type = value;
67        self
68    }
69    pub fn with_principal_name(mut self, value: KafkaString) -> Self {
70        self.principal_name = value;
71        self
72    }
73    pub fn with_token_requester_principal_type(mut self, value: KafkaString) -> Self {
74        self.token_requester_principal_type = value;
75        self
76    }
77    pub fn with_token_requester_principal_name(mut self, value: KafkaString) -> Self {
78        self.token_requester_principal_name = value;
79        self
80    }
81    pub fn with_issue_timestamp_ms(mut self, value: i64) -> Self {
82        self.issue_timestamp_ms = value;
83        self
84    }
85    pub fn with_expiry_timestamp_ms(mut self, value: i64) -> Self {
86        self.expiry_timestamp_ms = value;
87        self
88    }
89    pub fn with_max_timestamp_ms(mut self, value: i64) -> Self {
90        self.max_timestamp_ms = value;
91        self
92    }
93    pub fn with_token_id(mut self, value: KafkaString) -> Self {
94        self.token_id = value;
95        self
96    }
97    pub fn with_hmac(mut self, value: Bytes) -> Self {
98        self.hmac = value;
99        self
100    }
101    pub fn with_throttle_time_ms(mut self, value: i32) -> Self {
102        self.throttle_time_ms = value;
103        self
104    }
105    pub fn read(buf: &mut Bytes, version: i16) -> Result<Self> {
106        if version < 1 || version > 3 {
107            return Err(UnsupportedVersion::new(38, version).into());
108        }
109        let error_code;
110        let principal_type;
111        let principal_name;
112        let mut token_requester_principal_type = KafkaString::default();
113        let mut token_requester_principal_name = KafkaString::default();
114        let issue_timestamp_ms;
115        let expiry_timestamp_ms;
116        let max_timestamp_ms;
117        let token_id;
118        let hmac;
119        let throttle_time_ms;
120        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
121        error_code = read_i16(buf)?;
122        if version >= 2 {
123            principal_type = read_compact_string(buf)?;
124        } else {
125            principal_type = read_string(buf)?;
126        }
127        if version >= 2 {
128            principal_name = read_compact_string(buf)?;
129        } else {
130            principal_name = read_string(buf)?;
131        }
132        if version >= 3 {
133            token_requester_principal_type = read_compact_string(buf)?;
134        }
135        if version >= 3 {
136            token_requester_principal_name = read_compact_string(buf)?;
137        }
138        issue_timestamp_ms = read_i64(buf)?;
139        expiry_timestamp_ms = read_i64(buf)?;
140        max_timestamp_ms = read_i64(buf)?;
141        if version >= 2 {
142            token_id = read_compact_string(buf)?;
143        } else {
144            token_id = read_string(buf)?;
145        }
146        if version >= 2 {
147            hmac = read_compact_bytes(buf)?;
148        } else {
149            hmac = read_bytes(buf)?;
150        }
151        throttle_time_ms = read_i32(buf)?;
152        if version >= 2 {
153            let tagged_fields = read_tagged_fields(buf)?;
154            for field in &tagged_fields {
155                match field.tag {
156                    _ => {
157                        _unknown_tagged_fields.push(field.clone());
158                    },
159                }
160            }
161        }
162        Ok(Self {
163            error_code,
164            principal_type,
165            principal_name,
166            token_requester_principal_type,
167            token_requester_principal_name,
168            issue_timestamp_ms,
169            expiry_timestamp_ms,
170            max_timestamp_ms,
171            token_id,
172            hmac,
173            throttle_time_ms,
174            _unknown_tagged_fields,
175        })
176    }
177    pub fn write(&self, buf: &mut BytesMut, version: i16) -> Result<()> {
178        if version < 1 || version > 3 {
179            return Err(UnsupportedVersion::new(38, version).into());
180        }
181        write_i16(buf, self.error_code);
182        if version >= 2 {
183            write_compact_string(buf, &self.principal_type)?;
184        } else {
185            write_string(buf, &self.principal_type)?;
186        }
187        if version >= 2 {
188            write_compact_string(buf, &self.principal_name)?;
189        } else {
190            write_string(buf, &self.principal_name)?;
191        }
192        if version >= 3 {
193            write_compact_string(buf, &self.token_requester_principal_type)?;
194        } else if self.token_requester_principal_type != KafkaString::default() {
195            return Err(UnsupportedFieldVersion::new(
196                38,
197                "token_requester_principal_type",
198                version,
199            )
200            .into());
201        }
202        if version >= 3 {
203            write_compact_string(buf, &self.token_requester_principal_name)?;
204        } else if self.token_requester_principal_name != KafkaString::default() {
205            return Err(UnsupportedFieldVersion::new(
206                38,
207                "token_requester_principal_name",
208                version,
209            )
210            .into());
211        }
212        write_i64(buf, self.issue_timestamp_ms);
213        write_i64(buf, self.expiry_timestamp_ms);
214        write_i64(buf, self.max_timestamp_ms);
215        if version >= 2 {
216            write_compact_string(buf, &self.token_id)?;
217        } else {
218            write_string(buf, &self.token_id)?;
219        }
220        if version >= 2 {
221            write_compact_bytes(buf, &self.hmac)?;
222        } else {
223            write_bytes(buf, &self.hmac)?;
224        }
225        write_i32(buf, self.throttle_time_ms);
226        if version >= 2 {
227            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
228            all_tags.sort_by_key(|f| f.tag);
229            write_tagged_fields(buf, &all_tags)?;
230        }
231        Ok(())
232    }
233    pub fn encoded_len(&self, version: i16) -> Result<usize> {
234        if version < 1 || version > 3 {
235            return Err(UnsupportedVersion::new(38, version).into());
236        }
237        let mut len: usize = 0;
238        len += 2;
239        if version >= 2 {
240            len += compact_string_len(&self.principal_type)?;
241        } else {
242            len += string_len(&self.principal_type)?;
243        }
244        if version >= 2 {
245            len += compact_string_len(&self.principal_name)?;
246        } else {
247            len += string_len(&self.principal_name)?;
248        }
249        if version >= 3 {
250            len += compact_string_len(&self.token_requester_principal_type)?;
251        } else if self.token_requester_principal_type != KafkaString::default() {
252            return Err(UnsupportedFieldVersion::new(
253                38,
254                "token_requester_principal_type",
255                version,
256            )
257            .into());
258        }
259        if version >= 3 {
260            len += compact_string_len(&self.token_requester_principal_name)?;
261        } else if self.token_requester_principal_name != KafkaString::default() {
262            return Err(UnsupportedFieldVersion::new(
263                38,
264                "token_requester_principal_name",
265                version,
266            )
267            .into());
268        }
269        len += 8;
270        len += 8;
271        len += 8;
272        if version >= 2 {
273            len += compact_string_len(&self.token_id)?;
274        } else {
275            len += string_len(&self.token_id)?;
276        }
277        if version >= 2 {
278            len += compact_bytes_len(&self.hmac)?;
279        } else {
280            len += bytes_len(&self.hmac)?;
281        }
282        len += 4;
283        if version >= 2 {
284            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
285            all_tags.sort_by_key(|f| f.tag);
286            len += tagged_fields_len(&all_tags)?;
287        }
288        Ok(len)
289    }
290}
kacrab_protocol/generated/create_delegation_token_response.rs

kacrab_protocol/generated/
create_delegation_token_response.rs
