#![allow(unused)]
use std::borrow::Borrow;
use std::collections::BTreeMap;
use anyhow::bail;
use bytes::Bytes;
use uuid::Uuid;
use crate::protocol::{
buf::{ByteBuf, ByteBufMut},
compute_unknown_tagged_fields_size, types, write_unknown_tagged_fields, Builder, Decodable,
DecodeError, Decoder, Encodable, EncodeError, Encoder, HeaderVersion, MapDecodable,
MapEncodable, Message, StrBytes, VersionRange,
};
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, derive_builder::Builder)]
#[builder(default)]
pub struct ConsumerGroupHeartbeatRequest {
pub group_id: super::GroupId,
pub member_id: StrBytes,
pub member_epoch: i32,
pub instance_id: Option<StrBytes>,
pub rack_id: Option<StrBytes>,
pub rebalance_timeout_ms: i32,
pub subscribed_topic_names: Option<Vec<super::TopicName>>,
pub server_assignor: Option<StrBytes>,
pub topic_partitions: Option<Vec<TopicPartitions>>,
pub unknown_tagged_fields: BTreeMap<i32, Bytes>,
}
impl Builder for ConsumerGroupHeartbeatRequest {
type Builder = ConsumerGroupHeartbeatRequestBuilder;
fn builder() -> Self::Builder {
ConsumerGroupHeartbeatRequestBuilder::default()
}
}
impl Encodable for ConsumerGroupHeartbeatRequest {
fn encode<B: ByteBufMut>(&self, buf: &mut B, version: i16) -> Result<(), EncodeError> {
types::CompactString.encode(buf, &self.group_id)?;
types::CompactString.encode(buf, &self.member_id)?;
types::Int32.encode(buf, &self.member_epoch)?;
types::CompactString.encode(buf, &self.instance_id)?;
types::CompactString.encode(buf, &self.rack_id)?;
types::Int32.encode(buf, &self.rebalance_timeout_ms)?;
types::CompactArray(types::CompactString).encode(buf, &self.subscribed_topic_names)?;
types::CompactString.encode(buf, &self.server_assignor)?;
types::CompactArray(types::Struct { version }).encode(buf, &self.topic_partitions)?;
let num_tagged_fields = self.unknown_tagged_fields.len();
if num_tagged_fields > std::u32::MAX as usize {
bail!(
"Too many tagged fields to encode ({} fields)",
num_tagged_fields
);
}
types::UnsignedVarInt.encode(buf, num_tagged_fields as u32)?;
write_unknown_tagged_fields(buf, 0.., &self.unknown_tagged_fields)?;
Ok(())
}
fn compute_size(&self, version: i16) -> Result<usize, EncodeError> {
let mut total_size = 0;
total_size += types::CompactString.compute_size(&self.group_id)?;
total_size += types::CompactString.compute_size(&self.member_id)?;
total_size += types::Int32.compute_size(&self.member_epoch)?;
total_size += types::CompactString.compute_size(&self.instance_id)?;
total_size += types::CompactString.compute_size(&self.rack_id)?;
total_size += types::Int32.compute_size(&self.rebalance_timeout_ms)?;
total_size +=
types::CompactArray(types::CompactString).compute_size(&self.subscribed_topic_names)?;
total_size += types::CompactString.compute_size(&self.server_assignor)?;
total_size +=
types::CompactArray(types::Struct { version }).compute_size(&self.topic_partitions)?;
let num_tagged_fields = self.unknown_tagged_fields.len();
if num_tagged_fields > std::u32::MAX as usize {
bail!(
"Too many tagged fields to encode ({} fields)",
num_tagged_fields
);
}
total_size += types::UnsignedVarInt.compute_size(num_tagged_fields as u32)?;
total_size += compute_unknown_tagged_fields_size(&self.unknown_tagged_fields)?;
Ok(total_size)
}
}
impl Decodable for ConsumerGroupHeartbeatRequest {
fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<Self, DecodeError> {
let group_id = types::CompactString.decode(buf)?;
let member_id = types::CompactString.decode(buf)?;
let member_epoch = types::Int32.decode(buf)?;
let instance_id = types::CompactString.decode(buf)?;
let rack_id = types::CompactString.decode(buf)?;
let rebalance_timeout_ms = types::Int32.decode(buf)?;
let subscribed_topic_names = types::CompactArray(types::CompactString).decode(buf)?;
let server_assignor = types::CompactString.decode(buf)?;
let topic_partitions = types::CompactArray(types::Struct { version }).decode(buf)?;
let mut unknown_tagged_fields = BTreeMap::new();
let num_tagged_fields = types::UnsignedVarInt.decode(buf)?;
for _ in 0..num_tagged_fields {
let tag: u32 = types::UnsignedVarInt.decode(buf)?;
let size: u32 = types::UnsignedVarInt.decode(buf)?;
let unknown_value = buf.try_get_bytes(size as usize)?;
unknown_tagged_fields.insert(tag as i32, unknown_value);
}
Ok(Self {
group_id,
member_id,
member_epoch,
instance_id,
rack_id,
rebalance_timeout_ms,
subscribed_topic_names,
server_assignor,
topic_partitions,
unknown_tagged_fields,
})
}
}
impl Default for ConsumerGroupHeartbeatRequest {
fn default() -> Self {
Self {
group_id: Default::default(),
member_id: Default::default(),
member_epoch: 0,
instance_id: None,
rack_id: None,
rebalance_timeout_ms: -1,
subscribed_topic_names: None,
server_assignor: None,
topic_partitions: None,
unknown_tagged_fields: BTreeMap::new(),
}
}
}
impl Message for ConsumerGroupHeartbeatRequest {
const VERSIONS: VersionRange = VersionRange { min: 0, max: 0 };
const DEPRECATED_VERSIONS: Option<VersionRange> = None;
}
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, derive_builder::Builder)]
#[builder(default)]
pub struct TopicPartitions {
pub topic_id: Uuid,
pub partitions: Vec<i32>,
pub unknown_tagged_fields: BTreeMap<i32, Bytes>,
}
impl Builder for TopicPartitions {
type Builder = TopicPartitionsBuilder;
fn builder() -> Self::Builder {
TopicPartitionsBuilder::default()
}
}
impl Encodable for TopicPartitions {
fn encode<B: ByteBufMut>(&self, buf: &mut B, version: i16) -> Result<(), EncodeError> {
types::Uuid.encode(buf, &self.topic_id)?;
types::CompactArray(types::Int32).encode(buf, &self.partitions)?;
let num_tagged_fields = self.unknown_tagged_fields.len();
if num_tagged_fields > std::u32::MAX as usize {
bail!(
"Too many tagged fields to encode ({} fields)",
num_tagged_fields
);
}
types::UnsignedVarInt.encode(buf, num_tagged_fields as u32)?;
write_unknown_tagged_fields(buf, 0.., &self.unknown_tagged_fields)?;
Ok(())
}
fn compute_size(&self, version: i16) -> Result<usize, EncodeError> {
let mut total_size = 0;
total_size += types::Uuid.compute_size(&self.topic_id)?;
total_size += types::CompactArray(types::Int32).compute_size(&self.partitions)?;
let num_tagged_fields = self.unknown_tagged_fields.len();
if num_tagged_fields > std::u32::MAX as usize {
bail!(
"Too many tagged fields to encode ({} fields)",
num_tagged_fields
);
}
total_size += types::UnsignedVarInt.compute_size(num_tagged_fields as u32)?;
total_size += compute_unknown_tagged_fields_size(&self.unknown_tagged_fields)?;
Ok(total_size)
}
}
impl Decodable for TopicPartitions {
fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<Self, DecodeError> {
let topic_id = types::Uuid.decode(buf)?;
let partitions = types::CompactArray(types::Int32).decode(buf)?;
let mut unknown_tagged_fields = BTreeMap::new();
let num_tagged_fields = types::UnsignedVarInt.decode(buf)?;
for _ in 0..num_tagged_fields {
let tag: u32 = types::UnsignedVarInt.decode(buf)?;
let size: u32 = types::UnsignedVarInt.decode(buf)?;
let unknown_value = buf.try_get_bytes(size as usize)?;
unknown_tagged_fields.insert(tag as i32, unknown_value);
}
Ok(Self {
topic_id,
partitions,
unknown_tagged_fields,
})
}
}
impl Default for TopicPartitions {
fn default() -> Self {
Self {
topic_id: Uuid::nil(),
partitions: Default::default(),
unknown_tagged_fields: BTreeMap::new(),
}
}
}
impl Message for TopicPartitions {
const VERSIONS: VersionRange = VersionRange { min: 0, max: 0 };
const DEPRECATED_VERSIONS: Option<VersionRange> = None;
}
impl HeaderVersion for ConsumerGroupHeartbeatRequest {
fn header_version(version: i16) -> i16 {
2
}
}