Skip to main content

confluent_kafka/common/resource/
resource.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 resources.
16//!
17//! Corresponds to `org.apache.kafka.common.resource.Resource`.
18
19use super::ResourceType;
20
21/// Represents a cluster resource with a tuple of (type, name).
22#[derive(Clone, Debug, PartialEq, Eq, Hash)]
23#[doc(alias = "org.apache.kafka.common.resource.Resource")]
24pub struct Resource {
25    resource_type: ResourceType,
26    name: String,
27}
28
29impl Resource {
30    /// The name of the `CLUSTER` resource.
31    pub const CLUSTER_NAME: &str = "kafka-cluster";
32
33    /// Create an instance of this class with the provided parameters.
34    ///
35    /// # Arguments
36    /// * `resource_type` - resource type
37    /// * `name` - resource name
38    #[doc(alias = "org.apache.kafka.common.resource.Resource#Resource")]
39    pub fn new(resource_type: ResourceType, name: impl Into<String>) -> Resource {
40        Resource { resource_type, name: name.into() }
41    }
42
43    /// A resource representing the whole cluster.
44    #[doc(alias = "org.apache.kafka.common.resource.Resource#CLUSTER")]
45    pub fn cluster() -> Resource {
46        Resource::new(ResourceType::Cluster, Resource::CLUSTER_NAME)
47    }
48
49    /// Returns the resource type.
50    #[doc(alias = "org.apache.kafka.common.resource.Resource#resourceType")]
51    pub fn resource_type(&self) -> ResourceType {
52        self.resource_type
53    }
54
55    /// Returns the resource name.
56    #[doc(alias = "org.apache.kafka.common.resource.Resource#name")]
57    pub fn name(&self) -> &str {
58        &self.name
59    }
60
61    /// Returns true if this `Resource` has any UNKNOWN components.
62    #[doc(alias = "org.apache.kafka.common.resource.Resource#isUnknown")]
63    pub fn is_unknown(&self) -> bool {
64        self.resource_type.is_unknown()
65    }
66}
67
68impl std::fmt::Display for Resource {
69    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
70        write!(f, "(resourceType={}, name={})", self.resource_type, self.name)
71    }
72}
73
74#[cfg(test)]
75mod tests {
76    use super::*;
77
78    #[test]
79    fn cluster_resource() {
80        let cluster = Resource::cluster();
81        assert_eq!(cluster.resource_type(), ResourceType::Cluster);
82        assert_eq!(cluster.name(), "kafka-cluster");
83        assert!(!cluster.is_unknown());
84    }
85
86    #[test]
87    fn is_unknown_for_unknown_type() {
88        assert!(Resource::new(ResourceType::Unknown, "foo").is_unknown());
89        assert!(!Resource::new(ResourceType::Topic, "foo").is_unknown());
90    }
91
92    #[test]
93    fn equality_and_to_string() {
94        let a = Resource::new(ResourceType::Topic, "foo");
95        let b = Resource::new(ResourceType::Topic, "foo");
96        let c = Resource::new(ResourceType::Group, "foo");
97        assert_eq!(a, b);
98        assert_ne!(a, c);
99        assert_eq!(a.to_string(), "(resourceType=TOPIC, name=foo)");
100    }
101}