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 2024/03/23 03:44:11 UTC
(kafka) branch trunk updated: MINOR: Tuple2 replaced with Map.Entry (#15560)
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 0f216b64487 MINOR: Tuple2 replaced with Map.Entry (#15560)
0f216b64487 is described below
commit 0f216b644874f2f89285f9d4736b50246cd5b0a2
Author: Nikolay <ni...@apache.org>
AuthorDate: Sat Mar 23 06:44:05 2024 +0300
MINOR: Tuple2 replaced with Map.Entry (#15560)
Reviewers: Chia-Ping Tsai <ch...@gmail.com>
---
.../main/java/org/apache/kafka/tools/Tuple2.java | 48 ------
.../tools/consumer/group/ConsumerGroupCommand.java | 59 ++++----
.../tools/reassign/ReassignPartitionsCommand.java | 161 +++++++++++----------
.../org/apache/kafka/tools/ToolsTestUtils.java | 14 +-
.../consumer/group/ConsumerGroupServiceTest.java | 24 +--
.../consumer/group/DeleteConsumerGroupsTest.java | 4 +-
...OffsetsConsumerGroupCommandIntegrationTest.java | 12 +-
.../consumer/group/DescribeConsumerGroupTest.java | 156 ++++++++++----------
.../tools/other/ReplicationQuotasTestRig.java | 2 +-
.../ReassignPartitionsIntegrationTest.java | 11 +-
.../tools/reassign/ReassignPartitionsUnitTest.java | 47 +++---
11 files changed, 248 insertions(+), 290 deletions(-)
diff --git a/tools/src/main/java/org/apache/kafka/tools/Tuple2.java b/tools/src/main/java/org/apache/kafka/tools/Tuple2.java
deleted file mode 100644
index 02dd4bf3981..00000000000
--- a/tools/src/main/java/org/apache/kafka/tools/Tuple2.java
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.kafka.tools;
-
-import java.util.Objects;
-
-public final class Tuple2<V1, V2> {
- public final V1 v1;
-
- public final V2 v2;
-
- public Tuple2(V1 v1, V2 v2) {
- this.v1 = v1;
- this.v2 = v2;
- }
-
- @Override
- public boolean equals(Object o) {
- if (this == o) return true;
- if (o == null || getClass() != o.getClass()) return false;
- Tuple2<?, ?> tuple = (Tuple2<?, ?>) o;
- return Objects.equals(v1, tuple.v1) && Objects.equals(v2, tuple.v2);
- }
-
- @Override
- public int hashCode() {
- return Objects.hash(v1, v2);
- }
-
- @Override
- public String toString() {
- return "Tuple2{v1=" + v1 + ", v2=" + v2 + '}';
- }
-}
diff --git a/tools/src/main/java/org/apache/kafka/tools/consumer/group/ConsumerGroupCommand.java b/tools/src/main/java/org/apache/kafka/tools/consumer/group/ConsumerGroupCommand.java
index 2b055de6161..35371ce75aa 100644
--- a/tools/src/main/java/org/apache/kafka/tools/consumer/group/ConsumerGroupCommand.java
+++ b/tools/src/main/java/org/apache/kafka/tools/consumer/group/ConsumerGroupCommand.java
@@ -53,7 +53,6 @@ import org.apache.kafka.common.requests.ListOffsetsResponse;
import org.apache.kafka.common.utils.Utils;
import org.apache.kafka.server.util.CommandLineUtils;
import org.apache.kafka.tools.ToolsUtils;
-import org.apache.kafka.tools.Tuple2;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -61,6 +60,7 @@ import java.io.IOException;
import java.text.ParseException;
import java.time.Duration;
import java.time.Instant;
+import java.util.AbstractMap.SimpleImmutableEntry;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
@@ -71,6 +71,7 @@ import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
+import java.util.Map.Entry;
import java.util.Optional;
import java.util.OptionalInt;
import java.util.Properties;
@@ -315,10 +316,10 @@ public class ConsumerGroupCommand {
return colOpt.map(Collection::size);
}
- private void printOffsets(Map<String, Tuple2<Optional<String>, Optional<Collection<PartitionAssignmentState>>>> offsets) {
+ private void printOffsets(Map<String, Entry<Optional<String>, Optional<Collection<PartitionAssignmentState>>>> offsets) {
offsets.forEach((groupId, tuple) -> {
- Optional<String> state = tuple.v1;
- Optional<Collection<PartitionAssignmentState>> assignments = tuple.v2;
+ Optional<String> state = tuple.getKey();
+ Optional<Collection<PartitionAssignmentState>> assignments = tuple.getValue();
if (shouldPrintMemberState(groupId, state, size(assignments))) {
String format = printOffsetFormat(assignments);
@@ -359,10 +360,10 @@ public class ConsumerGroupCommand {
return format;
}
- private void printMembers(Map<String, Tuple2<Optional<String>, Optional<Collection<MemberAssignmentState>>>> members, boolean verbose) {
+ private void printMembers(Map<String, Entry<Optional<String>, Optional<Collection<MemberAssignmentState>>>> members, boolean verbose) {
members.forEach((groupId, tuple) -> {
- Optional<String> state = tuple.v1;
- Optional<Collection<MemberAssignmentState>> assignments = tuple.v2;
+ Optional<String> state = tuple.getKey();
+ Optional<Collection<MemberAssignmentState>> assignments = tuple.getValue();
int maxGroupLen = 15, maxConsumerIdLen = 15, maxGroupInstanceIdLen = 17, maxHostLen = 15, maxClientIdLen = 15;
boolean includeGroupInstanceId = false;
@@ -448,11 +449,11 @@ public class ConsumerGroupCommand {
long subActions = Stream.of(membersOptPresent, offsetsOptPresent, stateOptPresent).filter(x -> x).count();
if (subActions == 0 || offsetsOptPresent) {
- TreeMap<String, Tuple2<Optional<String>, Optional<Collection<PartitionAssignmentState>>>> offsets
+ TreeMap<String, Entry<Optional<String>, Optional<Collection<PartitionAssignmentState>>>> offsets
= collectGroupsOffsets(groupIds);
printOffsets(offsets);
} else if (membersOptPresent) {
- TreeMap<String, Tuple2<Optional<String>, Optional<Collection<MemberAssignmentState>>>> members
+ TreeMap<String, Entry<Optional<String>, Optional<Collection<MemberAssignmentState>>>> members
= collectGroupsMembers(groupIds, opts.options.has(opts.verboseOpt));
printMembers(members, opts.options.has(opts.verboseOpt));
} else {
@@ -560,7 +561,7 @@ public class ConsumerGroupCommand {
return result;
}
- Tuple2<Errors, Map<TopicPartition, Throwable>> deleteOffsets(String groupId, List<String> topics) {
+ Entry<Errors, Map<TopicPartition, Throwable>> deleteOffsets(String groupId, List<String> topics) {
Map<TopicPartition, Throwable> partitionLevelResult = new HashMap<>();
Set<String> topicWithPartitions = new HashSet<>();
Set<String> topicWithoutPartitions = new HashSet<>();
@@ -617,17 +618,17 @@ public class ConsumerGroupCommand {
}
});
- return new Tuple2<>(topLevelException, partitionLevelResult);
+ return new SimpleImmutableEntry<>(topLevelException, partitionLevelResult);
}
void deleteOffsets() {
String groupId = opts.options.valueOf(opts.groupOpt);
List<String> topics = opts.options.valuesOf(opts.topicOpt);
- Tuple2<Errors, Map<TopicPartition, Throwable>> res = deleteOffsets(groupId, topics);
+ Entry<Errors, Map<TopicPartition, Throwable>> res = deleteOffsets(groupId, topics);
- Errors topLevelResult = res.v1;
- Map<TopicPartition, Throwable> partitionLevelResult = res.v2;
+ Errors topLevelResult = res.getKey();
+ Map<TopicPartition, Throwable> partitionLevelResult = res.getValue();
switch (topLevelResult) {
case NONE:
@@ -677,7 +678,7 @@ public class ConsumerGroupCommand {
withTimeoutMs(new DescribeConsumerGroupsOptions())
).describedGroups();
- for (Map.Entry<String, KafkaFuture<ConsumerGroupDescription>> e : stringKafkaFutureMap.entrySet()) {
+ for (Entry<String, KafkaFuture<ConsumerGroupDescription>> e : stringKafkaFutureMap.entrySet()) {
res.put(e.getKey(), e.getValue().get());
}
return res;
@@ -686,16 +687,16 @@ public class ConsumerGroupCommand {
/**
* Returns the state of the specified consumer group and partition assignment states
*/
- Tuple2<Optional<String>, Optional<Collection<PartitionAssignmentState>>> collectGroupOffsets(String groupId) throws Exception {
- return collectGroupsOffsets(Collections.singletonList(groupId)).getOrDefault(groupId, new Tuple2<>(Optional.empty(), Optional.empty()));
+ Entry<Optional<String>, Optional<Collection<PartitionAssignmentState>>> collectGroupOffsets(String groupId) throws Exception {
+ return collectGroupsOffsets(Collections.singletonList(groupId)).getOrDefault(groupId, new SimpleImmutableEntry<>(Optional.empty(), Optional.empty()));
}
/**
* Returns states of the specified consumer groups and partition assignment states
*/
- TreeMap<String, Tuple2<Optional<String>, Optional<Collection<PartitionAssignmentState>>>> collectGroupsOffsets(Collection<String> groupIds) throws Exception {
+ TreeMap<String, Entry<Optional<String>, Optional<Collection<PartitionAssignmentState>>>> collectGroupsOffsets(Collection<String> groupIds) throws Exception {
Map<String, ConsumerGroupDescription> consumerGroups = describeConsumerGroups(groupIds);
- TreeMap<String, Tuple2<Optional<String>, Optional<Collection<PartitionAssignmentState>>>> groupOffsets = new TreeMap<>();
+ TreeMap<String, Entry<Optional<String>, Optional<Collection<PartitionAssignmentState>>>> groupOffsets = new TreeMap<>();
consumerGroups.forEach((groupId, consumerGroup) -> {
ConsumerGroupState state = consumerGroup.state();
@@ -737,19 +738,19 @@ public class ConsumerGroupCommand {
rowsWithConsumer.addAll(rowsWithoutConsumer);
- groupOffsets.put(groupId, new Tuple2<>(Optional.of(state.toString()), Optional.of(rowsWithConsumer)));
+ groupOffsets.put(groupId, new SimpleImmutableEntry<>(Optional.of(state.toString()), Optional.of(rowsWithConsumer)));
});
return groupOffsets;
}
- Tuple2<Optional<String>, Optional<Collection<MemberAssignmentState>>> collectGroupMembers(String groupId, boolean verbose) throws Exception {
+ Entry<Optional<String>, Optional<Collection<MemberAssignmentState>>> collectGroupMembers(String groupId, boolean verbose) throws Exception {
return collectGroupsMembers(Collections.singleton(groupId), verbose).get(groupId);
}
- TreeMap<String, Tuple2<Optional<String>, Optional<Collection<MemberAssignmentState>>>> collectGroupsMembers(Collection<String> groupIds, boolean verbose) throws Exception {
+ TreeMap<String, Entry<Optional<String>, Optional<Collection<MemberAssignmentState>>>> collectGroupsMembers(Collection<String> groupIds, boolean verbose) throws Exception {
Map<String, ConsumerGroupDescription> consumerGroups = describeConsumerGroups(groupIds);
- TreeMap<String, Tuple2<Optional<String>, Optional<Collection<MemberAssignmentState>>>> res = new TreeMap<>();
+ TreeMap<String, Entry<Optional<String>, Optional<Collection<MemberAssignmentState>>>> res = new TreeMap<>();
consumerGroups.forEach((groupId, consumerGroup) -> {
String state = consumerGroup.state().toString();
@@ -763,7 +764,7 @@ public class ConsumerGroupCommand {
consumer.assignment().topicPartitions().size(),
new ArrayList<>(verbose ? consumer.assignment().topicPartitions() : Collections.emptySet())
)).collect(Collectors.toList());
- res.put(groupId, new Tuple2<>(Optional.of(state), Optional.of(memberAssignmentStates)));
+ res.put(groupId, new SimpleImmutableEntry<>(Optional.of(state), Optional.of(memberAssignmentStates)));
});
return res;
}
@@ -836,7 +837,7 @@ public class ConsumerGroupCommand {
});
Map<TopicPartition, LogOffsetResult> successfulLogTimestampOffsets = successfulOffsetsForTimes.entrySet().stream()
- .collect(Collectors.toMap(Map.Entry::getKey, e -> new LogOffset(e.getValue().offset())));
+ .collect(Collectors.toMap(Entry::getKey, e -> new LogOffset(e.getValue().offset())));
unsuccessfulOffsetsForTimes.forEach((tp, offsetResultInfo) ->
System.out.println("\nWarn: Partition " + tp.partition() + " from topic " + tp.topic() +
@@ -991,7 +992,7 @@ public class ConsumerGroupCommand {
if (opts.options.has(opts.resetToOffsetOpt)) {
long offset = opts.options.valueOf(opts.resetToOffsetOpt);
return checkOffsetsRange(partitionsToReset.stream().collect(Collectors.toMap(Function.identity(), tp -> offset)))
- .entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new OffsetAndMetadata(e.getValue())));
+ .entrySet().stream().collect(Collectors.toMap(Entry::getKey, e -> new OffsetAndMetadata(e.getValue())));
} else if (opts.options.has(opts.resetToEarliestOpt)) {
Map<TopicPartition, LogOffsetResult> logStartOffsets = getLogStartOffsets(partitionsToReset);
return partitionsToReset.stream().collect(Collectors.toMap(Function.identity(), topicPartition -> {
@@ -1029,7 +1030,7 @@ public class ConsumerGroupCommand {
return currentOffset.offset() + shiftBy;
}));
return checkOffsetsRange(requestedOffsets).entrySet().stream()
- .collect(Collectors.toMap(Map.Entry::getKey, e -> new OffsetAndMetadata(e.getValue())));
+ .collect(Collectors.toMap(Entry::getKey, e -> new OffsetAndMetadata(e.getValue())));
} else if (opts.options.has(opts.resetToDatetimeOpt)) {
try {
long timestamp = Utils.getDateTime(opts.options.valueOf(opts.resetToDatetimeOpt));
@@ -1078,7 +1079,7 @@ public class ConsumerGroupCommand {
topicPartition -> resetPlanForGroup.get(topicPartition).offset()));
return checkOffsetsRange(requestedOffsets).entrySet().stream()
- .collect(Collectors.toMap(Map.Entry::getKey, e -> new OffsetAndMetadata(e.getValue())));
+ .collect(Collectors.toMap(Entry::getKey, e -> new OffsetAndMetadata(e.getValue())));
}).orElseGet(Collections::emptyMap);
} else if (opts.options.has(opts.resetToCurrentOpt)) {
Map<TopicPartition, OffsetAndMetadata> currentCommittedOffsets = getCommittedOffsets(groupId);
@@ -1104,7 +1105,7 @@ public class ConsumerGroupCommand {
}));
Map<TopicPartition, OffsetAndMetadata> preparedOffsetsForPartitionsWithoutCommittedOffset = getLogEndOffsets(partitionsToResetWithoutCommittedOffset)
- .entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> {
+ .entrySet().stream().collect(Collectors.toMap(Entry::getKey, e -> {
if (!(e.getValue() instanceof LogOffset)) {
ToolsUtils.printUsageAndExit(opts.parser, "Error getting ending offset of topic partition: " + e.getKey());
return null;
diff --git a/tools/src/main/java/org/apache/kafka/tools/reassign/ReassignPartitionsCommand.java b/tools/src/main/java/org/apache/kafka/tools/reassign/ReassignPartitionsCommand.java
index 36233469807..47c4a8234a1 100644
--- a/tools/src/main/java/org/apache/kafka/tools/reassign/ReassignPartitionsCommand.java
+++ b/tools/src/main/java/org/apache/kafka/tools/reassign/ReassignPartitionsCommand.java
@@ -49,9 +49,9 @@ import org.apache.kafka.server.util.json.JsonObject;
import org.apache.kafka.server.util.json.JsonValue;
import org.apache.kafka.tools.TerseException;
import org.apache.kafka.tools.ToolsUtils;
-import org.apache.kafka.tools.Tuple2;
import java.io.IOException;
+import java.util.AbstractMap.SimpleImmutableEntry;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
@@ -62,6 +62,7 @@ import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
+import java.util.Map.Entry;
import java.util.Objects;
import java.util.Optional;
import java.util.Properties;
@@ -203,20 +204,20 @@ public class ReassignPartitionsCommand {
String jsonString,
Boolean preserveThrottles
) throws ExecutionException, InterruptedException, JsonProcessingException {
- Tuple2<List<Tuple2<TopicPartition, List<Integer>>>, Map<TopicPartitionReplica, String>> t0 = parsePartitionReassignmentData(jsonString);
+ Entry<List<Entry<TopicPartition, List<Integer>>>, Map<TopicPartitionReplica, String>> t0 = parsePartitionReassignmentData(jsonString);
- List<Tuple2<TopicPartition, List<Integer>>> targetParts = t0.v1;
- Map<TopicPartitionReplica, String> targetLogDirs = t0.v2;
+ List<Entry<TopicPartition, List<Integer>>> targetParts = t0.getKey();
+ Map<TopicPartitionReplica, String> targetLogDirs = t0.getValue();
- Tuple2<Map<TopicPartition, PartitionReassignmentState>, Boolean> t1 = verifyPartitionAssignments(adminClient, targetParts);
+ Entry<Map<TopicPartition, PartitionReassignmentState>, Boolean> t1 = verifyPartitionAssignments(adminClient, targetParts);
- Map<TopicPartition, PartitionReassignmentState> partStates = t1.v1;
- Boolean partsOngoing = t1.v2;
+ Map<TopicPartition, PartitionReassignmentState> partStates = t1.getKey();
+ Boolean partsOngoing = t1.getValue();
- Tuple2<Map<TopicPartitionReplica, LogDirMoveState>, Boolean> t2 = verifyReplicaMoves(adminClient, targetLogDirs);
+ Entry<Map<TopicPartitionReplica, LogDirMoveState>, Boolean> t2 = verifyReplicaMoves(adminClient, targetLogDirs);
- Map<TopicPartitionReplica, LogDirMoveState> moveStates = t2.v1;
- Boolean movesOngoing = t2.v2;
+ Map<TopicPartitionReplica, LogDirMoveState> moveStates = t2.getKey();
+ Boolean movesOngoing = t2.getValue();
if (!partsOngoing && !movesOngoing && !preserveThrottles) {
// If the partition assignments and replica assignments are done, clear any throttles
@@ -240,11 +241,11 @@ public class ReassignPartitionsCommand {
* reassignments (including reassignments not described
* in the JSON file.)
*/
- private static Tuple2<Map<TopicPartition, PartitionReassignmentState>, Boolean> verifyPartitionAssignments(Admin adminClient,
- List<Tuple2<TopicPartition, List<Integer>>> targets
+ private static Entry<Map<TopicPartition, PartitionReassignmentState>, Boolean> verifyPartitionAssignments(Admin adminClient,
+ List<Entry<TopicPartition, List<Integer>>> targets
) throws ExecutionException, InterruptedException {
- Tuple2<Map<TopicPartition, PartitionReassignmentState>, Boolean> t0 = findPartitionReassignmentStates(adminClient, targets);
- System.out.println(partitionReassignmentStatesToString(t0.v1));
+ Entry<Map<TopicPartition, PartitionReassignmentState>, Boolean> t0 = findPartitionReassignmentStates(adminClient, targets);
+ System.out.println(partitionReassignmentStatesToString(t0.getKey()));
return t0;
}
@@ -301,27 +302,27 @@ public class ReassignPartitionsCommand {
* @return A tuple containing the reassignment states for each topic
* partition, plus whether there are any ongoing reassignments.
*/
- static Tuple2<Map<TopicPartition, PartitionReassignmentState>, Boolean> findPartitionReassignmentStates(Admin adminClient,
- List<Tuple2<TopicPartition,
+ static Entry<Map<TopicPartition, PartitionReassignmentState>, Boolean> findPartitionReassignmentStates(Admin adminClient,
+ List<Entry<TopicPartition,
List<Integer>>> targetReassignments
) throws ExecutionException, InterruptedException {
Map<TopicPartition, PartitionReassignment> currentReassignments = adminClient.
listPartitionReassignments().reassignments().get();
- List<Tuple2<TopicPartition, List<Integer>>> foundReassignments = new ArrayList<>();
- List<Tuple2<TopicPartition, List<Integer>>> notFoundReassignments = new ArrayList<>();
+ List<Entry<TopicPartition, List<Integer>>> foundReassignments = new ArrayList<>();
+ List<Entry<TopicPartition, List<Integer>>> notFoundReassignments = new ArrayList<>();
targetReassignments.forEach(reassignment -> {
- if (currentReassignments.containsKey(reassignment.v1))
+ if (currentReassignments.containsKey(reassignment.getKey()))
foundReassignments.add(reassignment);
else
notFoundReassignments.add(reassignment);
});
- List<Tuple2<TopicPartition, PartitionReassignmentState>> foundResults = foundReassignments.stream().map(e -> {
- TopicPartition part = e.v1;
- List<Integer> targetReplicas = e.v2;
- return new Tuple2<>(part,
+ List<Entry<TopicPartition, PartitionReassignmentState>> foundResults = foundReassignments.stream().map(e -> {
+ TopicPartition part = e.getKey();
+ List<Integer> targetReplicas = e.getValue();
+ return new SimpleImmutableEntry<>(part,
new PartitionReassignmentState(
currentReassignments.get(part).replicas(),
targetReplicas,
@@ -329,7 +330,7 @@ public class ReassignPartitionsCommand {
}).collect(Collectors.toList());
Set<String> topicNamesToLookUp = notFoundReassignments.stream()
- .map(e -> e.v1)
+ .map(e -> e.getKey())
.filter(part -> !currentReassignments.containsKey(part))
.map(TopicPartition::topic)
.collect(Collectors.toSet());
@@ -337,28 +338,28 @@ public class ReassignPartitionsCommand {
Map<String, KafkaFuture<TopicDescription>> topicDescriptions = adminClient.
describeTopics(topicNamesToLookUp).topicNameValues();
- List<Tuple2<TopicPartition, PartitionReassignmentState>> notFoundResults = new ArrayList<>();
- for (Tuple2<TopicPartition, List<Integer>> e : notFoundReassignments) {
- TopicPartition part = e.v1;
- List<Integer> targetReplicas = e.v2;
+ List<Entry<TopicPartition, PartitionReassignmentState>> notFoundResults = new ArrayList<>();
+ for (Entry<TopicPartition, List<Integer>> e : notFoundReassignments) {
+ TopicPartition part = e.getKey();
+ List<Integer> targetReplicas = e.getValue();
if (currentReassignments.containsKey(part)) {
PartitionReassignment reassignment = currentReassignments.get(part);
- notFoundResults.add(new Tuple2<>(part, new PartitionReassignmentState(
+ notFoundResults.add(new SimpleImmutableEntry<>(part, new PartitionReassignmentState(
reassignment.replicas(),
targetReplicas,
false)));
} else {
- notFoundResults.add(new Tuple2<>(part, topicDescriptionFutureToState(part.partition(),
+ notFoundResults.add(new SimpleImmutableEntry<>(part, topicDescriptionFutureToState(part.partition(),
topicDescriptions.get(part.topic()), targetReplicas)));
}
}
Map<TopicPartition, PartitionReassignmentState> allResults = new HashMap<>();
- foundResults.forEach(e -> allResults.put(e.v1, e.v2));
- notFoundResults.forEach(e -> allResults.put(e.v1, e.v2));
+ foundResults.forEach(e -> allResults.put(e.getKey(), e.getValue()));
+ notFoundResults.forEach(e -> allResults.put(e.getKey(), e.getValue()));
- return new Tuple2<>(allResults, !currentReassignments.isEmpty());
+ return new SimpleImmutableEntry<>(allResults, !currentReassignments.isEmpty());
}
private static PartitionReassignmentState topicDescriptionFutureToState(int partition,
@@ -396,12 +397,12 @@ public class ReassignPartitionsCommand {
* reassignments. (We don't have an efficient API that
* returns all ongoing replica reassignments.)
*/
- private static Tuple2<Map<TopicPartitionReplica, LogDirMoveState>, Boolean> verifyReplicaMoves(Admin adminClient,
+ private static Entry<Map<TopicPartitionReplica, LogDirMoveState>, Boolean> verifyReplicaMoves(Admin adminClient,
Map<TopicPartitionReplica, String> targetReassignments
) throws ExecutionException, InterruptedException {
Map<TopicPartitionReplica, LogDirMoveState> moveStates = findLogDirMoveStates(adminClient, targetReassignments);
System.out.println(replicaMoveStatesToString(moveStates));
- return new Tuple2<>(moveStates, !moveStates.values().stream().allMatch(LogDirMoveState::done));
+ return new SimpleImmutableEntry<>(moveStates, !moveStates.values().stream().allMatch(LogDirMoveState::done));
}
/**
@@ -420,7 +421,7 @@ public class ReassignPartitionsCommand {
Map<TopicPartitionReplica, DescribeReplicaLogDirsResult.ReplicaLogDirInfo> replicaLogDirInfos = adminClient
.describeReplicaLogDirs(targetMoves.keySet()).all().get();
- return targetMoves.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> {
+ return targetMoves.entrySet().stream().collect(Collectors.toMap(Entry::getKey, e -> {
TopicPartitionReplica replica = e.getKey();
String targetLogDir = e.getValue();
@@ -492,16 +493,16 @@ public class ReassignPartitionsCommand {
* @param targetParts The target partitions loaded from the JSON file.
*/
private static void clearAllThrottles(Admin adminClient,
- List<Tuple2<TopicPartition, List<Integer>>> targetParts
+ List<Entry<TopicPartition, List<Integer>>> targetParts
) throws ExecutionException, InterruptedException {
Set<Integer> brokers = adminClient.describeCluster().nodes().get().stream().map(Node::id).collect(Collectors.toSet());
- targetParts.forEach(t -> brokers.addAll(t.v2));
+ targetParts.forEach(t -> brokers.addAll(t.getValue()));
System.out.printf("Clearing broker-level throttles on broker%s %s%n",
brokers.size() == 1 ? "" : "s", Utils.join(brokers, ","));
clearBrokerLevelThrottles(adminClient, brokers);
- Set<String> topics = targetParts.stream().map(t -> t.v1.topic()).collect(Collectors.toSet());
+ Set<String> topics = targetParts.stream().map(t -> t.getKey().topic()).collect(Collectors.toSet());
System.out.printf("Clearing topic-level throttles on topic%s %s%n",
topics.size() == 1 ? "" : "s", Utils.join(topics, ","));
clearTopicLevelThrottles(adminClient, topics);
@@ -550,15 +551,15 @@ public class ReassignPartitionsCommand {
* @return A tuple containing the proposed assignment and the
* current assignment.
*/
- public static Tuple2<Map<TopicPartition, List<Integer>>, Map<TopicPartition, List<Integer>>> generateAssignment(Admin adminClient,
+ public static Entry<Map<TopicPartition, List<Integer>>, Map<TopicPartition, List<Integer>>> generateAssignment(Admin adminClient,
String reassignmentJson,
String brokerListString,
Boolean enableRackAwareness
) throws ExecutionException, InterruptedException, JsonProcessingException {
- Tuple2<List<Integer>, List<String>> t0 = parseGenerateAssignmentArgs(reassignmentJson, brokerListString);
+ Entry<List<Integer>, List<String>> t0 = parseGenerateAssignmentArgs(reassignmentJson, brokerListString);
- List<Integer> brokersToReassign = t0.v1;
- List<String> topicsToReassign = t0.v2;
+ List<Integer> brokersToReassign = t0.getKey();
+ List<String> topicsToReassign = t0.getValue();
Map<TopicPartition, List<Integer>> currentAssignments = getReplicaAssignmentForTopics(adminClient, topicsToReassign);
List<BrokerMetadata> brokerMetadatas = getBrokerMetadata(adminClient, brokersToReassign, enableRackAwareness);
@@ -567,7 +568,7 @@ public class ReassignPartitionsCommand {
formatAsReassignmentJson(currentAssignments, Collections.emptyMap()));
System.out.printf("Proposed partition reassignment configuration%n%s%n",
formatAsReassignmentJson(proposedAssignments, Collections.emptyMap()));
- return new Tuple2<>(proposedAssignments, currentAssignments);
+ return new SimpleImmutableEntry<>(proposedAssignments, currentAssignments);
}
/**
@@ -580,8 +581,8 @@ public class ReassignPartitionsCommand {
*/
private static Map<TopicPartition, List<Integer>> calculateAssignment(Map<TopicPartition, List<Integer>> currentAssignment,
List<BrokerMetadata> brokerMetadatas) {
- Map<String, List<Map.Entry<TopicPartition, List<Integer>>>> groupedByTopic = new HashMap<>();
- for (Map.Entry<TopicPartition, List<Integer>> e : currentAssignment.entrySet())
+ Map<String, List<Entry<TopicPartition, List<Integer>>>> groupedByTopic = new HashMap<>();
+ for (Entry<TopicPartition, List<Integer>> e : currentAssignment.entrySet())
groupedByTopic.computeIfAbsent(e.getKey().topic(), k -> new ArrayList<>()).add(e);
Map<TopicPartition, List<Integer>> proposedAssignments = new HashMap<>();
groupedByTopic.forEach((topic, assignment) -> {
@@ -598,7 +599,7 @@ public class ReassignPartitionsCommand {
Set<String> topics) throws ExecutionException, InterruptedException {
Map<String, KafkaFuture<TopicDescription>> futures = adminClient.describeTopics(topics).topicNameValues();
Map<String, TopicDescription> res = new HashMap<>();
- for (Map.Entry<String, KafkaFuture<TopicDescription>> e : futures.entrySet()) {
+ for (Entry<String, KafkaFuture<TopicDescription>> e : futures.entrySet()) {
String topicName = e.getKey();
KafkaFuture<TopicDescription> topicDescriptionFuture = e.getValue();
try {
@@ -695,7 +696,7 @@ public class ReassignPartitionsCommand {
*
* @return A tuple of brokers to reassign, topics to reassign
*/
- static Tuple2<List<Integer>, List<String>> parseGenerateAssignmentArgs(String reassignmentJson,
+ static Entry<List<Integer>, List<String>> parseGenerateAssignmentArgs(String reassignmentJson,
String brokerList) throws JsonMappingException {
List<Integer> brokerListToReassign = Arrays.stream(brokerList.split(",")).map(Integer::parseInt).collect(Collectors.toList());
Set<Integer> duplicateReassignments = ToolsUtils.duplicates(brokerListToReassign);
@@ -706,7 +707,7 @@ public class ReassignPartitionsCommand {
if (!duplicateTopicsToReassign.isEmpty())
throw new AdminCommandFailedException(String.format("List of topics to reassign contains duplicate entries: %s",
duplicateTopicsToReassign));
- return new Tuple2<>(brokerListToReassign, topicsToReassign);
+ return new SimpleImmutableEntry<>(brokerListToReassign, topicsToReassign);
}
/**
@@ -731,10 +732,10 @@ public class ReassignPartitionsCommand {
Long timeoutMs,
Time time
) throws ExecutionException, InterruptedException, JsonProcessingException, TerseException {
- Tuple2<Map<TopicPartition, List<Integer>>, Map<TopicPartitionReplica, String>> t0 = parseExecuteAssignmentArgs(reassignmentJson);
+ Entry<Map<TopicPartition, List<Integer>>, Map<TopicPartitionReplica, String>> t0 = parseExecuteAssignmentArgs(reassignmentJson);
- Map<TopicPartition, List<Integer>> proposedParts = t0.v1;
- Map<TopicPartitionReplica, String> proposedReplicas = t0.v2;
+ Map<TopicPartition, List<Integer>> proposedParts = t0.getKey();
+ Map<TopicPartitionReplica, String> proposedReplicas = t0.getValue();
Map<TopicPartition, PartitionReassignment> currentReassignments = adminClient.
listPartitionReassignments().reassignments().get();
// If there is an existing assignment, check for --additional before proceeding.
@@ -901,7 +902,7 @@ public class ReassignPartitionsCommand {
Map<TopicPartition, List<Integer>> currentParts) throws JsonProcessingException {
Map<TopicPartition, List<Integer>> partitionsToBeReassigned = currentParts.entrySet().stream()
.filter(e -> proposedParts.containsKey(e.getKey()))
- .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+ .collect(Collectors.toMap(Entry::getKey, Entry::getValue));
return String.format("Current partition replica assignment%n%n%s%n%nSave this to use as the %s",
formatAsReassignmentJson(partitionsToBeReassigned, Collections.emptyMap()),
@@ -921,7 +922,7 @@ public class ReassignPartitionsCommand {
reassignments.forEach((part, replicas) -> args.put(part, Optional.of(new NewPartitionReassignment(replicas))));
Map<TopicPartition, KafkaFuture<Void>> results = adminClient.alterPartitionReassignments(args).values();
Map<TopicPartition, Throwable> errors = new HashMap<>();
- for (Map.Entry<TopicPartition, KafkaFuture<Void>> e : results.entrySet()) {
+ for (Entry<TopicPartition, KafkaFuture<Void>> e : results.entrySet()) {
try {
e.getValue().get();
} catch (ExecutionException t) {
@@ -945,7 +946,7 @@ public class ReassignPartitionsCommand {
Map<TopicPartition, KafkaFuture<Void>> results = adminClient.alterPartitionReassignments(args).values();
Map<TopicPartition, Throwable> errors = new HashMap<>();
- for (Map.Entry<TopicPartition, KafkaFuture<Void>> e : results.entrySet()) {
+ for (Entry<TopicPartition, KafkaFuture<Void>> e : results.entrySet()) {
try {
e.getValue().get();
} catch (ExecutionException t) {
@@ -993,7 +994,7 @@ public class ReassignPartitionsCommand {
Map<TopicPartition, List<Integer>> proposedParts,
Map<TopicPartition, List<Integer>> currentParts) {
Map<String, Map<Integer, PartitionMove>> moveMap = calculateCurrentMoveMap(currentReassignments);
- for (Map.Entry<TopicPartition, List<Integer>> e : proposedParts.entrySet()) {
+ for (Entry<TopicPartition, List<Integer>> e : proposedParts.entrySet()) {
TopicPartition part = e.getKey();
List<Integer> replicas = e.getValue();
Map<Integer, PartitionMove> partMoves = moveMap.computeIfAbsent(part.topic(), k -> new HashMap<>());
@@ -1178,39 +1179,39 @@ public class ReassignPartitionsCommand {
* @return A tuple of the partitions to be reassigned and the replicas
* to be reassigned.
*/
- static Tuple2<Map<TopicPartition, List<Integer>>, Map<TopicPartitionReplica, String>> parseExecuteAssignmentArgs(
+ static Entry<Map<TopicPartition, List<Integer>>, Map<TopicPartitionReplica, String>> parseExecuteAssignmentArgs(
String reassignmentJson
) throws JsonProcessingException {
- Tuple2<List<Tuple2<TopicPartition, List<Integer>>>, Map<TopicPartitionReplica, String>> t0 = parsePartitionReassignmentData(reassignmentJson);
+ Entry<List<Entry<TopicPartition, List<Integer>>>, Map<TopicPartitionReplica, String>> t0 = parsePartitionReassignmentData(reassignmentJson);
- List<Tuple2<TopicPartition, List<Integer>>> partitionsToBeReassigned = t0.v1;
- Map<TopicPartitionReplica, String> replicaAssignment = t0.v2;
+ List<Entry<TopicPartition, List<Integer>>> partitionsToBeReassigned = t0.getKey();
+ Map<TopicPartitionReplica, String> replicaAssignment = t0.getValue();
if (partitionsToBeReassigned.isEmpty())
throw new AdminCommandFailedException("Partition reassignment list cannot be empty");
- if (partitionsToBeReassigned.stream().anyMatch(t -> t.v2.isEmpty())) {
+ if (partitionsToBeReassigned.stream().anyMatch(t -> t.getValue().isEmpty())) {
throw new AdminCommandFailedException("Partition replica list cannot be empty");
}
- Set<TopicPartition> duplicateReassignedPartitions = ToolsUtils.duplicates(partitionsToBeReassigned.stream().map(t -> t.v1).collect(Collectors.toList()));
+ Set<TopicPartition> duplicateReassignedPartitions = ToolsUtils.duplicates(partitionsToBeReassigned.stream().map(t -> t.getKey()).collect(Collectors.toList()));
if (!duplicateReassignedPartitions.isEmpty()) {
throw new AdminCommandFailedException(String.format(
"Partition reassignment contains duplicate topic partitions: %s",
duplicateReassignedPartitions.stream().map(Object::toString).collect(Collectors.joining(",")))
);
}
- List<Tuple2<TopicPartition, Set<Integer>>> duplicateEntries = partitionsToBeReassigned.stream()
- .map(t -> new Tuple2<>(t.v1, ToolsUtils.duplicates(t.v2)))
- .filter(t -> !t.v2.isEmpty())
+ List<Entry<TopicPartition, Set<Integer>>> duplicateEntries = partitionsToBeReassigned.stream()
+ .map(t -> new SimpleImmutableEntry<>(t.getKey(), ToolsUtils.duplicates(t.getValue())))
+ .filter(t -> !t.getValue().isEmpty())
.collect(Collectors.toList());
if (!duplicateEntries.isEmpty()) {
String duplicatesMsg = duplicateEntries.stream().map(t ->
String.format("%s contains multiple entries for %s",
- t.v1,
- t.v2.stream().map(Object::toString).collect(Collectors.joining(",")))
+ t.getKey(),
+ t.getValue().stream().map(Object::toString).collect(Collectors.joining(",")))
).collect(Collectors.joining(". "));
throw new AdminCommandFailedException(String.format("Partition replica lists may not contain duplicate entries: %s", duplicatesMsg));
}
- return new Tuple2<>(partitionsToBeReassigned.stream().collect(Collectors.toMap(t -> t.v1, t -> t.v2)), replicaAssignment);
+ return new SimpleImmutableEntry<>(partitionsToBeReassigned.stream().collect(Collectors.toMap(t -> t.getKey(), t -> t.getValue())), replicaAssignment);
}
/**
@@ -1226,17 +1227,17 @@ public class ReassignPartitionsCommand {
* @return A tuple of the partition reassignments that were cancelled,
* and the replica movements that were cancelled.
*/
- static Tuple2<Set<TopicPartition>, Set<TopicPartitionReplica>> cancelAssignment(Admin adminClient,
+ static Entry<Set<TopicPartition>, Set<TopicPartitionReplica>> cancelAssignment(Admin adminClient,
String jsonString,
Boolean preserveThrottles,
Long timeoutMs,
Time time
) throws ExecutionException, InterruptedException, JsonProcessingException, TerseException {
- Tuple2<List<Tuple2<TopicPartition, List<Integer>>>, Map<TopicPartitionReplica, String>> t0 = parsePartitionReassignmentData(jsonString);
+ Entry<List<Entry<TopicPartition, List<Integer>>>, Map<TopicPartitionReplica, String>> t0 = parsePartitionReassignmentData(jsonString);
- List<Tuple2<TopicPartition, List<Integer>>> targetParts = t0.v1;
- Map<TopicPartitionReplica, String> targetReplicas = t0.v2;
- Set<TopicPartition> targetPartsSet = targetParts.stream().map(t -> t.v1).collect(Collectors.toSet());
+ List<Entry<TopicPartition, List<Integer>>> targetParts = t0.getKey();
+ Map<TopicPartitionReplica, String> targetReplicas = t0.getValue();
+ Set<TopicPartition> targetPartsSet = targetParts.stream().map(t -> t.getKey()).collect(Collectors.toSet());
Set<TopicPartition> curReassigningParts = new HashSet<>();
adminClient.listPartitionReassignments(targetPartsSet).reassignments().get().forEach((part, reassignment) -> {
if (reassignment.addingReplicas().isEmpty() || !reassignment.removingReplicas().isEmpty())
@@ -1273,7 +1274,7 @@ public class ReassignPartitionsCommand {
if (!preserveThrottles) {
clearAllThrottles(adminClient, targetParts);
}
- return new Tuple2<>(curReassigningParts, curMovingParts.keySet());
+ return new SimpleImmutableEntry<>(curReassigningParts, curMovingParts.keySet());
}
public static String formatAsReassignmentJson(Map<TopicPartition, List<Integer>> partitionsToBeReassigned,
@@ -1330,7 +1331,7 @@ public class ReassignPartitionsCommand {
}
}
- private static Tuple2<List<Tuple2<TopicPartition, List<Integer>>>, Map<TopicPartitionReplica, String>> parsePartitionReassignmentData(
+ private static Entry<List<Entry<TopicPartition, List<Integer>>>, Map<TopicPartitionReplica, String>> parsePartitionReassignmentData(
String jsonData
) throws JsonProcessingException {
JsonValue js;
@@ -1344,12 +1345,12 @@ public class ReassignPartitionsCommand {
}
// Parses without deduplicating keys so the data can be checked before allowing reassignment to proceed
- private static Tuple2<List<Tuple2<TopicPartition, List<Integer>>>, Map<TopicPartitionReplica, String>> parsePartitionReassignmentData(
+ private static Entry<List<Entry<TopicPartition, List<Integer>>>, Map<TopicPartitionReplica, String>> parsePartitionReassignmentData(
int version, JsonValue jsonData
) throws JsonMappingException {
switch (version) {
case 1:
- List<Tuple2<TopicPartition, List<Integer>>> partitionAssignment = new ArrayList<>();
+ List<Entry<TopicPartition, List<Integer>>> partitionAssignment = new ArrayList<>();
Map<TopicPartitionReplica, String> replicaAssignment = new HashMap<>();
Optional<JsonValue> partitionsSeq = jsonData.asJsonObject().get("partitions");
@@ -1369,7 +1370,7 @@ public class ReassignPartitionsCommand {
if (newReplicas.size() != newLogDirs.size())
throw new AdminCommandFailedException("Size of replicas list " + newReplicas + " is different from " +
"size of log dirs list " + newLogDirs + " for partition " + new TopicPartition(topic, partition));
- partitionAssignment.add(new Tuple2<>(new TopicPartition(topic, partition), newReplicas));
+ partitionAssignment.add(new SimpleImmutableEntry<>(new TopicPartition(topic, partition), newReplicas));
for (int i = 0; i < newLogDirs.size(); i++) {
Integer replica = newReplicas.get(i);
String logDir = newLogDirs.get(i);
@@ -1382,7 +1383,7 @@ public class ReassignPartitionsCommand {
}
}
- return new Tuple2<>(partitionAssignment, replicaAssignment);
+ return new SimpleImmutableEntry<>(partitionAssignment, replicaAssignment);
default:
throw new AdminOperationException("Not supported version field value " + version);
@@ -1481,7 +1482,7 @@ public class ReassignPartitionsCommand {
Set<TopicPartitionReplica> results = new HashSet<>();
Map<TopicPartitionReplica, KafkaFuture<Void>> values = adminClient.alterReplicaLogDirs(assignment).values();
- for (Map.Entry<TopicPartitionReplica, KafkaFuture<Void>> e : values.entrySet()) {
+ for (Entry<TopicPartitionReplica, KafkaFuture<Void>> e : values.entrySet()) {
TopicPartitionReplica replica = e.getKey();
KafkaFuture<Void> future = e.getValue();
try {
diff --git a/tools/src/test/java/org/apache/kafka/tools/ToolsTestUtils.java b/tools/src/test/java/org/apache/kafka/tools/ToolsTestUtils.java
index 0bb2c9c9d1b..d427828f2c7 100644
--- a/tools/src/test/java/org/apache/kafka/tools/ToolsTestUtils.java
+++ b/tools/src/test/java/org/apache/kafka/tools/ToolsTestUtils.java
@@ -31,12 +31,14 @@ import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.PrintStream;
+import java.util.AbstractMap.SimpleImmutableEntry;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import java.util.Map.Entry;
import java.util.Properties;
import java.util.Set;
import java.util.concurrent.ExecutionException;
@@ -155,7 +157,7 @@ public class ToolsTestUtils {
}
public static void assignThrottledPartitionReplicas(Admin adminClient, Map<TopicPartition, List<Integer>> allReplicasByPartition) throws InterruptedException, ExecutionException {
- Map<ConfigResource, List<Map.Entry<TopicPartition, List<Integer>>>> configResourceToPartitionReplicas =
+ Map<ConfigResource, List<Entry<TopicPartition, List<Integer>>>> configResourceToPartitionReplicas =
allReplicasByPartition.entrySet().stream()
.collect(Collectors.groupingBy(
topicPartitionListEntry -> new ConfigResource(ConfigResource.Type.TOPIC, topicPartitionListEntry.getKey().topic()))
@@ -163,10 +165,10 @@ public class ToolsTestUtils {
Map<ConfigResource, List<AlterConfigOp>> throttles = configResourceToPartitionReplicas.entrySet().stream()
.collect(
- Collectors.toMap(Map.Entry::getKey, entry -> {
+ Collectors.toMap(Entry::getKey, entry -> {
List<AlterConfigOp> alterConfigOps = new ArrayList<>();
Map<TopicPartition, List<Integer>> replicaThrottle =
- entry.getValue().stream().collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+ entry.getValue().stream().collect(Collectors.toMap(Entry::getKey, Entry::getValue));
alterConfigOps.add(new AlterConfigOp(
new ConfigEntry(LogConfig.LEADER_REPLICATION_THROTTLED_REPLICAS_CONFIG, formatReplicaThrottles(replicaThrottle)),
AlterConfigOp.OpType.SET));
@@ -204,7 +206,7 @@ public class ToolsTestUtils {
public static File tempPropertiesFile(Map<String, String> properties) throws IOException {
StringBuilder sb = new StringBuilder();
- for (Map.Entry<String, String> entry : properties.entrySet()) {
+ for (Entry<String, String> entry : properties.entrySet()) {
sb.append(entry.getKey() + "=" + entry.getValue() + System.lineSeparator());
}
return org.apache.kafka.test.TestUtils.tempFile(sb.toString());
@@ -249,7 +251,7 @@ public class ToolsTestUtils {
/**
* Capture both the console output and console error during the execution of the provided function.
*/
- public static Tuple2<String, String> grabConsoleOutputAndError(Runnable f) {
+ public static Entry<String, String> grabConsoleOutputAndError(Runnable f) {
ByteArrayOutputStream outBuf = new ByteArrayOutputStream();
ByteArrayOutputStream errBuf = new ByteArrayOutputStream();
PrintStream out = new PrintStream(outBuf);
@@ -267,7 +269,7 @@ public class ToolsTestUtils {
}
out.flush();
err.flush();
- return new Tuple2<>(outBuf.toString(), errBuf.toString());
+ return new SimpleImmutableEntry<>(outBuf.toString(), errBuf.toString());
}
public static class MockExitProcedure implements Exit.Procedure {
diff --git a/tools/src/test/java/org/apache/kafka/tools/consumer/group/ConsumerGroupServiceTest.java b/tools/src/test/java/org/apache/kafka/tools/consumer/group/ConsumerGroupServiceTest.java
index b7583c1c44f..4fd7e3b9197 100644
--- a/tools/src/test/java/org/apache/kafka/tools/consumer/group/ConsumerGroupServiceTest.java
+++ b/tools/src/test/java/org/apache/kafka/tools/consumer/group/ConsumerGroupServiceTest.java
@@ -38,7 +38,6 @@ import org.apache.kafka.common.TopicPartition;
import org.apache.kafka.common.TopicPartitionInfo;
import org.apache.kafka.common.internals.KafkaFutureImpl;
import org.apache.kafka.common.utils.Utils;
-import org.apache.kafka.tools.Tuple2;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentMatcher;
import org.mockito.ArgumentMatchers;
@@ -49,11 +48,12 @@ import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
-import java.util.Objects;
-import java.util.Set;
import java.util.List;
import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Objects;
import java.util.Optional;
+import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
@@ -91,10 +91,10 @@ public class ConsumerGroupServiceTest {
when(admin.listOffsets(offsetsArgMatcher(), any()))
.thenReturn(listOffsetsResult());
- Tuple2<Optional<String>, Optional<Collection<PartitionAssignmentState>>> statesAndAssignments = groupService.collectGroupOffsets(GROUP);
- assertEquals(Optional.of("Stable"), statesAndAssignments.v1);
- assertTrue(statesAndAssignments.v2.isPresent());
- assertEquals(TOPIC_PARTITIONS.size(), statesAndAssignments.v2.get().size());
+ Entry<Optional<String>, Optional<Collection<PartitionAssignmentState>>> statesAndAssignments = groupService.collectGroupOffsets(GROUP);
+ assertEquals(Optional.of("Stable"), statesAndAssignments.getKey());
+ assertTrue(statesAndAssignments.getValue().isPresent());
+ assertEquals(TOPIC_PARTITIONS.size(), statesAndAssignments.getValue().get().size());
verify(admin, times(1)).describeConsumerGroups(ArgumentMatchers.eq(Collections.singletonList(GROUP)), any());
verify(admin, times(1)).listConsumerGroupOffsets(ArgumentMatchers.eq(listConsumerGroupOffsetsSpec()), any());
@@ -157,16 +157,16 @@ public class ConsumerGroupServiceTest {
ArgumentMatchers.argThat(offsetsArgMatcher.apply(assignedTopicPartitions)),
any()
)).thenReturn(new ListOffsetsResult(endOffsets.entrySet().stream().filter(e -> assignedTopicPartitions.contains(e.getKey()))
- .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue))));
+ .collect(Collectors.toMap(Entry::getKey, Entry::getValue))));
when(admin.listOffsets(
ArgumentMatchers.argThat(offsetsArgMatcher.apply(unassignedTopicPartitions)),
any()
)).thenReturn(new ListOffsetsResult(endOffsets.entrySet().stream().filter(e -> unassignedTopicPartitions.contains(e.getKey()))
- .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue))));
+ .collect(Collectors.toMap(Entry::getKey, Entry::getValue))));
- Tuple2<Optional<String>, Optional<Collection<PartitionAssignmentState>>> statesAndAssignments = groupService.collectGroupOffsets(GROUP);
- Optional<String> state = statesAndAssignments.v1;
- Optional<Collection<PartitionAssignmentState>> assignments = statesAndAssignments.v2;
+ Entry<Optional<String>, Optional<Collection<PartitionAssignmentState>>> statesAndAssignments = groupService.collectGroupOffsets(GROUP);
+ Optional<String> state = statesAndAssignments.getKey();
+ Optional<Collection<PartitionAssignmentState>> assignments = statesAndAssignments.getValue();
Map<TopicPartition, Optional<Long>> returnedOffsets = assignments.map(results ->
results.stream().collect(Collectors.toMap(
diff --git a/tools/src/test/java/org/apache/kafka/tools/consumer/group/DeleteConsumerGroupsTest.java b/tools/src/test/java/org/apache/kafka/tools/consumer/group/DeleteConsumerGroupsTest.java
index 95fe212c531..b8133433d64 100644
--- a/tools/src/test/java/org/apache/kafka/tools/consumer/group/DeleteConsumerGroupsTest.java
+++ b/tools/src/test/java/org/apache/kafka/tools/consumer/group/DeleteConsumerGroupsTest.java
@@ -92,7 +92,7 @@ public class DeleteConsumerGroupsTest extends ConsumerGroupCommandTest {
ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs);
TestUtils.waitForCondition(
- () -> service.collectGroupMembers(GROUP, false).v2.get().size() == 1,
+ () -> service.collectGroupMembers(GROUP, false).getValue().get().size() == 1,
"The group did not initialize as expected."
);
@@ -112,7 +112,7 @@ public class DeleteConsumerGroupsTest extends ConsumerGroupCommandTest {
ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs);
TestUtils.waitForCondition(
- () -> service.collectGroupMembers(GROUP, false).v2.get().size() == 1,
+ () -> service.collectGroupMembers(GROUP, false).getValue().get().size() == 1,
"The group did not initialize as expected."
);
diff --git a/tools/src/test/java/org/apache/kafka/tools/consumer/group/DeleteOffsetsConsumerGroupCommandIntegrationTest.java b/tools/src/test/java/org/apache/kafka/tools/consumer/group/DeleteOffsetsConsumerGroupCommandIntegrationTest.java
index 05fd00071e1..292180b8af9 100644
--- a/tools/src/test/java/org/apache/kafka/tools/consumer/group/DeleteOffsetsConsumerGroupCommandIntegrationTest.java
+++ b/tools/src/test/java/org/apache/kafka/tools/consumer/group/DeleteOffsetsConsumerGroupCommandIntegrationTest.java
@@ -29,12 +29,12 @@ import org.apache.kafka.common.serialization.ByteArrayDeserializer;
import org.apache.kafka.common.serialization.ByteArraySerializer;
import org.apache.kafka.common.utils.Utils;
import org.apache.kafka.server.config.Defaults;
-import org.apache.kafka.tools.Tuple2;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;
import java.util.Collections;
import java.util.Map;
+import java.util.Map.Entry;
import java.util.Properties;
import java.util.concurrent.ExecutionException;
@@ -60,8 +60,8 @@ public class DeleteOffsetsConsumerGroupCommandIntegrationTest extends ConsumerGr
String topic = "foo:1";
ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(getArgs(group, topic));
- Tuple2<Errors, Map<TopicPartition, Throwable>> res = service.deleteOffsets(group, Collections.singletonList(topic));
- assertEquals(Errors.GROUP_ID_NOT_FOUND, res.v1);
+ Entry<Errors, Map<TopicPartition, Throwable>> res = service.deleteOffsets(group, Collections.singletonList(topic));
+ assertEquals(Errors.GROUP_ID_NOT_FOUND, res.getKey());
}
@ParameterizedTest(name = TEST_WITH_PARAMETERIZED_QUORUM_NAME)
@@ -145,9 +145,9 @@ public class DeleteOffsetsConsumerGroupCommandIntegrationTest extends ConsumerGr
withConsumerGroup.accept(() -> {
String topic = inputPartition >= 0 ? inputTopic + ":" + inputPartition : inputTopic;
ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(getArgs(GROUP, topic));
- Tuple2<Errors, Map<TopicPartition, Throwable>> res = service.deleteOffsets(GROUP, Collections.singletonList(topic));
- Errors topLevelError = res.v1;
- Map<TopicPartition, Throwable> partitions = res.v2;
+ Entry<Errors, Map<TopicPartition, Throwable>> res = service.deleteOffsets(GROUP, Collections.singletonList(topic));
+ Errors topLevelError = res.getKey();
+ Map<TopicPartition, Throwable> partitions = res.getValue();
TopicPartition tp = new TopicPartition(inputTopic, expectedPartition);
// Partition level error should propagate to top level, unless this is due to a missed partition attempt.
if (inputPartition >= 0) {
diff --git a/tools/src/test/java/org/apache/kafka/tools/consumer/group/DescribeConsumerGroupTest.java b/tools/src/test/java/org/apache/kafka/tools/consumer/group/DescribeConsumerGroupTest.java
index 85f9f5b836a..f1b6bba9ac1 100644
--- a/tools/src/test/java/org/apache/kafka/tools/consumer/group/DescribeConsumerGroupTest.java
+++ b/tools/src/test/java/org/apache/kafka/tools/consumer/group/DescribeConsumerGroupTest.java
@@ -24,7 +24,6 @@ import org.apache.kafka.common.errors.TimeoutException;
import org.apache.kafka.common.utils.Exit;
import org.apache.kafka.test.TestUtils;
import org.apache.kafka.tools.ToolsTestUtils;
-import org.apache.kafka.tools.Tuple2;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;
import org.junit.jupiter.params.provider.ValueSource;
@@ -34,6 +33,7 @@ import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
+import java.util.Map.Entry;
import java.util.Objects;
import java.util.Optional;
import java.util.Properties;
@@ -138,8 +138,8 @@ public class DescribeConsumerGroupTest extends ConsumerGroupCommandTest {
String[] cgcArgs = new String[]{"--bootstrap-server", bootstrapServers(listenerName()), "--describe", "--group", group};
ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs);
- Tuple2<Optional<String>, Optional<Collection<PartitionAssignmentState>>> res = service.collectGroupOffsets(group);
- assertTrue(res.v1.map(s -> s.contains("Dead")).orElse(false) && res.v2.map(Collection::isEmpty).orElse(false),
+ Entry<Optional<String>, Optional<Collection<PartitionAssignmentState>>> res = service.collectGroupOffsets(group);
+ assertTrue(res.getKey().map(s -> s.contains("Dead")).orElse(false) && res.getValue().map(Collection::isEmpty).orElse(false),
"Expected the state to be 'Dead', with no members in the group '" + group + "'.");
}
@@ -155,12 +155,12 @@ public class DescribeConsumerGroupTest extends ConsumerGroupCommandTest {
String[] cgcArgs = new String[]{"--bootstrap-server", bootstrapServers(listenerName()), "--describe", "--group", group};
ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs);
- Tuple2<Optional<String>, Optional<Collection<MemberAssignmentState>>> res = service.collectGroupMembers(group, false);
- assertTrue(res.v1.map(s -> s.contains("Dead")).orElse(false) && res.v2.map(Collection::isEmpty).orElse(false),
+ Entry<Optional<String>, Optional<Collection<MemberAssignmentState>>> res = service.collectGroupMembers(group, false);
+ assertTrue(res.getKey().map(s -> s.contains("Dead")).orElse(false) && res.getValue().map(Collection::isEmpty).orElse(false),
"Expected the state to be 'Dead', with no members in the group '" + group + "'.");
- Tuple2<Optional<String>, Optional<Collection<MemberAssignmentState>>> res2 = service.collectGroupMembers(group, true);
- assertTrue(res2.v1.map(s -> s.contains("Dead")).orElse(false) && res2.v2.map(Collection::isEmpty).orElse(false),
+ Entry<Optional<String>, Optional<Collection<MemberAssignmentState>>> res2 = service.collectGroupMembers(group, true);
+ assertTrue(res2.getKey().map(s -> s.contains("Dead")).orElse(false) && res2.getValue().map(Collection::isEmpty).orElse(false),
"Expected the state to be 'Dead', with no members in the group '" + group + "' (verbose option).");
}
@@ -197,8 +197,8 @@ public class DescribeConsumerGroupTest extends ConsumerGroupCommandTest {
ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs.toArray(new String[0]));
TestUtils.waitForCondition(() -> {
- Tuple2<String, String> res = ToolsTestUtils.grabConsoleOutputAndError(describeGroups(service));
- return res.v1.trim().split("\n").length == 2 && res.v2.isEmpty();
+ Entry<String, String> res = ToolsTestUtils.grabConsoleOutputAndError(describeGroups(service));
+ return res.getKey().trim().split("\n").length == 2 && res.getValue().isEmpty();
}, "Expected a data row and no error in describe results with describe type " + String.join(" ", describeType) + ".");
}
}
@@ -226,9 +226,9 @@ public class DescribeConsumerGroupTest extends ConsumerGroupCommandTest {
ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs.toArray(new String[0]));
TestUtils.waitForCondition(() -> {
- Tuple2<String, String> res = ToolsTestUtils.grabConsoleOutputAndError(describeGroups(service));
- long numLines = Arrays.stream(res.v1.trim().split("\n")).filter(line -> !line.isEmpty()).count();
- return (numLines == expectedNumLines) && res.v2.isEmpty();
+ Entry<String, String> res = ToolsTestUtils.grabConsoleOutputAndError(describeGroups(service));
+ long numLines = Arrays.stream(res.getKey().trim().split("\n")).filter(line -> !line.isEmpty()).count();
+ return (numLines == expectedNumLines) && res.getValue().isEmpty();
}, "Expected a data row and no error in describe results with describe type " + String.join(" ", describeType) + ".");
}
}
@@ -252,9 +252,9 @@ public class DescribeConsumerGroupTest extends ConsumerGroupCommandTest {
ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs.toArray(new String[0]));
TestUtils.waitForCondition(() -> {
- Tuple2<String, String> res = ToolsTestUtils.grabConsoleOutputAndError(describeGroups(service));
- long numLines = Arrays.stream(res.v1.trim().split("\n")).filter(s -> !s.isEmpty()).count();
- return (numLines == expectedNumLines) && res.v2.isEmpty();
+ Entry<String, String> res = ToolsTestUtils.grabConsoleOutputAndError(describeGroups(service));
+ long numLines = Arrays.stream(res.getKey().trim().split("\n")).filter(s -> !s.isEmpty()).count();
+ return (numLines == expectedNumLines) && res.getValue().isEmpty();
}, "Expected a data row and no error in describe results with describe type " + String.join(" ", describeType) + ".");
}
}
@@ -271,9 +271,9 @@ public class DescribeConsumerGroupTest extends ConsumerGroupCommandTest {
ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs);
TestUtils.waitForCondition(() -> {
- Tuple2<Optional<String>, Optional<Collection<PartitionAssignmentState>>> groupOffsets = service.collectGroupOffsets(GROUP);
- Optional<String> state = groupOffsets.v1;
- Optional<Collection<PartitionAssignmentState>> assignments = groupOffsets.v2;
+ Entry<Optional<String>, Optional<Collection<PartitionAssignmentState>>> groupOffsets = service.collectGroupOffsets(GROUP);
+ Optional<String> state = groupOffsets.getKey();
+ Optional<Collection<PartitionAssignmentState>> assignments = groupOffsets.getValue();
Predicate<PartitionAssignmentState> isGrp = s -> Objects.equals(s.group, GROUP);
@@ -307,9 +307,9 @@ public class DescribeConsumerGroupTest extends ConsumerGroupCommandTest {
ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs);
TestUtils.waitForCondition(() -> {
- Tuple2<Optional<String>, Optional<Collection<MemberAssignmentState>>> groupMembers = service.collectGroupMembers(GROUP, false);
- Optional<String> state = groupMembers.v1;
- Optional<Collection<MemberAssignmentState>> assignments = groupMembers.v2;
+ Entry<Optional<String>, Optional<Collection<MemberAssignmentState>>> groupMembers = service.collectGroupMembers(GROUP, false);
+ Optional<String> state = groupMembers.getKey();
+ Optional<Collection<MemberAssignmentState>> assignments = groupMembers.getValue();
Predicate<MemberAssignmentState> isGrp = s -> Objects.equals(s.group, GROUP);
@@ -331,10 +331,10 @@ public class DescribeConsumerGroupTest extends ConsumerGroupCommandTest {
!Objects.equals(assignmentState.host, ConsumerGroupCommand.MISSING_COLUMN_VALUE);
}, "Expected a 'Stable' group status, rows and valid member information for group " + GROUP + ".");
- Tuple2<Optional<String>, Optional<Collection<MemberAssignmentState>>> res = service.collectGroupMembers(GROUP, true);
+ Entry<Optional<String>, Optional<Collection<MemberAssignmentState>>> res = service.collectGroupMembers(GROUP, true);
- if (res.v2.isPresent()) {
- assertTrue(res.v2.get().size() == 1 && res.v2.get().iterator().next().assignment.size() == 1,
+ if (res.getValue().isPresent()) {
+ assertTrue(res.getValue().get().size() == 1 && res.getValue().get().iterator().next().assignment.size() == 1,
"Expected a topic partition assigned to the single group member for group " + GROUP);
} else {
fail("Expected partition assignments for members of group " + GROUP);
@@ -407,8 +407,8 @@ public class DescribeConsumerGroupTest extends ConsumerGroupCommandTest {
ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs.toArray(new String[0]));
TestUtils.waitForCondition(() -> {
- Tuple2<String, String> res = ToolsTestUtils.grabConsoleOutputAndError(describeGroups(service));
- return res.v1.trim().split("\n").length == 2 && res.v2.isEmpty();
+ Entry<String, String> res = ToolsTestUtils.grabConsoleOutputAndError(describeGroups(service));
+ return res.getKey().trim().split("\n").length == 2 && res.getValue().isEmpty();
}, "Expected describe group results with one data row for describe type '" + String.join(" ", describeType) + "'");
// stop the consumer so the group has no active member anymore
@@ -431,18 +431,18 @@ public class DescribeConsumerGroupTest extends ConsumerGroupCommandTest {
ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs);
TestUtils.waitForCondition(() -> {
- Tuple2<Optional<String>, Optional<Collection<PartitionAssignmentState>>> res = service.collectGroupOffsets(GROUP);
- return res.v1.map(s -> s.contains("Stable")).orElse(false)
- && res.v2.map(c -> c.stream().anyMatch(assignment -> Objects.equals(assignment.group, GROUP) && assignment.offset.isPresent())).orElse(false);
+ Entry<Optional<String>, Optional<Collection<PartitionAssignmentState>>> res = service.collectGroupOffsets(GROUP);
+ return res.getKey().map(s -> s.contains("Stable")).orElse(false)
+ && res.getValue().map(c -> c.stream().anyMatch(assignment -> Objects.equals(assignment.group, GROUP) && assignment.offset.isPresent())).orElse(false);
}, "Expected the group to initially become stable, and to find group in assignments after initial offset commit.");
// stop the consumer so the group has no active member anymore
executor.shutdown();
TestUtils.waitForCondition(() -> {
- Tuple2<Optional<String>, Optional<Collection<PartitionAssignmentState>>> offsets = service.collectGroupOffsets(GROUP);
- Optional<String> state = offsets.v1;
- Optional<Collection<PartitionAssignmentState>> assignments = offsets.v2;
+ Entry<Optional<String>, Optional<Collection<PartitionAssignmentState>>> offsets = service.collectGroupOffsets(GROUP);
+ Optional<String> state = offsets.getKey();
+ Optional<Collection<PartitionAssignmentState>> assignments = offsets.getValue();
List<PartitionAssignmentState> testGroupAssignments = assignments.get().stream().filter(a -> Objects.equals(a.group, GROUP)).collect(Collectors.toList());
PartitionAssignmentState assignment = testGroupAssignments.get(0);
return state.map(s -> s.contains("Empty")).orElse(false) &&
@@ -465,17 +465,17 @@ public class DescribeConsumerGroupTest extends ConsumerGroupCommandTest {
ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs);
TestUtils.waitForCondition(() -> {
- Tuple2<Optional<String>, Optional<Collection<MemberAssignmentState>>> res = service.collectGroupMembers(GROUP, false);
- return res.v1.map(s -> s.contains("Stable")).orElse(false)
- && res.v2.map(c -> c.stream().anyMatch(m -> Objects.equals(m.group, GROUP))).orElse(false);
+ Entry<Optional<String>, Optional<Collection<MemberAssignmentState>>> res = service.collectGroupMembers(GROUP, false);
+ return res.getKey().map(s -> s.contains("Stable")).orElse(false)
+ && res.getValue().map(c -> c.stream().anyMatch(m -> Objects.equals(m.group, GROUP))).orElse(false);
}, "Expected the group to initially become stable, and to find group in assignments after initial offset commit.");
// stop the consumer so the group has no active member anymore
executor.shutdown();
TestUtils.waitForCondition(() -> {
- Tuple2<Optional<String>, Optional<Collection<MemberAssignmentState>>> res = service.collectGroupMembers(GROUP, false);
- return res.v1.map(s -> s.contains("Empty")).orElse(false) && res.v2.isPresent() && res.v2.get().isEmpty();
+ Entry<Optional<String>, Optional<Collection<MemberAssignmentState>>> res = service.collectGroupMembers(GROUP, false);
+ return res.getKey().map(s -> s.contains("Empty")).orElse(false) && res.getValue().isPresent() && res.getValue().get().isEmpty();
}, "Expected no member in describe group members results for group '" + GROUP + "'");
}
@@ -521,9 +521,9 @@ public class DescribeConsumerGroupTest extends ConsumerGroupCommandTest {
ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs.toArray(new String[0]));
TestUtils.waitForCondition(() -> {
- Tuple2<String, String> res = ToolsTestUtils.grabConsoleOutputAndError(describeGroups(service));
+ Entry<String, String> res = ToolsTestUtils.grabConsoleOutputAndError(describeGroups(service));
int expectedNumRows = DESCRIBE_TYPE_MEMBERS.contains(describeType) ? 3 : 2;
- return res.v2.isEmpty() && res.v1.trim().split("\n").length == expectedNumRows;
+ return res.getValue().isEmpty() && res.getKey().trim().split("\n").length == expectedNumRows;
}, "Expected a single data row in describe group result with describe type '" + String.join(" ", describeType) + "'");
}
}
@@ -540,11 +540,11 @@ public class DescribeConsumerGroupTest extends ConsumerGroupCommandTest {
ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs);
TestUtils.waitForCondition(() -> {
- Tuple2<Optional<String>, Optional<Collection<PartitionAssignmentState>>> res = service.collectGroupOffsets(GROUP);
- return res.v1.map(s -> s.contains("Stable")).isPresent() &&
- res.v2.isPresent() &&
- res.v2.get().stream().filter(s -> Objects.equals(s.group, GROUP)).count() == 1 &&
- res.v2.get().stream().filter(x -> Objects.equals(x.group, GROUP) && x.partition.isPresent()).count() == 1;
+ Entry<Optional<String>, Optional<Collection<PartitionAssignmentState>>> res = service.collectGroupOffsets(GROUP);
+ return res.getKey().map(s -> s.contains("Stable")).isPresent() &&
+ res.getValue().isPresent() &&
+ res.getValue().get().stream().filter(s -> Objects.equals(s.group, GROUP)).count() == 1 &&
+ res.getValue().get().stream().filter(x -> Objects.equals(x.group, GROUP) && x.partition.isPresent()).count() == 1;
}, "Expected rows for consumers with no assigned partitions in describe group results");
}
@@ -560,18 +560,18 @@ public class DescribeConsumerGroupTest extends ConsumerGroupCommandTest {
ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs);
TestUtils.waitForCondition(() -> {
- Tuple2<Optional<String>, Optional<Collection<MemberAssignmentState>>> res = service.collectGroupMembers(GROUP, false);
- return res.v1.map(s -> s.contains("Stable")).orElse(false) &&
- res.v2.isPresent() &&
- res.v2.get().stream().filter(s -> Objects.equals(s.group, GROUP)).count() == 2 &&
- res.v2.get().stream().filter(x -> Objects.equals(x.group, GROUP) && x.numPartitions == 1).count() == 1 &&
- res.v2.get().stream().filter(x -> Objects.equals(x.group, GROUP) && x.numPartitions == 0).count() == 1 &&
- res.v2.get().stream().allMatch(s -> s.assignment.isEmpty());
+ Entry<Optional<String>, Optional<Collection<MemberAssignmentState>>> res = service.collectGroupMembers(GROUP, false);
+ return res.getKey().map(s -> s.contains("Stable")).orElse(false) &&
+ res.getValue().isPresent() &&
+ res.getValue().get().stream().filter(s -> Objects.equals(s.group, GROUP)).count() == 2 &&
+ res.getValue().get().stream().filter(x -> Objects.equals(x.group, GROUP) && x.numPartitions == 1).count() == 1 &&
+ res.getValue().get().stream().filter(x -> Objects.equals(x.group, GROUP) && x.numPartitions == 0).count() == 1 &&
+ res.getValue().get().stream().allMatch(s -> s.assignment.isEmpty());
}, "Expected rows for consumers with no assigned partitions in describe group results");
- Tuple2<Optional<String>, Optional<Collection<MemberAssignmentState>>> res = service.collectGroupMembers(GROUP, true);
- assertTrue(res.v1.map(s -> s.contains("Stable")).orElse(false)
- && res.v2.map(c -> c.stream().anyMatch(s -> !s.assignment.isEmpty())).orElse(false),
+ Entry<Optional<String>, Optional<Collection<MemberAssignmentState>>> res = service.collectGroupMembers(GROUP, true);
+ assertTrue(res.getKey().map(s -> s.contains("Stable")).orElse(false)
+ && res.getValue().map(c -> c.stream().anyMatch(s -> !s.assignment.isEmpty())).orElse(false),
"Expected additional columns in verbose version of describe members");
}
@@ -608,9 +608,9 @@ public class DescribeConsumerGroupTest extends ConsumerGroupCommandTest {
ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs.toArray(new String[0]));
TestUtils.waitForCondition(() -> {
- Tuple2<String, String> res = ToolsTestUtils.grabConsoleOutputAndError(describeGroups(service));
+ Entry<String, String> res = ToolsTestUtils.grabConsoleOutputAndError(describeGroups(service));
int expectedNumRows = DESCRIBE_TYPE_STATE.contains(describeType) ? 2 : 3;
- return res.v2.isEmpty() && res.v1.trim().split("\n").length == expectedNumRows;
+ return res.getValue().isEmpty() && res.getKey().trim().split("\n").length == expectedNumRows;
}, "Expected a single data row in describe group result with describe type '" + String.join(" ", describeType) + "'");
}
}
@@ -629,12 +629,12 @@ public class DescribeConsumerGroupTest extends ConsumerGroupCommandTest {
ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs);
TestUtils.waitForCondition(() -> {
- Tuple2<Optional<String>, Optional<Collection<PartitionAssignmentState>>> res = service.collectGroupOffsets(GROUP);
- return res.v1.map(s -> s.contains("Stable")).orElse(false) &&
- res.v2.isPresent() &&
- res.v2.get().stream().filter(s -> Objects.equals(s.group, GROUP)).count() == 2 &&
- res.v2.get().stream().filter(x -> Objects.equals(x.group, GROUP) && x.partition.isPresent()).count() == 2 &&
- res.v2.get().stream().noneMatch(x -> Objects.equals(x.group, GROUP) && !x.partition.isPresent());
+ Entry<Optional<String>, Optional<Collection<PartitionAssignmentState>>> res = service.collectGroupOffsets(GROUP);
+ return res.getKey().map(s -> s.contains("Stable")).orElse(false) &&
+ res.getValue().isPresent() &&
+ res.getValue().get().stream().filter(s -> Objects.equals(s.group, GROUP)).count() == 2 &&
+ res.getValue().get().stream().filter(x -> Objects.equals(x.group, GROUP) && x.partition.isPresent()).count() == 2 &&
+ res.getValue().get().stream().noneMatch(x -> Objects.equals(x.group, GROUP) && !x.partition.isPresent());
}, "Expected two rows (one row per consumer) in describe group results.");
}
@@ -652,16 +652,16 @@ public class DescribeConsumerGroupTest extends ConsumerGroupCommandTest {
ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs);
TestUtils.waitForCondition(() -> {
- Tuple2<Optional<String>, Optional<Collection<MemberAssignmentState>>> res = service.collectGroupMembers(GROUP, false);
- return res.v1.map(s -> s.contains("Stable")).orElse(false) &&
- res.v2.isPresent() &&
- res.v2.get().stream().filter(s -> Objects.equals(s.group, GROUP)).count() == 2 &&
- res.v2.get().stream().filter(x -> Objects.equals(x.group, GROUP) && x.numPartitions == 1).count() == 2 &&
- res.v2.get().stream().noneMatch(x -> Objects.equals(x.group, GROUP) && x.numPartitions == 0);
+ Entry<Optional<String>, Optional<Collection<MemberAssignmentState>>> res = service.collectGroupMembers(GROUP, false);
+ return res.getKey().map(s -> s.contains("Stable")).orElse(false) &&
+ res.getValue().isPresent() &&
+ res.getValue().get().stream().filter(s -> Objects.equals(s.group, GROUP)).count() == 2 &&
+ res.getValue().get().stream().filter(x -> Objects.equals(x.group, GROUP) && x.numPartitions == 1).count() == 2 &&
+ res.getValue().get().stream().noneMatch(x -> Objects.equals(x.group, GROUP) && x.numPartitions == 0);
}, "Expected two rows (one row per consumer) in describe group members results.");
- Tuple2<Optional<String>, Optional<Collection<MemberAssignmentState>>> res = service.collectGroupMembers(GROUP, true);
- assertTrue(res.v1.map(s -> s.contains("Stable")).orElse(false) && res.v2.map(s -> s.stream().filter(x -> x.assignment.isEmpty()).count()).orElse(0L) == 0,
+ Entry<Optional<String>, Optional<Collection<MemberAssignmentState>>> res = service.collectGroupMembers(GROUP, true);
+ assertTrue(res.getKey().map(s -> s.contains("Stable")).orElse(false) && res.getValue().map(s -> s.stream().filter(x -> x.assignment.isEmpty()).count()).orElse(0L) == 0,
"Expected additional columns in verbose version of describe members");
}
@@ -698,9 +698,9 @@ public class DescribeConsumerGroupTest extends ConsumerGroupCommandTest {
ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs);
TestUtils.waitForCondition(() -> {
- Tuple2<Optional<String>, Optional<Collection<PartitionAssignmentState>>> res = service.collectGroupOffsets(GROUP);
- return res.v1.map(s -> s.contains("Empty")).orElse(false)
- && res.v2.isPresent() && res.v2.get().stream().filter(s -> Objects.equals(s.group, GROUP)).count() == 2;
+ Entry<Optional<String>, Optional<Collection<PartitionAssignmentState>>> res = service.collectGroupOffsets(GROUP);
+ return res.getKey().map(s -> s.contains("Empty")).orElse(false)
+ && res.getValue().isPresent() && res.getValue().get().stream().filter(s -> Objects.equals(s.group, GROUP)).count() == 2;
}, "Expected a stable group with two members in describe group state result.");
}
@@ -798,18 +798,18 @@ public class DescribeConsumerGroupTest extends ConsumerGroupCommandTest {
ConsumerGroupCommand.ConsumerGroupService service = getConsumerGroupService(cgcArgs);
TestUtils.waitForCondition(() -> {
- Tuple2<Optional<String>, Optional<Collection<PartitionAssignmentState>>> groupOffsets = service.collectGroupOffsets(GROUP);
+ Entry<Optional<String>, Optional<Collection<PartitionAssignmentState>>> groupOffsets = service.collectGroupOffsets(GROUP);
Predicate<PartitionAssignmentState> isGrp = s -> Objects.equals(s.group, GROUP);
- boolean res = groupOffsets.v1.map(s -> s.contains("Stable")).orElse(false) &&
- groupOffsets.v2.isPresent() &&
- groupOffsets.v2.get().stream().filter(isGrp).count() == 1;
+ boolean res = groupOffsets.getKey().map(s -> s.contains("Stable")).orElse(false) &&
+ groupOffsets.getValue().isPresent() &&
+ groupOffsets.getValue().get().stream().filter(isGrp).count() == 1;
if (!res)
return false;
- Optional<PartitionAssignmentState> maybeAssignmentState = groupOffsets.v2.get().stream().filter(isGrp).findFirst();
+ Optional<PartitionAssignmentState> maybeAssignmentState = groupOffsets.getValue().get().stream().filter(isGrp).findFirst();
if (!maybeAssignmentState.isPresent())
return false;
diff --git a/tools/src/test/java/org/apache/kafka/tools/other/ReplicationQuotasTestRig.java b/tools/src/test/java/org/apache/kafka/tools/other/ReplicationQuotasTestRig.java
index 618cf972995..c7c4a4f35e6 100644
--- a/tools/src/test/java/org/apache/kafka/tools/other/ReplicationQuotasTestRig.java
+++ b/tools/src/test/java/org/apache/kafka/tools/other/ReplicationQuotasTestRig.java
@@ -217,7 +217,7 @@ public class ReplicationQuotasTestRig {
System.out.println("Generating Reassignment");
Map<TopicPartition, List<Integer>> newAssignment = ReassignPartitionsCommand.generateAssignment(adminClient,
- json(TOPIC_NAME), brokers.stream().map(Object::toString).collect(Collectors.joining(",")), true).v1;
+ json(TOPIC_NAME), brokers.stream().map(Object::toString).collect(Collectors.joining(",")), true).getKey();
System.out.println("Starting Reassignment");
long start = System.currentTimeMillis();
diff --git a/tools/src/test/java/org/apache/kafka/tools/reassign/ReassignPartitionsIntegrationTest.java b/tools/src/test/java/org/apache/kafka/tools/reassign/ReassignPartitionsIntegrationTest.java
index 83fc665e3e4..0348aa24ffe 100644
--- a/tools/src/test/java/org/apache/kafka/tools/reassign/ReassignPartitionsIntegrationTest.java
+++ b/tools/src/test/java/org/apache/kafka/tools/reassign/ReassignPartitionsIntegrationTest.java
@@ -43,7 +43,6 @@ import org.apache.kafka.common.serialization.ByteArrayDeserializer;
import org.apache.kafka.common.utils.Time;
import org.apache.kafka.common.utils.Utils;
import org.apache.kafka.tools.TerseException;
-import org.apache.kafka.tools.Tuple2;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Timeout;
import org.junit.jupiter.params.ParameterizedTest;
@@ -54,6 +53,7 @@ import scala.collection.JavaConverters;
import scala.collection.Seq;
import java.io.Closeable;
+import java.util.AbstractMap.SimpleImmutableEntry;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
@@ -62,6 +62,7 @@ import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
+import java.util.Map.Entry;
import java.util.Objects;
import java.util.Optional;
import java.util.Properties;
@@ -395,11 +396,11 @@ public class ReassignPartitionsIntegrationTest extends QuorumTestHarness {
waitForVerifyAssignment(cluster.adminClient, assignment, true,
new VerifyAssignmentResult(partStates, true, Collections.emptyMap(), false));
// Cancel the reassignment.
- assertEquals(new Tuple2<>(new HashSet<>(asList(foo0, baz1)), Collections.emptySet()), runCancelAssignment(cluster.adminClient, assignment, true));
+ assertEquals(new SimpleImmutableEntry<>(new HashSet<>(asList(foo0, baz1)), Collections.emptySet()), runCancelAssignment(cluster.adminClient, assignment, true));
// Broker throttles are still active because we passed --preserve-throttles
waitForInterBrokerThrottle(asList(0, 1, 2, 3), interBrokerThrottle);
// Cancelling the reassignment again should reveal nothing to cancel.
- assertEquals(new Tuple2<>(Collections.emptySet(), Collections.emptySet()), runCancelAssignment(cluster.adminClient, assignment, false));
+ assertEquals(new SimpleImmutableEntry<>(Collections.emptySet(), Collections.emptySet()), runCancelAssignment(cluster.adminClient, assignment, false));
// This time, the broker throttles were removed.
waitForBrokerLevelThrottles(unthrottledBrokerConfigs);
// Verify that there are no ongoing reassignments.
@@ -446,7 +447,7 @@ public class ReassignPartitionsIntegrationTest extends QuorumTestHarness {
);
// Now cancel the assignment and verify that the partition is removed from cancelled replicas
- assertEquals(new Tuple2<>(Collections.singleton(foo0), Collections.emptySet()), runCancelAssignment(cluster.adminClient, assignment, true));
+ assertEquals(new SimpleImmutableEntry<>(Collections.singleton(foo0), Collections.emptySet()), runCancelAssignment(cluster.adminClient, assignment, true));
verifyReplicaDeleted(foo0, 3);
verifyReplicaDeleted(foo0, 4);
}
@@ -708,7 +709,7 @@ public class ReassignPartitionsIntegrationTest extends QuorumTestHarness {
}
}
- private Tuple2<Set<TopicPartition>, Set<TopicPartitionReplica>> runCancelAssignment(
+ private Entry<Set<TopicPartition>, Set<TopicPartitionReplica>> runCancelAssignment(
Admin adminClient,
String jsonString,
Boolean preserveThrottles
diff --git a/tools/src/test/java/org/apache/kafka/tools/reassign/ReassignPartitionsUnitTest.java b/tools/src/test/java/org/apache/kafka/tools/reassign/ReassignPartitionsUnitTest.java
index 699e048fb20..c6f145d9a55 100644
--- a/tools/src/test/java/org/apache/kafka/tools/reassign/ReassignPartitionsUnitTest.java
+++ b/tools/src/test/java/org/apache/kafka/tools/reassign/ReassignPartitionsUnitTest.java
@@ -31,18 +31,19 @@ import org.apache.kafka.common.utils.Exit;
import org.apache.kafka.common.utils.Time;
import org.apache.kafka.server.common.AdminCommandFailedException;
import org.apache.kafka.server.common.AdminOperationException;
-import org.apache.kafka.tools.Tuple2;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Timeout;
+import java.util.AbstractMap.SimpleImmutableEntry;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
+import java.util.Map.Entry;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
@@ -174,14 +175,14 @@ public class ReassignPartitionsUnitTest {
expStates.put(new TopicPartition("foo", 1),
new PartitionReassignmentState(asList(1, 2, 3), asList(1, 2, 3), true));
- Tuple2<Map<TopicPartition, PartitionReassignmentState>, Boolean> actual =
+ Entry<Map<TopicPartition, PartitionReassignmentState>, Boolean> actual =
findPartitionReassignmentStates(adminClient, asList(
- new Tuple2<>(new TopicPartition("foo", 0), asList(0, 1, 3)),
- new Tuple2<>(new TopicPartition("foo", 1), asList(1, 2, 3))
+ new SimpleImmutableEntry<>(new TopicPartition("foo", 0), asList(0, 1, 3)),
+ new SimpleImmutableEntry<>(new TopicPartition("foo", 1), asList(1, 2, 3))
));
- assertEquals(expStates, actual.v1);
- assertTrue(actual.v2);
+ assertEquals(expStates, actual.getKey());
+ assertTrue(actual.getValue());
// Cancel the reassignment and test findPartitionReassignmentStates again.
Map<TopicPartition, Throwable> cancelResult = cancelPartitionReassignments(adminClient,
@@ -198,12 +199,12 @@ public class ReassignPartitionsUnitTest {
new PartitionReassignmentState(asList(1, 2, 3), asList(1, 2, 3), true));
actual = findPartitionReassignmentStates(adminClient, asList(
- new Tuple2<>(new TopicPartition("foo", 0), asList(0, 1, 3)),
- new Tuple2<>(new TopicPartition("foo", 1), asList(1, 2, 3))
+ new SimpleImmutableEntry<>(new TopicPartition("foo", 0), asList(0, 1, 3)),
+ new SimpleImmutableEntry<>(new TopicPartition("foo", 1), asList(1, 2, 3))
));
- assertEquals(expStates, actual.v1);
- assertFalse(actual.v2);
+ assertEquals(expStates, actual.getKey());
+ assertFalse(actual.getValue());
}
}
@@ -338,13 +339,13 @@ public class ReassignPartitionsUnitTest {
assertThrows(AdminCommandFailedException.class, () -> parseGenerateAssignmentArgs(
"{\"topics\": [{\"topic\": \"foo\"}], \"version\":1}", "5,2,3,4,5"),
"Expected to detect duplicate broker list entries").getMessage());
- assertEquals(new Tuple2<>(asList(5, 2, 3, 4), asList("foo")),
+ assertEquals(new SimpleImmutableEntry<>(asList(5, 2, 3, 4), asList("foo")),
parseGenerateAssignmentArgs("{\"topics\": [{\"topic\": \"foo\"}], \"version\":1}", "5,2,3,4"));
assertStartsWith("List of topics to reassign contains duplicate entries",
assertThrows(AdminCommandFailedException.class, () -> parseGenerateAssignmentArgs(
"{\"topics\": [{\"topic\": \"foo\"},{\"topic\": \"foo\"}], \"version\":1}", "5,2,3,4"),
"Expected to detect duplicate topic entries").getMessage());
- assertEquals(new Tuple2<>(asList(5, 3, 4), asList("foo", "bar")),
+ assertEquals(new SimpleImmutableEntry<>(asList(5, 3, 4), asList("foo", "bar")),
parseGenerateAssignmentArgs(
"{\"topics\": [{\"topic\": \"foo\"},{\"topic\": \"bar\"}], \"version\":1}", "5,3,4"));
}
@@ -389,7 +390,7 @@ public class ReassignPartitionsUnitTest {
() -> generateAssignment(adminClient, "{\"topics\":[{\"topic\":\"foo\"}]}", "0,1,2,3", true),
"Expected generateAssignment to fail").getMessage());
// It should succeed when --disable-rack-aware is used.
- Tuple2<Map<TopicPartition, List<Integer>>, Map<TopicPartition, List<Integer>>>
+ Entry<Map<TopicPartition, List<Integer>>, Map<TopicPartition, List<Integer>>>
proposedCurrent = generateAssignment(adminClient, "{\"topics\":[{\"topic\":\"foo\"}]}", "0,1,2,3", false);
Map<TopicPartition, List<Integer>> expCurrent = new HashMap<>();
@@ -397,7 +398,7 @@ public class ReassignPartitionsUnitTest {
expCurrent.put(new TopicPartition("foo", 0), asList(0, 1, 2));
expCurrent.put(new TopicPartition("foo", 1), asList(1, 2, 3));
- assertEquals(expCurrent, proposedCurrent.v2);
+ assertEquals(expCurrent, proposedCurrent.getValue());
}
}
@@ -407,7 +408,7 @@ public class ReassignPartitionsUnitTest {
addTopics(adminClient);
List<Integer> goalBrokers = asList(0, 1, 3);
- Tuple2<Map<TopicPartition, List<Integer>>, Map<TopicPartition, List<Integer>>>
+ Entry<Map<TopicPartition, List<Integer>>, Map<TopicPartition, List<Integer>>>
proposedCurrent = generateAssignment(adminClient,
"{\"topics\":[{\"topic\":\"foo\"},{\"topic\":\"bar\"}]}",
goalBrokers.stream().map(Object::toString).collect(Collectors.joining(",")), false);
@@ -418,12 +419,12 @@ public class ReassignPartitionsUnitTest {
expCurrent.put(new TopicPartition("foo", 1), asList(1, 2, 3));
expCurrent.put(new TopicPartition("bar", 0), asList(2, 3, 0));
- assertEquals(expCurrent, proposedCurrent.v2);
+ assertEquals(expCurrent, proposedCurrent.getValue());
// The proposed assignment should only span the provided brokers
- proposedCurrent.v1.values().forEach(replicas ->
+ proposedCurrent.getKey().values().forEach(replicas ->
assertTrue(goalBrokers.containsAll(replicas),
- "Proposed assignment " + proposedCurrent.v1 + " puts replicas on brokers other than " + goalBrokers)
+ "Proposed assignment " + proposedCurrent.getKey() + " puts replicas on brokers other than " + goalBrokers)
);
}
}
@@ -567,14 +568,14 @@ public class ReassignPartitionsUnitTest {
partitionsToBeReassigned.put(new TopicPartition("foo", 0), asList(1, 2, 3));
partitionsToBeReassigned.put(new TopicPartition("foo", 1), asList(3, 4, 5));
- Tuple2<Map<TopicPartition, List<Integer>>, Map<TopicPartitionReplica, String>> actual = parseExecuteAssignmentArgs(
+ Entry<Map<TopicPartition, List<Integer>>, Map<TopicPartitionReplica, String>> actual = parseExecuteAssignmentArgs(
"{\"version\":1,\"partitions\":" +
"[{\"topic\":\"foo\",\"partition\":0,\"replicas\":[1,2,3],\"log_dirs\":[\"any\",\"any\",\"any\"]}," +
"{\"topic\":\"foo\",\"partition\":1,\"replicas\":[3,4,5],\"log_dirs\":[\"any\",\"any\",\"any\"]}" +
"]}");
- assertEquals(partitionsToBeReassigned, actual.v1);
- assertTrue(actual.v2.isEmpty());
+ assertEquals(partitionsToBeReassigned, actual.getKey());
+ assertTrue(actual.getValue().isEmpty());
Map<TopicPartitionReplica, String> replicaAssignment = new HashMap<>();
@@ -587,8 +588,8 @@ public class ReassignPartitionsUnitTest {
"[{\"topic\":\"foo\",\"partition\":0,\"replicas\":[1,2,3],\"log_dirs\":[\"/tmp/a\",\"/tmp/b\",\"/tmp/c\"]}" +
"]}");
- assertEquals(Collections.singletonMap(new TopicPartition("foo", 0), asList(1, 2, 3)), actual.v1);
- assertEquals(replicaAssignment, actual.v2);
+ assertEquals(Collections.singletonMap(new TopicPartition("foo", 0), asList(1, 2, 3)), actual.getKey());
+ assertEquals(replicaAssignment, actual.getValue());
}
@Test