You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@kafka.apache.org by mi...@apache.org on 2025/02/07 14:53:22 UTC
(kafka) branch 4.0 updated: KAFKA-17833: Convert DescribeAuthorizedOperationsTest to use KRaft (#18252)
This is an automated email from the ASF dual-hosted git repository.
mimaison pushed a commit to branch 4.0
in repository https://gitbox.apache.org/repos/asf/kafka.git
The following commit(s) were added to refs/heads/4.0 by this push:
new b3837f831e8 KAFKA-17833: Convert DescribeAuthorizedOperationsTest to use KRaft (#18252)
b3837f831e8 is described below
commit b3837f831e85e5d6f18ab37acbf8abe773068d40
Author: PoAn Yang <pa...@apache.org>
AuthorDate: Fri Feb 7 22:44:27 2025 +0800
KAFKA-17833: Convert DescribeAuthorizedOperationsTest to use KRaft (#18252)
Reviewers: Mickael Maison <mi...@gmail.com>
---
checkstyle/import-control-core.xml | 1 +
.../admin/DescribeAuthorizedOperationsTest.java | 252 +++++++++++++++++++++
.../api/DescribeAuthorizedOperationsTest.scala | 211 -----------------
3 files changed, 253 insertions(+), 211 deletions(-)
diff --git a/checkstyle/import-control-core.xml b/checkstyle/import-control-core.xml
index ce3ae6ea7c5..4d804a2c723 100644
--- a/checkstyle/import-control-core.xml
+++ b/checkstyle/import-control-core.xml
@@ -135,6 +135,7 @@
<allow pkg="kafka.security.authorizer"/>
<allow pkg="kafka.server"/>
<allow pkg="kafka.zk"/>
+ <allow pkg="org.apache.kafka.clients"/>
<allow pkg="org.apache.kafka.clients.admin"/>
<allow pkg="org.apache.kafka.coordinator.group"/>
<allow pkg="org.apache.kafka.metadata"/>
diff --git a/core/src/test/java/kafka/admin/DescribeAuthorizedOperationsTest.java b/core/src/test/java/kafka/admin/DescribeAuthorizedOperationsTest.java
new file mode 100644
index 00000000000..d58f1d9ec6e
--- /dev/null
+++ b/core/src/test/java/kafka/admin/DescribeAuthorizedOperationsTest.java
@@ -0,0 +1,252 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package kafka.admin;
+
+import org.apache.kafka.clients.CommonClientConfigs;
+import org.apache.kafka.clients.admin.Admin;
+import org.apache.kafka.clients.admin.ConsumerGroupDescription;
+import org.apache.kafka.clients.admin.DescribeClusterOptions;
+import org.apache.kafka.clients.admin.DescribeConsumerGroupsOptions;
+import org.apache.kafka.clients.admin.DescribeConsumerGroupsResult;
+import org.apache.kafka.clients.admin.DescribeTopicsOptions;
+import org.apache.kafka.clients.admin.NewTopic;
+import org.apache.kafka.clients.admin.TopicDescription;
+import org.apache.kafka.clients.consumer.OffsetAndMetadata;
+import org.apache.kafka.common.TopicPartition;
+import org.apache.kafka.common.acl.AccessControlEntry;
+import org.apache.kafka.common.acl.AclBinding;
+import org.apache.kafka.common.acl.AclBindingFilter;
+import org.apache.kafka.common.acl.AclOperation;
+import org.apache.kafka.common.config.SaslConfigs;
+import org.apache.kafka.common.resource.PatternType;
+import org.apache.kafka.common.resource.Resource;
+import org.apache.kafka.common.resource.ResourcePattern;
+import org.apache.kafka.common.resource.ResourceType;
+import org.apache.kafka.common.security.auth.KafkaPrincipal;
+import org.apache.kafka.common.security.auth.SecurityProtocol;
+import org.apache.kafka.common.test.ClusterInstance;
+import org.apache.kafka.common.test.JaasUtils;
+import org.apache.kafka.common.test.api.ClusterConfig;
+import org.apache.kafka.common.test.api.ClusterTemplate;
+import org.apache.kafka.common.test.api.Type;
+import org.apache.kafka.common.test.junit.ClusterTestExtensions;
+import org.apache.kafka.coordinator.group.GroupCoordinatorConfig;
+import org.apache.kafka.security.authorizer.AclEntry;
+
+import org.junit.jupiter.api.extension.ExtendWith;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ExecutionException;
+
+import static org.apache.kafka.common.acl.AccessControlEntryFilter.ANY;
+import static org.apache.kafka.common.acl.AclOperation.ALL;
+import static org.apache.kafka.common.acl.AclOperation.ALTER;
+import static org.apache.kafka.common.acl.AclOperation.DELETE;
+import static org.apache.kafka.common.acl.AclOperation.DESCRIBE;
+import static org.apache.kafka.common.acl.AclPermissionType.ALLOW;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+@ExtendWith(ClusterTestExtensions.class)
+public class DescribeAuthorizedOperationsTest {
+ private static final String GROUP1 = "group1";
+ private static final String GROUP2 = "group2";
+ private static final String GROUP3 = "group3";
+ private static final ResourcePattern GROUP1_PATTERN = new ResourcePattern(ResourceType.GROUP, GROUP1, PatternType.LITERAL);
+ private static final ResourcePattern GROUP2_PATTERN = new ResourcePattern(ResourceType.GROUP, GROUP2, PatternType.LITERAL);
+ private static final ResourcePattern GROUP3_PATTERN = new ResourcePattern(ResourceType.GROUP, GROUP3, PatternType.LITERAL);
+ private static final ResourcePattern CLUSTER_PATTERN = new ResourcePattern(ResourceType.CLUSTER, Resource.CLUSTER_NAME, PatternType.LITERAL);
+ private static final AccessControlEntry ALTER_ENTRY = createAccessControlEntry(JaasUtils.KAFKA_PLAIN_USER1, ALTER);
+ private static final AccessControlEntry DESCRIBE_ENTRY = createAccessControlEntry(JaasUtils.KAFKA_PLAIN_USER1, DESCRIBE);
+
+ static List<ClusterConfig> generator() {
+ return List.of(
+ ClusterConfig.defaultBuilder()
+ .setTypes(Set.of(Type.KRAFT))
+ .setServerProperties(Map.of(GroupCoordinatorConfig.OFFSETS_TOPIC_PARTITIONS_CONFIG, "1"))
+ .setServerProperties(Map.of(GroupCoordinatorConfig.OFFSETS_TOPIC_REPLICATION_FACTOR_CONFIG, "1"))
+ .setBrokerSecurityProtocol(SecurityProtocol.SASL_PLAINTEXT)
+ .setControllerSecurityProtocol(SecurityProtocol.SASL_PLAINTEXT)
+ .build()
+ );
+ }
+
+ private static AccessControlEntry createAccessControlEntry(String username, AclOperation operation) {
+ return new AccessControlEntry(
+ new KafkaPrincipal(KafkaPrincipal.USER_TYPE, username).toString(),
+ AclEntry.WILDCARD_HOST,
+ operation,
+ ALLOW
+ );
+ }
+
+ private Map<String, Object> createAdminConfig(String username, String password) {
+ Map<String, Object> configs = new HashMap<>();
+ configs.put(CommonClientConfigs.SECURITY_PROTOCOL_CONFIG, SecurityProtocol.SASL_PLAINTEXT.name);
+ configs.put(SaslConfigs.SASL_MECHANISM, "PLAIN");
+ configs.put(SaslConfigs.SASL_JAAS_CONFIG,
+ String.format("org.apache.kafka.common.security.plain.PlainLoginModule required username=\"%s\" password=\"%s\";", username, password));
+ return configs;
+ }
+
+ private void setupSecurity(ClusterInstance clusterInstance) throws ExecutionException, InterruptedException {
+ try (Admin admin = clusterInstance.admin(createAdminConfig(JaasUtils.KAFKA_PLAIN_ADMIN, JaasUtils.KAFKA_PLAIN_ADMIN_PASSWORD))) {
+ ResourcePattern topicResource = new ResourcePattern(ResourceType.TOPIC, AclEntry.WILDCARD_RESOURCE, PatternType.LITERAL);
+
+ admin.createAcls(List.of(
+ new AclBinding(CLUSTER_PATTERN, ALTER_ENTRY),
+ new AclBinding(topicResource, DESCRIBE_ENTRY)
+ )).all().get();
+
+ clusterInstance.waitAcls(new AclBindingFilter(CLUSTER_PATTERN.toFilter(), ANY), Set.of(ALTER_ENTRY));
+ clusterInstance.waitAcls(new AclBindingFilter(topicResource.toFilter(), ANY), Set.of(DESCRIBE_ENTRY));
+ }
+ }
+
+ @ClusterTemplate("generator")
+ public void testConsumerGroupAuthorizedOperations(ClusterInstance clusterInstance) throws ExecutionException, InterruptedException {
+ setupSecurity(clusterInstance);
+ try (Admin admin = clusterInstance.admin(createAdminConfig(JaasUtils.KAFKA_PLAIN_ADMIN, JaasUtils.KAFKA_PLAIN_ADMIN_PASSWORD));
+ Admin user1 = clusterInstance.admin(createAdminConfig(JaasUtils.KAFKA_PLAIN_USER1, JaasUtils.KAFKA_PLAIN_USER1_PASSWORD));
+ ) {
+ admin.createTopics(List.of(new NewTopic("topic1", 1, (short) 1)));
+ clusterInstance.waitForTopic("topic1", 1);
+
+ // create consumers to avoid group not found error
+ TopicPartition tp = new TopicPartition("topic1", 0);
+ OffsetAndMetadata offsetAndMetadata = new OffsetAndMetadata(0);
+ admin.alterConsumerGroupOffsets(GROUP1, Map.of(tp, offsetAndMetadata)).all().get();
+ admin.alterConsumerGroupOffsets(GROUP2, Map.of(tp, offsetAndMetadata)).all().get();
+ admin.alterConsumerGroupOffsets(GROUP3, Map.of(tp, offsetAndMetadata)).all().get();
+
+ AccessControlEntry allOperationsEntry = createAccessControlEntry(JaasUtils.KAFKA_PLAIN_USER1, ALL);
+ AccessControlEntry describeEntry = createAccessControlEntry(JaasUtils.KAFKA_PLAIN_USER1, DESCRIBE);
+ AccessControlEntry deleteEntry = createAccessControlEntry(JaasUtils.KAFKA_PLAIN_USER1, DELETE);
+ user1.createAcls(List.of(
+ new AclBinding(GROUP1_PATTERN, allOperationsEntry),
+ new AclBinding(GROUP2_PATTERN, describeEntry),
+ new AclBinding(GROUP3_PATTERN, deleteEntry)
+ )).all();
+ clusterInstance.waitAcls(new AclBindingFilter(GROUP1_PATTERN.toFilter(), ANY), Set.of(allOperationsEntry));
+ clusterInstance.waitAcls(new AclBindingFilter(GROUP2_PATTERN.toFilter(), ANY), Set.of(describeEntry));
+ clusterInstance.waitAcls(new AclBindingFilter(GROUP3_PATTERN.toFilter(), ANY), Set.of(deleteEntry));
+
+ DescribeConsumerGroupsResult describeConsumerGroupsResult = user1.describeConsumerGroups(
+ List.of(GROUP1, GROUP2, GROUP3), new DescribeConsumerGroupsOptions().includeAuthorizedOperations(true));
+ assertEquals(3, describeConsumerGroupsResult.describedGroups().size());
+
+ ConsumerGroupDescription group1Description = describeConsumerGroupsResult.describedGroups().get(GROUP1).get();
+ assertEquals(AclEntry.supportedOperations(ResourceType.GROUP), group1Description.authorizedOperations());
+
+ ConsumerGroupDescription group2Description = describeConsumerGroupsResult.describedGroups().get(GROUP2).get();
+ assertEquals(Set.of(DESCRIBE), group2Description.authorizedOperations());
+
+ ConsumerGroupDescription group3Description = describeConsumerGroupsResult.describedGroups().get(GROUP3).get();
+ assertEquals(Set.of(DESCRIBE, DELETE), group3Description.authorizedOperations());
+ }
+ }
+
+ @ClusterTemplate("generator")
+ public void testClusterAuthorizedOperations(ClusterInstance clusterInstance) throws ExecutionException, InterruptedException {
+ setupSecurity(clusterInstance);
+ try (Admin admin = clusterInstance.admin(createAdminConfig(JaasUtils.KAFKA_PLAIN_USER1, JaasUtils.KAFKA_PLAIN_USER1_PASSWORD))) {
+ // test without includeAuthorizedOperations flag
+ Set<AclOperation> authorizedOperations = admin.describeCluster().authorizedOperations().get();
+ assertNull(authorizedOperations);
+
+ // test with includeAuthorizedOperations flag
+ authorizedOperations = admin.describeCluster(new DescribeClusterOptions().includeAuthorizedOperations(true)).authorizedOperations().get();
+ assertEquals(Set.of(DESCRIBE, ALTER), authorizedOperations);
+ }
+
+ // enable all operations for cluster resource
+ try (Admin admin = clusterInstance.admin(createAdminConfig(JaasUtils.KAFKA_PLAIN_ADMIN, JaasUtils.KAFKA_PLAIN_ADMIN_PASSWORD))) {
+ AccessControlEntry allOperationEntry = createAccessControlEntry(JaasUtils.KAFKA_PLAIN_USER1, ALL);
+ admin.createAcls(List.of(new AclBinding(CLUSTER_PATTERN, allOperationEntry))).all().get();
+ clusterInstance.waitAcls(
+ new AclBindingFilter(CLUSTER_PATTERN.toFilter(), ANY),
+ Set.of(allOperationEntry, ALTER_ENTRY)
+ );
+ }
+
+ try (Admin admin = clusterInstance.admin(createAdminConfig(JaasUtils.KAFKA_PLAIN_USER1, JaasUtils.KAFKA_PLAIN_USER1_PASSWORD))) {
+ Set<AclOperation> authorizedOperations = admin.describeCluster(new DescribeClusterOptions().includeAuthorizedOperations(true)).authorizedOperations().get();
+ assertEquals(AclEntry.supportedOperations(ResourceType.CLUSTER), authorizedOperations);
+ }
+ }
+
+ @ClusterTemplate("generator")
+ public void testTopicAuthorizedOperations(ClusterInstance clusterInstance) throws ExecutionException, InterruptedException {
+ String topic1 = "topic1";
+ String topic2 = "topic2";
+ setupSecurity(clusterInstance);
+ try (Admin admin = clusterInstance.admin(createAdminConfig(JaasUtils.KAFKA_PLAIN_ADMIN, JaasUtils.KAFKA_PLAIN_ADMIN_PASSWORD))) {
+ admin.createTopics(List.of(
+ new NewTopic(topic1, 1, (short) 1),
+ new NewTopic(topic2, 1, (short) 1)
+ ));
+ clusterInstance.waitForTopic(topic1, 1);
+ clusterInstance.waitForTopic(topic2, 1);
+ }
+
+ try (Admin admin = clusterInstance.admin(createAdminConfig(JaasUtils.KAFKA_PLAIN_USER1, JaasUtils.KAFKA_PLAIN_USER1_PASSWORD))) {
+ // test without includeAuthorizedOperations flag
+ Map<String, TopicDescription> topicDescriptions = admin.describeTopics(List.of(topic1, topic2)).allTopicNames().get();
+ assertNull(topicDescriptions.get(topic1).authorizedOperations());
+ assertNull(topicDescriptions.get(topic2).authorizedOperations());
+
+ // test with includeAuthorizedOperations flag
+ topicDescriptions = admin.describeTopics(
+ List.of(topic1, topic2),
+ new DescribeTopicsOptions().includeAuthorizedOperations(true)).allTopicNames().get();
+ assertEquals(Set.of(DESCRIBE), topicDescriptions.get(topic1).authorizedOperations());
+ assertEquals(Set.of(DESCRIBE), topicDescriptions.get(topic2).authorizedOperations());
+ }
+
+ // add few permissions
+ try (Admin admin = clusterInstance.admin(createAdminConfig(JaasUtils.KAFKA_PLAIN_ADMIN, JaasUtils.KAFKA_PLAIN_ADMIN_PASSWORD))) {
+ ResourcePattern topic1Resource = new ResourcePattern(ResourceType.TOPIC, topic1, PatternType.LITERAL);
+ ResourcePattern topic2Resource = new ResourcePattern(ResourceType.TOPIC, topic2, PatternType.LITERAL);
+ AccessControlEntry allOperationEntry = createAccessControlEntry(JaasUtils.KAFKA_PLAIN_USER1, ALL);
+ AccessControlEntry deleteEntry = createAccessControlEntry(JaasUtils.KAFKA_PLAIN_USER1, DELETE);
+ admin.createAcls(List.of(
+ new AclBinding(topic1Resource, allOperationEntry),
+ new AclBinding(topic2Resource, deleteEntry)
+ )).all().get();
+ clusterInstance.waitAcls(
+ new AclBindingFilter(topic1Resource.toFilter(), ANY),
+ Set.of(allOperationEntry)
+ );
+ clusterInstance.waitAcls(
+ new AclBindingFilter(topic2Resource.toFilter(), ANY),
+ Set.of(deleteEntry)
+ );
+ }
+
+ try (Admin admin = clusterInstance.admin(createAdminConfig(JaasUtils.KAFKA_PLAIN_USER1, JaasUtils.KAFKA_PLAIN_USER1_PASSWORD))) {
+ Map<String, TopicDescription> topicDescriptions = admin.describeTopics(
+ List.of(topic1, topic2),
+ new DescribeTopicsOptions().includeAuthorizedOperations(true)).allTopicNames().get();
+ assertEquals(AclEntry.supportedOperations(ResourceType.TOPIC), topicDescriptions.get(topic1).authorizedOperations());
+ assertEquals(Set.of(DESCRIBE, DELETE), topicDescriptions.get(topic2).authorizedOperations());
+ }
+ }
+}
\ No newline at end of file
diff --git a/core/src/test/scala/integration/kafka/api/DescribeAuthorizedOperationsTest.scala b/core/src/test/scala/integration/kafka/api/DescribeAuthorizedOperationsTest.scala
deleted file mode 100644
index c7426c0d78e..00000000000
--- a/core/src/test/scala/integration/kafka/api/DescribeAuthorizedOperationsTest.scala
+++ /dev/null
@@ -1,211 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE
- * file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file
- * to You under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the
- * License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
- * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations under the License.
- */
-package kafka.api
-
-import kafka.security.JaasTestUtils
-
-import java.util
-import java.util.Properties
-import kafka.utils.{CoreUtils, TestUtils}
-import org.apache.kafka.clients.admin._
-import org.apache.kafka.common.acl.AclOperation.{ALL, ALTER, CLUSTER_ACTION, DELETE, DESCRIBE}
-import org.apache.kafka.common.acl.AclPermissionType.ALLOW
-import org.apache.kafka.common.acl._
-import org.apache.kafka.common.resource.{PatternType, Resource, ResourcePattern, ResourceType}
-import org.apache.kafka.common.security.auth.{KafkaPrincipal, SecurityProtocol}
-import org.apache.kafka.common.utils.Utils
-import org.apache.kafka.metadata.authorizer.StandardAuthorizer
-import org.apache.kafka.security.authorizer.AclEntry
-import org.apache.kafka.server.authorizer.Authorizer
-import org.apache.kafka.server.config.ServerConfigs
-import org.junit.jupiter.api.Assertions.{assertEquals, assertFalse, assertNull}
-import org.junit.jupiter.api.{AfterEach, BeforeEach, Disabled, Test, TestInfo}
-
-import scala.jdk.CollectionConverters._
-import scala.jdk.javaapi.OptionConverters
-
-object DescribeAuthorizedOperationsTest {
- val Group1 = "group1"
- val Group2 = "group2"
- val Group3 = "group3"
- val Topic1 = "topic1"
- val Topic2 = "topic2"
-
- val Group1Acl = new AclBinding(
- new ResourcePattern(ResourceType.GROUP, Group1, PatternType.LITERAL),
- accessControlEntry(JaasTestUtils.KAFKA_CLIENT_PRINCIPAL_UNQUALIFIED_NAME_2, ALL))
-
- val Group2Acl = new AclBinding(
- new ResourcePattern(ResourceType.GROUP, Group2, PatternType.LITERAL),
- accessControlEntry(JaasTestUtils.KAFKA_CLIENT_PRINCIPAL_UNQUALIFIED_NAME_2, DESCRIBE))
-
- val Group3Acl = new AclBinding(
- new ResourcePattern(ResourceType.GROUP, Group3, PatternType.LITERAL),
- accessControlEntry(JaasTestUtils.KAFKA_CLIENT_PRINCIPAL_UNQUALIFIED_NAME_2, DELETE))
-
- val ClusterAllAcl = new AclBinding(
- new ResourcePattern(ResourceType.CLUSTER, Resource.CLUSTER_NAME, PatternType.LITERAL),
- accessControlEntry(JaasTestUtils.KAFKA_CLIENT_PRINCIPAL_UNQUALIFIED_NAME_2, ALL))
-
- val Topic1Acl = new AclBinding(
- new ResourcePattern(ResourceType.TOPIC, Topic1, PatternType.LITERAL),
- accessControlEntry(JaasTestUtils.KAFKA_CLIENT_PRINCIPAL_UNQUALIFIED_NAME_2, ALL))
-
- val Topic2All = new AclBinding(
- new ResourcePattern(ResourceType.TOPIC, Topic2, PatternType.LITERAL),
- accessControlEntry(JaasTestUtils.KAFKA_CLIENT_PRINCIPAL_UNQUALIFIED_NAME_2, DELETE))
-
- private def accessControlEntry(
- userName: String,
- operation: AclOperation
- ): AccessControlEntry = {
- new AccessControlEntry(new KafkaPrincipal(KafkaPrincipal.USER_TYPE, userName).toString,
- AclEntry.WILDCARD_HOST, operation, ALLOW)
- }
-}
-
-@Disabled("KAFKA-17833: change to use kraft")
-class DescribeAuthorizedOperationsTest extends IntegrationTestHarness with SaslSetup {
- import DescribeAuthorizedOperationsTest._
-
- override val brokerCount = 1
- this.serverConfig.setProperty(ServerConfigs.AUTHORIZER_CLASS_NAME_CONFIG, classOf[StandardAuthorizer].getName)
-
- var client: Admin = _
-
- override protected def securityProtocol = SecurityProtocol.SASL_SSL
-
- override protected lazy val trustStoreFile = Some(TestUtils.tempFile("truststore", ".jks"))
-
- override def configureSecurityBeforeServersStart(testInfo: TestInfo): Unit = {
- val authorizer = CoreUtils.createObject[Authorizer](classOf[StandardAuthorizer].getName)
- val clusterResource = new ResourcePattern(ResourceType.CLUSTER, Resource.CLUSTER_NAME, PatternType.LITERAL)
- val topicResource = new ResourcePattern(ResourceType.TOPIC, AclEntry.WILDCARD_RESOURCE, PatternType.LITERAL)
-
- try {
- authorizer.configure(this.configs.head.originals())
- val result = authorizer.createAcls(null, List(
- new AclBinding(clusterResource, accessControlEntry(
- JaasTestUtils.KAFKA_SERVER_PRINCIPAL_UNQUALIFIED_NAME, CLUSTER_ACTION)),
- new AclBinding(clusterResource, accessControlEntry(
- JaasTestUtils.KAFKA_CLIENT_PRINCIPAL_UNQUALIFIED_NAME_2, ALTER)),
- new AclBinding(topicResource, accessControlEntry(
- JaasTestUtils.KAFKA_CLIENT_PRINCIPAL_UNQUALIFIED_NAME_2, DESCRIBE))
- ).asJava)
- result.asScala.map(_.toCompletableFuture.get).foreach(result => assertFalse(result.exception.isPresent))
- } finally {
- authorizer.close()
- }
- }
-
- @BeforeEach
- override def setUp(testInfo: TestInfo): Unit = {
- startSasl(jaasSections(Seq("GSSAPI"), Some("GSSAPI"), JaasTestUtils.KAFKA_SERVER_CONTEXT_NAME))
- super.setUp(testInfo)
- TestUtils.waitUntilBrokerMetadataIsPropagated(servers)
- client = Admin.create(createConfig())
- }
-
- @AfterEach
- override def tearDown(): Unit = {
- Utils.closeQuietly(client, "AdminClient")
- super.tearDown()
- closeSasl()
- }
-
- private def createConfig(): Properties = {
- val adminClientConfig = new Properties()
- adminClientConfig.put(AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers())
- adminClientConfig.put(AdminClientConfig.REQUEST_TIMEOUT_MS_CONFIG, "20000")
- val securityProps: util.Map[Object, Object] =
- JaasTestUtils.adminClientSecurityConfigs(securityProtocol, OptionConverters.toJava(trustStoreFile), OptionConverters.toJava(clientSaslProperties))
- adminClientConfig.putAll(securityProps)
- adminClientConfig
- }
-
- @Test
- def testConsumerGroupAuthorizedOperations(): Unit = {
- val results = client.createAcls(List(Group1Acl, Group2Acl, Group3Acl).asJava)
- assertEquals(Set(Group1Acl, Group2Acl, Group3Acl), results.values.keySet.asScala)
- results.all.get
-
- val describeConsumerGroupsResult = client.describeConsumerGroups(Seq(Group1, Group2, Group3).asJava,
- new DescribeConsumerGroupsOptions().includeAuthorizedOperations(true))
- assertEquals(3, describeConsumerGroupsResult.describedGroups().size())
- val expectedOperations = AclEntry.supportedOperations(ResourceType.GROUP)
-
- val group1Description = describeConsumerGroupsResult.describedGroups().get(Group1).get
- assertEquals(expectedOperations, group1Description.authorizedOperations())
-
- val group2Description = describeConsumerGroupsResult.describedGroups().get(Group2).get
- assertEquals(Set(AclOperation.DESCRIBE), group2Description.authorizedOperations().asScala.toSet)
-
- val group3Description = describeConsumerGroupsResult.describedGroups().get(Group3).get
- assertEquals(Set(AclOperation.DESCRIBE, AclOperation.DELETE), group3Description.authorizedOperations().asScala.toSet)
- }
-
- @Test
- def testClusterAuthorizedOperations(): Unit = {
- // test without includeAuthorizedOperations flag
- var clusterDescribeResult = client.describeCluster()
- assertNull(clusterDescribeResult.authorizedOperations.get())
-
- // test with includeAuthorizedOperations flag, we have give Alter permission
- // in configureSecurityBeforeServersStart()
- clusterDescribeResult = client.describeCluster(new DescribeClusterOptions().
- includeAuthorizedOperations(true))
- assertEquals(Set(AclOperation.DESCRIBE, AclOperation.ALTER),
- clusterDescribeResult.authorizedOperations().get().asScala.toSet)
-
- // enable all operations for cluster resource
- val results = client.createAcls(List(ClusterAllAcl).asJava)
- assertEquals(Set(ClusterAllAcl), results.values.keySet.asScala)
- results.all.get
-
- val expectedOperations = AclEntry.supportedOperations(ResourceType.CLUSTER)
-
- clusterDescribeResult = client.describeCluster(new DescribeClusterOptions().
- includeAuthorizedOperations(true))
- assertEquals(expectedOperations, clusterDescribeResult.authorizedOperations().get())
- }
-
- @Test
- def testTopicAuthorizedOperations(): Unit = {
- createTopic(Topic1)
- createTopic(Topic2)
-
- // test without includeAuthorizedOperations flag
- var describeTopicsResult = client.describeTopics(Set(Topic1, Topic2).asJava).allTopicNames.get()
- assertNull(describeTopicsResult.get(Topic1).authorizedOperations)
- assertNull(describeTopicsResult.get(Topic2).authorizedOperations)
-
- // test with includeAuthorizedOperations flag
- describeTopicsResult = client.describeTopics(Set(Topic1, Topic2).asJava,
- new DescribeTopicsOptions().includeAuthorizedOperations(true)).allTopicNames.get()
- assertEquals(Set(AclOperation.DESCRIBE), describeTopicsResult.get(Topic1).authorizedOperations().asScala.toSet)
- assertEquals(Set(AclOperation.DESCRIBE), describeTopicsResult.get(Topic2).authorizedOperations().asScala.toSet)
-
- // add few permissions
- val results = client.createAcls(List(Topic1Acl, Topic2All).asJava)
- assertEquals(Set(Topic1Acl, Topic2All), results.values.keySet.asScala)
- results.all.get
-
- val expectedOperations = AclEntry.supportedOperations(ResourceType.TOPIC)
-
- describeTopicsResult = client.describeTopics(Set(Topic1, Topic2).asJava,
- new DescribeTopicsOptions().includeAuthorizedOperations(true)).allTopicNames.get()
- assertEquals(expectedOperations, describeTopicsResult.get(Topic1).authorizedOperations())
- assertEquals(Set(AclOperation.DESCRIBE, AclOperation.DELETE),
- describeTopicsResult.get(Topic2).authorizedOperations().asScala.toSet)
- }
-}