You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@kafka.apache.org by ch...@apache.org on 2026/08/06 04:50:04 UTC
(kafka) branch trunk updated: MINOR: Split KafkaAdminClientTest into per-domain test classes (#22339)
This is an automated email from the ASF dual-hosted git repository.
chia7712 pushed a commit to branch trunk
in repository https://gitbox.apache.org/repos/asf/kafka.git
The following commit(s) were added to refs/heads/trunk by this push:
new 1a443b2d234 MINOR: Split KafkaAdminClientTest into per-domain test classes (#22339)
1a443b2d234 is described below
commit 1a443b2d234dadd0b66d8f404e7d61ea4f38b924
Author: Sanskar Jhajharia <sj...@confluent.io>
AuthorDate: Thu Aug 6 10:19:46 2026 +0530
MINOR: Split KafkaAdminClientTest into per-domain test classes (#22339)
### What
Split
clients/src/test/java/org/apache/kafka/clients/admin/KafkaAdminClientTest.java
(11,770 lines, 274 tests, 80 helpers) into one abstract base + 7
cohesive test classes:
- KafkaAdminClientTestBase.java: Abstract base -- all common helpers +
constants
- KafkaAdminClientTest.java: Lifecycle, cluster, features, raft, quorum,
broker unregister, telemetry, ListConfigResources, top-level timeouts
- KafkaAdminClientTopicTest.java: Topics, partitions, replicas, log
dirs, offsets, records, reassignments, leader election
- KafkaAdminClientConsumerGroupTest.java: Consumer + classic groups
(list / describe / delete / offsets / alter / remove-members)
- KafkaAdminClientStreamsGroupTest.java: Streams Group tests
- KafkaAdminClientShareGroupTest.java: Share Group Tests
- KafkaAdminClientConfigTest.java: ACLs, configs, SCRAM credentials,
client quotas
- KafkaAdminClientTransactionTest.java: Transactions + producer fencing
### Why
The original file had grown to ~3× the size of the next-largest test in
the clients module. Every new KIP that adds an Admin API extends it
further (recent additions: share groups, streams groups). The size hurt:
- IDE indexing and incremental compile were slow on this single file.
- Selective re-runs (--tests "*ShareGroup*") had to scan the whole file.
- A contributor working on one Admin API had to scroll through hundreds
of unrelated tests.
- 307 imports — most tests only needed a fraction.
```
KafkaAdminClientTest: 74 tests
KafkaAdminClientTopicTest: 62 tests
KafkaAdminClientConsumerGroupTest: 68 tests
KafkaAdminClientStreamsGroupTest: 29 tests
KafkaAdminClientShareGroupTest: 22 tests
KafkaAdminClientConfigTest: 19 tests
KafkaAdminClientTransactionTest: 13 tests
```
Reviewers: nileshkumar3 <ni...@gmail.com>, Chia-Ping Tsai
<ch...@gmail.com>
---
checkstyle/suppressions.xml | 4 +
.../clients/admin/KafkaAdminClientConfigTest.java | 788 ++
.../admin/KafkaAdminClientConsumerGroupTest.java | 3361 ++++++
.../admin/KafkaAdminClientShareGroupTest.java | 987 ++
.../admin/KafkaAdminClientStreamsGroupTest.java | 1464 +++
.../kafka/clients/admin/KafkaAdminClientTest.java | 11817 ++-----------------
.../clients/admin/KafkaAdminClientTestBase.java | 284 +
.../clients/admin/KafkaAdminClientTopicTest.java | 3078 +++++
.../admin/KafkaAdminClientTransactionTest.java | 642 +
9 files changed, 11459 insertions(+), 10966 deletions(-)
diff --git a/checkstyle/suppressions.xml b/checkstyle/suppressions.xml
index db005b5c37c..549743ef46e 100644
--- a/checkstyle/suppressions.xml
+++ b/checkstyle/suppressions.xml
@@ -91,6 +91,10 @@
<suppress checks="ClassFanOutComplexity"
files="(ConsumerCoordinator|KafkaConsumer|RequestResponse|Fetcher|FetchRequestManager|KafkaAdminClient|Message|KafkaProducer|NetworkClient|StreamsGroupHeartbeatRequestManager)Test.java"/>
+ <!-- KafkaAdminClient test split: shared base + per-domain test classes -->
+ <suppress checks="(ClassDataAbstractionCoupling|ClassFanOutComplexity|JavaNCSS)"
+ files="KafkaAdminClient(TestBase|TopicTest|ConsumerGroupTest|StreamsGroupTest|ShareGroupTest|ConfigTest|TransactionTest)\.java"/>
+
<suppress checks="ClassFanOutComplexity"
files="MockAdminClient.java"/>
diff --git a/clients/src/test/java/org/apache/kafka/clients/admin/KafkaAdminClientConfigTest.java b/clients/src/test/java/org/apache/kafka/clients/admin/KafkaAdminClientConfigTest.java
new file mode 100644
index 00000000000..9dd2801f192
--- /dev/null
+++ b/clients/src/test/java/org/apache/kafka/clients/admin/KafkaAdminClientConfigTest.java
@@ -0,0 +1,788 @@
+/*
+ * 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 org.apache.kafka.clients.admin;
+
+import org.apache.kafka.clients.NodeApiVersions;
+import org.apache.kafka.clients.admin.DeleteAclsResult.FilterResults;
+import org.apache.kafka.common.KafkaFuture;
+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.acl.AclPermissionType;
+import org.apache.kafka.common.config.ConfigResource;
+import org.apache.kafka.common.errors.ApiException;
+import org.apache.kafka.common.errors.ClusterAuthorizationException;
+import org.apache.kafka.common.errors.InvalidConfigurationException;
+import org.apache.kafka.common.errors.InvalidRequestException;
+import org.apache.kafka.common.errors.SecurityDisabledException;
+import org.apache.kafka.common.message.AlterUserScramCredentialsResponseData;
+import org.apache.kafka.common.message.CreateAclsResponseData;
+import org.apache.kafka.common.message.DeleteAclsResponseData;
+import org.apache.kafka.common.message.DescribeAclsResponseData;
+import org.apache.kafka.common.message.DescribeConfigsResponseData;
+import org.apache.kafka.common.message.DescribeUserScramCredentialsResponseData;
+import org.apache.kafka.common.message.DescribeUserScramCredentialsResponseData.CredentialInfo;
+import org.apache.kafka.common.message.IncrementalAlterConfigsResponseData;
+import org.apache.kafka.common.message.IncrementalAlterConfigsResponseData.AlterConfigsResourceResponse;
+import org.apache.kafka.common.protocol.ApiKeys;
+import org.apache.kafka.common.protocol.Errors;
+import org.apache.kafka.common.quota.ClientQuotaAlteration;
+import org.apache.kafka.common.quota.ClientQuotaEntity;
+import org.apache.kafka.common.quota.ClientQuotaFilter;
+import org.apache.kafka.common.quota.ClientQuotaFilterComponent;
+import org.apache.kafka.common.requests.AlterClientQuotasResponse;
+import org.apache.kafka.common.requests.AlterUserScramCredentialsResponse;
+import org.apache.kafka.common.requests.ApiError;
+import org.apache.kafka.common.requests.CreateAclsResponse;
+import org.apache.kafka.common.requests.DeleteAclsResponse;
+import org.apache.kafka.common.requests.DescribeAclsResponse;
+import org.apache.kafka.common.requests.DescribeClientQuotasResponse;
+import org.apache.kafka.common.requests.DescribeConfigsResponse;
+import org.apache.kafka.common.requests.DescribeUserScramCredentialsResponse;
+import org.apache.kafka.common.requests.IncrementalAlterConfigsResponse;
+import org.apache.kafka.common.requests.MetadataResponse;
+import org.apache.kafka.common.resource.ResourceType;
+import org.apache.kafka.test.TestUtils;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ExecutionException;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static java.util.Arrays.asList;
+import static java.util.Collections.emptyList;
+import static java.util.Collections.singleton;
+import static java.util.Collections.singletonList;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class KafkaAdminClientConfigTest extends KafkaAdminClientTestBase {
+
+ @Test
+ public void testDescribeAcls() throws Exception {
+ try (AdminClientUnitTestEnv env = mockClientEnv()) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ // Test a call where we get back ACL1 and ACL2.
+ env.kafkaClient().prepareResponse(new DescribeAclsResponse(new DescribeAclsResponseData()
+ .setResources(DescribeAclsResponse.aclsResources(asList(ACL1, ACL2))), ApiKeys.DESCRIBE_ACLS.latestVersion()));
+ assertCollectionIs(env.adminClient().describeAcls(FILTER1).values().get(), ACL1, ACL2);
+
+ // Test a call where we get back no results.
+ env.kafkaClient().prepareResponse(new DescribeAclsResponse(new DescribeAclsResponseData(),
+ ApiKeys.DESCRIBE_ACLS.latestVersion()));
+ assertTrue(env.adminClient().describeAcls(FILTER2).values().get().isEmpty());
+
+ // Test a call where we get back an error.
+ env.kafkaClient().prepareResponse(new DescribeAclsResponse(new DescribeAclsResponseData()
+ .setErrorCode(Errors.SECURITY_DISABLED.code())
+ .setErrorMessage("Security is disabled"), ApiKeys.DESCRIBE_ACLS.latestVersion()));
+ TestUtils.assertFutureThrows(SecurityDisabledException.class, env.adminClient().describeAcls(FILTER2).values());
+
+ // Test a call where we supply an invalid filter.
+ TestUtils.assertFutureThrows(InvalidRequestException.class, env.adminClient().describeAcls(UNKNOWN_FILTER).values());
+ }
+ }
+
+ @Test
+ public void testCreateAclsToController() throws Exception {
+ try (AdminClientUnitTestEnv env = mockClientEnv(AdminClientConfig.BOOTSTRAP_CONTROLLERS_CONFIG, "dummy")) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(new CreateAclsResponse(new CreateAclsResponseData().setResults(asList(
+ new CreateAclsResponseData.AclCreationResult()
+ .setErrorCode(Errors.NOT_CONTROLLER.code())
+ .setErrorMessage("not controller")))));
+ // should retry the describe cluster to update the metadata
+ env.kafkaClient().prepareResponse(
+ prepareDescribeClusterResponse(0,
+ env.cluster().nodes(),
+ env.cluster().clusterResource().clusterId(),
+ 2,
+ MetadataResponse.AUTHORIZED_OPERATIONS_OMITTED,
+ true)
+ );
+
+ // Test a call where we successfully create two ACLs.
+ env.kafkaClient().prepareResponse(new CreateAclsResponse(new CreateAclsResponseData().setResults(asList(
+ new CreateAclsResponseData.AclCreationResult()))));
+
+ CreateAclsResult results = env.adminClient().createAcls(asList(ACL1));
+ assertCollectionIs(results.values().keySet(), ACL1);
+ for (KafkaFuture<Void> future : results.values().values())
+ future.get();
+ results.all().get();
+ }
+ }
+
+ @Test
+ public void testDeleteAclsToController() throws Exception {
+ try (AdminClientUnitTestEnv env = mockClientEnv(AdminClientConfig.BOOTSTRAP_CONTROLLERS_CONFIG, "dummy")) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(new DeleteAclsResponse(new DeleteAclsResponseData()
+ .setThrottleTimeMs(0)
+ .setFilterResults(asList(new DeleteAclsResponseData.DeleteAclsFilterResult()
+ .setErrorCode(Errors.NOT_CONTROLLER.code())
+ .setErrorMessage("not controller"))),
+ ApiKeys.DELETE_ACLS.latestVersion()));
+ // should retry the describe cluster to update the metadata
+ env.kafkaClient().prepareResponse(
+ prepareDescribeClusterResponse(0,
+ env.cluster().nodes(),
+ env.cluster().clusterResource().clusterId(),
+ 2,
+ MetadataResponse.AUTHORIZED_OPERATIONS_OMITTED,
+ true)
+ );
+ // Test a call where there are no errors.
+ env.kafkaClient().prepareResponse(new DeleteAclsResponse(new DeleteAclsResponseData()
+ .setThrottleTimeMs(0)
+ .setFilterResults(asList(
+ new DeleteAclsResponseData.DeleteAclsFilterResult()
+ .setMatchingAcls(singletonList(DeleteAclsResponse.matchingAcl(ACL1, ApiError.NONE))))),
+ ApiKeys.DELETE_ACLS.latestVersion()));
+ DeleteAclsResult results = env.adminClient().deleteAcls(asList(FILTER1));
+ Collection<AclBinding> deleted = results.all().get();
+ assertCollectionIs(deleted, ACL1);
+ }
+ }
+
+ @Test
+ public void testCreateAcls() throws Exception {
+ try (AdminClientUnitTestEnv env = mockClientEnv()) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ // Test a call where we successfully create two ACLs.
+ env.kafkaClient().prepareResponse(new CreateAclsResponse(new CreateAclsResponseData().setResults(asList(
+ new CreateAclsResponseData.AclCreationResult(),
+ new CreateAclsResponseData.AclCreationResult()))));
+ CreateAclsResult results = env.adminClient().createAcls(asList(ACL1, ACL2));
+ assertCollectionIs(results.values().keySet(), ACL1, ACL2);
+ for (KafkaFuture<Void> future : results.values().values())
+ future.get();
+ results.all().get();
+
+ // Test a call where we fail to create one ACL.
+ env.kafkaClient().prepareResponse(new CreateAclsResponse(new CreateAclsResponseData().setResults(asList(
+ new CreateAclsResponseData.AclCreationResult()
+ .setErrorCode(Errors.SECURITY_DISABLED.code())
+ .setErrorMessage("Security is disabled"),
+ new CreateAclsResponseData.AclCreationResult()))));
+ results = env.adminClient().createAcls(asList(ACL1, ACL2));
+ assertCollectionIs(results.values().keySet(), ACL1, ACL2);
+ TestUtils.assertFutureThrows(SecurityDisabledException.class, results.values().get(ACL1));
+ results.values().get(ACL2).get();
+ TestUtils.assertFutureThrows(SecurityDisabledException.class, results.all());
+ }
+ }
+
+ @Test
+ public void testDeleteAcls() throws Exception {
+ try (AdminClientUnitTestEnv env = mockClientEnv()) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ // Test a call where one filter has an error.
+ env.kafkaClient().prepareResponse(new DeleteAclsResponse(new DeleteAclsResponseData()
+ .setThrottleTimeMs(0)
+ .setFilterResults(asList(
+ new DeleteAclsResponseData.DeleteAclsFilterResult()
+ .setMatchingAcls(asList(
+ DeleteAclsResponse.matchingAcl(ACL1, ApiError.NONE),
+ DeleteAclsResponse.matchingAcl(ACL2, ApiError.NONE))),
+ new DeleteAclsResponseData.DeleteAclsFilterResult()
+ .setErrorCode(Errors.SECURITY_DISABLED.code())
+ .setErrorMessage("No security"))),
+ ApiKeys.DELETE_ACLS.latestVersion()));
+ DeleteAclsResult results = env.adminClient().deleteAcls(asList(FILTER1, FILTER2));
+ Map<AclBindingFilter, KafkaFuture<FilterResults>> filterResults = results.values();
+ FilterResults filter1Results = filterResults.get(FILTER1).get();
+ assertNull(filter1Results.values().get(0).exception());
+ assertEquals(ACL1, filter1Results.values().get(0).binding());
+ assertNull(filter1Results.values().get(1).exception());
+ assertEquals(ACL2, filter1Results.values().get(1).binding());
+ TestUtils.assertFutureThrows(SecurityDisabledException.class, filterResults.get(FILTER2));
+ TestUtils.assertFutureThrows(SecurityDisabledException.class, results.all());
+
+ // Test a call where one deletion result has an error.
+ env.kafkaClient().prepareResponse(new DeleteAclsResponse(new DeleteAclsResponseData()
+ .setThrottleTimeMs(0)
+ .setFilterResults(asList(
+ new DeleteAclsResponseData.DeleteAclsFilterResult()
+ .setMatchingAcls(asList(
+ DeleteAclsResponse.matchingAcl(ACL1, ApiError.NONE),
+ new DeleteAclsResponseData.DeleteAclsMatchingAcl()
+ .setErrorCode(Errors.SECURITY_DISABLED.code())
+ .setErrorMessage("No security")
+ .setPermissionType(AclPermissionType.ALLOW.code())
+ .setOperation(AclOperation.ALTER.code())
+ .setResourceType(ResourceType.CLUSTER.code())
+ .setPatternType(FILTER2.patternFilter().patternType().code()))),
+ new DeleteAclsResponseData.DeleteAclsFilterResult())),
+ ApiKeys.DELETE_ACLS.latestVersion()));
+ results = env.adminClient().deleteAcls(asList(FILTER1, FILTER2));
+ assertTrue(results.values().get(FILTER2).get().values().isEmpty());
+ TestUtils.assertFutureThrows(SecurityDisabledException.class, results.all());
+
+ // Test a call where there are no errors.
+ env.kafkaClient().prepareResponse(new DeleteAclsResponse(new DeleteAclsResponseData()
+ .setThrottleTimeMs(0)
+ .setFilterResults(asList(
+ new DeleteAclsResponseData.DeleteAclsFilterResult()
+ .setMatchingAcls(singletonList(DeleteAclsResponse.matchingAcl(ACL1, ApiError.NONE))),
+ new DeleteAclsResponseData.DeleteAclsFilterResult()
+ .setMatchingAcls(singletonList(DeleteAclsResponse.matchingAcl(ACL2, ApiError.NONE))))),
+ ApiKeys.DELETE_ACLS.latestVersion()));
+ results = env.adminClient().deleteAcls(asList(FILTER1, FILTER2));
+ Collection<AclBinding> deleted = results.all().get();
+ assertCollectionIs(deleted, ACL1, ACL2);
+ }
+ }
+
+ @Test
+ public void testDescribeBrokerConfigs() throws Exception {
+ ConfigResource broker0Resource = new ConfigResource(ConfigResource.Type.BROKER, "0");
+ ConfigResource broker1Resource = new ConfigResource(ConfigResource.Type.BROKER, "1");
+ try (AdminClientUnitTestEnv env = mockClientEnv()) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+ env.kafkaClient().prepareResponseFrom(new DescribeConfigsResponse(
+ new DescribeConfigsResponseData().setResults(singletonList(new DescribeConfigsResponseData.DescribeConfigsResult()
+ .setResourceName(broker0Resource.name()).setResourceType(broker0Resource.type().id()).setErrorCode(Errors.NONE.code())
+ .setConfigs(emptyList())))), env.cluster().nodeById(0));
+ env.kafkaClient().prepareResponseFrom(new DescribeConfigsResponse(
+ new DescribeConfigsResponseData().setResults(singletonList(new DescribeConfigsResponseData.DescribeConfigsResult()
+ .setResourceName(broker1Resource.name()).setResourceType(broker1Resource.type().id()).setErrorCode(Errors.NONE.code())
+ .setConfigs(emptyList())))), env.cluster().nodeById(1));
+ Map<ConfigResource, KafkaFuture<Config>> result = env.adminClient().describeConfigs(asList(
+ broker0Resource,
+ broker1Resource)).values();
+ assertEquals(Set.of(broker0Resource, broker1Resource), result.keySet());
+ result.get(broker0Resource).get();
+ result.get(broker1Resource).get();
+ }
+ }
+
+ @Test
+ public void testDescribeBrokerAndLogConfigs() throws Exception {
+ ConfigResource brokerResource = new ConfigResource(ConfigResource.Type.BROKER, "0");
+ ConfigResource brokerLoggerResource = new ConfigResource(ConfigResource.Type.BROKER_LOGGER, "0");
+ try (AdminClientUnitTestEnv env = mockClientEnv()) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+ env.kafkaClient().prepareResponseFrom(new DescribeConfigsResponse(
+ new DescribeConfigsResponseData().setResults(asList(new DescribeConfigsResponseData.DescribeConfigsResult()
+ .setResourceName(brokerResource.name()).setResourceType(brokerResource.type().id()).setErrorCode(Errors.NONE.code())
+ .setConfigs(emptyList()),
+ new DescribeConfigsResponseData.DescribeConfigsResult()
+ .setResourceName(brokerLoggerResource.name()).setResourceType(brokerLoggerResource.type().id()).setErrorCode(Errors.NONE.code())
+ .setConfigs(emptyList())))), env.cluster().nodeById(0));
+ Map<ConfigResource, KafkaFuture<Config>> result = env.adminClient().describeConfigs(asList(
+ brokerResource,
+ brokerLoggerResource)).values();
+ assertEquals(Set.of(brokerResource, brokerLoggerResource), result.keySet());
+ result.get(brokerResource).get();
+ result.get(brokerLoggerResource).get();
+ }
+ }
+
+ @Test
+ public void testDescribeConfigsPartialResponse() {
+ ConfigResource topic = new ConfigResource(ConfigResource.Type.TOPIC, "topic");
+ ConfigResource topic2 = new ConfigResource(ConfigResource.Type.TOPIC, "topic2");
+ try (AdminClientUnitTestEnv env = mockClientEnv()) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+ env.kafkaClient().prepareResponse(new DescribeConfigsResponse(
+ new DescribeConfigsResponseData().setResults(singletonList(new DescribeConfigsResponseData.DescribeConfigsResult()
+ .setResourceName(topic.name()).setResourceType(topic.type().id()).setErrorCode(Errors.NONE.code())
+ .setConfigs(emptyList())))));
+ Map<ConfigResource, KafkaFuture<Config>> result = env.adminClient().describeConfigs(asList(
+ topic,
+ topic2)).values();
+ assertEquals(Set.of(topic, topic2), result.keySet());
+ result.get(topic);
+ TestUtils.assertFutureThrows(ApiException.class, result.get(topic2));
+ }
+ }
+
+ @Test
+ public void testDescribeConfigsUnrequested() throws Exception {
+ ConfigResource topic = new ConfigResource(ConfigResource.Type.TOPIC, "topic");
+ ConfigResource unrequested = new ConfigResource(ConfigResource.Type.TOPIC, "unrequested");
+ try (AdminClientUnitTestEnv env = mockClientEnv()) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+ env.kafkaClient().prepareResponse(new DescribeConfigsResponse(
+ new DescribeConfigsResponseData().setResults(asList(new DescribeConfigsResponseData.DescribeConfigsResult()
+ .setResourceName(topic.name()).setResourceType(topic.type().id()).setErrorCode(Errors.NONE.code())
+ .setConfigs(emptyList()),
+ new DescribeConfigsResponseData.DescribeConfigsResult()
+ .setResourceName(unrequested.name()).setResourceType(unrequested.type().id()).setErrorCode(Errors.NONE.code())
+ .setConfigs(emptyList())))));
+ Map<ConfigResource, KafkaFuture<Config>> result = env.adminClient().describeConfigs(singletonList(
+ topic)).values();
+ assertEquals(Set.of(topic), result.keySet());
+ assertNotNull(result.get(topic).get());
+ assertNull(result.get(unrequested));
+ }
+ }
+
+ @Test
+ public void testDescribeClientMetricsConfigs() throws Exception {
+ ConfigResource resource = new ConfigResource(ConfigResource.Type.CLIENT_METRICS, "sub1");
+ ConfigResource resource1 = new ConfigResource(ConfigResource.Type.CLIENT_METRICS, "sub2");
+ try (AdminClientUnitTestEnv env = mockClientEnv()) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+ env.kafkaClient().prepareResponse(new DescribeConfigsResponse(
+ new DescribeConfigsResponseData().setResults(asList(
+ new DescribeConfigsResponseData.DescribeConfigsResult()
+ .setResourceName(resource.name()).setResourceType(resource.type().id()).setErrorCode(Errors.NONE.code())
+ .setConfigs(emptyList()),
+ new DescribeConfigsResponseData.DescribeConfigsResult()
+ .setResourceName(resource1.name()).setResourceType(resource1.type().id()).setErrorCode(Errors.NONE.code())
+ .setConfigs(emptyList())))));
+ Map<ConfigResource, KafkaFuture<Config>> result = env.adminClient().describeConfigs(asList(
+ resource,
+ resource1)).values();
+ assertEquals(Set.of(resource, resource1), result.keySet());
+ assertNotNull(result.get(resource).get());
+ assertNotNull(result.get(resource1).get());
+ }
+ }
+
+ @Test
+ public void testDescribeConsumerGroupConfigs() throws Exception {
+ ConfigResource resource1 = new ConfigResource(ConfigResource.Type.GROUP, "group1");
+ ConfigResource resource2 = new ConfigResource(ConfigResource.Type.GROUP, "group2");
+ try (AdminClientUnitTestEnv env = mockClientEnv()) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+ env.kafkaClient().prepareResponse(new DescribeConfigsResponse(
+ new DescribeConfigsResponseData().setResults(asList(
+ new DescribeConfigsResponseData.DescribeConfigsResult()
+ .setResourceName(resource1.name())
+ .setResourceType(resource1.type().id())
+ .setErrorCode(Errors.NONE.code())
+ .setConfigs(emptyList()),
+ new DescribeConfigsResponseData.DescribeConfigsResult()
+ .setResourceName(resource2.name())
+ .setResourceType(resource2.type().id())
+ .setErrorCode(Errors.NONE.code())
+ .setConfigs(emptyList())))));
+ Map<ConfigResource, KafkaFuture<Config>> result = env.adminClient().describeConfigs(asList(
+ resource1,
+ resource2)).values();
+ assertEquals(Set.of(resource1, resource2), result.keySet());
+ assertNotNull(result.get(resource1).get());
+ assertNotNull(result.get(resource2).get());
+ }
+ }
+
+ @Test
+ public void testIncrementalAlterConfigs() throws Exception {
+ try (AdminClientUnitTestEnv env = mockClientEnv()) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ //test error scenarios
+ IncrementalAlterConfigsResponseData responseData = new IncrementalAlterConfigsResponseData();
+ responseData.responses().add(new AlterConfigsResourceResponse()
+ .setResourceName("")
+ .setResourceType(ConfigResource.Type.BROKER.id())
+ .setErrorCode(Errors.CLUSTER_AUTHORIZATION_FAILED.code())
+ .setErrorMessage("authorization error"));
+
+ responseData.responses().add(new AlterConfigsResourceResponse()
+ .setResourceName("metric1")
+ .setResourceType(ConfigResource.Type.CLIENT_METRICS.id())
+ .setErrorCode(Errors.INVALID_REQUEST.code())
+ .setErrorMessage("Subscription is not allowed"));
+
+ responseData.responses().add(new AlterConfigsResourceResponse()
+ .setResourceName("topic1")
+ .setResourceType(ConfigResource.Type.TOPIC.id())
+ .setErrorCode(Errors.INVALID_REQUEST.code())
+ .setErrorMessage("Config value append is not allowed for config"));
+
+ responseData.responses().add(new AlterConfigsResourceResponse()
+ .setResourceName("group1")
+ .setResourceType(ConfigResource.Type.GROUP.id())
+ .setErrorCode(Errors.INVALID_CONFIG.code())
+ .setErrorMessage("Unknown group config name: group.initial.rebalance.delay.ms"));
+
+ env.kafkaClient().prepareResponse(new IncrementalAlterConfigsResponse(responseData));
+
+ ConfigResource brokerResource = new ConfigResource(ConfigResource.Type.BROKER, "");
+ ConfigResource topicResource = new ConfigResource(ConfigResource.Type.TOPIC, "topic1");
+ ConfigResource metricResource = new ConfigResource(ConfigResource.Type.CLIENT_METRICS, "metric1");
+ ConfigResource groupResource = new ConfigResource(ConfigResource.Type.GROUP, "group1");
+
+ AlterConfigOp alterConfigOp1 = new AlterConfigOp(
+ new ConfigEntry("log.segment.bytes", "1073741"),
+ AlterConfigOp.OpType.SET);
+
+ AlterConfigOp alterConfigOp2 = new AlterConfigOp(
+ new ConfigEntry("compression.type", "gzip"),
+ AlterConfigOp.OpType.APPEND);
+
+ AlterConfigOp alterConfigOp3 = new AlterConfigOp(
+ new ConfigEntry("interval.ms", "1000"),
+ AlterConfigOp.OpType.APPEND);
+
+ AlterConfigOp alterConfigOp4 = new AlterConfigOp(
+ new ConfigEntry("group.initial.rebalance.delay.ms", "1000"),
+ AlterConfigOp.OpType.SET);
+
+ final Map<ConfigResource, Collection<AlterConfigOp>> configs = new HashMap<>();
+ configs.put(brokerResource, singletonList(alterConfigOp1));
+ configs.put(topicResource, singletonList(alterConfigOp2));
+ configs.put(metricResource, singletonList(alterConfigOp3));
+ configs.put(groupResource, singletonList(alterConfigOp4));
+
+ AlterConfigsResult result = env.adminClient().incrementalAlterConfigs(configs);
+ TestUtils.assertFutureThrows(ClusterAuthorizationException.class, result.values().get(brokerResource));
+ TestUtils.assertFutureThrows(InvalidRequestException.class, result.values().get(topicResource));
+ TestUtils.assertFutureThrows(InvalidRequestException.class, result.values().get(metricResource));
+ TestUtils.assertFutureThrows(InvalidConfigurationException.class, result.values().get(groupResource));
+
+ // Test a call where there are no errors.
+ responseData = new IncrementalAlterConfigsResponseData();
+ responseData.responses().add(new AlterConfigsResourceResponse()
+ .setResourceName("")
+ .setResourceType(ConfigResource.Type.BROKER.id())
+ .setErrorCode(Errors.NONE.code())
+ .setErrorMessage(ApiError.NONE.message()));
+ responseData.responses().add(new AlterConfigsResourceResponse()
+ .setResourceName("metric1")
+ .setResourceType(ConfigResource.Type.CLIENT_METRICS.id())
+ .setErrorCode(Errors.NONE.code())
+ .setErrorMessage(ApiError.NONE.message()));
+ responseData.responses().add(new AlterConfigsResourceResponse()
+ .setResourceName("group1")
+ .setResourceType(ConfigResource.Type.GROUP.id())
+ .setErrorCode(Errors.NONE.code())
+ .setErrorMessage(ApiError.NONE.message()));
+
+ final Map<ConfigResource, Collection<AlterConfigOp>> successConfig = new HashMap<>();
+ successConfig.put(brokerResource, singletonList(alterConfigOp1));
+ successConfig.put(metricResource, singletonList(alterConfigOp3));
+ successConfig.put(groupResource, singletonList(alterConfigOp4));
+
+ env.kafkaClient().prepareResponse(new IncrementalAlterConfigsResponse(responseData));
+ env.adminClient().incrementalAlterConfigs(successConfig).all().get();
+ }
+ }
+
+ @Test
+ public void testIncrementalAlterConfigsToController() throws Exception {
+ try (AdminClientUnitTestEnv env = mockClientEnv(AdminClientConfig.BOOTSTRAP_CONTROLLERS_CONFIG, "dummy")) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ //test NOT_CONTROLLER error scenarios
+ IncrementalAlterConfigsResponseData responseData = new IncrementalAlterConfigsResponseData();
+ responseData.responses().add(new AlterConfigsResourceResponse()
+ .setResourceName("")
+ .setResourceType(ConfigResource.Type.BROKER.id())
+ .setErrorCode(Errors.NOT_CONTROLLER.code())
+ .setErrorMessage("not controller"));
+
+ env.kafkaClient().prepareResponse(new IncrementalAlterConfigsResponse(responseData));
+
+ // should retry the describe cluster to update the metadata
+ env.kafkaClient().prepareResponse(
+ prepareDescribeClusterResponse(0,
+ env.cluster().nodes(),
+ env.cluster().clusterResource().clusterId(),
+ 2,
+ MetadataResponse.AUTHORIZED_OPERATIONS_OMITTED,
+ true)
+ );
+
+ IncrementalAlterConfigsResponseData responseData2 = new IncrementalAlterConfigsResponseData();
+ responseData2.responses().add(new AlterConfigsResourceResponse()
+ .setResourceName("")
+ .setResourceType(ConfigResource.Type.BROKER.id())
+ .setErrorCode(Errors.NONE.code())
+ .setErrorMessage(ApiError.NONE.message()));
+
+ ConfigResource brokerResource = new ConfigResource(ConfigResource.Type.BROKER, "");
+
+ AlterConfigOp alterConfigOp1 = new AlterConfigOp(
+ new ConfigEntry("log.segment.bytes", "1073741"),
+ AlterConfigOp.OpType.SET);
+
+ final Map<ConfigResource, Collection<AlterConfigOp>> configs = new HashMap<>();
+ configs.put(brokerResource, singletonList(alterConfigOp1));
+ env.kafkaClient().prepareResponse(new IncrementalAlterConfigsResponse(responseData2));
+ env.adminClient().incrementalAlterConfigs(configs).all().get();
+ }
+ }
+
+ @Test
+ public void testDescribeClientQuotas() throws Exception {
+ try (AdminClientUnitTestEnv env = mockClientEnv()) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ final String value = "value";
+
+ Map<ClientQuotaEntity, Map<String, Double>> responseData = new HashMap<>();
+ ClientQuotaEntity entity1 = newClientQuotaEntity(ClientQuotaEntity.USER, "user-1", ClientQuotaEntity.CLIENT_ID, value);
+ ClientQuotaEntity entity2 = newClientQuotaEntity(ClientQuotaEntity.USER, "user-2", ClientQuotaEntity.CLIENT_ID, value);
+ responseData.put(entity1, Collections.singletonMap("consumer_byte_rate", 10000.0));
+ responseData.put(entity2, Collections.singletonMap("producer_byte_rate", 20000.0));
+
+ env.kafkaClient().prepareResponse(DescribeClientQuotasResponse.fromQuotaEntities(responseData, 0));
+
+ ClientQuotaFilter filter = ClientQuotaFilter.contains(singletonList(ClientQuotaFilterComponent.ofEntity(ClientQuotaEntity.USER, value)));
+
+ DescribeClientQuotasResult result = env.adminClient().describeClientQuotas(filter);
+ Map<ClientQuotaEntity, Map<String, Double>> resultData = result.entities().get();
+ assertEquals(2, resultData.size());
+ assertTrue(resultData.containsKey(entity1));
+ Map<String, Double> config1 = resultData.get(entity1);
+ assertEquals(1, config1.size());
+ assertEquals(10000.0, config1.get("consumer_byte_rate"), 1e-6);
+ assertTrue(resultData.containsKey(entity2));
+ Map<String, Double> config2 = resultData.get(entity2);
+ assertEquals(1, config2.size());
+ assertEquals(20000.0, config2.get("producer_byte_rate"), 1e-6);
+ }
+ }
+
+ @Test
+ public void testEqualsOfClientQuotaFilterComponent() {
+ assertEquals(ClientQuotaFilterComponent.ofDefaultEntity(ClientQuotaEntity.USER),
+ ClientQuotaFilterComponent.ofDefaultEntity(ClientQuotaEntity.USER));
+
+ assertEquals(ClientQuotaFilterComponent.ofEntityType(ClientQuotaEntity.USER),
+ ClientQuotaFilterComponent.ofEntityType(ClientQuotaEntity.USER));
+
+ // match = null is different from match = Empty
+ assertNotEquals(ClientQuotaFilterComponent.ofDefaultEntity(ClientQuotaEntity.USER),
+ ClientQuotaFilterComponent.ofEntityType(ClientQuotaEntity.USER));
+
+ assertEquals(ClientQuotaFilterComponent.ofEntity(ClientQuotaEntity.USER, "user"),
+ ClientQuotaFilterComponent.ofEntity(ClientQuotaEntity.USER, "user"));
+
+ assertNotEquals(ClientQuotaFilterComponent.ofEntity(ClientQuotaEntity.USER, "user"),
+ ClientQuotaFilterComponent.ofDefaultEntity(ClientQuotaEntity.USER));
+
+ assertNotEquals(ClientQuotaFilterComponent.ofEntity(ClientQuotaEntity.USER, "user"),
+ ClientQuotaFilterComponent.ofEntityType(ClientQuotaEntity.USER));
+ }
+
+ @Test
+ public void testAlterClientQuotas() throws Exception {
+ try (AdminClientUnitTestEnv env = mockClientEnv()) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ ClientQuotaEntity goodEntity = newClientQuotaEntity(ClientQuotaEntity.USER, "user-1");
+ ClientQuotaEntity unauthorizedEntity = newClientQuotaEntity(ClientQuotaEntity.USER, "user-0");
+ ClientQuotaEntity invalidEntity = newClientQuotaEntity("", "user-0");
+
+ Map<ClientQuotaEntity, ApiError> responseData = new HashMap<>(2);
+ responseData.put(goodEntity, new ApiError(Errors.CLUSTER_AUTHORIZATION_FAILED, "Authorization failed"));
+ responseData.put(unauthorizedEntity, new ApiError(Errors.CLUSTER_AUTHORIZATION_FAILED, "Authorization failed"));
+ responseData.put(invalidEntity, new ApiError(Errors.INVALID_REQUEST, "Invalid quota entity"));
+
+ env.kafkaClient().prepareResponse(AlterClientQuotasResponse.fromQuotaEntities(responseData, 0));
+
+ List<ClientQuotaAlteration> entries = new ArrayList<>(3);
+ entries.add(new ClientQuotaAlteration(goodEntity, singleton(new ClientQuotaAlteration.Op("consumer_byte_rate", 10000.0))));
+ entries.add(new ClientQuotaAlteration(unauthorizedEntity, singleton(new ClientQuotaAlteration.Op("producer_byte_rate", 10000.0))));
+ entries.add(new ClientQuotaAlteration(invalidEntity, singleton(new ClientQuotaAlteration.Op("producer_byte_rate", 100.0))));
+
+ AlterClientQuotasResult result = env.adminClient().alterClientQuotas(entries);
+ result.values().get(goodEntity);
+ TestUtils.assertFutureThrows(ClusterAuthorizationException.class, result.values().get(unauthorizedEntity));
+ TestUtils.assertFutureThrows(InvalidRequestException.class, result.values().get(invalidEntity));
+
+ // ensure immutable
+ assertThrows(UnsupportedOperationException.class, () -> result.values().put(newClientQuotaEntity(ClientQuotaEntity.USER, "user-3"), null));
+ }
+ }
+
+ @Test
+ public void testDescribeUserScramCredentials() throws Exception {
+ try (AdminClientUnitTestEnv env = mockClientEnv()) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ final String user0Name = "user0";
+ final ScramMechanism user0ScramMechanism0 = ScramMechanism.SCRAM_SHA_256;
+ final int user0Iterations0 = 4096;
+ final ScramMechanism user0ScramMechanism1 = ScramMechanism.SCRAM_SHA_512;
+ final int user0Iterations1 = 8192;
+
+ final CredentialInfo user0CredentialInfo0 = new CredentialInfo();
+ user0CredentialInfo0.setMechanism(user0ScramMechanism0.type());
+ user0CredentialInfo0.setIterations(user0Iterations0);
+ final CredentialInfo user0CredentialInfo1 = new CredentialInfo();
+ user0CredentialInfo1.setMechanism(user0ScramMechanism1.type());
+ user0CredentialInfo1.setIterations(user0Iterations1);
+
+ final String user1Name = "user1";
+ final ScramMechanism user1ScramMechanism = ScramMechanism.SCRAM_SHA_256;
+ final int user1Iterations = 4096;
+
+ final CredentialInfo user1CredentialInfo = new CredentialInfo();
+ user1CredentialInfo.setMechanism(user1ScramMechanism.type());
+ user1CredentialInfo.setIterations(user1Iterations);
+
+ final DescribeUserScramCredentialsResponseData responseData = new DescribeUserScramCredentialsResponseData();
+ responseData.setResults(asList(
+ new DescribeUserScramCredentialsResponseData.DescribeUserScramCredentialsResult()
+ .setUser(user0Name)
+ .setCredentialInfos(asList(user0CredentialInfo0, user0CredentialInfo1)),
+ new DescribeUserScramCredentialsResponseData.DescribeUserScramCredentialsResult()
+ .setUser(user1Name)
+ .setCredentialInfos(singletonList(user1CredentialInfo))));
+ final DescribeUserScramCredentialsResponse response = new DescribeUserScramCredentialsResponse(responseData);
+
+ final Set<String> usersRequestedSet = new HashSet<>();
+ usersRequestedSet.add(user0Name);
+ usersRequestedSet.add(user1Name);
+
+ for (final List<String> users : asList(null, new ArrayList<String>(), asList(user0Name, null, user1Name))) {
+ env.kafkaClient().prepareResponse(response);
+
+ final DescribeUserScramCredentialsResult result = env.adminClient().describeUserScramCredentials(users);
+ final Map<String, UserScramCredentialsDescription> descriptionResults = result.all().get();
+ final KafkaFuture<UserScramCredentialsDescription> user0DescriptionFuture = result.description(user0Name);
+ final KafkaFuture<UserScramCredentialsDescription> user1DescriptionFuture = result.description(user1Name);
+
+ final Set<String> usersDescribedFromUsersSet = new HashSet<>(result.users().get());
+ assertEquals(usersRequestedSet, usersDescribedFromUsersSet);
+
+ final Set<String> usersDescribedFromMapKeySet = descriptionResults.keySet();
+ assertEquals(usersRequestedSet, usersDescribedFromMapKeySet);
+
+ final UserScramCredentialsDescription userScramCredentialsDescription0 = descriptionResults.get(user0Name);
+ assertEquals(user0Name, userScramCredentialsDescription0.name());
+ assertEquals(2, userScramCredentialsDescription0.credentialInfos().size());
+ assertEquals(user0ScramMechanism0, userScramCredentialsDescription0.credentialInfos().get(0).mechanism());
+ assertEquals(user0Iterations0, userScramCredentialsDescription0.credentialInfos().get(0).iterations());
+ assertEquals(user0ScramMechanism1, userScramCredentialsDescription0.credentialInfos().get(1).mechanism());
+ assertEquals(user0Iterations1, userScramCredentialsDescription0.credentialInfos().get(1).iterations());
+ assertEquals(userScramCredentialsDescription0, user0DescriptionFuture.get());
+
+ final UserScramCredentialsDescription userScramCredentialsDescription1 = descriptionResults.get(user1Name);
+ assertEquals(user1Name, userScramCredentialsDescription1.name());
+ assertEquals(1, userScramCredentialsDescription1.credentialInfos().size());
+ assertEquals(user1ScramMechanism, userScramCredentialsDescription1.credentialInfos().get(0).mechanism());
+ assertEquals(user1Iterations, userScramCredentialsDescription1.credentialInfos().get(0).iterations());
+ assertEquals(userScramCredentialsDescription1, user1DescriptionFuture.get());
+ }
+ }
+ }
+
+ @Test
+ public void testAlterUserScramCredentialsUnknownMechanism() throws ExecutionException, InterruptedException {
+ try (AdminClientUnitTestEnv env = mockClientEnv()) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ final String user0Name = "user0";
+ ScramMechanism user0ScramMechanism0 = ScramMechanism.UNKNOWN;
+
+ final String user1Name = "user1";
+ ScramMechanism user1ScramMechanism0 = ScramMechanism.UNKNOWN;
+
+ final String user2Name = "user2";
+ ScramMechanism user2ScramMechanism0 = ScramMechanism.SCRAM_SHA_256;
+
+ AlterUserScramCredentialsResponseData responseData = new AlterUserScramCredentialsResponseData();
+ responseData.setResults(singletonList(
+ new AlterUserScramCredentialsResponseData.AlterUserScramCredentialsResult().setUser(user2Name)));
+
+ env.kafkaClient().prepareResponse(new AlterUserScramCredentialsResponse(responseData));
+
+ AlterUserScramCredentialsResult result = env.adminClient().alterUserScramCredentials(asList(
+ new UserScramCredentialDeletion(user0Name, user0ScramMechanism0),
+ new UserScramCredentialUpsertion(user1Name, new ScramCredentialInfo(user1ScramMechanism0, 8192), "password"),
+ new UserScramCredentialUpsertion(user2Name, new ScramCredentialInfo(user2ScramMechanism0, 4096), "password")));
+ Map<String, KafkaFuture<Void>> resultData = result.values();
+ assertEquals(3, resultData.size());
+ Stream.of(user0Name, user1Name).forEach(u -> {
+ assertTrue(resultData.containsKey(u));
+ assertThrows(Exception.class, () -> resultData.get(u).get(), "Expected request for user " + u + " to complete exceptionally, but it did not");
+ });
+ assertTrue(resultData.containsKey(user2Name));
+ resultData.get(user2Name).get();
+
+ assertThrows(Exception.class, () -> result.all().get(), "Expected 'result.all().get()' to throw an exception since at least one user failed, but it did not");
+ }
+ }
+
+ @Test
+ public void testAlterUserScramCredentials() {
+ try (AdminClientUnitTestEnv env = mockClientEnv()) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ final String user0Name = "user0";
+ ScramMechanism user0ScramMechanism0 = ScramMechanism.SCRAM_SHA_256;
+ ScramMechanism user0ScramMechanism1 = ScramMechanism.SCRAM_SHA_512;
+ final String user1Name = "user1";
+ ScramMechanism user1ScramMechanism0 = ScramMechanism.SCRAM_SHA_256;
+ final String user2Name = "user2";
+ ScramMechanism user2ScramMechanism0 = ScramMechanism.SCRAM_SHA_512;
+ AlterUserScramCredentialsResponseData responseData = new AlterUserScramCredentialsResponseData();
+ responseData.setResults(Stream.of(user0Name, user1Name, user2Name).map(u ->
+ new AlterUserScramCredentialsResponseData.AlterUserScramCredentialsResult()
+ .setUser(u).setErrorCode(Errors.NONE.code())).collect(Collectors.toList()));
+
+ env.kafkaClient().prepareResponse(new AlterUserScramCredentialsResponse(responseData));
+
+ AlterUserScramCredentialsResult result = env.adminClient().alterUserScramCredentials(asList(
+ new UserScramCredentialDeletion(user0Name, user0ScramMechanism0),
+ new UserScramCredentialUpsertion(user0Name, new ScramCredentialInfo(user0ScramMechanism1, 8192), "password"),
+ new UserScramCredentialUpsertion(user1Name, new ScramCredentialInfo(user1ScramMechanism0, 8192), "password"),
+ new UserScramCredentialDeletion(user2Name, user2ScramMechanism0)));
+ Map<String, KafkaFuture<Void>> resultData = result.values();
+ assertEquals(3, resultData.size());
+ Stream.of(user0Name, user1Name, user2Name).forEach(u -> {
+ assertTrue(resultData.containsKey(u));
+ assertFalse(resultData.get(u).isCompletedExceptionally());
+ });
+ }
+ }
+
+ private ClientQuotaEntity newClientQuotaEntity(String... args) {
+ assertEquals(0, args.length % 2);
+
+ Map<String, String> entityMap = new HashMap<>(args.length / 2);
+ for (int index = 0; index < args.length; index += 2) {
+ entityMap.put(args[index], args[index + 1]);
+ }
+ return new ClientQuotaEntity(entityMap);
+ }
+
+ @SafeVarargs
+ private static <T> void assertCollectionIs(Collection<T> collection, T... elements) {
+ for (T element : elements) {
+ assertTrue(collection.contains(element), "Did not find " + element);
+ }
+ assertEquals(elements.length, collection.size(), "There are unexpected extra elements in the collection.");
+ }
+}
diff --git a/clients/src/test/java/org/apache/kafka/clients/admin/KafkaAdminClientConsumerGroupTest.java b/clients/src/test/java/org/apache/kafka/clients/admin/KafkaAdminClientConsumerGroupTest.java
new file mode 100644
index 00000000000..030b6c33a10
--- /dev/null
+++ b/clients/src/test/java/org/apache/kafka/clients/admin/KafkaAdminClientConsumerGroupTest.java
@@ -0,0 +1,3361 @@
+/*
+ * 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 org.apache.kafka.clients.admin;
+
+import org.apache.kafka.clients.ClientRequest;
+import org.apache.kafka.clients.CommonClientConfigs;
+import org.apache.kafka.clients.MockClient;
+import org.apache.kafka.clients.NodeApiVersions;
+import org.apache.kafka.clients.consumer.ConsumerPartitionAssignor;
+import org.apache.kafka.clients.consumer.OffsetAndMetadata;
+import org.apache.kafka.clients.consumer.internals.ConsumerProtocol;
+import org.apache.kafka.common.ClassicGroupState;
+import org.apache.kafka.common.Cluster;
+import org.apache.kafka.common.GroupState;
+import org.apache.kafka.common.GroupType;
+import org.apache.kafka.common.KafkaException;
+import org.apache.kafka.common.KafkaFuture;
+import org.apache.kafka.common.Node;
+import org.apache.kafka.common.TopicPartition;
+import org.apache.kafka.common.Uuid;
+import org.apache.kafka.common.errors.GroupAuthorizationException;
+import org.apache.kafka.common.errors.GroupSubscribedToTopicException;
+import org.apache.kafka.common.errors.TimeoutException;
+import org.apache.kafka.common.errors.UnknownMemberIdException;
+import org.apache.kafka.common.errors.UnknownServerException;
+import org.apache.kafka.common.errors.UnknownTopicOrPartitionException;
+import org.apache.kafka.common.errors.UnsupportedVersionException;
+import org.apache.kafka.common.message.ApiVersionsResponseData.ApiVersion;
+import org.apache.kafka.common.message.ConsumerGroupDescribeResponseData;
+import org.apache.kafka.common.message.DeleteGroupsResponseData;
+import org.apache.kafka.common.message.DeleteGroupsResponseData.DeletableGroupResult;
+import org.apache.kafka.common.message.DeleteGroupsResponseData.DeletableGroupResultCollection;
+import org.apache.kafka.common.message.DescribeGroupsResponseData;
+import org.apache.kafka.common.message.DescribeGroupsResponseData.DescribedGroupMember;
+import org.apache.kafka.common.message.FindCoordinatorResponseData;
+import org.apache.kafka.common.message.LeaveGroupRequestData;
+import org.apache.kafka.common.message.LeaveGroupResponseData;
+import org.apache.kafka.common.message.LeaveGroupResponseData.MemberResponse;
+import org.apache.kafka.common.message.ListGroupsResponseData;
+import org.apache.kafka.common.message.OffsetDeleteResponseData;
+import org.apache.kafka.common.message.OffsetDeleteResponseData.OffsetDeleteResponsePartition;
+import org.apache.kafka.common.message.OffsetDeleteResponseData.OffsetDeleteResponsePartitionCollection;
+import org.apache.kafka.common.message.OffsetDeleteResponseData.OffsetDeleteResponseTopic;
+import org.apache.kafka.common.message.OffsetDeleteResponseData.OffsetDeleteResponseTopicCollection;
+import org.apache.kafka.common.message.OffsetFetchRequestData;
+import org.apache.kafka.common.message.OffsetFetchRequestData.OffsetFetchRequestGroup;
+import org.apache.kafka.common.message.OffsetFetchRequestData.OffsetFetchRequestTopics;
+import org.apache.kafka.common.message.OffsetFetchResponseData;
+import org.apache.kafka.common.protocol.ApiKeys;
+import org.apache.kafka.common.protocol.Errors;
+import org.apache.kafka.common.requests.ConsumerGroupDescribeRequest;
+import org.apache.kafka.common.requests.ConsumerGroupDescribeResponse;
+import org.apache.kafka.common.requests.DeleteGroupsResponse;
+import org.apache.kafka.common.requests.DescribeGroupsRequest;
+import org.apache.kafka.common.requests.DescribeGroupsResponse;
+import org.apache.kafka.common.requests.FindCoordinatorResponse;
+import org.apache.kafka.common.requests.JoinGroupRequest;
+import org.apache.kafka.common.requests.LeaveGroupRequest;
+import org.apache.kafka.common.requests.LeaveGroupResponse;
+import org.apache.kafka.common.requests.ListGroupsRequest;
+import org.apache.kafka.common.requests.ListGroupsResponse;
+import org.apache.kafka.common.requests.MetadataResponse;
+import org.apache.kafka.common.requests.OffsetCommitResponse;
+import org.apache.kafka.common.requests.OffsetDeleteResponse;
+import org.apache.kafka.common.requests.OffsetFetchRequest;
+import org.apache.kafka.common.requests.OffsetFetchResponse;
+import org.apache.kafka.common.requests.RequestTestUtils;
+import org.apache.kafka.common.utils.MockTime;
+import org.apache.kafka.common.utils.Time;
+import org.apache.kafka.common.utils.Utils;
+import org.apache.kafka.test.TestUtils;
+
+import org.junit.jupiter.api.Test;
+
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static java.util.Arrays.asList;
+import static java.util.Collections.emptyList;
+import static java.util.Collections.emptySet;
+import static java.util.Collections.singleton;
+import static java.util.Collections.singletonList;
+import static org.apache.kafka.clients.admin.KafkaAdminClient.DEFAULT_LEAVE_GROUP_REASON;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class KafkaAdminClientConsumerGroupTest extends KafkaAdminClientTestBase {
+
+ @Test
+ public void testListGroups() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(4, 0),
+ AdminClientConfig.RETRIES_CONFIG, "2")) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ // Empty metadata response should be retried
+ env.kafkaClient().prepareResponse(
+ RequestTestUtils.metadataResponse(
+ Collections.emptyList(),
+ env.cluster().clusterResource().clusterId(),
+ -1,
+ Collections.emptyList()));
+
+ env.kafkaClient().prepareResponse(
+ RequestTestUtils.metadataResponse(
+ env.cluster().nodes(),
+ env.cluster().clusterResource().clusterId(),
+ env.cluster().controller().id(),
+ Collections.emptyList()));
+
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(
+ new ListGroupsResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setGroups(asList(
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-1")
+ .setProtocolType(ConsumerProtocol.PROTOCOL_TYPE)
+ .setGroupType(GroupType.CONSUMER.toString())
+ .setGroupState("Stable"),
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-connect-1")
+ .setProtocolType("connector")
+ .setGroupType(GroupType.CLASSIC.toString())
+ .setGroupState("Stable")
+ ))),
+ env.cluster().nodeById(0));
+
+ // handle retriable errors
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(
+ new ListGroupsResponseData()
+ .setErrorCode(Errors.COORDINATOR_NOT_AVAILABLE.code())
+ .setGroups(Collections.emptyList())
+ ),
+ env.cluster().nodeById(1));
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(
+ new ListGroupsResponseData()
+ .setErrorCode(Errors.COORDINATOR_LOAD_IN_PROGRESS.code())
+ .setGroups(Collections.emptyList())
+ ),
+ env.cluster().nodeById(1));
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(
+ new ListGroupsResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setGroups(asList(
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-2")
+ .setProtocolType("anyproto")
+ .setGroupType(GroupType.CLASSIC.toString())
+ .setGroupState("Stable"),
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-connect-2")
+ .setProtocolType("connector")
+ .setGroupType(GroupType.CLASSIC.toString())
+ .setGroupState("Stable")
+ ))),
+ env.cluster().nodeById(1));
+
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(
+ new ListGroupsResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setGroups(asList(
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-3")
+ .setProtocolType("share")
+ .setGroupType(GroupType.SHARE.toString())
+ .setGroupState("Stable"),
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-connect-3")
+ .setProtocolType("connector")
+ .setGroupType(GroupType.CLASSIC.toString())
+ .setGroupState("Stable")
+ ))),
+ env.cluster().nodeById(2));
+
+ // fatal error
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(
+ new ListGroupsResponseData()
+ .setErrorCode(Errors.UNKNOWN_SERVER_ERROR.code())
+ .setGroups(Collections.emptyList())),
+ env.cluster().nodeById(3));
+
+ final ListGroupsResult result = env.adminClient().listGroups();
+ TestUtils.assertFutureThrows(UnknownServerException.class, result.all());
+
+ Collection<GroupListing> listings = result.valid().get();
+ assertEquals(6, listings.size());
+
+ Set<String> groupIds = new HashSet<>();
+ for (GroupListing listing : listings) {
+ groupIds.add(listing.groupId());
+ }
+
+ assertEquals(Set.of("group-1", "group-connect-1", "group-2", "group-connect-2", "group-3", "group-connect-3"), groupIds);
+ assertEquals(1, result.errors().get().size());
+ }
+ }
+
+ @Test
+ public void testListGroupsMetadataFailure() throws Exception {
+ final Cluster cluster = mockCluster(3, 0);
+ final Time time = new MockTime();
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time, cluster,
+ AdminClientConfig.RETRIES_CONFIG, "0")) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ // Empty metadata causes the request to fail since we have no list of brokers
+ // to send the ListGroups requests to
+ env.kafkaClient().prepareResponse(
+ RequestTestUtils.metadataResponse(
+ Collections.emptyList(),
+ env.cluster().clusterResource().clusterId(),
+ -1,
+ Collections.emptyList()));
+
+ final ListGroupsResult result = env.adminClient().listGroups();
+ TestUtils.assertFutureThrows(KafkaException.class, result.all());
+ }
+ }
+
+ @Test
+ public void testListGroupsEmptyProtocol() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(prepareMetadataResponse(env.cluster(), Errors.NONE));
+
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(new ListGroupsResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setGroups(asList(
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-1")
+ .setProtocolType(ConsumerProtocol.PROTOCOL_TYPE)
+ .setGroupType(GroupType.CONSUMER.toString())
+ .setGroupState("Stable"),
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-2")
+ .setGroupType(GroupType.CLASSIC.toString())
+ .setGroupState("Empty")))),
+ env.cluster().nodeById(0));
+
+ final ListGroupsOptions options = new ListGroupsOptions();
+ final ListGroupsResult result = env.adminClient().listGroups(options);
+ Collection<GroupListing> listings = result.valid().get();
+
+ assertEquals(2, listings.size());
+ List<GroupListing> expected = new ArrayList<>();
+ expected.add(new GroupListing("group-2", Optional.of(GroupType.CLASSIC), "", Optional.of(GroupState.EMPTY)));
+ expected.add(new GroupListing("group-1", Optional.of(GroupType.CONSUMER), ConsumerProtocol.PROTOCOL_TYPE, Optional.of(GroupState.STABLE)));
+ assertEquals(expected, listings);
+ assertEquals(0, result.errors().get().size());
+ }
+ }
+
+ @Test
+ public void testListGroupsEmptyGroupType() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(prepareMetadataResponse(env.cluster(), Errors.NONE));
+
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(new ListGroupsResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setGroups(List.of(
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-1")
+ .setProtocolType("any")))),
+ env.cluster().nodeById(0));
+
+ final ListGroupsOptions options = new ListGroupsOptions();
+ final ListGroupsResult result = env.adminClient().listGroups(options);
+ Collection<GroupListing> listings = result.valid().get();
+
+ assertEquals(1, listings.size());
+ List<GroupListing> expected = new ArrayList<>();
+ expected.add(new GroupListing("group-1", Optional.empty(), "any", Optional.empty()));
+ assertEquals(expected, listings);
+ assertEquals(0, result.errors().get().size());
+ }
+ }
+
+ @Test
+ public void testListGroupsWithProtocolTypes() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ // Test with list group options.
+ env.kafkaClient().prepareResponse(prepareMetadataResponse(env.cluster(), Errors.NONE));
+
+ env.kafkaClient().prepareResponseFrom(
+ expectListGroupsRequestWithFilters(Set.of(), Set.of()),
+ new ListGroupsResponse(new ListGroupsResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setGroups(List.of(
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-1")
+ .setProtocolType(ConsumerProtocol.PROTOCOL_TYPE)
+ .setGroupState("Stable")
+ .setGroupType(GroupType.CONSUMER.toString()),
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-2")
+ .setGroupState("Empty")
+ .setGroupType(GroupType.CONSUMER.toString())))),
+ env.cluster().nodeById(0));
+
+ final ListGroupsOptions options = new ListGroupsOptions().withProtocolTypes(Set.of(""));
+ final ListGroupsResult result = env.adminClient().listGroups(options);
+ Collection<GroupListing> listing = result.valid().get();
+
+ assertEquals(1, listing.size());
+ List<GroupListing> expected = new ArrayList<>();
+ expected.add(new GroupListing("group-2", Optional.of(GroupType.CONSUMER), "", Optional.of(GroupState.EMPTY)));
+ assertEquals(expected, listing);
+ assertEquals(0, result.errors().get().size());
+ }
+ }
+
+ @Test
+ public void testListGroupsWithTypes() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ // Test with list group options.
+ env.kafkaClient().prepareResponse(prepareMetadataResponse(env.cluster(), Errors.NONE));
+
+ env.kafkaClient().prepareResponseFrom(
+ expectListGroupsRequestWithFilters(Collections.emptySet(), singleton(GroupType.CONSUMER.toString())),
+ new ListGroupsResponse(new ListGroupsResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setGroups(asList(
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-1")
+ .setProtocolType(ConsumerProtocol.PROTOCOL_TYPE)
+ .setGroupState("Stable")
+ .setGroupType(GroupType.CONSUMER.toString()),
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-2")
+ .setGroupState("Empty")
+ .setGroupType(GroupType.CONSUMER.toString())))),
+ env.cluster().nodeById(0));
+
+ final ListGroupsOptions options = new ListGroupsOptions().withTypes(singleton(GroupType.CONSUMER));
+ final ListGroupsResult result = env.adminClient().listGroups(options);
+ Collection<GroupListing> listing = result.valid().get();
+
+ assertEquals(2, listing.size());
+ List<GroupListing> expected = new ArrayList<>();
+ expected.add(new GroupListing("group-2", Optional.of(GroupType.CONSUMER), "", Optional.of(GroupState.EMPTY)));
+ expected.add(new GroupListing("group-1", Optional.of(GroupType.CONSUMER), ConsumerProtocol.PROTOCOL_TYPE, Optional.of(GroupState.STABLE)));
+ assertEquals(expected, listing);
+ assertEquals(0, result.errors().get().size());
+ }
+ }
+
+ @Test
+ public void testListGroupsWithTypesOlderBrokerVersion() throws Exception {
+ ApiVersion listGroupV4 = new ApiVersion()
+ .setApiKey(ApiKeys.LIST_GROUPS.id)
+ .setMinVersion((short) 0)
+ .setMaxVersion((short) 4);
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create(List.of(listGroupV4)));
+
+ // Check that we cannot set a type filter with an older broker.
+ env.kafkaClient().prepareResponse(prepareMetadataResponse(env.cluster(), Errors.NONE));
+ env.kafkaClient().prepareUnsupportedVersionResponse(request ->
+ request instanceof ListGroupsRequest && !((ListGroupsRequest) request).data().typesFilter().isEmpty()
+ );
+
+ ListGroupsOptions options = new ListGroupsOptions().withTypes(Set.of(GroupType.SHARE));
+ ListGroupsResult result = env.adminClient().listGroups(options);
+ TestUtils.assertFutureThrows(UnsupportedVersionException.class, result.all());
+
+ // But a type filter which is just classic groups is permitted with an older broker, because they
+ // only know about classic groups so the types filter can be omitted.
+ env.kafkaClient().prepareResponse(prepareMetadataResponse(env.cluster(), Errors.NONE));
+
+ env.kafkaClient().prepareResponseFrom(
+ expectListGroupsRequestWithFilters(Set.of(), Set.of()),
+ new ListGroupsResponse(new ListGroupsResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setGroups(List.of(
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-1")
+ .setProtocolType(ConsumerProtocol.PROTOCOL_TYPE)
+ .setGroupState(GroupState.STABLE.toString())))),
+ env.cluster().nodeById(0));
+
+ options = new ListGroupsOptions().withTypes(Set.of(GroupType.CLASSIC));
+ result = env.adminClient().listGroups(options);
+
+ Collection<GroupListing> listing = result.all().get();
+ assertEquals(1, listing.size());
+ List<GroupListing> expected = List.of(
+ new GroupListing("group-1", Optional.empty(), ConsumerProtocol.PROTOCOL_TYPE, Optional.of(GroupState.STABLE))
+ );
+ assertEquals(expected, listing);
+
+ // But a type filter which is just consumer groups without classic groups is not permitted with an older broker.
+ env.kafkaClient().prepareResponse(prepareMetadataResponse(env.cluster(), Errors.NONE));
+ env.kafkaClient().prepareUnsupportedVersionResponse(request ->
+ request instanceof ListGroupsRequest && !((ListGroupsRequest) request).data().typesFilter().isEmpty()
+ );
+
+ options = new ListGroupsOptions().withTypes(Set.of(GroupType.CONSUMER));
+ result = env.adminClient().listGroups(options);
+ TestUtils.assertFutureThrows(UnsupportedVersionException.class, result.all());
+ }
+ }
+
+ @Test
+ public void testListConsumerGroups() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(4, 0),
+ AdminClientConfig.RETRIES_CONFIG, "2")) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ // Empty metadata response should be retried
+ env.kafkaClient().prepareResponse(
+ RequestTestUtils.metadataResponse(
+ List.of(),
+ env.cluster().clusterResource().clusterId(),
+ -1,
+ List.of()));
+
+ env.kafkaClient().prepareResponse(
+ RequestTestUtils.metadataResponse(
+ env.cluster().nodes(),
+ env.cluster().clusterResource().clusterId(),
+ env.cluster().controller().id(),
+ List.of()));
+
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(
+ new ListGroupsResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setGroups(List.of(
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-1")
+ .setProtocolType(ConsumerProtocol.PROTOCOL_TYPE)
+ .setGroupState("Stable"),
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-connect-1")
+ .setProtocolType("connector")
+ .setGroupState("Stable")
+ ))),
+ env.cluster().nodeById(0));
+
+ // handle retriable errors
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(
+ new ListGroupsResponseData()
+ .setErrorCode(Errors.COORDINATOR_NOT_AVAILABLE.code())
+ .setGroups(Collections.emptyList())
+ ),
+ env.cluster().nodeById(1));
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(
+ new ListGroupsResponseData()
+ .setErrorCode(Errors.COORDINATOR_LOAD_IN_PROGRESS.code())
+ .setGroups(Collections.emptyList())
+ ),
+ env.cluster().nodeById(1));
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(
+ new ListGroupsResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setGroups(asList(
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-2")
+ .setProtocolType(ConsumerProtocol.PROTOCOL_TYPE)
+ .setGroupState("Stable"),
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-connect-2")
+ .setProtocolType("connector")
+ .setGroupState("Stable")
+ ))),
+ env.cluster().nodeById(1));
+
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(
+ new ListGroupsResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setGroups(List.of(
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-3")
+ .setProtocolType(ConsumerProtocol.PROTOCOL_TYPE)
+ .setGroupState("Stable"),
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-connect-3")
+ .setProtocolType("connector")
+ .setGroupState("Stable")
+ ))),
+ env.cluster().nodeById(2));
+
+ // fatal error
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(
+ new ListGroupsResponseData()
+ .setErrorCode(Errors.UNKNOWN_SERVER_ERROR.code())
+ .setGroups(Collections.emptyList())),
+ env.cluster().nodeById(3));
+
+ final ListGroupsResult result = env.adminClient().listGroups(ListGroupsOptions.forConsumerGroups());
+ TestUtils.assertFutureThrows(UnknownServerException.class, result.all());
+
+ Collection<GroupListing> listings = result.valid().get();
+ assertEquals(3, listings.size());
+
+ Set<String> groupIds = new HashSet<>();
+ for (GroupListing listing : listings) {
+ groupIds.add(listing.groupId());
+ assertTrue(listing.groupState().isPresent());
+ }
+
+ assertEquals(Set.of("group-1", "group-2", "group-3"), groupIds);
+ assertEquals(1, result.errors().get().size());
+ }
+ }
+
+ @Test
+ public void testListConsumerGroupsMetadataFailure() throws Exception {
+ final Cluster cluster = mockCluster(3, 0);
+ final Time time = new MockTime();
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time, cluster,
+ AdminClientConfig.RETRIES_CONFIG, "0")) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ // Empty metadata causes the request to fail since we have no list of brokers
+ // to send the ListGroups requests to
+ env.kafkaClient().prepareResponse(
+ RequestTestUtils.metadataResponse(
+ List.of(),
+ env.cluster().clusterResource().clusterId(),
+ -1,
+ List.of()));
+
+ final ListGroupsResult result = env.adminClient().listGroups(ListGroupsOptions.forConsumerGroups());
+ TestUtils.assertFutureThrows(KafkaException.class, result.all());
+ }
+ }
+
+ @Test
+ public void testListConsumerGroupsWithStates() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(prepareMetadataResponse(env.cluster(), Errors.NONE));
+
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(new ListGroupsResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setGroups(List.of(
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-1")
+ .setProtocolType(ConsumerProtocol.PROTOCOL_TYPE)
+ .setGroupState("Stable"),
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-2")
+ .setGroupState("Empty")))),
+ env.cluster().nodeById(0));
+
+ final ListGroupsOptions options = ListGroupsOptions.forConsumerGroups();
+ final ListGroupsResult result = env.adminClient().listGroups(options);
+ Collection<GroupListing> listings = result.valid().get();
+
+ assertEquals(2, listings.size());
+ List<GroupListing> expected = new ArrayList<>();
+ expected.add(new GroupListing("group-2", Optional.empty(), "", Optional.of(GroupState.EMPTY)));
+ expected.add(new GroupListing("group-1", Optional.empty(), ConsumerProtocol.PROTOCOL_TYPE, Optional.of(GroupState.STABLE)));
+ assertEquals(expected, listings);
+ assertEquals(0, result.errors().get().size());
+ }
+ }
+
+ @Test
+ public void testListConsumerGroupsWithProtocolTypes() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ // Test with a specific protocol type filter in list consumer group options.
+ env.kafkaClient().prepareResponse(prepareMetadataResponse(env.cluster(), Errors.NONE));
+
+ env.kafkaClient().prepareResponseFrom(
+ expectListGroupsRequestWithFilters(Set.of(), Set.of(GroupType.CONSUMER.toString(), GroupType.CLASSIC.toString())),
+ new ListGroupsResponse(new ListGroupsResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setGroups(List.of(
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-1")
+ .setProtocolType(ConsumerProtocol.PROTOCOL_TYPE)
+ .setGroupState("Stable")
+ .setGroupType(GroupType.CONSUMER.toString()),
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-2")
+ .setGroupState("Empty")
+ .setGroupType(GroupType.CONSUMER.toString())))),
+ env.cluster().nodeById(0));
+
+ final ListGroupsOptions options = ListGroupsOptions.forConsumerGroups().withProtocolTypes(Set.of(ConsumerProtocol.PROTOCOL_TYPE));
+ final ListGroupsResult result = env.adminClient().listGroups(options);
+ Collection<GroupListing> listings = result.valid().get();
+
+ assertEquals(1, listings.size());
+ List<GroupListing> expected = new ArrayList<>();
+ expected.add(new GroupListing("group-1", Optional.of(GroupType.CONSUMER), ConsumerProtocol.PROTOCOL_TYPE, Optional.of(GroupState.STABLE)));
+ assertEquals(expected, listings);
+ assertEquals(0, result.errors().get().size());
+ }
+ }
+
+ @Test
+ public void testListConsumerGroupsWithTypes() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ // Test with a specific state filter but no type filter in list consumer group options.
+ env.kafkaClient().prepareResponse(prepareMetadataResponse(env.cluster(), Errors.NONE));
+
+ env.kafkaClient().prepareResponseFrom(
+ expectListGroupsRequestWithFilters(Set.of(GroupState.STABLE.toString()), Set.of(GroupType.CONSUMER.toString(), GroupType.CLASSIC.toString())),
+ new ListGroupsResponse(new ListGroupsResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setGroups(List.of(
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-1")
+ .setProtocolType(ConsumerProtocol.PROTOCOL_TYPE)
+ .setGroupState("Stable")
+ .setGroupType(GroupType.CLASSIC.toString())))),
+ env.cluster().nodeById(0));
+
+ final ListGroupsOptions options = ListGroupsOptions.forConsumerGroups().inGroupStates(Set.of(GroupState.STABLE));
+ final ListGroupsResult result = env.adminClient().listGroups(options);
+ Collection<GroupListing> listings = result.valid().get();
+
+ assertEquals(1, listings.size());
+ List<GroupListing> expected = new ArrayList<>();
+ expected.add(new GroupListing("group-1", Optional.of(GroupType.CLASSIC), ConsumerProtocol.PROTOCOL_TYPE, Optional.of(GroupState.STABLE)));
+ assertEquals(expected, listings);
+ assertEquals(0, result.errors().get().size());
+
+ // Test with list consumer group options.
+ env.kafkaClient().prepareResponse(prepareMetadataResponse(env.cluster(), Errors.NONE));
+
+ env.kafkaClient().prepareResponseFrom(
+ expectListGroupsRequestWithFilters(Set.of(), Set.of(GroupType.CONSUMER.toString())),
+ new ListGroupsResponse(new ListGroupsResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setGroups(List.of(
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-1")
+ .setProtocolType(ConsumerProtocol.PROTOCOL_TYPE)
+ .setGroupState("Stable")
+ .setGroupType(GroupType.CONSUMER.toString()),
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-2")
+ .setGroupState("Empty")
+ .setGroupType(GroupType.CONSUMER.toString())))),
+ env.cluster().nodeById(0));
+
+ final ListGroupsOptions options2 = ListGroupsOptions.forConsumerGroups().withTypes(Set.of(GroupType.CONSUMER));
+ final ListGroupsResult result2 = env.adminClient().listGroups(options2);
+ Collection<GroupListing> listings2 = result2.valid().get();
+
+ assertEquals(2, listings2.size());
+ List<GroupListing> expected2 = new ArrayList<>();
+ expected2.add(new GroupListing("group-2", Optional.of(GroupType.CONSUMER), "", Optional.of(GroupState.EMPTY)));
+ expected2.add(new GroupListing("group-1", Optional.of(GroupType.CONSUMER), ConsumerProtocol.PROTOCOL_TYPE, Optional.of(GroupState.STABLE)));
+ assertEquals(expected2, listings2);
+ assertEquals(0, result.errors().get().size());
+ }
+ }
+
+ @Test
+ public void testListConsumerGroupsWithStatesOlderBrokerVersion() throws Exception {
+ ApiVersion listGroupV3 = new ApiVersion()
+ .setApiKey(ApiKeys.LIST_GROUPS.id)
+ .setMinVersion((short) 0)
+ .setMaxVersion((short) 3);
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create(List.of(listGroupV3)));
+
+ env.kafkaClient().prepareResponse(prepareMetadataResponse(env.cluster(), Errors.NONE));
+
+ // Check we can list groups v3 with older broker if we don't specify states, and use just consumer group types which can be omitted.
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(new ListGroupsResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setGroups(List.of(
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-1")
+ .setProtocolType(ConsumerProtocol.PROTOCOL_TYPE)))),
+ env.cluster().nodeById(0));
+
+ ListGroupsOptions options = ListGroupsOptions.forConsumerGroups();
+ ListGroupsResult result = env.adminClient().listGroups(options);
+ Collection<GroupListing> listing = result.all().get();
+ assertEquals(1, listing.size());
+ List<GroupListing> expected = List.of(new GroupListing("group-1", Optional.empty(), ConsumerProtocol.PROTOCOL_TYPE, Optional.empty()));
+ assertEquals(expected, listing);
+
+ // But we cannot set a state filter with older broker
+ env.kafkaClient().prepareResponse(prepareMetadataResponse(env.cluster(), Errors.NONE));
+
+ env.kafkaClient().prepareUnsupportedVersionResponse(request ->
+ request instanceof ListGroupsRequest &&
+ !((ListGroupsRequest) request).data().statesFilter().isEmpty()
+ );
+
+ options = ListGroupsOptions.forConsumerGroups().inGroupStates(Set.of(GroupState.STABLE));
+ result = env.adminClient().listGroups(options);
+ TestUtils.assertFutureThrows(UnsupportedVersionException.class, result.all());
+ }
+ }
+
+ @Test
+ public void testListConsumerGroupsWithTypesOlderBrokerVersion() throws Exception {
+ ApiVersion listGroupV4 = new ApiVersion()
+ .setApiKey(ApiKeys.LIST_GROUPS.id)
+ .setMinVersion((short) 0)
+ .setMaxVersion((short) 4);
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create(List.of(listGroupV4)));
+
+ env.kafkaClient().prepareResponse(prepareMetadataResponse(env.cluster(), Errors.NONE));
+
+ // Check if we can list groups v4 with older broker if we specify states and don't specify types.
+ env.kafkaClient().prepareResponseFrom(
+ expectListGroupsRequestWithFilters(Set.of(GroupState.STABLE.toString()), Set.of()),
+ new ListGroupsResponse(new ListGroupsResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setGroups(List.of(
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-1")
+ .setProtocolType(ConsumerProtocol.PROTOCOL_TYPE)
+ .setGroupState(GroupState.STABLE.toString())))),
+ env.cluster().nodeById(0));
+
+ ListGroupsOptions options = ListGroupsOptions.forConsumerGroups().inGroupStates(Set.of(GroupState.STABLE));
+ ListGroupsResult result = env.adminClient().listGroups(options);
+
+ Collection<GroupListing> listing = result.all().get();
+ assertEquals(1, listing.size());
+ List<GroupListing> expected = List.of(
+ new GroupListing("group-1", Optional.empty(), ConsumerProtocol.PROTOCOL_TYPE, Optional.of(GroupState.STABLE))
+ );
+ assertEquals(expected, listing);
+
+ // Check that we cannot set a type filter with an older broker.
+ env.kafkaClient().prepareResponse(prepareMetadataResponse(env.cluster(), Errors.NONE));
+ // First attempt to build request will require v5 (type filter), but the broker only supports v4
+ env.kafkaClient().prepareUnsupportedVersionResponse(request ->
+ request instanceof ListGroupsRequest && !((ListGroupsRequest) request).data().typesFilter().isEmpty()
+ );
+
+ options = ListGroupsOptions.forConsumerGroups().withTypes(Set.of(GroupType.SHARE));
+ result = env.adminClient().listGroups(options);
+ TestUtils.assertFutureThrows(UnsupportedVersionException.class, result.all());
+ }
+ }
+
+ @Test
+ @SuppressWarnings("removal")
+ public void testListConsumerGroupsDeprecated() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(4, 0),
+ AdminClientConfig.RETRIES_CONFIG, "2")) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ // Empty metadata response should be retried
+ env.kafkaClient().prepareResponse(
+ RequestTestUtils.metadataResponse(
+ List.of(),
+ env.cluster().clusterResource().clusterId(),
+ -1,
+ List.of()));
+
+ env.kafkaClient().prepareResponse(
+ RequestTestUtils.metadataResponse(
+ env.cluster().nodes(),
+ env.cluster().clusterResource().clusterId(),
+ env.cluster().controller().id(),
+ List.of()));
+
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(
+ new ListGroupsResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setGroups(List.of(
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-1")
+ .setProtocolType(ConsumerProtocol.PROTOCOL_TYPE)
+ .setGroupState("Stable"),
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-connect-1")
+ .setProtocolType("connector")
+ .setGroupState("Stable")
+ ))),
+ env.cluster().nodeById(0));
+
+ // handle retriable errors
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(
+ new ListGroupsResponseData()
+ .setErrorCode(Errors.COORDINATOR_NOT_AVAILABLE.code())
+ .setGroups(List.of())
+ ),
+ env.cluster().nodeById(1));
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(
+ new ListGroupsResponseData()
+ .setErrorCode(Errors.COORDINATOR_LOAD_IN_PROGRESS.code())
+ .setGroups(List.of())
+ ),
+ env.cluster().nodeById(1));
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(
+ new ListGroupsResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setGroups(List.of(
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-2")
+ .setProtocolType(ConsumerProtocol.PROTOCOL_TYPE)
+ .setGroupState("Stable"),
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-connect-2")
+ .setProtocolType("connector")
+ .setGroupState("Stable")
+ ))),
+ env.cluster().nodeById(1));
+
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(
+ new ListGroupsResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setGroups(List.of(
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-3")
+ .setProtocolType(ConsumerProtocol.PROTOCOL_TYPE)
+ .setGroupState("Stable"),
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-connect-3")
+ .setProtocolType("connector")
+ .setGroupState("Stable")
+ ))),
+ env.cluster().nodeById(2));
+
+ // fatal error
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(
+ new ListGroupsResponseData()
+ .setErrorCode(Errors.UNKNOWN_SERVER_ERROR.code())
+ .setGroups(List.of())),
+ env.cluster().nodeById(3));
+
+ final ListConsumerGroupsResult result = env.adminClient().listConsumerGroups();
+ TestUtils.assertFutureThrows(UnknownServerException.class, result.all());
+
+ Collection<ConsumerGroupListing> listings = result.valid().get();
+ assertEquals(3, listings.size());
+
+ Set<String> groupIds = new HashSet<>();
+ for (ConsumerGroupListing listing : listings) {
+ groupIds.add(listing.groupId());
+ assertTrue(listing.state().isPresent());
+ }
+
+ assertEquals(Set.of("group-1", "group-2", "group-3"), groupIds);
+ assertEquals(1, result.errors().get().size());
+ }
+ }
+
+ @Test
+ @SuppressWarnings("removal")
+ public void testListConsumerGroupsDeprecatedMetadataFailure() throws Exception {
+ final Cluster cluster = mockCluster(3, 0);
+ final Time time = new MockTime();
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time, cluster,
+ AdminClientConfig.RETRIES_CONFIG, "0")) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ // Empty metadata causes the request to fail since we have no list of brokers
+ // to send the ListGroups requests to
+ env.kafkaClient().prepareResponse(
+ RequestTestUtils.metadataResponse(
+ List.of(),
+ env.cluster().clusterResource().clusterId(),
+ -1,
+ List.of()));
+
+ final ListConsumerGroupsResult result = env.adminClient().listConsumerGroups();
+ TestUtils.assertFutureThrows(KafkaException.class, result.all());
+ }
+ }
+
+ @Test
+ @SuppressWarnings("removal")
+ public void testListConsumerGroupsDeprecatedWithStates() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(prepareMetadataResponse(env.cluster(), Errors.NONE));
+
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(new ListGroupsResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setGroups(List.of(
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-1")
+ .setProtocolType(ConsumerProtocol.PROTOCOL_TYPE)
+ .setGroupState("Stable"),
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-2")
+ .setGroupState("Empty")))),
+ env.cluster().nodeById(0));
+
+ final ListConsumerGroupsOptions options = new ListConsumerGroupsOptions();
+ final ListConsumerGroupsResult result = env.adminClient().listConsumerGroups(options);
+ Collection<ConsumerGroupListing> listings = result.valid().get();
+
+ assertEquals(2, listings.size());
+ List<ConsumerGroupListing> expected = new ArrayList<>();
+ expected.add(new ConsumerGroupListing("group-2", Optional.of(GroupState.EMPTY), true));
+ expected.add(new ConsumerGroupListing("group-1", Optional.of(GroupState.STABLE), false));
+ assertEquals(expected, listings);
+ assertEquals(0, result.errors().get().size());
+ }
+ }
+
+ @Test
+ @SuppressWarnings("removal")
+ public void testListConsumerGroupsDeprecatedWithTypes() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ // Test with a specific state filter but no type filter in list consumer group options.
+ env.kafkaClient().prepareResponse(prepareMetadataResponse(env.cluster(), Errors.NONE));
+
+ env.kafkaClient().prepareResponseFrom(
+ expectListGroupsRequestWithFilters(Set.of(GroupState.STABLE.toString()), Set.of()),
+ new ListGroupsResponse(new ListGroupsResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setGroups(List.of(
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-1")
+ .setProtocolType(ConsumerProtocol.PROTOCOL_TYPE)
+ .setGroupState("Stable")
+ .setGroupType(GroupType.CLASSIC.toString())))),
+ env.cluster().nodeById(0));
+
+ final ListConsumerGroupsOptions options = new ListConsumerGroupsOptions().inGroupStates(Set.of(GroupState.STABLE));
+ final ListConsumerGroupsResult result = env.adminClient().listConsumerGroups(options);
+ Collection<ConsumerGroupListing> listings = result.valid().get();
+
+ assertEquals(1, listings.size());
+ List<ConsumerGroupListing> expected = new ArrayList<>();
+ expected.add(new ConsumerGroupListing("group-1", Optional.of(GroupState.STABLE), Optional.of(GroupType.CLASSIC), false));
+ assertEquals(expected, listings);
+ assertEquals(0, result.errors().get().size());
+
+ // Test with list consumer group options.
+ env.kafkaClient().prepareResponse(prepareMetadataResponse(env.cluster(), Errors.NONE));
+
+ env.kafkaClient().prepareResponseFrom(
+ expectListGroupsRequestWithFilters(Set.of(), Set.of(GroupType.CONSUMER.toString())),
+ new ListGroupsResponse(new ListGroupsResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setGroups(List.of(
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-1")
+ .setProtocolType(ConsumerProtocol.PROTOCOL_TYPE)
+ .setGroupState("Stable")
+ .setGroupType(GroupType.CONSUMER.toString()),
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-2")
+ .setGroupState("Empty")
+ .setGroupType(GroupType.CONSUMER.toString())))),
+ env.cluster().nodeById(0));
+
+ final ListConsumerGroupsOptions options2 = new ListConsumerGroupsOptions().withTypes(singleton(GroupType.CONSUMER));
+ final ListConsumerGroupsResult result2 = env.adminClient().listConsumerGroups(options2);
+ Collection<ConsumerGroupListing> listings2 = result2.valid().get();
+
+ assertEquals(2, listings2.size());
+ List<ConsumerGroupListing> expected2 = new ArrayList<>();
+ expected2.add(new ConsumerGroupListing("group-2", Optional.of(GroupState.EMPTY), Optional.of(GroupType.CONSUMER), true));
+ expected2.add(new ConsumerGroupListing("group-1", Optional.of(GroupState.STABLE), Optional.of(GroupType.CONSUMER), false));
+ assertEquals(expected2, listings2);
+ assertEquals(0, result.errors().get().size());
+ }
+ }
+
+ @Test
+ @SuppressWarnings("removal")
+ public void testListConsumerGroupsDeprecatedWithStatesOlderBrokerVersion() throws Exception {
+ ApiVersion listGroupV3 = new ApiVersion()
+ .setApiKey(ApiKeys.LIST_GROUPS.id)
+ .setMinVersion((short) 0)
+ .setMaxVersion((short) 3);
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create(List.of(listGroupV3)));
+
+ env.kafkaClient().prepareResponse(prepareMetadataResponse(env.cluster(), Errors.NONE));
+
+ // Check we can list groups with older broker if we don't specify states
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(new ListGroupsResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setGroups(List.of(
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-1")
+ .setProtocolType(ConsumerProtocol.PROTOCOL_TYPE)))),
+ env.cluster().nodeById(0));
+
+ ListConsumerGroupsOptions options = new ListConsumerGroupsOptions();
+ ListConsumerGroupsResult result = env.adminClient().listConsumerGroups(options);
+ Collection<ConsumerGroupListing> listing = result.all().get();
+ assertEquals(1, listing.size());
+ List<ConsumerGroupListing> expected = List.of(new ConsumerGroupListing("group-1", false));
+ assertEquals(expected, listing);
+
+ // But we cannot set a state filter with older broker
+ env.kafkaClient().prepareResponse(prepareMetadataResponse(env.cluster(), Errors.NONE));
+ env.kafkaClient().prepareUnsupportedVersionResponse(
+ body -> body instanceof ListGroupsRequest);
+
+ options = new ListConsumerGroupsOptions().inGroupStates(Set.of(GroupState.STABLE));
+ result = env.adminClient().listConsumerGroups(options);
+ TestUtils.assertFutureThrows(UnsupportedVersionException.class, result.all());
+ }
+ }
+
+ @Test
+ @SuppressWarnings("removal")
+ public void testListConsumerGroupsDeprecatedWithTypesOlderBrokerVersion() throws Exception {
+ ApiVersion listGroupV4 = new ApiVersion()
+ .setApiKey(ApiKeys.LIST_GROUPS.id)
+ .setMinVersion((short) 0)
+ .setMaxVersion((short) 4);
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create(List.of(listGroupV4)));
+
+ env.kafkaClient().prepareResponse(prepareMetadataResponse(env.cluster(), Errors.NONE));
+
+ // Check if we can list groups with older broker if we specify states and don't specify types.
+ env.kafkaClient().prepareResponseFrom(
+ expectListGroupsRequestWithFilters(Set.of(GroupState.STABLE.toString()), Set.of()),
+ new ListGroupsResponse(new ListGroupsResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setGroups(List.of(
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-1")
+ .setProtocolType(ConsumerProtocol.PROTOCOL_TYPE)
+ .setGroupState(GroupState.STABLE.toString())))),
+ env.cluster().nodeById(0));
+
+ ListConsumerGroupsOptions options = new ListConsumerGroupsOptions().inGroupStates(Set.of(GroupState.STABLE));
+ ListConsumerGroupsResult result = env.adminClient().listConsumerGroups(options);
+
+ Collection<ConsumerGroupListing> listing = result.all().get();
+ assertEquals(1, listing.size());
+ List<ConsumerGroupListing> expected = List.of(
+ new ConsumerGroupListing("group-1", Optional.of(GroupState.STABLE), false)
+ );
+ assertEquals(expected, listing);
+
+ // Check that we cannot set a type filter with an older broker.
+ env.kafkaClient().prepareResponse(prepareMetadataResponse(env.cluster(), Errors.NONE));
+ env.kafkaClient().prepareUnsupportedVersionResponse(request ->
+ request instanceof ListGroupsRequest && !((ListGroupsRequest) request).data().typesFilter().isEmpty()
+ );
+
+ options = new ListConsumerGroupsOptions().withTypes(Set.of(GroupType.SHARE));
+ result = env.adminClient().listConsumerGroups(options);
+ TestUtils.assertFutureThrows(UnsupportedVersionException.class, result.all());
+
+ // But a type filter which is just classic groups is permitted with an older broker, because they
+ // only know about classic groups so the types filter can be omitted.
+ env.kafkaClient().prepareResponse(prepareMetadataResponse(env.cluster(), Errors.NONE));
+
+ env.kafkaClient().prepareResponseFrom(
+ expectListGroupsRequestWithFilters(Set.of(), Set.of()),
+ new ListGroupsResponse(new ListGroupsResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setGroups(List.of(
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("group-1")
+ .setProtocolType(ConsumerProtocol.PROTOCOL_TYPE)
+ .setGroupState(GroupState.STABLE.toString())))),
+ env.cluster().nodeById(0));
+
+ options = new ListConsumerGroupsOptions().withTypes(Set.of(GroupType.CLASSIC));
+ result = env.adminClient().listConsumerGroups(options);
+
+ listing = result.all().get();
+ assertEquals(1, listing.size());
+ assertEquals(expected, listing);
+ }
+ }
+
+ @Test
+ public void testOffsetCommitNumRetries() throws Exception {
+ final Cluster cluster = mockCluster(3, 0);
+ final Time time = new MockTime();
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time, cluster,
+ AdminClientConfig.RETRIES_CONFIG, "0")) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ final TopicPartition tp1 = new TopicPartition("foo", 0);
+
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+ env.kafkaClient().prepareResponse(prepareOffsetCommitResponse(tp1, Errors.NOT_COORDINATOR));
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ Map<TopicPartition, OffsetAndMetadata> offsets = new HashMap<>();
+ offsets.put(tp1, new OffsetAndMetadata(123L));
+ final AlterConsumerGroupOffsetsResult result = env.adminClient().alterConsumerGroupOffsets(GROUP_ID, offsets);
+
+ TestUtils.assertFutureThrows(TimeoutException.class, result.all());
+ }
+ }
+
+ @Test
+ public void testOffsetCommitWithMultipleErrors() throws Exception {
+ final Cluster cluster = mockCluster(3, 0);
+ final Time time = new MockTime();
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time, cluster,
+ AdminClientConfig.RETRIES_CONFIG, "0")) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ final TopicPartition foo0 = new TopicPartition("foo", 0);
+ final TopicPartition foo1 = new TopicPartition("foo", 1);
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ Map<TopicPartition, Errors> responseData = new HashMap<>();
+ responseData.put(foo0, Errors.NONE);
+ responseData.put(foo1, Errors.UNKNOWN_TOPIC_OR_PARTITION);
+ env.kafkaClient().prepareResponse(new OffsetCommitResponse(0, responseData));
+
+ Map<TopicPartition, OffsetAndMetadata> offsets = new HashMap<>();
+ offsets.put(foo0, new OffsetAndMetadata(123L));
+ offsets.put(foo1, new OffsetAndMetadata(456L));
+ final AlterConsumerGroupOffsetsResult result = env.adminClient()
+ .alterConsumerGroupOffsets(GROUP_ID, offsets);
+
+ assertNull(result.partitionResult(foo0).get());
+ TestUtils.assertFutureThrows(UnknownTopicOrPartitionException.class, result.partitionResult(foo1));
+
+ TestUtils.assertFutureThrows(UnknownTopicOrPartitionException.class, result.all());
+ }
+ }
+
+ @Test
+ public void testOffsetCommitRetryBackoff() throws Exception {
+ MockTime time = new MockTime();
+ int retryBackoff = 100;
+
+ try (final AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time,
+ mockCluster(3, 0),
+ newStrMap(AdminClientConfig.RETRY_BACKOFF_MS_CONFIG, "" + retryBackoff))) {
+ MockClient mockClient = env.kafkaClient();
+
+ mockClient.setNodeApiVersions(NodeApiVersions.create());
+
+ AtomicLong firstAttemptTime = new AtomicLong(0);
+ AtomicLong secondAttemptTime = new AtomicLong(0);
+
+ final TopicPartition tp1 = new TopicPartition("foo", 0);
+
+ mockClient.prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+ mockClient.prepareResponse(body -> {
+ firstAttemptTime.set(time.milliseconds());
+ return true;
+ }, prepareOffsetCommitResponse(tp1, Errors.NOT_COORDINATOR));
+
+ mockClient.prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+ mockClient.prepareResponse(body -> {
+ secondAttemptTime.set(time.milliseconds());
+ return true;
+ }, prepareOffsetCommitResponse(tp1, Errors.NONE));
+
+ Map<TopicPartition, OffsetAndMetadata> offsets = new HashMap<>();
+ offsets.put(tp1, new OffsetAndMetadata(123L));
+ final KafkaFuture<Void> future = env.adminClient().alterConsumerGroupOffsets(GROUP_ID, offsets).all();
+
+ TestUtils.waitForCondition(() -> mockClient.numAwaitingResponses() == 1, "Failed awaiting CommitOffsets first request failure");
+ TestUtils.waitForCondition(() -> ((KafkaAdminClient) env.adminClient()).numPendingCalls() == 1, "Failed to add retry CommitOffsets call on first failure");
+
+ long lowerBoundBackoffMs = (long) (retryBackoff * (1 - CommonClientConfigs.RETRY_BACKOFF_JITTER));
+ long upperBoundBackoffMs = (long) (retryBackoff * CommonClientConfigs.RETRY_BACKOFF_EXP_BASE * (1 + CommonClientConfigs.RETRY_BACKOFF_JITTER));
+ time.sleep(upperBoundBackoffMs);
+
+ future.get();
+
+ long actualRetryBackoff = secondAttemptTime.get() - firstAttemptTime.get();
+ assertEquals(retryBackoff, actualRetryBackoff, upperBoundBackoffMs - lowerBoundBackoffMs, "CommitOffsets retry did not await expected backoff");
+ }
+ }
+
+ @Test
+ public void testDescribeConsumerGroupNumRetries() throws Exception {
+ final Cluster cluster = mockCluster(3, 0);
+ final Time time = new MockTime();
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time, cluster,
+ AdminClientConfig.RETRIES_CONFIG, "0")) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ DescribeGroupsResponseData data = new DescribeGroupsResponseData();
+
+ data.groups().add(DescribeGroupsResponse.groupMetadata(
+ GROUP_ID,
+ Errors.NOT_COORDINATOR,
+ "",
+ "",
+ "",
+ Collections.emptyList(),
+ Collections.emptySet()));
+ env.kafkaClient().prepareResponse(new DescribeGroupsResponse(data));
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ final DescribeConsumerGroupsResult result = env.adminClient().describeConsumerGroups(singletonList(GROUP_ID));
+
+ TestUtils.assertFutureThrows(TimeoutException.class, result.all());
+ }
+ }
+
+ @Test
+ public void testDescribeConsumerGroupRetryBackoff() throws Exception {
+ MockTime time = new MockTime();
+ int retryBackoff = 100;
+
+ try (final AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time,
+ mockCluster(3, 0),
+ newStrMap(AdminClientConfig.RETRY_BACKOFF_MS_CONFIG, "" + retryBackoff))) {
+ MockClient mockClient = env.kafkaClient();
+
+ mockClient.setNodeApiVersions(NodeApiVersions.create());
+
+ AtomicLong firstAttemptTime = new AtomicLong(0);
+ AtomicLong secondAttemptTime = new AtomicLong(0);
+
+ mockClient.prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ DescribeGroupsResponseData data = new DescribeGroupsResponseData();
+ data.groups().add(DescribeGroupsResponse.groupMetadata(
+ GROUP_ID,
+ Errors.NOT_COORDINATOR,
+ "",
+ "",
+ "",
+ Collections.emptyList(),
+ Collections.emptySet()));
+
+ mockClient.prepareResponse(body -> {
+ firstAttemptTime.set(time.milliseconds());
+ return true;
+ }, new DescribeGroupsResponse(data));
+
+ mockClient.prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ data = new DescribeGroupsResponseData();
+ data.groups().add(DescribeGroupsResponse.groupMetadata(
+ GROUP_ID,
+ Errors.NONE,
+ "",
+ ConsumerProtocol.PROTOCOL_TYPE,
+ "",
+ Collections.emptyList(),
+ Collections.emptySet()));
+
+ mockClient.prepareResponse(body -> {
+ secondAttemptTime.set(time.milliseconds());
+ return true;
+ }, new DescribeGroupsResponse(data));
+
+ final KafkaFuture<Map<String, ConsumerGroupDescription>> future =
+ env.adminClient().describeConsumerGroups(singletonList(GROUP_ID)).all();
+
+ TestUtils.waitForCondition(() -> mockClient.numAwaitingResponses() == 1, "Failed awaiting DescribeConsumerGroup first request failure");
+ TestUtils.waitForCondition(() -> ((KafkaAdminClient) env.adminClient()).numPendingCalls() == 1, "Failed to add retry DescribeConsumerGroup call on first failure");
+
+ long lowerBoundBackoffMs = (long) (retryBackoff * (1 - CommonClientConfigs.RETRY_BACKOFF_JITTER));
+ long upperBoundBackoffMs = (long) (retryBackoff * CommonClientConfigs.RETRY_BACKOFF_EXP_BASE * (1 + CommonClientConfigs.RETRY_BACKOFF_JITTER));
+ time.sleep(upperBoundBackoffMs);
+
+ future.get();
+
+ long actualRetryBackoff = secondAttemptTime.get() - firstAttemptTime.get();
+ assertEquals(retryBackoff, actualRetryBackoff, upperBoundBackoffMs - lowerBoundBackoffMs, "DescribeConsumerGroup retry did not await expected backoff!");
+ }
+ }
+
+ @Test
+ public void testDescribeConsumerGroups() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ // Retriable FindCoordinatorResponse errors should be retried
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.COORDINATOR_NOT_AVAILABLE, Node.noNode()));
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.COORDINATOR_LOAD_IN_PROGRESS, Node.noNode()));
+
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ // The first request sent will be a ConsumerGroupDescribe request. Let's
+ // fail it in order to fail back to using the classic version.
+ env.kafkaClient().prepareUnsupportedVersionResponse(
+ request -> request instanceof ConsumerGroupDescribeRequest);
+
+ DescribeGroupsResponseData data = new DescribeGroupsResponseData();
+
+ // Retriable errors should be retried
+ data.groups().add(DescribeGroupsResponse.groupMetadata(
+ GROUP_ID,
+ Errors.COORDINATOR_LOAD_IN_PROGRESS,
+ "",
+ "",
+ "",
+ Collections.emptyList(),
+ Collections.emptySet()));
+ env.kafkaClient().prepareResponse(new DescribeGroupsResponse(data));
+
+ /*
+ * We need to return two responses here, one with NOT_COORDINATOR error when calling describe consumer group
+ * api using coordinator that has moved. This will retry whole operation. So we need to again respond with a
+ * FindCoordinatorResponse.
+ *
+ * And the same reason for COORDINATOR_NOT_AVAILABLE error response
+ */
+ data = new DescribeGroupsResponseData();
+ data.groups().add(DescribeGroupsResponse.groupMetadata(
+ GROUP_ID,
+ Errors.NOT_COORDINATOR,
+ "",
+ "",
+ "",
+ Collections.emptyList(),
+ Collections.emptySet()));
+ env.kafkaClient().prepareResponse(new DescribeGroupsResponse(data));
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ data = new DescribeGroupsResponseData();
+ data.groups().add(DescribeGroupsResponse.groupMetadata(
+ GROUP_ID,
+ Errors.COORDINATOR_NOT_AVAILABLE,
+ "",
+ "",
+ "",
+ Collections.emptyList(),
+ Collections.emptySet()));
+ env.kafkaClient().prepareResponse(new DescribeGroupsResponse(data));
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ data = new DescribeGroupsResponseData();
+ TopicPartition myTopicPartition0 = new TopicPartition("my_topic", 0);
+ TopicPartition myTopicPartition1 = new TopicPartition("my_topic", 1);
+ TopicPartition myTopicPartition2 = new TopicPartition("my_topic", 2);
+
+ final List<TopicPartition> topicPartitions = new ArrayList<>();
+ topicPartitions.add(0, myTopicPartition0);
+ topicPartitions.add(1, myTopicPartition1);
+ topicPartitions.add(2, myTopicPartition2);
+
+ final ByteBuffer memberAssignment = ConsumerProtocol.serializeAssignment(new ConsumerPartitionAssignor.Assignment(topicPartitions));
+ byte[] memberAssignmentBytes = new byte[memberAssignment.remaining()];
+ memberAssignment.get(memberAssignmentBytes);
+
+ DescribedGroupMember memberOne = DescribeGroupsResponse.groupMember("0", "instance1", "clientId0", "clientHost", memberAssignmentBytes, null);
+ DescribedGroupMember memberTwo = DescribeGroupsResponse.groupMember("1", "instance2", "clientId1", "clientHost", memberAssignmentBytes, null);
+
+ List<MemberDescription> expectedMemberDescriptions = new ArrayList<>();
+ expectedMemberDescriptions.add(convertToMemberDescriptions(memberOne,
+ new MemberAssignment(new HashSet<>(topicPartitions))));
+ expectedMemberDescriptions.add(convertToMemberDescriptions(memberTwo,
+ new MemberAssignment(new HashSet<>(topicPartitions))));
+ data.groups().add(DescribeGroupsResponse.groupMetadata(
+ GROUP_ID,
+ Errors.NONE,
+ "",
+ ConsumerProtocol.PROTOCOL_TYPE,
+ "",
+ asList(memberOne, memberTwo),
+ Collections.emptySet()));
+
+ env.kafkaClient().prepareResponse(new DescribeGroupsResponse(data));
+
+ final DescribeConsumerGroupsResult result = env.adminClient().describeConsumerGroups(singletonList(GROUP_ID));
+ final ConsumerGroupDescription groupDescription = result.describedGroups().get(GROUP_ID).get();
+
+ assertEquals(1, result.describedGroups().size());
+ assertEquals(GROUP_ID, groupDescription.groupId());
+ assertEquals(2, groupDescription.members().size());
+ assertEquals(expectedMemberDescriptions, groupDescription.members());
+ }
+ }
+
+ @Test
+ public void testDescribeMultipleConsumerGroups() {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(new FindCoordinatorResponse(
+ new FindCoordinatorResponseData()
+ .setCoordinators(asList(
+ FindCoordinatorResponse.prepareCoordinatorResponse(Errors.NONE, GROUP_ID, env.cluster().controller()),
+ FindCoordinatorResponse.prepareCoordinatorResponse(Errors.NONE, "group-connect-0", env.cluster().controller())
+ ))
+ ));
+
+ // The first request sent will be a ConsumerGroupDescribe request. Let's
+ // fail it in order to fail back to using the classic version.
+ env.kafkaClient().prepareUnsupportedVersionResponse(
+ request -> request instanceof ConsumerGroupDescribeRequest);
+
+ TopicPartition myTopicPartition0 = new TopicPartition("my_topic", 0);
+ TopicPartition myTopicPartition1 = new TopicPartition("my_topic", 1);
+ TopicPartition myTopicPartition2 = new TopicPartition("my_topic", 2);
+
+ final List<TopicPartition> topicPartitions = new ArrayList<>();
+ topicPartitions.add(0, myTopicPartition0);
+ topicPartitions.add(1, myTopicPartition1);
+ topicPartitions.add(2, myTopicPartition2);
+
+ final ByteBuffer memberAssignment = ConsumerProtocol.serializeAssignment(new ConsumerPartitionAssignor.Assignment(topicPartitions));
+ byte[] memberAssignmentBytes = new byte[memberAssignment.remaining()];
+ memberAssignment.get(memberAssignmentBytes);
+
+ DescribeGroupsResponseData groupData = new DescribeGroupsResponseData();
+ groupData.groups().add(DescribeGroupsResponse.groupMetadata(
+ GROUP_ID,
+ Errors.NONE,
+ "",
+ ConsumerProtocol.PROTOCOL_TYPE,
+ "",
+ asList(
+ DescribeGroupsResponse.groupMember("0", null, "clientId0", "clientHost", memberAssignmentBytes, null),
+ DescribeGroupsResponse.groupMember("1", null, "clientId1", "clientHost", memberAssignmentBytes, null)
+ ),
+ Collections.emptySet()));
+ groupData.groups().add(DescribeGroupsResponse.groupMetadata(
+ "group-connect-0",
+ Errors.NONE,
+ "",
+ "connect",
+ "",
+ asList(
+ DescribeGroupsResponse.groupMember("0", null, "clientId0", "clientHost", memberAssignmentBytes, null),
+ DescribeGroupsResponse.groupMember("1", null, "clientId1", "clientHost", memberAssignmentBytes, null)
+ ),
+ Collections.emptySet()));
+
+ env.kafkaClient().prepareResponse(new DescribeGroupsResponse(groupData));
+
+ Collection<String> groups = new HashSet<>();
+ groups.add(GROUP_ID);
+ groups.add("group-connect-0");
+ final DescribeConsumerGroupsResult result = env.adminClient().describeConsumerGroups(groups);
+ assertEquals(2, result.describedGroups().size());
+ assertEquals(groups, result.describedGroups().keySet());
+ KafkaFuture<Map<String, ConsumerGroupDescription>> allFuture = result.all();
+ // This throws because the second group is a classic connect group, not a consumer group.
+ assertThrows(ExecutionException.class, allFuture::get);
+ assertTrue(allFuture.isCompletedExceptionally());
+ }
+ }
+
+ @Test
+ public void testDescribeConsumerGroupsGroupIdNotFound() {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(new FindCoordinatorResponse(
+ new FindCoordinatorResponseData()
+ .setCoordinators(asList(
+ FindCoordinatorResponse.prepareCoordinatorResponse(Errors.NONE, GROUP_ID, env.cluster().controller()),
+ FindCoordinatorResponse.prepareCoordinatorResponse(Errors.NONE, "group-connect-0", env.cluster().controller())
+ ))
+ ));
+
+ // The first request sent will be a ConsumerGroupDescribe request. Let's
+ // fail it in order to fail back to using the classic version.
+ env.kafkaClient().prepareUnsupportedVersionResponse(
+ request -> request instanceof ConsumerGroupDescribeRequest);
+
+ TopicPartition myTopicPartition0 = new TopicPartition("my_topic", 0);
+ TopicPartition myTopicPartition1 = new TopicPartition("my_topic", 1);
+ TopicPartition myTopicPartition2 = new TopicPartition("my_topic", 2);
+
+ final List<TopicPartition> topicPartitions = new ArrayList<>();
+ topicPartitions.add(0, myTopicPartition0);
+ topicPartitions.add(1, myTopicPartition1);
+ topicPartitions.add(2, myTopicPartition2);
+
+ final ByteBuffer memberAssignment = ConsumerProtocol.serializeAssignment(new ConsumerPartitionAssignor.Assignment(topicPartitions));
+ byte[] memberAssignmentBytes = new byte[memberAssignment.remaining()];
+ memberAssignment.get(memberAssignmentBytes);
+
+ DescribeGroupsResponseData groupData = new DescribeGroupsResponseData();
+ groupData.groups().add(DescribeGroupsResponse.groupMetadata(
+ GROUP_ID,
+ Errors.NONE,
+ "",
+ ConsumerProtocol.PROTOCOL_TYPE,
+ "",
+ asList(
+ DescribeGroupsResponse.groupMember("0", null, "clientId0", "clientHost", memberAssignmentBytes, null),
+ DescribeGroupsResponse.groupMember("1", null, "clientId1", "clientHost", memberAssignmentBytes, null)
+ ),
+ Collections.emptySet()));
+ groupData.groups().add(DescribeGroupsResponse.groupError(
+ "group-connect-0",
+ Errors.GROUP_ID_NOT_FOUND,
+ "Group group-connect-0 is not a classic group."));
+
+ env.kafkaClient().prepareResponse(new DescribeGroupsResponse(groupData));
+
+ Collection<String> groups = new HashSet<>();
+ groups.add(GROUP_ID);
+ groups.add("group-connect-0");
+ final DescribeConsumerGroupsResult result = env.adminClient().describeConsumerGroups(groups);
+ assertEquals(2, result.describedGroups().size());
+ assertEquals(groups, result.describedGroups().keySet());
+ KafkaFuture<Map<String, ConsumerGroupDescription>> allFuture = result.all();
+ assertThrows(ExecutionException.class, allFuture::get);
+ assertTrue(result.all().isCompletedExceptionally());
+ }
+ }
+
+ @Test
+ public void testDescribeConsumerGroupsWithAuthorizedOperationsOmitted() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ // The first request sent will be a ConsumerGroupDescribe request. Let's
+ // fail it in order to fail back to using the classic version.
+ env.kafkaClient().prepareUnsupportedVersionResponse(
+ request -> request instanceof ConsumerGroupDescribeRequest);
+
+ DescribeGroupsResponseData data = new DescribeGroupsResponseData();
+ data.groups().add(DescribeGroupsResponse.groupMetadata(
+ GROUP_ID,
+ Errors.NONE,
+ "",
+ ConsumerProtocol.PROTOCOL_TYPE,
+ "",
+ Collections.emptyList(),
+ MetadataResponse.AUTHORIZED_OPERATIONS_OMITTED));
+
+ env.kafkaClient().prepareResponse(new DescribeGroupsResponse(data));
+
+ final DescribeConsumerGroupsResult result = env.adminClient().describeConsumerGroups(singletonList(GROUP_ID));
+ final ConsumerGroupDescription groupDescription = result.describedGroups().get(GROUP_ID).get();
+
+ assertNull(groupDescription.authorizedOperations());
+ }
+ }
+
+ @Test
+ public void testDescribeNonConsumerGroups() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ // The first request sent will be a ConsumerGroupDescribe request. Let's
+ // fail it in order to fail back to using the classic version.
+ env.kafkaClient().prepareUnsupportedVersionResponse(
+ request -> request instanceof ConsumerGroupDescribeRequest);
+
+ DescribeGroupsResponseData data = new DescribeGroupsResponseData();
+
+ data.groups().add(DescribeGroupsResponse.groupMetadata(
+ GROUP_ID,
+ Errors.NONE,
+ "",
+ "non-consumer",
+ "",
+ emptyList(),
+ Collections.emptySet()));
+
+ env.kafkaClient().prepareResponse(new DescribeGroupsResponse(data));
+
+ final DescribeConsumerGroupsResult result = env.adminClient().describeConsumerGroups(singletonList(GROUP_ID));
+
+ TestUtils.assertFutureThrows(IllegalArgumentException.class, result.describedGroups().get(GROUP_ID));
+ }
+ }
+
+ @Test
+ public void testDescribeGroupsWithBothUnsupportedApis() throws InterruptedException {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ // The first request sent will be a ConsumerGroupDescribe request. Let's
+ // fail it in order to fail back to using the classic version.
+ env.kafkaClient().prepareUnsupportedVersionResponse(
+ request -> request instanceof ConsumerGroupDescribeRequest);
+
+ // Let's also fail the second one.
+ env.kafkaClient().prepareUnsupportedVersionResponse(
+ request -> request instanceof DescribeGroupsRequest);
+
+ DescribeConsumerGroupsResult result = env.adminClient().describeConsumerGroups(singletonList(GROUP_ID));
+ TestUtils.assertFutureThrows(UnsupportedVersionException.class, result.describedGroups().get(GROUP_ID));
+ }
+ }
+
+ @Test
+ public void testDescribeOldAndNewConsumerGroups() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(new FindCoordinatorResponse(
+ new FindCoordinatorResponseData()
+ .setCoordinators(asList(
+ FindCoordinatorResponse.prepareCoordinatorResponse(Errors.NONE, "grp1", env.cluster().controller()),
+ FindCoordinatorResponse.prepareCoordinatorResponse(Errors.NONE, "grp2", env.cluster().controller())
+ ))
+ ));
+
+ env.kafkaClient().prepareResponse(new ConsumerGroupDescribeResponse(
+ new ConsumerGroupDescribeResponseData()
+ .setGroups(asList(
+ new ConsumerGroupDescribeResponseData.DescribedGroup()
+ .setGroupId("grp1")
+ .setGroupState("Stable")
+ .setGroupEpoch(10)
+ .setAssignmentEpoch(10)
+ .setAssignorName("range")
+ .setAuthorizedOperations(Utils.to32BitField(emptySet()))
+ .setMembers(singletonList(
+ new ConsumerGroupDescribeResponseData.Member()
+ .setMemberId("memberId")
+ .setInstanceId("instanceId")
+ .setClientHost("host")
+ .setClientId("clientId")
+ .setMemberEpoch(10)
+ .setRackId("rackId")
+ .setSubscribedTopicNames(singletonList("foo"))
+ .setSubscribedTopicRegex("regex")
+ .setAssignment(new ConsumerGroupDescribeResponseData.Assignment()
+ .setTopicPartitions(singletonList(
+ new ConsumerGroupDescribeResponseData.TopicPartitions()
+ .setTopicId(Uuid.randomUuid())
+ .setTopicName("foo")
+ .setPartitions(singletonList(0))
+ )))
+ .setTargetAssignment(new ConsumerGroupDescribeResponseData.Assignment()
+ .setTopicPartitions(singletonList(
+ new ConsumerGroupDescribeResponseData.TopicPartitions()
+ .setTopicId(Uuid.randomUuid())
+ .setTopicName("foo")
+ .setPartitions(singletonList(1))
+ )))
+ .setMemberType((byte) 1)
+ )),
+ new ConsumerGroupDescribeResponseData.DescribedGroup()
+ .setGroupId("grp2")
+ .setErrorCode(Errors.GROUP_ID_NOT_FOUND.code())
+ ))
+ ));
+
+ env.kafkaClient().prepareResponse(new DescribeGroupsResponse(
+ new DescribeGroupsResponseData()
+ .setGroups(Collections.singletonList(
+ DescribeGroupsResponse.groupMetadata(
+ "grp2",
+ Errors.NONE,
+ "Stable",
+ ConsumerProtocol.PROTOCOL_TYPE,
+ "range",
+ singletonList(
+ DescribeGroupsResponse.groupMember(
+ "0",
+ null,
+ "clientId0",
+ "clientHost",
+ ConsumerProtocol.serializeAssignment(
+ new ConsumerPartitionAssignor.Assignment(
+ Collections.singletonList(new TopicPartition("bar", 0))
+ )
+ ).array(),
+ null
+ )
+ ),
+ Collections.emptySet()
+ )
+ ))
+ ));
+
+ DescribeConsumerGroupsResult result = env.adminClient()
+ .describeConsumerGroups(asList("grp1", "grp2"));
+
+ Map<String, ConsumerGroupDescription> expectedResult = new HashMap<>();
+ expectedResult.put("grp1", new ConsumerGroupDescription(
+ "grp1",
+ false,
+ Collections.singletonList(
+ new MemberDescription(
+ "memberId",
+ Optional.of("instanceId"),
+ Optional.of("rackId"),
+ "clientId",
+ "host",
+ new MemberAssignment(
+ Collections.singleton(new TopicPartition("foo", 0))
+ ),
+ Optional.of(new MemberAssignment(
+ Collections.singleton(new TopicPartition("foo", 1))
+ )),
+ Optional.of(10),
+ Optional.of(true)
+ )
+ ),
+ "range",
+ GroupType.CONSUMER,
+ GroupState.STABLE,
+ env.cluster().controller(),
+ Collections.emptySet(),
+ Optional.of(10),
+ Optional.of(10)
+ ));
+ expectedResult.put("grp2", new ConsumerGroupDescription(
+ "grp2",
+ false,
+ Collections.singletonList(
+ new MemberDescription(
+ "0",
+ Optional.empty(),
+ Optional.empty(),
+ "clientId0",
+ "clientHost",
+ new MemberAssignment(
+ Collections.singleton(new TopicPartition("bar", 0))
+ ),
+ Optional.empty(),
+ Optional.empty(),
+ Optional.empty()
+ )
+ ),
+ "range",
+ GroupType.CLASSIC,
+ GroupState.STABLE,
+ env.cluster().controller(),
+ Collections.emptySet(),
+ Optional.empty(),
+ Optional.empty()
+ ));
+
+ assertEquals(expectedResult, result.all().get());
+ }
+ }
+
+ @Test
+ public void testListConsumerGroupOffsetsOptionsWithBatchedApi() throws Exception {
+ verifyListConsumerGroupOffsetsOptions();
+ }
+
+ @Test
+ public void testListConsumerGroupOffsetsNumRetries() throws Exception {
+ final Cluster cluster = mockCluster(3, 0);
+ final Time time = new MockTime();
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time, cluster,
+ AdminClientConfig.RETRIES_CONFIG, "0")) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+ env.kafkaClient().prepareResponse(offsetFetchResponse(Errors.NOT_COORDINATOR));
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ final ListConsumerGroupOffsetsResult result = env.adminClient().listConsumerGroupOffsets(GROUP_ID);
+
+ TestUtils.assertFutureThrows(TimeoutException.class, result.partitionsToOffsetAndMetadata());
+ }
+ }
+
+ @Test
+ public void testListConsumerGroupOffsetsRetryBackoff() throws Exception {
+ MockTime time = new MockTime();
+ int retryBackoff = 100;
+
+ try (final AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time,
+ mockCluster(3, 0),
+ newStrMap(AdminClientConfig.RETRY_BACKOFF_MS_CONFIG, "" + retryBackoff))) {
+ MockClient mockClient = env.kafkaClient();
+
+ mockClient.setNodeApiVersions(NodeApiVersions.create());
+
+ AtomicLong firstAttemptTime = new AtomicLong(0);
+ AtomicLong secondAttemptTime = new AtomicLong(0);
+
+ mockClient.prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+ mockClient.prepareResponse(body -> {
+ firstAttemptTime.set(time.milliseconds());
+ return true;
+ }, offsetFetchResponse(Errors.NOT_COORDINATOR));
+
+ mockClient.prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ mockClient.prepareResponse(body -> {
+ secondAttemptTime.set(time.milliseconds());
+ return true;
+ }, offsetFetchResponse(Errors.NONE));
+
+ final KafkaFuture<Map<TopicPartition, OffsetAndMetadata>> future = env.adminClient().listConsumerGroupOffsets(GROUP_ID).partitionsToOffsetAndMetadata();
+
+ TestUtils.waitForCondition(() -> mockClient.numAwaitingResponses() == 1, "Failed awaiting ListConsumerGroupOffsets first request failure");
+ TestUtils.waitForCondition(() -> ((KafkaAdminClient) env.adminClient()).numPendingCalls() == 1, "Failed to add retry ListConsumerGroupOffsets call on first failure");
+
+ long lowerBoundBackoffMs = (long) (retryBackoff * (1 - CommonClientConfigs.RETRY_BACKOFF_JITTER));
+ long upperBoundBackoffMs = (long) (retryBackoff * CommonClientConfigs.RETRY_BACKOFF_EXP_BASE * (1 + CommonClientConfigs.RETRY_BACKOFF_JITTER));
+ time.sleep(upperBoundBackoffMs);
+
+ future.get();
+
+ long actualRetryBackoff = secondAttemptTime.get() - firstAttemptTime.get();
+ assertEquals(retryBackoff, actualRetryBackoff, upperBoundBackoffMs - lowerBoundBackoffMs, "ListConsumerGroupOffsets retry did not await expected backoff!");
+ }
+ }
+
+ @Test
+ public void testListConsumerGroupOffsetsRetriableErrors() throws Exception {
+ // Retriable errors should be retried
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ env.kafkaClient().prepareResponse(
+ offsetFetchResponse(Errors.COORDINATOR_LOAD_IN_PROGRESS));
+
+ /*
+ * We need to return two responses here, one for NOT_COORDINATOR call when calling list consumer offsets
+ * api using coordinator that has moved. This will retry whole operation. So we need to again respond with a
+ * FindCoordinatorResponse.
+ *
+ * And the same reason for the following COORDINATOR_NOT_AVAILABLE error response
+ */
+ env.kafkaClient().prepareResponse(
+ offsetFetchResponse(Errors.NOT_COORDINATOR));
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ env.kafkaClient().prepareResponse(
+ offsetFetchResponse(Errors.COORDINATOR_NOT_AVAILABLE));
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ env.kafkaClient().prepareResponse(
+ offsetFetchResponse(Errors.NONE));
+
+ final ListConsumerGroupOffsetsResult errorResult1 = env.adminClient().listConsumerGroupOffsets(GROUP_ID);
+
+ assertEquals(Collections.emptyMap(), errorResult1.partitionsToOffsetAndMetadata().get());
+ }
+ }
+
+ @Test
+ public void testListConsumerGroupOffsetsNonRetriableErrors() throws Exception {
+ // Non-retriable errors throw an exception
+ final List<Errors> nonRetriableErrors = asList(
+ Errors.GROUP_AUTHORIZATION_FAILED, Errors.INVALID_GROUP_ID, Errors.GROUP_ID_NOT_FOUND,
+ Errors.UNKNOWN_MEMBER_ID, Errors.STALE_MEMBER_EPOCH);
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ for (Errors error : nonRetriableErrors) {
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ env.kafkaClient().prepareResponse(offsetFetchResponse(error));
+
+ ListConsumerGroupOffsetsResult errorResult = env.adminClient().listConsumerGroupOffsets(GROUP_ID);
+
+ TestUtils.assertFutureThrows(error.exception().getClass(), errorResult.partitionsToOffsetAndMetadata());
+ }
+ }
+ }
+
+ @Test
+ public void testListConsumerGroupOffsets() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ // Retriable FindCoordinatorResponse errors should be retried
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.COORDINATOR_NOT_AVAILABLE, Node.noNode()));
+
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ // Retriable errors should be retried
+ env.kafkaClient().prepareResponse(offsetFetchResponse(Errors.COORDINATOR_LOAD_IN_PROGRESS));
+
+ /*
+ * We need to return two responses here, one for NOT_COORDINATOR error when calling list consumer group offsets
+ * api using coordinator that has moved. This will retry whole operation. So we need to again respond with a
+ * FindCoordinatorResponse.
+ *
+ * And the same reason for the following COORDINATOR_NOT_AVAILABLE error response
+ */
+ env.kafkaClient().prepareResponse(offsetFetchResponse(Errors.NOT_COORDINATOR));
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ env.kafkaClient().prepareResponse(offsetFetchResponse(Errors.COORDINATOR_NOT_AVAILABLE));
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ TopicPartition myTopicPartition0 = new TopicPartition("my_topic", 0);
+ TopicPartition myTopicPartition1 = new TopicPartition("my_topic", 1);
+ TopicPartition myTopicPartition2 = new TopicPartition("my_topic", 2);
+ TopicPartition myTopicPartition3 = new TopicPartition("my_topic", 3);
+
+ final OffsetFetchResponseData response = new OffsetFetchResponseData()
+ .setGroups(List.of(
+ new OffsetFetchResponseData.OffsetFetchResponseGroup()
+ .setGroupId(GROUP_ID)
+ .setTopics(List.of(
+ new OffsetFetchResponseData.OffsetFetchResponseTopics()
+ .setName("my_topic")
+ .setPartitions(List.of(
+ new OffsetFetchResponseData.OffsetFetchResponsePartitions()
+ .setPartitionIndex(myTopicPartition0.partition())
+ .setCommittedOffset(10),
+ new OffsetFetchResponseData.OffsetFetchResponsePartitions()
+ .setPartitionIndex(myTopicPartition1.partition())
+ .setCommittedOffset(0),
+ new OffsetFetchResponseData.OffsetFetchResponsePartitions()
+ .setPartitionIndex(myTopicPartition2.partition())
+ .setCommittedOffset(20),
+ new OffsetFetchResponseData.OffsetFetchResponsePartitions()
+ .setPartitionIndex(myTopicPartition3.partition())
+ .setCommittedOffset(OffsetFetchResponse.INVALID_OFFSET)
+ ))
+ ))
+ ));
+
+ env.kafkaClient().prepareResponse(new OffsetFetchResponse(response, ApiKeys.OFFSET_FETCH.latestVersion()));
+
+ final ListConsumerGroupOffsetsResult result = env.adminClient().listConsumerGroupOffsets(GROUP_ID);
+ final Map<TopicPartition, OffsetAndMetadata> partitionToOffsetAndMetadata = result.partitionsToOffsetAndMetadata().get();
+
+ assertEquals(4, partitionToOffsetAndMetadata.size());
+ assertEquals(10, partitionToOffsetAndMetadata.get(myTopicPartition0).offset());
+ assertEquals(0, partitionToOffsetAndMetadata.get(myTopicPartition1).offset());
+ assertEquals(20, partitionToOffsetAndMetadata.get(myTopicPartition2).offset());
+ assertTrue(partitionToOffsetAndMetadata.containsKey(myTopicPartition3));
+ assertNull(partitionToOffsetAndMetadata.get(myTopicPartition3));
+ }
+ }
+
+ @Test
+ public void testBatchedListConsumerGroupOffsets() throws Exception {
+ Cluster cluster = mockCluster(1, 0);
+ Time time = new MockTime();
+ Map<String, ListConsumerGroupOffsetsSpec> groupSpecs = batchedListConsumerGroupOffsetsSpec();
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time, cluster, AdminClientConfig.RETRIES_CONFIG, "0")) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+ env.kafkaClient().prepareResponse(prepareBatchedFindCoordinatorResponse(Errors.NONE, env.cluster().controller(), groupSpecs.keySet()));
+
+ ListConsumerGroupOffsetsResult result = env.adminClient().listConsumerGroupOffsets(groupSpecs, new ListConsumerGroupOffsetsOptions());
+ sendOffsetFetchResponse(env.kafkaClient(), groupSpecs, true, Errors.NONE);
+
+ verifyListOffsetsForMultipleGroups(groupSpecs, result);
+ }
+ }
+
+ @Test
+ public void testBatchedListConsumerGroupOffsetsWithNoFindCoordinatorBatching() throws Exception {
+ Cluster cluster = mockCluster(1, 0);
+ Time time = new MockTime();
+ Map<String, ListConsumerGroupOffsetsSpec> groupSpecs = batchedListConsumerGroupOffsetsSpec();
+
+ ApiVersion findCoordinatorV3 = new ApiVersion()
+ .setApiKey(ApiKeys.FIND_COORDINATOR.id)
+ .setMinVersion((short) 0)
+ .setMaxVersion((short) 3);
+ ApiVersion offsetFetchV7 = new ApiVersion()
+ .setApiKey(ApiKeys.OFFSET_FETCH.id)
+ .setMinVersion((short) 0)
+ .setMaxVersion((short) 7);
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time, cluster, AdminClientConfig.RETRY_BACKOFF_MS_CONFIG, "0")) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create(asList(findCoordinatorV3, offsetFetchV7)));
+ env.kafkaClient().prepareResponse(prepareOldFindCoordinatorResponse(Errors.COORDINATOR_NOT_AVAILABLE, Node.noNode()));
+ env.kafkaClient().prepareResponse(prepareOldFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+ env.kafkaClient().prepareResponse(prepareOldFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ ListConsumerGroupOffsetsResult result = env.adminClient().listConsumerGroupOffsets(groupSpecs);
+
+ // Fail the first request in order to ensure that the group is not batched when retried.
+ sendOffsetFetchResponse(env.kafkaClient(), groupSpecs, false, Errors.COORDINATOR_LOAD_IN_PROGRESS);
+
+ sendOffsetFetchResponse(env.kafkaClient(), groupSpecs, false, Errors.NONE);
+ sendOffsetFetchResponse(env.kafkaClient(), groupSpecs, false, Errors.NONE);
+
+ verifyListOffsetsForMultipleGroups(groupSpecs, result);
+ }
+ }
+
+ @Test
+ public void testBatchedListConsumerGroupOffsetsWithNoOffsetFetchBatching() throws Exception {
+ Cluster cluster = mockCluster(1, 0);
+ Time time = new MockTime();
+ Map<String, ListConsumerGroupOffsetsSpec> groupSpecs = batchedListConsumerGroupOffsetsSpec();
+
+ ApiVersion offsetFetchV7 = new ApiVersion()
+ .setApiKey(ApiKeys.OFFSET_FETCH.id)
+ .setMinVersion((short) 0)
+ .setMaxVersion((short) 7);
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time, cluster, AdminClientConfig.RETRY_BACKOFF_MS_CONFIG, "0")) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create(Collections.singleton(offsetFetchV7)));
+ env.kafkaClient().prepareResponse(prepareBatchedFindCoordinatorResponse(Errors.NONE, env.cluster().controller(), groupSpecs.keySet()));
+ // Prepare a response to force client to attempt batched request creation that throws
+ // NoBatchedOffsetFetchRequestException. This triggers creation of non-batched requests.
+ env.kafkaClient().prepareResponse(offsetFetchResponse(Errors.COORDINATOR_NOT_AVAILABLE));
+
+ ListConsumerGroupOffsetsResult result = env.adminClient().listConsumerGroupOffsets(groupSpecs);
+
+ // The request handler attempts both FindCoordinator and OffsetFetch requests. This seems
+ // ok since we expect this scenario only during upgrades from versions < 3.0.0 where
+ // some upgraded brokers could handle batched FindCoordinator while non-upgraded coordinators
+ // rejected batched OffsetFetch requests.
+ sendFindCoordinatorResponse(env.kafkaClient(), env.cluster().controller());
+ sendFindCoordinatorResponse(env.kafkaClient(), env.cluster().controller());
+ sendOffsetFetchResponse(env.kafkaClient(), groupSpecs, false, Errors.NONE);
+ sendOffsetFetchResponse(env.kafkaClient(), groupSpecs, false, Errors.NONE);
+
+ verifyListOffsetsForMultipleGroups(groupSpecs, result);
+ }
+ }
+
+ @Test
+ public void testDeleteConsumerGroupsNumRetries() throws Exception {
+ final Cluster cluster = mockCluster(3, 0);
+ final Time time = new MockTime();
+ final List<String> groupIds = singletonList("groupId");
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time, cluster,
+ AdminClientConfig.RETRIES_CONFIG, "0")) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+ final DeletableGroupResultCollection validResponse = new DeletableGroupResultCollection();
+ validResponse.add(new DeletableGroupResult()
+ .setGroupId("groupId")
+ .setErrorCode(Errors.NOT_COORDINATOR.code()));
+ env.kafkaClient().prepareResponse(new DeleteGroupsResponse(
+ new DeleteGroupsResponseData()
+ .setResults(validResponse)
+ ));
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ final DeleteConsumerGroupsResult result = env.adminClient().deleteConsumerGroups(groupIds);
+
+ TestUtils.assertFutureThrows(TimeoutException.class, result.all());
+ }
+ }
+
+ @Test
+ public void testDeleteConsumerGroupsRetryBackoff() throws Exception {
+ MockTime time = new MockTime();
+ int retryBackoff = 100;
+ final List<String> groupIds = singletonList(GROUP_ID);
+
+ try (final AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time,
+ mockCluster(3, 0),
+ newStrMap(AdminClientConfig.RETRY_BACKOFF_MS_CONFIG, "" + retryBackoff))) {
+ MockClient mockClient = env.kafkaClient();
+
+ mockClient.setNodeApiVersions(NodeApiVersions.create());
+
+ AtomicLong firstAttemptTime = new AtomicLong(0);
+ AtomicLong secondAttemptTime = new AtomicLong(0);
+
+ mockClient.prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ DeletableGroupResultCollection validResponse = new DeletableGroupResultCollection();
+ validResponse.add(new DeletableGroupResult()
+ .setGroupId(GROUP_ID)
+ .setErrorCode(Errors.NOT_COORDINATOR.code()));
+
+ mockClient.prepareResponse(body -> {
+ firstAttemptTime.set(time.milliseconds());
+ return true;
+ }, new DeleteGroupsResponse(new DeleteGroupsResponseData().setResults(validResponse)));
+
+ mockClient.prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ validResponse = new DeletableGroupResultCollection();
+ validResponse.add(new DeletableGroupResult()
+ .setGroupId(GROUP_ID)
+ .setErrorCode(Errors.NONE.code()));
+
+ mockClient.prepareResponse(body -> {
+ secondAttemptTime.set(time.milliseconds());
+ return true;
+ }, new DeleteGroupsResponse(new DeleteGroupsResponseData().setResults(validResponse)));
+
+ final KafkaFuture<Void> future = env.adminClient().deleteConsumerGroups(groupIds).all();
+
+ TestUtils.waitForCondition(() -> mockClient.numAwaitingResponses() == 1, "Failed awaiting DeleteConsumerGroups first request failure");
+ TestUtils.waitForCondition(() -> ((KafkaAdminClient) env.adminClient()).numPendingCalls() == 1, "Failed to add retry DeleteConsumerGroups call on first failure");
+
+ long lowerBoundBackoffMs = (long) (retryBackoff * (1 - CommonClientConfigs.RETRY_BACKOFF_JITTER));
+ long upperBoundBackoffMs = (long) (retryBackoff * CommonClientConfigs.RETRY_BACKOFF_EXP_BASE * (1 + CommonClientConfigs.RETRY_BACKOFF_JITTER));
+ time.sleep(upperBoundBackoffMs);
+
+ future.get();
+
+ long actualRetryBackoff = secondAttemptTime.get() - firstAttemptTime.get();
+ assertEquals(retryBackoff, actualRetryBackoff, upperBoundBackoffMs - lowerBoundBackoffMs, "DeleteConsumerGroups retry did not await expected backoff!");
+ }
+ }
+
+ @Test
+ public void testDeleteConsumerGroupsWithOlderBroker() throws Exception {
+ final List<String> groupIds = singletonList("groupId");
+ ApiVersion findCoordinatorV3 = new ApiVersion()
+ .setApiKey(ApiKeys.FIND_COORDINATOR.id)
+ .setMinVersion((short) 0)
+ .setMaxVersion((short) 3);
+ ApiVersion describeGroups = new ApiVersion()
+ .setApiKey(ApiKeys.DESCRIBE_GROUPS.id)
+ .setMinVersion((short) 0)
+ .setMaxVersion(ApiKeys.DELETE_GROUPS.latestVersion());
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create(asList(findCoordinatorV3, describeGroups)));
+
+ // Retriable FindCoordinatorResponse errors should be retried
+ env.kafkaClient().prepareResponse(prepareOldFindCoordinatorResponse(Errors.COORDINATOR_NOT_AVAILABLE, Node.noNode()));
+ env.kafkaClient().prepareResponse(prepareOldFindCoordinatorResponse(Errors.COORDINATOR_LOAD_IN_PROGRESS, Node.noNode()));
+
+ env.kafkaClient().prepareResponse(prepareOldFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ final DeletableGroupResultCollection validResponse = new DeletableGroupResultCollection();
+ validResponse.add(new DeletableGroupResult()
+ .setGroupId("groupId")
+ .setErrorCode(Errors.NONE.code()));
+ env.kafkaClient().prepareResponse(new DeleteGroupsResponse(
+ new DeleteGroupsResponseData()
+ .setResults(validResponse)
+ ));
+
+ final DeleteConsumerGroupsResult result = env.adminClient().deleteConsumerGroups(groupIds);
+
+ final KafkaFuture<Void> results = result.deletedGroups().get("groupId");
+ assertNull(results.get());
+
+ // should throw error for non-retriable errors
+ env.kafkaClient().prepareResponse(
+ prepareOldFindCoordinatorResponse(Errors.GROUP_AUTHORIZATION_FAILED, Node.noNode()));
+
+ DeleteConsumerGroupsResult errorResult = env.adminClient().deleteConsumerGroups(groupIds);
+ TestUtils.assertFutureThrows(GroupAuthorizationException.class, errorResult.deletedGroups().get("groupId"));
+
+ // Retriable errors should be retried
+ env.kafkaClient().prepareResponse(
+ prepareOldFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ final DeletableGroupResultCollection errorResponse = new DeletableGroupResultCollection();
+ errorResponse.add(new DeletableGroupResult()
+ .setGroupId("groupId")
+ .setErrorCode(Errors.COORDINATOR_LOAD_IN_PROGRESS.code())
+ );
+ env.kafkaClient().prepareResponse(new DeleteGroupsResponse(
+ new DeleteGroupsResponseData()
+ .setResults(errorResponse)));
+
+ /*
+ * We need to return two responses here, one for NOT_COORDINATOR call when calling delete a consumer group
+ * api using coordinator that has moved. This will retry whole operation. So we need to again respond with a
+ * FindCoordinatorResponse.
+ *
+ * And the same reason for the following COORDINATOR_NOT_AVAILABLE error response
+ */
+
+ DeletableGroupResultCollection coordinatorMoved = new DeletableGroupResultCollection();
+ coordinatorMoved.add(new DeletableGroupResult()
+ .setGroupId("groupId")
+ .setErrorCode(Errors.NOT_COORDINATOR.code())
+ );
+
+ env.kafkaClient().prepareResponse(new DeleteGroupsResponse(
+ new DeleteGroupsResponseData()
+ .setResults(coordinatorMoved)));
+ env.kafkaClient().prepareResponse(prepareOldFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ coordinatorMoved = new DeletableGroupResultCollection();
+ coordinatorMoved.add(new DeletableGroupResult()
+ .setGroupId("groupId")
+ .setErrorCode(Errors.COORDINATOR_NOT_AVAILABLE.code())
+ );
+
+ env.kafkaClient().prepareResponse(new DeleteGroupsResponse(
+ new DeleteGroupsResponseData()
+ .setResults(coordinatorMoved)));
+ env.kafkaClient().prepareResponse(prepareOldFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ env.kafkaClient().prepareResponse(new DeleteGroupsResponse(
+ new DeleteGroupsResponseData()
+ .setResults(validResponse)));
+
+ errorResult = env.adminClient().deleteConsumerGroups(groupIds);
+
+ final KafkaFuture<Void> errorResults = errorResult.deletedGroups().get("groupId");
+ assertNull(errorResults.get());
+ }
+ }
+
+ @Test
+ public void testDeleteMultipleConsumerGroupsWithOlderBroker() throws Exception {
+ final List<String> groupIds = asList("group1", "group2");
+ ApiVersion findCoordinatorV3 = new ApiVersion()
+ .setApiKey(ApiKeys.FIND_COORDINATOR.id)
+ .setMinVersion((short) 0)
+ .setMaxVersion((short) 3);
+ ApiVersion describeGroups = new ApiVersion()
+ .setApiKey(ApiKeys.DESCRIBE_GROUPS.id)
+ .setMinVersion((short) 0)
+ .setMaxVersion(ApiKeys.DELETE_GROUPS.latestVersion());
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(
+ NodeApiVersions.create(asList(findCoordinatorV3, describeGroups)));
+
+ // Dummy response for MockClient to handle the UnsupportedVersionException correctly to switch from batched to un-batched
+ env.kafkaClient().prepareResponse(null);
+ // Retriable FindCoordinatorResponse errors should be retried
+ for (int i = 0; i < groupIds.size(); i++) {
+ env.kafkaClient().prepareResponse(
+ prepareOldFindCoordinatorResponse(Errors.COORDINATOR_NOT_AVAILABLE, Node.noNode()));
+ }
+ for (int i = 0; i < groupIds.size(); i++) {
+ env.kafkaClient().prepareResponse(
+ prepareOldFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+ }
+
+ final DeletableGroupResultCollection validResponse = new DeletableGroupResultCollection();
+ validResponse.add(new DeletableGroupResult()
+ .setGroupId("group1")
+ .setErrorCode(Errors.NONE.code()));
+ validResponse.add(new DeletableGroupResult()
+ .setGroupId("group2")
+ .setErrorCode(Errors.NONE.code()));
+ env.kafkaClient().prepareResponse(new DeleteGroupsResponse(
+ new DeleteGroupsResponseData()
+ .setResults(validResponse)
+ ));
+
+ final DeleteConsumerGroupsResult result = env.adminClient()
+ .deleteConsumerGroups(groupIds);
+
+ final KafkaFuture<Void> results = result.deletedGroups().get("group1");
+ assertNull(results.get(5, TimeUnit.SECONDS));
+ }
+ }
+
+ @Test
+ public void testDeleteConsumerGroupOffsetsNumRetries() throws Exception {
+ final Cluster cluster = mockCluster(3, 0);
+ final Time time = new MockTime();
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time, cluster,
+ AdminClientConfig.RETRIES_CONFIG, "0")) {
+ final TopicPartition tp1 = new TopicPartition("foo", 0);
+
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+ env.kafkaClient().prepareResponse(prepareOffsetDeleteResponse(Errors.NOT_COORDINATOR));
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ final DeleteConsumerGroupOffsetsResult result = env.adminClient()
+ .deleteConsumerGroupOffsets(GROUP_ID, Stream.of(tp1).collect(Collectors.toSet()));
+
+ TestUtils.assertFutureThrows(TimeoutException.class, result.all());
+ }
+ }
+
+ @Test
+ public void testDeleteConsumerGroupOffsetsRetryBackoff() throws Exception {
+ MockTime time = new MockTime();
+ int retryBackoff = 100;
+
+ try (final AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time,
+ mockCluster(3, 0),
+ newStrMap(AdminClientConfig.RETRY_BACKOFF_MS_CONFIG, "" + retryBackoff))) {
+ MockClient mockClient = env.kafkaClient();
+
+ mockClient.setNodeApiVersions(NodeApiVersions.create());
+
+ AtomicLong firstAttemptTime = new AtomicLong(0);
+ AtomicLong secondAttemptTime = new AtomicLong(0);
+
+ final TopicPartition tp1 = new TopicPartition("foo", 0);
+
+ mockClient.prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ mockClient.prepareResponse(body -> {
+ firstAttemptTime.set(time.milliseconds());
+ return true;
+ }, prepareOffsetDeleteResponse(Errors.NOT_COORDINATOR));
+
+ mockClient.prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ mockClient.prepareResponse(body -> {
+ secondAttemptTime.set(time.milliseconds());
+ return true;
+ }, prepareOffsetDeleteResponse("foo", 0, Errors.NONE));
+
+ final KafkaFuture<Void> future = env.adminClient().deleteConsumerGroupOffsets(GROUP_ID, Stream.of(tp1).collect(Collectors.toSet())).all();
+
+ TestUtils.waitForCondition(() -> mockClient.numAwaitingResponses() == 1, "Failed awaiting DeleteConsumerGroupOffsets first request failure");
+ TestUtils.waitForCondition(() -> ((KafkaAdminClient) env.adminClient()).numPendingCalls() == 1, "Failed to add retry DeleteConsumerGroupOffsets call on first failure");
+
+ long lowerBoundBackoffMs = (long) (retryBackoff * (1 - CommonClientConfigs.RETRY_BACKOFF_JITTER));
+ long upperBoundBackoffMs = (long) (retryBackoff * CommonClientConfigs.RETRY_BACKOFF_EXP_BASE * (1 + CommonClientConfigs.RETRY_BACKOFF_JITTER));
+ time.sleep(upperBoundBackoffMs);
+
+ future.get();
+
+ long actualRetryBackoff = secondAttemptTime.get() - firstAttemptTime.get();
+ assertEquals(retryBackoff, actualRetryBackoff, upperBoundBackoffMs - lowerBoundBackoffMs, "DeleteConsumerGroupOffsets retry did not await expected backoff!");
+ }
+ }
+
+ @Test
+ public void testDeleteConsumerGroupOffsets() throws Exception {
+ // Happy path
+
+ final TopicPartition tp1 = new TopicPartition("foo", 0);
+ final TopicPartition tp2 = new TopicPartition("bar", 0);
+ final TopicPartition tp3 = new TopicPartition("foobar", 0);
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ env.kafkaClient().prepareResponse(new OffsetDeleteResponse(
+ new OffsetDeleteResponseData()
+ .setTopics(new OffsetDeleteResponseTopicCollection(Stream.of(
+ new OffsetDeleteResponseTopic()
+ .setName("foo")
+ .setPartitions(new OffsetDeleteResponsePartitionCollection(Collections.singletonList(
+ new OffsetDeleteResponsePartition()
+ .setPartitionIndex(0)
+ .setErrorCode(Errors.NONE.code())
+ ))),
+ new OffsetDeleteResponseTopic()
+ .setName("bar")
+ .setPartitions(new OffsetDeleteResponsePartitionCollection(Collections.singletonList(
+ new OffsetDeleteResponsePartition()
+ .setPartitionIndex(0)
+ .setErrorCode(Errors.GROUP_SUBSCRIBED_TO_TOPIC.code())
+ )))
+ ).collect(Collectors.toList())))
+ )
+ );
+
+ final DeleteConsumerGroupOffsetsResult errorResult = env.adminClient().deleteConsumerGroupOffsets(
+ GROUP_ID, Stream.of(tp1, tp2).collect(Collectors.toSet()));
+
+ assertNull(errorResult.partitionResult(tp1).get());
+ TestUtils.assertFutureThrows(GroupSubscribedToTopicException.class, errorResult.all());
+ TestUtils.assertFutureThrows(GroupSubscribedToTopicException.class, errorResult.partitionResult(tp2));
+ assertThrows(IllegalArgumentException.class, () -> errorResult.partitionResult(tp3));
+ }
+ }
+
+ @Test
+ public void testDeleteConsumerGroupOffsetsRetriableErrors() throws Exception {
+ // Retriable errors should be retried
+
+ final TopicPartition tp1 = new TopicPartition("foo", 0);
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ env.kafkaClient().prepareResponse(
+ prepareOffsetDeleteResponse(Errors.COORDINATOR_LOAD_IN_PROGRESS));
+
+ /*
+ * We need to return two responses here, one for NOT_COORDINATOR call when calling delete a consumer group
+ * api using coordinator that has moved. This will retry whole operation. So we need to again respond with a
+ * FindCoordinatorResponse.
+ *
+ * And the same reason for the following COORDINATOR_NOT_AVAILABLE error response
+ */
+ env.kafkaClient().prepareResponse(
+ prepareOffsetDeleteResponse(Errors.NOT_COORDINATOR));
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ env.kafkaClient().prepareResponse(
+ prepareOffsetDeleteResponse(Errors.COORDINATOR_NOT_AVAILABLE));
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ env.kafkaClient().prepareResponse(
+ prepareOffsetDeleteResponse("foo", 0, Errors.NONE));
+
+ final DeleteConsumerGroupOffsetsResult errorResult1 = env.adminClient()
+ .deleteConsumerGroupOffsets(GROUP_ID, Stream.of(tp1).collect(Collectors.toSet()));
+
+ assertNull(errorResult1.all().get());
+ assertNull(errorResult1.partitionResult(tp1).get());
+ }
+ }
+
+ @Test
+ public void testDeleteConsumerGroupOffsetsNonRetriableErrors() throws Exception {
+ // Non-retriable errors throw an exception
+
+ final TopicPartition tp1 = new TopicPartition("foo", 0);
+ final List<Errors> nonRetriableErrors = asList(
+ Errors.GROUP_AUTHORIZATION_FAILED, Errors.INVALID_GROUP_ID, Errors.GROUP_ID_NOT_FOUND);
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ for (Errors error : nonRetriableErrors) {
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ env.kafkaClient().prepareResponse(
+ prepareOffsetDeleteResponse(error));
+
+ DeleteConsumerGroupOffsetsResult errorResult = env.adminClient()
+ .deleteConsumerGroupOffsets(GROUP_ID, Stream.of(tp1).collect(Collectors.toSet()));
+
+ TestUtils.assertFutureThrows(error.exception().getClass(), errorResult.all());
+ TestUtils.assertFutureThrows(error.exception().getClass(), errorResult.partitionResult(tp1));
+ }
+ }
+ }
+
+ @Test
+ public void testDeleteConsumerGroupOffsetsFindCoordinatorRetriableErrors() throws Exception {
+ // Retriable FindCoordinatorResponse errors should be retried
+
+ final TopicPartition tp1 = new TopicPartition("foo", 0);
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.COORDINATOR_NOT_AVAILABLE, Node.noNode()));
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.COORDINATOR_LOAD_IN_PROGRESS, Node.noNode()));
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ env.kafkaClient().prepareResponse(
+ prepareOffsetDeleteResponse("foo", 0, Errors.NONE));
+
+ final DeleteConsumerGroupOffsetsResult result = env.adminClient()
+ .deleteConsumerGroupOffsets(GROUP_ID, Stream.of(tp1).collect(Collectors.toSet()));
+
+ assertNull(result.all().get());
+ assertNull(result.partitionResult(tp1).get());
+ }
+ }
+
+ @Test
+ public void testDeleteConsumerGroupOffsetsFindCoordinatorNonRetriableErrors() throws Exception {
+ // Non-retriable FindCoordinatorResponse errors throw an exception
+
+ final TopicPartition tp1 = new TopicPartition("foo", 0);
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.GROUP_AUTHORIZATION_FAILED, Node.noNode()));
+
+ final DeleteConsumerGroupOffsetsResult errorResult = env.adminClient()
+ .deleteConsumerGroupOffsets(GROUP_ID, Stream.of(tp1).collect(Collectors.toSet()));
+
+ TestUtils.assertFutureThrows(GroupAuthorizationException.class, errorResult.all());
+ TestUtils.assertFutureThrows(GroupAuthorizationException.class, errorResult.partitionResult(tp1));
+ }
+ }
+
+ @Test
+ public void testDescribeClassicGroups() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ // Retriable FindCoordinatorResponse errors should be retried
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.COORDINATOR_NOT_AVAILABLE, Node.noNode()));
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.COORDINATOR_LOAD_IN_PROGRESS, Node.noNode()));
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ DescribeGroupsResponseData data = new DescribeGroupsResponseData();
+
+ // Retriable errors should be retried
+ data.groups().add(new DescribeGroupsResponseData.DescribedGroup()
+ .setGroupId(GROUP_ID)
+ .setErrorCode(Errors.COORDINATOR_LOAD_IN_PROGRESS.code()));
+ env.kafkaClient().prepareResponse(new DescribeGroupsResponse(data));
+
+ /*
+ * We need to return two responses here, one with NOT_COORDINATOR error when calling describe classic group
+ * api using coordinator that has moved. This will retry whole operation. So we need to again respond with a
+ * FindCoordinatorResponse.
+ *
+ * And the same reason for COORDINATOR_NOT_AVAILABLE error response
+ */
+ data = new DescribeGroupsResponseData();
+ data.groups().add(new DescribeGroupsResponseData.DescribedGroup()
+ .setGroupId(GROUP_ID)
+ .setErrorCode(Errors.NOT_COORDINATOR.code()));
+ env.kafkaClient().prepareResponse(new DescribeGroupsResponse(data));
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ data = new DescribeGroupsResponseData();
+ data.groups().add(new DescribeGroupsResponseData.DescribedGroup()
+ .setGroupId(GROUP_ID)
+ .setErrorCode(Errors.COORDINATOR_NOT_AVAILABLE.code()));
+ env.kafkaClient().prepareResponse(new DescribeGroupsResponse(data));
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ final List<TopicPartition> topicPartitions = List.of(
+ new TopicPartition("my_topic", 0),
+ new TopicPartition("my_topic", 1),
+ new TopicPartition("my_topic", 2));
+ final ByteBuffer memberAssignment = ConsumerProtocol.serializeAssignment(new ConsumerPartitionAssignor.Assignment(topicPartitions));
+ final byte[] memberAssignmentBytes = new byte[memberAssignment.remaining()];
+ memberAssignment.get(memberAssignmentBytes);
+
+ data = new DescribeGroupsResponseData();
+ DescribeGroupsResponseData.DescribedGroupMember memberOne = new DescribeGroupsResponseData.DescribedGroupMember()
+ .setMemberId("0")
+ .setClientId("clientId0")
+ .setClientHost("clientHost")
+ .setMemberAssignment(memberAssignmentBytes);
+ DescribeGroupsResponseData.DescribedGroupMember memberTwo = new DescribeGroupsResponseData.DescribedGroupMember()
+ .setMemberId("1")
+ .setClientId("clientId1")
+ .setClientHost("clientHost")
+ .setGroupInstanceId("static")
+ .setMemberAssignment(memberAssignmentBytes);
+
+ final List<TopicPartition> expectedTopicPartitions = new ArrayList<>();
+ expectedTopicPartitions.add(0, new TopicPartition("my_topic", 0));
+ expectedTopicPartitions.add(1, new TopicPartition("my_topic", 1));
+ expectedTopicPartitions.add(2, new TopicPartition("my_topic", 2));
+
+ List<MemberDescription> expectedMemberDescriptions = new ArrayList<>();
+ expectedMemberDescriptions.add(convertToMemberDescriptions(memberOne,
+ new MemberAssignment(new HashSet<>(expectedTopicPartitions))));
+ expectedMemberDescriptions.add(convertToMemberDescriptions(memberTwo,
+ new MemberAssignment(new HashSet<>(expectedTopicPartitions))));
+ data.groups().add(new DescribeGroupsResponseData.DescribedGroup()
+ .setGroupId(GROUP_ID)
+ .setProtocolType(ConsumerProtocol.PROTOCOL_TYPE)
+ .setGroupState(ClassicGroupState.STABLE.toString())
+ .setMembers(List.of(memberOne, memberTwo)));
+
+ env.kafkaClient().prepareResponse(new DescribeGroupsResponse(data));
+
+ final DescribeClassicGroupsResult result = env.adminClient().describeClassicGroups(List.of(GROUP_ID));
+ final ClassicGroupDescription groupDescription = result.describedGroups().get(GROUP_ID).get();
+
+ assertEquals(1, result.describedGroups().size());
+ assertEquals(GROUP_ID, groupDescription.groupId());
+ assertEquals(2, groupDescription.members().size());
+ assertEquals(expectedMemberDescriptions, groupDescription.members());
+ }
+ }
+
+ @Test
+ public void testDescribeClassicGroupsWithAuthorizedOperationsOmitted() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ DescribeGroupsResponseData data = new DescribeGroupsResponseData();
+
+ data.groups().add(new DescribeGroupsResponseData.DescribedGroup()
+ .setGroupId(GROUP_ID)
+ .setProtocolType("")
+ .setAuthorizedOperations(MetadataResponse.AUTHORIZED_OPERATIONS_OMITTED));
+
+ env.kafkaClient().prepareResponse(new DescribeGroupsResponse(data));
+
+ final DescribeClassicGroupsResult result = env.adminClient().describeClassicGroups(List.of(GROUP_ID));
+ final ClassicGroupDescription groupDescription = result.describedGroups().get(GROUP_ID).get();
+
+ assertNull(groupDescription.authorizedOperations());
+ }
+ }
+
+ @Test
+ public void testDescribeMultipleClassicGroups() {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ final List<TopicPartition> topicPartitions = List.of(
+ new TopicPartition("my_topic", 0),
+ new TopicPartition("my_topic", 1),
+ new TopicPartition("my_topic", 2));
+ final ByteBuffer memberAssignment = ConsumerProtocol.serializeAssignment(new ConsumerPartitionAssignor.Assignment(topicPartitions));
+ final byte[] memberAssignmentBytes = new byte[memberAssignment.remaining()];
+ memberAssignment.get(memberAssignmentBytes);
+
+ DescribeGroupsResponseData group0Data = new DescribeGroupsResponseData();
+ group0Data.groups().add(new DescribeGroupsResponseData.DescribedGroup()
+ .setGroupId(GROUP_ID)
+ .setProtocolType(ConsumerProtocol.PROTOCOL_TYPE)
+ .setGroupState(ClassicGroupState.STABLE.toString())
+ .setMembers(List.of(
+ new DescribeGroupsResponseData.DescribedGroupMember()
+ .setMemberId("0")
+ .setClientId("clientId0")
+ .setClientHost("clientHost")
+ .setMemberAssignment(memberAssignmentBytes),
+ new DescribeGroupsResponseData.DescribedGroupMember()
+ .setMemberId("1")
+ .setClientId("clientId1")
+ .setClientHost("clientHost")
+ .setMemberAssignment(memberAssignmentBytes))));
+
+ DescribeGroupsResponseData group1Data = new DescribeGroupsResponseData();
+ group1Data.groups().add(new DescribeGroupsResponseData.DescribedGroup()
+ .setGroupId("group-1")
+ .setProtocolType("other")
+ .setGroupState(ClassicGroupState.STABLE.toString())
+ .setMembers(List.of(
+ new DescribeGroupsResponseData.DescribedGroupMember()
+ .setMemberId("0")
+ .setClientId("clientId0")
+ .setClientHost("clientHost"),
+ new DescribeGroupsResponseData.DescribedGroupMember()
+ .setMemberId("1")
+ .setClientId("clientId1")
+ .setClientHost("clientHost"))));
+
+ env.kafkaClient().prepareResponse(new DescribeGroupsResponse(group0Data));
+ env.kafkaClient().prepareResponse(new DescribeGroupsResponse(group1Data));
+
+ Collection<String> groups = new HashSet<>();
+ groups.add(GROUP_ID);
+ groups.add("group-1");
+ final DescribeClassicGroupsResult result = env.adminClient().describeClassicGroups(groups);
+ assertEquals(2, result.describedGroups().size());
+ assertEquals(groups, result.describedGroups().keySet());
+ }
+ }
+
+ @Test
+ public void testRemoveMembersFromGroupNumRetries() throws Exception {
+ final Cluster cluster = mockCluster(3, 0);
+ final Time time = new MockTime();
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time, cluster,
+ AdminClientConfig.RETRIES_CONFIG, "0")) {
+
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+ env.kafkaClient().prepareResponse(new LeaveGroupResponse(new LeaveGroupResponseData().setErrorCode(Errors.NOT_COORDINATOR.code())));
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ Collection<MemberToRemove> membersToRemove = asList(new MemberToRemove("instance-1"), new MemberToRemove("instance-2"));
+
+ final RemoveMembersFromConsumerGroupResult result = env.adminClient().removeMembersFromConsumerGroup(
+ GROUP_ID, new RemoveMembersFromConsumerGroupOptions(membersToRemove));
+
+ TestUtils.assertFutureThrows(TimeoutException.class, result.all());
+ }
+ }
+
+ @Test
+ public void testRemoveMembersFromGroupRetryBackoff() throws Exception {
+ MockTime time = new MockTime();
+ int retryBackoff = 100;
+
+ try (final AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time,
+ mockCluster(3, 0),
+ newStrMap(AdminClientConfig.RETRY_BACKOFF_MS_CONFIG, "" + retryBackoff))) {
+ MockClient mockClient = env.kafkaClient();
+
+ mockClient.setNodeApiVersions(NodeApiVersions.create());
+
+ AtomicLong firstAttemptTime = new AtomicLong(0);
+ AtomicLong secondAttemptTime = new AtomicLong(0);
+
+ mockClient.prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ env.kafkaClient().prepareResponse(body -> {
+ firstAttemptTime.set(time.milliseconds());
+ return true;
+ }, new LeaveGroupResponse(new LeaveGroupResponseData().setErrorCode(Errors.NOT_COORDINATOR.code())));
+
+ mockClient.prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ MemberResponse responseOne = new MemberResponse()
+ .setGroupInstanceId("instance-1")
+ .setErrorCode(Errors.NONE.code());
+ env.kafkaClient().prepareResponse(body -> {
+ secondAttemptTime.set(time.milliseconds());
+ return true;
+ }, new LeaveGroupResponse(new LeaveGroupResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setMembers(Collections.singletonList(responseOne))));
+
+ Collection<MemberToRemove> membersToRemove = singletonList(new MemberToRemove("instance-1"));
+
+ final KafkaFuture<Void> future = env.adminClient().removeMembersFromConsumerGroup(
+ GROUP_ID, new RemoveMembersFromConsumerGroupOptions(membersToRemove)).all();
+
+ TestUtils.waitForCondition(() -> mockClient.numAwaitingResponses() == 1, "Failed awaiting RemoveMembersFromGroup first request failure");
+ TestUtils.waitForCondition(() -> ((KafkaAdminClient) env.adminClient()).numPendingCalls() == 1, "Failed to add retry RemoveMembersFromGroup call on first failure");
+
+ long lowerBoundBackoffMs = (long) (retryBackoff * (1 - CommonClientConfigs.RETRY_BACKOFF_JITTER));
+ long upperBoundBackoffMs = (long) (retryBackoff * CommonClientConfigs.RETRY_BACKOFF_EXP_BASE * (1 + CommonClientConfigs.RETRY_BACKOFF_JITTER));
+ time.sleep(upperBoundBackoffMs);
+
+ future.get();
+
+ long actualRetryBackoff = secondAttemptTime.get() - firstAttemptTime.get();
+ assertEquals(retryBackoff, actualRetryBackoff, upperBoundBackoffMs - lowerBoundBackoffMs, "RemoveMembersFromGroup retry did not await expected backoff!");
+ }
+ }
+
+ @Test
+ public void testRemoveMembersFromGroupRetriableErrors() throws Exception {
+ // Retriable errors should be retried
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ env.kafkaClient().prepareResponse(
+ new LeaveGroupResponse(new LeaveGroupResponseData()
+ .setErrorCode(Errors.COORDINATOR_LOAD_IN_PROGRESS.code())));
+
+ /*
+ * We need to return two responses here, one for NOT_COORDINATOR call when calling remove member
+ * api using coordinator that has moved. This will retry whole operation. So we need to again respond with a
+ * FindCoordinatorResponse.
+ *
+ * And the same reason for the following COORDINATOR_NOT_AVAILABLE error response
+ */
+ env.kafkaClient().prepareResponse(
+ new LeaveGroupResponse(new LeaveGroupResponseData()
+ .setErrorCode(Errors.NOT_COORDINATOR.code())));
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ env.kafkaClient().prepareResponse(
+ new LeaveGroupResponse(new LeaveGroupResponseData()
+ .setErrorCode(Errors.COORDINATOR_NOT_AVAILABLE.code())));
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ MemberResponse memberResponse = new MemberResponse()
+ .setGroupInstanceId("instance-1")
+ .setErrorCode(Errors.NONE.code());
+ env.kafkaClient().prepareResponse(
+ new LeaveGroupResponse(new LeaveGroupResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setMembers(Collections.singletonList(memberResponse))));
+
+ MemberToRemove memberToRemove = new MemberToRemove("instance-1");
+ Collection<MemberToRemove> membersToRemove = singletonList(memberToRemove);
+
+ final RemoveMembersFromConsumerGroupResult result = env.adminClient().removeMembersFromConsumerGroup(
+ GROUP_ID, new RemoveMembersFromConsumerGroupOptions(membersToRemove));
+
+ assertNull(result.all().get());
+ assertNull(result.memberResult(memberToRemove).get());
+ }
+ }
+
+ @Test
+ public void testRemoveMembersFromGroupNonRetriableErrors() throws Exception {
+ // Non-retriable errors throw an exception
+
+ final List<Errors> nonRetriableErrors = asList(
+ Errors.GROUP_AUTHORIZATION_FAILED, Errors.INVALID_GROUP_ID, Errors.GROUP_ID_NOT_FOUND);
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ for (Errors error : nonRetriableErrors) {
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ env.kafkaClient().prepareResponse(
+ new LeaveGroupResponse(new LeaveGroupResponseData()
+ .setErrorCode(error.code())));
+
+ MemberToRemove memberToRemove = new MemberToRemove("instance-1");
+ Collection<MemberToRemove> membersToRemove = singletonList(memberToRemove);
+
+ final RemoveMembersFromConsumerGroupResult result = env.adminClient().removeMembersFromConsumerGroup(
+ GROUP_ID, new RemoveMembersFromConsumerGroupOptions(membersToRemove));
+
+ TestUtils.assertFutureThrows(error.exception().getClass(), result.all());
+ TestUtils.assertFutureThrows(error.exception().getClass(), result.memberResult(memberToRemove));
+ }
+ }
+ }
+
+ @Test
+ public void testRemoveMembersFromGroup() throws Exception {
+ try (AdminClientUnitTestEnv env = mockClientEnv()) {
+ final String instanceOne = "instance-1";
+ final String instanceTwo = "instance-2";
+
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ // Retriable FindCoordinatorResponse errors should be retried
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.COORDINATOR_LOAD_IN_PROGRESS, Node.noNode()));
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ // Retriable errors should be retried
+ env.kafkaClient().prepareResponse(new LeaveGroupResponse(new LeaveGroupResponseData()
+ .setErrorCode(Errors.COORDINATOR_LOAD_IN_PROGRESS.code())));
+
+ // Inject a top-level non-retriable error
+ env.kafkaClient().prepareResponse(new LeaveGroupResponse(new LeaveGroupResponseData()
+ .setErrorCode(Errors.UNKNOWN_SERVER_ERROR.code())));
+
+ Collection<MemberToRemove> membersToRemove = asList(new MemberToRemove(instanceOne),
+ new MemberToRemove(instanceTwo));
+ final RemoveMembersFromConsumerGroupResult unknownErrorResult = env.adminClient().removeMembersFromConsumerGroup(
+ GROUP_ID,
+ new RemoveMembersFromConsumerGroupOptions(membersToRemove)
+ );
+
+ MemberToRemove memberOne = new MemberToRemove(instanceOne);
+ MemberToRemove memberTwo = new MemberToRemove(instanceTwo);
+
+ TestUtils.assertFutureThrows(UnknownServerException.class, unknownErrorResult.memberResult(memberOne));
+ TestUtils.assertFutureThrows(UnknownServerException.class, unknownErrorResult.memberResult(memberTwo));
+
+ MemberResponse responseOne = new MemberResponse()
+ .setGroupInstanceId(instanceOne)
+ .setErrorCode(Errors.UNKNOWN_MEMBER_ID.code());
+
+ MemberResponse responseTwo = new MemberResponse()
+ .setGroupInstanceId(instanceTwo)
+ .setErrorCode(Errors.NONE.code());
+
+ // Inject one member level error.
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+ env.kafkaClient().prepareResponse(new LeaveGroupResponse(new LeaveGroupResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setMembers(asList(responseOne, responseTwo))));
+
+ final RemoveMembersFromConsumerGroupResult memberLevelErrorResult = env.adminClient().removeMembersFromConsumerGroup(
+ GROUP_ID,
+ new RemoveMembersFromConsumerGroupOptions(membersToRemove)
+ );
+
+ TestUtils.assertFutureThrows(UnknownMemberIdException.class, memberLevelErrorResult.all());
+ TestUtils.assertFutureThrows(UnknownMemberIdException.class, memberLevelErrorResult.memberResult(memberOne));
+ assertNull(memberLevelErrorResult.memberResult(memberTwo).get());
+
+ // Return with missing member.
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+ env.kafkaClient().prepareResponse(new LeaveGroupResponse(new LeaveGroupResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setMembers(Collections.singletonList(responseTwo))));
+
+ final RemoveMembersFromConsumerGroupResult missingMemberResult = env.adminClient().removeMembersFromConsumerGroup(
+ GROUP_ID,
+ new RemoveMembersFromConsumerGroupOptions(membersToRemove)
+ );
+
+ TestUtils.assertFutureThrows(IllegalArgumentException.class, missingMemberResult.all());
+ // The memberOne was not included in the response.
+ TestUtils.assertFutureThrows(IllegalArgumentException.class, missingMemberResult.memberResult(memberOne));
+ assertNull(missingMemberResult.memberResult(memberTwo).get());
+
+ // Return with success.
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+ env.kafkaClient().prepareResponse(new LeaveGroupResponse(
+ new LeaveGroupResponseData().setErrorCode(Errors.NONE.code()).setMembers(
+ asList(responseTwo,
+ new MemberResponse().setGroupInstanceId(instanceOne).setErrorCode(Errors.NONE.code())
+ ))
+ ));
+
+ final RemoveMembersFromConsumerGroupResult noErrorResult = env.adminClient().removeMembersFromConsumerGroup(
+ GROUP_ID,
+ new RemoveMembersFromConsumerGroupOptions(membersToRemove)
+ );
+ assertNull(noErrorResult.all().get());
+ assertNull(noErrorResult.memberResult(memberOne).get());
+ assertNull(noErrorResult.memberResult(memberTwo).get());
+
+ // Test the "removeAll" scenario
+ final List<TopicPartition> topicPartitions = Stream.of(1, 2, 3).map(partition -> new TopicPartition("my_topic", partition))
+ .collect(Collectors.toList());
+ // construct the DescribeGroupsResponse
+ DescribeGroupsResponseData data = prepareDescribeGroupsResponseData(GROUP_ID, asList(instanceOne, instanceTwo), topicPartitions);
+
+ // Return with partial failure for "removeAll" scenario
+ // 1 prepare response for AdminClient.describeConsumerGroups
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+ env.kafkaClient().prepareResponse(new DescribeGroupsResponse(data));
+
+ // 2 KafkaAdminClient encounter partial failure when trying to delete all members
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+ env.kafkaClient().prepareResponse(new LeaveGroupResponse(
+ new LeaveGroupResponseData().setErrorCode(Errors.NONE.code()).setMembers(
+ asList(responseOne, responseTwo))
+ ));
+ final RemoveMembersFromConsumerGroupResult partialFailureResults = env.adminClient().removeMembersFromConsumerGroup(
+ GROUP_ID,
+ new RemoveMembersFromConsumerGroupOptions()
+ );
+ ExecutionException exception = assertThrows(ExecutionException.class, () -> partialFailureResults.all().get());
+ assertInstanceOf(KafkaException.class, exception.getCause());
+ assertInstanceOf(UnknownMemberIdException.class, exception.getCause().getCause());
+
+ // Return with success for "removeAll" scenario
+ // 1 prepare response for AdminClient.describeConsumerGroups
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+ env.kafkaClient().prepareResponse(new DescribeGroupsResponse(data));
+
+ // 2. KafkaAdminClient should delete all members correctly
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+ env.kafkaClient().prepareResponse(new LeaveGroupResponse(
+ new LeaveGroupResponseData().setErrorCode(Errors.NONE.code()).setMembers(
+ asList(responseTwo,
+ new MemberResponse().setGroupInstanceId(instanceOne).setErrorCode(Errors.NONE.code())
+ ))
+ ));
+ final RemoveMembersFromConsumerGroupResult successResult = env.adminClient().removeMembersFromConsumerGroup(
+ GROUP_ID,
+ new RemoveMembersFromConsumerGroupOptions()
+ );
+ assertNull(successResult.all().get());
+ }
+ }
+
+ @Test
+ public void testRemoveMembersFromGroupReason() throws Exception {
+ testRemoveMembersFromGroup("testing remove members reason", "testing remove members reason");
+ }
+
+ @Test
+ public void testRemoveMembersFromGroupTruncatesReason() throws Exception {
+ final String reason = "Very looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong reason that is 271 characters long to make sure that length limit logic handles the scenario nicely";
+ final String truncatedReason = reason.substring(0, 255);
+ testRemoveMembersFromGroup(reason, truncatedReason);
+ }
+
+ @Test
+ public void testRemoveMembersFromGroupDefaultReason() throws Exception {
+ testRemoveMembersFromGroup(null, DEFAULT_LEAVE_GROUP_REASON);
+ testRemoveMembersFromGroup("", DEFAULT_LEAVE_GROUP_REASON);
+ }
+
+ @Test
+ public void testAlterConsumerGroupOffsets() throws Exception {
+ // Happy path
+
+ final TopicPartition tp1 = new TopicPartition("foo", 0);
+ final TopicPartition tp2 = new TopicPartition("bar", 0);
+ final TopicPartition tp3 = new TopicPartition("foobar", 0);
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ Map<TopicPartition, Errors> responseData = new HashMap<>();
+ responseData.put(tp1, Errors.NONE);
+ responseData.put(tp2, Errors.NONE);
+ env.kafkaClient().prepareResponse(new OffsetCommitResponse(0, responseData));
+
+ Map<TopicPartition, OffsetAndMetadata> offsets = new HashMap<>();
+ offsets.put(tp1, new OffsetAndMetadata(123L));
+ offsets.put(tp2, new OffsetAndMetadata(456L));
+ final AlterConsumerGroupOffsetsResult result = env.adminClient().alterConsumerGroupOffsets(
+ GROUP_ID, offsets);
+
+ assertNull(result.all().get());
+ assertNull(result.partitionResult(tp1).get());
+ assertNull(result.partitionResult(tp2).get());
+ TestUtils.assertFutureThrows(IllegalArgumentException.class, result.partitionResult(tp3));
+ }
+ }
+
+ @Test
+ public void testAlterConsumerGroupOffsetsRetriableErrors() throws Exception {
+ // Retriable errors should be retried
+
+ final TopicPartition tp1 = new TopicPartition("foo", 0);
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ env.kafkaClient().prepareResponse(
+ prepareOffsetCommitResponse(tp1, Errors.COORDINATOR_NOT_AVAILABLE));
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ env.kafkaClient().prepareResponse(
+ prepareOffsetCommitResponse(tp1, Errors.COORDINATOR_LOAD_IN_PROGRESS));
+
+ env.kafkaClient().prepareResponse(
+ prepareOffsetCommitResponse(tp1, Errors.NOT_COORDINATOR));
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ env.kafkaClient().prepareResponse(
+ prepareOffsetCommitResponse(tp1, Errors.REBALANCE_IN_PROGRESS));
+
+ env.kafkaClient().prepareResponse(
+ prepareOffsetCommitResponse(tp1, Errors.NONE));
+
+ Map<TopicPartition, OffsetAndMetadata> offsets = new HashMap<>();
+ offsets.put(tp1, new OffsetAndMetadata(123L));
+ final AlterConsumerGroupOffsetsResult result1 = env.adminClient()
+ .alterConsumerGroupOffsets(GROUP_ID, offsets);
+
+ assertNull(result1.all().get());
+ assertNull(result1.partitionResult(tp1).get());
+ }
+ }
+
+ @Test
+ public void testAlterConsumerGroupOffsetsNonRetriableErrors() throws Exception {
+ // Non-retriable errors throw an exception
+
+ final TopicPartition tp1 = new TopicPartition("foo", 0);
+ final List<Errors> nonRetriableErrors = asList(
+ Errors.GROUP_AUTHORIZATION_FAILED, Errors.INVALID_GROUP_ID, Errors.GROUP_ID_NOT_FOUND, Errors.STALE_MEMBER_EPOCH);
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ for (Errors error : nonRetriableErrors) {
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ env.kafkaClient().prepareResponse(prepareOffsetCommitResponse(tp1, error));
+
+ Map<TopicPartition, OffsetAndMetadata> offsets = new HashMap<>();
+ offsets.put(tp1, new OffsetAndMetadata(123L));
+ AlterConsumerGroupOffsetsResult errorResult = env.adminClient()
+ .alterConsumerGroupOffsets(GROUP_ID, offsets);
+
+ TestUtils.assertFutureThrows(error.exception().getClass(), errorResult.all());
+ TestUtils.assertFutureThrows(error.exception().getClass(), errorResult.partitionResult(tp1));
+ }
+ }
+ }
+
+ @Test
+ public void testAlterConsumerGroupOffsetsFindCoordinatorRetriableErrors() throws Exception {
+ // Retriable FindCoordinatorResponse errors should be retried
+
+ final TopicPartition tp1 = new TopicPartition("foo", 0);
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.COORDINATOR_NOT_AVAILABLE, Node.noNode()));
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.COORDINATOR_LOAD_IN_PROGRESS, Node.noNode()));
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ env.kafkaClient().prepareResponse(
+ prepareOffsetCommitResponse(tp1, Errors.NONE));
+
+ Map<TopicPartition, OffsetAndMetadata> offsets = new HashMap<>();
+ offsets.put(tp1, new OffsetAndMetadata(123L));
+ final AlterConsumerGroupOffsetsResult result = env.adminClient()
+ .alterConsumerGroupOffsets(GROUP_ID, offsets);
+
+ assertNull(result.all().get());
+ assertNull(result.partitionResult(tp1).get());
+ }
+ }
+
+ @Test
+ public void testAlterConsumerGroupOffsetsFindCoordinatorNonRetriableErrors() throws Exception {
+ // Non-retriable FindCoordinatorResponse errors throw an exception
+
+ final TopicPartition tp1 = new TopicPartition("foo", 0);
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.GROUP_AUTHORIZATION_FAILED, Node.noNode()));
+
+ Map<TopicPartition, OffsetAndMetadata> offsets = new HashMap<>();
+ offsets.put(tp1, new OffsetAndMetadata(123L));
+ final AlterConsumerGroupOffsetsResult errorResult = env.adminClient()
+ .alterConsumerGroupOffsets(GROUP_ID, offsets);
+
+ TestUtils.assertFutureThrows(GroupAuthorizationException.class, errorResult.all());
+ TestUtils.assertFutureThrows(GroupAuthorizationException.class, errorResult.partitionResult(tp1));
+ }
+ }
+
+ private MockClient.RequestMatcher expectListGroupsRequestWithFilters(
+ Set<String> expectedStates,
+ Set<String> expectedTypes
+ ) {
+ return body -> {
+ if (body instanceof ListGroupsRequest) {
+ ListGroupsRequest request = (ListGroupsRequest) body;
+ return Objects.equals(new HashSet<>(request.data().statesFilter()), expectedStates)
+ && Objects.equals(new HashSet<>(request.data().typesFilter()), expectedTypes);
+ }
+ return false;
+ };
+ }
+
+ private void verifyListConsumerGroupOffsetsOptions() throws Exception {
+ final Cluster cluster = mockCluster(3, 0);
+ final Time time = new MockTime();
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time, cluster,
+ AdminClientConfig.RETRIES_CONFIG, "0")) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ final List<TopicPartition> partitions = Collections.singletonList(new TopicPartition("A", 0));
+ final ListConsumerGroupOffsetsOptions options = new ListConsumerGroupOffsetsOptions()
+ .requireStable(true)
+ .timeoutMs(300);
+
+ final ListConsumerGroupOffsetsSpec groupSpec = new ListConsumerGroupOffsetsSpec()
+ .topicPartitions(partitions);
+ env.adminClient().listConsumerGroupOffsets(Collections.singletonMap(GROUP_ID, groupSpec), options);
+
+ final MockClient mockClient = env.kafkaClient();
+ waitForRequest(mockClient, ApiKeys.OFFSET_FETCH);
+
+ ClientRequest clientRequest = mockClient.requests().peek();
+ assertNotNull(clientRequest);
+ assertEquals(300, clientRequest.requestTimeoutMs());
+ OffsetFetchRequestData data = ((OffsetFetchRequest.Builder) clientRequest.requestBuilder()).build().data();
+ assertTrue(data.requireStable());
+ assertEquals(Collections.singletonList(GROUP_ID),
+ data.groups().stream().map(OffsetFetchRequestGroup::groupId).collect(Collectors.toList()));
+ assertEquals(Collections.singletonList("A"),
+ data.groups().get(0).topics().stream().map(OffsetFetchRequestTopics::name).collect(Collectors.toList()));
+ assertEquals(Collections.singletonList(0),
+ data.groups().get(0).topics().get(0).partitionIndexes());
+ }
+ }
+
+ private Map<String, ListConsumerGroupOffsetsSpec> batchedListConsumerGroupOffsetsSpec() {
+ Set<TopicPartition> groupAPartitions = Collections.singleton(new TopicPartition("A", 1));
+ Set<TopicPartition> groupBPartitions = Collections.singleton(new TopicPartition("B", 2));
+
+ ListConsumerGroupOffsetsSpec groupASpec = new ListConsumerGroupOffsetsSpec().topicPartitions(groupAPartitions);
+ ListConsumerGroupOffsetsSpec groupBSpec = new ListConsumerGroupOffsetsSpec().topicPartitions(groupBPartitions);
+ return Map.of("groupA", groupASpec, "groupB", groupBSpec);
+ }
+
+ private void sendOffsetFetchResponse(MockClient mockClient, Map<String, ListConsumerGroupOffsetsSpec> groupSpecs, boolean batched, Errors error) throws Exception {
+ waitForRequest(mockClient, ApiKeys.OFFSET_FETCH);
+
+ ClientRequest clientRequest = mockClient.requests().peek();
+ OffsetFetchRequestData data = ((OffsetFetchRequest.Builder) clientRequest.requestBuilder()).build().data();
+
+ if (!batched) {
+ assertEquals(1, data.groups().size());
+ }
+
+ OffsetFetchResponseData response = new OffsetFetchResponseData()
+ .setGroups(data.groups().stream().map(group ->
+ new OffsetFetchResponseData.OffsetFetchResponseGroup()
+ .setGroupId(group.groupId())
+ .setErrorCode(error.code())
+ .setTopics(groupSpecs.get(group.groupId()).topicPartitions().stream()
+ .collect(Collectors.groupingBy(TopicPartition::topic)).entrySet().stream().map(entry ->
+ new OffsetFetchResponseData.OffsetFetchResponseTopics()
+ .setName(entry.getKey())
+ .setPartitions(entry.getValue().stream().map(partition ->
+ new OffsetFetchResponseData.OffsetFetchResponsePartitions()
+ .setPartitionIndex(partition.partition())
+ .setCommittedOffset(10)
+ ).collect(Collectors.toList()))
+ ).collect(Collectors.toList()))
+ ).collect(Collectors.toList()));
+
+ mockClient.respond(new OffsetFetchResponse(response, ApiKeys.OFFSET_FETCH.latestVersion()));
+ }
+
+ private void verifyListOffsetsForMultipleGroups(Map<String, ListConsumerGroupOffsetsSpec> groupSpecs,
+ ListConsumerGroupOffsetsResult result) throws Exception {
+ assertEquals(groupSpecs.size(), result.all().get(10, TimeUnit.SECONDS).size());
+ for (Map.Entry<String, ListConsumerGroupOffsetsSpec> entry : groupSpecs.entrySet()) {
+ assertEquals(entry.getValue().topicPartitions(),
+ result.partitionsToOffsetAndMetadata(entry.getKey()).get().keySet());
+ }
+ }
+
+ private void testRemoveMembersFromGroup(String reason, String expectedReason) throws Exception {
+ final Cluster cluster = mockCluster(3, 0);
+ final Time time = new MockTime();
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time, cluster)) {
+
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+ env.kafkaClient().prepareResponse(body -> {
+ if (!(body instanceof LeaveGroupRequest)) {
+ return false;
+ }
+ LeaveGroupRequestData leaveGroupRequest = ((LeaveGroupRequest) body).data();
+
+ return leaveGroupRequest.members().stream().allMatch(
+ member -> member.reason().equals(expectedReason)
+ );
+ }, new LeaveGroupResponse(new LeaveGroupResponseData().setErrorCode(Errors.NONE.code()).setMembers(
+ asList(
+ new MemberResponse().setGroupInstanceId("instance-1"),
+ new MemberResponse().setGroupInstanceId("instance-2")
+ ))
+ ));
+
+ MemberToRemove memberToRemove1 = new MemberToRemove("instance-1");
+ MemberToRemove memberToRemove2 = new MemberToRemove("instance-2");
+
+ RemoveMembersFromConsumerGroupOptions options = new RemoveMembersFromConsumerGroupOptions(asList(
+ memberToRemove1,
+ memberToRemove2
+ ));
+ options.reason(reason);
+
+ final RemoveMembersFromConsumerGroupResult result = env.adminClient().removeMembersFromConsumerGroup(
+ GROUP_ID,
+ options
+ );
+
+ assertNull(result.all().get());
+ assertNull(result.memberResult(memberToRemove1).get());
+ assertNull(result.memberResult(memberToRemove2).get());
+ }
+ }
+
+ private static MemberDescription convertToMemberDescriptions(DescribedGroupMember member,
+ MemberAssignment assignment) {
+ return new MemberDescription(member.memberId(),
+ Optional.ofNullable(member.groupInstanceId()),
+ Optional.empty(),
+ member.clientId(),
+ member.clientHost(),
+ assignment,
+ Optional.empty(),
+ Optional.empty(),
+ Optional.empty());
+ }
+
+ private static DescribeGroupsResponseData prepareDescribeGroupsResponseData(String groupId,
+ List<String> groupInstances,
+ List<TopicPartition> topicPartitions) {
+ final ByteBuffer memberAssignment = ConsumerProtocol.serializeAssignment(new ConsumerPartitionAssignor.Assignment(topicPartitions));
+ List<DescribedGroupMember> describedGroupMembers = groupInstances.stream().map(groupInstance -> DescribeGroupsResponse.groupMember(JoinGroupRequest.UNKNOWN_MEMBER_ID,
+ groupInstance, "clientId0", "clientHost", new byte[memberAssignment.remaining()], null)).collect(Collectors.toList());
+ DescribeGroupsResponseData data = new DescribeGroupsResponseData();
+ data.groups().add(DescribeGroupsResponse.groupMetadata(
+ groupId,
+ Errors.NONE,
+ "",
+ ConsumerProtocol.PROTOCOL_TYPE,
+ "",
+ describedGroupMembers,
+ Collections.emptySet()));
+ return data;
+ }
+}
diff --git a/clients/src/test/java/org/apache/kafka/clients/admin/KafkaAdminClientShareGroupTest.java b/clients/src/test/java/org/apache/kafka/clients/admin/KafkaAdminClientShareGroupTest.java
new file mode 100644
index 00000000000..f505f31c75e
--- /dev/null
+++ b/clients/src/test/java/org/apache/kafka/clients/admin/KafkaAdminClientShareGroupTest.java
@@ -0,0 +1,987 @@
+/*
+ * 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 org.apache.kafka.clients.admin;
+
+import org.apache.kafka.clients.ClientRequest;
+import org.apache.kafka.clients.MockClient;
+import org.apache.kafka.clients.NodeApiVersions;
+import org.apache.kafka.common.Cluster;
+import org.apache.kafka.common.GroupState;
+import org.apache.kafka.common.GroupType;
+import org.apache.kafka.common.KafkaException;
+import org.apache.kafka.common.KafkaFuture;
+import org.apache.kafka.common.Node;
+import org.apache.kafka.common.TopicPartition;
+import org.apache.kafka.common.Uuid;
+import org.apache.kafka.common.errors.GroupAuthorizationException;
+import org.apache.kafka.common.errors.TopicAuthorizationException;
+import org.apache.kafka.common.errors.UnknownServerException;
+import org.apache.kafka.common.errors.UnsupportedVersionException;
+import org.apache.kafka.common.message.AlterShareGroupOffsetsResponseData;
+import org.apache.kafka.common.message.ApiVersionsResponseData.ApiVersion;
+import org.apache.kafka.common.message.DeleteShareGroupOffsetsRequestData;
+import org.apache.kafka.common.message.DeleteShareGroupOffsetsResponseData;
+import org.apache.kafka.common.message.DescribeShareGroupOffsetsRequestData;
+import org.apache.kafka.common.message.DescribeShareGroupOffsetsResponseData;
+import org.apache.kafka.common.message.FindCoordinatorResponseData;
+import org.apache.kafka.common.message.ListGroupsResponseData;
+import org.apache.kafka.common.message.ShareGroupDescribeResponseData;
+import org.apache.kafka.common.protocol.ApiKeys;
+import org.apache.kafka.common.protocol.Errors;
+import org.apache.kafka.common.requests.AlterShareGroupOffsetsResponse;
+import org.apache.kafka.common.requests.DeleteShareGroupOffsetsRequest;
+import org.apache.kafka.common.requests.DeleteShareGroupOffsetsResponse;
+import org.apache.kafka.common.requests.DescribeShareGroupOffsetsRequest;
+import org.apache.kafka.common.requests.DescribeShareGroupOffsetsResponse;
+import org.apache.kafka.common.requests.FindCoordinatorResponse;
+import org.apache.kafka.common.requests.ListGroupsResponse;
+import org.apache.kafka.common.requests.MetadataResponse;
+import org.apache.kafka.common.requests.RequestTestUtils;
+import org.apache.kafka.common.requests.ShareGroupDescribeResponse;
+import org.apache.kafka.common.utils.MockTime;
+import org.apache.kafka.common.utils.Time;
+import org.apache.kafka.test.TestUtils;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.ExecutionException;
+import java.util.stream.Collectors;
+
+import static java.util.Arrays.asList;
+import static java.util.Collections.singletonList;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class KafkaAdminClientShareGroupTest extends KafkaAdminClientTestBase {
+
+ @Test
+ public void testDescribeShareGroups() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ // Retriable FindCoordinatorResponse errors should be retried
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.COORDINATOR_NOT_AVAILABLE, Node.noNode()));
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.COORDINATOR_LOAD_IN_PROGRESS, Node.noNode()));
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ ShareGroupDescribeResponseData data = new ShareGroupDescribeResponseData();
+
+ // Retriable errors should be retried
+ data.groups().add(new ShareGroupDescribeResponseData.DescribedGroup()
+ .setGroupId(GROUP_ID)
+ .setErrorCode(Errors.COORDINATOR_LOAD_IN_PROGRESS.code()));
+ env.kafkaClient().prepareResponse(new ShareGroupDescribeResponse(data));
+
+ /*
+ * We need to return two responses here, one with NOT_COORDINATOR error when calling describe share group
+ * api using coordinator that has moved. This will retry whole operation. So we need to again respond with a
+ * FindCoordinatorResponse.
+ *
+ * And the same reason for COORDINATOR_NOT_AVAILABLE error response
+ */
+ data = new ShareGroupDescribeResponseData();
+ data.groups().add(new ShareGroupDescribeResponseData.DescribedGroup()
+ .setGroupId(GROUP_ID)
+ .setErrorCode(Errors.NOT_COORDINATOR.code()));
+ env.kafkaClient().prepareResponse(new ShareGroupDescribeResponse(data));
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ data = new ShareGroupDescribeResponseData();
+ data.groups().add(new ShareGroupDescribeResponseData.DescribedGroup()
+ .setGroupId(GROUP_ID)
+ .setErrorCode(Errors.COORDINATOR_NOT_AVAILABLE.code()));
+ env.kafkaClient().prepareResponse(new ShareGroupDescribeResponse(data));
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ data = new ShareGroupDescribeResponseData();
+ ShareGroupDescribeResponseData.TopicPartitions topicPartitions = new ShareGroupDescribeResponseData.TopicPartitions()
+ .setTopicName("my_topic")
+ .setPartitions(asList(0, 1, 2));
+ ShareGroupDescribeResponseData.Assignment memberAssignment = new ShareGroupDescribeResponseData.Assignment()
+ .setTopicPartitions(asList(topicPartitions));
+ ShareGroupDescribeResponseData.Member memberOne = new ShareGroupDescribeResponseData.Member()
+ .setMemberId("0")
+ .setClientId("clientId0")
+ .setClientHost("clientHost")
+ .setAssignment(memberAssignment);
+ ShareGroupDescribeResponseData.Member memberTwo = new ShareGroupDescribeResponseData.Member()
+ .setMemberId("1")
+ .setClientId("clientId1")
+ .setClientHost("clientHost")
+ .setAssignment(memberAssignment);
+
+ ShareGroupDescribeResponseData group0Data = new ShareGroupDescribeResponseData();
+ group0Data.groups().add(new ShareGroupDescribeResponseData.DescribedGroup()
+ .setGroupId(GROUP_ID)
+ .setGroupState(GroupState.STABLE.toString())
+ .setMembers(asList(memberOne, memberTwo)));
+
+ final List<TopicPartition> expectedTopicPartitions = new ArrayList<>();
+ expectedTopicPartitions.add(0, new TopicPartition("my_topic", 0));
+ expectedTopicPartitions.add(1, new TopicPartition("my_topic", 1));
+ expectedTopicPartitions.add(2, new TopicPartition("my_topic", 2));
+
+ List<ShareMemberDescription> expectedMemberDescriptions = new ArrayList<>();
+ expectedMemberDescriptions.add(convertToShareMemberDescriptions(memberOne,
+ new ShareMemberAssignment(new HashSet<>(expectedTopicPartitions))));
+ expectedMemberDescriptions.add(convertToShareMemberDescriptions(memberTwo,
+ new ShareMemberAssignment(new HashSet<>(expectedTopicPartitions))));
+ data.groups().add(new ShareGroupDescribeResponseData.DescribedGroup()
+ .setGroupId(GROUP_ID)
+ .setGroupState(GroupState.STABLE.toString())
+ .setMembers(asList(memberOne, memberTwo)));
+
+ env.kafkaClient().prepareResponse(new ShareGroupDescribeResponse(data));
+
+ final DescribeShareGroupsResult result = env.adminClient().describeShareGroups(singletonList(GROUP_ID));
+ final ShareGroupDescription groupDescription = result.describedGroups().get(GROUP_ID).get();
+
+ assertEquals(1, result.describedGroups().size());
+ assertEquals(GROUP_ID, groupDescription.groupId());
+ assertEquals(2, groupDescription.members().size());
+ assertEquals(expectedMemberDescriptions, groupDescription.members());
+ }
+ }
+
+ @Test
+ public void testDescribeShareGroupsGroupIdNotFound() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(new FindCoordinatorResponse(
+ new FindCoordinatorResponseData()
+ .setCoordinators(asList(
+ FindCoordinatorResponse.prepareCoordinatorResponse(Errors.NONE, GROUP_ID, env.cluster().controller()),
+ FindCoordinatorResponse.prepareCoordinatorResponse(Errors.NONE, "group-1", env.cluster().controller())
+ ))
+ ));
+
+ ShareGroupDescribeResponseData.TopicPartitions topicPartitions = new ShareGroupDescribeResponseData.TopicPartitions()
+ .setTopicName("my_topic")
+ .setPartitions(asList(0, 1, 2));
+ final ShareGroupDescribeResponseData.Assignment memberAssignment = new ShareGroupDescribeResponseData.Assignment()
+ .setTopicPartitions(asList(topicPartitions));
+ ShareGroupDescribeResponseData groupData = new ShareGroupDescribeResponseData();
+ groupData.groups().add(new ShareGroupDescribeResponseData.DescribedGroup()
+ .setGroupId(GROUP_ID)
+ .setGroupState(GroupState.STABLE.toString())
+ .setMembers(asList(
+ new ShareGroupDescribeResponseData.Member()
+ .setMemberId("0")
+ .setClientId("clientId0")
+ .setClientHost("clientHost")
+ .setAssignment(memberAssignment),
+ new ShareGroupDescribeResponseData.Member()
+ .setMemberId("1")
+ .setClientId("clientId1")
+ .setClientHost("clientHost")
+ .setAssignment(memberAssignment))));
+ groupData.groups().add(new ShareGroupDescribeResponseData.DescribedGroup()
+ .setGroupId("group-1")
+ .setGroupState(GroupState.DEAD.toString())
+ .setErrorCode(Errors.GROUP_ID_NOT_FOUND.code())
+ .setErrorMessage("Group group-1 not found."));
+
+ env.kafkaClient().prepareResponse(new ShareGroupDescribeResponse(groupData));
+
+ Collection<String> groups = new HashSet<>();
+ groups.add(GROUP_ID);
+ groups.add("group-1");
+ final DescribeShareGroupsResult result = env.adminClient().describeShareGroups(groups);
+ assertEquals(2, result.describedGroups().size());
+ assertEquals(groups, result.describedGroups().keySet());
+ KafkaFuture<Map<String, ShareGroupDescription>> allFuture = result.all();
+ assertThrows(ExecutionException.class, allFuture::get);
+ assertTrue(result.all().isCompletedExceptionally());
+ }
+ }
+
+ @Test
+ public void testDescribeShareGroupsWithAuthorizedOperationsOmitted() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ ShareGroupDescribeResponseData data = new ShareGroupDescribeResponseData();
+
+ data.groups().add(new ShareGroupDescribeResponseData.DescribedGroup()
+ .setGroupId(GROUP_ID)
+ .setAuthorizedOperations(MetadataResponse.AUTHORIZED_OPERATIONS_OMITTED));
+
+ env.kafkaClient().prepareResponse(new ShareGroupDescribeResponse(data));
+
+ final DescribeShareGroupsResult result = env.adminClient().describeShareGroups(singletonList(GROUP_ID));
+ final ShareGroupDescription groupDescription = result.describedGroups().get(GROUP_ID).get();
+
+ assertNull(groupDescription.authorizedOperations());
+ }
+ }
+
+ @Test
+ public void testDescribeMultipleShareGroups() {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(new FindCoordinatorResponse(
+ new FindCoordinatorResponseData()
+ .setCoordinators(asList(
+ FindCoordinatorResponse.prepareCoordinatorResponse(Errors.NONE, GROUP_ID, env.cluster().controller()),
+ FindCoordinatorResponse.prepareCoordinatorResponse(Errors.NONE, "group-1", env.cluster().controller())
+ ))
+ ));
+
+ ShareGroupDescribeResponseData.TopicPartitions topicPartitions = new ShareGroupDescribeResponseData.TopicPartitions()
+ .setTopicName("my_topic")
+ .setPartitions(asList(0, 1, 2));
+ final ShareGroupDescribeResponseData.Assignment memberAssignment = new ShareGroupDescribeResponseData.Assignment()
+ .setTopicPartitions(asList(topicPartitions));
+ ShareGroupDescribeResponseData groupData = new ShareGroupDescribeResponseData();
+ groupData.groups().add(new ShareGroupDescribeResponseData.DescribedGroup()
+ .setGroupId(GROUP_ID)
+ .setGroupState(GroupState.STABLE.toString())
+ .setMembers(asList(
+ new ShareGroupDescribeResponseData.Member()
+ .setMemberId("0")
+ .setClientId("clientId0")
+ .setClientHost("clientHost")
+ .setAssignment(memberAssignment),
+ new ShareGroupDescribeResponseData.Member()
+ .setMemberId("1")
+ .setClientId("clientId1")
+ .setClientHost("clientHost")
+ .setAssignment(memberAssignment))));
+ groupData.groups().add(new ShareGroupDescribeResponseData.DescribedGroup()
+ .setGroupId("group-1")
+ .setGroupState(GroupState.STABLE.toString())
+ .setMembers(asList(
+ new ShareGroupDescribeResponseData.Member()
+ .setMemberId("0")
+ .setClientId("clientId0")
+ .setClientHost("clientHost")
+ .setAssignment(memberAssignment),
+ new ShareGroupDescribeResponseData.Member()
+ .setMemberId("1")
+ .setClientId("clientId1")
+ .setClientHost("clientHost")
+ .setAssignment(memberAssignment))));
+
+ env.kafkaClient().prepareResponse(new ShareGroupDescribeResponse(groupData));
+
+ Collection<String> groups = new HashSet<>();
+ groups.add(GROUP_ID);
+ groups.add("group-1");
+ final DescribeShareGroupsResult result = env.adminClient().describeShareGroups(groups);
+ assertEquals(2, result.describedGroups().size());
+ assertEquals(groups, result.describedGroups().keySet());
+ KafkaFuture<Map<String, ShareGroupDescription>> allFuture = result.all();
+ assertDoesNotThrow(() -> allFuture.get());
+ assertFalse(allFuture.isCompletedExceptionally());
+ }
+ }
+
+ @Test
+ public void testListShareGroups() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(4, 0),
+ AdminClientConfig.RETRIES_CONFIG, "2")) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ // Empty metadata response should be retried
+ env.kafkaClient().prepareResponse(
+ RequestTestUtils.metadataResponse(
+ Collections.emptyList(),
+ env.cluster().clusterResource().clusterId(),
+ -1,
+ Collections.emptyList()));
+
+ env.kafkaClient().prepareResponse(
+ RequestTestUtils.metadataResponse(
+ env.cluster().nodes(),
+ env.cluster().clusterResource().clusterId(),
+ env.cluster().controller().id(),
+ Collections.emptyList()));
+
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(
+ new ListGroupsResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setGroups(Arrays.asList(
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("share-group-1")
+ .setGroupType(GroupType.SHARE.toString())
+ .setGroupState("Stable")
+ ))),
+ env.cluster().nodeById(0));
+
+ // handle retriable errors
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(
+ new ListGroupsResponseData()
+ .setErrorCode(Errors.COORDINATOR_NOT_AVAILABLE.code())
+ .setGroups(Collections.emptyList())
+ ),
+ env.cluster().nodeById(1));
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(
+ new ListGroupsResponseData()
+ .setErrorCode(Errors.COORDINATOR_LOAD_IN_PROGRESS.code())
+ .setGroups(Collections.emptyList())
+ ),
+ env.cluster().nodeById(1));
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(
+ new ListGroupsResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setGroups(Arrays.asList(
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("share-group-2")
+ .setGroupType(GroupType.SHARE.toString())
+ .setGroupState("Stable"),
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("share-group-3")
+ .setGroupType(GroupType.SHARE.toString())
+ .setGroupState("Stable")
+ ))),
+ env.cluster().nodeById(1));
+
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(
+ new ListGroupsResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setGroups(Arrays.asList(
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("share-group-4")
+ .setGroupType(GroupType.SHARE.toString())
+ .setGroupState("Stable")
+ ))),
+ env.cluster().nodeById(2));
+
+ // fatal error
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(
+ new ListGroupsResponseData()
+ .setErrorCode(Errors.UNKNOWN_SERVER_ERROR.code())
+ .setGroups(Collections.emptyList())),
+ env.cluster().nodeById(3));
+
+ final ListGroupsResult result = env.adminClient().listGroups(ListGroupsOptions.forShareGroups());
+ TestUtils.assertFutureThrows(UnknownServerException.class, result.all());
+
+ Collection<GroupListing> listings = result.valid().get();
+ assertEquals(4, listings.size());
+
+ Set<String> groupIds = new HashSet<>();
+ for (GroupListing listing : listings) {
+ groupIds.add(listing.groupId());
+ assertTrue(listing.groupState().isPresent());
+ }
+
+ assertEquals(Set.of("share-group-1", "share-group-2", "share-group-3", "share-group-4"), groupIds);
+ assertEquals(1, result.errors().get().size());
+ }
+ }
+
+ @Test
+ public void testListShareGroupsMetadataFailure() throws Exception {
+ final Cluster cluster = mockCluster(3, 0);
+ final Time time = new MockTime();
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time, cluster,
+ AdminClientConfig.RETRIES_CONFIG, "0")) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ // Empty metadata causes the request to fail since we have no list of brokers
+ // to send the ListGroups requests to
+ env.kafkaClient().prepareResponse(
+ RequestTestUtils.metadataResponse(
+ Collections.emptyList(),
+ env.cluster().clusterResource().clusterId(),
+ -1,
+ Collections.emptyList()));
+
+ final ListGroupsResult result = env.adminClient().listGroups(ListGroupsOptions.forShareGroups());
+ TestUtils.assertFutureThrows(KafkaException.class, result.all());
+ }
+ }
+
+ @Test
+ public void testListShareGroupsWithStates() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(prepareMetadataResponse(env.cluster(), Errors.NONE));
+
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(new ListGroupsResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setGroups(Arrays.asList(
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("share-group-1")
+ .setGroupType(GroupType.SHARE.toString())
+ .setProtocolType("share")
+ .setGroupState("Stable"),
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("share-group-2")
+ .setGroupType(GroupType.SHARE.toString())
+ .setProtocolType("share")
+ .setGroupState("Empty")))),
+ env.cluster().nodeById(0));
+
+ final ListGroupsResult result = env.adminClient().listGroups(ListGroupsOptions.forShareGroups());
+ Collection<GroupListing> listings = result.valid().get();
+
+ assertEquals(2, listings.size());
+ List<GroupListing> expected = new ArrayList<>();
+ expected.add(new GroupListing("share-group-1", Optional.of(GroupType.SHARE), "share", Optional.of(GroupState.STABLE)));
+ expected.add(new GroupListing("share-group-2", Optional.of(GroupType.SHARE), "share", Optional.of(GroupState.EMPTY)));
+ assertEquals(expected, listings);
+ assertEquals(0, result.errors().get().size());
+ }
+ }
+
+ @Test
+ public void testListShareGroupsWithStatesOlderBrokerVersion() {
+ ApiVersion listGroupV4 = new ApiVersion()
+ .setApiKey(ApiKeys.LIST_GROUPS.id)
+ .setMinVersion((short) 0)
+ .setMaxVersion((short) 4);
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create(Collections.singletonList(listGroupV4)));
+
+ env.kafkaClient().prepareResponse(prepareMetadataResponse(env.cluster(), Errors.NONE));
+
+ // Check we should not be able to list share groups with broker having version < 5
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(new ListGroupsResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setGroups(Collections.singletonList(
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("share-group-1")))),
+ env.cluster().nodeById(0));
+ ListGroupsResult result = env.adminClient().listGroups(ListGroupsOptions.forShareGroups());
+ TestUtils.assertFutureThrows(UnsupportedVersionException.class, result.all());
+ }
+ }
+
+ @Test
+ public void testListShareGroupOffsetsOptionsWithBatchedApi() throws Exception {
+ final Cluster cluster = mockCluster(3, 0);
+ final Time time = new MockTime();
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time, cluster,
+ AdminClientConfig.RETRIES_CONFIG, "0")) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ final List<TopicPartition> partitions = Collections.singletonList(new TopicPartition("A", 0));
+ final ListShareGroupOffsetsOptions options = new ListShareGroupOffsetsOptions();
+
+ final ListShareGroupOffsetsSpec groupSpec = new ListShareGroupOffsetsSpec()
+ .topicPartitions(partitions);
+ Map<String, ListShareGroupOffsetsSpec> groupSpecs = new HashMap<>();
+ groupSpecs.put(GROUP_ID, groupSpec);
+
+ env.adminClient().listShareGroupOffsets(groupSpecs, options);
+
+ final MockClient mockClient = env.kafkaClient();
+ waitForRequest(mockClient, ApiKeys.DESCRIBE_SHARE_GROUP_OFFSETS);
+
+ ClientRequest clientRequest = mockClient.requests().peek();
+ assertNotNull(clientRequest);
+ DescribeShareGroupOffsetsRequestData data = ((DescribeShareGroupOffsetsRequest.Builder) clientRequest.requestBuilder()).build().data();
+ assertEquals(1, data.groups().size());
+ assertEquals(GROUP_ID, data.groups().get(0).groupId());
+ assertEquals(Collections.singletonList("A"),
+ data.groups().get(0).topics().stream().map(DescribeShareGroupOffsetsRequestData.DescribeShareGroupOffsetsRequestTopic::topicName).collect(Collectors.toList()));
+ }
+ }
+
+ @Test
+ public void testListShareGroupOffsets() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ TopicPartition myTopicPartition0 = new TopicPartition("my_topic", 0);
+ TopicPartition myTopicPartition1 = new TopicPartition("my_topic", 1);
+ TopicPartition myTopicPartition2 = new TopicPartition("my_topic", 2);
+ TopicPartition myTopicPartition3 = new TopicPartition("my_topic", 3);
+ TopicPartition myTopicPartition4 = new TopicPartition("my_topic_1", 4);
+ TopicPartition myTopicPartition5 = new TopicPartition("my_topic_2", 6);
+
+ ListShareGroupOffsetsSpec groupSpec = new ListShareGroupOffsetsSpec();
+ Map<String, ListShareGroupOffsetsSpec> groupSpecs = new HashMap<>();
+ groupSpecs.put(GROUP_ID, groupSpec);
+
+ DescribeShareGroupOffsetsResponseData data = new DescribeShareGroupOffsetsResponseData().setGroups(
+ List.of(
+ new DescribeShareGroupOffsetsResponseData.DescribeShareGroupOffsetsResponseGroup().setGroupId(GROUP_ID).setTopics(
+ List.of(
+ new DescribeShareGroupOffsetsResponseData.DescribeShareGroupOffsetsResponseTopic().setTopicName("my_topic").setPartitions(
+ List.of(
+ new DescribeShareGroupOffsetsResponseData.DescribeShareGroupOffsetsResponsePartition().setPartitionIndex(0).setStartOffset(10).setLeaderEpoch(0),
+ new DescribeShareGroupOffsetsResponseData.DescribeShareGroupOffsetsResponsePartition().setPartitionIndex(1).setStartOffset(11).setLeaderEpoch(0),
+ new DescribeShareGroupOffsetsResponseData.DescribeShareGroupOffsetsResponsePartition().setPartitionIndex(2).setStartOffset(40).setLeaderEpoch(0),
+ new DescribeShareGroupOffsetsResponseData.DescribeShareGroupOffsetsResponsePartition().setPartitionIndex(3).setStartOffset(50).setLeaderEpoch(1)
+ )
+ ),
+ new DescribeShareGroupOffsetsResponseData.DescribeShareGroupOffsetsResponseTopic().setTopicName("my_topic_1").setPartitions(
+ List.of(
+ new DescribeShareGroupOffsetsResponseData.DescribeShareGroupOffsetsResponsePartition().setPartitionIndex(4).setStartOffset(100).setLeaderEpoch(2)
+ )
+ ),
+ new DescribeShareGroupOffsetsResponseData.DescribeShareGroupOffsetsResponseTopic().setTopicName("my_topic_2").setPartitions(
+ List.of(
+ new DescribeShareGroupOffsetsResponseData.DescribeShareGroupOffsetsResponsePartition().setPartitionIndex(6).setStartOffset(500).setLeaderEpoch(3)
+ )
+ )
+ )
+ )
+ )
+ );
+ env.kafkaClient().prepareResponse(new DescribeShareGroupOffsetsResponse(data));
+
+ final ListShareGroupOffsetsResult result = env.adminClient().listShareGroupOffsets(groupSpecs);
+ final Map<TopicPartition, SharePartitionOffsetInfo> partitionToOffsetInfo = result.partitionsToOffsetInfo(GROUP_ID).get();
+
+ assertEquals(6, partitionToOffsetInfo.size());
+ assertEquals(new SharePartitionOffsetInfo(10, Optional.of(0), Optional.empty()), partitionToOffsetInfo.get(myTopicPartition0));
+ assertEquals(new SharePartitionOffsetInfo(11, Optional.of(0), Optional.empty()), partitionToOffsetInfo.get(myTopicPartition1));
+ assertEquals(new SharePartitionOffsetInfo(40, Optional.of(0), Optional.empty()), partitionToOffsetInfo.get(myTopicPartition2));
+ assertEquals(new SharePartitionOffsetInfo(50, Optional.of(1), Optional.empty()), partitionToOffsetInfo.get(myTopicPartition3));
+ assertEquals(new SharePartitionOffsetInfo(100, Optional.of(2), Optional.empty()), partitionToOffsetInfo.get(myTopicPartition4));
+ assertEquals(new SharePartitionOffsetInfo(500, Optional.of(3), Optional.empty()), partitionToOffsetInfo.get(myTopicPartition5));
+ }
+ }
+
+ @Test
+ public void testListShareGroupOffsetsMultipleGroups() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(prepareBatchedFindCoordinatorResponse(Errors.NONE, env.cluster().controller(), Set.of(GROUP_ID, "group-1")));
+
+ TopicPartition myTopicPartition0 = new TopicPartition("my_topic", 0);
+ TopicPartition myTopicPartition1 = new TopicPartition("my_topic", 1);
+ TopicPartition myTopicPartition2 = new TopicPartition("my_topic", 2);
+ TopicPartition myTopicPartition3 = new TopicPartition("my_topic", 3);
+ TopicPartition myTopicPartition4 = new TopicPartition("my_topic_1", 4);
+ TopicPartition myTopicPartition5 = new TopicPartition("my_topic_2", 6);
+
+ ListShareGroupOffsetsSpec group0Specs = new ListShareGroupOffsetsSpec().topicPartitions(
+ List.of(myTopicPartition0, myTopicPartition1, myTopicPartition2, myTopicPartition3)
+ );
+ ListShareGroupOffsetsSpec group1Specs = new ListShareGroupOffsetsSpec().topicPartitions(
+ List.of(myTopicPartition4, myTopicPartition5)
+ );
+ Map<String, ListShareGroupOffsetsSpec> groupSpecs = new HashMap<>();
+ groupSpecs.put(GROUP_ID, group0Specs);
+ groupSpecs.put("group-1", group1Specs);
+
+ DescribeShareGroupOffsetsResponseData data = new DescribeShareGroupOffsetsResponseData().setGroups(
+ List.of(
+ new DescribeShareGroupOffsetsResponseData.DescribeShareGroupOffsetsResponseGroup().setGroupId(GROUP_ID).setTopics(
+ List.of(
+ new DescribeShareGroupOffsetsResponseData.DescribeShareGroupOffsetsResponseTopic().setTopicName("my_topic").setPartitions(
+ List.of(
+ new DescribeShareGroupOffsetsResponseData.DescribeShareGroupOffsetsResponsePartition().setPartitionIndex(0).setStartOffset(10).setLeaderEpoch(0),
+ new DescribeShareGroupOffsetsResponseData.DescribeShareGroupOffsetsResponsePartition().setPartitionIndex(1).setStartOffset(11).setLeaderEpoch(0),
+ new DescribeShareGroupOffsetsResponseData.DescribeShareGroupOffsetsResponsePartition().setPartitionIndex(2).setStartOffset(40).setLeaderEpoch(0),
+ new DescribeShareGroupOffsetsResponseData.DescribeShareGroupOffsetsResponsePartition().setPartitionIndex(3).setStartOffset(50).setLeaderEpoch(1)
+ )
+ )
+ )
+ ),
+ new DescribeShareGroupOffsetsResponseData.DescribeShareGroupOffsetsResponseGroup().setGroupId("group-1").setTopics(
+ List.of(
+ new DescribeShareGroupOffsetsResponseData.DescribeShareGroupOffsetsResponseTopic().setTopicName("my_topic_1").setPartitions(
+ List.of(
+ new DescribeShareGroupOffsetsResponseData.DescribeShareGroupOffsetsResponsePartition().setPartitionIndex(4).setStartOffset(100).setLeaderEpoch(2)
+ )
+ ),
+ new DescribeShareGroupOffsetsResponseData.DescribeShareGroupOffsetsResponseTopic().setTopicName("my_topic_2").setPartitions(
+ List.of(
+ new DescribeShareGroupOffsetsResponseData.DescribeShareGroupOffsetsResponsePartition().setPartitionIndex(6).setStartOffset(500).setLeaderEpoch(2)
+ )
+ )
+ )
+ )
+ )
+ );
+ env.kafkaClient().prepareResponse(new DescribeShareGroupOffsetsResponse(data));
+
+ final ListShareGroupOffsetsResult result = env.adminClient().listShareGroupOffsets(groupSpecs);
+ assertEquals(2, result.all().get().size());
+
+ final Map<TopicPartition, SharePartitionOffsetInfo> partitionToOffsetInfoGroup0 = result.partitionsToOffsetInfo(GROUP_ID).get();
+ assertEquals(4, partitionToOffsetInfoGroup0.size());
+ assertEquals(new SharePartitionOffsetInfo(10, Optional.of(0), Optional.empty()), partitionToOffsetInfoGroup0.get(myTopicPartition0));
+ assertEquals(new SharePartitionOffsetInfo(11, Optional.of(0), Optional.empty()), partitionToOffsetInfoGroup0.get(myTopicPartition1));
+ assertEquals(new SharePartitionOffsetInfo(40, Optional.of(0), Optional.empty()), partitionToOffsetInfoGroup0.get(myTopicPartition2));
+ assertEquals(new SharePartitionOffsetInfo(50, Optional.of(1), Optional.empty()), partitionToOffsetInfoGroup0.get(myTopicPartition3));
+
+ final Map<TopicPartition, SharePartitionOffsetInfo> partitionToOffsetInfoGroup1 = result.partitionsToOffsetInfo("group-1").get();
+ assertEquals(2, partitionToOffsetInfoGroup1.size());
+ assertEquals(new SharePartitionOffsetInfo(100, Optional.of(2), Optional.empty()), partitionToOffsetInfoGroup1.get(myTopicPartition4));
+ assertEquals(new SharePartitionOffsetInfo(500, Optional.of(2), Optional.empty()), partitionToOffsetInfoGroup1.get(myTopicPartition5));
+ }
+ }
+
+ @Test
+ public void testListShareGroupOffsetsEmpty() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ ListShareGroupOffsetsSpec groupSpec = new ListShareGroupOffsetsSpec();
+ Map<String, ListShareGroupOffsetsSpec> groupSpecs = new HashMap<>();
+ groupSpecs.put(GROUP_ID, groupSpec);
+
+ DescribeShareGroupOffsetsResponseData data = new DescribeShareGroupOffsetsResponseData().setGroups(
+ List.of(
+ new DescribeShareGroupOffsetsResponseData.DescribeShareGroupOffsetsResponseGroup().setGroupId(GROUP_ID)
+ )
+ );
+ env.kafkaClient().prepareResponse(new DescribeShareGroupOffsetsResponse(data));
+
+ final ListShareGroupOffsetsResult result = env.adminClient().listShareGroupOffsets(groupSpecs);
+ final Map<TopicPartition, SharePartitionOffsetInfo> partitionToOffsetInfo = result.partitionsToOffsetInfo(GROUP_ID).get();
+
+ assertEquals(0, partitionToOffsetInfo.size());
+ }
+ }
+
+ @Test
+ public void testListShareGroupOffsetsWithErrorInOnePartition() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ TopicPartition myTopicPartition0 = new TopicPartition("my_topic", 0);
+ TopicPartition myTopicPartition1 = new TopicPartition("my_topic", 1);
+ TopicPartition myTopicPartition2 = new TopicPartition("my_topic_1", 4);
+ TopicPartition myTopicPartition3 = new TopicPartition("my_topic_2", 6);
+
+ ListShareGroupOffsetsSpec groupSpec = new ListShareGroupOffsetsSpec().topicPartitions(
+ List.of(myTopicPartition0, myTopicPartition1, myTopicPartition2, myTopicPartition3)
+ );
+ Map<String, ListShareGroupOffsetsSpec> groupSpecs = new HashMap<>();
+ groupSpecs.put(GROUP_ID, groupSpec);
+
+ DescribeShareGroupOffsetsResponseData data = new DescribeShareGroupOffsetsResponseData().setGroups(
+ List.of(
+ new DescribeShareGroupOffsetsResponseData.DescribeShareGroupOffsetsResponseGroup().setGroupId(GROUP_ID).setTopics(
+ List.of(
+ new DescribeShareGroupOffsetsResponseData.DescribeShareGroupOffsetsResponseTopic().setTopicName("my_topic").setPartitions(
+ List.of(
+ new DescribeShareGroupOffsetsResponseData.DescribeShareGroupOffsetsResponsePartition().setPartitionIndex(0).setStartOffset(10).setLeaderEpoch(0),
+ new DescribeShareGroupOffsetsResponseData.DescribeShareGroupOffsetsResponsePartition().setPartitionIndex(1).setStartOffset(11).setLeaderEpoch(1)
+ )
+ ),
+ new DescribeShareGroupOffsetsResponseData.DescribeShareGroupOffsetsResponseTopic().setTopicName("my_topic_1").setPartitions(
+ List.of(
+ new DescribeShareGroupOffsetsResponseData.DescribeShareGroupOffsetsResponsePartition().setPartitionIndex(4).setErrorCode(Errors.NOT_COORDINATOR.code()).setErrorMessage("Not a Coordinator")
+ )
+ ),
+ new DescribeShareGroupOffsetsResponseData.DescribeShareGroupOffsetsResponseTopic().setTopicName("my_topic_2").setPartitions(
+ List.of(
+ new DescribeShareGroupOffsetsResponseData.DescribeShareGroupOffsetsResponsePartition().setPartitionIndex(6).setStartOffset(500).setLeaderEpoch(2)
+ )
+ )
+ )
+ )
+ )
+ );
+ env.kafkaClient().prepareResponse(new DescribeShareGroupOffsetsResponse(data));
+
+ final ListShareGroupOffsetsResult result = env.adminClient().listShareGroupOffsets(groupSpecs);
+ final Map<TopicPartition, SharePartitionOffsetInfo> partitionToOffsetInfo = result.partitionsToOffsetInfo(GROUP_ID).get();
+
+ // For myTopicPartition2 we have set an error as the response. Thus, it should be skipped from the final result
+ assertEquals(3, partitionToOffsetInfo.size());
+ assertEquals(new SharePartitionOffsetInfo(10, Optional.of(0), Optional.empty()), partitionToOffsetInfo.get(myTopicPartition0));
+ assertEquals(new SharePartitionOffsetInfo(11, Optional.of(1), Optional.empty()), partitionToOffsetInfo.get(myTopicPartition1));
+ assertEquals(new SharePartitionOffsetInfo(500, Optional.of(2), Optional.empty()), partitionToOffsetInfo.get(myTopicPartition3));
+ }
+ }
+
+ @Test
+ public void testAlterShareGroupOffsets() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ AlterShareGroupOffsetsResponseData data = new AlterShareGroupOffsetsResponseData().setResponses(
+ new AlterShareGroupOffsetsResponseData.AlterShareGroupOffsetsResponseTopicCollection(List.of(
+ new AlterShareGroupOffsetsResponseData.AlterShareGroupOffsetsResponseTopic().setTopicName("foo").setPartitions(List.of(new AlterShareGroupOffsetsResponseData.AlterShareGroupOffsetsResponsePartition().setPartitionIndex(0), new AlterShareGroupOffsetsResponseData.AlterShareGroupOffsetsResponsePartition().setPartitionIndex(1))),
+ new AlterShareGroupOffsetsResponseData.AlterShareGroupOffsetsResponseTopic().setTopicName("bar").setPartitions(List.of(new AlterShareGroupOffsetsResponseData.AlterShareGroupOffsetsResponsePartition().setPartitionIndex(0)))
+ ))
+ );
+
+ TopicPartition fooTopicPartition0 = new TopicPartition("foo", 0);
+ TopicPartition fooTopicPartition1 = new TopicPartition("foo", 1);
+ TopicPartition barPartition0 = new TopicPartition("bar", 0);
+ TopicPartition zooTopicPartition0 = new TopicPartition("zoo", 0);
+
+ env.kafkaClient().prepareResponse(new AlterShareGroupOffsetsResponse(data));
+ final AlterShareGroupOffsetsResult result = env.adminClient().alterShareGroupOffsets(GROUP_ID, Map.of(fooTopicPartition0, 1L, fooTopicPartition1, 2L, barPartition0, 1L));
+
+ assertNull(result.all().get());
+ assertNull(result.partitionResult(fooTopicPartition0).get());
+ assertNull(result.partitionResult(fooTopicPartition1).get());
+ assertNull(result.partitionResult(barPartition0).get());
+ TestUtils.assertFutureThrows(IllegalArgumentException.class, result.partitionResult(zooTopicPartition0));
+ }
+ }
+
+ @Test
+ public void testAlterShareGroupOffsetsWithTopLevelError() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ AlterShareGroupOffsetsResponseData data = new AlterShareGroupOffsetsResponseData().setErrorCode(Errors.GROUP_AUTHORIZATION_FAILED.code()).setErrorMessage("Group authorization failed.");
+
+ TopicPartition fooTopicPartition0 = new TopicPartition("foo", 0);
+ TopicPartition fooTopicPartition1 = new TopicPartition("foo", 1);
+ TopicPartition barPartition0 = new TopicPartition("bar", 0);
+ TopicPartition zooTopicPartition0 = new TopicPartition("zoo", 0);
+
+ env.kafkaClient().prepareResponse(new AlterShareGroupOffsetsResponse(data));
+ final AlterShareGroupOffsetsResult result = env.adminClient().alterShareGroupOffsets(GROUP_ID, Map.of(fooTopicPartition0, 1L, fooTopicPartition1, 2L, barPartition0, 1L));
+
+ TestUtils.assertFutureThrows(GroupAuthorizationException.class, result.all());
+ TestUtils.assertFutureThrows(GroupAuthorizationException.class, result.partitionResult(fooTopicPartition1));
+ TestUtils.assertFutureThrows(IllegalArgumentException.class, result.partitionResult(zooTopicPartition0));
+ }
+ }
+
+ @Test
+ public void testAlterShareGroupOffsetsWithErrorInOnePartition() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ AlterShareGroupOffsetsResponseData data = new AlterShareGroupOffsetsResponseData().setResponses(
+ new AlterShareGroupOffsetsResponseData.AlterShareGroupOffsetsResponseTopicCollection(List.of(
+ new AlterShareGroupOffsetsResponseData.AlterShareGroupOffsetsResponseTopic().setTopicName("foo").setPartitions(List.of(new AlterShareGroupOffsetsResponseData.AlterShareGroupOffsetsResponsePartition().setPartitionIndex(0),
+ new AlterShareGroupOffsetsResponseData.AlterShareGroupOffsetsResponsePartition().setPartitionIndex(1).setErrorCode(Errors.TOPIC_AUTHORIZATION_FAILED.code()).setErrorMessage("Topic authorization failed."))),
+ new AlterShareGroupOffsetsResponseData.AlterShareGroupOffsetsResponseTopic().setTopicName("bar").setPartitions(List.of(new AlterShareGroupOffsetsResponseData.AlterShareGroupOffsetsResponsePartition().setPartitionIndex(0)))
+ ))
+ );
+
+ TopicPartition fooTopicPartition0 = new TopicPartition("foo", 0);
+ TopicPartition fooTopicPartition1 = new TopicPartition("foo", 1);
+ TopicPartition barPartition0 = new TopicPartition("bar", 0);
+
+ env.kafkaClient().prepareResponse(new AlterShareGroupOffsetsResponse(data));
+ final AlterShareGroupOffsetsResult result = env.adminClient().alterShareGroupOffsets(GROUP_ID, Map.of(fooTopicPartition0, 1L, fooTopicPartition1, 2L, barPartition0, 1L));
+
+ TestUtils.assertFutureThrows(TopicAuthorizationException.class, result.all());
+ assertNull(result.partitionResult(fooTopicPartition0).get());
+ TestUtils.assertFutureThrows(TopicAuthorizationException.class, result.partitionResult(fooTopicPartition1));
+ assertNull(result.partitionResult(barPartition0).get());
+ }
+ }
+
+ @Test
+ public void testDeleteShareGroupOffsetsOptionsWithBatchedApi() throws Exception {
+ final Cluster cluster = mockCluster(3, 0);
+ final Time time = new MockTime();
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time, cluster,
+ AdminClientConfig.RETRIES_CONFIG, "0")) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ final Set<String> topics = Collections.singleton("A");
+ final DeleteShareGroupOffsetsOptions options = new DeleteShareGroupOffsetsOptions();
+
+ env.adminClient().deleteShareGroupOffsets(GROUP_ID, topics, options);
+
+ final MockClient mockClient = env.kafkaClient();
+ waitForRequest(mockClient, ApiKeys.DELETE_SHARE_GROUP_OFFSETS);
+
+ ClientRequest clientRequest = mockClient.requests().peek();
+ assertNotNull(clientRequest);
+ DeleteShareGroupOffsetsRequestData data = ((DeleteShareGroupOffsetsRequest.Builder) clientRequest.requestBuilder()).build().data();
+ assertEquals(GROUP_ID, data.groupId());
+ assertEquals(1, data.topics().size());
+ assertEquals(Collections.singletonList("A"),
+ data.topics().stream().map(DeleteShareGroupOffsetsRequestData.DeleteShareGroupOffsetsRequestTopic::topicName).collect(Collectors.toList()));
+ }
+ }
+
+ @Test
+ public void testDeleteShareGroupOffsets() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ Uuid fooId = Uuid.randomUuid();
+ String fooName = "foo";
+ Uuid barId = Uuid.randomUuid();
+ String barName = "bar";
+
+ String zooName = "zoo";
+
+ DeleteShareGroupOffsetsResponseData data = new DeleteShareGroupOffsetsResponseData().setResponses(
+ List.of(
+ new DeleteShareGroupOffsetsResponseData.DeleteShareGroupOffsetsResponseTopic().setTopicName(fooName).setTopicId(fooId),
+ new DeleteShareGroupOffsetsResponseData.DeleteShareGroupOffsetsResponseTopic().setTopicName(barName).setTopicId(barId)
+ )
+ );
+
+ env.kafkaClient().prepareResponse(new DeleteShareGroupOffsetsResponse(data));
+ final DeleteShareGroupOffsetsResult result = env.adminClient().deleteShareGroupOffsets(GROUP_ID, Set.of(fooName, barName));
+
+ assertNull(result.all().get());
+ assertNull(result.topicResult(fooName).get());
+ assertNull(result.topicResult(barName).get());
+ assertThrows(IllegalArgumentException.class, () -> result.topicResult(zooName));
+ }
+ }
+
+ @Test
+ public void testDeleteShareGroupOffsetsEmpty() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ DeleteShareGroupOffsetsResponseData data = new DeleteShareGroupOffsetsResponseData().setResponses(
+ List.of()
+ );
+ env.kafkaClient().prepareResponse(new DeleteShareGroupOffsetsResponse(data));
+
+ final DeleteShareGroupOffsetsResult result = env.adminClient().deleteShareGroupOffsets(GROUP_ID, Collections.emptySet());
+ assertDoesNotThrow(() -> result.all().get());
+ }
+ }
+
+ @Test
+ public void testDeleteShareGroupOffsetsWithErrorInGroup() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ DeleteShareGroupOffsetsResponseData data = new DeleteShareGroupOffsetsResponseData()
+ .setErrorCode(Errors.GROUP_AUTHORIZATION_FAILED.code())
+ .setErrorMessage(Errors.GROUP_AUTHORIZATION_FAILED.message());
+
+ String fooName = "foo";
+ String barName = "bar";
+
+ env.kafkaClient().prepareResponse(new DeleteShareGroupOffsetsResponse(data));
+ final DeleteShareGroupOffsetsResult result = env.adminClient().deleteShareGroupOffsets(GROUP_ID, Set.of(fooName, barName));
+
+ TestUtils.assertFutureThrows(Errors.GROUP_AUTHORIZATION_FAILED.exception().getClass(), result.all());
+ }
+ }
+
+ @Test
+ public void testDeleteShareGroupOffsetsWithErrorInOneTopic() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ Uuid fooId = Uuid.randomUuid();
+ String fooName = "foo";
+ Uuid barId = Uuid.randomUuid();
+ String barName = "bar";
+
+ DeleteShareGroupOffsetsResponseData data = new DeleteShareGroupOffsetsResponseData().setResponses(
+ List.of(
+ new DeleteShareGroupOffsetsResponseData.DeleteShareGroupOffsetsResponseTopic()
+ .setTopicName(fooName)
+ .setTopicId(fooId)
+ .setErrorCode(Errors.KAFKA_STORAGE_ERROR.code())
+ .setErrorMessage(Errors.KAFKA_STORAGE_ERROR.message()),
+ new DeleteShareGroupOffsetsResponseData.DeleteShareGroupOffsetsResponseTopic()
+ .setTopicName(barName)
+ .setTopicId(barId)
+ )
+ );
+
+ env.kafkaClient().prepareResponse(new DeleteShareGroupOffsetsResponse(data));
+ final DeleteShareGroupOffsetsResult result = env.adminClient().deleteShareGroupOffsets(GROUP_ID, Set.of(fooName, barName));
+
+ TestUtils.assertFutureThrows(Errors.KAFKA_STORAGE_ERROR.exception().getClass(), result.all());
+ TestUtils.assertFutureThrows(Errors.KAFKA_STORAGE_ERROR.exception().getClass(), result.topicResult(fooName));
+ assertNull(result.topicResult(barName).get());
+ }
+ }
+
+ @Test
+ public void testDeleteShareGroupOffsetsWithPartitionNotPresentInResult() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ Uuid fooId = Uuid.randomUuid();
+ String fooName = "foo";
+
+ String barName = "bar";
+
+ DeleteShareGroupOffsetsResponseData data = new DeleteShareGroupOffsetsResponseData().setResponses(
+ List.of(
+ new DeleteShareGroupOffsetsResponseData.DeleteShareGroupOffsetsResponseTopic()
+ .setTopicName(fooName)
+ .setTopicId(fooId)
+ )
+ );
+
+ env.kafkaClient().prepareResponse(new DeleteShareGroupOffsetsResponse(data));
+ final DeleteShareGroupOffsetsResult result = env.adminClient().deleteShareGroupOffsets(GROUP_ID, Set.of(fooName));
+
+ assertDoesNotThrow(() -> result.all().get());
+ assertThrows(IllegalArgumentException.class, () -> result.topicResult(barName));
+ assertNull(result.topicResult(fooName).get());
+ }
+ }
+
+ private static ShareMemberDescription convertToShareMemberDescriptions(ShareGroupDescribeResponseData.Member member,
+ ShareMemberAssignment assignment) {
+ return new ShareMemberDescription(member.memberId(),
+ Optional.ofNullable(member.rackId()),
+ member.clientId(),
+ member.clientHost(),
+ assignment,
+ member.memberEpoch());
+ }
+}
diff --git a/clients/src/test/java/org/apache/kafka/clients/admin/KafkaAdminClientStreamsGroupTest.java b/clients/src/test/java/org/apache/kafka/clients/admin/KafkaAdminClientStreamsGroupTest.java
new file mode 100644
index 00000000000..4853e4fa676
--- /dev/null
+++ b/clients/src/test/java/org/apache/kafka/clients/admin/KafkaAdminClientStreamsGroupTest.java
@@ -0,0 +1,1464 @@
+/*
+ * 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 org.apache.kafka.clients.admin;
+
+import org.apache.kafka.clients.ClientRequest;
+import org.apache.kafka.clients.CommonClientConfigs;
+import org.apache.kafka.clients.MockClient;
+import org.apache.kafka.clients.NodeApiVersions;
+import org.apache.kafka.clients.consumer.OffsetAndMetadata;
+import org.apache.kafka.common.Cluster;
+import org.apache.kafka.common.GroupState;
+import org.apache.kafka.common.GroupType;
+import org.apache.kafka.common.KafkaException;
+import org.apache.kafka.common.KafkaFuture;
+import org.apache.kafka.common.Node;
+import org.apache.kafka.common.TopicPartition;
+import org.apache.kafka.common.errors.GroupAuthorizationException;
+import org.apache.kafka.common.errors.GroupSubscribedToTopicException;
+import org.apache.kafka.common.errors.TimeoutException;
+import org.apache.kafka.common.errors.UnknownServerException;
+import org.apache.kafka.common.errors.UnknownTopicOrPartitionException;
+import org.apache.kafka.common.errors.UnsupportedVersionException;
+import org.apache.kafka.common.message.ApiVersionsResponseData.ApiVersion;
+import org.apache.kafka.common.message.DeleteGroupsResponseData;
+import org.apache.kafka.common.message.DeleteGroupsResponseData.DeletableGroupResult;
+import org.apache.kafka.common.message.DeleteGroupsResponseData.DeletableGroupResultCollection;
+import org.apache.kafka.common.message.ListGroupsResponseData;
+import org.apache.kafka.common.message.ListGroupsResponseData.ListedGroup;
+import org.apache.kafka.common.message.OffsetDeleteResponseData;
+import org.apache.kafka.common.message.OffsetDeleteResponseData.OffsetDeleteResponsePartition;
+import org.apache.kafka.common.message.OffsetDeleteResponseData.OffsetDeleteResponsePartitionCollection;
+import org.apache.kafka.common.message.OffsetDeleteResponseData.OffsetDeleteResponseTopic;
+import org.apache.kafka.common.message.OffsetDeleteResponseData.OffsetDeleteResponseTopicCollection;
+import org.apache.kafka.common.message.OffsetFetchRequestData;
+import org.apache.kafka.common.message.OffsetFetchResponseData;
+import org.apache.kafka.common.message.StreamsGroupDescribeResponseData;
+import org.apache.kafka.common.protocol.ApiKeys;
+import org.apache.kafka.common.protocol.Errors;
+import org.apache.kafka.common.requests.DeleteGroupsResponse;
+import org.apache.kafka.common.requests.ListGroupsResponse;
+import org.apache.kafka.common.requests.MetadataResponse;
+import org.apache.kafka.common.requests.OffsetCommitResponse;
+import org.apache.kafka.common.requests.OffsetDeleteResponse;
+import org.apache.kafka.common.requests.OffsetFetchRequest;
+import org.apache.kafka.common.requests.OffsetFetchResponse;
+import org.apache.kafka.common.requests.RequestTestUtils;
+import org.apache.kafka.common.requests.StreamsGroupDescribeResponse;
+import org.apache.kafka.common.utils.MockTime;
+import org.apache.kafka.common.utils.Time;
+import org.apache.kafka.test.TestUtils;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static java.util.Arrays.asList;
+import static java.util.Collections.singletonList;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class KafkaAdminClientStreamsGroupTest extends KafkaAdminClientTestBase {
+
+ @Test
+ public void testStreamsOffsetCommitNumRetries() throws Exception {
+ final Cluster cluster = mockCluster(3, 0);
+ final Time time = new MockTime();
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time, cluster,
+ AdminClientConfig.RETRIES_CONFIG, "0")) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ final TopicPartition tp1 = new TopicPartition("foo", 0);
+
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+ env.kafkaClient().prepareResponse(prepareOffsetCommitResponse(tp1, Errors.NOT_COORDINATOR));
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ Map<TopicPartition, OffsetAndMetadata> offsets = new HashMap<>();
+ offsets.put(tp1, new OffsetAndMetadata(123L));
+ final AlterStreamsGroupOffsetsResult result = env.adminClient().alterStreamsGroupOffsets(GROUP_ID, offsets);
+
+ TestUtils.assertFutureThrows(TimeoutException.class, result.all());
+ }
+ }
+
+ @Test
+ public void testStreamsOffsetCommitWithMultipleErrors() throws Exception {
+ final Cluster cluster = mockCluster(3, 0);
+ final Time time = new MockTime();
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time, cluster,
+ AdminClientConfig.RETRIES_CONFIG, "0")) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ final TopicPartition foo0 = new TopicPartition("foo", 0);
+ final TopicPartition foo1 = new TopicPartition("foo", 1);
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ Map<TopicPartition, Errors> responseData = new HashMap<>();
+ responseData.put(foo0, Errors.NONE);
+ responseData.put(foo1, Errors.UNKNOWN_TOPIC_OR_PARTITION);
+ env.kafkaClient().prepareResponse(new OffsetCommitResponse(0, responseData));
+
+ Map<TopicPartition, OffsetAndMetadata> offsets = new HashMap<>();
+ offsets.put(foo0, new OffsetAndMetadata(123L));
+ offsets.put(foo1, new OffsetAndMetadata(456L));
+ final AlterStreamsGroupOffsetsResult result = env.adminClient()
+ .alterStreamsGroupOffsets(GROUP_ID, offsets);
+
+ assertNull(result.partitionResult(foo0).get());
+ TestUtils.assertFutureThrows(UnknownTopicOrPartitionException.class, result.partitionResult(foo1));
+
+ TestUtils.assertFutureThrows(UnknownTopicOrPartitionException.class, result.all());
+ }
+ }
+
+ @Test
+ public void testStreamsOffsetCommitRetryBackoff() throws Exception {
+ MockTime time = new MockTime();
+ int retryBackoff = 100;
+
+ try (final AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time,
+ mockCluster(3, 0),
+ newStrMap(AdminClientConfig.RETRY_BACKOFF_MS_CONFIG, "" + retryBackoff))) {
+ MockClient mockClient = env.kafkaClient();
+
+ mockClient.setNodeApiVersions(NodeApiVersions.create());
+
+ AtomicLong firstAttemptTime = new AtomicLong(0);
+ AtomicLong secondAttemptTime = new AtomicLong(0);
+
+ final TopicPartition tp1 = new TopicPartition("foo", 0);
+
+ mockClient.prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+ mockClient.prepareResponse(body -> {
+ firstAttemptTime.set(time.milliseconds());
+ return true;
+ }, prepareOffsetCommitResponse(tp1, Errors.NOT_COORDINATOR));
+
+ mockClient.prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+ mockClient.prepareResponse(body -> {
+ secondAttemptTime.set(time.milliseconds());
+ return true;
+ }, prepareOffsetCommitResponse(tp1, Errors.NONE));
+
+ Map<TopicPartition, OffsetAndMetadata> offsets = new HashMap<>();
+ offsets.put(tp1, new OffsetAndMetadata(123L));
+ final KafkaFuture<Void> future = env.adminClient().alterStreamsGroupOffsets(GROUP_ID, offsets).all();
+
+ TestUtils.waitForCondition(() -> mockClient.numAwaitingResponses() == 1, "Failed awaiting CommitOffsets first request failure");
+ TestUtils.waitForCondition(() -> ((KafkaAdminClient) env.adminClient()).numPendingCalls() == 1, "Failed to add retry CommitOffsets call on first failure");
+
+ long lowerBoundBackoffMs = (long) (retryBackoff * (1 - CommonClientConfigs.RETRY_BACKOFF_JITTER));
+ long upperBoundBackoffMs = (long) (retryBackoff * CommonClientConfigs.RETRY_BACKOFF_EXP_BASE * (1 + CommonClientConfigs.RETRY_BACKOFF_JITTER));
+ time.sleep(upperBoundBackoffMs);
+
+ future.get();
+
+ long actualRetryBackoff = secondAttemptTime.get() - firstAttemptTime.get();
+ assertEquals(retryBackoff, actualRetryBackoff, upperBoundBackoffMs - lowerBoundBackoffMs, "CommitOffsets retry did not await expected backoff");
+ }
+ }
+
+ @Test
+ public void testBatchedListStreamsGroupOffsets() throws Exception {
+ Cluster cluster = mockCluster(1, 0);
+ Time time = new MockTime();
+ Map<String, ListStreamsGroupOffsetsSpec> groupSpecs = batchedListStreamsGroupOffsetsSpec();
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time, cluster, AdminClientConfig.RETRIES_CONFIG, "0")) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+ env.kafkaClient().prepareResponse(prepareBatchedFindCoordinatorResponse(Errors.NONE, env.cluster().controller(), groupSpecs.keySet()));
+
+ ListStreamsGroupOffsetsResult result = env.adminClient().listStreamsGroupOffsets(groupSpecs, new ListStreamsGroupOffsetsOptions());
+ sendStreamsOffsetFetchResponse(env.kafkaClient(), groupSpecs, true, Errors.NONE);
+
+ verifyListStreamsOffsetsForMultipleGroups(groupSpecs, result);
+ }
+ }
+
+ @Test
+ public void testBatchedListStreamsGroupOffsetsWithNoFindCoordinatorBatching() throws Exception {
+ Cluster cluster = mockCluster(1, 0);
+ Time time = new MockTime();
+ Map<String, ListStreamsGroupOffsetsSpec> groupSpecs = batchedListStreamsGroupOffsetsSpec();
+
+ ApiVersion findCoordinatorV3 = new ApiVersion()
+ .setApiKey(ApiKeys.FIND_COORDINATOR.id)
+ .setMinVersion((short) 0)
+ .setMaxVersion((short) 3);
+ ApiVersion offsetFetchV7 = new ApiVersion()
+ .setApiKey(ApiKeys.OFFSET_FETCH.id)
+ .setMinVersion((short) 0)
+ .setMaxVersion((short) 7);
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time, cluster, AdminClientConfig.RETRY_BACKOFF_MS_CONFIG, "0")) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create(asList(findCoordinatorV3, offsetFetchV7)));
+ env.kafkaClient().prepareResponse(prepareOldFindCoordinatorResponse(Errors.COORDINATOR_NOT_AVAILABLE, Node.noNode()));
+ env.kafkaClient().prepareResponse(prepareOldFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+ env.kafkaClient().prepareResponse(prepareOldFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ ListStreamsGroupOffsetsResult result = env.adminClient().listStreamsGroupOffsets(groupSpecs);
+
+ // Fail the first request in order to ensure that the group is not batched when retried.
+ sendStreamsOffsetFetchResponse(env.kafkaClient(), groupSpecs, false, Errors.COORDINATOR_LOAD_IN_PROGRESS);
+
+ sendStreamsOffsetFetchResponse(env.kafkaClient(), groupSpecs, false, Errors.NONE);
+ sendStreamsOffsetFetchResponse(env.kafkaClient(), groupSpecs, false, Errors.NONE);
+
+ verifyListStreamsOffsetsForMultipleGroups(groupSpecs, result);
+ }
+ }
+
+ @Test
+ public void testBatchedListStreamsGroupOffsetsWithNoOffsetFetchBatching() throws Exception {
+ Cluster cluster = mockCluster(1, 0);
+ Time time = new MockTime();
+ Map<String, ListStreamsGroupOffsetsSpec> groupSpecs = batchedListStreamsGroupOffsetsSpec();
+
+ ApiVersion offsetFetchV7 = new ApiVersion()
+ .setApiKey(ApiKeys.OFFSET_FETCH.id)
+ .setMinVersion((short) 0)
+ .setMaxVersion((short) 7);
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time, cluster, AdminClientConfig.RETRY_BACKOFF_MS_CONFIG, "0")) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create(Collections.singleton(offsetFetchV7)));
+ env.kafkaClient().prepareResponse(prepareBatchedFindCoordinatorResponse(Errors.NONE, env.cluster().controller(), groupSpecs.keySet()));
+ // Prepare a response to force client to attempt batched request creation that throws
+ // NoBatchedOffsetFetchRequestException. This triggers creation of non-batched requests.
+ env.kafkaClient().prepareResponse(offsetFetchResponse(Errors.COORDINATOR_NOT_AVAILABLE));
+
+ ListStreamsGroupOffsetsResult result = env.adminClient().listStreamsGroupOffsets(groupSpecs);
+
+ // The request handler attempts both FindCoordinator and OffsetFetch requests. This seems
+ // ok since we expect this scenario only during upgrades from versions < 3.0.0 where
+ // some upgraded brokers could handle batched FindCoordinator while non-upgraded coordinators
+ // rejected batched OffsetFetch requests.
+ sendFindCoordinatorResponse(env.kafkaClient(), env.cluster().controller());
+ sendFindCoordinatorResponse(env.kafkaClient(), env.cluster().controller());
+ sendStreamsOffsetFetchResponse(env.kafkaClient(), groupSpecs, false, Errors.NONE);
+ sendStreamsOffsetFetchResponse(env.kafkaClient(), groupSpecs, false, Errors.NONE);
+
+ verifyListStreamsOffsetsForMultipleGroups(groupSpecs, result);
+ }
+ }
+
+ @Test
+ public void testDeleteStreamsGroupsNumRetries() throws Exception {
+ final Cluster cluster = mockCluster(3, 0);
+ final Time time = new MockTime();
+ final List<String> groupIds = singletonList("groupId");
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time, cluster,
+ AdminClientConfig.RETRIES_CONFIG, "0")) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+ final DeletableGroupResultCollection validResponse = new DeletableGroupResultCollection();
+ validResponse.add(new DeletableGroupResult()
+ .setGroupId("groupId")
+ .setErrorCode(Errors.NOT_COORDINATOR.code()));
+ env.kafkaClient().prepareResponse(new DeleteGroupsResponse(
+ new DeleteGroupsResponseData()
+ .setResults(validResponse)
+ ));
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ final DeleteStreamsGroupsResult result = env.adminClient().deleteStreamsGroups(groupIds);
+
+ TestUtils.assertFutureThrows(TimeoutException.class, result.all());
+ }
+ }
+
+ @Test
+ public void testDeleteStreamsGroupsRetryBackoff() throws Exception {
+ MockTime time = new MockTime();
+ int retryBackoff = 100;
+ final List<String> groupIds = singletonList(GROUP_ID);
+
+ try (final AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time,
+ mockCluster(3, 0),
+ newStrMap(AdminClientConfig.RETRY_BACKOFF_MS_CONFIG, "" + retryBackoff))) {
+ MockClient mockClient = env.kafkaClient();
+
+ mockClient.setNodeApiVersions(NodeApiVersions.create());
+
+ AtomicLong firstAttemptTime = new AtomicLong(0);
+ AtomicLong secondAttemptTime = new AtomicLong(0);
+
+ mockClient.prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ DeletableGroupResultCollection validResponse = new DeletableGroupResultCollection();
+ validResponse.add(new DeletableGroupResult()
+ .setGroupId(GROUP_ID)
+ .setErrorCode(Errors.NOT_COORDINATOR.code()));
+
+ mockClient.prepareResponse(body -> {
+ firstAttemptTime.set(time.milliseconds());
+ return true;
+ }, new DeleteGroupsResponse(new DeleteGroupsResponseData().setResults(validResponse)));
+
+ mockClient.prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ validResponse = new DeletableGroupResultCollection();
+ validResponse.add(new DeletableGroupResult()
+ .setGroupId(GROUP_ID)
+ .setErrorCode(Errors.NONE.code()));
+
+ mockClient.prepareResponse(body -> {
+ secondAttemptTime.set(time.milliseconds());
+ return true;
+ }, new DeleteGroupsResponse(new DeleteGroupsResponseData().setResults(validResponse)));
+
+ final KafkaFuture<Void> future = env.adminClient().deleteStreamsGroups(groupIds).all();
+
+ TestUtils.waitForCondition(() -> mockClient.numAwaitingResponses() == 1, "Failed awaiting DeleteStreamsGroups first request failure");
+ TestUtils.waitForCondition(() -> ((KafkaAdminClient) env.adminClient()).numPendingCalls() == 1, "Failed to add retry DeleteStreamsGroups call on first failure");
+
+ long lowerBoundBackoffMs = (long) (retryBackoff * (1 - CommonClientConfigs.RETRY_BACKOFF_JITTER));
+ long upperBoundBackoffMs = (long) (retryBackoff * CommonClientConfigs.RETRY_BACKOFF_EXP_BASE * (1 + CommonClientConfigs.RETRY_BACKOFF_JITTER));
+ time.sleep(upperBoundBackoffMs);
+
+ future.get();
+
+ long actualRetryBackoff = secondAttemptTime.get() - firstAttemptTime.get();
+ assertEquals(retryBackoff, actualRetryBackoff, upperBoundBackoffMs - lowerBoundBackoffMs, "DeleteConsumerGroups retry did not await expected backoff!");
+ }
+ }
+
+ @Test
+ public void testDeleteStreamsGroupsWithOlderBroker() throws Exception {
+ final List<String> groupIds = singletonList("groupId");
+ ApiVersion findCoordinatorV3 = new ApiVersion()
+ .setApiKey(ApiKeys.FIND_COORDINATOR.id)
+ .setMinVersion((short) 0)
+ .setMaxVersion((short) 3);
+ ApiVersion describeGroups = new ApiVersion()
+ .setApiKey(ApiKeys.DESCRIBE_GROUPS.id)
+ .setMinVersion((short) 0)
+ .setMaxVersion(ApiKeys.DELETE_GROUPS.latestVersion());
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create(asList(findCoordinatorV3, describeGroups)));
+
+ // Retriable FindCoordinatorResponse errors should be retried
+ env.kafkaClient().prepareResponse(prepareOldFindCoordinatorResponse(Errors.COORDINATOR_NOT_AVAILABLE, Node.noNode()));
+ env.kafkaClient().prepareResponse(prepareOldFindCoordinatorResponse(Errors.COORDINATOR_LOAD_IN_PROGRESS, Node.noNode()));
+
+ env.kafkaClient().prepareResponse(prepareOldFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ final DeletableGroupResultCollection validResponse = new DeletableGroupResultCollection();
+ validResponse.add(new DeletableGroupResult()
+ .setGroupId("groupId")
+ .setErrorCode(Errors.NONE.code()));
+ env.kafkaClient().prepareResponse(new DeleteGroupsResponse(
+ new DeleteGroupsResponseData()
+ .setResults(validResponse)
+ ));
+
+ final DeleteStreamsGroupsResult result = env.adminClient().deleteStreamsGroups(groupIds);
+
+ final KafkaFuture<Void> results = result.deletedGroups().get("groupId");
+ assertNull(results.get());
+
+ // should throw error for non-retriable errors
+ env.kafkaClient().prepareResponse(
+ prepareOldFindCoordinatorResponse(Errors.GROUP_AUTHORIZATION_FAILED, Node.noNode()));
+
+ DeleteStreamsGroupsResult errorResult = env.adminClient().deleteStreamsGroups(groupIds);
+ TestUtils.assertFutureThrows(GroupAuthorizationException.class, errorResult.deletedGroups().get("groupId"));
+
+ // Retriable errors should be retried
+ env.kafkaClient().prepareResponse(
+ prepareOldFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ final DeletableGroupResultCollection errorResponse = new DeletableGroupResultCollection();
+ errorResponse.add(new DeletableGroupResult()
+ .setGroupId("groupId")
+ .setErrorCode(Errors.COORDINATOR_LOAD_IN_PROGRESS.code())
+ );
+ env.kafkaClient().prepareResponse(new DeleteGroupsResponse(
+ new DeleteGroupsResponseData()
+ .setResults(errorResponse)));
+
+ /*
+ * We need to return two responses here, one for NOT_COORDINATOR call when calling delete a consumer group
+ * api using coordinator that has moved. This will retry whole operation. So we need to again respond with a
+ * FindCoordinatorResponse.
+ *
+ * And the same reason for the following COORDINATOR_NOT_AVAILABLE error response
+ */
+
+ DeletableGroupResultCollection coordinatorMoved = new DeletableGroupResultCollection();
+ coordinatorMoved.add(new DeletableGroupResult()
+ .setGroupId("groupId")
+ .setErrorCode(Errors.NOT_COORDINATOR.code())
+ );
+
+ env.kafkaClient().prepareResponse(new DeleteGroupsResponse(
+ new DeleteGroupsResponseData()
+ .setResults(coordinatorMoved)));
+ env.kafkaClient().prepareResponse(prepareOldFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ coordinatorMoved = new DeletableGroupResultCollection();
+ coordinatorMoved.add(new DeletableGroupResult()
+ .setGroupId("groupId")
+ .setErrorCode(Errors.COORDINATOR_NOT_AVAILABLE.code())
+ );
+
+ env.kafkaClient().prepareResponse(new DeleteGroupsResponse(
+ new DeleteGroupsResponseData()
+ .setResults(coordinatorMoved)));
+ env.kafkaClient().prepareResponse(prepareOldFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ env.kafkaClient().prepareResponse(new DeleteGroupsResponse(
+ new DeleteGroupsResponseData()
+ .setResults(validResponse)));
+
+ errorResult = env.adminClient().deleteStreamsGroups(groupIds);
+
+ final KafkaFuture<Void> errorResults = errorResult.deletedGroups().get("groupId");
+ assertNull(errorResults.get());
+ }
+ }
+
+ @Test
+ public void testDeleteMultipleStreamsGroupsWithOlderBroker() throws Exception {
+ final List<String> groupIds = asList("group1", "group2");
+ ApiVersion findCoordinatorV3 = new ApiVersion()
+ .setApiKey(ApiKeys.FIND_COORDINATOR.id)
+ .setMinVersion((short) 0)
+ .setMaxVersion((short) 3);
+ ApiVersion describeGroups = new ApiVersion()
+ .setApiKey(ApiKeys.DESCRIBE_GROUPS.id)
+ .setMinVersion((short) 0)
+ .setMaxVersion(ApiKeys.DELETE_GROUPS.latestVersion());
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(
+ NodeApiVersions.create(asList(findCoordinatorV3, describeGroups)));
+
+ // Dummy response for MockClient to handle the UnsupportedVersionException correctly to switch from batched to un-batched
+ env.kafkaClient().prepareResponse(null);
+ // Retriable FindCoordinatorResponse errors should be retried
+ for (int i = 0; i < groupIds.size(); i++) {
+ env.kafkaClient().prepareResponse(
+ prepareOldFindCoordinatorResponse(Errors.COORDINATOR_NOT_AVAILABLE, Node.noNode()));
+ }
+ for (int i = 0; i < groupIds.size(); i++) {
+ env.kafkaClient().prepareResponse(
+ prepareOldFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+ }
+
+ final DeletableGroupResultCollection validResponse = new DeletableGroupResultCollection();
+ validResponse.add(new DeletableGroupResult()
+ .setGroupId("group1")
+ .setErrorCode(Errors.NONE.code()));
+ validResponse.add(new DeletableGroupResult()
+ .setGroupId("group2")
+ .setErrorCode(Errors.NONE.code()));
+ env.kafkaClient().prepareResponse(new DeleteGroupsResponse(
+ new DeleteGroupsResponseData()
+ .setResults(validResponse)
+ ));
+
+ final DeleteStreamsGroupsResult result = env.adminClient()
+ .deleteStreamsGroups(groupIds);
+
+ final KafkaFuture<Void> results = result.deletedGroups().get("group1");
+ assertNull(results.get(5, TimeUnit.SECONDS));
+ }
+ }
+
+ @Test
+ public void testDeleteStreamsGroupOffsetsNumRetries() throws Exception {
+ final Cluster cluster = mockCluster(3, 0);
+ final Time time = new MockTime();
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time, cluster,
+ AdminClientConfig.RETRIES_CONFIG, "0")) {
+ final TopicPartition tp1 = new TopicPartition("foo", 0);
+
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+ env.kafkaClient().prepareResponse(prepareOffsetDeleteResponse(Errors.NOT_COORDINATOR));
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ final DeleteStreamsGroupOffsetsResult result = env.adminClient()
+ .deleteStreamsGroupOffsets(GROUP_ID, Stream.of(tp1).collect(Collectors.toSet()));
+
+ TestUtils.assertFutureThrows(TimeoutException.class, result.all());
+ }
+ }
+
+ @Test
+ public void testDeleteStreamsGroupOffsetsRetryBackoff() throws Exception {
+ MockTime time = new MockTime();
+ int retryBackoff = 100;
+
+ try (final AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time,
+ mockCluster(3, 0),
+ newStrMap(AdminClientConfig.RETRY_BACKOFF_MS_CONFIG, "" + retryBackoff))) {
+ MockClient mockClient = env.kafkaClient();
+
+ mockClient.setNodeApiVersions(NodeApiVersions.create());
+
+ AtomicLong firstAttemptTime = new AtomicLong(0);
+ AtomicLong secondAttemptTime = new AtomicLong(0);
+
+ final TopicPartition tp1 = new TopicPartition("foo", 0);
+
+ mockClient.prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ mockClient.prepareResponse(body -> {
+ firstAttemptTime.set(time.milliseconds());
+ return true;
+ }, prepareOffsetDeleteResponse(Errors.NOT_COORDINATOR));
+
+ mockClient.prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ mockClient.prepareResponse(body -> {
+ secondAttemptTime.set(time.milliseconds());
+ return true;
+ }, prepareOffsetDeleteResponse("foo", 0, Errors.NONE));
+
+ final KafkaFuture<Void> future = env.adminClient().deleteStreamsGroupOffsets(GROUP_ID, Stream.of(tp1).collect(Collectors.toSet())).all();
+
+ TestUtils.waitForCondition(() -> mockClient.numAwaitingResponses() == 1, "Failed awaiting DeleteStreamsGroupOffsets first request failure");
+ TestUtils.waitForCondition(() -> ((KafkaAdminClient) env.adminClient()).numPendingCalls() == 1, "Failed to add retry DeleteStreamsGroupOffsets call on first failure");
+
+ long lowerBoundBackoffMs = (long) (retryBackoff * (1 - CommonClientConfigs.RETRY_BACKOFF_JITTER));
+ long upperBoundBackoffMs = (long) (retryBackoff * CommonClientConfigs.RETRY_BACKOFF_EXP_BASE * (1 + CommonClientConfigs.RETRY_BACKOFF_JITTER));
+ time.sleep(upperBoundBackoffMs);
+
+ future.get();
+
+ long actualRetryBackoff = secondAttemptTime.get() - firstAttemptTime.get();
+ assertEquals(retryBackoff, actualRetryBackoff, upperBoundBackoffMs - lowerBoundBackoffMs, "DeleteStreamsGroupOffsets retry did not await expected backoff!");
+ }
+ }
+
+ @Test
+ public void testDeleteStreamsGroupOffsets() throws Exception {
+ // Happy path
+
+ final TopicPartition tp1 = new TopicPartition("foo", 0);
+ final TopicPartition tp2 = new TopicPartition("bar", 0);
+ final TopicPartition tp3 = new TopicPartition("foobar", 0);
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ env.kafkaClient().prepareResponse(new OffsetDeleteResponse(
+ new OffsetDeleteResponseData()
+ .setTopics(new OffsetDeleteResponseTopicCollection(Stream.of(
+ new OffsetDeleteResponseTopic()
+ .setName("foo")
+ .setPartitions(new OffsetDeleteResponsePartitionCollection(Collections.singletonList(
+ new OffsetDeleteResponsePartition()
+ .setPartitionIndex(0)
+ .setErrorCode(Errors.NONE.code())
+ ))),
+ new OffsetDeleteResponseTopic()
+ .setName("bar")
+ .setPartitions(new OffsetDeleteResponsePartitionCollection(Collections.singletonList(
+ new OffsetDeleteResponsePartition()
+ .setPartitionIndex(0)
+ .setErrorCode(Errors.GROUP_SUBSCRIBED_TO_TOPIC.code())
+ )))
+ ).collect(Collectors.toList())))
+ )
+ );
+
+ final DeleteStreamsGroupOffsetsResult errorResult = env.adminClient().deleteStreamsGroupOffsets(
+ GROUP_ID, Stream.of(tp1, tp2).collect(Collectors.toSet()));
+
+ assertNull(errorResult.partitionResult(tp1).get());
+ TestUtils.assertFutureThrows(GroupSubscribedToTopicException.class, errorResult.all());
+ TestUtils.assertFutureThrows(GroupSubscribedToTopicException.class, errorResult.partitionResult(tp2));
+ assertThrows(IllegalArgumentException.class, () -> errorResult.partitionResult(tp3));
+ }
+ }
+
+ @Test
+ public void testDeleteStreamsGroupOffsetsRetriableErrors() throws Exception {
+ // Retriable errors should be retried
+
+ final TopicPartition tp1 = new TopicPartition("foo", 0);
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ env.kafkaClient().prepareResponse(
+ prepareOffsetDeleteResponse(Errors.COORDINATOR_LOAD_IN_PROGRESS));
+
+ /*
+ * We need to return two responses here, one for NOT_COORDINATOR call when calling delete a consumer group
+ * api using coordinator that has moved. This will retry whole operation. So we need to again respond with a
+ * FindCoordinatorResponse.
+ *
+ * And the same reason for the following COORDINATOR_NOT_AVAILABLE error response
+ */
+ env.kafkaClient().prepareResponse(
+ prepareOffsetDeleteResponse(Errors.NOT_COORDINATOR));
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ env.kafkaClient().prepareResponse(
+ prepareOffsetDeleteResponse(Errors.COORDINATOR_NOT_AVAILABLE));
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ env.kafkaClient().prepareResponse(
+ prepareOffsetDeleteResponse("foo", 0, Errors.NONE));
+
+ final DeleteStreamsGroupOffsetsResult errorResult1 = env.adminClient()
+ .deleteStreamsGroupOffsets(GROUP_ID, Stream.of(tp1).collect(Collectors.toSet()));
+
+ assertNull(errorResult1.all().get());
+ assertNull(errorResult1.partitionResult(tp1).get());
+ }
+ }
+
+ @Test
+ public void testDeleteStreamsGroupOffsetsNonRetriableErrors() throws Exception {
+ // Non-retriable errors throw an exception
+
+ final TopicPartition tp1 = new TopicPartition("foo", 0);
+ final List<Errors> nonRetriableErrors = asList(
+ Errors.GROUP_AUTHORIZATION_FAILED, Errors.INVALID_GROUP_ID, Errors.GROUP_ID_NOT_FOUND);
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ for (Errors error : nonRetriableErrors) {
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ env.kafkaClient().prepareResponse(
+ prepareOffsetDeleteResponse(error));
+
+ DeleteStreamsGroupOffsetsResult errorResult = env.adminClient()
+ .deleteStreamsGroupOffsets(GROUP_ID, Stream.of(tp1).collect(Collectors.toSet()));
+
+ TestUtils.assertFutureThrows(error.exception().getClass(), errorResult.all());
+ TestUtils.assertFutureThrows(error.exception().getClass(), errorResult.partitionResult(tp1));
+ }
+ }
+ }
+
+ @Test
+ public void testDeleteStreamsGroupOffsetsFindCoordinatorRetriableErrors() throws Exception {
+ // Retriable FindCoordinatorResponse errors should be retried
+
+ final TopicPartition tp1 = new TopicPartition("foo", 0);
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.COORDINATOR_NOT_AVAILABLE, Node.noNode()));
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.COORDINATOR_LOAD_IN_PROGRESS, Node.noNode()));
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ env.kafkaClient().prepareResponse(
+ prepareOffsetDeleteResponse("foo", 0, Errors.NONE));
+
+ final DeleteStreamsGroupOffsetsResult result = env.adminClient()
+ .deleteStreamsGroupOffsets(GROUP_ID, Stream.of(tp1).collect(Collectors.toSet()));
+
+ assertNull(result.all().get());
+ assertNull(result.partitionResult(tp1).get());
+ }
+ }
+
+ @Test
+ public void testDeleteStreamsGroupOffsetsFindCoordinatorNonRetriableErrors() throws Exception {
+ // Non-retriable FindCoordinatorResponse errors throw an exception
+
+ final TopicPartition tp1 = new TopicPartition("foo", 0);
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.GROUP_AUTHORIZATION_FAILED, Node.noNode()));
+
+ final DeleteStreamsGroupOffsetsResult errorResult = env.adminClient()
+ .deleteStreamsGroupOffsets(GROUP_ID, Stream.of(tp1).collect(Collectors.toSet()));
+
+ TestUtils.assertFutureThrows(GroupAuthorizationException.class, errorResult.all());
+ TestUtils.assertFutureThrows(GroupAuthorizationException.class, errorResult.partitionResult(tp1));
+ }
+ }
+
+ @Test
+ public void testDescribeStreamsGroups() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ // Retriable FindCoordinatorResponse errors should be retried
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.COORDINATOR_NOT_AVAILABLE, Node.noNode()));
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.COORDINATOR_LOAD_IN_PROGRESS, Node.noNode()));
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ StreamsGroupDescribeResponseData data = new StreamsGroupDescribeResponseData();
+
+ // Retriable errors should be retried
+ data.groups().add(new StreamsGroupDescribeResponseData.DescribedGroup()
+ .setGroupId(GROUP_ID)
+ .setErrorCode(Errors.COORDINATOR_LOAD_IN_PROGRESS.code()));
+ env.kafkaClient().prepareResponse(new StreamsGroupDescribeResponse(data));
+
+ // We need to return two responses here, one with NOT_COORDINATOR error when calling describe streams group
+ // api using coordinator that has moved. This will retry whole operation. So we need to again respond with a
+ // FindCoordinatorResponse.
+ //
+ // And the same reason for COORDINATOR_NOT_AVAILABLE error response
+ data = new StreamsGroupDescribeResponseData();
+ data.groups().add(new StreamsGroupDescribeResponseData.DescribedGroup()
+ .setGroupId(GROUP_ID)
+ .setErrorCode(Errors.NOT_COORDINATOR.code()));
+ env.kafkaClient().prepareResponse(new StreamsGroupDescribeResponse(data));
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ data = new StreamsGroupDescribeResponseData();
+ data.groups().add(new StreamsGroupDescribeResponseData.DescribedGroup()
+ .setGroupId(GROUP_ID)
+ .setErrorCode(Errors.COORDINATOR_NOT_AVAILABLE.code()));
+ env.kafkaClient().prepareResponse(new StreamsGroupDescribeResponse(data));
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ data = makeFullStreamsGroupDescribeResponse();
+
+ env.kafkaClient().prepareResponse(new StreamsGroupDescribeResponse(data));
+
+ final DescribeStreamsGroupsResult result = env.adminClient().describeStreamsGroups(singletonList(GROUP_ID));
+ final StreamsGroupDescription groupDescription = result.describedGroups().get(GROUP_ID).get();
+
+ final String subtopologyId = "my_subtopology";
+ StreamsGroupMemberAssignment.TaskIds expectedActiveTasks1 =
+ new StreamsGroupMemberAssignment.TaskIds(subtopologyId, asList(0, 1, 2));
+ StreamsGroupMemberAssignment.TaskIds expectedStandbyTasks1 =
+ new StreamsGroupMemberAssignment.TaskIds(subtopologyId, asList(3, 4, 5));
+ StreamsGroupMemberAssignment.TaskIds expectedWarmupTasks1 =
+ new StreamsGroupMemberAssignment.TaskIds(subtopologyId, asList(6, 7, 8));
+ StreamsGroupMemberAssignment.TaskIds expectedActiveTasks2 =
+ new StreamsGroupMemberAssignment.TaskIds(subtopologyId, asList(3, 4, 5));
+ StreamsGroupMemberAssignment.TaskIds expectedStandbyTasks2 =
+ new StreamsGroupMemberAssignment.TaskIds(subtopologyId, asList(6, 7, 8));
+ StreamsGroupMemberAssignment.TaskIds expectedWarmupTasks2 =
+ new StreamsGroupMemberAssignment.TaskIds(subtopologyId, asList(0, 1, 2));
+ StreamsGroupMemberAssignment expectedMemberAssignment = new StreamsGroupMemberAssignment(
+ singletonList(expectedActiveTasks1),
+ singletonList(expectedStandbyTasks1),
+ singletonList(expectedWarmupTasks1)
+ );
+ StreamsGroupMemberAssignment expectedTargetAssignment = new StreamsGroupMemberAssignment(
+ singletonList(expectedActiveTasks2),
+ singletonList(expectedStandbyTasks2),
+ singletonList(expectedWarmupTasks2)
+ );
+ final String instanceId = "instance-id";
+ final String rackId = "rack-id";
+ StreamsGroupMemberDescription expectedMemberOne = new StreamsGroupMemberDescription(
+ "0",
+ 1,
+ Optional.of(instanceId),
+ Optional.of(rackId),
+ "clientId0",
+ "clientHost",
+ 0,
+ "processId",
+ Optional.of(new StreamsGroupMemberDescription.Endpoint("localhost", 8080)),
+ Collections.singletonMap("key", "value"),
+ Collections.singletonList(new StreamsGroupMemberDescription.TaskOffset(subtopologyId, 0, 0)),
+ Collections.singletonList(new StreamsGroupMemberDescription.TaskOffset(subtopologyId, 0, 1)),
+ expectedMemberAssignment,
+ expectedTargetAssignment,
+ true
+ );
+
+ StreamsGroupMemberDescription expectedMemberTwo = new StreamsGroupMemberDescription(
+ "1",
+ 2,
+ Optional.empty(),
+ Optional.empty(),
+ "clientId1",
+ "clientHost",
+ 1,
+ "processId2",
+ Optional.empty(),
+ Collections.emptyMap(),
+ Collections.emptyList(),
+ Collections.emptyList(),
+ new StreamsGroupMemberAssignment(Collections.emptyList(), Collections.emptyList(), Collections.emptyList()),
+ new StreamsGroupMemberAssignment(Collections.emptyList(), Collections.emptyList(), Collections.emptyList()),
+ false
+ );
+
+ StreamsGroupSubtopologyDescription expectedSubtopologyDescription = new StreamsGroupSubtopologyDescription(
+ subtopologyId,
+ Collections.singletonList("my_source_topic"),
+ Collections.singletonList("my_repartition_sink_topic"),
+ Collections.singletonMap(
+ "my_changelog_topic",
+ new StreamsGroupSubtopologyDescription.TopicInfo(
+ 0,
+ (short) 3,
+ Collections.singletonMap("key1", "value1")
+ )
+ ),
+ Collections.singletonMap(
+ "my_repartition_topic",
+ new StreamsGroupSubtopologyDescription.TopicInfo(
+ 99,
+ (short) 0,
+ Collections.emptyMap()
+ )
+ )
+ );
+
+ assertEquals(1, result.describedGroups().size());
+ assertEquals(GROUP_ID, groupDescription.groupId());
+ assertEquals(2, groupDescription.members().size());
+ Iterator<StreamsGroupMemberDescription> members = groupDescription.members().iterator();
+ assertEquals(expectedMemberOne, members.next());
+ assertEquals(expectedMemberTwo, members.next());
+ assertEquals(1, groupDescription.subtopologies().size());
+ assertEquals(expectedSubtopologyDescription, groupDescription.subtopologies().iterator().next());
+ assertEquals(2, groupDescription.groupEpoch());
+ assertEquals(1, groupDescription.targetAssignmentEpoch());
+
+ }
+ }
+
+ @Test
+ public void testDescribeStreamsGroupsWithAuthorizedOperationsOmitted() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ StreamsGroupDescribeResponseData data = makeFullStreamsGroupDescribeResponse();
+
+ data.groups().iterator().next()
+ .setAuthorizedOperations(MetadataResponse.AUTHORIZED_OPERATIONS_OMITTED);
+
+ env.kafkaClient().prepareResponse(new StreamsGroupDescribeResponse(data));
+
+ final DescribeStreamsGroupsResult result = env.adminClient().describeStreamsGroups(singletonList(GROUP_ID));
+ final StreamsGroupDescription groupDescription = result.describedGroups().get(GROUP_ID).get();
+
+ assertNull(groupDescription.authorizedOperations());
+ }
+ }
+
+ @Test
+ public void testDescribeMultipleStreamsGroups() {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ StreamsGroupDescribeResponseData.TaskIds activeTasks = new StreamsGroupDescribeResponseData.TaskIds()
+ .setSubtopologyId("my_subtopology")
+ .setPartitions(asList(0, 1, 2));
+ StreamsGroupDescribeResponseData.TaskIds standbyTasks = new StreamsGroupDescribeResponseData.TaskIds()
+ .setSubtopologyId("my_subtopology")
+ .setPartitions(asList(3, 4, 5));
+ StreamsGroupDescribeResponseData.TaskIds warmupTasks = new StreamsGroupDescribeResponseData.TaskIds()
+ .setSubtopologyId("my_subtopology")
+ .setPartitions(asList(6, 7, 8));
+ final StreamsGroupDescribeResponseData.Assignment memberAssignment = new StreamsGroupDescribeResponseData.Assignment()
+ .setActiveTasks(singletonList(activeTasks))
+ .setStandbyTasks(singletonList(standbyTasks))
+ .setWarmupTasks(singletonList(warmupTasks));
+ StreamsGroupDescribeResponseData group0Data = new StreamsGroupDescribeResponseData();
+ group0Data.groups().add(new StreamsGroupDescribeResponseData.DescribedGroup()
+ .setGroupId(GROUP_ID)
+ .setGroupState(GroupState.STABLE.toString())
+ .setMembers(asList(
+ new StreamsGroupDescribeResponseData.Member()
+ .setMemberId("0")
+ .setClientId("clientId0")
+ .setClientHost("clientHost")
+ .setAssignment(memberAssignment),
+ new StreamsGroupDescribeResponseData.Member()
+ .setMemberId("1")
+ .setClientId("clientId1")
+ .setClientHost("clientHost")
+ .setAssignment(memberAssignment))));
+
+ StreamsGroupDescribeResponseData group1Data = new StreamsGroupDescribeResponseData();
+ group1Data.groups().add(new StreamsGroupDescribeResponseData.DescribedGroup()
+ .setGroupId("group-1")
+ .setGroupState(GroupState.STABLE.toString())
+ .setMembers(asList(
+ new StreamsGroupDescribeResponseData.Member()
+ .setMemberId("0")
+ .setClientId("clientId0")
+ .setClientHost("clientHost")
+ .setAssignment(memberAssignment),
+ new StreamsGroupDescribeResponseData.Member()
+ .setMemberId("1")
+ .setClientId("clientId1")
+ .setClientHost("clientHost")
+ .setAssignment(memberAssignment))));
+
+ env.kafkaClient().prepareResponse(new StreamsGroupDescribeResponse(group0Data));
+ env.kafkaClient().prepareResponse(new StreamsGroupDescribeResponse(group1Data));
+
+ Collection<String> groups = new HashSet<>();
+ groups.add(GROUP_ID);
+ groups.add("group-1");
+ final DescribeStreamsGroupsResult result = env.adminClient().describeStreamsGroups(groups);
+ assertEquals(2, result.describedGroups().size());
+ assertEquals(groups, result.describedGroups().keySet());
+ }
+ }
+
+ @Test
+ public void testListStreamsGroups() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(4, 0),
+ AdminClientConfig.RETRIES_CONFIG, "2")) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ // Empty metadata response should be retried
+ env.kafkaClient().prepareResponse(
+ RequestTestUtils.metadataResponse(
+ Collections.emptyList(),
+ env.cluster().clusterResource().clusterId(),
+ -1,
+ Collections.emptyList()));
+
+ env.kafkaClient().prepareResponse(
+ RequestTestUtils.metadataResponse(
+ env.cluster().nodes(),
+ env.cluster().clusterResource().clusterId(),
+ env.cluster().controller().id(),
+ Collections.emptyList()));
+
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(
+ new ListGroupsResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setGroups(singletonList(
+ new ListedGroup()
+ .setGroupId("streams-group-1")
+ .setGroupType(GroupType.STREAMS.toString())
+ .setGroupState("Stable")
+ ))),
+ env.cluster().nodeById(0));
+
+ // handle retriable errors
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(
+ new ListGroupsResponseData()
+ .setErrorCode(Errors.COORDINATOR_NOT_AVAILABLE.code())
+ .setGroups(Collections.emptyList())
+ ),
+ env.cluster().nodeById(1));
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(
+ new ListGroupsResponseData()
+ .setErrorCode(Errors.COORDINATOR_LOAD_IN_PROGRESS.code())
+ .setGroups(Collections.emptyList())
+ ),
+ env.cluster().nodeById(1));
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(
+ new ListGroupsResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setGroups(Arrays.asList(
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("streams-group-2")
+ .setGroupType(GroupType.STREAMS.toString())
+ .setGroupState("Stable"),
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("streams-group-3")
+ .setGroupType(GroupType.STREAMS.toString())
+ .setGroupState("Stable")
+ ))),
+ env.cluster().nodeById(1));
+
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(
+ new ListGroupsResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setGroups(singletonList(
+ new ListedGroup()
+ .setGroupId("streams-group-4")
+ .setGroupType(GroupType.STREAMS.toString())
+ .setGroupState("Stable")
+ ))),
+ env.cluster().nodeById(2));
+
+ // fatal error
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(
+ new ListGroupsResponseData()
+ .setErrorCode(Errors.UNKNOWN_SERVER_ERROR.code())
+ .setGroups(Collections.emptyList())),
+ env.cluster().nodeById(3));
+
+ final ListGroupsResult result = env.adminClient().listGroups(ListGroupsOptions.forStreamsGroups());
+ TestUtils.assertFutureThrows(UnknownServerException.class, result.all());
+
+ Collection<GroupListing> listings = result.valid().get();
+ assertEquals(4, listings.size());
+
+ Set<String> groupIds = new HashSet<>();
+ for (GroupListing listing : listings) {
+ groupIds.add(listing.groupId());
+ assertTrue(listing.groupState().isPresent());
+ }
+
+ assertEquals(Set.of("streams-group-1", "streams-group-2", "streams-group-3", "streams-group-4"), groupIds);
+ assertEquals(1, result.errors().get().size());
+ }
+ }
+
+ @Test
+ public void testListStreamsGroupsMetadataFailure() throws Exception {
+ final Cluster cluster = mockCluster(3, 0);
+ final Time time = new MockTime();
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time, cluster,
+ AdminClientConfig.RETRIES_CONFIG, "0")) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ // Empty metadata causes the request to fail since we have no list of brokers
+ // to send the ListGroups requests to
+ env.kafkaClient().prepareResponse(
+ RequestTestUtils.metadataResponse(
+ Collections.emptyList(),
+ env.cluster().clusterResource().clusterId(),
+ -1,
+ Collections.emptyList()));
+
+ final ListGroupsResult result = env.adminClient().listGroups(ListGroupsOptions.forStreamsGroups());
+ TestUtils.assertFutureThrows(KafkaException.class, result.all());
+ }
+ }
+
+ @Test
+ public void testListStreamsGroupsWithStates() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(prepareMetadataResponse(env.cluster(), Errors.NONE));
+
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(new ListGroupsResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setGroups(Arrays.asList(
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("streams-group-1")
+ .setGroupType(GroupType.STREAMS.toString())
+ .setProtocolType("streams")
+ .setGroupState("Stable"),
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("streams-group-2")
+ .setGroupType(GroupType.STREAMS.toString())
+ .setProtocolType("streams")
+ .setGroupState("NotReady")))),
+ env.cluster().nodeById(0));
+
+ final ListGroupsResult result = env.adminClient().listGroups(ListGroupsOptions.forStreamsGroups());
+ Collection<GroupListing> listings = result.valid().get();
+
+ assertEquals(2, listings.size());
+ List<GroupListing> expected = new ArrayList<>();
+ expected.add(new GroupListing("streams-group-1", Optional.of(GroupType.STREAMS), "streams", Optional.of(GroupState.STABLE)));
+ expected.add(new GroupListing("streams-group-2", Optional.of(GroupType.STREAMS), "streams", Optional.of(GroupState.NOT_READY)));
+ assertEquals(expected, listings);
+ assertEquals(0, result.errors().get().size());
+ }
+ }
+
+ @Test
+ public void testListStreamsGroupsWithStatesOlderBrokerVersion() {
+ ApiVersion listGroupV4 = new ApiVersion()
+ .setApiKey(ApiKeys.LIST_GROUPS.id)
+ .setMinVersion((short) 0)
+ .setMaxVersion((short) 4);
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create(Collections.singletonList(listGroupV4)));
+
+ env.kafkaClient().prepareResponse(prepareMetadataResponse(env.cluster(), Errors.NONE));
+
+ // Check we should not be able to list streams groups with broker having version < 5
+ env.kafkaClient().prepareResponseFrom(
+ new ListGroupsResponse(new ListGroupsResponseData()
+ .setErrorCode(Errors.NONE.code())
+ .setGroups(Collections.singletonList(
+ new ListGroupsResponseData.ListedGroup()
+ .setGroupId("streams-group-1")))),
+ env.cluster().nodeById(0));
+ ListGroupsResult result = env.adminClient().listGroups(ListGroupsOptions.forStreamsGroups());
+ TestUtils.assertFutureThrows(UnsupportedVersionException.class, result.all());
+ }
+ }
+
+ @Test
+ public void testAlterStreamsGroupOffsets() throws Exception {
+ // Happy path
+
+ final TopicPartition tp1 = new TopicPartition("foo", 0);
+ final TopicPartition tp2 = new TopicPartition("bar", 0);
+ final TopicPartition tp3 = new TopicPartition("foobar", 0);
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ Map<TopicPartition, Errors> responseData = new HashMap<>();
+ responseData.put(tp1, Errors.NONE);
+ responseData.put(tp2, Errors.NONE);
+ env.kafkaClient().prepareResponse(new OffsetCommitResponse(0, responseData));
+
+ Map<TopicPartition, OffsetAndMetadata> offsets = new HashMap<>();
+ offsets.put(tp1, new OffsetAndMetadata(123L));
+ offsets.put(tp2, new OffsetAndMetadata(456L));
+ final AlterStreamsGroupOffsetsResult result = env.adminClient().alterStreamsGroupOffsets(
+ GROUP_ID, offsets);
+
+ assertNull(result.all().get());
+ assertNull(result.partitionResult(tp1).get());
+ assertNull(result.partitionResult(tp2).get());
+ TestUtils.assertFutureThrows(IllegalArgumentException.class, result.partitionResult(tp3));
+ }
+ }
+
+ @Test
+ public void testAlterStreamsGroupOffsetsRetriableErrors() throws Exception {
+ // Retriable errors should be retried
+
+ final TopicPartition tp1 = new TopicPartition("foo", 0);
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ env.kafkaClient().prepareResponse(
+ prepareOffsetCommitResponse(tp1, Errors.COORDINATOR_NOT_AVAILABLE));
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ env.kafkaClient().prepareResponse(
+ prepareOffsetCommitResponse(tp1, Errors.COORDINATOR_LOAD_IN_PROGRESS));
+
+ env.kafkaClient().prepareResponse(
+ prepareOffsetCommitResponse(tp1, Errors.NOT_COORDINATOR));
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ env.kafkaClient().prepareResponse(
+ prepareOffsetCommitResponse(tp1, Errors.REBALANCE_IN_PROGRESS));
+
+ env.kafkaClient().prepareResponse(
+ prepareOffsetCommitResponse(tp1, Errors.NONE));
+
+ Map<TopicPartition, OffsetAndMetadata> offsets = new HashMap<>();
+ offsets.put(tp1, new OffsetAndMetadata(123L));
+ final AlterStreamsGroupOffsetsResult result1 = env.adminClient()
+ .alterStreamsGroupOffsets(GROUP_ID, offsets);
+
+ assertNull(result1.all().get());
+ assertNull(result1.partitionResult(tp1).get());
+ }
+ }
+
+ @Test
+ public void testAlterStreamsGroupOffsetsNonRetriableErrors() throws Exception {
+ // Non-retriable errors throw an exception
+
+ final TopicPartition tp1 = new TopicPartition("foo", 0);
+ final List<Errors> nonRetriableErrors = asList(
+ Errors.GROUP_AUTHORIZATION_FAILED, Errors.INVALID_GROUP_ID, Errors.GROUP_ID_NOT_FOUND, Errors.STALE_MEMBER_EPOCH);
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ for (Errors error : nonRetriableErrors) {
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ env.kafkaClient().prepareResponse(prepareOffsetCommitResponse(tp1, error));
+
+ Map<TopicPartition, OffsetAndMetadata> offsets = new HashMap<>();
+ offsets.put(tp1, new OffsetAndMetadata(123L));
+ AlterStreamsGroupOffsetsResult errorResult = env.adminClient()
+ .alterStreamsGroupOffsets(GROUP_ID, offsets);
+
+ TestUtils.assertFutureThrows(error.exception().getClass(), errorResult.all());
+ TestUtils.assertFutureThrows(error.exception().getClass(), errorResult.partitionResult(tp1));
+ }
+ }
+ }
+
+ @Test
+ public void testAlterStreamsGroupOffsetsFindCoordinatorRetriableErrors() throws Exception {
+ // Retriable FindCoordinatorResponse errors should be retried
+
+ final TopicPartition tp1 = new TopicPartition("foo", 0);
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.COORDINATOR_NOT_AVAILABLE, Node.noNode()));
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.COORDINATOR_LOAD_IN_PROGRESS, Node.noNode()));
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
+
+ env.kafkaClient().prepareResponse(
+ prepareOffsetCommitResponse(tp1, Errors.NONE));
+
+ Map<TopicPartition, OffsetAndMetadata> offsets = new HashMap<>();
+ offsets.put(tp1, new OffsetAndMetadata(123L));
+ final AlterStreamsGroupOffsetsResult result = env.adminClient()
+ .alterStreamsGroupOffsets(GROUP_ID, offsets);
+
+ assertNull(result.all().get());
+ assertNull(result.partitionResult(tp1).get());
+ }
+ }
+
+ @Test
+ public void testAlterStreamsGroupOffsetsFindCoordinatorNonRetriableErrors() throws Exception {
+ // Non-retriable FindCoordinatorResponse errors throw an exception
+
+ final TopicPartition tp1 = new TopicPartition("foo", 0);
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ env.kafkaClient().prepareResponse(
+ prepareFindCoordinatorResponse(Errors.GROUP_AUTHORIZATION_FAILED, Node.noNode()));
+
+ Map<TopicPartition, OffsetAndMetadata> offsets = new HashMap<>();
+ offsets.put(tp1, new OffsetAndMetadata(123L));
+ final AlterStreamsGroupOffsetsResult errorResult = env.adminClient()
+ .alterStreamsGroupOffsets(GROUP_ID, offsets);
+
+ TestUtils.assertFutureThrows(GroupAuthorizationException.class, errorResult.all());
+ TestUtils.assertFutureThrows(GroupAuthorizationException.class, errorResult.partitionResult(tp1));
+ }
+ }
+
+ private Map<String, ListStreamsGroupOffsetsSpec> batchedListStreamsGroupOffsetsSpec() {
+ Set<TopicPartition> groupAPartitions = Collections.singleton(new TopicPartition("A", 1));
+ Set<TopicPartition> groupBPartitions = Collections.singleton(new TopicPartition("B", 2));
+
+ ListStreamsGroupOffsetsSpec groupASpec = new ListStreamsGroupOffsetsSpec().topicPartitions(groupAPartitions);
+ ListStreamsGroupOffsetsSpec groupBSpec = new ListStreamsGroupOffsetsSpec().topicPartitions(groupBPartitions);
+ return Map.of("groupA", groupASpec, "groupB", groupBSpec);
+ }
+
+ private void sendStreamsOffsetFetchResponse(MockClient mockClient, Map<String, ListStreamsGroupOffsetsSpec> groupSpecs, boolean batched, Errors error) throws Exception {
+ waitForRequest(mockClient, ApiKeys.OFFSET_FETCH);
+
+ ClientRequest clientRequest = mockClient.requests().peek();
+ OffsetFetchRequestData data = ((OffsetFetchRequest.Builder) clientRequest.requestBuilder()).build().data();
+
+ if (!batched) {
+ assertEquals(1, data.groups().size());
+ }
+
+ OffsetFetchResponseData response = new OffsetFetchResponseData()
+ .setGroups(data.groups().stream().map(group ->
+ new OffsetFetchResponseData.OffsetFetchResponseGroup()
+ .setGroupId(group.groupId())
+ .setErrorCode(error.code())
+ .setTopics(groupSpecs.get(group.groupId()).topicPartitions().stream()
+ .collect(Collectors.groupingBy(TopicPartition::topic)).entrySet().stream().map(entry ->
+ new OffsetFetchResponseData.OffsetFetchResponseTopics()
+ .setName(entry.getKey())
+ .setPartitions(entry.getValue().stream().map(partition ->
+ new OffsetFetchResponseData.OffsetFetchResponsePartitions()
+ .setPartitionIndex(partition.partition())
+ .setCommittedOffset(10)
+ ).collect(Collectors.toList()))
+ ).collect(Collectors.toList()))
+ ).collect(Collectors.toList()));
+
+ mockClient.respond(new OffsetFetchResponse(response, ApiKeys.OFFSET_FETCH.latestVersion()));
+ }
+
+ private void verifyListStreamsOffsetsForMultipleGroups(Map<String, ListStreamsGroupOffsetsSpec> groupSpecs,
+ ListStreamsGroupOffsetsResult result) throws Exception {
+ assertEquals(groupSpecs.size(), result.all().get(10, TimeUnit.SECONDS).size());
+ for (Map.Entry<String, ListStreamsGroupOffsetsSpec> entry : groupSpecs.entrySet()) {
+ assertEquals(entry.getValue().topicPartitions(),
+ result.partitionsToOffsetAndMetadata(entry.getKey()).get().keySet());
+ }
+ }
+
+ private static StreamsGroupDescribeResponseData makeFullStreamsGroupDescribeResponse() {
+ StreamsGroupDescribeResponseData data;
+ StreamsGroupDescribeResponseData.TaskIds activeTasks1 = new StreamsGroupDescribeResponseData.TaskIds()
+ .setSubtopologyId("my_subtopology")
+ .setPartitions(asList(0, 1, 2));
+ StreamsGroupDescribeResponseData.TaskIds standbyTasks1 = new StreamsGroupDescribeResponseData.TaskIds()
+ .setSubtopologyId("my_subtopology")
+ .setPartitions(asList(3, 4, 5));
+ StreamsGroupDescribeResponseData.TaskIds warmupTasks1 = new StreamsGroupDescribeResponseData.TaskIds()
+ .setSubtopologyId("my_subtopology")
+ .setPartitions(asList(6, 7, 8));
+ StreamsGroupDescribeResponseData.TaskIds activeTasks2 = new StreamsGroupDescribeResponseData.TaskIds()
+ .setSubtopologyId("my_subtopology")
+ .setPartitions(asList(3, 4, 5));
+ StreamsGroupDescribeResponseData.TaskIds standbyTasks2 = new StreamsGroupDescribeResponseData.TaskIds()
+ .setSubtopologyId("my_subtopology")
+ .setPartitions(asList(6, 7, 8));
+ StreamsGroupDescribeResponseData.TaskIds warmupTasks2 = new StreamsGroupDescribeResponseData.TaskIds()
+ .setSubtopologyId("my_subtopology")
+ .setPartitions(asList(0, 1, 2));
+ StreamsGroupDescribeResponseData.Assignment memberAssignment = new StreamsGroupDescribeResponseData.Assignment()
+ .setActiveTasks(singletonList(activeTasks1))
+ .setStandbyTasks(singletonList(standbyTasks1))
+ .setWarmupTasks(singletonList(warmupTasks1));
+ StreamsGroupDescribeResponseData.Assignment targetAssignment = new StreamsGroupDescribeResponseData.Assignment()
+ .setActiveTasks(singletonList(activeTasks2))
+ .setStandbyTasks(singletonList(standbyTasks2))
+ .setWarmupTasks(singletonList(warmupTasks2));
+ StreamsGroupDescribeResponseData.Member memberOne = new StreamsGroupDescribeResponseData.Member()
+ .setMemberId("0")
+ .setMemberEpoch(1)
+ .setInstanceId("instance-id")
+ .setRackId("rack-id")
+ .setClientId("clientId0")
+ .setClientHost("clientHost")
+ .setTopologyEpoch(0)
+ .setProcessId("processId")
+ .setUserEndpoint(new StreamsGroupDescribeResponseData.Endpoint()
+ .setHost("localhost")
+ .setPort(8080)
+ )
+ .setClientTags(Collections.singletonList(new StreamsGroupDescribeResponseData.KeyValue()
+ .setKey("key")
+ .setValue("value")
+ ))
+ .setTaskOffsets(Collections.singletonList(new StreamsGroupDescribeResponseData.TaskOffset()
+ .setSubtopologyId("my_subtopology")
+ .setPartition(0)
+ .setOffset(0)
+ ))
+ .setTaskEndOffsets(Collections.singletonList(new StreamsGroupDescribeResponseData.TaskOffset()
+ .setSubtopologyId("my_subtopology")
+ .setPartition(0)
+ .setOffset(1)
+ ))
+ .setAssignment(memberAssignment)
+ .setTargetAssignment(targetAssignment)
+ .setIsClassic(true);
+
+ StreamsGroupDescribeResponseData.Member memberTwo = new StreamsGroupDescribeResponseData.Member()
+ .setMemberId("1")
+ .setMemberEpoch(2)
+ .setInstanceId(null)
+ .setRackId(null)
+ .setClientId("clientId1")
+ .setClientHost("clientHost")
+ .setTopologyEpoch(1)
+ .setProcessId("processId2")
+ .setUserEndpoint(null)
+ .setClientTags(Collections.emptyList())
+ .setTaskOffsets(Collections.emptyList())
+ .setTaskEndOffsets(Collections.emptyList())
+ .setAssignment(new StreamsGroupDescribeResponseData.Assignment())
+ .setTargetAssignment(new StreamsGroupDescribeResponseData.Assignment())
+ .setIsClassic(false);
+
+ StreamsGroupDescribeResponseData.Subtopology subtopologyDescription = new StreamsGroupDescribeResponseData.Subtopology()
+ .setSubtopologyId("my_subtopology")
+ .setSourceTopics(Collections.singletonList("my_source_topic"))
+ .setRepartitionSinkTopics(Collections.singletonList("my_repartition_sink_topic"))
+ .setStateChangelogTopics(Collections.singletonList(
+ new StreamsGroupDescribeResponseData.TopicInfo()
+ .setName("my_changelog_topic")
+ .setPartitions(0)
+ .setReplicationFactor((short) 3)
+ .setTopicConfigs(Collections.singletonList(new StreamsGroupDescribeResponseData.KeyValue()
+ .setKey("key1")
+ .setValue("value1")
+ ))
+ ))
+ .setRepartitionSourceTopics(Collections.singletonList(
+ new StreamsGroupDescribeResponseData.TopicInfo()
+ .setName("my_repartition_topic")
+ .setPartitions(99)
+ .setReplicationFactor((short) 0)
+ .setTopicConfigs(Collections.emptyList())
+ ));
+
+ data = new StreamsGroupDescribeResponseData();
+ data.groups().add(new StreamsGroupDescribeResponseData.DescribedGroup()
+ .setGroupId(GROUP_ID)
+ .setGroupState(GroupState.STABLE.toString())
+ .setMembers(asList(memberOne, memberTwo))
+ .setTopology(new StreamsGroupDescribeResponseData.Topology()
+ .setEpoch(1)
+ .setSubtopologies(Collections.singletonList(subtopologyDescription))
+ )
+ .setGroupEpoch(2)
+ .setAssignmentEpoch(1));
+ return data;
+ }
+}
diff --git a/clients/src/test/java/org/apache/kafka/clients/admin/KafkaAdminClientTest.java b/clients/src/test/java/org/apache/kafka/clients/admin/KafkaAdminClientTest.java
index e90cfe4b2a5..f5c0825832b 100644
--- a/clients/src/test/java/org/apache/kafka/clients/admin/KafkaAdminClientTest.java
+++ b/clients/src/test/java/org/apache/kafka/clients/admin/KafkaAdminClientTest.java
@@ -21,242 +21,71 @@ import org.apache.kafka.clients.CommonClientConfigs;
import org.apache.kafka.clients.MetadataRecoveryStrategy;
import org.apache.kafka.clients.MockClient;
import org.apache.kafka.clients.NodeApiVersions;
-import org.apache.kafka.clients.admin.DeleteAclsResult.FilterResults;
-import org.apache.kafka.clients.admin.ListOffsetsResult.ListOffsetsResultInfo;
import org.apache.kafka.clients.admin.internals.AdminMetadataManager;
import org.apache.kafka.clients.admin.internals.InternalDescribeFeaturesResult;
-import org.apache.kafka.clients.consumer.ConsumerPartitionAssignor;
-import org.apache.kafka.clients.consumer.OffsetAndMetadata;
-import org.apache.kafka.clients.consumer.internals.ConsumerProtocol;
-import org.apache.kafka.common.ClassicGroupState;
import org.apache.kafka.common.Cluster;
-import org.apache.kafka.common.ElectionType;
-import org.apache.kafka.common.GroupState;
-import org.apache.kafka.common.GroupType;
import org.apache.kafka.common.KafkaException;
import org.apache.kafka.common.KafkaFuture;
import org.apache.kafka.common.Node;
import org.apache.kafka.common.PartitionInfo;
-import org.apache.kafka.common.TopicCollection;
-import org.apache.kafka.common.TopicPartition;
-import org.apache.kafka.common.TopicPartitionReplica;
import org.apache.kafka.common.Uuid;
-import org.apache.kafka.common.acl.AccessControlEntry;
-import org.apache.kafka.common.acl.AccessControlEntryFilter;
-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.acl.AclPermissionType;
import org.apache.kafka.common.config.ConfigException;
import org.apache.kafka.common.config.ConfigResource;
-import org.apache.kafka.common.errors.ApiException;
import org.apache.kafka.common.errors.AuthenticationException;
import org.apache.kafka.common.errors.BootstrapResolutionException;
-import org.apache.kafka.common.errors.ClusterAuthorizationException;
import org.apache.kafka.common.errors.DuplicateVoterException;
import org.apache.kafka.common.errors.FencedInstanceIdException;
-import org.apache.kafka.common.errors.GroupAuthorizationException;
-import org.apache.kafka.common.errors.GroupSubscribedToTopicException;
-import org.apache.kafka.common.errors.InvalidConfigurationException;
-import org.apache.kafka.common.errors.InvalidReplicaAssignmentException;
import org.apache.kafka.common.errors.InvalidRequestException;
-import org.apache.kafka.common.errors.InvalidTopicException;
-import org.apache.kafka.common.errors.LogDirNotFoundException;
import org.apache.kafka.common.errors.MismatchedEndpointTypeException;
-import org.apache.kafka.common.errors.OffsetOutOfRangeException;
import org.apache.kafka.common.errors.SaslAuthenticationException;
-import org.apache.kafka.common.errors.SecurityDisabledException;
-import org.apache.kafka.common.errors.ThrottlingQuotaExceededException;
import org.apache.kafka.common.errors.TimeoutException;
-import org.apache.kafka.common.errors.TopicAuthorizationException;
-import org.apache.kafka.common.errors.TopicDeletionDisabledException;
-import org.apache.kafka.common.errors.TopicExistsException;
-import org.apache.kafka.common.errors.TransactionalIdAuthorizationException;
-import org.apache.kafka.common.errors.UnknownMemberIdException;
import org.apache.kafka.common.errors.UnknownServerException;
-import org.apache.kafka.common.errors.UnknownTopicIdException;
-import org.apache.kafka.common.errors.UnknownTopicOrPartitionException;
import org.apache.kafka.common.errors.UnsupportedVersionException;
import org.apache.kafka.common.errors.VoterNotFoundException;
import org.apache.kafka.common.feature.Features;
import org.apache.kafka.common.internals.Topic;
import org.apache.kafka.common.message.AddRaftVoterRequestData;
import org.apache.kafka.common.message.AddRaftVoterResponseData;
-import org.apache.kafka.common.message.AlterPartitionReassignmentsResponseData;
-import org.apache.kafka.common.message.AlterPartitionReassignmentsResponseData.ReassignablePartitionResponse;
-import org.apache.kafka.common.message.AlterPartitionReassignmentsResponseData.ReassignableTopicResponse;
-import org.apache.kafka.common.message.AlterReplicaLogDirsResponseData;
-import org.apache.kafka.common.message.AlterReplicaLogDirsResponseData.AlterReplicaLogDirPartitionResult;
-import org.apache.kafka.common.message.AlterReplicaLogDirsResponseData.AlterReplicaLogDirTopicResult;
-import org.apache.kafka.common.message.AlterShareGroupOffsetsResponseData;
-import org.apache.kafka.common.message.AlterUserScramCredentialsResponseData;
import org.apache.kafka.common.message.ApiMessageType;
import org.apache.kafka.common.message.ApiVersionsResponseData;
import org.apache.kafka.common.message.ApiVersionsResponseData.ApiVersion;
-import org.apache.kafka.common.message.ConsumerGroupDescribeResponseData;
-import org.apache.kafka.common.message.CreateAclsResponseData;
-import org.apache.kafka.common.message.CreatePartitionsResponseData;
-import org.apache.kafka.common.message.CreatePartitionsResponseData.CreatePartitionsTopicResult;
-import org.apache.kafka.common.message.CreateTopicsResponseData;
-import org.apache.kafka.common.message.CreateTopicsResponseData.CreatableTopicResult;
-import org.apache.kafka.common.message.CreateTopicsResponseData.CreatableTopicResultCollection;
-import org.apache.kafka.common.message.DeleteAclsResponseData;
-import org.apache.kafka.common.message.DeleteGroupsResponseData;
-import org.apache.kafka.common.message.DeleteGroupsResponseData.DeletableGroupResult;
-import org.apache.kafka.common.message.DeleteGroupsResponseData.DeletableGroupResultCollection;
-import org.apache.kafka.common.message.DeleteRecordsResponseData;
-import org.apache.kafka.common.message.DeleteShareGroupOffsetsRequestData;
-import org.apache.kafka.common.message.DeleteShareGroupOffsetsResponseData;
-import org.apache.kafka.common.message.DeleteTopicsResponseData;
-import org.apache.kafka.common.message.DeleteTopicsResponseData.DeletableTopicResult;
-import org.apache.kafka.common.message.DeleteTopicsResponseData.DeletableTopicResultCollection;
-import org.apache.kafka.common.message.DescribeAclsResponseData;
import org.apache.kafka.common.message.DescribeClusterResponseData;
import org.apache.kafka.common.message.DescribeClusterResponseData.DescribeClusterBroker;
-import org.apache.kafka.common.message.DescribeConfigsResponseData;
-import org.apache.kafka.common.message.DescribeGroupsResponseData;
-import org.apache.kafka.common.message.DescribeGroupsResponseData.DescribedGroupMember;
-import org.apache.kafka.common.message.DescribeLogDirsResponseData;
-import org.apache.kafka.common.message.DescribeLogDirsResponseData.DescribeLogDirsTopic;
-import org.apache.kafka.common.message.DescribeProducersResponseData;
import org.apache.kafka.common.message.DescribeQuorumResponseData;
-import org.apache.kafka.common.message.DescribeShareGroupOffsetsRequestData;
-import org.apache.kafka.common.message.DescribeShareGroupOffsetsResponseData;
-import org.apache.kafka.common.message.DescribeTopicPartitionsRequestData;
-import org.apache.kafka.common.message.DescribeTopicPartitionsResponseData;
-import org.apache.kafka.common.message.DescribeTopicPartitionsResponseData.DescribeTopicPartitionsResponsePartition;
-import org.apache.kafka.common.message.DescribeTopicPartitionsResponseData.DescribeTopicPartitionsResponseTopic;
-import org.apache.kafka.common.message.DescribeTransactionsResponseData;
-import org.apache.kafka.common.message.DescribeUserScramCredentialsResponseData;
-import org.apache.kafka.common.message.DescribeUserScramCredentialsResponseData.CredentialInfo;
-import org.apache.kafka.common.message.ElectLeadersResponseData.PartitionResult;
-import org.apache.kafka.common.message.ElectLeadersResponseData.ReplicaElectionResult;
-import org.apache.kafka.common.message.FindCoordinatorRequestData;
-import org.apache.kafka.common.message.FindCoordinatorResponseData;
-import org.apache.kafka.common.message.IncrementalAlterConfigsResponseData;
-import org.apache.kafka.common.message.IncrementalAlterConfigsResponseData.AlterConfigsResourceResponse;
-import org.apache.kafka.common.message.InitProducerIdResponseData;
-import org.apache.kafka.common.message.LeaveGroupRequestData;
import org.apache.kafka.common.message.LeaveGroupRequestData.MemberIdentity;
-import org.apache.kafka.common.message.LeaveGroupResponseData;
-import org.apache.kafka.common.message.LeaveGroupResponseData.MemberResponse;
import org.apache.kafka.common.message.ListConfigResourcesResponseData;
-import org.apache.kafka.common.message.ListGroupsResponseData;
-import org.apache.kafka.common.message.ListGroupsResponseData.ListedGroup;
-import org.apache.kafka.common.message.ListOffsetsResponseData;
-import org.apache.kafka.common.message.ListOffsetsResponseData.ListOffsetsTopicResponse;
-import org.apache.kafka.common.message.ListPartitionReassignmentsResponseData;
-import org.apache.kafka.common.message.ListPartitionReassignmentsResponseData.OngoingPartitionReassignment;
-import org.apache.kafka.common.message.ListPartitionReassignmentsResponseData.OngoingTopicReassignment;
-import org.apache.kafka.common.message.ListTransactionsResponseData;
-import org.apache.kafka.common.message.MetadataResponseData;
-import org.apache.kafka.common.message.MetadataResponseData.MetadataResponsePartition;
-import org.apache.kafka.common.message.MetadataResponseData.MetadataResponseTopic;
-import org.apache.kafka.common.message.OffsetDeleteResponseData;
-import org.apache.kafka.common.message.OffsetDeleteResponseData.OffsetDeleteResponsePartition;
-import org.apache.kafka.common.message.OffsetDeleteResponseData.OffsetDeleteResponsePartitionCollection;
-import org.apache.kafka.common.message.OffsetDeleteResponseData.OffsetDeleteResponseTopic;
-import org.apache.kafka.common.message.OffsetDeleteResponseData.OffsetDeleteResponseTopicCollection;
-import org.apache.kafka.common.message.OffsetFetchRequestData;
-import org.apache.kafka.common.message.OffsetFetchRequestData.OffsetFetchRequestGroup;
-import org.apache.kafka.common.message.OffsetFetchRequestData.OffsetFetchRequestTopics;
-import org.apache.kafka.common.message.OffsetFetchResponseData;
import org.apache.kafka.common.message.RemoveRaftVoterRequestData;
import org.apache.kafka.common.message.RemoveRaftVoterResponseData;
-import org.apache.kafka.common.message.ShareGroupDescribeResponseData;
-import org.apache.kafka.common.message.StreamsGroupDescribeResponseData;
import org.apache.kafka.common.message.UnregisterBrokerResponseData;
import org.apache.kafka.common.message.UnregisterControllerResponseData;
-import org.apache.kafka.common.message.WriteTxnMarkersResponseData;
import org.apache.kafka.common.protocol.ApiKeys;
import org.apache.kafka.common.protocol.Errors;
import org.apache.kafka.common.quota.ClientQuotaAlteration;
import org.apache.kafka.common.quota.ClientQuotaEntity;
import org.apache.kafka.common.quota.ClientQuotaFilter;
-import org.apache.kafka.common.quota.ClientQuotaFilterComponent;
-import org.apache.kafka.common.requests.AbstractRequest;
import org.apache.kafka.common.requests.AbstractResponse;
import org.apache.kafka.common.requests.AddRaftVoterRequest;
import org.apache.kafka.common.requests.AddRaftVoterResponse;
-import org.apache.kafka.common.requests.AlterClientQuotasResponse;
-import org.apache.kafka.common.requests.AlterPartitionReassignmentsResponse;
-import org.apache.kafka.common.requests.AlterReplicaLogDirsResponse;
-import org.apache.kafka.common.requests.AlterShareGroupOffsetsResponse;
-import org.apache.kafka.common.requests.AlterUserScramCredentialsResponse;
import org.apache.kafka.common.requests.ApiError;
import org.apache.kafka.common.requests.ApiVersionsRequest;
import org.apache.kafka.common.requests.ApiVersionsResponse;
-import org.apache.kafka.common.requests.ConsumerGroupDescribeRequest;
-import org.apache.kafka.common.requests.ConsumerGroupDescribeResponse;
-import org.apache.kafka.common.requests.CreateAclsResponse;
-import org.apache.kafka.common.requests.CreatePartitionsRequest;
-import org.apache.kafka.common.requests.CreatePartitionsResponse;
import org.apache.kafka.common.requests.CreateTopicsRequest;
-import org.apache.kafka.common.requests.CreateTopicsResponse;
-import org.apache.kafka.common.requests.DeleteAclsResponse;
-import org.apache.kafka.common.requests.DeleteGroupsResponse;
-import org.apache.kafka.common.requests.DeleteRecordsResponse;
-import org.apache.kafka.common.requests.DeleteShareGroupOffsetsRequest;
-import org.apache.kafka.common.requests.DeleteShareGroupOffsetsResponse;
-import org.apache.kafka.common.requests.DeleteTopicsRequest;
-import org.apache.kafka.common.requests.DeleteTopicsResponse;
-import org.apache.kafka.common.requests.DescribeAclsResponse;
-import org.apache.kafka.common.requests.DescribeClientQuotasResponse;
import org.apache.kafka.common.requests.DescribeClusterRequest;
import org.apache.kafka.common.requests.DescribeClusterResponse;
-import org.apache.kafka.common.requests.DescribeConfigsResponse;
-import org.apache.kafka.common.requests.DescribeGroupsRequest;
-import org.apache.kafka.common.requests.DescribeGroupsResponse;
-import org.apache.kafka.common.requests.DescribeLogDirsResponse;
-import org.apache.kafka.common.requests.DescribeProducersRequest;
-import org.apache.kafka.common.requests.DescribeProducersResponse;
import org.apache.kafka.common.requests.DescribeQuorumRequest;
import org.apache.kafka.common.requests.DescribeQuorumResponse;
-import org.apache.kafka.common.requests.DescribeShareGroupOffsetsRequest;
-import org.apache.kafka.common.requests.DescribeShareGroupOffsetsResponse;
-import org.apache.kafka.common.requests.DescribeTopicPartitionsResponse;
-import org.apache.kafka.common.requests.DescribeTransactionsRequest;
-import org.apache.kafka.common.requests.DescribeTransactionsResponse;
-import org.apache.kafka.common.requests.DescribeUserScramCredentialsResponse;
-import org.apache.kafka.common.requests.ElectLeadersResponse;
-import org.apache.kafka.common.requests.FindCoordinatorRequest;
-import org.apache.kafka.common.requests.FindCoordinatorResponse;
-import org.apache.kafka.common.requests.IncrementalAlterConfigsResponse;
-import org.apache.kafka.common.requests.InitProducerIdRequest;
-import org.apache.kafka.common.requests.InitProducerIdResponse;
-import org.apache.kafka.common.requests.JoinGroupRequest;
-import org.apache.kafka.common.requests.LeaveGroupRequest;
-import org.apache.kafka.common.requests.LeaveGroupResponse;
import org.apache.kafka.common.requests.ListConfigResourcesRequest;
import org.apache.kafka.common.requests.ListConfigResourcesResponse;
-import org.apache.kafka.common.requests.ListGroupsRequest;
-import org.apache.kafka.common.requests.ListGroupsResponse;
-import org.apache.kafka.common.requests.ListOffsetsRequest;
-import org.apache.kafka.common.requests.ListOffsetsResponse;
-import org.apache.kafka.common.requests.ListPartitionReassignmentsResponse;
-import org.apache.kafka.common.requests.ListTransactionsRequest;
-import org.apache.kafka.common.requests.ListTransactionsResponse;
import org.apache.kafka.common.requests.MetadataRequest;
import org.apache.kafka.common.requests.MetadataResponse;
-import org.apache.kafka.common.requests.OffsetCommitResponse;
-import org.apache.kafka.common.requests.OffsetDeleteResponse;
-import org.apache.kafka.common.requests.OffsetFetchRequest;
-import org.apache.kafka.common.requests.OffsetFetchResponse;
import org.apache.kafka.common.requests.RemoveRaftVoterRequest;
import org.apache.kafka.common.requests.RemoveRaftVoterResponse;
import org.apache.kafka.common.requests.RequestTestUtils;
-import org.apache.kafka.common.requests.ShareGroupDescribeResponse;
-import org.apache.kafka.common.requests.StreamsGroupDescribeResponse;
import org.apache.kafka.common.requests.UnregisterBrokerResponse;
import org.apache.kafka.common.requests.UnregisterControllerResponse;
import org.apache.kafka.common.requests.UpdateFeaturesRequest;
import org.apache.kafka.common.requests.UpdateFeaturesResponse;
-import org.apache.kafka.common.requests.WriteTxnMarkersRequest;
-import org.apache.kafka.common.requests.WriteTxnMarkersResponse;
-import org.apache.kafka.common.resource.PatternType;
-import org.apache.kafka.common.resource.ResourcePattern;
-import org.apache.kafka.common.resource.ResourcePatternFilter;
-import org.apache.kafka.common.resource.ResourceType;
import org.apache.kafka.common.telemetry.internals.ClientTelemetryReporter;
import org.apache.kafka.common.telemetry.internals.ClientTelemetrySender;
import org.apache.kafka.common.utils.MockTime;
@@ -268,28 +97,20 @@ import org.apache.kafka.test.TestUtils;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Timeout;
import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.CsvSource;
-import org.junit.jupiter.params.provider.MethodSource;
import org.junit.jupiter.params.provider.ValueSource;
import org.mockito.MockedStatic;
import org.mockito.internal.stubbing.answers.CallsRealMethods;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
import java.net.InetSocketAddress;
-import java.nio.ByteBuffer;
import java.time.Duration;
import java.util.ArrayList;
-import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
-import java.util.Iterator;
import java.util.List;
import java.util.Map;
-import java.util.Objects;
import java.util.Optional;
import java.util.OptionalInt;
import java.util.OptionalLong;
@@ -298,29 +119,20 @@ import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Function;
-import java.util.function.Predicate;
import java.util.stream.Collectors;
-import java.util.stream.Stream;
import static java.util.Arrays.asList;
-import static java.util.Collections.emptyList;
-import static java.util.Collections.emptySet;
import static java.util.Collections.singleton;
import static java.util.Collections.singletonList;
import static java.util.Collections.singletonMap;
-import static org.apache.kafka.clients.admin.KafkaAdminClient.DEFAULT_LEAVE_GROUP_REASON;
import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertInstanceOf;
-import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
@@ -335,16 +147,9 @@ import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.mockStatic;
import static org.mockito.Mockito.when;
-/**
- * A unit test for KafkaAdminClient.
- *
- * See AdminClientIntegrationTest for an integration test.
- */
-@Timeout(120)
-public class KafkaAdminClientTest {
- private static final Logger log = LoggerFactory.getLogger(KafkaAdminClientTest.class);
- private static final String GROUP_ID = "group-0";
- public static final Uuid REPLICA_DIRECTORY_ID = Uuid.randomUuid();
+public class KafkaAdminClientTest extends KafkaAdminClientTestBase {
+
+ private static final Uuid REPLICA_DIRECTORY_ID = Uuid.randomUuid();
@Test
public void testDefaultApiTimeoutAndRequestTimeoutConflicts() {
@@ -435,23 +240,6 @@ public class KafkaAdminClientTest {
KafkaAdminClient.prettyPrintException(new TimeoutException("The foobar timed out.")));
}
- private static Map<String, Object> newStrMap(String... vals) {
- Map<String, Object> map = new HashMap<>();
- map.put(AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:8121");
- map.put(AdminClientConfig.REQUEST_TIMEOUT_MS_CONFIG, "1000");
- if (vals.length % 2 != 0) {
- throw new IllegalStateException();
- }
- for (int i = 0; i < vals.length; i += 2) {
- map.put(vals[i], vals[i + 1]);
- }
- return map;
- }
-
- private static AdminClientConfig newConfMap(String... vals) {
- return new AdminClientConfig(newStrMap(vals));
- }
-
@Test
public void testGenerateClientId() {
Set<String> ids = new HashSet<>();
@@ -527,27 +315,6 @@ public class KafkaAdminClientTest {
}
}
- private static Cluster mockCluster(int numNodes, int controllerIndex) {
- HashMap<Integer, Node> nodes = new HashMap<>();
- for (int i = 0; i < numNodes; i++)
- nodes.put(i, new Node(i, "localhost", 8121 + i));
- return new Cluster("mockClusterId", nodes.values(),
- Collections.emptySet(), Collections.emptySet(),
- Collections.emptySet(), nodes.get(controllerIndex));
- }
-
- private static Cluster mockBootstrapCluster() {
- return Cluster.bootstrap(singletonList(InetSocketAddress.createUnresolved("localhost", 8121)));
- }
-
- private static AdminClientUnitTestEnv mockClientEnv(String... configVals) {
- return new AdminClientUnitTestEnv(mockCluster(3, 0), configVals);
- }
-
- private static AdminClientUnitTestEnv mockClientEnv(Time time, String... configVals) {
- return new AdminClientUnitTestEnv(time, mockCluster(3, 0), configVals);
- }
-
@Test
public void testCloseAdminClient() {
try (AdminClientUnitTestEnv env = mockClientEnv()) {
@@ -588,282 +355,6 @@ public class KafkaAdminClientTest {
"Expected an IllegalStateException error, but got " + Utils.stackTrace(e));
}
- private static OffsetDeleteResponse prepareOffsetDeleteResponse(Errors error) {
- return new OffsetDeleteResponse(
- new OffsetDeleteResponseData()
- .setErrorCode(error.code())
- .setTopics(new OffsetDeleteResponseTopicCollection())
- );
- }
-
- private static OffsetDeleteResponse prepareOffsetDeleteResponse(String topic, int partition, Errors error) {
- return new OffsetDeleteResponse(
- new OffsetDeleteResponseData()
- .setErrorCode(Errors.NONE.code())
- .setTopics(new OffsetDeleteResponseTopicCollection(Stream.of(
- new OffsetDeleteResponseTopic()
- .setName(topic)
- .setPartitions(new OffsetDeleteResponsePartitionCollection(Collections.singletonList(
- new OffsetDeleteResponsePartition()
- .setPartitionIndex(partition)
- .setErrorCode(error.code())
- )))
- ).collect(Collectors.toList())))
- );
- }
-
- private static OffsetCommitResponse prepareOffsetCommitResponse(TopicPartition tp, Errors error) {
- Map<TopicPartition, Errors> responseData = new HashMap<>();
- responseData.put(tp, error);
- return new OffsetCommitResponse(0, responseData);
- }
-
- private static CreateTopicsResponse prepareCreateTopicsResponse(String topicName, Errors error) {
- CreateTopicsResponseData data = new CreateTopicsResponseData();
- data.topics().add(new CreatableTopicResult()
- .setName(topicName)
- .setErrorCode(error.code()));
- return new CreateTopicsResponse(data);
- }
-
- public static CreateTopicsResponse prepareCreateTopicsResponse(int throttleTimeMs, CreatableTopicResult... topics) {
- CreateTopicsResponseData data = new CreateTopicsResponseData()
- .setThrottleTimeMs(throttleTimeMs)
- .setTopics(new CreatableTopicResultCollection(Arrays.asList(topics)));
- return new CreateTopicsResponse(data);
- }
-
- public static CreatableTopicResult creatableTopicResult(String name, Errors error) {
- return new CreatableTopicResult()
- .setName(name)
- .setErrorCode(error.code());
- }
-
- public static DeleteTopicsResponse prepareDeleteTopicsResponse(int throttleTimeMs, DeletableTopicResult... topics) {
- DeleteTopicsResponseData data = new DeleteTopicsResponseData()
- .setThrottleTimeMs(throttleTimeMs)
- .setResponses(new DeletableTopicResultCollection(Arrays.asList(topics)));
- return new DeleteTopicsResponse(data);
- }
-
- public static DeletableTopicResult deletableTopicResult(String topicName, Errors error) {
- return new DeletableTopicResult()
- .setName(topicName)
- .setErrorCode(error.code());
- }
-
- public static DeletableTopicResult deletableTopicResultWithId(Uuid topicId, Errors error) {
- return new DeletableTopicResult()
- .setTopicId(topicId)
- .setErrorCode(error.code());
- }
-
- public static CreatePartitionsResponse prepareCreatePartitionsResponse(int throttleTimeMs, CreatePartitionsTopicResult... topics) {
- CreatePartitionsResponseData data = new CreatePartitionsResponseData()
- .setThrottleTimeMs(throttleTimeMs)
- .setResults(asList(topics));
- return new CreatePartitionsResponse(data);
- }
-
- public static CreatePartitionsTopicResult createPartitionsTopicResult(String name, Errors error) {
- return createPartitionsTopicResult(name, error, null);
- }
-
- public static CreatePartitionsTopicResult createPartitionsTopicResult(String name, Errors error, String errorMessage) {
- return new CreatePartitionsTopicResult()
- .setName(name)
- .setErrorCode(error.code())
- .setErrorMessage(errorMessage);
- }
-
- private static DeleteTopicsResponse prepareDeleteTopicsResponse(String topicName, Errors error) {
- DeleteTopicsResponseData data = new DeleteTopicsResponseData();
- data.responses().add(new DeletableTopicResult()
- .setName(topicName)
- .setErrorCode(error.code()));
- return new DeleteTopicsResponse(data);
- }
-
- private static DeleteTopicsResponse prepareDeleteTopicsResponseWithTopicId(Uuid id, Errors error) {
- DeleteTopicsResponseData data = new DeleteTopicsResponseData();
- data.responses().add(new DeletableTopicResult()
- .setTopicId(id)
- .setErrorCode(error.code()));
- return new DeleteTopicsResponse(data);
- }
-
- private static FindCoordinatorResponse prepareFindCoordinatorResponse(Errors error, Node node) {
- return prepareFindCoordinatorResponse(error, GROUP_ID, node);
- }
-
- private static FindCoordinatorResponse prepareFindCoordinatorResponse(Errors error, String key, Node node) {
- return FindCoordinatorResponse.prepareResponse(error, key, node);
- }
-
- private static FindCoordinatorResponse prepareOldFindCoordinatorResponse(Errors error, Node node) {
- return FindCoordinatorResponse.prepareOldResponse(error, node);
- }
-
- private static FindCoordinatorResponse prepareBatchedFindCoordinatorResponse(Errors error, Node node, Collection<String> groups) {
- FindCoordinatorResponseData data = new FindCoordinatorResponseData();
- List<FindCoordinatorResponseData.Coordinator> coordinators = groups.stream()
- .map(group -> new FindCoordinatorResponseData.Coordinator()
- .setErrorCode(error.code())
- .setErrorMessage(error.message())
- .setKey(group)
- .setHost(node.host())
- .setPort(node.port())
- .setNodeId(node.id()))
- .collect(Collectors.toList());
- data.setCoordinators(coordinators);
- return new FindCoordinatorResponse(data);
- }
-
- private static MetadataResponse prepareMetadataResponse(Cluster cluster, Errors error) {
- return prepareMetadataResponse(cluster, error, error);
- }
-
- private static MetadataResponse prepareMetadataResponse(Cluster cluster, Errors topicError, Errors partitionError) {
- List<MetadataResponseTopic> metadata = new ArrayList<>();
- for (String topic : cluster.topics()) {
- List<MetadataResponsePartition> pms = new ArrayList<>();
- for (PartitionInfo pInfo : cluster.availablePartitionsForTopic(topic)) {
- MetadataResponsePartition pm = new MetadataResponsePartition()
- .setErrorCode(partitionError.code())
- .setPartitionIndex(pInfo.partition())
- .setLeaderId(pInfo.leader().id())
- .setLeaderEpoch(234)
- .setReplicaNodes(Arrays.stream(pInfo.replicas()).map(Node::id).collect(Collectors.toList()))
- .setIsrNodes(Arrays.stream(pInfo.inSyncReplicas()).map(Node::id).collect(Collectors.toList()))
- .setOfflineReplicas(Arrays.stream(pInfo.offlineReplicas()).map(Node::id).collect(Collectors.toList()));
- pms.add(pm);
- }
- MetadataResponseTopic tm = new MetadataResponseTopic()
- .setErrorCode(topicError.code())
- .setName(topic)
- .setIsInternal(false)
- .setPartitions(pms);
- metadata.add(tm);
- }
- return MetadataResponse.prepareResponse(true,
- 0,
- cluster.nodes(),
- cluster.clusterResource().clusterId(),
- cluster.controller().id(),
- metadata,
- MetadataResponse.AUTHORIZED_OPERATIONS_OMITTED);
- }
-
- private static DescribeGroupsResponseData prepareDescribeGroupsResponseData(String groupId,
- List<String> groupInstances,
- List<TopicPartition> topicPartitions) {
- final ByteBuffer memberAssignment = ConsumerProtocol.serializeAssignment(new ConsumerPartitionAssignor.Assignment(topicPartitions));
- List<DescribedGroupMember> describedGroupMembers = groupInstances.stream().map(groupInstance -> DescribeGroupsResponse.groupMember(JoinGroupRequest.UNKNOWN_MEMBER_ID,
- groupInstance, "clientId0", "clientHost", new byte[memberAssignment.remaining()], null)).collect(Collectors.toList());
- DescribeGroupsResponseData data = new DescribeGroupsResponseData();
- data.groups().add(DescribeGroupsResponse.groupMetadata(
- groupId,
- Errors.NONE,
- "",
- ConsumerProtocol.PROTOCOL_TYPE,
- "",
- describedGroupMembers,
- Collections.emptySet()));
- return data;
- }
-
- private static FeatureMetadata defaultFeatureMetadata() {
- return new FeatureMetadata(
- Map.of("test_feature_1", new FinalizedVersionRange((short) 2, (short) 2)),
- Optional.of(1L),
- Map.of("test_feature_1", new SupportedVersionRange((short) 1, (short) 5)));
- }
-
- private static Features<org.apache.kafka.common.feature.SupportedVersionRange> convertSupportedFeaturesMap(Map<String, SupportedVersionRange> features) {
- final Map<String, org.apache.kafka.common.feature.SupportedVersionRange> featuresMap = new HashMap<>();
- for (final Map.Entry<String, SupportedVersionRange> entry : features.entrySet()) {
- final SupportedVersionRange versionRange = entry.getValue();
- featuresMap.put(
- entry.getKey(),
- new org.apache.kafka.common.feature.SupportedVersionRange(versionRange.minVersion(),
- versionRange.maxVersion()));
- }
-
- return Features.supportedFeatures(featuresMap);
- }
-
- private static ApiVersionsResponse prepareApiVersionsResponseForDescribeFeatures(Errors error) {
- if (error == Errors.NONE) {
- return new ApiVersionsResponse.Builder().
- setApiVersions(ApiVersionsResponse.filterApis(
- ApiMessageType.ListenerType.BROKER, false, false)).
- setSupportedFeatures(
- convertSupportedFeaturesMap(defaultFeatureMetadata().supportedFeatures())).
- setFinalizedFeatures(
- Collections.singletonMap("test_feature_1", (short) 2)).
- setFinalizedFeaturesEpoch(
- defaultFeatureMetadata().finalizedFeaturesEpoch().get()).
- build();
- }
- return new ApiVersionsResponse(
- new ApiVersionsResponseData()
- .setThrottleTimeMs(0)
- .setErrorCode(error.code()));
- }
-
- private static QuorumInfo defaultQuorumInfo(boolean emptyOptionals) {
- return new QuorumInfo(1, 1, 1L,
- singletonList(new QuorumInfo.ReplicaState(1,
- emptyOptionals ? Uuid.ZERO_UUID : REPLICA_DIRECTORY_ID,
- 100,
- emptyOptionals ? OptionalLong.empty() : OptionalLong.of(1000),
- emptyOptionals ? OptionalLong.empty() : OptionalLong.of(1000))),
- singletonList(new QuorumInfo.ReplicaState(1,
- emptyOptionals ? Uuid.ZERO_UUID : REPLICA_DIRECTORY_ID,
- 100,
- emptyOptionals ? OptionalLong.empty() : OptionalLong.of(1000),
- emptyOptionals ? OptionalLong.empty() : OptionalLong.of(1000))),
- singletonMap(1, new QuorumInfo.Node(1, Collections.emptyList())));
- }
-
- private static DescribeQuorumResponse prepareDescribeQuorumResponse(
- Errors topLevelError,
- Errors partitionLevelError,
- Boolean topicCountError,
- Boolean topicNameError,
- Boolean partitionCountError,
- Boolean partitionIndexError,
- Boolean emptyOptionals) {
- String topicName = topicNameError ? "RANDOM" : Topic.CLUSTER_METADATA_TOPIC_NAME;
- int partitionIndex = partitionIndexError ? 1 : Topic.CLUSTER_METADATA_TOPIC_PARTITION.partition();
- List<DescribeQuorumResponseData.TopicData> topics = new ArrayList<>();
- List<DescribeQuorumResponseData.PartitionData> partitions = new ArrayList<>();
- for (int i = 0; i < (partitionCountError ? 2 : 1); i++) {
- DescribeQuorumResponseData.ReplicaState replica = new DescribeQuorumResponseData.ReplicaState()
- .setReplicaId(1)
- .setReplicaDirectoryId(emptyOptionals ? Uuid.ZERO_UUID : REPLICA_DIRECTORY_ID)
- .setLogEndOffset(100);
- replica.setLastFetchTimestamp(emptyOptionals ? -1 : 1000);
- replica.setLastCaughtUpTimestamp(emptyOptionals ? -1 : 1000);
- partitions.add(new DescribeQuorumResponseData.PartitionData().setPartitionIndex(partitionIndex)
- .setLeaderId(1)
- .setLeaderEpoch(1)
- .setHighWatermark(1)
- .setCurrentVoters(singletonList(replica))
- .setObservers(singletonList(replica))
- .setErrorCode(partitionLevelError.code())
- .setErrorMessage(partitionLevelError.message()));
- }
- for (int i = 0; i < (topicCountError ? 2 : 1); i++) {
- topics.add(new DescribeQuorumResponseData.TopicData().setTopicName(topicName).setPartitions(partitions));
- }
- return new DescribeQuorumResponse(new DescribeQuorumResponseData()
- .setTopics(topics)
- .setErrorCode(topLevelError.code())
- .setErrorMessage(topLevelError.message())
- .setNodes(new DescribeQuorumResponseData.NodeCollection(Collections.singleton(new DescribeQuorumResponseData.Node().setNodeId(1)))));
- }
-
/**
* Test that the client properly times out when we don't receive any metadata.
*/
@@ -914,38 +405,6 @@ public class KafkaAdminClientTest {
verifyUnreachableBootstrapServer(MetadataRecoveryStrategy.NONE);
}
- private void verifyUnreachableBootstrapServer(MetadataRecoveryStrategy metadataRecoveryStrategy) throws Exception {
- // This tests the scenario in which the bootstrap server is unreachable for a short while,
- // which prevents AdminClient from being able to send the initial metadata request
-
- Cluster cluster = Cluster.bootstrap(singletonList(new InetSocketAddress("localhost", 8121)));
- Node bootstrapNode = cluster.nodes().get(0);
- Map<Node, Long> unreachableNodes = Collections.singletonMap(bootstrapNode, 200L);
- try (final AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(Time.SYSTEM, cluster,
- AdminClientUnitTestEnv.clientConfigs(AdminClientConfig.METADATA_RECOVERY_STRATEGY_CONFIG, metadataRecoveryStrategy.name), unreachableNodes)) {
- Cluster discoveredCluster = mockCluster(3, 0);
- env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
- // Bind responses to specific destinations so MockClient delivery does not depend on
- // the iteration order of AdminClient's callsToSend map (which is keyed by Node).
- env.kafkaClient().prepareResponseFrom(body -> body instanceof MetadataRequest,
- RequestTestUtils.metadataResponse(discoveredCluster.nodes(), discoveredCluster.clusterResource().clusterId(),
- 1, Collections.emptyList()), bootstrapNode);
- if (metadataRecoveryStrategy == MetadataRecoveryStrategy.REBOOTSTRAP) {
- env.kafkaClient().prepareResponseFrom(body -> body instanceof MetadataRequest,
- RequestTestUtils.metadataResponse(discoveredCluster.nodes(), discoveredCluster.clusterResource().clusterId(),
- 1, Collections.emptyList()), bootstrapNode);
- }
- env.kafkaClient().prepareResponseFrom(body -> body instanceof CreateTopicsRequest,
- prepareCreateTopicsResponse("myTopic", Errors.NONE), discoveredCluster.nodeById(1));
-
- KafkaFuture<Void> future = env.adminClient().createTopics(
- singleton(new NewTopic("myTopic", Collections.singletonMap(0, asList(0, 1, 2)))),
- new CreateTopicsOptions().timeoutMs(10000)).all();
-
- future.get();
- }
- }
-
/**
* Test that we propagate exceptions encountered when fetching metadata.
*/
@@ -967,10029 +426,815 @@ public class KafkaAdminClientTest {
}
@Test
- public void testCreateTopics() throws Exception {
- try (AdminClientUnitTestEnv env = mockClientEnv()) {
+ public void testAdminClientApisAuthenticationFailure() {
+ Cluster cluster = mockBootstrapCluster();
+ try (final AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(Time.SYSTEM, cluster,
+ newStrMap(AdminClientConfig.REQUEST_TIMEOUT_MS_CONFIG, "1000",
+ // Default "metadata.recovery.strategy" is rebootstrap. If it meets "retry.backoff.ms" (default is 100L),
+ // following assertion will fail. Set it to none to avoid authentication error cleanup.
+ AdminClientConfig.METADATA_RECOVERY_STRATEGY_CONFIG, "none"))) {
env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
- env.kafkaClient().prepareResponse(
- expectCreateTopicsRequestWithTopics("myTopic"),
- prepareCreateTopicsResponse("myTopic", Errors.NONE));
- KafkaFuture<Void> future = env.adminClient().createTopics(
- singleton(new NewTopic("myTopic", Collections.singletonMap(0, asList(0, 1, 2)))),
- new CreateTopicsOptions().timeoutMs(10000)).all();
- future.get();
+ env.kafkaClient().createPendingAuthenticationError(cluster.nodes().get(0),
+ TimeUnit.DAYS.toMillis(1));
+ callAdminClientApisAndExpectAnAuthenticationError(env);
+ callClientQuotasApisAndExpectAnAuthenticationError(env);
}
}
@Test
- public void testCreateTopicsPartialResponse() throws Exception {
- try (AdminClientUnitTestEnv env = mockClientEnv()) {
+ public void testDescribeCluster() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(4, 0),
+ AdminClientConfig.RETRIES_CONFIG, "2")) {
env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ // Prepare the describe cluster response used for the first describe cluster
env.kafkaClient().prepareResponse(
- expectCreateTopicsRequestWithTopics("myTopic", "myTopic2"),
- prepareCreateTopicsResponse("myTopic", Errors.NONE));
- CreateTopicsResult topicsResult = env.adminClient().createTopics(
- asList(new NewTopic("myTopic", Collections.singletonMap(0, asList(0, 1, 2))),
- new NewTopic("myTopic2", Collections.singletonMap(0, asList(0, 1, 2)))),
- new CreateTopicsOptions().timeoutMs(10000));
- topicsResult.values().get("myTopic").get();
- TestUtils.assertFutureThrows(ApiException.class, topicsResult.values().get("myTopic2"));
- }
- }
+ prepareDescribeClusterResponse(0,
+ env.cluster().nodes(),
+ env.cluster().clusterResource().clusterId(),
+ 2,
+ MetadataResponse.AUTHORIZED_OPERATIONS_OMITTED,
+ false));
- @Test
- public void testCreateTopicsRetryBackoff() throws Exception {
- MockTime time = new MockTime();
- int retryBackoff = 100;
+ // Prepare the describe cluster response used for the second describe cluster
+ env.kafkaClient().prepareResponse(
+ prepareDescribeClusterResponse(0,
+ env.cluster().nodes(),
+ env.cluster().clusterResource().clusterId(),
+ 3,
+ 1 << AclOperation.DESCRIBE.code() | 1 << AclOperation.ALTER.code(),
+ false));
- try (final AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time,
- mockCluster(3, 0),
- newStrMap(AdminClientConfig.RETRY_BACKOFF_MS_CONFIG, "" + retryBackoff))) {
- MockClient mockClient = env.kafkaClient();
+ // Test DescribeCluster with the authorized operations omitted.
+ final DescribeClusterResult result = env.adminClient().describeCluster();
+ assertEquals(env.cluster().clusterResource().clusterId(), result.clusterId().get());
+ assertEquals(new HashSet<>(env.cluster().nodes()), new HashSet<>(result.nodes().get()));
+ assertEquals(2, result.controller().get().id());
+ assertNull(result.authorizedOperations().get());
- mockClient.setNodeApiVersions(NodeApiVersions.create());
+ // Test DescribeCluster with the authorized operations included.
+ final DescribeClusterResult result2 = env.adminClient().describeCluster();
+ assertEquals(env.cluster().clusterResource().clusterId(), result2.clusterId().get());
+ assertEquals(new HashSet<>(env.cluster().nodes()), new HashSet<>(result2.nodes().get()));
+ assertEquals(3, result2.controller().get().id());
+ assertEquals(Set.of(AclOperation.DESCRIBE, AclOperation.ALTER),
+ result2.authorizedOperations().get());
+ }
+ }
- AtomicLong firstAttemptTime = new AtomicLong(0);
- AtomicLong secondAttemptTime = new AtomicLong(0);
+ @Test
+ public void testDescribeClusterHandleError() {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(4, 0),
+ AdminClientConfig.RETRIES_CONFIG, "2")) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
- mockClient.prepareResponse(body -> {
- firstAttemptTime.set(time.milliseconds());
- return body instanceof CreateTopicsRequest;
- }, null, true);
+ // Prepare the describe cluster response used for the first describe cluster
+ String errorMessage = "my error";
+ env.kafkaClient().prepareResponse(
+ new DescribeClusterResponse(new DescribeClusterResponseData()
+ .setErrorCode(Errors.INVALID_REQUEST.code())
+ .setErrorMessage(errorMessage)));
- mockClient.prepareResponse(body -> {
- secondAttemptTime.set(time.milliseconds());
- return body instanceof CreateTopicsRequest;
- }, prepareCreateTopicsResponse("myTopic", Errors.NONE));
+ final DescribeClusterResult result = env.adminClient().describeCluster();
+ TestUtils.assertFutureThrows(InvalidRequestException.class, result.clusterId(), errorMessage);
+ TestUtils.assertFutureThrows(InvalidRequestException.class, result.controller(), errorMessage);
+ TestUtils.assertFutureThrows(InvalidRequestException.class, result.nodes(), errorMessage);
+ TestUtils.assertFutureThrows(InvalidRequestException.class, result.authorizedOperations(), errorMessage);
+ }
+ }
- KafkaFuture<Void> future = env.adminClient().createTopics(
- singleton(new NewTopic("myTopic", Collections.singletonMap(0, asList(0, 1, 2)))),
- new CreateTopicsOptions().timeoutMs(10000)).all();
+ @Test
+ public void testDescribeClusterFailBack() throws Exception {
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(4, 0),
+ AdminClientConfig.RETRIES_CONFIG, "2")) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+
+ // Reject the describe cluster request with an unsupported exception
+ env.kafkaClient().prepareUnsupportedVersionResponse(
+ request -> request instanceof DescribeClusterRequest);
- // Wait until the first attempt has failed, then advance the time
- TestUtils.waitForCondition(() -> mockClient.numAwaitingResponses() == 1,
- "Failed awaiting CreateTopics first request failure");
+ // Prepare the metadata response used for the first describe cluster
+ env.kafkaClient().prepareResponse(
+ RequestTestUtils.metadataResponse(
+ 0,
+ env.cluster().nodes(),
+ env.cluster().clusterResource().clusterId(),
+ 2,
+ Collections.emptyList(),
+ MetadataResponse.AUTHORIZED_OPERATIONS_OMITTED,
+ ApiKeys.METADATA.latestVersion()));
- // Wait until the retry call added to the queue in AdminClient
- TestUtils.waitForCondition(() -> ((KafkaAdminClient) env.adminClient()).numPendingCalls() == 1,
- "Failed to add retry CreateTopics call");
+ final DescribeClusterResult result = env.adminClient().describeCluster();
+ assertEquals(env.cluster().clusterResource().clusterId(), result.clusterId().get());
+ assertEquals(new HashSet<>(env.cluster().nodes()), new HashSet<>(result.nodes().get()));
+ assertEquals(2, result.controller().get().id());
+ assertNull(result.authorizedOperations().get());
+ }
+ }
- long lowerBoundBackoffMs = (long) (retryBackoff * (1 - CommonClientConfigs.RETRY_BACKOFF_JITTER));
- long upperBoundBackoffMs = (long) (retryBackoff * CommonClientConfigs.RETRY_BACKOFF_EXP_BASE * (1 + CommonClientConfigs.RETRY_BACKOFF_JITTER));
- time.sleep(upperBoundBackoffMs);
+ @Test
+ public void testDescribeClusterHandleUnsupportedVersionForIncludingFencedBrokers() {
+ ApiVersion describeClusterV1 = new ApiVersion()
+ .setApiKey(ApiKeys.DESCRIBE_CLUSTER.id)
+ .setMinVersion((short) 0)
+ .setMaxVersion((short) 1);
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create(Collections.singletonList(describeClusterV1)));
- future.get();
+ env.kafkaClient().prepareUnsupportedVersionResponse(
+ request -> request instanceof DescribeClusterRequest);
- long actualRetryBackoff = secondAttemptTime.get() - firstAttemptTime.get();
- assertEquals(retryBackoff, actualRetryBackoff, upperBoundBackoffMs - lowerBoundBackoffMs, "CreateTopics retry did not await expected backoff");
+ final DescribeClusterResult result = env.adminClient().describeCluster(new DescribeClusterOptions().includeFencedBrokers(true));
+ TestUtils.assertFutureThrows(UnsupportedVersionException.class, result.nodes());
}
}
+ @ParameterizedTest
+ @ValueSource(shorts = {1, 2})
+ public void testUpdateFeaturesDuringSuccess(short version) throws Exception {
+ final Map<String, FeatureUpdate> updates = makeTestFeatureUpdates();
+ // Only v1 and below specifies error codes per feature for NONE error.
+ Set<String> features = version <= 1 ? updates.keySet() : Set.of();
+ testUpdateFeatures(updates, ApiError.NONE, features);
+ }
+
@Test
- public void testCreateTopicsHandleNotControllerException() throws Exception {
- try (AdminClientUnitTestEnv env = mockClientEnv()) {
- env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+ public void testUpdateFeaturesTopLevelError() throws Exception {
+ final Map<String, FeatureUpdate> updates = makeTestFeatureUpdates();
+ testUpdateFeatures(updates, new ApiError(Errors.INVALID_REQUEST), Set.of());
+ }
+
+ @ParameterizedTest
+ @ValueSource(shorts = {1, 2})
+ public void testUpdateFeaturesHandleNotControllerException(short version) throws Exception {
+ try (final AdminClientUnitTestEnv env = mockClientEnv()) {
env.kafkaClient().prepareResponseFrom(
- prepareCreateTopicsResponse("myTopic", Errors.NOT_CONTROLLER),
+ request -> request instanceof UpdateFeaturesRequest,
+ UpdateFeaturesResponse.createWithErrors(
+ new ApiError(Errors.NOT_CONTROLLER),
+ Set.of(),
+ 0),
env.cluster().nodeById(0));
+ final int controllerId = 1;
env.kafkaClient().prepareResponse(RequestTestUtils.metadataResponse(env.cluster().nodes(),
env.cluster().clusterResource().clusterId(),
- 1,
+ controllerId,
Collections.emptyList()));
+ // Only v1 and below specifies error codes per feature for NONE error.
+ Set<String> features = version <= 1 ? Set.of("test_feature_1", "test_feature_2") : Set.of();
env.kafkaClient().prepareResponseFrom(
- prepareCreateTopicsResponse("myTopic", Errors.NONE),
- env.cluster().nodeById(1));
- KafkaFuture<Void> future = env.adminClient().createTopics(
- singleton(new NewTopic("myTopic", Collections.singletonMap(0, asList(0, 1, 2)))),
- new CreateTopicsOptions().timeoutMs(10000)).all();
+ request -> request instanceof UpdateFeaturesRequest,
+ UpdateFeaturesResponse.createWithErrors(
+ ApiError.NONE,
+ features,
+ 0),
+ env.cluster().nodeById(controllerId));
+ final KafkaFuture<Void> future = env.adminClient().updateFeatures(
+ Map.of(
+ "test_feature_1", new FeatureUpdate((short) 2, FeatureUpdate.UpgradeType.UPGRADE),
+ "test_feature_2", new FeatureUpdate((short) 3, FeatureUpdate.UpgradeType.SAFE_DOWNGRADE)),
+ new UpdateFeaturesOptions().timeoutMs(10000)
+ ).all();
future.get();
}
}
@Test
- public void testCreateTopicsRetryThrottlingExceptionWhenEnabled() throws Exception {
- try (AdminClientUnitTestEnv env = mockClientEnv()) {
- env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
-
- env.kafkaClient().prepareResponse(
- expectCreateTopicsRequestWithTopics("topic1", "topic2", "topic3"),
- prepareCreateTopicsResponse(1000,
- creatableTopicResult("topic1", Errors.NONE),
- creatableTopicResult("topic2", Errors.THROTTLING_QUOTA_EXCEEDED),
- creatableTopicResult("topic3", Errors.TOPIC_ALREADY_EXISTS)));
-
- env.kafkaClient().prepareResponse(
- expectCreateTopicsRequestWithTopics("topic2"),
- prepareCreateTopicsResponse(1000,
- creatableTopicResult("topic2", Errors.THROTTLING_QUOTA_EXCEEDED)));
-
- env.kafkaClient().prepareResponse(
- expectCreateTopicsRequestWithTopics("topic2"),
- prepareCreateTopicsResponse(0,
- creatableTopicResult("topic2", Errors.NONE)));
-
- CreateTopicsResult result = env.adminClient().createTopics(
- asList(
- new NewTopic("topic1", 1, (short) 1),
- new NewTopic("topic2", 1, (short) 1),
- new NewTopic("topic3", 1, (short) 1)),
- new CreateTopicsOptions().retryOnQuotaViolation(true));
-
- assertNull(result.values().get("topic1").get());
- assertNull(result.values().get("topic2").get());
- TestUtils.assertFutureThrows(TopicExistsException.class, result.values().get("topic3"));
+ public void testUpdateFeaturesShouldFailRequestForEmptyUpdates() {
+ try (final AdminClientUnitTestEnv env = mockClientEnv()) {
+ assertThrows(
+ IllegalArgumentException.class,
+ () -> env.adminClient().updateFeatures(new HashMap<>()));
}
}
@Test
- public void testCreateTopicsRetryThrottlingExceptionWhenEnabledUntilRequestTimeOut() throws Exception {
- long defaultApiTimeout = 60000;
- MockTime time = new MockTime();
-
- try (AdminClientUnitTestEnv env = mockClientEnv(time,
- AdminClientConfig.DEFAULT_API_TIMEOUT_MS_CONFIG, String.valueOf(defaultApiTimeout))) {
-
- env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+ public void testUpdateFeaturesShouldFailRequestForInvalidFeatureName() {
+ try (final AdminClientUnitTestEnv env = mockClientEnv()) {
+ assertThrows(
+ IllegalArgumentException.class,
+ () -> env.adminClient().updateFeatures(
+ Map.of("feature", new FeatureUpdate((short) 2, FeatureUpdate.UpgradeType.UPGRADE),
+ "", new FeatureUpdate((short) 2, FeatureUpdate.UpgradeType.UPGRADE))));
+ }
+ }
- env.kafkaClient().prepareResponse(
- expectCreateTopicsRequestWithTopics("topic1", "topic2", "topic3"),
- prepareCreateTopicsResponse(1000,
- creatableTopicResult("topic1", Errors.NONE),
- creatableTopicResult("topic2", Errors.THROTTLING_QUOTA_EXCEEDED),
- creatableTopicResult("topic3", Errors.TOPIC_ALREADY_EXISTS)));
+ @Test
+ public void testUpdateFeaturesShouldFailRequestInClientWhenDowngradeFlagIsNotSetDuringDeletion() {
+ assertThrows(
+ IllegalArgumentException.class,
+ () -> new FeatureUpdate((short) 0, FeatureUpdate.UpgradeType.UPGRADE));
+ }
+ @Test
+ public void testDescribeFeaturesSuccess() throws Exception {
+ try (final AdminClientUnitTestEnv env = mockClientEnv()) {
env.kafkaClient().prepareResponse(
- expectCreateTopicsRequestWithTopics("topic2"),
- prepareCreateTopicsResponse(1000,
- creatableTopicResult("topic2", Errors.THROTTLING_QUOTA_EXCEEDED)));
-
- CreateTopicsResult result = env.adminClient().createTopics(
- asList(
- new NewTopic("topic1", 1, (short) 1),
- new NewTopic("topic2", 1, (short) 1),
- new NewTopic("topic3", 1, (short) 1)),
- new CreateTopicsOptions().retryOnQuotaViolation(true));
-
- // Wait until the prepared attempts have consumed
- TestUtils.waitForCondition(() -> env.kafkaClient().numAwaitingResponses() == 0,
- "Failed awaiting CreateTopics requests");
-
- // Wait until the next request is sent out
- TestUtils.waitForCondition(() -> env.kafkaClient().inFlightRequestCount() == 1,
- "Failed awaiting next CreateTopics request");
-
- // Advance time past the default api timeout to time out the inflight request
- time.sleep(defaultApiTimeout + 1);
-
- assertNull(result.values().get("topic1").get());
- ThrottlingQuotaExceededException e = TestUtils.assertFutureThrows(ThrottlingQuotaExceededException.class, result.values().get("topic2"));
- assertEquals(0, e.throttleTimeMs());
- TestUtils.assertFutureThrows(TopicExistsException.class, result.values().get("topic3"));
+ body -> body instanceof ApiVersionsRequest,
+ prepareApiVersionsResponseForDescribeFeatures(Errors.NONE));
+ final var result = (InternalDescribeFeaturesResult) env.adminClient().describeFeatures(
+ new DescribeFeaturesOptions().timeoutMs(10000));
+ assertEquals(defaultFeatureMetadata(), result.featureMetadata().get());
+ assertNotNull(result.nodeApiVersions().get().apiVersion(ApiKeys.API_VERSIONS));
}
}
@Test
- public void testCreateTopicsDontRetryThrottlingExceptionWhenDisabled() throws Exception {
- try (AdminClientUnitTestEnv env = mockClientEnv()) {
- env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
-
+ public void testDescribeFeaturesFailure() {
+ try (final AdminClientUnitTestEnv env = mockClientEnv()) {
env.kafkaClient().prepareResponse(
- expectCreateTopicsRequestWithTopics("topic1", "topic2", "topic3"),
- prepareCreateTopicsResponse(1000,
- creatableTopicResult("topic1", Errors.NONE),
- creatableTopicResult("topic2", Errors.THROTTLING_QUOTA_EXCEEDED),
- creatableTopicResult("topic3", Errors.TOPIC_ALREADY_EXISTS)));
-
- CreateTopicsResult result = env.adminClient().createTopics(
- asList(
- new NewTopic("topic1", 1, (short) 1),
- new NewTopic("topic2", 1, (short) 1),
- new NewTopic("topic3", 1, (short) 1)),
- new CreateTopicsOptions().retryOnQuotaViolation(false));
-
- assertNull(result.values().get("topic1").get());
- ThrottlingQuotaExceededException e = TestUtils.assertFutureThrows(ThrottlingQuotaExceededException.class, result.values().get("topic2"));
- assertEquals(1000, e.throttleTimeMs());
- TestUtils.assertFutureThrows(TopicExistsException.class, result.values().get("topic3"));
+ body -> body instanceof ApiVersionsRequest,
+ prepareApiVersionsResponseForDescribeFeatures(Errors.INVALID_REQUEST));
+ final DescribeFeaturesOptions options = new DescribeFeaturesOptions();
+ options.timeoutMs(10000);
+ final var result = (InternalDescribeFeaturesResult) env.adminClient().describeFeatures(options);
+ TestUtils.assertFutureThrows(InvalidRequestException.class, result.featureMetadata());
+ TestUtils.assertFutureThrows(InvalidRequestException.class, result.nodeApiVersions());
}
}
- private MockClient.RequestMatcher expectCreateTopicsRequestWithTopics(final String... topics) {
- return body -> {
- if (body instanceof CreateTopicsRequest) {
- CreateTopicsRequest request = (CreateTopicsRequest) body;
- for (String topic : topics) {
- if (request.data().topics().find(topic) == null)
- return false;
- }
- return topics.length == request.data().topics().size();
- }
- return false;
- };
+ @Test
+ public void testDescribeFeaturesWithNodeSuccess() throws Exception {
+ try (final AdminClientUnitTestEnv env = mockClientEnv()) {
+ env.kafkaClient().prepareResponseFrom(
+ body -> body instanceof ApiVersionsRequest,
+ prepareApiVersionsResponseForDescribeFeatures(Errors.NONE),
+ env.cluster().nodeById(0));
+ final KafkaFuture<FeatureMetadata> future = env.adminClient().describeFeatures(
+ new DescribeFeaturesOptions().timeoutMs(10000).nodeId(0)).featureMetadata();
+ final FeatureMetadata metadata = future.get();
+ assertEquals(defaultFeatureMetadata(), metadata);
+ }
}
@Test
- public void testDeleteTopics() throws Exception {
- try (AdminClientUnitTestEnv env = mockClientEnv()) {
- env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
-
- env.kafkaClient().prepareResponse(
- expectDeleteTopicsRequestWithTopics("myTopic"),
- prepareDeleteTopicsResponse("myTopic", Errors.NONE));
- KafkaFuture<Void> future = env.adminClient().deleteTopics(singletonList("myTopic"),
- new DeleteTopicsOptions()).all();
- assertNull(future.get());
-
- env.kafkaClient().prepareResponse(
- expectDeleteTopicsRequestWithTopics("myTopic"),
- prepareDeleteTopicsResponse("myTopic", Errors.TOPIC_DELETION_DISABLED));
- future = env.adminClient().deleteTopics(singletonList("myTopic"),
- new DeleteTopicsOptions()).all();
- TestUtils.assertFutureThrows(TopicDeletionDisabledException.class, future);
-
- env.kafkaClient().prepareResponse(
- expectDeleteTopicsRequestWithTopics("myTopic"),
- prepareDeleteTopicsResponse("myTopic", Errors.UNKNOWN_TOPIC_OR_PARTITION));
- future = env.adminClient().deleteTopics(singletonList("myTopic"),
- new DeleteTopicsOptions()).all();
- TestUtils.assertFutureThrows(UnknownTopicOrPartitionException.class, future);
-
- // With topic IDs
- Uuid topicId = Uuid.randomUuid();
+ public void testDescribeFeaturesWithNodeFailure() throws Exception {
+ try (final AdminClientUnitTestEnv env = mockClientEnv()) {
+ env.kafkaClient().prepareResponseFrom(
+ body -> body instanceof ApiVersionsRequest,
+ prepareApiVersionsResponseForDescribeFeatures(Errors.NONE),
+ env.cluster().nodeById(1));
+ final var result = (InternalDescribeFeaturesResult) env.adminClient().describeFeatures(
+ new DescribeFeaturesOptions().timeoutMs(1000).nodeId(0));
+ TestUtils.assertFutureThrows(TimeoutException.class, result.featureMetadata());
+ TestUtils.assertFutureThrows(TimeoutException.class, result.nodeApiVersions());
+ }
+ }
- env.kafkaClient().prepareResponse(
- expectDeleteTopicsRequestWithTopicIds(topicId),
- prepareDeleteTopicsResponseWithTopicId(topicId, Errors.NONE));
- future = env.adminClient().deleteTopics(TopicCollection.ofTopicIds(singletonList(topicId)),
- new DeleteTopicsOptions()).all();
- assertNull(future.get());
+ @Test
+ public void testDescribeMetadataQuorumSuccess() throws Exception {
+ try (final AdminClientUnitTestEnv env = mockClientEnv()) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create(ApiKeys.DESCRIBE_QUORUM.id,
+ ApiKeys.DESCRIBE_QUORUM.oldestVersion(),
+ ApiKeys.DESCRIBE_QUORUM.latestVersion()));
+ // Test with optional fields set
env.kafkaClient().prepareResponse(
- expectDeleteTopicsRequestWithTopicIds(topicId),
- prepareDeleteTopicsResponseWithTopicId(topicId, Errors.TOPIC_DELETION_DISABLED));
- future = env.adminClient().deleteTopics(TopicCollection.ofTopicIds(singletonList(topicId)),
- new DeleteTopicsOptions()).all();
- TestUtils.assertFutureThrows(TopicDeletionDisabledException.class, future);
+ body -> body instanceof DescribeQuorumRequest,
+ prepareDescribeQuorumResponse(Errors.NONE, Errors.NONE, false, false, false, false, false));
+ KafkaFuture<QuorumInfo> future = env.adminClient().describeMetadataQuorum().quorumInfo();
+ QuorumInfo quorumInfo = future.get();
+ assertEquals(defaultQuorumInfo(false), quorumInfo);
+ // Test with optional fields empty
env.kafkaClient().prepareResponse(
- expectDeleteTopicsRequestWithTopicIds(topicId),
- prepareDeleteTopicsResponseWithTopicId(topicId, Errors.UNKNOWN_TOPIC_ID));
- future = env.adminClient().deleteTopics(TopicCollection.ofTopicIds(singletonList(topicId)),
- new DeleteTopicsOptions()).all();
- TestUtils.assertFutureThrows(UnknownTopicIdException.class, future);
+ body -> body instanceof DescribeQuorumRequest,
+ prepareDescribeQuorumResponse(Errors.NONE, Errors.NONE, false, false, false, false, true));
+ future = env.adminClient().describeMetadataQuorum().quorumInfo();
+ quorumInfo = future.get();
+ assertEquals(defaultQuorumInfo(true), quorumInfo);
}
}
-
@Test
- public void testDeleteTopicsPartialResponse() throws Exception {
- try (AdminClientUnitTestEnv env = mockClientEnv()) {
- env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+ public void testDescribeMetadataQuorumRetriableError() throws Exception {
+ try (final AdminClientUnitTestEnv env = mockClientEnv()) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create(ApiKeys.DESCRIBE_QUORUM.id,
+ ApiKeys.DESCRIBE_QUORUM.oldestVersion(),
+ ApiKeys.DESCRIBE_QUORUM.latestVersion()));
+ // First request fails with a NOT_LEADER_OR_FOLLOWER error (which is retriable)
env.kafkaClient().prepareResponse(
- expectDeleteTopicsRequestWithTopics("myTopic", "myOtherTopic"),
- prepareDeleteTopicsResponse(1000,
- deletableTopicResult("myTopic", Errors.NONE)));
-
- DeleteTopicsResult result = env.adminClient().deleteTopics(
- asList("myTopic", "myOtherTopic"), new DeleteTopicsOptions());
-
- result.topicNameValues().get("myTopic").get();
- TestUtils.assertFutureThrows(ApiException.class, result.topicNameValues().get("myOtherTopic"));
+ body -> body instanceof DescribeQuorumRequest,
+ prepareDescribeQuorumResponse(Errors.NONE, Errors.NOT_LEADER_OR_FOLLOWER, false, false, false, false, false));
- // With topic IDs
- Uuid topicId1 = Uuid.randomUuid();
- Uuid topicId2 = Uuid.randomUuid();
+ // The second request succeeds
env.kafkaClient().prepareResponse(
- expectDeleteTopicsRequestWithTopicIds(topicId1, topicId2),
- prepareDeleteTopicsResponse(1000,
- deletableTopicResultWithId(topicId1, Errors.NONE)));
-
- DeleteTopicsResult resultIds = env.adminClient().deleteTopics(
- TopicCollection.ofTopicIds(asList(topicId1, topicId2)), new DeleteTopicsOptions());
+ body -> body instanceof DescribeQuorumRequest,
+ prepareDescribeQuorumResponse(Errors.NONE, Errors.NONE, false, false, false, false, false));
- resultIds.topicIdValues().get(topicId1).get();
- TestUtils.assertFutureThrows(ApiException.class, resultIds.topicIdValues().get(topicId2));
+ KafkaFuture<QuorumInfo> future = env.adminClient().describeMetadataQuorum().quorumInfo();
+ QuorumInfo quorumInfo = future.get();
+ assertEquals(defaultQuorumInfo(false), quorumInfo);
}
}
@Test
- public void testDeleteTopicsRetryThrottlingExceptionWhenEnabled() throws Exception {
- try (AdminClientUnitTestEnv env = mockClientEnv()) {
- env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+ public void testDescribeMetadataQuorumFailure() {
+ try (final AdminClientUnitTestEnv env = mockClientEnv()) {
+ env.kafkaClient().setNodeApiVersions(NodeApiVersions.create(ApiKeys.DESCRIBE_QUORUM.id,
+ ApiKeys.DESCRIBE_QUORUM.oldestVersion(),
+ ApiKeys.DESCRIBE_QUORUM.latestVersion()));
+ // Test top level error
env.kafkaClient().prepareResponse(
- expectDeleteTopicsRequestWithTopics("topic1", "topic2", "topic3"),
- prepareDeleteTopicsResponse(1000,
- deletableTopicResult("topic1", Errors.NONE),
- deletableTopicResult("topic2", Errors.THROTTLING_QUOTA_EXCEEDED),
- deletableTopicResult("topic3", Errors.TOPIC_ALREADY_EXISTS)));
+ body -> body instanceof DescribeQuorumRequest,
+ prepareDescribeQuorumResponse(Errors.INVALID_REQUEST, Errors.NONE, false, false, false, false, false));
+ KafkaFuture<QuorumInfo> future = env.adminClient().describeMetadataQuorum().quorumInfo();
+ TestUtils.assertFutureThrows(InvalidRequestException.class, future);
+ // Test incorrect topic count
env.kafkaClient().prepareResponse(
- expectDeleteTopicsRequestWithTopics("topic2"),
- prepareDeleteTopicsResponse(1000,
- deletableTopicResult("topic2", Errors.THROTTLING_QUOTA_EXCEEDED)));
+ body -> body instanceof DescribeQuorumRequest,
+ prepareDescribeQuorumResponse(Errors.NONE, Errors.NONE, true, false, false, false, false));
+ future = env.adminClient().describeMetadataQuorum().quorumInfo();
+ TestUtils.assertFutureThrows(UnknownServerException.class, future);
+ // Test incorrect topic name
env.kafkaClient().prepareResponse(
- expectDeleteTopicsRequestWithTopics("topic2"),
- prepareDeleteTopicsResponse(0,
- deletableTopicResult("topic2", Errors.NONE)));
-
- DeleteTopicsResult result = env.adminClient().deleteTopics(
- asList("topic1", "topic2", "topic3"),
- new DeleteTopicsOptions().retryOnQuotaViolation(true));
-
- assertNull(result.topicNameValues().get("topic1").get());
- assertNull(result.topicNameValues().get("topic2").get());
- TestUtils.assertFutureThrows(TopicExistsException.class, result.topicNameValues().get("topic3"));
-
- // With topic IDs
- Uuid topicId1 = Uuid.randomUuid();
- Uuid topicId2 = Uuid.randomUuid();
- Uuid topicId3 = Uuid.randomUuid();
+ body -> body instanceof DescribeQuorumRequest,
+ prepareDescribeQuorumResponse(Errors.NONE, Errors.NONE, false, true, false, false, false));
+ future = env.adminClient().describeMetadataQuorum().quorumInfo();
+ TestUtils.assertFutureThrows(UnknownServerException.class, future);
+ // Test incorrect partition count
env.kafkaClient().prepareResponse(
- expectDeleteTopicsRequestWithTopicIds(topicId1, topicId2, topicId3),
- prepareDeleteTopicsResponse(1000,
- deletableTopicResultWithId(topicId1, Errors.NONE),
- deletableTopicResultWithId(topicId2, Errors.THROTTLING_QUOTA_EXCEEDED),
- deletableTopicResultWithId(topicId3, Errors.UNKNOWN_TOPIC_ID)));
+ body -> body instanceof DescribeQuorumRequest,
+ prepareDescribeQuorumResponse(Errors.NONE, Errors.NONE, false, false, true, false, false));
+ future = env.adminClient().describeMetadataQuorum().quorumInfo();
+ TestUtils.assertFutureThrows(UnknownServerException.class, future);
+ // Test incorrect partition index
env.kafkaClient().prepareResponse(
- expectDeleteTopicsRequestWithTopicIds(topicId2),
- prepareDeleteTopicsResponse(1000,
- deletableTopicResultWithId(topicId2, Errors.THROTTLING_QUOTA_EXCEEDED)));
+ body -> body instanceof DescribeQuorumRequest,
+ prepareDescribeQuorumResponse(Errors.NONE, Errors.NONE, false, false, false, true, false));
+ future = env.adminClient().describeMetadataQuorum().quorumInfo();
+ TestUtils.assertFutureThrows(UnknownServerException.class, future);
+ // Test partition level error
env.kafkaClient().prepareResponse(
- expectDeleteTopicsRequestWithTopicIds(topicId2),
- prepareDeleteTopicsResponse(0,
- deletableTopicResultWithId(topicId2, Errors.NONE)));
+ body -> body instanceof DescribeQuorumRequest,
+ prepareDescribeQuorumResponse(Errors.NONE, Errors.INVALID_REQUEST, false, false, false, false, false));
+ future = env.adminClient().describeMetadataQuorum().quorumInfo();
+ TestUtils.assertFutureThrows(InvalidRequestException.class, future);
- DeleteTopicsResult resultIds = env.adminClient().deleteTopics(
- TopicCollection.ofTopicIds(asList(topicId1, topicId2, topicId3)),
- new DeleteTopicsOptions().retryOnQuotaViolation(true));
+ // Test all incorrect and no errors
+ env.kafkaClient().prepareResponse(
+ body -> body instanceof DescribeQuorumRequest,
+ prepareDescribeQuorumResponse(Errors.NONE, Errors.NONE, true, true, true, true, false));
+ future = env.adminClient().describeMetadataQuorum().quorumInfo();
+ TestUtils.assertFutureThrows(UnknownServerException.class, future);
- assertNull(resultIds.topicIdValues().get(topicId1).get());
- assertNull(resultIds.topicIdValues().get(topicId2).get());
- TestUtils.assertFutureThrows(UnknownTopicIdException.class, resultIds.topicIdValues().get(topicId3));
+ // Test all incorrect and both errors
+ env.kafkaClient().prepareResponse(
+ body -> body instanceof DescribeQuorumRequest,
+ prepareDescribeQuorumResponse(Errors.INVALID_REQUEST, Errors.INVALID_REQUEST, true, true, true, true, false));
+ future = env.adminClient().describeMetadataQuorum().quorumInfo();
+ TestUtils.assertFutureThrows(InvalidRequestException.class, future);
}
}
@Test
- public void testDeleteTopicsRetryThrottlingExceptionWhenEnabledUntilRequestTimeOut() throws Exception {
- long defaultApiTimeout = 60000;
+ public void testGetSubLevelError() {
+ List<MemberIdentity> memberIdentities = asList(
+ new MemberIdentity().setGroupInstanceId("instance-0"),
+ new MemberIdentity().setGroupInstanceId("instance-1"));
+ Map<MemberIdentity, Errors> errorsMap = new HashMap<>();
+ errorsMap.put(memberIdentities.get(0), Errors.NONE);
+ errorsMap.put(memberIdentities.get(1), Errors.FENCED_INSTANCE_ID);
+ assertEquals(IllegalArgumentException.class, KafkaAdminClient.getSubLevelError(errorsMap,
+ new MemberIdentity().setGroupInstanceId("non-exist-id"), "For unit test").getClass());
+ assertNull(KafkaAdminClient.getSubLevelError(errorsMap, memberIdentities.get(0), "For unit test"));
+ assertEquals(FencedInstanceIdException.class, KafkaAdminClient.getSubLevelError(
+ errorsMap, memberIdentities.get(1), "For unit test").getClass());
+ }
+
+ @Test
+ public void testSuccessfulRetryAfterRequestTimeout() throws Exception {
+ HashMap<Integer, Node> nodes = new HashMap<>();
MockTime time = new MockTime();
+ Node node0 = new Node(0, "localhost", 8121);
+ nodes.put(0, node0);
+ Cluster cluster = new Cluster("mockClusterId", nodes.values(),
+ singletonList(new PartitionInfo("foo", 0, node0, new Node[]{node0}, new Node[]{node0})),
+ Collections.emptySet(), Collections.emptySet(),
+ Collections.emptySet(), nodes.get(0));
- try (AdminClientUnitTestEnv env = mockClientEnv(time,
- AdminClientConfig.DEFAULT_API_TIMEOUT_MS_CONFIG, String.valueOf(defaultApiTimeout))) {
+ final int requestTimeoutMs = 1000;
+ final int retryBackoffMs = 100;
+ final int apiTimeoutMs = 3000;
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time, cluster,
+ AdminClientConfig.RETRY_BACKOFF_MS_CONFIG, String.valueOf(retryBackoffMs),
+ AdminClientConfig.RETRY_BACKOFF_MAX_MS_CONFIG, String.valueOf(retryBackoffMs),
+ AdminClientConfig.REQUEST_TIMEOUT_MS_CONFIG, String.valueOf(requestTimeoutMs))) {
env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
- env.kafkaClient().prepareResponse(
- expectDeleteTopicsRequestWithTopics("topic1", "topic2", "topic3"),
- prepareDeleteTopicsResponse(1000,
- deletableTopicResult("topic1", Errors.NONE),
- deletableTopicResult("topic2", Errors.THROTTLING_QUOTA_EXCEEDED),
- deletableTopicResult("topic3", Errors.TOPIC_ALREADY_EXISTS)));
-
- env.kafkaClient().prepareResponse(
- expectDeleteTopicsRequestWithTopics("topic2"),
- prepareDeleteTopicsResponse(1000,
- deletableTopicResult("topic2", Errors.THROTTLING_QUOTA_EXCEEDED)));
-
- DeleteTopicsResult result = env.adminClient().deleteTopics(
- asList("topic1", "topic2", "topic3"),
- new DeleteTopicsOptions().retryOnQuotaViolation(true));
-
- // Wait until the prepared attempts have consumed
- TestUtils.waitForCondition(() -> env.kafkaClient().numAwaitingResponses() == 0,
- "Failed awaiting DeleteTopics requests");
-
- // Wait until the next request is sent out
- TestUtils.waitForCondition(() -> env.kafkaClient().inFlightRequestCount() == 1,
- "Failed awaiting next DeleteTopics request");
-
- // Advance time past the default api timeout to time out the inflight request
- time.sleep(defaultApiTimeout + 1);
-
- assertNull(result.topicNameValues().get("topic1").get());
- ThrottlingQuotaExceededException e = TestUtils.assertFutureThrows(ThrottlingQuotaExceededException.class, result.topicNameValues().get("topic2"));
- assertEquals(0, e.throttleTimeMs());
- TestUtils.assertFutureThrows(TopicExistsException.class, result.topicNameValues().get("topic3"));
-
- // With topic IDs
- Uuid topicId1 = Uuid.randomUuid();
- Uuid topicId2 = Uuid.randomUuid();
- Uuid topicId3 = Uuid.randomUuid();
- env.kafkaClient().prepareResponse(
- expectDeleteTopicsRequestWithTopicIds(topicId1, topicId2, topicId3),
- prepareDeleteTopicsResponse(1000,
- deletableTopicResultWithId(topicId1, Errors.NONE),
- deletableTopicResultWithId(topicId2, Errors.THROTTLING_QUOTA_EXCEEDED),
- deletableTopicResultWithId(topicId3, Errors.UNKNOWN_TOPIC_ID)));
-
- env.kafkaClient().prepareResponse(
- expectDeleteTopicsRequestWithTopicIds(topicId2),
- prepareDeleteTopicsResponse(1000,
- deletableTopicResultWithId(topicId2, Errors.THROTTLING_QUOTA_EXCEEDED)));
-
- DeleteTopicsResult resultIds = env.adminClient().deleteTopics(
- TopicCollection.ofTopicIds(asList(topicId1, topicId2, topicId3)),
- new DeleteTopicsOptions().retryOnQuotaViolation(true));
+ final ListTopicsResult result = env.adminClient()
+ .listTopics(new ListTopicsOptions().timeoutMs(apiTimeoutMs));
- // Wait until the prepared attempts have consumed
- TestUtils.waitForCondition(() -> env.kafkaClient().numAwaitingResponses() == 0,
- "Failed awaiting DeleteTopics requests");
+ // Wait until the first attempt has been sent, then advance the time
+ TestUtils.waitForCondition(() -> env.kafkaClient().hasInFlightRequests(),
+ "Timed out waiting for Metadata request to be sent");
+ time.sleep(requestTimeoutMs + 1);
- // Wait until the next request is sent out
- TestUtils.waitForCondition(() -> env.kafkaClient().inFlightRequestCount() == 1,
- "Failed awaiting next DeleteTopics request");
+ // Wait for the request to be timed out before backing off
+ TestUtils.waitForCondition(() -> !env.kafkaClient().hasInFlightRequests(),
+ "Timed out waiting for inFlightRequests to be timed out");
+ time.sleep(retryBackoffMs + 1);
- // Advance time past the default api timeout to time out the inflight request
- time.sleep(defaultApiTimeout + 1);
+ // Since api timeout bound is not hit, AdminClient should retry
+ TestUtils.waitForCondition(() -> env.kafkaClient().hasInFlightRequests(),
+ "Failed to retry Metadata request");
+ env.kafkaClient().respond(prepareMetadataResponse(cluster, Errors.NONE));
- assertNull(resultIds.topicIdValues().get(topicId1).get());
- e = TestUtils.assertFutureThrows(ThrottlingQuotaExceededException.class, resultIds.topicIdValues().get(topicId2));
- assertEquals(0, e.throttleTimeMs());
- TestUtils.assertFutureThrows(UnknownTopicIdException.class, resultIds.topicIdValues().get(topicId3));
+ assertEquals(1, result.listings().get().size());
+ assertEquals("foo", result.listings().get().iterator().next().name());
}
}
@Test
- public void testDeleteTopicsDontRetryThrottlingExceptionWhenDisabled() throws Exception {
- try (AdminClientUnitTestEnv env = mockClientEnv()) {
- env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
-
- env.kafkaClient().prepareResponse(
- expectDeleteTopicsRequestWithTopics("topic1", "topic2", "topic3"),
- prepareDeleteTopicsResponse(1000,
- deletableTopicResult("topic1", Errors.NONE),
- deletableTopicResult("topic2", Errors.THROTTLING_QUOTA_EXCEEDED),
- deletableTopicResult("topic3", Errors.TOPIC_ALREADY_EXISTS)));
-
- DeleteTopicsResult result = env.adminClient().deleteTopics(
- asList("topic1", "topic2", "topic3"),
- new DeleteTopicsOptions().retryOnQuotaViolation(false));
-
- assertNull(result.topicNameValues().get("topic1").get());
- ThrottlingQuotaExceededException e = TestUtils.assertFutureThrows(ThrottlingQuotaExceededException.class, result.topicNameValues().get("topic2"));
- assertEquals(1000, e.throttleTimeMs());
- TestUtils.assertFutureThrows(TopicExistsException.class, result.topicNameValues().get("topic3"));
-
- // With topic IDs
- Uuid topicId1 = Uuid.randomUuid();
- Uuid topicId2 = Uuid.randomUuid();
- Uuid topicId3 = Uuid.randomUuid();
- env.kafkaClient().prepareResponse(
- expectDeleteTopicsRequestWithTopicIds(topicId1, topicId2, topicId3),
- prepareDeleteTopicsResponse(1000,
- deletableTopicResultWithId(topicId1, Errors.NONE),
- deletableTopicResultWithId(topicId2, Errors.THROTTLING_QUOTA_EXCEEDED),
- deletableTopicResultWithId(topicId3, Errors.UNKNOWN_TOPIC_ID)));
-
- DeleteTopicsResult resultIds = env.adminClient().deleteTopics(
- TopicCollection.ofTopicIds(asList(topicId1, topicId2, topicId3)),
- new DeleteTopicsOptions().retryOnQuotaViolation(false));
-
- assertNull(resultIds.topicIdValues().get(topicId1).get());
- e = TestUtils.assertFutureThrows(ThrottlingQuotaExceededException.class, resultIds.topicIdValues().get(topicId2));
- assertEquals(1000, e.throttleTimeMs());
- TestUtils.assertFutureThrows(UnknownTopicIdException.class, resultIds.topicIdValues().get(topicId3));
- }
- }
-
- private MockClient.RequestMatcher expectDeleteTopicsRequestWithTopics(final String... topics) {
- return body -> {
- if (body instanceof DeleteTopicsRequest) {
- DeleteTopicsRequest request = (DeleteTopicsRequest) body;
- return request.topicNames().equals(asList(topics));
- }
- return false;
- };
+ public void testDefaultApiTimeout() throws Exception {
+ testApiTimeout(1500, 3000, OptionalInt.empty());
}
- private MockClient.RequestMatcher expectDeleteTopicsRequestWithTopicIds(final Uuid... topicIds) {
- return body -> {
- if (body instanceof DeleteTopicsRequest) {
- DeleteTopicsRequest request = (DeleteTopicsRequest) body;
- return request.topicIds().equals(asList(topicIds));
- }
- return false;
- };
+ @Test
+ public void testDefaultApiTimeoutOverride() throws Exception {
+ testApiTimeout(1500, 10000, OptionalInt.of(3000));
}
@Test
- public void testInvalidTopicNames() throws Exception {
- try (AdminClientUnitTestEnv env = mockClientEnv()) {
+ public void testRequestTimeoutExceedingDefaultApiTimeout() throws Exception {
+ HashMap<Integer, Node> nodes = new HashMap<>();
+ MockTime time = new MockTime();
+ Node node0 = new Node(0, "localhost", 8121);
+ nodes.put(0, node0);
+ Cluster cluster = new Cluster("mockClusterId", nodes.values(),
+ singletonList(new PartitionInfo("foo", 0, node0, new Node[]{node0}, new Node[]{node0})),
+ Collections.emptySet(), Collections.emptySet(),
+ Collections.emptySet(), nodes.get(0));
+
+ // This test assumes the default api timeout value of 60000. When the request timeout
+ // is set to something larger, we should adjust the api timeout accordingly for compatibility.
+
+ final int retryBackoffMs = 100;
+ final int requestTimeoutMs = 120000;
+
+ try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time, cluster,
+ AdminClientConfig.RETRY_BACKOFF_MS_CONFIG, String.valueOf(retryBackoffMs),
+ AdminClientConfig.REQUEST_TIMEOUT_MS_CONFIG, String.valueOf(requestTimeoutMs))) {
env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
- List<String> sillyTopicNames = asList("", null);
- Map<String, KafkaFuture<Void>> deleteFutures = env.adminClient().deleteTopics(sillyTopicNames).topicNameValues();
- for (String sillyTopicName : sillyTopicNames) {
- TestUtils.assertFutureThrows(InvalidTopicException.class, deleteFutures.get(sillyTopicName));
- }
- assertEquals(0, env.kafkaClient().inFlightRequestCount());
+ ListTopicsOptions options = new ListTopicsOptions();
- Map<String, KafkaFuture<TopicDescription>> describeFutures =
- env.adminClient().describeTopics(sillyTopicNames).topicNameValues();
- for (String sillyTopicName : sillyTopicNames) {
- TestUtils.assertFutureThrows(InvalidTopicException.class, describeFutures.get(sillyTopicName));
- }
- assertEquals(0, env.kafkaClient().inFlightRequestCount());
+ final ListTopicsResult result = env.adminClient().listTopics(options);
- List<NewTopic> newTopics = new ArrayList<>();
- for (String sillyTopicName : sillyTopicNames) {
- newTopics.add(new NewTopic(sillyTopicName, 1, (short) 1));
- }
+ // Wait until the first attempt has been sent, then advance the time by the default api timeout
+ TestUtils.waitForCondition(() -> env.kafkaClient().hasInFlightRequests(),
+ "Timed out waiting for Metadata request to be sent");
+ time.sleep(60001);
- Map<String, KafkaFuture<Void>> createFutures = env.adminClient().createTopics(newTopics).values();
- for (String sillyTopicName : sillyTopicNames) {
- TestUtils.assertFutureThrows(InvalidTopicException.class, createFutures.get(sillyTopicName));
- }
- assertEquals(0, env.kafkaClient().inFlightRequestCount());
+ // The in-flight request should not be cancelled
+ assertTrue(env.kafkaClient().hasInFlightRequests());
+
+ // Now sleep the remaining time for the request timeout to expire
+ time.sleep(60000);
+ TestUtils.assertFutureThrows(TimeoutException.class, result.future);
}
}
- @SuppressWarnings("NPathComplexity")
- @Test
- public void testDescribeTopicsWithDescribeTopicPartitionsApiBasic() throws ExecutionException, InterruptedException {
- try (AdminClientUnitTestEnv env = mockClientEnv()) {
- env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
- String topicName0 = "test-0";
- String topicName1 = "test-1";
- Map<String, Uuid> topics = new HashMap<>();
- topics.put(topicName0, Uuid.randomUuid());
- topics.put(topicName1, Uuid.randomUuid());
+ private static final int UNREGISTER_NODE_ID = 1;
- env.kafkaClient().prepareResponse(
- prepareDescribeClusterResponse(0,
- env.cluster().nodes(),
- env.cluster().clusterResource().clusterId(),
- 2,
- MetadataResponse.AUTHORIZED_OPERATIONS_OMITTED,
- false)
- );
+ private static final Function<Errors, AbstractResponse> BROKER_RESPONSE_FACTORY =
+ error -> new UnregisterBrokerResponse(new UnregisterBrokerResponseData()
+ .setErrorCode(error.code())
+ .setErrorMessage(error.message()));
- DescribeTopicPartitionsResponseData dataFirstPart = new DescribeTopicPartitionsResponseData();
- addPartitionToDescribeTopicPartitionsResponse(dataFirstPart, topicName0, topics.get(topicName0), singletonList(0));
- dataFirstPart.setNextCursor(new DescribeTopicPartitionsResponseData.Cursor()
- .setTopicName(topicName0)
- .setPartitionIndex(1));
- env.kafkaClient().prepareResponse(body -> {
- DescribeTopicPartitionsRequestData request = (DescribeTopicPartitionsRequestData) body.data();
- if (request.topics().size() != 2) return false;
- if (!request.topics().get(0).name().equals(topicName0)) return false;
- if (!request.topics().get(1).name().equals(topicName1)) return false;
- return request.cursor() == null;
- }, new DescribeTopicPartitionsResponse(dataFirstPart));
-
- DescribeTopicPartitionsResponseData dataSecondPart = new DescribeTopicPartitionsResponseData();
- addPartitionToDescribeTopicPartitionsResponse(dataSecondPart, topicName0, topics.get(topicName0), singletonList(1));
- addPartitionToDescribeTopicPartitionsResponse(dataSecondPart, topicName1, topics.get(topicName1), singletonList(0));
- env.kafkaClient().prepareResponse(body -> {
- DescribeTopicPartitionsRequestData request = (DescribeTopicPartitionsRequestData) body.data();
- if (request.topics().size() != 2) return false;
- if (!request.topics().get(0).name().equals(topicName0)) return false;
- if (!request.topics().get(1).name().equals(topicName1)) return false;
-
- DescribeTopicPartitionsRequestData.Cursor cursor = request.cursor();
- return cursor != null && cursor.topicName() == topicName0 && cursor.partitionIndex() == 1;
- }, new DescribeTopicPartitionsResponse(dataSecondPart));
-
- DescribeTopicsResult result = env.adminClient().describeTopics(
- asList(topicName0, topicName1), new DescribeTopicsOptions()
- );
- Map<String, TopicDescription> topicDescriptions = result.allTopicNames().get();
- assertEquals(2, topicDescriptions.size());
- TopicDescription topicDescription = topicDescriptions.get(topicName0);
- assertEquals(2, topicDescription.partitions().size());
- assertEquals(0, topicDescription.partitions().get(0).partition());
- assertEquals(1, topicDescription.partitions().get(1).partition());
- topicDescription = topicDescriptions.get(topicName1);
- assertEquals(1, topicDescription.partitions().size());
- assertNull(topicDescription.authorizedOperations());
+ private static final Function<Errors, AbstractResponse> CONTROLLER_RESPONSE_FACTORY =
+ error -> new UnregisterControllerResponse(new UnregisterControllerResponseData()
+ .setErrorCode(error.code())
+ .setErrorMessage(error.message()));
+
+ private static final Function<Admin, KafkaFuture<Void>> UNREGISTER_BROKER_CALL =
+ admin -> admin.unregisterBroker(UNREGISTER_NODE_ID).all();
+
+ private static final Function<Admin, KafkaFuture<Void>> UNREGISTER_CONTROLLER_CALL =
+ admin -> admin.unregisterController(UNREGISTER_NODE_ID).all();
+
+ private void runUnregisterScenario(
+ AdminClientUnitTestEnv env,
+ ApiKeys apiKey,
+ Function<Errors, AbstractResponse> responseFactory,
+ Function<Admin, KafkaFuture<Void>> adminCall,
+ List<Errors> responsesToPrepare,
+ Class<? extends Throwable> expectedException
+ ) throws ExecutionException, InterruptedException {
+ env.kafkaClient().setNodeApiVersions(
+ NodeApiVersions.create(apiKey.id, (short) 0, (short) 0));
+ for (Errors error : responsesToPrepare) {
+ env.kafkaClient().prepareResponse(responseFactory.apply(error));
+ }
+ KafkaFuture<Void> future = adminCall.apply(env.adminClient());
+ assertNotNull(future);
+ if (expectedException == null) {
+ future.get();
+ } else {
+ TestUtils.assertFutureThrows(expectedException, future);
}
}
@Test
- public void testDescribeTopicPartitionsApiWithAuthorizedOps() throws ExecutionException, InterruptedException {
+ public void testUnregisterBrokerSuccess() throws InterruptedException, ExecutionException {
try (AdminClientUnitTestEnv env = mockClientEnv()) {
- env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
- String topicName0 = "test-0";
- Uuid topicId = Uuid.randomUuid();
-
- int authorisedOperations = Utils.to32BitField(Set.of(AclOperation.DESCRIBE.code(), AclOperation.ALTER.code()));
- env.kafkaClient().prepareResponse(
- prepareDescribeClusterResponse(0,
- env.cluster().nodes(),
- env.cluster().clusterResource().clusterId(),
- 2,
- authorisedOperations,
- false)
- );
-
- DescribeTopicPartitionsResponseData responseData = new DescribeTopicPartitionsResponseData();
- responseData.topics().add(new DescribeTopicPartitionsResponseTopic()
- .setErrorCode((short) 0)
- .setTopicId(topicId)
- .setName(topicName0)
- .setIsInternal(false)
- .setTopicAuthorizedOperations(authorisedOperations));
- env.kafkaClient().prepareResponse(new DescribeTopicPartitionsResponse(responseData));
-
- DescribeTopicsResult result = env.adminClient().describeTopics(
- singletonList(topicName0), new DescribeTopicsOptions().includeAuthorizedOperations(true)
- );
-
- Map<String, TopicDescription> topicDescriptions = result.allTopicNames().get();
- TopicDescription topicDescription = topicDescriptions.get(topicName0);
- assertEquals(Set.of(AclOperation.DESCRIBE, AclOperation.ALTER),
- topicDescription.authorizedOperations());
+ runUnregisterScenario(env, ApiKeys.UNREGISTER_BROKER, BROKER_RESPONSE_FACTORY,
+ UNREGISTER_BROKER_CALL, List.of(Errors.NONE), null);
}
}
@Test
- public void testDescribeTopicPartitionsApiWithoutAuthorizedOps() throws ExecutionException, InterruptedException {
+ public void testUnregisterBrokerFailure() throws ExecutionException, InterruptedException {
try (AdminClientUnitTestEnv env = mockClientEnv()) {
- env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
- String topicName0 = "test-0";
- Uuid topicId = Uuid.randomUuid();
-
- int authorisedOperations = Utils.to32BitField(Set.of(AclOperation.DESCRIBE.code(), AclOperation.ALTER.code()));
- env.kafkaClient().prepareResponse(
- prepareDescribeClusterResponse(0,
- env.cluster().nodes(),
- env.cluster().clusterResource().clusterId(),
- 2,
- authorisedOperations,
- false)
- );
-
- DescribeTopicPartitionsResponseData responseData = new DescribeTopicPartitionsResponseData();
- responseData.topics().add(new DescribeTopicPartitionsResponseTopic()
- .setErrorCode((short) 0)
- .setTopicId(topicId)
- .setName(topicName0)
- .setIsInternal(false)
- .setTopicAuthorizedOperations(authorisedOperations));
- env.kafkaClient().prepareResponse(new DescribeTopicPartitionsResponse(responseData));
-
- DescribeTopicsResult result = env.adminClient().describeTopics(
- singletonList(topicName0), new DescribeTopicsOptions().includeAuthorizedOperations(false)
- );
-
- Map<String, TopicDescription> topicDescriptions = result.allTopicNames().get();
- TopicDescription topicDescription = topicDescriptions.get(topicName0);
- assertNull(topicDescription.authorizedOperations());
+ runUnregisterScenario(env, ApiKeys.UNREGISTER_BROKER, BROKER_RESPONSE_FACTORY,
+ UNREGISTER_BROKER_CALL, List.of(Errors.UNKNOWN_SERVER_ERROR), UnknownServerException.class);
}
}
- @SuppressWarnings({"NPathComplexity", "CyclomaticComplexity"})
@Test
- public void testDescribeTopicsWithDescribeTopicPartitionsApiEdgeCase() throws ExecutionException, InterruptedException {
+ public void testUnregisterBrokerTimeoutAndSuccessRetry() throws ExecutionException, InterruptedException {
try (AdminClientUnitTestEnv env = mockClientEnv()) {
- env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
- String topicName0 = "test-0";
- String topicName1 = "test-1";
- String topicName2 = "test-2";
- Map<String, Uuid> topics = new HashMap<>();
- topics.put(topicName0, Uuid.randomUuid());
- topics.put(topicName1, Uuid.randomUuid());
- topics.put(topicName2, Uuid.randomUuid());
-
- env.kafkaClient().prepareResponse(
- prepareDescribeClusterResponse(0,
- env.cluster().nodes(),
- env.cluster().clusterResource().clusterId(),
- 2,
- MetadataResponse.AUTHORIZED_OPERATIONS_OMITTED,
- false)
- );
+ runUnregisterScenario(env, ApiKeys.UNREGISTER_BROKER, BROKER_RESPONSE_FACTORY,
+ UNREGISTER_BROKER_CALL, List.of(Errors.REQUEST_TIMED_OUT, Errors.NONE), null);
+ }
+ }
- DescribeTopicPartitionsResponseData dataFirstPart = new DescribeTopicPartitionsResponseData();
- addPartitionToDescribeTopicPartitionsResponse(dataFirstPart, topicName0, topics.get(topicName0), singletonList(0));
- addPartitionToDescribeTopicPartitionsResponse(dataFirstPart, topicName1, topics.get(topicName1), singletonList(0));
- dataFirstPart.setNextCursor(new DescribeTopicPartitionsResponseData.Cursor()
- .setTopicName(topicName1)
- .setPartitionIndex(1));
- env.kafkaClient().prepareResponse(body -> {
- DescribeTopicPartitionsRequestData request = (DescribeTopicPartitionsRequestData) body.data();
- if (request.topics().size() != 3) return false;
- if (!request.topics().get(0).name().equals(topicName0)) return false;
- if (!request.topics().get(1).name().equals(topicName1)) return false;
- if (!request.topics().get(2).name().equals(topicName2)) return false;
- return request.cursor() == null;
- }, new DescribeTopicPartitionsResponse(dataFirstPart));
-
- DescribeTopicPartitionsResponseData dataSecondPart = new DescribeTopicPartitionsResponseData();
- addPartitionToDescribeTopicPartitionsResponse(dataSecondPart, topicName1, topics.get(topicName1), singletonList(1));
- addPartitionToDescribeTopicPartitionsResponse(dataSecondPart, topicName2, topics.get(topicName2), singletonList(0));
- dataSecondPart.setNextCursor(new DescribeTopicPartitionsResponseData.Cursor()
- .setTopicName(topicName2)
- .setPartitionIndex(1));
- env.kafkaClient().prepareResponse(body -> {
- DescribeTopicPartitionsRequestData request = (DescribeTopicPartitionsRequestData) body.data();
- if (request.topics().size() != 2) return false;
- if (!request.topics().get(0).name().equals(topicName1)) return false;
- if (!request.topics().get(1).name().equals(topicName2)) return false;
- DescribeTopicPartitionsRequestData.Cursor cursor = request.cursor();
- return cursor != null && cursor.topicName().equals(topicName1) && cursor.partitionIndex() == 1;
- }, new DescribeTopicPartitionsResponse(dataSecondPart));
-
- DescribeTopicPartitionsResponseData dataThirdPart = new DescribeTopicPartitionsResponseData();
- addPartitionToDescribeTopicPartitionsResponse(dataThirdPart, topicName2, topics.get(topicName2), singletonList(1));
- env.kafkaClient().prepareResponse(body -> {
- DescribeTopicPartitionsRequestData request = (DescribeTopicPartitionsRequestData) body.data();
- if (request.topics().size() != 1) return false;
- if (!request.topics().get(0).name().equals(topicName2)) return false;
- DescribeTopicPartitionsRequestData.Cursor cursor = request.cursor();
- return cursor != null && cursor.topicName().equals(topicName2) && cursor.partitionIndex() == 1;
- }, new DescribeTopicPartitionsResponse(dataThirdPart));
-
- DescribeTopicsResult result = env.adminClient().describeTopics(
- asList(topicName1, topicName0, topicName2), new DescribeTopicsOptions()
- );
- Map<String, TopicDescription> topicDescriptions = result.allTopicNames().get();
- assertEquals(3, topicDescriptions.size());
- TopicDescription topicDescription = topicDescriptions.get(topicName0);
- assertEquals(1, topicDescription.partitions().size());
- assertEquals(0, topicDescription.partitions().get(0).partition());
- topicDescription = topicDescriptions.get(topicName1);
- assertEquals(2, topicDescription.partitions().size());
- topicDescription = topicDescriptions.get(topicName2);
- assertEquals(2, topicDescription.partitions().size());
- assertNull(topicDescription.authorizedOperations());
+ @Test
+ public void testUnregisterBrokerTimeoutAndFailureRetry() throws ExecutionException, InterruptedException {
+ try (AdminClientUnitTestEnv env = mockClientEnv()) {
+ runUnregisterScenario(env, ApiKeys.UNREGISTER_BROKER, BROKER_RESPONSE_FACTORY,
+ UNREGISTER_BROKER_CALL, List.of(Errors.REQUEST_TIMED_OUT, Errors.UNKNOWN_SERVER_ERROR),
+ UnknownServerException.class);
}
}
- private void addPartitionToDescribeTopicPartitionsResponse(
- DescribeTopicPartitionsResponseData data,
- String topicName,
- Uuid topicId,
- List<Integer> partitions) {
- List<DescribeTopicPartitionsResponsePartition> addingPartitions = new ArrayList<>();
- partitions.forEach(partition ->
- addingPartitions.add(new DescribeTopicPartitionsResponsePartition()
- .setIsrNodes(singletonList(0))
- .setErrorCode((short) 0)
- .setLeaderEpoch(0)
- .setLeaderId(0)
- .setEligibleLeaderReplicas(singletonList(1))
- .setLastKnownElr(singletonList(2))
- .setPartitionIndex(partition)
- .setReplicaNodes(asList(0, 1, 2)))
- );
- data.topics().add(new DescribeTopicPartitionsResponseTopic()
- .setErrorCode((short) 0)
- .setTopicId(topicId)
- .setName(topicName)
- .setIsInternal(false)
- .setPartitions(addingPartitions));
+ @Test
+ public void testUnregisterBrokerTimeoutMaxRetry() throws ExecutionException, InterruptedException {
+ try (AdminClientUnitTestEnv env = mockClientEnv(Time.SYSTEM, AdminClientConfig.RETRIES_CONFIG, "1")) {
+ runUnregisterScenario(env, ApiKeys.UNREGISTER_BROKER, BROKER_RESPONSE_FACTORY,
+ UNREGISTER_BROKER_CALL, List.of(Errors.REQUEST_TIMED_OUT, Errors.REQUEST_TIMED_OUT),
+ TimeoutException.class);
+ }
}
- @SuppressWarnings("NPathComplexity")
@Test
- public void testDescribeTopicsWithDescribeTopicPartitionsApiErrorHandling() throws InterruptedException {
+ public void testUnregisterBrokerTimeoutMaxWait() throws ExecutionException, InterruptedException {
try (AdminClientUnitTestEnv env = mockClientEnv()) {
- env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
- String topicName0 = "test-0";
- String topicName1 = "test-1";
- Map<String, Uuid> topics = new HashMap<>();
- topics.put(topicName0, Uuid.randomUuid());
- topics.put(topicName1, Uuid.randomUuid());
-
- env.kafkaClient().prepareResponse(
- prepareDescribeClusterResponse(0,
- env.cluster().nodes(),
- env.cluster().clusterResource().clusterId(),
- 2,
- MetadataResponse.AUTHORIZED_OPERATIONS_OMITTED,
- false)
- );
-
- DescribeTopicPartitionsResponseData dataFirstPart = new DescribeTopicPartitionsResponseData();
- dataFirstPart.topics().add(new DescribeTopicPartitionsResponseTopic()
- .setErrorCode((short) 0)
- .setTopicId(topics.get(topicName0))
- .setName(topicName0)
- .setIsInternal(false)
- .setPartitions(singletonList(new DescribeTopicPartitionsResponsePartition()
- .setIsrNodes(singletonList(0))
- .setErrorCode((short) 0)
- .setLeaderEpoch(0)
- .setLeaderId(0)
- .setEligibleLeaderReplicas(singletonList(1))
- .setLastKnownElr(singletonList(2))
- .setPartitionIndex(0)
- .setReplicaNodes(asList(0, 1, 2))))
- );
- dataFirstPart.topics().add(new DescribeTopicPartitionsResponseTopic()
- .setErrorCode((short) 29)
- .setTopicId(Uuid.ZERO_UUID)
- .setName(topicName1)
- .setIsInternal(false)
- );
- env.kafkaClient().prepareResponse(body -> {
- DescribeTopicPartitionsRequestData request = (DescribeTopicPartitionsRequestData) body.data();
- if (request.topics().size() != 2) return false;
- if (!request.topics().get(0).name().equals(topicName0)) return false;
- if (!request.topics().get(1).name().equals(topicName1)) return false;
- return request.cursor() == null;
- }, new DescribeTopicPartitionsResponse(dataFirstPart));
- DescribeTopicsResult result = env.adminClient().describeTopics(
- asList(topicName1, topicName0), new DescribeTopicsOptions()
- );
+ runUnregisterScenario(env, ApiKeys.UNREGISTER_BROKER, BROKER_RESPONSE_FACTORY,
+ admin -> admin.unregisterBroker(UNREGISTER_NODE_ID,
+ new UnregisterBrokerOptions().timeoutMs(10)).all(),
+ List.of(), TimeoutException.class);
+ }
+ }
- TestUtils.assertFutureThrows(TopicAuthorizationException.class, result.allTopicNames());
+ @Test
+ public void testUnregisterControllerSuccess() throws InterruptedException, ExecutionException {
+ try (AdminClientUnitTestEnv env = mockClientEnv()) {
+ runUnregisterScenario(env, ApiKeys.UNREGISTER_CONTROLLER, CONTROLLER_RESPONSE_FACTORY,
+ UNREGISTER_CONTROLLER_CALL, List.of(Errors.NONE), null);
+ }
+ }
+ @Test
+ public void testUnregisterControllerFailure() throws ExecutionException, InterruptedException {
+ try (AdminClientUnitTestEnv env = mockClientEnv()) {
+ runUnregisterScenario(env, ApiKeys.UNREGISTER_CONTROLLER, CONTROLLER_RESPONSE_FACTORY,
+ UNREGISTER_CONTROLLER_CALL, List.of(Errors.UNKNOWN_SERVER_ERROR), UnknownServerException.class);
}
}
@Test
- public void testAdminClientApisAuthenticationFailure() {
- Cluster cluster = mockBootstrapCluster();
- try (final AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(Time.SYSTEM, cluster,
- newStrMap(AdminClientConfig.REQUEST_TIMEOUT_MS_CONFIG, "1000",
- // Default "metadata.recovery.strategy" is rebootstrap. If it meets "retry.backoff.ms" (default is 100L),
- // following assertion will fail. Set it to none to avoid authentication error cleanup.
- AdminClientConfig.METADATA_RECOVERY_STRATEGY_CONFIG, "none"))) {
- env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
- env.kafkaClient().createPendingAuthenticationError(cluster.nodes().get(0),
- TimeUnit.DAYS.toMillis(1));
- callAdminClientApisAndExpectAnAuthenticationError(env);
- callClientQuotasApisAndExpectAnAuthenticationError(env);
+ public void testUnregisterControllerTimeoutAndSuccessRetry() throws ExecutionException, InterruptedException {
+ try (AdminClientUnitTestEnv env = mockClientEnv()) {
+ runUnregisterScenario(env, ApiKeys.UNREGISTER_CONTROLLER, CONTROLLER_RESPONSE_FACTORY,
+ UNREGISTER_CONTROLLER_CALL, List.of(Errors.REQUEST_TIMED_OUT, Errors.NONE), null);
}
}
- private void callAdminClientApisAndExpectAnAuthenticationError(AdminClientUnitTestEnv env) {
- ExecutionException e = assertThrows(ExecutionException.class, () -> env.adminClient().createTopics(
- singleton(new NewTopic("myTopic", Collections.singletonMap(0, asList(0, 1, 2)))),
- new CreateTopicsOptions().timeoutMs(10000)).all().get());
- assertInstanceOf(AuthenticationException.class, e.getCause(),
- "Expected an authentication error, but got " + Utils.stackTrace(e));
-
- Map<String, NewPartitions> counts = new HashMap<>();
- counts.put("my_topic", NewPartitions.increaseTo(3));
- counts.put("other_topic", NewPartitions.increaseTo(3, asList(singletonList(2), singletonList(3))));
- e = assertThrows(ExecutionException.class, () -> env.adminClient().createPartitions(counts).all().get());
- assertInstanceOf(AuthenticationException.class, e.getCause(),
- "Expected an authentication error, but got " + Utils.stackTrace(e));
-
- e = assertThrows(ExecutionException.class, () -> env.adminClient().createAcls(asList(ACL1, ACL2)).all().get());
- assertInstanceOf(AuthenticationException.class, e.getCause(),
- "Expected an authentication error, but got " + Utils.stackTrace(e));
-
- e = assertThrows(ExecutionException.class, () -> env.adminClient().describeAcls(FILTER1).values().get());
- assertInstanceOf(AuthenticationException.class, e.getCause(),
- "Expected an authentication error, but got " + Utils.stackTrace(e));
-
- e = assertThrows(ExecutionException.class, () -> env.adminClient().deleteAcls(asList(FILTER1, FILTER2)).all().get());
- assertInstanceOf(AuthenticationException.class, e.getCause(),
- "Expected an authentication error, but got " + Utils.stackTrace(e));
-
- e = assertThrows(ExecutionException.class, () -> env.adminClient().describeConfigs(
- singleton(new ConfigResource(ConfigResource.Type.BROKER, "0"))).all().get());
- assertInstanceOf(AuthenticationException.class, e.getCause(),
- "Expected an authentication error, but got " + Utils.stackTrace(e));
+ @Test
+ public void testUnregisterControllerTimeoutAndFailureRetry() throws ExecutionException, InterruptedException {
+ try (AdminClientUnitTestEnv env = mockClientEnv()) {
+ runUnregisterScenario(env, ApiKeys.UNREGISTER_CONTROLLER, CONTROLLER_RESPONSE_FACTORY,
+ UNREGISTER_CONTROLLER_CALL, List.of(Errors.REQUEST_TIMED_OUT, Errors.UNKNOWN_SERVER_ERROR),
+ UnknownServerException.class);
+ }
}
- private void callClientQuotasApisAndExpectAnAuthenticationError(AdminClientUnitTestEnv env) {
- ExecutionException e = assertThrows(ExecutionException.class,
- () -> env.adminClient().describeClientQuotas(ClientQuotaFilter.all()).entities().get());
- assertInstanceOf(AuthenticationException.class, e.getCause(),
- "Expected an authentication error, but got " + Utils.stackTrace(e));
-
- ClientQuotaEntity entity = new ClientQuotaEntity(Collections.singletonMap(ClientQuotaEntity.USER, "user"));
- ClientQuotaAlteration alteration = new ClientQuotaAlteration(entity, singletonList(new ClientQuotaAlteration.Op("consumer_byte_rate", 1000.0)));
- e = assertThrows(ExecutionException.class,
- () -> env.adminClient().alterClientQuotas(singletonList(alteration)).all().get());
-
- assertInstanceOf(AuthenticationException.class, e.getCause(),
- "Expected an authentication error, but got " + Utils.stackTrace(e));
+ @Test
+ public void testUnregisterControllerTimeoutMaxRetry() throws ExecutionException, InterruptedException {
+ try (AdminClientUnitTestEnv env = mockClientEnv(Time.SYSTEM, AdminClientConfig.RETRIES_CONFIG, "1")) {
+ runUnregisterScenario(env, ApiKeys.UNREGISTER_CONTROLLER, CONTROLLER_RESPONSE_FACTORY,
+ UNREGISTER_CONTROLLER_CALL, List.of(Errors.REQUEST_TIMED_OUT, Errors.REQUEST_TIMED_OUT),
+ TimeoutException.class);
+ }
}
- private static final AclBinding ACL1 = new AclBinding(new ResourcePattern(ResourceType.TOPIC, "mytopic3", PatternType.LITERAL),
- new AccessControlEntry("User:ANONYMOUS", "*", AclOperation.DESCRIBE, AclPermissionType.ALLOW));
- private static final AclBinding ACL2 = new AclBinding(new ResourcePattern(ResourceType.TOPIC, "mytopic4", PatternType.LITERAL),
- new AccessControlEntry("User:ANONYMOUS", "*", AclOperation.DESCRIBE, AclPermissionType.DENY));
- private static final AclBindingFilter FILTER1 = new AclBindingFilter(new ResourcePatternFilter(ResourceType.ANY, null, PatternType.LITERAL),
- new AccessControlEntryFilter("User:ANONYMOUS", null, AclOperation.ANY, AclPermissionType.ANY));
- private static final AclBindingFilter FILTER2 = new AclBindingFilter(new ResourcePatternFilter(ResourceType.ANY, null, PatternType.LITERAL),
- new AccessControlEntryFilter("User:bob", null, AclOperation.ANY, AclPermissionType.ANY));
- private static final AclBindingFilter UNKNOWN_FILTER = new AclBindingFilter(
- new ResourcePatternFilter(ResourceType.UNKNOWN, null, PatternType.LITERAL),
- new AccessControlEntryFilter("User:bob", null, AclOperation.ANY, AclPermissionType.ANY));
-
@Test
- public void testDescribeAcls() throws Exception {
+ public void testUnregisterControllerTimeoutMaxWait() throws ExecutionException, InterruptedException {
try (AdminClientUnitTestEnv env = mockClientEnv()) {
- env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
-
- // Test a call where we get back ACL1 and ACL2.
- env.kafkaClient().prepareResponse(new DescribeAclsResponse(new DescribeAclsResponseData()
- .setResources(DescribeAclsResponse.aclsResources(asList(ACL1, ACL2))), ApiKeys.DESCRIBE_ACLS.latestVersion()));
- assertCollectionIs(env.adminClient().describeAcls(FILTER1).values().get(), ACL1, ACL2);
-
- // Test a call where we get back no results.
- env.kafkaClient().prepareResponse(new DescribeAclsResponse(new DescribeAclsResponseData(),
- ApiKeys.DESCRIBE_ACLS.latestVersion()));
- assertTrue(env.adminClient().describeAcls(FILTER2).values().get().isEmpty());
-
- // Test a call where we get back an error.
- env.kafkaClient().prepareResponse(new DescribeAclsResponse(new DescribeAclsResponseData()
- .setErrorCode(Errors.SECURITY_DISABLED.code())
- .setErrorMessage("Security is disabled"), ApiKeys.DESCRIBE_ACLS.latestVersion()));
- TestUtils.assertFutureThrows(SecurityDisabledException.class, env.adminClient().describeAcls(FILTER2).values());
-
- // Test a call where we supply an invalid filter.
- TestUtils.assertFutureThrows(InvalidRequestException.class, env.adminClient().describeAcls(UNKNOWN_FILTER).values());
+ runUnregisterScenario(env, ApiKeys.UNREGISTER_CONTROLLER, CONTROLLER_RESPONSE_FACTORY,
+ admin -> admin.unregisterController(UNREGISTER_NODE_ID,
+ new UnregisterControllerOptions().timeoutMs(10)).all(),
+ List.of(), TimeoutException.class);
}
}
+ /**
+ * Test that if the client can obtain a node assignment, but can't send to the given
+ * node, it will disconnect and try a different node.
+ */
@Test
- public void testCreateAclsToController() throws Exception {
- try (AdminClientUnitTestEnv env = mockClientEnv(AdminClientConfig.BOOTSTRAP_CONTROLLERS_CONFIG, "dummy")) {
+ public void testClientSideTimeoutAfterFailureToSend() throws Exception {
+ Cluster cluster = mockCluster(3, 0);
+ CompletableFuture<String> disconnectFuture = new CompletableFuture<>();
+ MockTime time = new MockTime();
+ try (final AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time, cluster,
+ newStrMap(AdminClientConfig.REQUEST_TIMEOUT_MS_CONFIG, "1",
+ AdminClientConfig.DEFAULT_API_TIMEOUT_MS_CONFIG, "100000",
+ AdminClientConfig.RETRY_BACKOFF_MS_CONFIG, "1"))) {
env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+ for (Node node : cluster.nodes()) {
+ env.kafkaClient().delayReady(node, 100);
+ }
+ // We use a countdown latch to ensure that we get to the first
+ // call to `ready` before we increment the time below to trigger
+ // the disconnect.
+ CountDownLatch readyLatch = new CountDownLatch(2);
- env.kafkaClient().prepareResponse(new CreateAclsResponse(new CreateAclsResponseData().setResults(asList(
- new CreateAclsResponseData.AclCreationResult()
- .setErrorCode(Errors.NOT_CONTROLLER.code())
- .setErrorMessage("not controller")))));
- // should retry the describe cluster to update the metadata
- env.kafkaClient().prepareResponse(
- prepareDescribeClusterResponse(0,
- env.cluster().nodes(),
- env.cluster().clusterResource().clusterId(),
- 2,
- MetadataResponse.AUTHORIZED_OPERATIONS_OMITTED,
- true)
- );
-
- // Test a call where we successfully create two ACLs.
- env.kafkaClient().prepareResponse(new CreateAclsResponse(new CreateAclsResponseData().setResults(asList(
- new CreateAclsResponseData.AclCreationResult()))));
+ env.kafkaClient().setDisconnectFuture(disconnectFuture);
+ env.kafkaClient().setReadyCallback(node -> readyLatch.countDown());
+ env.kafkaClient().prepareResponse(prepareMetadataResponse(cluster, Errors.NONE));
- CreateAclsResult results = env.adminClient().createAcls(asList(ACL1));
- assertCollectionIs(results.values().keySet(), ACL1);
- for (KafkaFuture<Void> future : results.values().values())
- future.get();
- results.all().get();
- }
- }
+ final ListTopicsResult result = env.adminClient().listTopics();
- @Test
- public void testDeleteAclsToController() throws Exception {
- try (AdminClientUnitTestEnv env = mockClientEnv(AdminClientConfig.BOOTSTRAP_CONTROLLERS_CONFIG, "dummy")) {
- env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+ readyLatch.await(TestUtils.DEFAULT_MAX_WAIT_MS, TimeUnit.MILLISECONDS);
+ log.debug("Advancing clock by 25 ms to trigger client-side disconnect.");
+ time.sleep(25);
+ disconnectFuture.get();
- env.kafkaClient().prepareResponse(new DeleteAclsResponse(new DeleteAclsResponseData()
- .setThrottleTimeMs(0)
- .setFilterResults(asList(new DeleteAclsResponseData.DeleteAclsFilterResult()
- .setErrorCode(Errors.NOT_CONTROLLER.code())
- .setErrorMessage("not controller"))),
- ApiKeys.DELETE_ACLS.latestVersion()));
- // should retry the describe cluster to update the metadata
- env.kafkaClient().prepareResponse(
- prepareDescribeClusterResponse(0,
- env.cluster().nodes(),
- env.cluster().clusterResource().clusterId(),
- 2,
- MetadataResponse.AUTHORIZED_OPERATIONS_OMITTED,
- true)
- );
- // Test a call where there are no errors.
- env.kafkaClient().prepareResponse(new DeleteAclsResponse(new DeleteAclsResponseData()
- .setThrottleTimeMs(0)
- .setFilterResults(asList(
- new DeleteAclsResponseData.DeleteAclsFilterResult()
- .setMatchingAcls(singletonList(DeleteAclsResponse.matchingAcl(ACL1, ApiError.NONE))))),
- ApiKeys.DELETE_ACLS.latestVersion()));
- DeleteAclsResult results = env.adminClient().deleteAcls(asList(FILTER1));
- Collection<AclBinding> deleted = results.all().get();
- assertCollectionIs(deleted, ACL1);
+ log.debug("Enabling nodes to send requests again.");
+ for (Node node : cluster.nodes()) {
+ env.kafkaClient().delayReady(node, 0);
+ }
+ time.sleep(5);
+ log.info("Waiting for result.");
+ assertEquals(0, result.listings().get().size());
}
}
+ /**
+ * Test that if the client can send to a node, but doesn't receive a response, it will
+ * disconnect and try a different node.
+ */
@Test
- public void testCreateAcls() throws Exception {
- try (AdminClientUnitTestEnv env = mockClientEnv()) {
+ public void testClientSideTimeoutAfterFailureToReceiveResponse() throws Exception {
+ Cluster cluster = mockCluster(3, 0);
+ CompletableFuture<String> disconnectFuture = new CompletableFuture<>();
+ MockTime time = new MockTime();
+ try (final AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time, cluster,
+ newStrMap(AdminClientConfig.REQUEST_TIMEOUT_MS_CONFIG, "1",
+ AdminClientConfig.DEFAULT_API_TIMEOUT_MS_CONFIG, "100000",
+ AdminClientConfig.RETRY_BACKOFF_MS_CONFIG, "0"))) {
env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
-
- // Test a call where we successfully create two ACLs.
- env.kafkaClient().prepareResponse(new CreateAclsResponse(new CreateAclsResponseData().setResults(asList(
- new CreateAclsResponseData.AclCreationResult(),
- new CreateAclsResponseData.AclCreationResult()))));
- CreateAclsResult results = env.adminClient().createAcls(asList(ACL1, ACL2));
- assertCollectionIs(results.values().keySet(), ACL1, ACL2);
- for (KafkaFuture<Void> future : results.values().values())
- future.get();
- results.all().get();
-
- // Test a call where we fail to create one ACL.
- env.kafkaClient().prepareResponse(new CreateAclsResponse(new CreateAclsResponseData().setResults(asList(
- new CreateAclsResponseData.AclCreationResult()
- .setErrorCode(Errors.SECURITY_DISABLED.code())
- .setErrorMessage("Security is disabled"),
- new CreateAclsResponseData.AclCreationResult()))));
- results = env.adminClient().createAcls(asList(ACL1, ACL2));
- assertCollectionIs(results.values().keySet(), ACL1, ACL2);
- TestUtils.assertFutureThrows(SecurityDisabledException.class, results.values().get(ACL1));
- results.values().get(ACL2).get();
- TestUtils.assertFutureThrows(SecurityDisabledException.class, results.all());
+ env.kafkaClient().setDisconnectFuture(disconnectFuture);
+ final ListTopicsResult result = env.adminClient().listTopics();
+ TestUtils.waitForCondition(() -> {
+ time.sleep(1);
+ return disconnectFuture.isDone();
+ }, 5000, 1, () -> "Timed out waiting for expected disconnect");
+ assertFalse(disconnectFuture.isCompletedExceptionally());
+ assertFalse(result.future.isDone());
+ TestUtils.waitForCondition(env.kafkaClient()::hasInFlightRequests,
+ "Timed out waiting for retry");
+ env.kafkaClient().respond(prepareMetadataResponse(cluster, Errors.NONE));
+ assertEquals(0, result.listings().get().size());
}
}
@Test
- public void testDeleteAcls() throws Exception {
- try (AdminClientUnitTestEnv env = mockClientEnv()) {
- env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
+ public void testClientInstanceId() {
- // Test a call where one filter has an error.
- env.kafkaClient().prepareResponse(new DeleteAclsResponse(new DeleteAclsResponseData()
- .setThrottleTimeMs(0)
- .setFilterResults(asList(
- new DeleteAclsResponseData.DeleteAclsFilterResult()
- .setMatchingAcls(asList(
- DeleteAclsResponse.matchingAcl(ACL1, ApiError.NONE),
- DeleteAclsResponse.matchingAcl(ACL2, ApiError.NONE))),
- new DeleteAclsResponseData.DeleteAclsFilterResult()
- .setErrorCode(Errors.SECURITY_DISABLED.code())
- .setErrorMessage("No security"))),
- ApiKeys.DELETE_ACLS.latestVersion()));
- DeleteAclsResult results = env.adminClient().deleteAcls(asList(FILTER1, FILTER2));
- Map<AclBindingFilter, KafkaFuture<FilterResults>> filterResults = results.values();
- FilterResults filter1Results = filterResults.get(FILTER1).get();
- assertNull(filter1Results.values().get(0).exception());
- assertEquals(ACL1, filter1Results.values().get(0).binding());
- assertNull(filter1Results.values().get(1).exception());
- assertEquals(ACL2, filter1Results.values().get(1).binding());
- TestUtils.assertFutureThrows(SecurityDisabledException.class, filterResults.get(FILTER2));
- TestUtils.assertFutureThrows(SecurityDisabledException.class, results.all());
-
- // Test a call where one deletion result has an error.
- env.kafkaClient().prepareResponse(new DeleteAclsResponse(new DeleteAclsResponseData()
- .setThrottleTimeMs(0)
- .setFilterResults(asList(
- new DeleteAclsResponseData.DeleteAclsFilterResult()
- .setMatchingAcls(asList(
- DeleteAclsResponse.matchingAcl(ACL1, ApiError.NONE),
- new DeleteAclsResponseData.DeleteAclsMatchingAcl()
- .setErrorCode(Errors.SECURITY_DISABLED.code())
- .setErrorMessage("No security")
- .setPermissionType(AclPermissionType.ALLOW.code())
- .setOperation(AclOperation.ALTER.code())
- .setResourceType(ResourceType.CLUSTER.code())
- .setPatternType(FILTER2.patternFilter().patternType().code()))),
- new DeleteAclsResponseData.DeleteAclsFilterResult())),
- ApiKeys.DELETE_ACLS.latestVersion()));
- results = env.adminClient().deleteAcls(asList(FILTER1, FILTER2));
- assertTrue(results.values().get(FILTER2).get().values().isEmpty());
- TestUtils.assertFutureThrows(SecurityDisabledException.class, results.all());
-
- // Test a call where there are no errors.
- env.kafkaClient().prepareResponse(new DeleteAclsResponse(new DeleteAclsResponseData()
- .setThrottleTimeMs(0)
- .setFilterResults(asList(
- new DeleteAclsResponseData.DeleteAclsFilterResult()
- .setMatchingAcls(singletonList(DeleteAclsResponse.matchingAcl(ACL1, ApiError.NONE))),
- new DeleteAclsResponseData.DeleteAclsFilterResult()
- .setMatchingAcls(singletonList(DeleteAclsResponse.matchingAcl(ACL2, ApiError.NONE))))),
- ApiKeys.DELETE_ACLS.latestVersion()));
- results = env.adminClient().deleteAcls(asList(FILTER1, FILTER2));
- Collection<AclBinding> deleted = results.all().get();
- assertCollectionIs(deleted, ACL1, ACL2);
- }
- }
+ try (MockedStatic<CommonClientConfigs> mockedCommonClientConfigs = mockStatic(CommonClientConfigs.class, new CallsRealMethods())) {
+ ClientTelemetryReporter clientTelemetryReporter = mock(ClientTelemetryReporter.class);
+ clientTelemetryReporter.configure(any());
+ mockedCommonClientConfigs.when(() -> CommonClientConfigs.telemetryReporter(anyString(), any())).thenReturn(Optional.of(clientTelemetryReporter));
+
+ try (AdminClientUnitTestEnv env = mockClientEnv(AdminClientConfig.ENABLE_METRICS_PUSH_CONFIG, "true")) {
+ ClientTelemetrySender clientTelemetrySender = mock(ClientTelemetrySender.class);
+ Uuid expectedUuid = Uuid.randomUuid();
+ when(clientTelemetryReporter.telemetrySender()).thenReturn(clientTelemetrySender);
+ when(clientTelemetrySender.clientInstanceId(any())).thenReturn(Optional.of(expectedUuid));
- @Test
- public void testElectLeaders() throws Exception {
- TopicPartition topic1 = new TopicPartition("topic", 0);
- TopicPartition topic2 = new TopicPartition("topic", 2);
- try (AdminClientUnitTestEnv env = mockClientEnv()) {
- for (ElectionType electionType : ElectionType.values()) {
- env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
-
- // Test a call where one partition has an error.
- ApiError value = ApiError.fromThrowable(new ClusterAuthorizationException(null));
- List<ReplicaElectionResult> electionResults = new ArrayList<>();
- ReplicaElectionResult electionResult = new ReplicaElectionResult();
- electionResult.setTopic(topic1.topic());
- // Add partition 1 result
- PartitionResult partition1Result = new PartitionResult();
- partition1Result.setPartitionId(topic1.partition());
- partition1Result.setErrorCode(value.error().code());
- partition1Result.setErrorMessage(value.message());
- electionResult.partitionResult().add(partition1Result);
-
- // Add partition 2 result
- PartitionResult partition2Result = new PartitionResult();
- partition2Result.setPartitionId(topic2.partition());
- partition2Result.setErrorCode(value.error().code());
- partition2Result.setErrorMessage(value.message());
- electionResult.partitionResult().add(partition2Result);
-
- electionResults.add(electionResult);
-
- env.kafkaClient().prepareResponse(new ElectLeadersResponse(0, Errors.NONE.code(),
- electionResults, ApiKeys.ELECT_LEADERS.latestVersion()));
- ElectLeadersResult results = env.adminClient().electLeaders(
- electionType,
- Set.of(topic1, topic2));
- assertEquals(ClusterAuthorizationException.class, results.partitions().get().get(topic2).get().getClass());
-
- // Test a call where there are no errors. By mutating the internal of election results
- partition1Result.setErrorCode(ApiError.NONE.error().code());
- partition1Result.setErrorMessage(ApiError.NONE.message());
-
- partition2Result.setErrorCode(ApiError.NONE.error().code());
- partition2Result.setErrorMessage(ApiError.NONE.message());
-
- env.kafkaClient().prepareResponse(new ElectLeadersResponse(0, Errors.NONE.code(), electionResults,
- ApiKeys.ELECT_LEADERS.latestVersion()));
- results = env.adminClient().electLeaders(electionType, Set.of(topic1, topic2));
- assertFalse(results.partitions().get().get(topic1).isPresent());
- assertFalse(results.partitions().get().get(topic2).isPresent());
-
- // Now try a timeout
- results = env.adminClient().electLeaders(
- electionType,
- Set.of(topic1, topic2),
- new ElectLeadersOptions().timeoutMs(100));
- TestUtils.assertFutureThrows(TimeoutException.class, results.partitions());
+ Uuid result = env.adminClient().clientInstanceId(Duration.ofSeconds(1));
+ assertEquals(expectedUuid, result);
}
}
}
@Test
- public void testDescribeBrokerConfigs() throws Exception {
- ConfigResource broker0Resource = new ConfigResource(ConfigResource.Type.BROKER, "0");
- ConfigResource broker1Resource = new ConfigResource(ConfigResource.Type.BROKER, "1");
- try (AdminClientUnitTestEnv env = mockClientEnv()) {
- env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
- env.kafkaClient().prepareResponseFrom(new DescribeConfigsResponse(
- new DescribeConfigsResponseData().setResults(singletonList(new DescribeConfigsResponseData.DescribeConfigsResult()
- .setResourceName(broker0Resource.name()).setResourceType(broker0Resource.type().id()).setErrorCode(Errors.NONE.code())
- .setConfigs(emptyList())))), env.cluster().nodeById(0));
- env.kafkaClient().prepareResponseFrom(new DescribeConfigsResponse(
- new DescribeConfigsResponseData().setResults(singletonList(new DescribeConfigsResponseData.DescribeConfigsResult()
- .setResourceName(broker1Resource.name()).setResourceType(broker1Resource.type().id()).setErrorCode(Errors.NONE.code())
- .setConfigs(emptyList())))), env.cluster().nodeById(1));
- Map<ConfigResource, KafkaFuture<Config>> result = env.adminClient().describeConfigs(asList(
- broker0Resource,
- broker1Resource)).values();
- assertEquals(Set.of(broker0Resource, broker1Resource), result.keySet());
- result.get(broker0Resource).get();
- result.get(broker1Resource).get();
- }
+ public void testClientInstanceIdInvalidTimeout() {
+ Properties props = new Properties();
+ props.setProperty(AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9999");
+
+ KafkaAdminClient admin = (KafkaAdminClient) AdminClient.create(props);
+ Exception exception = assertThrows(IllegalArgumentException.class, () -> admin.clientInstanceId(Duration.ofMillis(-1)));
+ assertEquals("The timeout cannot be negative.", exception.getMessage());
+
+ admin.close();
}
@Test
- public void testDescribeBrokerAndLogConfigs() throws Exception {
- ConfigResource brokerResource = new ConfigResource(ConfigResource.Type.BROKER, "0");
- ConfigResource brokerLoggerResource = new ConfigResource(ConfigResource.Type.BROKER_LOGGER, "0");
- try (AdminClientUnitTestEnv env = mockClientEnv()) {
- env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
- env.kafkaClient().prepareResponseFrom(new DescribeConfigsResponse(
- new DescribeConfigsResponseData().setResults(asList(new DescribeConfigsResponseData.DescribeConfigsResult()
- .setResourceName(brokerResource.name()).setResourceType(brokerResource.type().id()).setErrorCode(Errors.NONE.code())
- .setConfigs(emptyList()),
- new DescribeConfigsResponseData.DescribeConfigsResult()
- .setResourceName(brokerLoggerResource.name()).setResourceType(brokerLoggerResource.type().id()).setErrorCode(Errors.NONE.code())
- .setConfigs(emptyList())))), env.cluster().nodeById(0));
- Map<ConfigResource, KafkaFuture<Config>> result = env.adminClient().describeConfigs(asList(
- brokerResource,
- brokerLoggerResource)).values();
- assertEquals(Set.of(brokerResource, brokerLoggerResource), result.keySet());
- result.get(brokerResource).get();
- result.get(brokerLoggerResource).get();
- }
+ public void testClientInstanceIdNoTelemetryReporterRegistered() {
+ Properties props = new Properties();
+ props.setProperty(AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9999");
+ props.setProperty(AdminClientConfig.ENABLE_METRICS_PUSH_CONFIG, "false");
+
+ KafkaAdminClient admin = (KafkaAdminClient) AdminClient.create(props);
+ Exception exception = assertThrows(IllegalStateException.class, () -> admin.clientInstanceId(Duration.ofMillis(0)));
+ assertEquals("Telemetry is not enabled. Set config `enable.metrics.push` to `true`.", exception.getMessage());
+
+ admin.close();
}
+ @SuppressWarnings({"deprecation", "removal"})
@Test
- public void testDescribeConfigsPartialResponse() {
- ConfigResource topic = new ConfigResource(ConfigResource.Type.TOPIC, "topic");
- ConfigResource topic2 = new ConfigResource(ConfigResource.Type.TOPIC, "topic2");
+ public void testListClientMetricsResources() throws Exception {
try (AdminClientUnitTestEnv env = mockClientEnv()) {
- env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
- env.kafkaClient().prepareResponse(new DescribeConfigsResponse(
- new DescribeConfigsResponseData().setResults(singletonList(new DescribeConfigsResponseData.DescribeConfigsResult()
- .setResourceName(topic.name()).setResourceType(topic.type().id()).setErrorCode(Errors.NONE.code())
- .setConfigs(emptyList())))));
- Map<ConfigResource, KafkaFuture<Config>> result = env.adminClient().describeConfigs(asList(
- topic,
- topic2)).values();
- assertEquals(Set.of(topic, topic2), result.keySet());
- result.get(topic);
- TestUtils.assertFutureThrows(ApiException.class, result.get(topic2));
+ List<ClientMetricsResourceListing> expected = asList(
+ new ClientMetricsResourceListing("one"),
+ new ClientMetricsResourceListing("two")
+ );
+
+ ListConfigResourcesResponseData responseData =
+ new ListConfigResourcesResponseData().setErrorCode(Errors.NONE.code());
+
+ responseData.configResources()
+ .add(new ListConfigResourcesResponseData
+ .ConfigResource()
+ .setResourceName("one")
+ .setResourceType(ConfigResource.Type.CLIENT_METRICS.id())
+ );
+ responseData.configResources()
+ .add(new ListConfigResourcesResponseData
+ .ConfigResource()
+ .setResourceName("two")
+ .setResourceType(ConfigResource.Type.CLIENT_METRICS.id())
+ );
+
+ env.kafkaClient().prepareResponse(
+ request -> request instanceof ListConfigResourcesRequest,
+ new ListConfigResourcesResponse(responseData));
+
+ ListClientMetricsResourcesResult result = env.adminClient().listClientMetricsResources();
+ assertEquals(new HashSet<>(expected), new HashSet<>(result.all().get()));
}
}
+ @SuppressWarnings({"deprecation", "removal"})
@Test
- public void testDescribeConfigsUnrequested() throws Exception {
- ConfigResource topic = new ConfigResource(ConfigResource.Type.TOPIC, "topic");
- ConfigResource unrequested = new ConfigResource(ConfigResource.Type.TOPIC, "unrequested");
+ public void testListClientMetricsResourcesEmpty() throws Exception {
try (AdminClientUnitTestEnv env = mockClientEnv()) {
- env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
- env.kafkaClient().prepareResponse(new DescribeConfigsResponse(
- new DescribeConfigsResponseData().setResults(asList(new DescribeConfigsResponseData.DescribeConfigsResult()
- .setResourceName(topic.name()).setResourceType(topic.type().id()).setErrorCode(Errors.NONE.code())
- .setConfigs(emptyList()),
- new DescribeConfigsResponseData.DescribeConfigsResult()
- .setResourceName(unrequested.name()).setResourceType(unrequested.type().id()).setErrorCode(Errors.NONE.code())
- .setConfigs(emptyList())))));
- Map<ConfigResource, KafkaFuture<Config>> result = env.adminClient().describeConfigs(singletonList(
- topic)).values();
- assertEquals(Set.of(topic), result.keySet());
- assertNotNull(result.get(topic).get());
- assertNull(result.get(unrequested));
+ List<ClientMetricsResourceListing> expected = Collections.emptyList();
+
+ ListConfigResourcesResponseData responseData =
+ new ListConfigResourcesResponseData().setErrorCode(Errors.NONE.code());
+
+ env.kafkaClient().prepareResponse(
+ request -> request instanceof ListConfigResourcesRequest,
+ new ListConfigResourcesResponse(responseData));
+
+ ListClientMetricsResourcesResult result = env.adminClient().listClientMetricsResources();
+ assertEquals(new HashSet<>(expected), new HashSet<>(result.all().get()));
}
}
+ @SuppressWarnings({"deprecation", "removal"})
@Test
- public void testDescribeClientMetricsConfigs() throws Exception {
- ConfigResource resource = new ConfigResource(ConfigResource.Type.CLIENT_METRICS, "sub1");
- ConfigResource resource1 = new ConfigResource(ConfigResource.Type.CLIENT_METRICS, "sub2");
+ public void testListClientMetricsResourcesNotSupported() {
try (AdminClientUnitTestEnv env = mockClientEnv()) {
- env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
- env.kafkaClient().prepareResponse(new DescribeConfigsResponse(
- new DescribeConfigsResponseData().setResults(asList(
- new DescribeConfigsResponseData.DescribeConfigsResult()
- .setResourceName(resource.name()).setResourceType(resource.type().id()).setErrorCode(Errors.NONE.code())
- .setConfigs(emptyList()),
- new DescribeConfigsResponseData.DescribeConfigsResult()
- .setResourceName(resource1.name()).setResourceType(resource1.type().id()).setErrorCode(Errors.NONE.code())
- .setConfigs(emptyList())))));
- Map<ConfigResource, KafkaFuture<Config>> result = env.adminClient().describeConfigs(asList(
- resource,
- resource1)).values();
- assertEquals(Set.of(resource, resource1), result.keySet());
- assertNotNull(result.get(resource).get());
- assertNotNull(result.get(resource1).get());
+ env.kafkaClient().prepareResponse(
+ request -> request instanceof ListConfigResourcesRequest,
+ prepareListClientMetricsResourcesResponse(Errors.UNSUPPORTED_VERSION));
+
+ ListClientMetricsResourcesResult result = env.adminClient().listClientMetricsResources();
+
+ // Validate response
+ assertNotNull(result.all());
+ TestUtils.assertFutureThrows(UnsupportedVersionException.class, result.all());
}
}
@Test
- public void testDescribeConsumerGroupConfigs() throws Exception {
- ConfigResource resource1 = new ConfigResource(ConfigResource.Type.GROUP, "group1");
- ConfigResource resource2 = new ConfigResource(ConfigResource.Type.GROUP, "group2");
- try (AdminClientUnitTestEnv env = mockClientEnv()) {
- env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
- env.kafkaClient().prepareResponse(new DescribeConfigsResponse(
- new DescribeConfigsResponseData().setResults(asList(
- new DescribeConfigsResponseData.DescribeConfigsResult()
- .setResourceName(resource1.name())
- .setResourceType(resource1.type().id())
- .setErrorCode(Errors.NONE.code())
- .setConfigs(emptyList()),
- new DescribeConfigsResponseData.DescribeConfigsResult()
- .setResourceName(resource2.name())
- .setResourceType(resource2.type().id())
- .setErrorCode(Errors.NONE.code())
- .setConfigs(emptyList())))));
- Map<ConfigResource, KafkaFuture<Config>> result = env.adminClient().describeConfigs(asList(
- resource1,
- resource2)).values();
- assertEquals(Set.of(resource1, resource2), result.keySet());
- assertNotNull(result.get(resource1).get());
- assertNotNull(result.get(resource2).get());
- }
- }
-
- private static DescribeLogDirsResponse prepareDescribeLogDirsResponse(Errors error, String logDir, TopicPartition tp, long partitionSize, long offsetLag) {
- return prepareDescribeLogDirsResponse(error, logDir,
- prepareDescribeLogDirsTopics(partitionSize, offsetLag, tp.topic(), tp.partition(), false));
- }
-
- private static DescribeLogDirsResponse prepareDescribeLogDirsResponse(Errors error, String logDir, TopicPartition tp, long partitionSize, long offsetLag, long totalBytes, long usableBytes) {
- return prepareDescribeLogDirsResponse(error, logDir,
- prepareDescribeLogDirsTopics(partitionSize, offsetLag, tp.topic(), tp.partition(), false), totalBytes, usableBytes, false);
- }
-
- private static DescribeLogDirsResponse prepareDescribeLogDirsResponse(Errors error, String logDir, TopicPartition tp, long partitionSize, long offsetLag, long totalBytes, long usableBytes, boolean isCordoned) {
- return prepareDescribeLogDirsResponse(error, logDir,
- prepareDescribeLogDirsTopics(partitionSize, offsetLag, tp.topic(), tp.partition(), false), totalBytes, usableBytes, isCordoned);
- }
-
- private static List<DescribeLogDirsTopic> prepareDescribeLogDirsTopics(
- long partitionSize, long offsetLag, String topic, int partition, boolean isFuture) {
- return singletonList(new DescribeLogDirsTopic()
- .setName(topic)
- .setPartitions(singletonList(new DescribeLogDirsResponseData.DescribeLogDirsPartition()
- .setPartitionIndex(partition)
- .setPartitionSize(partitionSize)
- .setIsFutureKey(isFuture)
- .setOffsetLag(offsetLag))));
- }
-
- private static DescribeLogDirsResponse prepareDescribeLogDirsResponse(Errors error, String logDir,
- List<DescribeLogDirsTopic> topics) {
- return new DescribeLogDirsResponse(
- new DescribeLogDirsResponseData().setResults(singletonList(new DescribeLogDirsResponseData.DescribeLogDirsResult()
- .setErrorCode(error.code())
- .setLogDir(logDir)
- .setTopics(topics)
- )));
- }
-
- private static DescribeLogDirsResponse prepareDescribeLogDirsResponse(Errors error, String logDir,
- List<DescribeLogDirsTopic> topics,
- long totalBytes, long usableBytes,
- boolean isCordoned) {
- return new DescribeLogDirsResponse(
- new DescribeLogDirsResponseData().setResults(singletonList(new DescribeLogDirsResponseData.DescribeLogDirsResult()
- .setErrorCode(error.code())
- .setLogDir(logDir)
- .setTopics(topics)
- .setTotalBytes(totalBytes)
- .setUsableBytes(usableBytes)
- .setIsCordoned(isCordoned)
- )));
- }
-
- private static DescribeLogDirsResponse prepareEmptyDescribeLogDirsResponse(Optional<Errors> error) {
- DescribeLogDirsResponseData data = new DescribeLogDirsResponseData();
- error.ifPresent(e -> data.setErrorCode(e.code()));
- return new DescribeLogDirsResponse(data);
- }
-
- @Test
- public void testDescribeLogDirs() throws ExecutionException, InterruptedException {
- Set<Integer> brokers = singleton(0);
- String logDir = "/var/data/kafka";
- TopicPartition tp = new TopicPartition("topic", 12);
- long partitionSize = 1234567890;
- long offsetLag = 24;
-
- try (AdminClientUnitTestEnv env = mockClientEnv()) {
- env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
- env.kafkaClient().prepareResponseFrom(
- prepareDescribeLogDirsResponse(Errors.NONE, logDir, tp, partitionSize, offsetLag),
- env.cluster().nodeById(0));
-
- DescribeLogDirsResult result = env.adminClient().describeLogDirs(brokers);
-
- Map<Integer, KafkaFuture<Map<String, LogDirDescription>>> descriptions = result.descriptions();
- assertEquals(brokers, descriptions.keySet());
- assertNotNull(descriptions.get(0));
- assertDescriptionContains(descriptions.get(0).get(), logDir, tp, partitionSize, offsetLag);
-
- Map<Integer, Map<String, LogDirDescription>> allDescriptions = result.allDescriptions().get();
- assertEquals(brokers, allDescriptions.keySet());
- assertDescriptionContains(allDescriptions.get(0), logDir, tp, partitionSize, offsetLag);
-
- // Empty results when not authorized with version < 3
- env.kafkaClient().prepareResponseFrom(
- prepareEmptyDescribeLogDirsResponse(Optional.empty()),
- env.cluster().nodeById(0));
- final DescribeLogDirsResult errorResult = env.adminClient().describeLogDirs(brokers);
- ExecutionException exception = assertThrows(ExecutionException.class, () -> errorResult.allDescriptions().get());
- assertInstanceOf(ClusterAuthorizationException.class, exception.getCause());
-
- // Empty results with an error with version >= 3
- env.kafkaClient().prepareResponseFrom(
- prepareEmptyDescribeLogDirsResponse(Optional.of(Errors.UNKNOWN_SERVER_ERROR)),
- env.cluster().nodeById(0));
- final DescribeLogDirsResult errorResult2 = env.adminClient().describeLogDirs(brokers);
- exception = assertThrows(ExecutionException.class, () -> errorResult2.allDescriptions().get());
- assertInstanceOf(UnknownServerException.class, exception.getCause());
- }
- }
-
- private static void assertDescriptionContains(Map<String, LogDirDescription> descriptionsMap, String logDir,
- TopicPartition tp, long partitionSize, long offsetLag) {
- assertDescriptionContains(descriptionsMap, logDir, tp, partitionSize, offsetLag, OptionalLong.empty(), OptionalLong.empty());
- }
-
- private static void assertDescriptionContains(Map<String, LogDirDescription> descriptionsMap, String logDir,
- TopicPartition tp, long partitionSize, long offsetLag, OptionalLong totalBytes, OptionalLong usableBytes) {
- assertNotNull(descriptionsMap);
- assertEquals(singleton(logDir), descriptionsMap.keySet());
- assertNull(descriptionsMap.get(logDir).error());
- Map<TopicPartition, ReplicaInfo> descriptionsReplicaInfos = descriptionsMap.get(logDir).replicaInfos();
- assertEquals(singleton(tp), descriptionsReplicaInfos.keySet());
- assertEquals(partitionSize, descriptionsReplicaInfos.get(tp).size());
- assertEquals(offsetLag, descriptionsReplicaInfos.get(tp).offsetLag());
- assertFalse(descriptionsReplicaInfos.get(tp).isFuture());
- assertEquals(totalBytes, descriptionsMap.get(logDir).totalBytes());
- assertEquals(usableBytes, descriptionsMap.get(logDir).usableBytes());
- assertFalse(descriptionsMap.get(logDir).isCordoned());
- }
-
- @Test
- public void testDescribeLogDirsWithVolumeBytes() throws ExecutionException, InterruptedException {
- Set<Integer> brokers = singleton(0);
- String logDir = "/var/data/kafka";
- TopicPartition tp = new TopicPartition("topic", 12);
- long partitionSize = 1234567890;
- long offsetLag = 24;
- long totalBytes = 123L;
- long usableBytes = 456L;
-
- try (AdminClientUnitTestEnv env = mockClientEnv()) {
- env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
- env.kafkaClient().prepareResponseFrom(
- prepareDescribeLogDirsResponse(Errors.NONE, logDir, tp, partitionSize, offsetLag, totalBytes, usableBytes),
- env.cluster().nodeById(0));
-
- DescribeLogDirsResult result = env.adminClient().describeLogDirs(brokers);
-
- Map<Integer, KafkaFuture<Map<String, LogDirDescription>>> descriptions = result.descriptions();
- assertEquals(brokers, descriptions.keySet());
- assertNotNull(descriptions.get(0));
- assertDescriptionContains(descriptions.get(0).get(), logDir, tp, partitionSize, offsetLag, OptionalLong.of(totalBytes), OptionalLong.of(usableBytes));
-
- Map<Integer, Map<String, LogDirDescription>> allDescriptions = result.allDescriptions().get();
- assertEquals(brokers, allDescriptions.keySet());
- assertDescriptionContains(allDescriptions.get(0), logDir, tp, partitionSize, offsetLag, OptionalLong.of(totalBytes), OptionalLong.of(usableBytes));
-
- // Empty results when not authorized with version < 3
- env.kafkaClient().prepareResponseFrom(
- prepareEmptyDescribeLogDirsResponse(Optional.empty()),
- env.cluster().nodeById(0));
- final DescribeLogDirsResult errorResult = env.adminClient().describeLogDirs(brokers);
- ExecutionException exception = assertThrows(ExecutionException.class, () -> errorResult.allDescriptions().get());
- assertInstanceOf(ClusterAuthorizationException.class, exception.getCause());
-
- // Empty results with an error with version >= 3
- env.kafkaClient().prepareResponseFrom(
- prepareEmptyDescribeLogDirsResponse(Optional.of(Errors.UNKNOWN_SERVER_ERROR)),
- env.cluster().nodeById(0));
- final DescribeLogDirsResult errorResult2 = env.adminClient().describeLogDirs(brokers);
- exception = assertThrows(ExecutionException.class, () -> errorResult2.allDescriptions().get());
- assertInstanceOf(UnknownServerException.class, exception.getCause());
- }
- }
-
- @Test
- public void testDescribeLogDirsOfflineDir() throws ExecutionException, InterruptedException {
- Set<Integer> brokers = singleton(0);
- String logDir = "/var/data/kafka";
- Errors error = Errors.KAFKA_STORAGE_ERROR;
-
- try (AdminClientUnitTestEnv env = mockClientEnv()) {
- env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
- env.kafkaClient().prepareResponseFrom(
- prepareDescribeLogDirsResponse(error, logDir, emptyList()),
- env.cluster().nodeById(0));
-
- DescribeLogDirsResult result = env.adminClient().describeLogDirs(brokers);
-
- Map<Integer, KafkaFuture<Map<String, LogDirDescription>>> descriptions = result.descriptions();
- assertEquals(brokers, descriptions.keySet());
- assertNotNull(descriptions.get(0));
- Map<String, LogDirDescription> descriptionsMap = descriptions.get(0).get();
- assertEquals(singleton(logDir), descriptionsMap.keySet());
- assertEquals(error.exception().getClass(), descriptionsMap.get(logDir).error().getClass());
- assertEquals(emptySet(), descriptionsMap.get(logDir).replicaInfos().keySet());
-
- Map<Integer, Map<String, LogDirDescription>> allDescriptions = result.allDescriptions().get();
- assertEquals(brokers, allDescriptions.keySet());
- Map<String, LogDirDescription> allMap = allDescriptions.get(0);
- assertNotNull(allMap);
- assertEquals(singleton(logDir), allMap.keySet());
- assertEquals(error.exception().getClass(), allMap.get(logDir).error().getClass());
- assertEquals(emptySet(), allMap.get(logDir).replicaInfos().keySet());
- }
- }
-
- @Test
- public void testDescribeLogDirsWithCordonedDir() throws ExecutionException, InterruptedException {
- Set<Integer> brokers = singleton(0);
- String logDir = "/var/data/kafka";
- TopicPartition tp = new TopicPartition("topic", 12);
-
- try (AdminClientUnitTestEnv env = mockClientEnv()) {
- env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
- env.kafkaClient().prepareResponseFrom(
- prepareDescribeLogDirsResponse(Errors.NONE, logDir, tp, 123, -1, -1, -1, true),
- env.cluster().nodeById(0));
-
- DescribeLogDirsResult result = env.adminClient().describeLogDirs(brokers);
-
- Map<Integer, KafkaFuture<Map<String, LogDirDescription>>> descriptions = result.descriptions();
- assertEquals(brokers, descriptions.keySet());
- assertNotNull(descriptions.get(0));
- Map<String, LogDirDescription> descriptionsMap = descriptions.get(0).get();
- assertEquals(singleton(logDir), descriptionsMap.keySet());
- assertTrue(descriptionsMap.get(logDir).isCordoned());
- assertEquals(Set.of(tp), descriptionsMap.get(logDir).replicaInfos().keySet());
-
- Map<Integer, Map<String, LogDirDescription>> allDescriptions = result.allDescriptions().get();
- assertEquals(brokers, allDescriptions.keySet());
- Map<String, LogDirDescription> allMap = allDescriptions.get(0);
- assertNotNull(allMap);
- assertEquals(singleton(logDir), allMap.keySet());
- assertTrue(allMap.get(logDir).isCordoned());
- assertEquals(Set.of(tp), allMap.get(logDir).replicaInfos().keySet());
- }
- }
-
- @Test
- public void testDescribeReplicaLogDirs() throws ExecutionException, InterruptedException {
- TopicPartitionReplica tpr1 = new TopicPartitionReplica("topic", 12, 1);
- TopicPartitionReplica tpr2 = new TopicPartitionReplica("topic", 12, 2);
-
- try (AdminClientUnitTestEnv env = mockClientEnv()) {
- env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
- String broker1log0 = "/var/data/kafka0";
- String broker1log1 = "/var/data/kafka1";
- String broker2log0 = "/var/data/kafka2";
- int broker1Log0OffsetLag = 24;
- int broker1Log0PartitionSize = 987654321;
- int broker1Log1PartitionSize = 123456789;
- int broker1Log1OffsetLag = 4321;
- env.kafkaClient().prepareResponseFrom(
- new DescribeLogDirsResponse(
- new DescribeLogDirsResponseData().setResults(asList(
- prepareDescribeLogDirsResult(tpr1, broker1log0, broker1Log0PartitionSize, broker1Log0OffsetLag, false),
- prepareDescribeLogDirsResult(tpr1, broker1log1, broker1Log1PartitionSize, broker1Log1OffsetLag, true)))),
- env.cluster().nodeById(tpr1.brokerId()));
- env.kafkaClient().prepareResponseFrom(
- prepareDescribeLogDirsResponse(Errors.KAFKA_STORAGE_ERROR, broker2log0),
- env.cluster().nodeById(tpr2.brokerId()));
-
- DescribeReplicaLogDirsResult result = env.adminClient().describeReplicaLogDirs(asList(tpr1, tpr2));
-
- Map<TopicPartitionReplica, KafkaFuture<DescribeReplicaLogDirsResult.ReplicaLogDirInfo>> values = result.values();
- assertEquals(Set.of(tpr1, tpr2), values.keySet());
-
- assertNotNull(values.get(tpr1));
- assertEquals(broker1log0, values.get(tpr1).get().getCurrentReplicaLogDir());
- assertEquals(broker1Log0OffsetLag, values.get(tpr1).get().getCurrentReplicaOffsetLag());
- assertEquals(broker1log1, values.get(tpr1).get().getFutureReplicaLogDir());
- assertEquals(broker1Log1OffsetLag, values.get(tpr1).get().getFutureReplicaOffsetLag());
-
- assertNotNull(values.get(tpr2));
- assertNull(values.get(tpr2).get().getCurrentReplicaLogDir());
- assertEquals(-1, values.get(tpr2).get().getCurrentReplicaOffsetLag());
- assertNull(values.get(tpr2).get().getFutureReplicaLogDir());
- assertEquals(-1, values.get(tpr2).get().getFutureReplicaOffsetLag());
- }
- }
-
- private static DescribeLogDirsResponseData.DescribeLogDirsResult prepareDescribeLogDirsResult(TopicPartitionReplica tpr, String logDir, int partitionSize, int offsetLag, boolean isFuture) {
- return new DescribeLogDirsResponseData.DescribeLogDirsResult()
- .setErrorCode(Errors.NONE.code())
- .setLogDir(logDir)
- .setTopics(prepareDescribeLogDirsTopics(partitionSize, offsetLag, tpr.topic(), tpr.partition(), isFuture));
- }
-
- @Test
- public void testDescribeReplicaLogDirsUnexpected() throws ExecutionException, InterruptedException {
- TopicPartitionReplica expected = new TopicPartitionReplica("topic", 12, 1);
- TopicPartitionReplica unexpected = new TopicPartitionReplica("topic", 12, 2);
-
- try (AdminClientUnitTestEnv env = mockClientEnv()) {
- env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
- String broker1log0 = "/var/data/kafka0";
- String broker1log1 = "/var/data/kafka1";
- int broker1Log0PartitionSize = 987654321;
- int broker1Log0OffsetLag = 24;
- int broker1Log1PartitionSize = 123456789;
- int broker1Log1OffsetLag = 4321;
- env.kafkaClient().prepareResponseFrom(
- new DescribeLogDirsResponse(
- new DescribeLogDirsResponseData().setResults(asList(
- prepareDescribeLogDirsResult(expected, broker1log0, broker1Log0PartitionSize, broker1Log0OffsetLag, false),
- prepareDescribeLogDirsResult(unexpected, broker1log1, broker1Log1PartitionSize, broker1Log1OffsetLag, true)))),
- env.cluster().nodeById(expected.brokerId()));
-
- DescribeReplicaLogDirsResult result = env.adminClient().describeReplicaLogDirs(singletonList(expected));
-
- Map<TopicPartitionReplica, KafkaFuture<DescribeReplicaLogDirsResult.ReplicaLogDirInfo>> values = result.values();
- assertEquals(Set.of(expected), values.keySet());
-
- assertNotNull(values.get(expected));
- assertEquals(broker1log0, values.get(expected).get().getCurrentReplicaLogDir());
- assertEquals(broker1Log0OffsetLag, values.get(expected).get().getCurrentReplicaOffsetLag());
- assertEquals(broker1log1, values.get(expected).get().getFutureReplicaLogDir());
- assertEquals(broker1Log1OffsetLag, values.get(expected).get().getFutureReplicaOffsetLag());
- }
- }
-
- @Test
- public void testCreatePartitions() throws Exception {
- try (AdminClientUnitTestEnv env = mockClientEnv()) {
- env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
-
- // Test a call where one filter has an error.
- env.kafkaClient().prepareResponse(
- expectCreatePartitionsRequestWithTopics("my_topic", "other_topic"),
- prepareCreatePartitionsResponse(1000,
- createPartitionsTopicResult("my_topic", Errors.NONE),
- createPartitionsTopicResult("other_topic", Errors.INVALID_TOPIC_EXCEPTION,
- "some detailed reason")));
-
-
- Map<String, NewPartitions> counts = new HashMap<>();
- counts.put("my_topic", NewPartitions.increaseTo(3));
- counts.put("other_topic", NewPartitions.increaseTo(3, asList(singletonList(2), singletonList(3))));
-
- CreatePartitionsResult results = env.adminClient().createPartitions(counts);
- Map<String, KafkaFuture<Void>> values = results.values();
- KafkaFuture<Void> myTopicResult = values.get("my_topic");
- myTopicResult.get();
- KafkaFuture<Void> otherTopicResult = values.get("other_topic");
- assertEquals("some detailed reason",
- assertInstanceOf(InvalidTopicException.class,
- assertThrows(ExecutionException.class, otherTopicResult::get).getCause()).getMessage());
- }
- }
-
- @Test
- public void testCreatePartitionsRetryThrottlingExceptionWhenEnabled() throws Exception {
- try (AdminClientUnitTestEnv env = mockClientEnv()) {
- env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
-
- env.kafkaClient().prepareResponse(
- expectCreatePartitionsRequestWithTopics("topic1", "topic2", "topic3"),
- prepareCreatePartitionsResponse(1000,
- createPartitionsTopicResult("topic1", Errors.NONE),
- createPartitionsTopicResult("topic2", Errors.THROTTLING_QUOTA_EXCEEDED),
- createPartitionsTopicResult("topic3", Errors.TOPIC_ALREADY_EXISTS)));
-
- env.kafkaClient().prepareResponse(
- expectCreatePartitionsRequestWithTopics("topic2"),
- prepareCreatePartitionsResponse(1000,
- createPartitionsTopicResult("topic2", Errors.THROTTLING_QUOTA_EXCEEDED)));
-
- env.kafkaClient().prepareResponse(
- expectCreatePartitionsRequestWithTopics("topic2"),
- prepareCreatePartitionsResponse(0,
- createPartitionsTopicResult("topic2", Errors.NONE)));
-
- Map<String, NewPartitions> counts = new HashMap<>();
- counts.put("topic1", NewPartitions.increaseTo(1));
- counts.put("topic2", NewPartitions.increaseTo(2));
- counts.put("topic3", NewPartitions.increaseTo(3));
-
- CreatePartitionsResult result = env.adminClient().createPartitions(
- counts, new CreatePartitionsOptions().retryOnQuotaViolation(true));
-
- assertNull(result.values().get("topic1").get());
- assertNull(result.values().get("topic2").get());
- TestUtils.assertFutureThrows(TopicExistsException.class, result.values().get("topic3"));
- }
- }
-
- @Test
- public void testCreatePartitionsRetryThrottlingExceptionWhenEnabledUntilRequestTimeOut() throws Exception {
- long defaultApiTimeout = 60000;
- MockTime time = new MockTime();
-
- try (AdminClientUnitTestEnv env = mockClientEnv(time,
- AdminClientConfig.DEFAULT_API_TIMEOUT_MS_CONFIG, String.valueOf(defaultApiTimeout))) {
-
- env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
-
- env.kafkaClient().prepareResponse(
- expectCreatePartitionsRequestWithTopics("topic1", "topic2", "topic3"),
- prepareCreatePartitionsResponse(1000,
- createPartitionsTopicResult("topic1", Errors.NONE),
- createPartitionsTopicResult("topic2", Errors.THROTTLING_QUOTA_EXCEEDED),
- createPartitionsTopicResult("topic3", Errors.TOPIC_ALREADY_EXISTS)));
-
- env.kafkaClient().prepareResponse(
- expectCreatePartitionsRequestWithTopics("topic2"),
- prepareCreatePartitionsResponse(1000,
- createPartitionsTopicResult("topic2", Errors.THROTTLING_QUOTA_EXCEEDED)));
-
- Map<String, NewPartitions> counts = new HashMap<>();
- counts.put("topic1", NewPartitions.increaseTo(1));
- counts.put("topic2", NewPartitions.increaseTo(2));
- counts.put("topic3", NewPartitions.increaseTo(3));
-
- CreatePartitionsResult result = env.adminClient().createPartitions(
- counts, new CreatePartitionsOptions().retryOnQuotaViolation(true));
-
- // Wait until the prepared attempts have consumed
- TestUtils.waitForCondition(() -> env.kafkaClient().numAwaitingResponses() == 0,
- "Failed awaiting CreatePartitions requests");
-
- // Wait until the next request is sent out
- TestUtils.waitForCondition(() -> env.kafkaClient().inFlightRequestCount() == 1,
- "Failed awaiting next CreatePartitions request");
-
- // Advance time past the default api timeout to time out the inflight request
- time.sleep(defaultApiTimeout + 1);
-
- assertNull(result.values().get("topic1").get());
- ThrottlingQuotaExceededException e = TestUtils.assertFutureThrows(ThrottlingQuotaExceededException.class, result.values().get("topic2"));
- assertEquals(0, e.throttleTimeMs());
- TestUtils.assertFutureThrows(TopicExistsException.class, result.values().get("topic3"));
- }
- }
-
- @Test
- public void testCreatePartitionsDontRetryThrottlingExceptionWhenDisabled() throws Exception {
- try (AdminClientUnitTestEnv env = mockClientEnv()) {
- env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
-
- env.kafkaClient().prepareResponse(
- expectCreatePartitionsRequestWithTopics("topic1", "topic2", "topic3"),
- prepareCreatePartitionsResponse(1000,
- createPartitionsTopicResult("topic1", Errors.NONE),
- createPartitionsTopicResult("topic2", Errors.THROTTLING_QUOTA_EXCEEDED),
- createPartitionsTopicResult("topic3", Errors.TOPIC_ALREADY_EXISTS)));
-
- Map<String, NewPartitions> counts = new HashMap<>();
- counts.put("topic1", NewPartitions.increaseTo(1));
- counts.put("topic2", NewPartitions.increaseTo(2));
- counts.put("topic3", NewPartitions.increaseTo(3));
-
- CreatePartitionsResult result = env.adminClient().createPartitions(
- counts, new CreatePartitionsOptions().retryOnQuotaViolation(false));
-
- assertNull(result.values().get("topic1").get());
- ThrottlingQuotaExceededException e = TestUtils.assertFutureThrows(ThrottlingQuotaExceededException.class, result.values().get("topic2"));
- assertEquals(1000, e.throttleTimeMs());
- TestUtils.assertFutureThrows(TopicExistsException.class, result.values().get("topic3"));
- }
- }
-
- private MockClient.RequestMatcher expectCreatePartitionsRequestWithTopics(final String... topics) {
- return body -> {
- if (body instanceof CreatePartitionsRequest) {
- CreatePartitionsRequest request = (CreatePartitionsRequest) body;
- for (String topic : topics) {
- if (request.data().topics().find(topic) == null)
- return false;
- }
- return topics.length == request.data().topics().size();
- }
- return false;
- };
- }
-
- @Test
- public void testDeleteRecordsTopicAuthorizationError() {
- String topic = "foo";
- TopicPartition partition = new TopicPartition(topic, 0);
-
- try (AdminClientUnitTestEnv env = mockClientEnv()) {
- List<MetadataResponse.TopicMetadata> topics = new ArrayList<>();
- topics.add(new MetadataResponse.TopicMetadata(Errors.TOPIC_AUTHORIZATION_FAILED, topic, false,
- Collections.emptyList()));
-
- env.kafkaClient().prepareResponse(RequestTestUtils.metadataResponse(env.cluster().nodes(),
- env.cluster().clusterResource().clusterId(), env.cluster().controller().id(), topics));
-
- Map<TopicPartition, RecordsToDelete> recordsToDelete = new HashMap<>();
- recordsToDelete.put(partition, RecordsToDelete.beforeOffset(10L));
- DeleteRecordsResult results = env.adminClient().deleteRecords(recordsToDelete);
-
- TestUtils.assertFutureThrows(TopicAuthorizationException.class, results.lowWatermarks().get(partition));
- }
- }
-
- @Test
- public void testDeleteRecordsMultipleSends() throws Exception {
- String topic = "foo";
- TopicPartition tp0 = new TopicPartition(topic, 0);
- TopicPartition tp1 = new TopicPartition(topic, 1);
-
- MockTime time = new MockTime();
-
- try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time, mockCluster(3, 0))) {
- List<Node> nodes = env.cluster().nodes();
-
- List<MetadataResponse.PartitionMetadata> partitionMetadata = new ArrayList<>();
- partitionMetadata.add(new MetadataResponse.PartitionMetadata(Errors.NONE, tp0,
- Optional.of(nodes.get(0).id()), Optional.of(5), singletonList(nodes.get(0).id()),
- singletonList(nodes.get(0).id()), Collections.emptyList()));
- partitionMetadata.add(new MetadataResponse.PartitionMetadata(Errors.NONE, tp1,
- Optional.of(nodes.get(1).id()), Optional.of(5), singletonList(nodes.get(1).id()),
- singletonList(nodes.get(1).id()), Collections.emptyList()));
-
- List<MetadataResponse.TopicMetadata> topicMetadata = new ArrayList<>();
- topicMetadata.add(new MetadataResponse.TopicMetadata(Errors.NONE, topic, false, partitionMetadata));
-
- env.kafkaClient().prepareResponse(RequestTestUtils.metadataResponse(env.cluster().nodes(),
- env.cluster().clusterResource().clusterId(), env.cluster().controller().id(), topicMetadata));
-
- env.kafkaClient().prepareResponseFrom(new DeleteRecordsResponse(new DeleteRecordsResponseData().setTopics(
- new DeleteRecordsResponseData.DeleteRecordsTopicResultCollection(singletonList(new DeleteRecordsResponseData.DeleteRecordsTopicResult()
- .setName(tp0.topic())
- .setPartitions(new DeleteRecordsResponseData.DeleteRecordsPartitionResultCollection(singletonList(new DeleteRecordsResponseData.DeleteRecordsPartitionResult()
- .setPartitionIndex(tp0.partition())
- .setErrorCode(Errors.NONE.code())
- .setLowWatermark(3)))))))), nodes.get(0));
-
- env.kafkaClient().disconnect(nodes.get(1).idString());
- env.kafkaClient().createPendingAuthenticationError(nodes.get(1), 100);
-
- Map<TopicPartition, RecordsToDelete> recordsToDelete = new HashMap<>();
- recordsToDelete.put(tp0, RecordsToDelete.beforeOffset(10L));
- recordsToDelete.put(tp1, RecordsToDelete.beforeOffset(10L));
- DeleteRecordsResult results = env.adminClient().deleteRecords(recordsToDelete);
-
- assertEquals(3L, results.lowWatermarks().get(tp0).get().lowWatermark());
- TestUtils.assertFutureThrows(SaslAuthenticationException.class, results.lowWatermarks().get(tp1));
- }
- }
-
- @Test
- public void testDeleteRecords() throws Exception {
- HashMap<Integer, Node> nodes = new HashMap<>();
- nodes.put(0, new Node(0, "localhost", 8121));
- List<PartitionInfo> partitionInfos = new ArrayList<>();
- partitionInfos.add(new PartitionInfo("my_topic", 0, nodes.get(0), new Node[] {nodes.get(0)}, new Node[] {nodes.get(0)}));
- partitionInfos.add(new PartitionInfo("my_topic", 1, nodes.get(0), new Node[] {nodes.get(0)}, new Node[] {nodes.get(0)}));
- partitionInfos.add(new PartitionInfo("my_topic", 2, nodes.get(0), new Node[] {nodes.get(0)}, new Node[] {nodes.get(0)}));
- partitionInfos.add(new PartitionInfo("my_topic", 3, nodes.get(0), new Node[] {nodes.get(0)}, new Node[] {nodes.get(0)}));
-
- Cluster cluster = new Cluster("mockClusterId", nodes.values(),
- partitionInfos, Collections.emptySet(),
- Collections.emptySet(), nodes.get(0));
-
- TopicPartition myTopicPartition0 = new TopicPartition("my_topic", 0);
- TopicPartition myTopicPartition1 = new TopicPartition("my_topic", 1);
- TopicPartition myTopicPartition2 = new TopicPartition("my_topic", 2);
- TopicPartition myTopicPartition3 = new TopicPartition("my_topic", 3);
-
-
- try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(cluster)) {
- env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
-
- env.kafkaClient().prepareResponse(prepareMetadataResponse(cluster, Errors.LEADER_NOT_AVAILABLE));
- env.kafkaClient().prepareResponse(prepareMetadataResponse(cluster, Errors.UNKNOWN_TOPIC_OR_PARTITION));
- env.kafkaClient().prepareResponse(prepareMetadataResponse(cluster, Errors.NONE));
-
- DeleteRecordsResponseData m = new DeleteRecordsResponseData();
- m.topics().add(new DeleteRecordsResponseData.DeleteRecordsTopicResult().setName(myTopicPartition0.topic())
- .setPartitions(new DeleteRecordsResponseData.DeleteRecordsPartitionResultCollection(asList(
- new DeleteRecordsResponseData.DeleteRecordsPartitionResult()
- .setPartitionIndex(myTopicPartition0.partition())
- .setLowWatermark(3)
- .setErrorCode(Errors.NONE.code()),
- new DeleteRecordsResponseData.DeleteRecordsPartitionResult()
- .setPartitionIndex(myTopicPartition1.partition())
- .setLowWatermark(DeleteRecordsResponse.INVALID_LOW_WATERMARK)
- .setErrorCode(Errors.OFFSET_OUT_OF_RANGE.code()),
- new DeleteRecordsResponseData.DeleteRecordsPartitionResult()
- .setPartitionIndex(myTopicPartition2.partition())
- .setLowWatermark(DeleteRecordsResponse.INVALID_LOW_WATERMARK)
- .setErrorCode(Errors.TOPIC_AUTHORIZATION_FAILED.code())
- ))));
- env.kafkaClient().prepareResponse(new DeleteRecordsResponse(m));
-
- Map<TopicPartition, RecordsToDelete> recordsToDelete = new HashMap<>();
- recordsToDelete.put(myTopicPartition0, RecordsToDelete.beforeOffset(3L));
- recordsToDelete.put(myTopicPartition1, RecordsToDelete.beforeOffset(10L));
- recordsToDelete.put(myTopicPartition2, RecordsToDelete.beforeOffset(10L));
- recordsToDelete.put(myTopicPartition3, RecordsToDelete.beforeOffset(10L));
-
- DeleteRecordsResult results = env.adminClient().deleteRecords(recordsToDelete);
-
- // success on records deletion for partition 0
- Map<TopicPartition, KafkaFuture<DeletedRecords>> values = results.lowWatermarks();
- KafkaFuture<DeletedRecords> myTopicPartition0Result = values.get(myTopicPartition0);
- long myTopicPartition0lowWatermark = myTopicPartition0Result.get().lowWatermark();
- assertEquals(3, myTopicPartition0lowWatermark);
-
- // "offset out of range" failure on records deletion for partition 1
- KafkaFuture<DeletedRecords> myTopicPartition1Result = values.get(myTopicPartition1);
- assertInstanceOf(OffsetOutOfRangeException.class,
- assertThrows(ExecutionException.class, myTopicPartition1Result::get).getCause());
-
- // not authorized to delete records for partition 2
- KafkaFuture<DeletedRecords> myTopicPartition2Result = values.get(myTopicPartition2);
- assertInstanceOf(TopicAuthorizationException.class,
- assertThrows(ExecutionException.class, myTopicPartition2Result::get).getCause());
-
- // the response does not contain a result for partition 3
- KafkaFuture<DeletedRecords> myTopicPartition3Result = values.get(myTopicPartition3);
- assertInstanceOf(ApiException.class,
- assertThrows(ExecutionException.class, myTopicPartition3Result::get).getCause());
- }
- }
-
- @Test
- public void testDescribeTopicsByIds() throws ExecutionException, InterruptedException {
- try (AdminClientUnitTestEnv env = mockClientEnv()) {
- env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
-
- // Valid ID
- Uuid topicId = Uuid.randomUuid();
- String topicName = "test-topic";
- Node leader = env.cluster().nodes().get(0);
- MetadataResponse.PartitionMetadata partitionMetadata = new MetadataResponse.PartitionMetadata(
- Errors.NONE,
- new TopicPartition(topicName, 0),
- Optional.of(leader.id()),
- Optional.of(10),
- singletonList(leader.id()),
- singletonList(leader.id()),
- singletonList(leader.id()));
- env.kafkaClient().prepareResponse(RequestTestUtils
- .metadataResponse(
- env.cluster().nodes(),
- env.cluster().clusterResource().clusterId(),
- env.cluster().controller().id(),
- singletonList(new MetadataResponse.TopicMetadata(Errors.NONE, topicName, topicId, false,
- singletonList(partitionMetadata), MetadataResponse.AUTHORIZED_OPERATIONS_OMITTED))));
- TopicCollection.TopicIdCollection topicIds = TopicCollection.ofTopicIds(
- singletonList(topicId));
-
- DescribeTopicsResult describeTopicsresult = env.adminClient().describeTopics(topicIds);
- Map<Uuid, TopicDescription> allTopicIds = describeTopicsresult.allTopicIds().get();
- assertEquals(topicName, allTopicIds.get(topicId).name());
-
- // ID not exist in brokers
- Uuid nonExistID = Uuid.randomUuid();
- env.kafkaClient().prepareResponse(RequestTestUtils
- .metadataResponse(
- env.cluster().nodes(),
- env.cluster().clusterResource().clusterId(),
- env.cluster().controller().id(),
- emptyList()));
-
- DescribeTopicsResult result1 = env.adminClient().describeTopics(
- TopicCollection.ofTopicIds(singletonList(nonExistID)));
- TestUtils.assertFutureThrows(UnknownTopicIdException.class, result1.allTopicIds());
- Exception e = assertThrows(Exception.class, () -> result1.allTopicIds().get(), "describe with non-exist topic ID should throw exception");
- assertEquals(String.format("org.apache.kafka.common.errors.UnknownTopicIdException: TopicId %s not found.", nonExistID), e.getMessage());
-
- DescribeTopicsResult result2 = env.adminClient().describeTopics(
- TopicCollection.ofTopicIds(singletonList(Uuid.ZERO_UUID)));
- TestUtils.assertFutureThrows(InvalidTopicException.class, result2.allTopicIds());
- e = assertThrows(Exception.class, () -> result2.allTopicIds().get(), "describe with non-exist topic ID should throw exception");
- assertEquals("The given topic id 'AAAAAAAAAAAAAAAAAAAAAA' cannot be represented in a request.", e.getCause().getMessage());
-
- }
- }
-
- @Test
- public void testDescribeCluster() throws Exception {
- try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(4, 0),
- AdminClientConfig.RETRIES_CONFIG, "2")) {
- env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
-
- // Prepare the describe cluster response used for the first describe cluster
- env.kafkaClient().prepareResponse(
- prepareDescribeClusterResponse(0,
- env.cluster().nodes(),
- env.cluster().clusterResource().clusterId(),
- 2,
- MetadataResponse.AUTHORIZED_OPERATIONS_OMITTED,
- false));
-
- // Prepare the describe cluster response used for the second describe cluster
- env.kafkaClient().prepareResponse(
- prepareDescribeClusterResponse(0,
- env.cluster().nodes(),
- env.cluster().clusterResource().clusterId(),
- 3,
- 1 << AclOperation.DESCRIBE.code() | 1 << AclOperation.ALTER.code(),
- false));
-
- // Test DescribeCluster with the authorized operations omitted.
- final DescribeClusterResult result = env.adminClient().describeCluster();
- assertEquals(env.cluster().clusterResource().clusterId(), result.clusterId().get());
- assertEquals(new HashSet<>(env.cluster().nodes()), new HashSet<>(result.nodes().get()));
- assertEquals(2, result.controller().get().id());
- assertNull(result.authorizedOperations().get());
-
- // Test DescribeCluster with the authorized operations included.
- final DescribeClusterResult result2 = env.adminClient().describeCluster();
- assertEquals(env.cluster().clusterResource().clusterId(), result2.clusterId().get());
... 12972 lines suppressed ...