1#![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#[non_exhaustive]
22#[derive(Debug, Clone, PartialEq)]
23pub struct AddRaftVoterRequest {
24 pub cluster_id: Option<StrBytes>,
28
29 pub timeout_ms: i32,
33
34 pub voter_id: i32,
38
39 pub voter_directory_id: Uuid,
43
44 pub listeners: Vec<Listener>,
48
49 pub unknown_tagged_fields: BTreeMap<i32, Bytes>,
51}
52
53impl AddRaftVoterRequest {
54 pub fn with_cluster_id(mut self, value: Option<StrBytes>) -> Self {
60 self.cluster_id = value;
61 self
62 }
63 pub fn with_timeout_ms(mut self, value: i32) -> Self {
69 self.timeout_ms = value;
70 self
71 }
72 pub fn with_voter_id(mut self, value: i32) -> Self {
78 self.voter_id = value;
79 self
80 }
81 pub fn with_voter_directory_id(mut self, value: Uuid) -> Self {
87 self.voter_directory_id = value;
88 self
89 }
90 pub fn with_listeners(mut self, value: Vec<Listener>) -> Self {
96 self.listeners = value;
97 self
98 }
99 pub fn with_unknown_tagged_fields(mut self, value: BTreeMap<i32, Bytes>) -> Self {
101 self.unknown_tagged_fields = value;
102 self
103 }
104 pub fn with_unknown_tagged_field(mut self, key: i32, value: Bytes) -> Self {
106 self.unknown_tagged_fields.insert(key, value);
107 self
108 }
109}
110
111#[cfg(feature = "client")]
112impl Encodable for AddRaftVoterRequest {
113 fn encode<B: ByteBufMut>(&self, buf: &mut B, version: i16) -> Result<()> {
114 if version != 0 {
115 bail!("specified version not supported by this message type");
116 }
117 types::CompactString.encode(buf, &self.cluster_id)?;
118 types::Int32.encode(buf, &self.timeout_ms)?;
119 types::Int32.encode(buf, &self.voter_id)?;
120 types::Uuid.encode(buf, &self.voter_directory_id)?;
121 types::CompactArray(types::Struct { version }).encode(buf, &self.listeners)?;
122 let num_tagged_fields = self.unknown_tagged_fields.len();
123 if num_tagged_fields > std::u32::MAX as usize {
124 bail!(
125 "Too many tagged fields to encode ({} fields)",
126 num_tagged_fields
127 );
128 }
129 types::UnsignedVarInt.encode(buf, num_tagged_fields as u32)?;
130
131 write_unknown_tagged_fields(buf, 0.., &self.unknown_tagged_fields)?;
132 Ok(())
133 }
134 fn compute_size(&self, version: i16) -> Result<usize> {
135 let mut total_size = 0;
136 total_size += types::CompactString.compute_size(&self.cluster_id)?;
137 total_size += types::Int32.compute_size(&self.timeout_ms)?;
138 total_size += types::Int32.compute_size(&self.voter_id)?;
139 total_size += types::Uuid.compute_size(&self.voter_directory_id)?;
140 total_size +=
141 types::CompactArray(types::Struct { version }).compute_size(&self.listeners)?;
142 let num_tagged_fields = self.unknown_tagged_fields.len();
143 if num_tagged_fields > std::u32::MAX as usize {
144 bail!(
145 "Too many tagged fields to encode ({} fields)",
146 num_tagged_fields
147 );
148 }
149 total_size += types::UnsignedVarInt.compute_size(num_tagged_fields as u32)?;
150
151 total_size += compute_unknown_tagged_fields_size(&self.unknown_tagged_fields)?;
152 Ok(total_size)
153 }
154}
155
156#[cfg(feature = "broker")]
157impl Decodable for AddRaftVoterRequest {
158 fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<Self> {
159 if version != 0 {
160 bail!("specified version not supported by this message type");
161 }
162 let cluster_id = types::CompactString.decode(buf)?;
163 let timeout_ms = types::Int32.decode(buf)?;
164 let voter_id = types::Int32.decode(buf)?;
165 let voter_directory_id = types::Uuid.decode(buf)?;
166 let listeners = types::CompactArray(types::Struct { version }).decode(buf)?;
167 let mut unknown_tagged_fields = BTreeMap::new();
168 let num_tagged_fields = types::UnsignedVarInt.decode(buf)?;
169 for _ in 0..num_tagged_fields {
170 let tag: u32 = types::UnsignedVarInt.decode(buf)?;
171 let size: u32 = types::UnsignedVarInt.decode(buf)?;
172 let unknown_value = buf.try_get_bytes(size as usize)?;
173 unknown_tagged_fields.insert(tag as i32, unknown_value);
174 }
175 Ok(Self {
176 cluster_id,
177 timeout_ms,
178 voter_id,
179 voter_directory_id,
180 listeners,
181 unknown_tagged_fields,
182 })
183 }
184}
185
186impl Default for AddRaftVoterRequest {
187 fn default() -> Self {
188 Self {
189 cluster_id: Some(Default::default()),
190 timeout_ms: 0,
191 voter_id: 0,
192 voter_directory_id: Uuid::nil(),
193 listeners: Default::default(),
194 unknown_tagged_fields: BTreeMap::new(),
195 }
196 }
197}
198
199impl Message for AddRaftVoterRequest {
200 const VERSIONS: VersionRange = VersionRange { min: 0, max: 0 };
201 const DEPRECATED_VERSIONS: Option<VersionRange> = None;
202}
203
204#[non_exhaustive]
206#[derive(Debug, Clone, PartialEq)]
207pub struct Listener {
208 pub name: StrBytes,
212
213 pub host: StrBytes,
217
218 pub port: u16,
222
223 pub unknown_tagged_fields: BTreeMap<i32, Bytes>,
225}
226
227impl Listener {
228 pub fn with_name(mut self, value: StrBytes) -> Self {
234 self.name = value;
235 self
236 }
237 pub fn with_host(mut self, value: StrBytes) -> Self {
243 self.host = value;
244 self
245 }
246 pub fn with_port(mut self, value: u16) -> Self {
252 self.port = value;
253 self
254 }
255 pub fn with_unknown_tagged_fields(mut self, value: BTreeMap<i32, Bytes>) -> Self {
257 self.unknown_tagged_fields = value;
258 self
259 }
260 pub fn with_unknown_tagged_field(mut self, key: i32, value: Bytes) -> Self {
262 self.unknown_tagged_fields.insert(key, value);
263 self
264 }
265}
266
267#[cfg(feature = "client")]
268impl Encodable for Listener {
269 fn encode<B: ByteBufMut>(&self, buf: &mut B, version: i16) -> Result<()> {
270 if version != 0 {
271 bail!("specified version not supported by this message type");
272 }
273 types::CompactString.encode(buf, &self.name)?;
274 types::CompactString.encode(buf, &self.host)?;
275 types::UInt16.encode(buf, &self.port)?;
276 let num_tagged_fields = self.unknown_tagged_fields.len();
277 if num_tagged_fields > std::u32::MAX as usize {
278 bail!(
279 "Too many tagged fields to encode ({} fields)",
280 num_tagged_fields
281 );
282 }
283 types::UnsignedVarInt.encode(buf, num_tagged_fields as u32)?;
284
285 write_unknown_tagged_fields(buf, 0.., &self.unknown_tagged_fields)?;
286 Ok(())
287 }
288 fn compute_size(&self, version: i16) -> Result<usize> {
289 let mut total_size = 0;
290 total_size += types::CompactString.compute_size(&self.name)?;
291 total_size += types::CompactString.compute_size(&self.host)?;
292 total_size += types::UInt16.compute_size(&self.port)?;
293 let num_tagged_fields = self.unknown_tagged_fields.len();
294 if num_tagged_fields > std::u32::MAX as usize {
295 bail!(
296 "Too many tagged fields to encode ({} fields)",
297 num_tagged_fields
298 );
299 }
300 total_size += types::UnsignedVarInt.compute_size(num_tagged_fields as u32)?;
301
302 total_size += compute_unknown_tagged_fields_size(&self.unknown_tagged_fields)?;
303 Ok(total_size)
304 }
305}
306
307#[cfg(feature = "broker")]
308impl Decodable for Listener {
309 fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<Self> {
310 if version != 0 {
311 bail!("specified version not supported by this message type");
312 }
313 let name = types::CompactString.decode(buf)?;
314 let host = types::CompactString.decode(buf)?;
315 let port = types::UInt16.decode(buf)?;
316 let mut unknown_tagged_fields = BTreeMap::new();
317 let num_tagged_fields = types::UnsignedVarInt.decode(buf)?;
318 for _ in 0..num_tagged_fields {
319 let tag: u32 = types::UnsignedVarInt.decode(buf)?;
320 let size: u32 = types::UnsignedVarInt.decode(buf)?;
321 let unknown_value = buf.try_get_bytes(size as usize)?;
322 unknown_tagged_fields.insert(tag as i32, unknown_value);
323 }
324 Ok(Self {
325 name,
326 host,
327 port,
328 unknown_tagged_fields,
329 })
330 }
331}
332
333impl Default for Listener {
334 fn default() -> Self {
335 Self {
336 name: Default::default(),
337 host: Default::default(),
338 port: 0,
339 unknown_tagged_fields: BTreeMap::new(),
340 }
341 }
342}
343
344impl Message for Listener {
345 const VERSIONS: VersionRange = VersionRange { min: 0, max: 0 };
346 const DEPRECATED_VERSIONS: Option<VersionRange> = None;
347}
348
349impl HeaderVersion for AddRaftVoterRequest {
350 fn header_version(version: i16) -> i16 {
351 2
352 }
353}