kafka_client_engine/admin/configs/
model.rs1use kafka_client_core::{
4 DescribeConfigsPlan, DescribeConfigsPlanError,
5 DescribeConfigsResourceQuery as CoreResourceQuery,
6};
7
8const RESULT_BYTES_PER_RESOURCE: usize = 256 * 1024;
9
10pub(crate) const fn describe_configs_result_limit(resource_count: usize) -> Option<usize> {
11 resource_count.checked_mul(RESULT_BYTES_PER_RESOURCE)
12}
13
14#[derive(Clone, Copy)]
15pub(crate) struct DescribeConfigsRetention {
16 total: usize,
17 result_limit: usize,
18}
19
20impl DescribeConfigsRetention {
21 pub(crate) const fn total(self) -> usize {
22 self.total
23 }
24
25 pub(crate) const fn result_limit(self) -> usize {
26 self.result_limit
27 }
28
29 #[cfg(test)]
30 pub(crate) const fn from_parts(total: usize, result_limit: usize) -> Self {
31 Self {
32 total,
33 result_limit,
34 }
35 }
36}
37
38#[derive(Clone, Debug, Eq, PartialEq)]
40pub struct DescribeConfigsResourceQuery {
41 resource_type: i8,
42 resource_name: String,
43 configuration_keys: Option<Vec<String>>,
44}
45
46impl DescribeConfigsResourceQuery {
47 pub const fn new(
49 resource_type: i8,
50 resource_name: String,
51 configuration_keys: Option<Vec<String>>,
52 ) -> Self {
53 Self {
54 resource_type,
55 resource_name,
56 configuration_keys,
57 }
58 }
59
60 fn canonicalize(mut self) -> Self {
61 self.resource_name = canonical_string(self.resource_name);
62 if let Some(keys) = self.configuration_keys.as_mut() {
63 for key in keys.iter_mut() {
64 *key = canonical_string(std::mem::take(key));
65 }
66 *keys = std::mem::take(keys).into_boxed_slice().into_vec();
67 }
68 self
69 }
70
71 fn text_bytes(&self) -> Option<usize> {
72 self.configuration_keys
73 .as_deref()
74 .unwrap_or_default()
75 .iter()
76 .try_fold(self.resource_name.len(), |bytes, key| {
77 bytes.checked_add(key.len())
78 })
79 }
80
81 fn into_core(self) -> CoreResourceQuery {
82 CoreResourceQuery::new(
83 self.resource_type,
84 self.resource_name,
85 self.configuration_keys,
86 )
87 }
88}
89
90#[derive(Clone, Debug, Eq, PartialEq)]
92pub struct DescribeConfigsRequest {
93 resources: Vec<DescribeConfigsResourceQuery>,
94 include_synonyms: bool,
95 include_documentation: bool,
96}
97
98impl DescribeConfigsRequest {
99 pub const fn new(
101 resources: Vec<DescribeConfigsResourceQuery>,
102 include_synonyms: bool,
103 include_documentation: bool,
104 ) -> Self {
105 Self {
106 resources,
107 include_synonyms,
108 include_documentation,
109 }
110 }
111
112 #[must_use]
114 pub const fn with_include_synonyms(mut self, include_synonyms: bool) -> Self {
115 self.include_synonyms = include_synonyms;
116 self
117 }
118
119 #[must_use]
121 pub const fn with_include_documentation(mut self, include_documentation: bool) -> Self {
122 self.include_documentation = include_documentation;
123 self
124 }
125
126 pub(crate) fn canonicalize(mut self) -> Self {
127 self.resources = self
128 .resources
129 .into_iter()
130 .map(DescribeConfigsResourceQuery::canonicalize)
131 .collect::<Vec<_>>()
132 .into_boxed_slice()
133 .into_vec();
134 self
135 }
136
137 pub(crate) fn retention(&self) -> Option<DescribeConfigsRetention> {
138 let resource_count = self.resources.len();
139 let key_count = self.resources.iter().try_fold(0usize, |count, resource| {
140 count.checked_add(resource.configuration_keys.as_ref().map_or(0, Vec::len))
141 })?;
142 let text_bytes = self.resources.iter().try_fold(0usize, |bytes, resource| {
143 bytes.checked_add(resource.text_bytes()?)
144 })?;
145 let request =
146 crate::admin::retention::request_charge(resource_count, key_count, text_bytes)?;
147 let result_limit = describe_configs_result_limit(resource_count)?;
148 Some(DescribeConfigsRetention {
149 total: request.checked_add(result_limit)?,
150 result_limit,
151 })
152 }
153
154 pub(crate) fn into_plan(self) -> Result<DescribeConfigsPlan, DescribeConfigsRequestError> {
155 DescribeConfigsPlan::new(
156 self.resources
157 .into_iter()
158 .map(DescribeConfigsResourceQuery::into_core)
159 .collect(),
160 self.include_synonyms,
161 self.include_documentation,
162 )
163 .map_err(DescribeConfigsRequestError::Invalid)
164 }
165}
166
167#[derive(Debug)]
168pub(crate) enum DescribeConfigsRequestError {
169 Invalid(DescribeConfigsPlanError),
170}
171
172fn canonical_string(value: String) -> String {
173 value.into_boxed_str().into_string()
174}