confluent_kafka/common/acl/
access_control_entry.rs1use crate::common::Error;
20
21use super::access_control_entry_data::AccessControlEntryData;
22use super::{AccessControlEntryFilter, AclOperation, AclPermissionType};
23
24#[derive(Clone, Debug, PartialEq, Eq, Hash)]
27#[doc(alias = "org.apache.kafka.common.acl.AccessControlEntry")]
28pub struct AccessControlEntry {
29 pub(crate) data: AccessControlEntryData,
30}
31
32impl AccessControlEntry {
33 #[doc(alias = "org.apache.kafka.common.acl.AccessControlEntry#AccessControlEntry")]
47 pub fn new(
48 principal: impl Into<String>,
49 host: impl Into<String>,
50 operation: AclOperation,
51 permission_type: AclPermissionType,
52 ) -> Result<AccessControlEntry, Error> {
53 if operation == AclOperation::Any {
54 return Err(Error::local_illegal_argument("operation must not be ANY"));
55 }
56 if permission_type == AclPermissionType::Any {
57 return Err(Error::local_illegal_argument("permissionType must not be ANY"));
58 }
59 Ok(AccessControlEntry {
60 data: AccessControlEntryData::new(Some(principal.into()), Some(host.into()), operation, permission_type),
61 })
62 }
63
64 #[doc(alias = "org.apache.kafka.common.acl.AccessControlEntry#principal")]
66 pub fn principal(&self) -> &str {
67 self.data.principal().expect("AccessControlEntry principal is always set")
70 }
71
72 #[doc(alias = "org.apache.kafka.common.acl.AccessControlEntry#host")]
74 pub fn host(&self) -> &str {
75 self.data.host().expect("AccessControlEntry host is always set")
76 }
77
78 #[doc(alias = "org.apache.kafka.common.acl.AccessControlEntry#operation")]
81 pub fn operation(&self) -> AclOperation {
82 self.data.operation()
83 }
84
85 #[doc(alias = "org.apache.kafka.common.acl.AccessControlEntry#permissionType")]
88 pub fn permission_type(&self) -> AclPermissionType {
89 self.data.permission_type()
90 }
91
92 #[doc(alias = "org.apache.kafka.common.acl.AccessControlEntry#toFilter")]
94 pub fn to_filter(&self) -> AccessControlEntryFilter {
95 AccessControlEntryFilter::with_data(self.data.clone())
96 }
97
98 #[doc(alias = "org.apache.kafka.common.acl.AccessControlEntry#isUnknown")]
100 pub fn is_unknown(&self) -> bool {
101 self.data.is_unknown()
102 }
103}
104
105impl std::fmt::Display for AccessControlEntry {
106 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
107 write!(f, "{}", self.data)
108 }
109}
110
111#[cfg(test)]
112mod tests {
113 use super::*;
114
115 #[test]
116 fn rejects_any_operation() {
117 let err = AccessControlEntry::new("User:x", "*", AclOperation::Any, AclPermissionType::Allow);
118 assert!(matches!(err, Err(Error::LocalIllegalArgument(_))));
119 }
120
121 #[test]
122 fn rejects_any_permission_type() {
123 let err = AccessControlEntry::new("User:x", "*", AclOperation::Read, AclPermissionType::Any);
124 assert!(matches!(err, Err(Error::LocalIllegalArgument(_))));
125 }
126
127 #[test]
128 fn accessors() {
129 let entry = AccessControlEntry::new("User:x", "host", AclOperation::Read, AclPermissionType::Allow).unwrap();
130 assert_eq!(entry.principal(), "User:x");
131 assert_eq!(entry.host(), "host");
132 assert_eq!(entry.operation(), AclOperation::Read);
133 assert_eq!(entry.permission_type(), AclPermissionType::Allow);
134 assert!(!entry.is_unknown());
135 }
136
137 #[test]
138 fn is_unknown_for_unknown_operation() {
139 let entry = AccessControlEntry::new("User:x", "host", AclOperation::Unknown, AclPermissionType::Allow).unwrap();
140 assert!(entry.is_unknown());
141 }
142}