Skip to main content

kafka_client_engine/admin/configs/
model.rs

1//! Engine-owned request values for bounded batches of resource-generic `DescribeConfigs`.
2
3use 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/// One ordered configuration-resource query.
39#[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    /// Creates one raw resource query for validation at admission.
48    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/// One ordered batch-native `DescribeConfigs` request.
91#[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    /// Creates one raw batch for deterministic admission validation.
100    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    /// Replaces whether Kafka should return configuration synonyms.
113    #[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    /// Replaces whether Kafka should return configuration documentation.
120    #[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}