confluent_kafka/common/acl/
acl_binding.rs1use crate::common::resource::ResourcePattern;
20
21use super::{AccessControlEntry, AclBindingFilter};
22
23#[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 #[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 #[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 #[doc(alias = "org.apache.kafka.common.acl.AclBinding#pattern")]
50 pub fn pattern(&self) -> &ResourcePattern {
51 &self.pattern
52 }
53
54 #[doc(alias = "org.apache.kafka.common.acl.AclBinding#entry")]
56 pub fn entry(&self) -> &AccessControlEntry {
57 &self.entry
58 }
59
60 #[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}