Skip to main content

confluent_kafka/common/acl/
acl_binding.rs

1// Copyright 2025 Confluent Inc.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15//! ACL bindings.
16//!
17//! Corresponds to `org.apache.kafka.common.acl.AclBinding`.
18
19use crate::common::resource::ResourcePattern;
20
21use super::{AccessControlEntry, AclBindingFilter};
22
23/// Represents a binding between a resource pattern and an access control entry.
24#[derive(Clone, Debug, PartialEq, Eq, Hash)]
25#[doc(alias = "org.apache.kafka.common.acl.AclBinding")]
26pub struct AclBinding {
27    pattern: ResourcePattern,
28    entry: AccessControlEntry,
29}
30
31impl AclBinding {
32    /// Create an instance of this class with the provided parameters.
33    ///
34    /// # Arguments
35    /// * `pattern` - resource pattern
36    /// * `entry` - entry
37    #[doc(alias = "org.apache.kafka.common.acl.AclBinding#AclBinding")]
38    pub fn new(pattern: ResourcePattern, entry: AccessControlEntry) -> AclBinding {
39        AclBinding { pattern, entry }
40    }
41
42    /// Returns true if this binding has any UNKNOWN components.
43    #[doc(alias = "org.apache.kafka.common.acl.AclBinding#isUnknown")]
44    pub fn is_unknown(&self) -> bool {
45        self.pattern.is_unknown() || self.entry.is_unknown()
46    }
47
48    /// Returns the resource pattern for this binding.
49    #[doc(alias = "org.apache.kafka.common.acl.AclBinding#pattern")]
50    pub fn pattern(&self) -> &ResourcePattern {
51        &self.pattern
52    }
53
54    /// Returns the access control entry for this binding.
55    #[doc(alias = "org.apache.kafka.common.acl.AclBinding#entry")]
56    pub fn entry(&self) -> &AccessControlEntry {
57        &self.entry
58    }
59
60    /// Returns a filter which matches only this `AclBinding`.
61    #[doc(alias = "org.apache.kafka.common.acl.AclBinding#toFilter")]
62    pub fn to_filter(&self) -> AclBindingFilter {
63        AclBindingFilter::new(self.pattern.to_filter(), self.entry.to_filter())
64    }
65}
66
67impl std::fmt::Display for AclBinding {
68    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
69        write!(f, "(pattern={}, entry={})", self.pattern, self.entry)
70    }
71}
72
73#[cfg(test)]
74mod tests {
75    use super::*;
76    use crate::common::acl::{AccessControlEntryFilter, AclBindingFilter, AclOperation, AclPermissionType};
77    use crate::common::resource::{PatternType, ResourcePatternFilter, ResourceType};
78
79    fn acl(
80        rt: ResourceType,
81        name: &str,
82        pt: PatternType,
83        principal: &str,
84        host: &str,
85        op: AclOperation,
86        perm: AclPermissionType,
87    ) -> AclBinding {
88        AclBinding::new(
89            ResourcePattern::new(rt, name, pt).unwrap(),
90            AccessControlEntry::new(principal, host, op, perm).unwrap(),
91        )
92    }
93
94    fn acl1() -> AclBinding {
95        acl(
96            ResourceType::Topic,
97            "mytopic",
98            PatternType::Literal,
99            "User:ANONYMOUS",
100            "",
101            AclOperation::All,
102            AclPermissionType::Allow,
103        )
104    }
105    fn acl2() -> AclBinding {
106        acl(
107            ResourceType::Topic,
108            "mytopic",
109            PatternType::Literal,
110            "User:*",
111            "",
112            AclOperation::Read,
113            AclPermissionType::Allow,
114        )
115    }
116    fn acl3() -> AclBinding {
117        acl(
118            ResourceType::Topic,
119            "mytopic2",
120            PatternType::Literal,
121            "User:ANONYMOUS",
122            "127.0.0.1",
123            AclOperation::Read,
124            AclPermissionType::Deny,
125        )
126    }
127    fn unknown_acl() -> AclBinding {
128        acl(
129            ResourceType::Topic,
130            "mytopic2",
131            PatternType::Literal,
132            "User:ANONYMOUS",
133            "127.0.0.1",
134            AclOperation::Unknown,
135            AclPermissionType::Deny,
136        )
137    }
138
139    fn any_anonymous() -> AclBindingFilter {
140        AclBindingFilter::new(
141            ResourcePatternFilter::any(),
142            AccessControlEntryFilter::new(
143                Some("User:ANONYMOUS".to_string()),
144                None,
145                AclOperation::Any,
146                AclPermissionType::Any,
147            ),
148        )
149    }
150    fn any_deny() -> AclBindingFilter {
151        AclBindingFilter::new(
152            ResourcePatternFilter::any(),
153            AccessControlEntryFilter::new(None, None, AclOperation::Any, AclPermissionType::Deny),
154        )
155    }
156    fn any_mytopic() -> AclBindingFilter {
157        AclBindingFilter::new(
158            ResourcePatternFilter::new(ResourceType::Topic, Some("mytopic".to_string()), PatternType::Literal),
159            AccessControlEntryFilter::new(None, None, AclOperation::Any, AclPermissionType::Any),
160        )
161    }
162
163    #[test]
164    #[doc(alias = "org.apache.kafka.common.acl.AclBindingTest#testMatching")]
165    fn test_matching() {
166        assert_eq!(acl1(), acl1());
167        let acl1_copy = acl(
168            ResourceType::Topic,
169            "mytopic",
170            PatternType::Literal,
171            "User:ANONYMOUS",
172            "",
173            AclOperation::All,
174            AclPermissionType::Allow,
175        );
176        assert_eq!(acl1(), acl1_copy);
177        assert_eq!(acl2(), acl2());
178        assert_ne!(acl1(), acl2());
179        assert!(AclBindingFilter::any().matches(&acl1()));
180        assert!(AclBindingFilter::any().matches(&acl2()));
181        assert!(AclBindingFilter::any().matches(&acl3()));
182        assert_eq!(AclBindingFilter::any(), AclBindingFilter::any());
183        assert!(any_anonymous().matches(&acl1()));
184        assert!(!any_anonymous().matches(&acl2()));
185        assert!(any_anonymous().matches(&acl3()));
186        assert!(!any_deny().matches(&acl1()));
187        assert!(!any_deny().matches(&acl2()));
188        assert!(any_deny().matches(&acl3()));
189        assert!(any_mytopic().matches(&acl1()));
190        assert!(any_mytopic().matches(&acl2()));
191        assert!(!any_mytopic().matches(&acl3()));
192        assert!(any_anonymous().matches(&unknown_acl()));
193        assert!(any_deny().matches(&unknown_acl()));
194        assert_eq!(unknown_acl(), unknown_acl());
195        assert!(!any_mytopic().matches(&unknown_acl()));
196    }
197
198    #[test]
199    #[doc(alias = "org.apache.kafka.common.acl.AclBindingTest#testUnknowns")]
200    fn test_unknowns() {
201        assert!(!acl1().is_unknown());
202        assert!(!acl2().is_unknown());
203        assert!(!acl3().is_unknown());
204        assert!(!any_anonymous().is_unknown());
205        assert!(!any_deny().is_unknown());
206        assert!(!any_mytopic().is_unknown());
207        assert!(unknown_acl().is_unknown());
208    }
209
210    #[test]
211    #[doc(alias = "org.apache.kafka.common.acl.AclBindingTest#testMatchesAtMostOne")]
212    fn test_matches_at_most_one() {
213        assert!(acl1().to_filter().find_indefinite_field().is_none());
214        assert!(acl2().to_filter().find_indefinite_field().is_none());
215        assert!(acl3().to_filter().find_indefinite_field().is_none());
216        assert!(!any_anonymous().matches_at_most_one());
217        assert!(!any_deny().matches_at_most_one());
218        assert!(!any_mytopic().matches_at_most_one());
219    }
220
221    #[test]
222    fn should_not_throw_on_unknown_pattern_type() {
223        AclBinding::new(
224            ResourcePattern::new(ResourceType::Topic, "foo", PatternType::Unknown).unwrap(),
225            acl1().entry().clone(),
226        );
227    }
228
229    #[test]
230    fn should_not_throw_on_unknown_resource_type() {
231        AclBinding::new(
232            ResourcePattern::new(ResourceType::Unknown, "foo", PatternType::Literal).unwrap(),
233            acl1().entry().clone(),
234        );
235    }
236
237    #[test]
238    fn should_throw_on_match_pattern_type() {
239        assert!(ResourcePattern::new(ResourceType::Topic, "foo", PatternType::Match).is_err());
240    }
241
242    #[test]
243    fn should_throw_on_any_pattern_type() {
244        assert!(ResourcePattern::new(ResourceType::Topic, "foo", PatternType::Any).is_err());
245    }
246
247    #[test]
248    fn should_throw_on_any_resource_type() {
249        assert!(ResourcePattern::new(ResourceType::Any, "foo", PatternType::Literal).is_err());
250    }
251}