From 913ba2922e39efb890e7b0af16ed361952c87150 Mon Sep 17 00:00:00 2001 From: Daniil Zulin Date: Tue, 6 May 2025 18:28:58 +0700 Subject: [PATCH 1/8] Add base implementation for auto partitioning settings --- .../tech/ydb/topic/impl/TopicClientImpl.java | 50 +++++++++++- ...AutoPartitioningWriteStrategySettings.java | 77 +++++++++++++++++++ .../settings/AlterPartitioningSettings.java | 40 ++++++++++ .../settings/AutoPartitioningStrategy.java | 48 ++++++++++++ ...AutoPartitioningWriteStrategySettings.java | 68 ++++++++++++++++ .../topic/settings/PartitioningSettings.java | 42 ++++++++++ .../topic/impl/YdbTopicsIntegrationTest.java | 7 +- 7 files changed, 329 insertions(+), 3 deletions(-) create mode 100644 topic/src/main/java/tech/ydb/topic/settings/AlterAutoPartitioningWriteStrategySettings.java create mode 100644 topic/src/main/java/tech/ydb/topic/settings/AutoPartitioningStrategy.java create mode 100644 topic/src/main/java/tech/ydb/topic/settings/AutoPartitioningWriteStrategySettings.java diff --git a/topic/src/main/java/tech/ydb/topic/impl/TopicClientImpl.java b/topic/src/main/java/tech/ydb/topic/impl/TopicClientImpl.java index 4e6261a92..4834aa179 100644 --- a/topic/src/main/java/tech/ydb/topic/impl/TopicClientImpl.java +++ b/topic/src/main/java/tech/ydb/topic/impl/TopicClientImpl.java @@ -35,9 +35,12 @@ import tech.ydb.topic.read.SyncReader; import tech.ydb.topic.read.impl.AsyncReaderImpl; import tech.ydb.topic.read.impl.SyncReaderImpl; +import tech.ydb.topic.settings.AlterAutoPartitioningWriteStrategySettings; import tech.ydb.topic.settings.AlterConsumerSettings; import tech.ydb.topic.settings.AlterPartitioningSettings; import tech.ydb.topic.settings.AlterTopicSettings; +import tech.ydb.topic.settings.AutoPartitioningStrategy; +import tech.ydb.topic.settings.AutoPartitioningWriteStrategySettings; import tech.ydb.topic.settings.CommitOffsetSettings; import tech.ydb.topic.settings.CreateTopicSettings; import tech.ydb.topic.settings.DescribeConsumerSettings; @@ -104,7 +107,19 @@ public CompletableFuture createTopic(String path, CreateTopicSettings se if (partitioningSettings != null) { requestBuilder.setPartitioningSettings(YdbTopic.PartitioningSettings.newBuilder() .setMinActivePartitions(partitioningSettings.getMinActivePartitions()) - .setPartitionCountLimit(partitioningSettings.getPartitionCountLimit())); + .setPartitionCountLimit(partitioningSettings.getPartitionCountLimit()) + .setAutoPartitioningSettings(YdbTopic.AutoPartitioningSettings.newBuilder() + .setStrategy(partitioningSettings.getAutoPartitioningStrategy().getProtoReference()))); + + AutoPartitioningWriteStrategySettings writeStrategySettings = partitioningSettings.getWriteStrategySettings(); + if (writeStrategySettings != null) { + requestBuilder.getPartitioningSettingsBuilder().getAutoPartitioningSettingsBuilder() + .setPartitionWriteSpeed(YdbTopic.AutoPartitioningWriteSpeedStrategy.newBuilder() + .setStabilizationWindow(ProtobufUtils.durationToProto(writeStrategySettings.getStabilizationWindow())) + .setDownUtilizationPercent(writeStrategySettings.getDownUtilizationPercent()) + .setUpUtilizationPercent(writeStrategySettings.getUpUtilizationPercent()) + ); + } } Duration retentionPeriod = settings.getRetentionPeriod(); @@ -145,6 +160,28 @@ public CompletableFuture alterTopic(String path, AlterTopicSettings sett if (partitionCountLimit != null) { builder.setSetPartitionCountLimit(partitionCountLimit); } + AutoPartitioningStrategy autoPartitioningStrategy = partitioningSettings.getAutoPartitioningStrategy(); + if (autoPartitioningStrategy != null) { + builder.getAlterAutoPartitioningSettingsBuilder().setSetStrategy(autoPartitioningStrategy.getProtoReference()); + } + AlterAutoPartitioningWriteStrategySettings writeStrategySettings = partitioningSettings.getWriteStrategySettings(); + if (writeStrategySettings != null) { + Duration stabilizationWindow = writeStrategySettings.getStabilizationWindow(); + if (stabilizationWindow != null) { + builder.getAlterAutoPartitioningSettingsBuilder().getSetPartitionWriteSpeedBuilder() + .setSetStabilizationWindow(ProtobufUtils.durationToProto(stabilizationWindow)); + } + Integer upUtilizationPercent = writeStrategySettings.getUpUtilizationPercent(); + if (upUtilizationPercent != null) { + builder.getAlterAutoPartitioningSettingsBuilder().getSetPartitionWriteSpeedBuilder() + .setSetUpUtilizationPercent(upUtilizationPercent); + } + Integer downUtilizationPercent = writeStrategySettings.getDownUtilizationPercent(); + if (downUtilizationPercent != null) { + builder.getAlterAutoPartitioningSettingsBuilder().getSetPartitionWriteSpeedBuilder() + .setSetDownUtilizationPercent(downUtilizationPercent); + } + } requestBuilder.setAlterPartitioningSettings(builder); } @@ -273,11 +310,20 @@ private TopicDescription mapDescribeTopic(YdbTopic.DescribeTopicResult result) { .setMeteringMode(fromProto(result.getMeteringMode())); YdbTopic.PartitioningSettings partitioningSettings = result.getPartitioningSettings(); - description.setPartitioningSettings(PartitioningSettings.newBuilder() + PartitioningSettings.Builder partitioningDescription = PartitioningSettings.newBuilder() .setMinActivePartitions(partitioningSettings.getMinActivePartitions()) .setPartitionCountLimit(partitioningSettings.getPartitionCountLimit()) + .setAutoPartitioningStrategy(AutoPartitioningStrategy.fromProto(partitioningSettings.getAutoPartitioningSettings().getStrategy())); + + YdbTopic.AutoPartitioningWriteSpeedStrategy partitionWriteSpeed = partitioningSettings.getAutoPartitioningSettings().getPartitionWriteSpeed(); + partitioningDescription.setWriteStrategySettings(AutoPartitioningWriteStrategySettings.newBuilder() + .setStabilizationWindow(ProtobufUtils.protoToDuration(partitionWriteSpeed.getStabilizationWindow())) + .setUpUtilizationPercent(partitionWriteSpeed.getUpUtilizationPercent()) + .setDownUtilizationPercent(partitionWriteSpeed.getDownUtilizationPercent()) .build()); + description.setPartitioningSettings(partitioningDescription.build()); + List partitions = new ArrayList<>(); for (YdbTopic.DescribeTopicResult.PartitionInfo partition : result.getPartitionsList()) { PartitionInfo.Builder partitionBuilder = PartitionInfo.newBuilder() diff --git a/topic/src/main/java/tech/ydb/topic/settings/AlterAutoPartitioningWriteStrategySettings.java b/topic/src/main/java/tech/ydb/topic/settings/AlterAutoPartitioningWriteStrategySettings.java new file mode 100644 index 000000000..d88d13415 --- /dev/null +++ b/topic/src/main/java/tech/ydb/topic/settings/AlterAutoPartitioningWriteStrategySettings.java @@ -0,0 +1,77 @@ +package tech.ydb.topic.settings; + +import javax.annotation.Nullable; + +import java.time.Duration; + +// TODO add proper javadocs +public class AlterAutoPartitioningWriteStrategySettings { + @Nullable + private final Duration stabilizationWindow; + @Nullable + private final Integer upUtilizationPercent; + @Nullable + private final Integer downUtilizationPercent; + + public AlterAutoPartitioningWriteStrategySettings(Builder builder) { + this.stabilizationWindow = builder.stabilizationWindow; + this.upUtilizationPercent = builder.upUtilizationPercent; + this.downUtilizationPercent = builder.downUtilizationPercent; + } + + @Nullable + public Duration getStabilizationWindow() { + return stabilizationWindow; + } + + @Nullable + public Integer getUpUtilizationPercent() { + return upUtilizationPercent; + } + + @Nullable + public Integer getDownUtilizationPercent() { + return downUtilizationPercent; + } + + public static Builder newBuilder() { + return new Builder(); + } + + public static class Builder { + private Duration stabilizationWindow = null; + private Integer upUtilizationPercent = null; + private Integer downUtilizationPercent = null; + + /** + * @param stabilizationWindow + * @return strategy builder + */ + public Builder setStabilizationWindow(Duration stabilizationWindow) { + this.stabilizationWindow = stabilizationWindow; + return this; + } + + /** + * @param upUtilizationPercent + * @return strategy builder + */ + public Builder setUpUtilizationPercent(int upUtilizationPercent) { + this.upUtilizationPercent = upUtilizationPercent; + return this; + } + + /** + * @param downUtilizationPercent + * @return strategy builder + */ + public Builder setDownUtilizationPercent(int downUtilizationPercent) { + this.downUtilizationPercent = downUtilizationPercent; + return this; + } + + public AlterAutoPartitioningWriteStrategySettings build() { + return new AlterAutoPartitioningWriteStrategySettings(this); + } + } +} diff --git a/topic/src/main/java/tech/ydb/topic/settings/AlterPartitioningSettings.java b/topic/src/main/java/tech/ydb/topic/settings/AlterPartitioningSettings.java index 46305d6ec..4ae62bdfd 100644 --- a/topic/src/main/java/tech/ydb/topic/settings/AlterPartitioningSettings.java +++ b/topic/src/main/java/tech/ydb/topic/settings/AlterPartitioningSettings.java @@ -10,10 +10,16 @@ public class AlterPartitioningSettings { private final Long minActivePartitions; @Nullable private final Long partitionCountLimit; + @Nullable + private final AutoPartitioningStrategy autoPartitioningStrategy; + @Nullable + private final AlterAutoPartitioningWriteStrategySettings writeStrategySettings; private AlterPartitioningSettings(Builder builder) { this.minActivePartitions = builder.minActivePartitions; this.partitionCountLimit = builder.partitionCountLimit; + this.autoPartitioningStrategy = builder.autoPartitioningStrategy; + this.writeStrategySettings = builder.writeStrategySettings; } public static Builder newBuilder() { @@ -30,12 +36,24 @@ public Long getPartitionCountLimit() { return partitionCountLimit; } + @Nullable + public AutoPartitioningStrategy getAutoPartitioningStrategy() { + return autoPartitioningStrategy; + } + + @Nullable + public AlterAutoPartitioningWriteStrategySettings getWriteStrategySettings() { + return writeStrategySettings; + } + /** * BUILDER */ public static class Builder { private Long minActivePartitions = null; private Long partitionCountLimit = null; + private AutoPartitioningStrategy autoPartitioningStrategy = null; + private AlterAutoPartitioningWriteStrategySettings writeStrategySettings = null; /** * @param minActivePartitions minimum partition count auto merge would stop working at. @@ -58,6 +76,28 @@ public Builder setPartitionCountLimit(long partitionCountLimit) { return this; } + /** + * @param autoPartitioningStrategy Strategy for auto partitioning. + * Auto partitioning is disabled by default. + * @return settings builder + * @see AutoPartitioningStrategy#DISABLED + */ + public Builder setAutoPartitioningStrategy(AutoPartitioningStrategy autoPartitioningStrategy) { + this.autoPartitioningStrategy = autoPartitioningStrategy; + return this; + } + + /** + * @param writeStrategySettings Settings for auto partitioning write strategy. + * Does not have any effect if auto partitioning is disabled. + * See {@link AlterAutoPartitioningWriteStrategySettings} for defaults + * @return settings builder + */ + public Builder setWriteStrategySettings(AlterAutoPartitioningWriteStrategySettings writeStrategySettings) { + this.writeStrategySettings = writeStrategySettings; + return this; + } + public AlterPartitioningSettings build() { return new AlterPartitioningSettings(this); } diff --git a/topic/src/main/java/tech/ydb/topic/settings/AutoPartitioningStrategy.java b/topic/src/main/java/tech/ydb/topic/settings/AutoPartitioningStrategy.java new file mode 100644 index 000000000..89f23c07d --- /dev/null +++ b/topic/src/main/java/tech/ydb/topic/settings/AutoPartitioningStrategy.java @@ -0,0 +1,48 @@ +package tech.ydb.topic.settings; + +import tech.ydb.proto.topic.YdbTopic; + +import javax.annotation.Nullable; + +public enum AutoPartitioningStrategy { + /** + * The auto partitioning is disabled. + * You cannot disable the auto partitioning after it has been enabled. + * @see AutoPartitioningStrategy#PAUSED + */ + DISABLED(YdbTopic.AutoPartitioningStrategy.AUTO_PARTITIONING_STRATEGY_DISABLED), + /** + * The auto partitioning algorithm will increase the partition count depending on the load characteristics. + * The auto partitioning algorithm will never decrease the number of partitions. + * @see AlterAutoPartitioningWriteStrategySettings + */ + SCALE_UP(YdbTopic.AutoPartitioningStrategy.AUTO_PARTITIONING_STRATEGY_SCALE_UP), + /** + * The auto partitioning algorithm will both increase and decrease partitions count depending on the load characteristics. + * @see AlterAutoPartitioningWriteStrategySettings + */ + SCALE_UP_AND_DOWN(YdbTopic.AutoPartitioningStrategy.AUTO_PARTITIONING_STRATEGY_SCALE_UP_AND_DOWN), + /** + * The auto partitioning is paused. + */ + PAUSED(YdbTopic.AutoPartitioningStrategy.AUTO_PARTITIONING_STRATEGY_PAUSED); + + private final YdbTopic.AutoPartitioningStrategy protoReference; + + AutoPartitioningStrategy(YdbTopic.AutoPartitioningStrategy protoReference) { + this.protoReference = protoReference; + } + + public YdbTopic.AutoPartitioningStrategy getProtoReference() { + return protoReference; + } + + public static @Nullable AutoPartitioningStrategy fromProto(YdbTopic.AutoPartitioningStrategy protoReference) { + for (AutoPartitioningStrategy value : values()) { + if (value.getProtoReference() == protoReference) { + return value; + } + } + return null; + } +} diff --git a/topic/src/main/java/tech/ydb/topic/settings/AutoPartitioningWriteStrategySettings.java b/topic/src/main/java/tech/ydb/topic/settings/AutoPartitioningWriteStrategySettings.java new file mode 100644 index 000000000..30f5f3f89 --- /dev/null +++ b/topic/src/main/java/tech/ydb/topic/settings/AutoPartitioningWriteStrategySettings.java @@ -0,0 +1,68 @@ +package tech.ydb.topic.settings; + +import java.time.Duration; + +public class AutoPartitioningWriteStrategySettings { + private final Duration stabilizationWindow; + private final int upUtilizationPercent; + private final int downUtilizationPercent; + + public AutoPartitioningWriteStrategySettings(Builder builder) { + this.stabilizationWindow = builder.stabilizationWindow; + this.upUtilizationPercent = builder.upUtilizationPercent; + this.downUtilizationPercent = builder.downUtilizationPercent; + } + + public Duration getStabilizationWindow() { + return stabilizationWindow; + } + + public int getUpUtilizationPercent() { + return upUtilizationPercent; + } + + public int getDownUtilizationPercent() { + return downUtilizationPercent; + } + + public static Builder newBuilder() { + return new Builder(); + } + + public static class Builder { + private Duration stabilizationWindow = Duration.ofMinutes(5); + private int upUtilizationPercent = 90; + private int downUtilizationPercent = 30; + + /** + * @param stabilizationWindow + * @return strategy builder + */ + public Builder setStabilizationWindow(Duration stabilizationWindow) { + this.stabilizationWindow = stabilizationWindow; + return this; + } + + /** + * @param upUtilizationPercent + * @return strategy builder + */ + public Builder setUpUtilizationPercent(int upUtilizationPercent) { + this.upUtilizationPercent = upUtilizationPercent; + return this; + } + + /** + * @param downUtilizationPercent + * @return strategy builder + */ + public Builder setDownUtilizationPercent(int downUtilizationPercent) { + this.downUtilizationPercent = downUtilizationPercent; + return this; + } + + public AutoPartitioningWriteStrategySettings build() { + return new AutoPartitioningWriteStrategySettings(this); + } + } +} diff --git a/topic/src/main/java/tech/ydb/topic/settings/PartitioningSettings.java b/topic/src/main/java/tech/ydb/topic/settings/PartitioningSettings.java index 5316b70bf..e963babc2 100644 --- a/topic/src/main/java/tech/ydb/topic/settings/PartitioningSettings.java +++ b/topic/src/main/java/tech/ydb/topic/settings/PartitioningSettings.java @@ -6,10 +6,14 @@ public class PartitioningSettings { private final long minActivePartitions; private final long partitionCountLimit; + private final AutoPartitioningStrategy autoPartitioningStrategy; + private final AutoPartitioningWriteStrategySettings writeStrategySettings; private PartitioningSettings(Builder builder) { this.minActivePartitions = builder.minActivePartitions; this.partitionCountLimit = builder.partitionCountLimit; + this.autoPartitioningStrategy = builder.autoPartitioningStrategy; + this.writeStrategySettings = builder.writeStrategySettings; } /** @@ -29,6 +33,20 @@ public long getPartitionCountLimit() { return partitionCountLimit; } + /** + * @return Auto partitioning strategy. Disabled by default + */ + public AutoPartitioningStrategy getAutoPartitioningStrategy() { + return autoPartitioningStrategy; + } + + /** + * @return Auto partitioning write strategy settings. Does not have effect until the auto partitioning is enabled + */ + public AutoPartitioningWriteStrategySettings getWriteStrategySettings() { + return writeStrategySettings; + } + public static Builder newBuilder() { return new Builder(); } @@ -39,6 +57,8 @@ public static Builder newBuilder() { public static class Builder { private long minActivePartitions = 0; private long partitionCountLimit = 0; + private AutoPartitioningStrategy autoPartitioningStrategy = AutoPartitioningStrategy.DISABLED; + private AutoPartitioningWriteStrategySettings writeStrategySettings = null; /** * @param minActivePartitions minimum partition count auto merge would stop working at. @@ -61,6 +81,28 @@ public Builder setPartitionCountLimit(long partitionCountLimit) { return this; } + /** + * @param autoPartitioningStrategy Strategy for auto partitioning. + * Auto partitioning is disabled by default. + * @return settings builder + * @see AutoPartitioningStrategy#DISABLED + */ + public Builder setAutoPartitioningStrategy(AutoPartitioningStrategy autoPartitioningStrategy) { + this.autoPartitioningStrategy = autoPartitioningStrategy; + return this; + } + + /** + * @param writeStrategySettings Settings for auto partitioning write strategy. + * Does not have any effect if auto partitioning is disabled. + * See {@link AutoPartitioningWriteStrategySettings} for defaults + * @return settings builder + */ + public Builder setWriteStrategySettings(AutoPartitioningWriteStrategySettings writeStrategySettings) { + this.writeStrategySettings = writeStrategySettings; + return this; + } + public PartitioningSettings build() { return new PartitioningSettings(this); } diff --git a/topic/src/test/java/tech/ydb/topic/impl/YdbTopicsIntegrationTest.java b/topic/src/test/java/tech/ydb/topic/impl/YdbTopicsIntegrationTest.java index 011d6018b..368445fcf 100644 --- a/topic/src/test/java/tech/ydb/topic/impl/YdbTopicsIntegrationTest.java +++ b/topic/src/test/java/tech/ydb/topic/impl/YdbTopicsIntegrationTest.java @@ -177,7 +177,7 @@ public void step04_readNextHalfWithCommit() throws InterruptedException { } @Test - public void step05_describeTopic() throws InterruptedException { + public void step05_describeTopic() { TopicDescription description = client.describeTopic(TEST_TOPIC).join().getValue(); Assert.assertNull(description.getTopicStats()); @@ -227,4 +227,9 @@ public void onMessages(DataReceivedEvent dre) { Assert.assertArrayEquals(TEST_MESSAGES[idx], results[results.length - idx - 1]); } } + + @Test + public void step07_alterTopicWithAutoPartitioning() { + // TODO add proper integration test for alter + describe + } } From 32aaae35e63e59b58994c2d9f5cef31ac79ec58b Mon Sep 17 00:00:00 2001 From: Daniil Zulin Date: Tue, 6 May 2025 20:49:35 +0700 Subject: [PATCH 2/8] Add test for alter topic Add equals implementations for topic description classes --- .../ydb/test/integration/YdbEnvironment.java | 2 +- .../tech/ydb/topic/description/Consumer.java | 18 +++++++ .../description/ConsumerDescription.java | 12 +++++ .../description/ConsumerPartitionInfo.java | 19 +++++++ .../description/MultipleWindowsStat.java | 14 ++++++ .../ydb/topic/description/PartitionInfo.java | 17 +++++++ .../ydb/topic/description/PartitionStats.java | 18 +++++++ .../topic/description/SupportedCodecs.java | 13 +++++ .../topic/description/TopicDescription.java | 22 +++++++++ .../ydb/topic/description/TopicStats.java | 16 ++++++ .../ydb/topic/read/impl/OffsetsRangeImpl.java | 14 ++++++ ...AutoPartitioningWriteStrategySettings.java | 11 +++-- ...AutoPartitioningWriteStrategySettings.java | 25 ++++++++-- .../topic/settings/PartitioningSettings.java | 17 +++++++ .../topic/impl/YdbTopicsIntegrationTest.java | 49 +++++++++++++++++-- 15 files changed, 255 insertions(+), 12 deletions(-) diff --git a/tests/common/src/main/java/tech/ydb/test/integration/YdbEnvironment.java b/tests/common/src/main/java/tech/ydb/test/integration/YdbEnvironment.java index a2b493875..8b2711af8 100644 --- a/tests/common/src/main/java/tech/ydb/test/integration/YdbEnvironment.java +++ b/tests/common/src/main/java/tech/ydb/test/integration/YdbEnvironment.java @@ -9,7 +9,7 @@ * @author Aleksandr Gorshenin */ public class YdbEnvironment { - private static final String YDB_DEFAULT_IMAGE = "ydbplatform/local-ydb:latest"; + private static final String YDB_DEFAULT_IMAGE = "ydbplatform/local-ydb:25.1"; private final Supplier ydbEndpoint = createParam("YDB_ENDPOINT", null); private final Supplier ydbDatabase = createParam("YDB_DATABASE", null); diff --git a/topic/src/main/java/tech/ydb/topic/description/Consumer.java b/topic/src/main/java/tech/ydb/topic/description/Consumer.java index 3dc85d45c..dfd4dd3a2 100644 --- a/topic/src/main/java/tech/ydb/topic/description/Consumer.java +++ b/topic/src/main/java/tech/ydb/topic/description/Consumer.java @@ -5,6 +5,7 @@ import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.Objects; import java.util.stream.Collectors; import javax.annotation.Nonnull; @@ -140,4 +141,21 @@ public Consumer build() { return new Consumer(this); } } + + @Override + public boolean equals(Object o) { + if (o == null || getClass() != o.getClass()) return false; + Consumer consumer = (Consumer) o; + return important == consumer.important && + Objects.equals(name, consumer.name) && + Objects.equals(readFrom, consumer.readFrom) && + Objects.equals(supportedCodecs, consumer.supportedCodecs) && + Objects.equals(attributes, consumer.attributes) && + Objects.equals(stats, consumer.stats); + } + + @Override + public int hashCode() { + return Objects.hash(name, important, readFrom, supportedCodecs, attributes, stats); + } } diff --git a/topic/src/main/java/tech/ydb/topic/description/ConsumerDescription.java b/topic/src/main/java/tech/ydb/topic/description/ConsumerDescription.java index 4f4af116d..8ef7aad48 100644 --- a/topic/src/main/java/tech/ydb/topic/description/ConsumerDescription.java +++ b/topic/src/main/java/tech/ydb/topic/description/ConsumerDescription.java @@ -2,6 +2,7 @@ import java.util.List; +import java.util.Objects; import java.util.stream.Collectors; import tech.ydb.proto.topic.YdbTopic; @@ -29,4 +30,15 @@ public List getPartitions() { return partitions; } + @Override + public boolean equals(Object o) { + if (o == null || getClass() != o.getClass()) return false; + ConsumerDescription that = (ConsumerDescription) o; + return Objects.equals(consumer, that.consumer) && Objects.equals(partitions, that.partitions); + } + + @Override + public int hashCode() { + return Objects.hash(consumer, partitions); + } } diff --git a/topic/src/main/java/tech/ydb/topic/description/ConsumerPartitionInfo.java b/topic/src/main/java/tech/ydb/topic/description/ConsumerPartitionInfo.java index 225c614da..b64a9c67c 100644 --- a/topic/src/main/java/tech/ydb/topic/description/ConsumerPartitionInfo.java +++ b/topic/src/main/java/tech/ydb/topic/description/ConsumerPartitionInfo.java @@ -3,6 +3,7 @@ import java.time.Duration; import java.time.Instant; import java.util.List; +import java.util.Objects; import tech.ydb.core.utils.ProtobufUtils; import tech.ydb.proto.topic.YdbTopic; @@ -178,4 +179,22 @@ public int getConnectionNodeId() { return connectionNodeId; } } + + @Override + public boolean equals(Object o) { + if (o == null || getClass() != o.getClass()) return false; + ConsumerPartitionInfo that = (ConsumerPartitionInfo) o; + return partitionId == that.partitionId && + active == that.active && + Objects.equals(childPartitionIds, that.childPartitionIds) && + Objects.equals(parentPartitionIds, that.parentPartitionIds) && + Objects.equals(partitionStats, that.partitionStats) && + Objects.equals(consumerStats, that.consumerStats) && + Objects.equals(location, that.location); + } + + @Override + public int hashCode() { + return Objects.hash(partitionId, active, childPartitionIds, parentPartitionIds, partitionStats, consumerStats, location); + } } diff --git a/topic/src/main/java/tech/ydb/topic/description/MultipleWindowsStat.java b/topic/src/main/java/tech/ydb/topic/description/MultipleWindowsStat.java index 74a0c4f2a..1f0b42fda 100644 --- a/topic/src/main/java/tech/ydb/topic/description/MultipleWindowsStat.java +++ b/topic/src/main/java/tech/ydb/topic/description/MultipleWindowsStat.java @@ -2,6 +2,8 @@ import tech.ydb.proto.topic.YdbTopic; +import java.util.Objects; + /** * @author Nikolay Perfilov */ @@ -33,4 +35,16 @@ public long getPerHour() { public long getPerDay() { return perDay; } + + @Override + public boolean equals(Object o) { + if (o == null || getClass() != o.getClass()) return false; + MultipleWindowsStat that = (MultipleWindowsStat) o; + return perMinute == that.perMinute && perHour == that.perHour && perDay == that.perDay; + } + + @Override + public int hashCode() { + return Objects.hash(perMinute, perHour, perDay); + } } diff --git a/topic/src/main/java/tech/ydb/topic/description/PartitionInfo.java b/topic/src/main/java/tech/ydb/topic/description/PartitionInfo.java index 1c16782f0..520e28e23 100644 --- a/topic/src/main/java/tech/ydb/topic/description/PartitionInfo.java +++ b/topic/src/main/java/tech/ydb/topic/description/PartitionInfo.java @@ -2,6 +2,7 @@ import java.util.ArrayList; import java.util.List; +import java.util.Objects; import com.google.common.collect.ImmutableList; @@ -86,4 +87,20 @@ public PartitionInfo build() { return new PartitionInfo(this); } } + + @Override + public boolean equals(Object o) { + if (o == null || getClass() != o.getClass()) return false; + PartitionInfo that = (PartitionInfo) o; + return partitionId == that.partitionId && + active == that.active && + Objects.equals(childPartitionIds, that.childPartitionIds) && + Objects.equals(parentPartitionIds, that.parentPartitionIds) && + Objects.equals(partitionStats, that.partitionStats); + } + + @Override + public int hashCode() { + return Objects.hash(partitionId, active, childPartitionIds, parentPartitionIds, partitionStats); + } } diff --git a/topic/src/main/java/tech/ydb/topic/description/PartitionStats.java b/topic/src/main/java/tech/ydb/topic/description/PartitionStats.java index 78bde4ec1..493023e12 100644 --- a/topic/src/main/java/tech/ydb/topic/description/PartitionStats.java +++ b/topic/src/main/java/tech/ydb/topic/description/PartitionStats.java @@ -2,6 +2,7 @@ import java.time.Duration; import java.time.Instant; +import java.util.Objects; import javax.annotation.Nullable; @@ -126,4 +127,21 @@ public PartitionStats build() { return new PartitionStats(this); } } + + @Override + public boolean equals(Object o) { + if (o == null || getClass() != o.getClass()) return false; + PartitionStats that = (PartitionStats) o; + return storeSizeBytes == that.storeSizeBytes && + partitionNodeId == that.partitionNodeId && + Objects.equals(partitionOffsets, that.partitionOffsets) && + Objects.equals(lastWriteTime, that.lastWriteTime) && + Objects.equals(maxWriteTimeLag, that.maxWriteTimeLag) && + Objects.equals(bytesWritten, that.bytesWritten); + } + + @Override + public int hashCode() { + return Objects.hash(partitionOffsets, storeSizeBytes, lastWriteTime, maxWriteTimeLag, bytesWritten, partitionNodeId); + } } diff --git a/topic/src/main/java/tech/ydb/topic/description/SupportedCodecs.java b/topic/src/main/java/tech/ydb/topic/description/SupportedCodecs.java index 09a4b126b..01d66c1ff 100644 --- a/topic/src/main/java/tech/ydb/topic/description/SupportedCodecs.java +++ b/topic/src/main/java/tech/ydb/topic/description/SupportedCodecs.java @@ -2,6 +2,7 @@ import java.util.ArrayList; import java.util.List; +import java.util.Objects; import com.google.common.collect.ImmutableList; @@ -47,4 +48,16 @@ public SupportedCodecs build() { return new SupportedCodecs(this); } } + + @Override + public boolean equals(Object o) { + if (o == null || getClass() != o.getClass()) return false; + SupportedCodecs that = (SupportedCodecs) o; + return Objects.equals(codecs, that.codecs); + } + + @Override + public int hashCode() { + return Objects.hashCode(codecs); + } } diff --git a/topic/src/main/java/tech/ydb/topic/description/TopicDescription.java b/topic/src/main/java/tech/ydb/topic/description/TopicDescription.java index 38aeb8123..14e3c8e3c 100644 --- a/topic/src/main/java/tech/ydb/topic/description/TopicDescription.java +++ b/topic/src/main/java/tech/ydb/topic/description/TopicDescription.java @@ -4,6 +4,7 @@ import java.util.ArrayList; import java.util.List; import java.util.Map; +import java.util.Objects; import javax.annotation.Nonnull; import javax.annotation.Nullable; @@ -180,4 +181,25 @@ public TopicDescription build() { } } + @Override + public boolean equals(Object o) { + if (o == null || getClass() != o.getClass()) return false; + TopicDescription that = (TopicDescription) o; + return retentionStorageMb == that.retentionStorageMb && + partitionWriteSpeedBytesPerSecond == that.partitionWriteSpeedBytesPerSecond && + partitionWriteBurstBytes == that.partitionWriteBurstBytes && + Objects.equals(partitioningSettings, that.partitioningSettings) && + Objects.equals(partitions, that.partitions) && + Objects.equals(retentionPeriod, that.retentionPeriod) && + Objects.equals(supportedCodecs, that.supportedCodecs) && + Objects.equals(attributes, that.attributes) && + Objects.equals(consumers, that.consumers) && + meteringMode == that.meteringMode && + Objects.equals(topicStats, that.topicStats); + } + + @Override + public int hashCode() { + return Objects.hash(partitioningSettings, partitions, retentionPeriod, retentionStorageMb, supportedCodecs, partitionWriteSpeedBytesPerSecond, partitionWriteBurstBytes, attributes, consumers, meteringMode, topicStats); + } } diff --git a/topic/src/main/java/tech/ydb/topic/description/TopicStats.java b/topic/src/main/java/tech/ydb/topic/description/TopicStats.java index f350660a1..1309cae0a 100644 --- a/topic/src/main/java/tech/ydb/topic/description/TopicStats.java +++ b/topic/src/main/java/tech/ydb/topic/description/TopicStats.java @@ -2,6 +2,7 @@ import java.time.Duration; import java.time.Instant; +import java.util.Objects; import javax.annotation.Nullable; @@ -76,4 +77,19 @@ public TopicStats build() { return new TopicStats(this); } } + + @Override + public boolean equals(Object o) { + if (o == null || getClass() != o.getClass()) return false; + TopicStats that = (TopicStats) o; + return storeSizeBytes == that.storeSizeBytes && + Objects.equals(minLastWriteTime, that.minLastWriteTime) && + Objects.equals(maxWriteTimeLag, that.maxWriteTimeLag) && + Objects.equals(bytesWritten, that.bytesWritten); + } + + @Override + public int hashCode() { + return Objects.hash(storeSizeBytes, minLastWriteTime, maxWriteTimeLag, bytesWritten); + } } diff --git a/topic/src/main/java/tech/ydb/topic/read/impl/OffsetsRangeImpl.java b/topic/src/main/java/tech/ydb/topic/read/impl/OffsetsRangeImpl.java index 6cf1165ca..b9ac8b547 100644 --- a/topic/src/main/java/tech/ydb/topic/read/impl/OffsetsRangeImpl.java +++ b/topic/src/main/java/tech/ydb/topic/read/impl/OffsetsRangeImpl.java @@ -2,6 +2,8 @@ import tech.ydb.topic.description.OffsetsRange; +import java.util.Objects; + /** * @author Nikolay Perfilov */ @@ -36,4 +38,16 @@ public void setStart(long start) { public void setEnd(long end) { this.end = end; } + + @Override + public boolean equals(Object o) { + if (o == null || getClass() != o.getClass()) return false; + OffsetsRangeImpl that = (OffsetsRangeImpl) o; + return start == that.start && end == that.end; + } + + @Override + public int hashCode() { + return Objects.hash(start, end); + } } diff --git a/topic/src/main/java/tech/ydb/topic/settings/AlterAutoPartitioningWriteStrategySettings.java b/topic/src/main/java/tech/ydb/topic/settings/AlterAutoPartitioningWriteStrategySettings.java index d88d13415..8d8ec0bce 100644 --- a/topic/src/main/java/tech/ydb/topic/settings/AlterAutoPartitioningWriteStrategySettings.java +++ b/topic/src/main/java/tech/ydb/topic/settings/AlterAutoPartitioningWriteStrategySettings.java @@ -4,7 +4,6 @@ import java.time.Duration; -// TODO add proper javadocs public class AlterAutoPartitioningWriteStrategySettings { @Nullable private final Duration stabilizationWindow; @@ -44,7 +43,8 @@ public static class Builder { private Integer downUtilizationPercent = null; /** - * @param stabilizationWindow + * @param stabilizationWindow Duration used by the auto partitioning algorithm to define if the partition must be split. + * Default value is 5 minutes. * @return strategy builder */ public Builder setStabilizationWindow(Duration stabilizationWindow) { @@ -53,7 +53,8 @@ public Builder setStabilizationWindow(Duration stabilizationWindow) { } /** - * @param upUtilizationPercent + * @param upUtilizationPercent Upper level of partition quota utilization after which the partition should be split. + * Default value is 90%. * @return strategy builder */ public Builder setUpUtilizationPercent(int upUtilizationPercent) { @@ -62,7 +63,9 @@ public Builder setUpUtilizationPercent(int upUtilizationPercent) { } /** - * @param downUtilizationPercent + * @param downUtilizationPercent Lower level of partition quota utilization + * after which the partition should be merged with the other one. + * Default value is 30%. * @return strategy builder */ public Builder setDownUtilizationPercent(int downUtilizationPercent) { diff --git a/topic/src/main/java/tech/ydb/topic/settings/AutoPartitioningWriteStrategySettings.java b/topic/src/main/java/tech/ydb/topic/settings/AutoPartitioningWriteStrategySettings.java index 30f5f3f89..9f39c988a 100644 --- a/topic/src/main/java/tech/ydb/topic/settings/AutoPartitioningWriteStrategySettings.java +++ b/topic/src/main/java/tech/ydb/topic/settings/AutoPartitioningWriteStrategySettings.java @@ -1,6 +1,7 @@ package tech.ydb.topic.settings; import java.time.Duration; +import java.util.Objects; public class AutoPartitioningWriteStrategySettings { private final Duration stabilizationWindow; @@ -35,7 +36,8 @@ public static class Builder { private int downUtilizationPercent = 30; /** - * @param stabilizationWindow + * @param stabilizationWindow Duration used by the auto partitioning algorithm to define if the partition must be split. + * Default value is 5 minutes. * @return strategy builder */ public Builder setStabilizationWindow(Duration stabilizationWindow) { @@ -44,7 +46,8 @@ public Builder setStabilizationWindow(Duration stabilizationWindow) { } /** - * @param upUtilizationPercent + * @param upUtilizationPercent Upper level of partition quota utilization after which the partition should be split. + * Default value is 90%. * @return strategy builder */ public Builder setUpUtilizationPercent(int upUtilizationPercent) { @@ -53,7 +56,9 @@ public Builder setUpUtilizationPercent(int upUtilizationPercent) { } /** - * @param downUtilizationPercent + * @param downUtilizationPercent Lower level of partition quota utilization + * after which the partition should be merged with the other one. + * Default value is 30%. * @return strategy builder */ public Builder setDownUtilizationPercent(int downUtilizationPercent) { @@ -65,4 +70,18 @@ public AutoPartitioningWriteStrategySettings build() { return new AutoPartitioningWriteStrategySettings(this); } } + + @Override + public boolean equals(Object o) { + if (o == null || getClass() != o.getClass()) return false; + AutoPartitioningWriteStrategySettings that = (AutoPartitioningWriteStrategySettings) o; + return upUtilizationPercent == that.upUtilizationPercent && + downUtilizationPercent == that.downUtilizationPercent && + Objects.equals(stabilizationWindow, that.stabilizationWindow); + } + + @Override + public int hashCode() { + return Objects.hash(stabilizationWindow, upUtilizationPercent, downUtilizationPercent); + } } diff --git a/topic/src/main/java/tech/ydb/topic/settings/PartitioningSettings.java b/topic/src/main/java/tech/ydb/topic/settings/PartitioningSettings.java index e963babc2..d7e82dc6c 100644 --- a/topic/src/main/java/tech/ydb/topic/settings/PartitioningSettings.java +++ b/topic/src/main/java/tech/ydb/topic/settings/PartitioningSettings.java @@ -1,5 +1,7 @@ package tech.ydb.topic.settings; +import java.util.Objects; + /** * @author Nikolay Perfilov */ @@ -107,4 +109,19 @@ public PartitioningSettings build() { return new PartitioningSettings(this); } } + + @Override + public boolean equals(Object o) { + if (o == null || getClass() != o.getClass()) return false; + PartitioningSettings that = (PartitioningSettings) o; + return minActivePartitions == that.minActivePartitions && + partitionCountLimit == that.partitionCountLimit && + autoPartitioningStrategy == that.autoPartitioningStrategy && + Objects.equals(writeStrategySettings, that.writeStrategySettings); + } + + @Override + public int hashCode() { + return Objects.hash(minActivePartitions, partitionCountLimit, autoPartitioningStrategy, writeStrategySettings); + } } diff --git a/topic/src/test/java/tech/ydb/topic/impl/YdbTopicsIntegrationTest.java b/topic/src/test/java/tech/ydb/topic/impl/YdbTopicsIntegrationTest.java index 368445fcf..380287326 100644 --- a/topic/src/test/java/tech/ydb/topic/impl/YdbTopicsIntegrationTest.java +++ b/topic/src/test/java/tech/ydb/topic/impl/YdbTopicsIntegrationTest.java @@ -1,5 +1,6 @@ package tech.ydb.topic.impl; +import java.time.Duration; import java.util.List; import java.util.concurrent.CompletableFuture; import java.util.concurrent.ExecutionException; @@ -12,6 +13,7 @@ import org.junit.BeforeClass; import org.junit.ClassRule; import org.junit.FixMethodOrder; +import org.junit.Ignore; import org.junit.Test; import org.junit.runners.MethodSorters; import org.slf4j.Logger; @@ -27,7 +29,13 @@ import tech.ydb.topic.read.SyncReader; import tech.ydb.topic.read.events.AbstractReadEventHandler; import tech.ydb.topic.read.events.DataReceivedEvent; +import tech.ydb.topic.settings.AlterAutoPartitioningWriteStrategySettings; +import tech.ydb.topic.settings.AlterPartitioningSettings; +import tech.ydb.topic.settings.AlterTopicSettings; +import tech.ydb.topic.settings.AutoPartitioningStrategy; +import tech.ydb.topic.settings.AutoPartitioningWriteStrategySettings; import tech.ydb.topic.settings.CreateTopicSettings; +import tech.ydb.topic.settings.PartitioningSettings; import tech.ydb.topic.settings.ReadEventHandlersSettings; import tech.ydb.topic.settings.ReaderSettings; import tech.ydb.topic.settings.TopicReadSettings; @@ -131,7 +139,7 @@ public void step03_readHalfWithCommit() throws InterruptedException { for (byte[] bytes: TEST_MESSAGES) { tech.ydb.topic.read.Message msg = reader.receive(); Assert.assertArrayEquals(bytes, msg.getData()); - msg.commit(); + msg.commit().join(); } reader.shutdown(); @@ -149,7 +157,11 @@ public void step03_readNextHalfWithoutCommit() throws InterruptedException { for (int idx = TEST_MESSAGES.length - 1; idx >= 0; idx -= 1) { tech.ydb.topic.read.Message msg = reader.receive(); - Assert.assertArrayEquals(TEST_MESSAGES[idx], msg.getData()); + Assert.assertArrayEquals( + new String(msg.getData()) + " on position " + idx, + TEST_MESSAGES[idx], + msg.getData() + ); } reader.shutdown(); @@ -168,7 +180,11 @@ public void step04_readNextHalfWithCommit() throws InterruptedException { DeferredCommitter committer = DeferredCommitter.newInstance(); for (int idx = TEST_MESSAGES.length - 1; idx >= 0; idx -= 1) { tech.ydb.topic.read.Message msg = reader.receive(); - Assert.assertArrayEquals(TEST_MESSAGES[idx], msg.getData()); + Assert.assertArrayEquals( + new String(msg.getData()) + " on position " + idx, + TEST_MESSAGES[idx], + msg.getData() + ); committer.add(msg); } @@ -228,8 +244,33 @@ public void onMessages(DataReceivedEvent dre) { } } + @Ignore("remove ignore once :latest YDB container tag moves onto version 25.1") @Test public void step07_alterTopicWithAutoPartitioning() { - // TODO add proper integration test for alter + describe + client.alterTopic(TEST_TOPIC, AlterTopicSettings.newBuilder() + .setAlterPartitioningSettings(AlterPartitioningSettings.newBuilder() + .setAutoPartitioningStrategy(AutoPartitioningStrategy.SCALE_UP) + .setWriteStrategySettings(AlterAutoPartitioningWriteStrategySettings.newBuilder() + .setStabilizationWindow(Duration.ofMinutes(1)) + .setUpUtilizationPercent(80) + .build()) + .build()) + .build()).join().expectSuccess("can't alter the topic"); + + TopicDescription description = client.describeTopic(TEST_TOPIC).join().getValue(); + + PartitioningSettings actualPartitioningSettings = description.getPartitioningSettings(); + PartitioningSettings expectedPartitioningSettings = PartitioningSettings.newBuilder() + .setAutoPartitioningStrategy(AutoPartitioningStrategy.SCALE_UP) + .setWriteStrategySettings(AutoPartitioningWriteStrategySettings.newBuilder() + .setStabilizationWindow(Duration.ofMinutes(1)) + .setUpUtilizationPercent(80) + .setDownUtilizationPercent(20) + .build()) + .setMinActivePartitions(1) + .setPartitionCountLimit(0) + .build(); + + Assert.assertEquals(expectedPartitioningSettings, actualPartitioningSettings); } } From ea50c505cf3f2da03b9ae815e2b2d82c4d8d47fa Mon Sep 17 00:00:00 2001 From: Daniil Zulin Date: Tue, 6 May 2025 20:55:34 +0700 Subject: [PATCH 3/8] Revert changes in YdbEnvironment --- .../src/main/java/tech/ydb/test/integration/YdbEnvironment.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/common/src/main/java/tech/ydb/test/integration/YdbEnvironment.java b/tests/common/src/main/java/tech/ydb/test/integration/YdbEnvironment.java index 8b2711af8..a2b493875 100644 --- a/tests/common/src/main/java/tech/ydb/test/integration/YdbEnvironment.java +++ b/tests/common/src/main/java/tech/ydb/test/integration/YdbEnvironment.java @@ -9,7 +9,7 @@ * @author Aleksandr Gorshenin */ public class YdbEnvironment { - private static final String YDB_DEFAULT_IMAGE = "ydbplatform/local-ydb:25.1"; + private static final String YDB_DEFAULT_IMAGE = "ydbplatform/local-ydb:latest"; private final Supplier ydbEndpoint = createParam("YDB_ENDPOINT", null); private final Supplier ydbDatabase = createParam("YDB_DATABASE", null); From 17eece39b7c4c33f60e61b39f002dcdce57ac239 Mon Sep 17 00:00:00 2001 From: Daniil Zulin Date: Wed, 7 May 2025 13:45:43 +0700 Subject: [PATCH 4/8] Fix checkstyle --- .../tech/ydb/topic/description/Consumer.java | 4 ++- .../description/ConsumerDescription.java | 4 ++- .../description/ConsumerPartitionInfo.java | 14 ++++++++-- .../description/MultipleWindowsStat.java | 8 +++--- .../ydb/topic/description/PartitionInfo.java | 4 ++- .../ydb/topic/description/PartitionStats.java | 13 ++++++++-- .../topic/description/SupportedCodecs.java | 4 ++- .../topic/description/TopicDescription.java | 18 +++++++++++-- .../ydb/topic/description/TopicStats.java | 4 ++- .../tech/ydb/topic/impl/TopicClientImpl.java | 26 ++++++++++++++----- .../ydb/topic/read/impl/OffsetsRangeImpl.java | 8 +++--- ...AutoPartitioningWriteStrategySettings.java | 4 +-- .../settings/AutoPartitioningStrategy.java | 4 +-- ...AutoPartitioningWriteStrategySettings.java | 4 ++- .../topic/settings/PartitioningSettings.java | 4 ++- 15 files changed, 93 insertions(+), 30 deletions(-) diff --git a/topic/src/main/java/tech/ydb/topic/description/Consumer.java b/topic/src/main/java/tech/ydb/topic/description/Consumer.java index dfd4dd3a2..e20ca9f85 100644 --- a/topic/src/main/java/tech/ydb/topic/description/Consumer.java +++ b/topic/src/main/java/tech/ydb/topic/description/Consumer.java @@ -144,7 +144,9 @@ public Consumer build() { @Override public boolean equals(Object o) { - if (o == null || getClass() != o.getClass()) return false; + if (o == null || getClass() != o.getClass()) { + return false; + } Consumer consumer = (Consumer) o; return important == consumer.important && Objects.equals(name, consumer.name) && diff --git a/topic/src/main/java/tech/ydb/topic/description/ConsumerDescription.java b/topic/src/main/java/tech/ydb/topic/description/ConsumerDescription.java index 8ef7aad48..68084c2aa 100644 --- a/topic/src/main/java/tech/ydb/topic/description/ConsumerDescription.java +++ b/topic/src/main/java/tech/ydb/topic/description/ConsumerDescription.java @@ -32,7 +32,9 @@ public List getPartitions() { @Override public boolean equals(Object o) { - if (o == null || getClass() != o.getClass()) return false; + if (o == null || getClass() != o.getClass()) { + return false; + } ConsumerDescription that = (ConsumerDescription) o; return Objects.equals(consumer, that.consumer) && Objects.equals(partitions, that.partitions); } diff --git a/topic/src/main/java/tech/ydb/topic/description/ConsumerPartitionInfo.java b/topic/src/main/java/tech/ydb/topic/description/ConsumerPartitionInfo.java index b64a9c67c..babd11506 100644 --- a/topic/src/main/java/tech/ydb/topic/description/ConsumerPartitionInfo.java +++ b/topic/src/main/java/tech/ydb/topic/description/ConsumerPartitionInfo.java @@ -182,7 +182,9 @@ public int getConnectionNodeId() { @Override public boolean equals(Object o) { - if (o == null || getClass() != o.getClass()) return false; + if (o == null || getClass() != o.getClass()) { + return false; + } ConsumerPartitionInfo that = (ConsumerPartitionInfo) o; return partitionId == that.partitionId && active == that.active && @@ -195,6 +197,14 @@ public boolean equals(Object o) { @Override public int hashCode() { - return Objects.hash(partitionId, active, childPartitionIds, parentPartitionIds, partitionStats, consumerStats, location); + return Objects.hash( + partitionId, + active, + childPartitionIds, + parentPartitionIds, + partitionStats, + consumerStats, + location + ); } } diff --git a/topic/src/main/java/tech/ydb/topic/description/MultipleWindowsStat.java b/topic/src/main/java/tech/ydb/topic/description/MultipleWindowsStat.java index 1f0b42fda..dcbf1ac66 100644 --- a/topic/src/main/java/tech/ydb/topic/description/MultipleWindowsStat.java +++ b/topic/src/main/java/tech/ydb/topic/description/MultipleWindowsStat.java @@ -1,9 +1,9 @@ package tech.ydb.topic.description; -import tech.ydb.proto.topic.YdbTopic; - import java.util.Objects; +import tech.ydb.proto.topic.YdbTopic; + /** * @author Nikolay Perfilov */ @@ -38,7 +38,9 @@ public long getPerDay() { @Override public boolean equals(Object o) { - if (o == null || getClass() != o.getClass()) return false; + if (o == null || getClass() != o.getClass()) { + return false; + } MultipleWindowsStat that = (MultipleWindowsStat) o; return perMinute == that.perMinute && perHour == that.perHour && perDay == that.perDay; } diff --git a/topic/src/main/java/tech/ydb/topic/description/PartitionInfo.java b/topic/src/main/java/tech/ydb/topic/description/PartitionInfo.java index 520e28e23..dc439191e 100644 --- a/topic/src/main/java/tech/ydb/topic/description/PartitionInfo.java +++ b/topic/src/main/java/tech/ydb/topic/description/PartitionInfo.java @@ -90,7 +90,9 @@ public PartitionInfo build() { @Override public boolean equals(Object o) { - if (o == null || getClass() != o.getClass()) return false; + if (o == null || getClass() != o.getClass()) { + return false; + } PartitionInfo that = (PartitionInfo) o; return partitionId == that.partitionId && active == that.active && diff --git a/topic/src/main/java/tech/ydb/topic/description/PartitionStats.java b/topic/src/main/java/tech/ydb/topic/description/PartitionStats.java index 493023e12..8c4e27b35 100644 --- a/topic/src/main/java/tech/ydb/topic/description/PartitionStats.java +++ b/topic/src/main/java/tech/ydb/topic/description/PartitionStats.java @@ -130,7 +130,9 @@ public PartitionStats build() { @Override public boolean equals(Object o) { - if (o == null || getClass() != o.getClass()) return false; + if (o == null || getClass() != o.getClass()) { + return false; + } PartitionStats that = (PartitionStats) o; return storeSizeBytes == that.storeSizeBytes && partitionNodeId == that.partitionNodeId && @@ -142,6 +144,13 @@ public boolean equals(Object o) { @Override public int hashCode() { - return Objects.hash(partitionOffsets, storeSizeBytes, lastWriteTime, maxWriteTimeLag, bytesWritten, partitionNodeId); + return Objects.hash( + partitionOffsets, + storeSizeBytes, + lastWriteTime, + maxWriteTimeLag, + bytesWritten, + partitionNodeId + ); } } diff --git a/topic/src/main/java/tech/ydb/topic/description/SupportedCodecs.java b/topic/src/main/java/tech/ydb/topic/description/SupportedCodecs.java index 01d66c1ff..2fa1d088c 100644 --- a/topic/src/main/java/tech/ydb/topic/description/SupportedCodecs.java +++ b/topic/src/main/java/tech/ydb/topic/description/SupportedCodecs.java @@ -51,7 +51,9 @@ public SupportedCodecs build() { @Override public boolean equals(Object o) { - if (o == null || getClass() != o.getClass()) return false; + if (o == null || getClass() != o.getClass()) { + return false; + } SupportedCodecs that = (SupportedCodecs) o; return Objects.equals(codecs, that.codecs); } diff --git a/topic/src/main/java/tech/ydb/topic/description/TopicDescription.java b/topic/src/main/java/tech/ydb/topic/description/TopicDescription.java index 14e3c8e3c..024ccd709 100644 --- a/topic/src/main/java/tech/ydb/topic/description/TopicDescription.java +++ b/topic/src/main/java/tech/ydb/topic/description/TopicDescription.java @@ -183,7 +183,9 @@ public TopicDescription build() { @Override public boolean equals(Object o) { - if (o == null || getClass() != o.getClass()) return false; + if (o == null || getClass() != o.getClass()) { + return false; + } TopicDescription that = (TopicDescription) o; return retentionStorageMb == that.retentionStorageMb && partitionWriteSpeedBytesPerSecond == that.partitionWriteSpeedBytesPerSecond && @@ -200,6 +202,18 @@ public boolean equals(Object o) { @Override public int hashCode() { - return Objects.hash(partitioningSettings, partitions, retentionPeriod, retentionStorageMb, supportedCodecs, partitionWriteSpeedBytesPerSecond, partitionWriteBurstBytes, attributes, consumers, meteringMode, topicStats); + return Objects.hash( + partitioningSettings, + partitions, + retentionPeriod, + retentionStorageMb, + supportedCodecs, + partitionWriteSpeedBytesPerSecond, + partitionWriteBurstBytes, + attributes, + consumers, + meteringMode, + topicStats + ); } } diff --git a/topic/src/main/java/tech/ydb/topic/description/TopicStats.java b/topic/src/main/java/tech/ydb/topic/description/TopicStats.java index 1309cae0a..5f7d77a2d 100644 --- a/topic/src/main/java/tech/ydb/topic/description/TopicStats.java +++ b/topic/src/main/java/tech/ydb/topic/description/TopicStats.java @@ -80,7 +80,9 @@ public TopicStats build() { @Override public boolean equals(Object o) { - if (o == null || getClass() != o.getClass()) return false; + if (o == null || getClass() != o.getClass()) { + return false; + } TopicStats that = (TopicStats) o; return storeSizeBytes == that.storeSizeBytes && Objects.equals(minLastWriteTime, that.minLastWriteTime) && diff --git a/topic/src/main/java/tech/ydb/topic/impl/TopicClientImpl.java b/topic/src/main/java/tech/ydb/topic/impl/TopicClientImpl.java index 4834aa179..0b8a0b922 100644 --- a/topic/src/main/java/tech/ydb/topic/impl/TopicClientImpl.java +++ b/topic/src/main/java/tech/ydb/topic/impl/TopicClientImpl.java @@ -111,11 +111,15 @@ public CompletableFuture createTopic(String path, CreateTopicSettings se .setAutoPartitioningSettings(YdbTopic.AutoPartitioningSettings.newBuilder() .setStrategy(partitioningSettings.getAutoPartitioningStrategy().getProtoReference()))); - AutoPartitioningWriteStrategySettings writeStrategySettings = partitioningSettings.getWriteStrategySettings(); + AutoPartitioningWriteStrategySettings writeStrategySettings = partitioningSettings + .getWriteStrategySettings(); + if (writeStrategySettings != null) { requestBuilder.getPartitioningSettingsBuilder().getAutoPartitioningSettingsBuilder() .setPartitionWriteSpeed(YdbTopic.AutoPartitioningWriteSpeedStrategy.newBuilder() - .setStabilizationWindow(ProtobufUtils.durationToProto(writeStrategySettings.getStabilizationWindow())) + .setStabilizationWindow(ProtobufUtils.durationToProto( + writeStrategySettings.getStabilizationWindow() + )) .setDownUtilizationPercent(writeStrategySettings.getDownUtilizationPercent()) .setUpUtilizationPercent(writeStrategySettings.getUpUtilizationPercent()) ); @@ -162,9 +166,11 @@ public CompletableFuture alterTopic(String path, AlterTopicSettings sett } AutoPartitioningStrategy autoPartitioningStrategy = partitioningSettings.getAutoPartitioningStrategy(); if (autoPartitioningStrategy != null) { - builder.getAlterAutoPartitioningSettingsBuilder().setSetStrategy(autoPartitioningStrategy.getProtoReference()); + YdbTopic.AutoPartitioningStrategy protoReference = autoPartitioningStrategy.getProtoReference(); + builder.getAlterAutoPartitioningSettingsBuilder().setSetStrategy(protoReference); } - AlterAutoPartitioningWriteStrategySettings writeStrategySettings = partitioningSettings.getWriteStrategySettings(); + AlterAutoPartitioningWriteStrategySettings writeStrategySettings = partitioningSettings + .getWriteStrategySettings(); if (writeStrategySettings != null) { Duration stabilizationWindow = writeStrategySettings.getStabilizationWindow(); if (stabilizationWindow != null) { @@ -310,14 +316,20 @@ private TopicDescription mapDescribeTopic(YdbTopic.DescribeTopicResult result) { .setMeteringMode(fromProto(result.getMeteringMode())); YdbTopic.PartitioningSettings partitioningSettings = result.getPartitioningSettings(); + YdbTopic.AutoPartitioningSettings autoPartitioningSettings = partitioningSettings.getAutoPartitioningSettings(); + YdbTopic.AutoPartitioningStrategy autoPartitioningStrategy = autoPartitioningSettings.getStrategy(); + PartitioningSettings.Builder partitioningDescription = PartitioningSettings.newBuilder() .setMinActivePartitions(partitioningSettings.getMinActivePartitions()) .setPartitionCountLimit(partitioningSettings.getPartitionCountLimit()) - .setAutoPartitioningStrategy(AutoPartitioningStrategy.fromProto(partitioningSettings.getAutoPartitioningSettings().getStrategy())); + .setAutoPartitioningStrategy(AutoPartitioningStrategy.fromProto(autoPartitioningStrategy)); - YdbTopic.AutoPartitioningWriteSpeedStrategy partitionWriteSpeed = partitioningSettings.getAutoPartitioningSettings().getPartitionWriteSpeed(); + YdbTopic.AutoPartitioningWriteSpeedStrategy partitionWriteSpeed = autoPartitioningSettings + .getPartitionWriteSpeed(); partitioningDescription.setWriteStrategySettings(AutoPartitioningWriteStrategySettings.newBuilder() - .setStabilizationWindow(ProtobufUtils.protoToDuration(partitionWriteSpeed.getStabilizationWindow())) + .setStabilizationWindow(ProtobufUtils.protoToDuration( + partitionWriteSpeed.getStabilizationWindow() + )) .setUpUtilizationPercent(partitionWriteSpeed.getUpUtilizationPercent()) .setDownUtilizationPercent(partitionWriteSpeed.getDownUtilizationPercent()) .build()); diff --git a/topic/src/main/java/tech/ydb/topic/read/impl/OffsetsRangeImpl.java b/topic/src/main/java/tech/ydb/topic/read/impl/OffsetsRangeImpl.java index b9ac8b547..e85cad1a1 100644 --- a/topic/src/main/java/tech/ydb/topic/read/impl/OffsetsRangeImpl.java +++ b/topic/src/main/java/tech/ydb/topic/read/impl/OffsetsRangeImpl.java @@ -1,9 +1,9 @@ package tech.ydb.topic.read.impl; -import tech.ydb.topic.description.OffsetsRange; - import java.util.Objects; +import tech.ydb.topic.description.OffsetsRange; + /** * @author Nikolay Perfilov */ @@ -41,7 +41,9 @@ public void setEnd(long end) { @Override public boolean equals(Object o) { - if (o == null || getClass() != o.getClass()) return false; + if (o == null || getClass() != o.getClass()) { + return false; + } OffsetsRangeImpl that = (OffsetsRangeImpl) o; return start == that.start && end == that.end; } diff --git a/topic/src/main/java/tech/ydb/topic/settings/AlterAutoPartitioningWriteStrategySettings.java b/topic/src/main/java/tech/ydb/topic/settings/AlterAutoPartitioningWriteStrategySettings.java index 8d8ec0bce..facbc4993 100644 --- a/topic/src/main/java/tech/ydb/topic/settings/AlterAutoPartitioningWriteStrategySettings.java +++ b/topic/src/main/java/tech/ydb/topic/settings/AlterAutoPartitioningWriteStrategySettings.java @@ -1,9 +1,9 @@ package tech.ydb.topic.settings; -import javax.annotation.Nullable; - import java.time.Duration; +import javax.annotation.Nullable; + public class AlterAutoPartitioningWriteStrategySettings { @Nullable private final Duration stabilizationWindow; diff --git a/topic/src/main/java/tech/ydb/topic/settings/AutoPartitioningStrategy.java b/topic/src/main/java/tech/ydb/topic/settings/AutoPartitioningStrategy.java index 89f23c07d..00015b6f7 100644 --- a/topic/src/main/java/tech/ydb/topic/settings/AutoPartitioningStrategy.java +++ b/topic/src/main/java/tech/ydb/topic/settings/AutoPartitioningStrategy.java @@ -1,9 +1,9 @@ package tech.ydb.topic.settings; -import tech.ydb.proto.topic.YdbTopic; - import javax.annotation.Nullable; +import tech.ydb.proto.topic.YdbTopic; + public enum AutoPartitioningStrategy { /** * The auto partitioning is disabled. diff --git a/topic/src/main/java/tech/ydb/topic/settings/AutoPartitioningWriteStrategySettings.java b/topic/src/main/java/tech/ydb/topic/settings/AutoPartitioningWriteStrategySettings.java index 9f39c988a..c54ab0572 100644 --- a/topic/src/main/java/tech/ydb/topic/settings/AutoPartitioningWriteStrategySettings.java +++ b/topic/src/main/java/tech/ydb/topic/settings/AutoPartitioningWriteStrategySettings.java @@ -73,7 +73,9 @@ public AutoPartitioningWriteStrategySettings build() { @Override public boolean equals(Object o) { - if (o == null || getClass() != o.getClass()) return false; + if (o == null || getClass() != o.getClass()) { + return false; + } AutoPartitioningWriteStrategySettings that = (AutoPartitioningWriteStrategySettings) o; return upUtilizationPercent == that.upUtilizationPercent && downUtilizationPercent == that.downUtilizationPercent && diff --git a/topic/src/main/java/tech/ydb/topic/settings/PartitioningSettings.java b/topic/src/main/java/tech/ydb/topic/settings/PartitioningSettings.java index d7e82dc6c..d19f361eb 100644 --- a/topic/src/main/java/tech/ydb/topic/settings/PartitioningSettings.java +++ b/topic/src/main/java/tech/ydb/topic/settings/PartitioningSettings.java @@ -112,7 +112,9 @@ public PartitioningSettings build() { @Override public boolean equals(Object o) { - if (o == null || getClass() != o.getClass()) return false; + if (o == null || getClass() != o.getClass()) { + return false; + } PartitioningSettings that = (PartitioningSettings) o; return minActivePartitions == that.minActivePartitions && partitionCountLimit == that.partitionCountLimit && From 1ca0b668ecca14f0c88b01e1fa604a3eae486914 Mon Sep 17 00:00:00 2001 From: Daniil Zulin Date: Wed, 7 May 2025 15:56:12 +0700 Subject: [PATCH 5/8] Remove equals/hashCode implementations. Will create a separate PR for these changes --- .../tech/ydb/topic/description/Consumer.java | 20 ---------- .../description/ConsumerDescription.java | 15 -------- .../description/ConsumerPartitionInfo.java | 29 --------------- .../ydb/topic/description/PartitionInfo.java | 19 ---------- .../ydb/topic/description/PartitionStats.java | 27 -------------- .../topic/description/SupportedCodecs.java | 15 -------- .../topic/description/TopicDescription.java | 37 ------------------- .../ydb/topic/description/TopicStats.java | 18 --------- ...AutoPartitioningWriteStrategySettings.java | 17 --------- .../topic/settings/PartitioningSettings.java | 19 ---------- 10 files changed, 216 deletions(-) diff --git a/topic/src/main/java/tech/ydb/topic/description/Consumer.java b/topic/src/main/java/tech/ydb/topic/description/Consumer.java index e20ca9f85..3dc85d45c 100644 --- a/topic/src/main/java/tech/ydb/topic/description/Consumer.java +++ b/topic/src/main/java/tech/ydb/topic/description/Consumer.java @@ -5,7 +5,6 @@ import java.util.HashMap; import java.util.List; import java.util.Map; -import java.util.Objects; import java.util.stream.Collectors; import javax.annotation.Nonnull; @@ -141,23 +140,4 @@ public Consumer build() { return new Consumer(this); } } - - @Override - public boolean equals(Object o) { - if (o == null || getClass() != o.getClass()) { - return false; - } - Consumer consumer = (Consumer) o; - return important == consumer.important && - Objects.equals(name, consumer.name) && - Objects.equals(readFrom, consumer.readFrom) && - Objects.equals(supportedCodecs, consumer.supportedCodecs) && - Objects.equals(attributes, consumer.attributes) && - Objects.equals(stats, consumer.stats); - } - - @Override - public int hashCode() { - return Objects.hash(name, important, readFrom, supportedCodecs, attributes, stats); - } } diff --git a/topic/src/main/java/tech/ydb/topic/description/ConsumerDescription.java b/topic/src/main/java/tech/ydb/topic/description/ConsumerDescription.java index 68084c2aa..3a85494fe 100644 --- a/topic/src/main/java/tech/ydb/topic/description/ConsumerDescription.java +++ b/topic/src/main/java/tech/ydb/topic/description/ConsumerDescription.java @@ -2,7 +2,6 @@ import java.util.List; -import java.util.Objects; import java.util.stream.Collectors; import tech.ydb.proto.topic.YdbTopic; @@ -29,18 +28,4 @@ public Consumer getConsumer() { public List getPartitions() { return partitions; } - - @Override - public boolean equals(Object o) { - if (o == null || getClass() != o.getClass()) { - return false; - } - ConsumerDescription that = (ConsumerDescription) o; - return Objects.equals(consumer, that.consumer) && Objects.equals(partitions, that.partitions); - } - - @Override - public int hashCode() { - return Objects.hash(consumer, partitions); - } } diff --git a/topic/src/main/java/tech/ydb/topic/description/ConsumerPartitionInfo.java b/topic/src/main/java/tech/ydb/topic/description/ConsumerPartitionInfo.java index babd11506..225c614da 100644 --- a/topic/src/main/java/tech/ydb/topic/description/ConsumerPartitionInfo.java +++ b/topic/src/main/java/tech/ydb/topic/description/ConsumerPartitionInfo.java @@ -3,7 +3,6 @@ import java.time.Duration; import java.time.Instant; import java.util.List; -import java.util.Objects; import tech.ydb.core.utils.ProtobufUtils; import tech.ydb.proto.topic.YdbTopic; @@ -179,32 +178,4 @@ public int getConnectionNodeId() { return connectionNodeId; } } - - @Override - public boolean equals(Object o) { - if (o == null || getClass() != o.getClass()) { - return false; - } - ConsumerPartitionInfo that = (ConsumerPartitionInfo) o; - return partitionId == that.partitionId && - active == that.active && - Objects.equals(childPartitionIds, that.childPartitionIds) && - Objects.equals(parentPartitionIds, that.parentPartitionIds) && - Objects.equals(partitionStats, that.partitionStats) && - Objects.equals(consumerStats, that.consumerStats) && - Objects.equals(location, that.location); - } - - @Override - public int hashCode() { - return Objects.hash( - partitionId, - active, - childPartitionIds, - parentPartitionIds, - partitionStats, - consumerStats, - location - ); - } } diff --git a/topic/src/main/java/tech/ydb/topic/description/PartitionInfo.java b/topic/src/main/java/tech/ydb/topic/description/PartitionInfo.java index dc439191e..1c16782f0 100644 --- a/topic/src/main/java/tech/ydb/topic/description/PartitionInfo.java +++ b/topic/src/main/java/tech/ydb/topic/description/PartitionInfo.java @@ -2,7 +2,6 @@ import java.util.ArrayList; import java.util.List; -import java.util.Objects; import com.google.common.collect.ImmutableList; @@ -87,22 +86,4 @@ public PartitionInfo build() { return new PartitionInfo(this); } } - - @Override - public boolean equals(Object o) { - if (o == null || getClass() != o.getClass()) { - return false; - } - PartitionInfo that = (PartitionInfo) o; - return partitionId == that.partitionId && - active == that.active && - Objects.equals(childPartitionIds, that.childPartitionIds) && - Objects.equals(parentPartitionIds, that.parentPartitionIds) && - Objects.equals(partitionStats, that.partitionStats); - } - - @Override - public int hashCode() { - return Objects.hash(partitionId, active, childPartitionIds, parentPartitionIds, partitionStats); - } } diff --git a/topic/src/main/java/tech/ydb/topic/description/PartitionStats.java b/topic/src/main/java/tech/ydb/topic/description/PartitionStats.java index 8c4e27b35..78bde4ec1 100644 --- a/topic/src/main/java/tech/ydb/topic/description/PartitionStats.java +++ b/topic/src/main/java/tech/ydb/topic/description/PartitionStats.java @@ -2,7 +2,6 @@ import java.time.Duration; import java.time.Instant; -import java.util.Objects; import javax.annotation.Nullable; @@ -127,30 +126,4 @@ public PartitionStats build() { return new PartitionStats(this); } } - - @Override - public boolean equals(Object o) { - if (o == null || getClass() != o.getClass()) { - return false; - } - PartitionStats that = (PartitionStats) o; - return storeSizeBytes == that.storeSizeBytes && - partitionNodeId == that.partitionNodeId && - Objects.equals(partitionOffsets, that.partitionOffsets) && - Objects.equals(lastWriteTime, that.lastWriteTime) && - Objects.equals(maxWriteTimeLag, that.maxWriteTimeLag) && - Objects.equals(bytesWritten, that.bytesWritten); - } - - @Override - public int hashCode() { - return Objects.hash( - partitionOffsets, - storeSizeBytes, - lastWriteTime, - maxWriteTimeLag, - bytesWritten, - partitionNodeId - ); - } } diff --git a/topic/src/main/java/tech/ydb/topic/description/SupportedCodecs.java b/topic/src/main/java/tech/ydb/topic/description/SupportedCodecs.java index 2fa1d088c..09a4b126b 100644 --- a/topic/src/main/java/tech/ydb/topic/description/SupportedCodecs.java +++ b/topic/src/main/java/tech/ydb/topic/description/SupportedCodecs.java @@ -2,7 +2,6 @@ import java.util.ArrayList; import java.util.List; -import java.util.Objects; import com.google.common.collect.ImmutableList; @@ -48,18 +47,4 @@ public SupportedCodecs build() { return new SupportedCodecs(this); } } - - @Override - public boolean equals(Object o) { - if (o == null || getClass() != o.getClass()) { - return false; - } - SupportedCodecs that = (SupportedCodecs) o; - return Objects.equals(codecs, that.codecs); - } - - @Override - public int hashCode() { - return Objects.hashCode(codecs); - } } diff --git a/topic/src/main/java/tech/ydb/topic/description/TopicDescription.java b/topic/src/main/java/tech/ydb/topic/description/TopicDescription.java index 024ccd709..3b228624d 100644 --- a/topic/src/main/java/tech/ydb/topic/description/TopicDescription.java +++ b/topic/src/main/java/tech/ydb/topic/description/TopicDescription.java @@ -4,7 +4,6 @@ import java.util.ArrayList; import java.util.List; import java.util.Map; -import java.util.Objects; import javax.annotation.Nonnull; import javax.annotation.Nullable; @@ -180,40 +179,4 @@ public TopicDescription build() { return new TopicDescription(this); } } - - @Override - public boolean equals(Object o) { - if (o == null || getClass() != o.getClass()) { - return false; - } - TopicDescription that = (TopicDescription) o; - return retentionStorageMb == that.retentionStorageMb && - partitionWriteSpeedBytesPerSecond == that.partitionWriteSpeedBytesPerSecond && - partitionWriteBurstBytes == that.partitionWriteBurstBytes && - Objects.equals(partitioningSettings, that.partitioningSettings) && - Objects.equals(partitions, that.partitions) && - Objects.equals(retentionPeriod, that.retentionPeriod) && - Objects.equals(supportedCodecs, that.supportedCodecs) && - Objects.equals(attributes, that.attributes) && - Objects.equals(consumers, that.consumers) && - meteringMode == that.meteringMode && - Objects.equals(topicStats, that.topicStats); - } - - @Override - public int hashCode() { - return Objects.hash( - partitioningSettings, - partitions, - retentionPeriod, - retentionStorageMb, - supportedCodecs, - partitionWriteSpeedBytesPerSecond, - partitionWriteBurstBytes, - attributes, - consumers, - meteringMode, - topicStats - ); - } } diff --git a/topic/src/main/java/tech/ydb/topic/description/TopicStats.java b/topic/src/main/java/tech/ydb/topic/description/TopicStats.java index 5f7d77a2d..f350660a1 100644 --- a/topic/src/main/java/tech/ydb/topic/description/TopicStats.java +++ b/topic/src/main/java/tech/ydb/topic/description/TopicStats.java @@ -2,7 +2,6 @@ import java.time.Duration; import java.time.Instant; -import java.util.Objects; import javax.annotation.Nullable; @@ -77,21 +76,4 @@ public TopicStats build() { return new TopicStats(this); } } - - @Override - public boolean equals(Object o) { - if (o == null || getClass() != o.getClass()) { - return false; - } - TopicStats that = (TopicStats) o; - return storeSizeBytes == that.storeSizeBytes && - Objects.equals(minLastWriteTime, that.minLastWriteTime) && - Objects.equals(maxWriteTimeLag, that.maxWriteTimeLag) && - Objects.equals(bytesWritten, that.bytesWritten); - } - - @Override - public int hashCode() { - return Objects.hash(storeSizeBytes, minLastWriteTime, maxWriteTimeLag, bytesWritten); - } } diff --git a/topic/src/main/java/tech/ydb/topic/settings/AutoPartitioningWriteStrategySettings.java b/topic/src/main/java/tech/ydb/topic/settings/AutoPartitioningWriteStrategySettings.java index c54ab0572..88db26fb1 100644 --- a/topic/src/main/java/tech/ydb/topic/settings/AutoPartitioningWriteStrategySettings.java +++ b/topic/src/main/java/tech/ydb/topic/settings/AutoPartitioningWriteStrategySettings.java @@ -1,7 +1,6 @@ package tech.ydb.topic.settings; import java.time.Duration; -import java.util.Objects; public class AutoPartitioningWriteStrategySettings { private final Duration stabilizationWindow; @@ -70,20 +69,4 @@ public AutoPartitioningWriteStrategySettings build() { return new AutoPartitioningWriteStrategySettings(this); } } - - @Override - public boolean equals(Object o) { - if (o == null || getClass() != o.getClass()) { - return false; - } - AutoPartitioningWriteStrategySettings that = (AutoPartitioningWriteStrategySettings) o; - return upUtilizationPercent == that.upUtilizationPercent && - downUtilizationPercent == that.downUtilizationPercent && - Objects.equals(stabilizationWindow, that.stabilizationWindow); - } - - @Override - public int hashCode() { - return Objects.hash(stabilizationWindow, upUtilizationPercent, downUtilizationPercent); - } } diff --git a/topic/src/main/java/tech/ydb/topic/settings/PartitioningSettings.java b/topic/src/main/java/tech/ydb/topic/settings/PartitioningSettings.java index d19f361eb..e963babc2 100644 --- a/topic/src/main/java/tech/ydb/topic/settings/PartitioningSettings.java +++ b/topic/src/main/java/tech/ydb/topic/settings/PartitioningSettings.java @@ -1,7 +1,5 @@ package tech.ydb.topic.settings; -import java.util.Objects; - /** * @author Nikolay Perfilov */ @@ -109,21 +107,4 @@ public PartitioningSettings build() { return new PartitioningSettings(this); } } - - @Override - public boolean equals(Object o) { - if (o == null || getClass() != o.getClass()) { - return false; - } - PartitioningSettings that = (PartitioningSettings) o; - return minActivePartitions == that.minActivePartitions && - partitionCountLimit == that.partitionCountLimit && - autoPartitioningStrategy == that.autoPartitioningStrategy && - Objects.equals(writeStrategySettings, that.writeStrategySettings); - } - - @Override - public int hashCode() { - return Objects.hash(minActivePartitions, partitionCountLimit, autoPartitioningStrategy, writeStrategySettings); - } } From e464913896e85c5587ce416d0461c004dc50f270 Mon Sep 17 00:00:00 2001 From: Daniil Zulin Date: Wed, 7 May 2025 16:04:20 +0700 Subject: [PATCH 6/8] Move proto mappings into the TopicClientImpl --- .../tech/ydb/topic/impl/TopicClientImpl.java | 36 +++++++++++++++++-- .../settings/AutoPartitioningStrategy.java | 31 +++------------- 2 files changed, 37 insertions(+), 30 deletions(-) diff --git a/topic/src/main/java/tech/ydb/topic/impl/TopicClientImpl.java b/topic/src/main/java/tech/ydb/topic/impl/TopicClientImpl.java index 0b8a0b922..35893a815 100644 --- a/topic/src/main/java/tech/ydb/topic/impl/TopicClientImpl.java +++ b/topic/src/main/java/tech/ydb/topic/impl/TopicClientImpl.java @@ -109,7 +109,7 @@ public CompletableFuture createTopic(String path, CreateTopicSettings se .setMinActivePartitions(partitioningSettings.getMinActivePartitions()) .setPartitionCountLimit(partitioningSettings.getPartitionCountLimit()) .setAutoPartitioningSettings(YdbTopic.AutoPartitioningSettings.newBuilder() - .setStrategy(partitioningSettings.getAutoPartitioningStrategy().getProtoReference()))); + .setStrategy(toProto(partitioningSettings.getAutoPartitioningStrategy())))); AutoPartitioningWriteStrategySettings writeStrategySettings = partitioningSettings .getWriteStrategySettings(); @@ -166,7 +166,7 @@ public CompletableFuture alterTopic(String path, AlterTopicSettings sett } AutoPartitioningStrategy autoPartitioningStrategy = partitioningSettings.getAutoPartitioningStrategy(); if (autoPartitioningStrategy != null) { - YdbTopic.AutoPartitioningStrategy protoReference = autoPartitioningStrategy.getProtoReference(); + YdbTopic.AutoPartitioningStrategy protoReference = toProto(autoPartitioningStrategy); builder.getAlterAutoPartitioningSettingsBuilder().setSetStrategy(protoReference); } AlterAutoPartitioningWriteStrategySettings writeStrategySettings = partitioningSettings @@ -322,7 +322,7 @@ private TopicDescription mapDescribeTopic(YdbTopic.DescribeTopicResult result) { PartitioningSettings.Builder partitioningDescription = PartitioningSettings.newBuilder() .setMinActivePartitions(partitioningSettings.getMinActivePartitions()) .setPartitionCountLimit(partitioningSettings.getPartitionCountLimit()) - .setAutoPartitioningStrategy(AutoPartitioningStrategy.fromProto(autoPartitioningStrategy)); + .setAutoPartitioningStrategy(fromProto(autoPartitioningStrategy)); YdbTopic.AutoPartitioningWriteSpeedStrategy partitionWriteSpeed = autoPartitioningSettings .getPartitionWriteSpeed(); @@ -449,6 +449,36 @@ private static YdbTopic.SupportedCodecs toProto(SupportedCodecs supportedCodecs) return codecsBuilder.build(); } + private static AutoPartitioningStrategy fromProto(YdbTopic.AutoPartitioningStrategy autoPartitioningStrategy) { + switch (autoPartitioningStrategy) { + case AUTO_PARTITIONING_STRATEGY_PAUSED: + return AutoPartitioningStrategy.PAUSED; + case AUTO_PARTITIONING_STRATEGY_SCALE_UP: + return AutoPartitioningStrategy.SCALE_UP; + case AUTO_PARTITIONING_STRATEGY_SCALE_UP_AND_DOWN: + return AutoPartitioningStrategy.SCALE_UP_AND_DOWN; + case AUTO_PARTITIONING_STRATEGY_DISABLED: + return AutoPartitioningStrategy.DISABLED; + default: + return null; + } + } + + private static YdbTopic.AutoPartitioningStrategy toProto(AutoPartitioningStrategy autoPartitioningStrategy) { + switch (autoPartitioningStrategy) { + case PAUSED: + return YdbTopic.AutoPartitioningStrategy.AUTO_PARTITIONING_STRATEGY_PAUSED; + case SCALE_UP: + return YdbTopic.AutoPartitioningStrategy.AUTO_PARTITIONING_STRATEGY_SCALE_UP; + case SCALE_UP_AND_DOWN: + return YdbTopic.AutoPartitioningStrategy.AUTO_PARTITIONING_STRATEGY_SCALE_UP_AND_DOWN; + case DISABLED: + return YdbTopic.AutoPartitioningStrategy.AUTO_PARTITIONING_STRATEGY_DISABLED; + default: + throw new IllegalArgumentException("Unknown auto partitioning strategy: " + autoPartitioningStrategy); + } + } + @Override public void close() { logger.debug("TopicClientImpl.close() is called"); diff --git a/topic/src/main/java/tech/ydb/topic/settings/AutoPartitioningStrategy.java b/topic/src/main/java/tech/ydb/topic/settings/AutoPartitioningStrategy.java index 00015b6f7..9af11f3db 100644 --- a/topic/src/main/java/tech/ydb/topic/settings/AutoPartitioningStrategy.java +++ b/topic/src/main/java/tech/ydb/topic/settings/AutoPartitioningStrategy.java @@ -1,48 +1,25 @@ package tech.ydb.topic.settings; -import javax.annotation.Nullable; - -import tech.ydb.proto.topic.YdbTopic; - public enum AutoPartitioningStrategy { /** * The auto partitioning is disabled. * You cannot disable the auto partitioning after it has been enabled. * @see AutoPartitioningStrategy#PAUSED */ - DISABLED(YdbTopic.AutoPartitioningStrategy.AUTO_PARTITIONING_STRATEGY_DISABLED), + DISABLED, /** * The auto partitioning algorithm will increase the partition count depending on the load characteristics. * The auto partitioning algorithm will never decrease the number of partitions. * @see AlterAutoPartitioningWriteStrategySettings */ - SCALE_UP(YdbTopic.AutoPartitioningStrategy.AUTO_PARTITIONING_STRATEGY_SCALE_UP), + SCALE_UP, /** * The auto partitioning algorithm will both increase and decrease partitions count depending on the load characteristics. * @see AlterAutoPartitioningWriteStrategySettings */ - SCALE_UP_AND_DOWN(YdbTopic.AutoPartitioningStrategy.AUTO_PARTITIONING_STRATEGY_SCALE_UP_AND_DOWN), + SCALE_UP_AND_DOWN, /** * The auto partitioning is paused. */ - PAUSED(YdbTopic.AutoPartitioningStrategy.AUTO_PARTITIONING_STRATEGY_PAUSED); - - private final YdbTopic.AutoPartitioningStrategy protoReference; - - AutoPartitioningStrategy(YdbTopic.AutoPartitioningStrategy protoReference) { - this.protoReference = protoReference; - } - - public YdbTopic.AutoPartitioningStrategy getProtoReference() { - return protoReference; - } - - public static @Nullable AutoPartitioningStrategy fromProto(YdbTopic.AutoPartitioningStrategy protoReference) { - for (AutoPartitioningStrategy value : values()) { - if (value.getProtoReference() == protoReference) { - return value; - } - } - return null; - } + PAUSED; } From 77f469b23aa7bb6cb61dd0572eb4abb403fbb842 Mon Sep 17 00:00:00 2001 From: Daniil Zulin Date: Wed, 7 May 2025 16:09:14 +0700 Subject: [PATCH 7/8] Remove leftover equals implementations --- .../topic/description/MultipleWindowsStat.java | 16 ---------------- .../ydb/topic/read/impl/OffsetsRangeImpl.java | 16 ---------------- 2 files changed, 32 deletions(-) diff --git a/topic/src/main/java/tech/ydb/topic/description/MultipleWindowsStat.java b/topic/src/main/java/tech/ydb/topic/description/MultipleWindowsStat.java index dcbf1ac66..74a0c4f2a 100644 --- a/topic/src/main/java/tech/ydb/topic/description/MultipleWindowsStat.java +++ b/topic/src/main/java/tech/ydb/topic/description/MultipleWindowsStat.java @@ -1,7 +1,5 @@ package tech.ydb.topic.description; -import java.util.Objects; - import tech.ydb.proto.topic.YdbTopic; /** @@ -35,18 +33,4 @@ public long getPerHour() { public long getPerDay() { return perDay; } - - @Override - public boolean equals(Object o) { - if (o == null || getClass() != o.getClass()) { - return false; - } - MultipleWindowsStat that = (MultipleWindowsStat) o; - return perMinute == that.perMinute && perHour == that.perHour && perDay == that.perDay; - } - - @Override - public int hashCode() { - return Objects.hash(perMinute, perHour, perDay); - } } diff --git a/topic/src/main/java/tech/ydb/topic/read/impl/OffsetsRangeImpl.java b/topic/src/main/java/tech/ydb/topic/read/impl/OffsetsRangeImpl.java index e85cad1a1..6cf1165ca 100644 --- a/topic/src/main/java/tech/ydb/topic/read/impl/OffsetsRangeImpl.java +++ b/topic/src/main/java/tech/ydb/topic/read/impl/OffsetsRangeImpl.java @@ -1,7 +1,5 @@ package tech.ydb.topic.read.impl; -import java.util.Objects; - import tech.ydb.topic.description.OffsetsRange; /** @@ -38,18 +36,4 @@ public void setStart(long start) { public void setEnd(long end) { this.end = end; } - - @Override - public boolean equals(Object o) { - if (o == null || getClass() != o.getClass()) { - return false; - } - OffsetsRangeImpl that = (OffsetsRangeImpl) o; - return start == that.start && end == that.end; - } - - @Override - public int hashCode() { - return Objects.hash(start, end); - } } From 6f3d0f556e4be56d20775e7b54b1e7874a6b5f57 Mon Sep 17 00:00:00 2001 From: Daniil Zulin Date: Wed, 7 May 2025 16:11:41 +0700 Subject: [PATCH 8/8] Introduce equals/hashCode methods to classes used for the topic description --- .../tech/ydb/topic/description/Consumer.java | 20 ++++++++++ .../description/ConsumerDescription.java | 15 ++++++++ .../description/ConsumerPartitionInfo.java | 29 +++++++++++++++ .../description/MultipleWindowsStat.java | 16 ++++++++ .../ydb/topic/description/PartitionInfo.java | 19 ++++++++++ .../ydb/topic/description/PartitionStats.java | 27 ++++++++++++++ .../topic/description/SupportedCodecs.java | 15 ++++++++ .../topic/description/TopicDescription.java | 37 +++++++++++++++++++ .../ydb/topic/description/TopicStats.java | 18 +++++++++ .../ydb/topic/read/impl/OffsetsRangeImpl.java | 16 ++++++++ ...AutoPartitioningWriteStrategySettings.java | 17 +++++++++ .../topic/settings/PartitioningSettings.java | 19 ++++++++++ 12 files changed, 248 insertions(+) diff --git a/topic/src/main/java/tech/ydb/topic/description/Consumer.java b/topic/src/main/java/tech/ydb/topic/description/Consumer.java index 3dc85d45c..e20ca9f85 100644 --- a/topic/src/main/java/tech/ydb/topic/description/Consumer.java +++ b/topic/src/main/java/tech/ydb/topic/description/Consumer.java @@ -5,6 +5,7 @@ import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.Objects; import java.util.stream.Collectors; import javax.annotation.Nonnull; @@ -140,4 +141,23 @@ public Consumer build() { return new Consumer(this); } } + + @Override + public boolean equals(Object o) { + if (o == null || getClass() != o.getClass()) { + return false; + } + Consumer consumer = (Consumer) o; + return important == consumer.important && + Objects.equals(name, consumer.name) && + Objects.equals(readFrom, consumer.readFrom) && + Objects.equals(supportedCodecs, consumer.supportedCodecs) && + Objects.equals(attributes, consumer.attributes) && + Objects.equals(stats, consumer.stats); + } + + @Override + public int hashCode() { + return Objects.hash(name, important, readFrom, supportedCodecs, attributes, stats); + } } diff --git a/topic/src/main/java/tech/ydb/topic/description/ConsumerDescription.java b/topic/src/main/java/tech/ydb/topic/description/ConsumerDescription.java index 3a85494fe..68084c2aa 100644 --- a/topic/src/main/java/tech/ydb/topic/description/ConsumerDescription.java +++ b/topic/src/main/java/tech/ydb/topic/description/ConsumerDescription.java @@ -2,6 +2,7 @@ import java.util.List; +import java.util.Objects; import java.util.stream.Collectors; import tech.ydb.proto.topic.YdbTopic; @@ -28,4 +29,18 @@ public Consumer getConsumer() { public List getPartitions() { return partitions; } + + @Override + public boolean equals(Object o) { + if (o == null || getClass() != o.getClass()) { + return false; + } + ConsumerDescription that = (ConsumerDescription) o; + return Objects.equals(consumer, that.consumer) && Objects.equals(partitions, that.partitions); + } + + @Override + public int hashCode() { + return Objects.hash(consumer, partitions); + } } diff --git a/topic/src/main/java/tech/ydb/topic/description/ConsumerPartitionInfo.java b/topic/src/main/java/tech/ydb/topic/description/ConsumerPartitionInfo.java index 225c614da..babd11506 100644 --- a/topic/src/main/java/tech/ydb/topic/description/ConsumerPartitionInfo.java +++ b/topic/src/main/java/tech/ydb/topic/description/ConsumerPartitionInfo.java @@ -3,6 +3,7 @@ import java.time.Duration; import java.time.Instant; import java.util.List; +import java.util.Objects; import tech.ydb.core.utils.ProtobufUtils; import tech.ydb.proto.topic.YdbTopic; @@ -178,4 +179,32 @@ public int getConnectionNodeId() { return connectionNodeId; } } + + @Override + public boolean equals(Object o) { + if (o == null || getClass() != o.getClass()) { + return false; + } + ConsumerPartitionInfo that = (ConsumerPartitionInfo) o; + return partitionId == that.partitionId && + active == that.active && + Objects.equals(childPartitionIds, that.childPartitionIds) && + Objects.equals(parentPartitionIds, that.parentPartitionIds) && + Objects.equals(partitionStats, that.partitionStats) && + Objects.equals(consumerStats, that.consumerStats) && + Objects.equals(location, that.location); + } + + @Override + public int hashCode() { + return Objects.hash( + partitionId, + active, + childPartitionIds, + parentPartitionIds, + partitionStats, + consumerStats, + location + ); + } } diff --git a/topic/src/main/java/tech/ydb/topic/description/MultipleWindowsStat.java b/topic/src/main/java/tech/ydb/topic/description/MultipleWindowsStat.java index 74a0c4f2a..dcbf1ac66 100644 --- a/topic/src/main/java/tech/ydb/topic/description/MultipleWindowsStat.java +++ b/topic/src/main/java/tech/ydb/topic/description/MultipleWindowsStat.java @@ -1,5 +1,7 @@ package tech.ydb.topic.description; +import java.util.Objects; + import tech.ydb.proto.topic.YdbTopic; /** @@ -33,4 +35,18 @@ public long getPerHour() { public long getPerDay() { return perDay; } + + @Override + public boolean equals(Object o) { + if (o == null || getClass() != o.getClass()) { + return false; + } + MultipleWindowsStat that = (MultipleWindowsStat) o; + return perMinute == that.perMinute && perHour == that.perHour && perDay == that.perDay; + } + + @Override + public int hashCode() { + return Objects.hash(perMinute, perHour, perDay); + } } diff --git a/topic/src/main/java/tech/ydb/topic/description/PartitionInfo.java b/topic/src/main/java/tech/ydb/topic/description/PartitionInfo.java index 1c16782f0..dc439191e 100644 --- a/topic/src/main/java/tech/ydb/topic/description/PartitionInfo.java +++ b/topic/src/main/java/tech/ydb/topic/description/PartitionInfo.java @@ -2,6 +2,7 @@ import java.util.ArrayList; import java.util.List; +import java.util.Objects; import com.google.common.collect.ImmutableList; @@ -86,4 +87,22 @@ public PartitionInfo build() { return new PartitionInfo(this); } } + + @Override + public boolean equals(Object o) { + if (o == null || getClass() != o.getClass()) { + return false; + } + PartitionInfo that = (PartitionInfo) o; + return partitionId == that.partitionId && + active == that.active && + Objects.equals(childPartitionIds, that.childPartitionIds) && + Objects.equals(parentPartitionIds, that.parentPartitionIds) && + Objects.equals(partitionStats, that.partitionStats); + } + + @Override + public int hashCode() { + return Objects.hash(partitionId, active, childPartitionIds, parentPartitionIds, partitionStats); + } } diff --git a/topic/src/main/java/tech/ydb/topic/description/PartitionStats.java b/topic/src/main/java/tech/ydb/topic/description/PartitionStats.java index 78bde4ec1..8c4e27b35 100644 --- a/topic/src/main/java/tech/ydb/topic/description/PartitionStats.java +++ b/topic/src/main/java/tech/ydb/topic/description/PartitionStats.java @@ -2,6 +2,7 @@ import java.time.Duration; import java.time.Instant; +import java.util.Objects; import javax.annotation.Nullable; @@ -126,4 +127,30 @@ public PartitionStats build() { return new PartitionStats(this); } } + + @Override + public boolean equals(Object o) { + if (o == null || getClass() != o.getClass()) { + return false; + } + PartitionStats that = (PartitionStats) o; + return storeSizeBytes == that.storeSizeBytes && + partitionNodeId == that.partitionNodeId && + Objects.equals(partitionOffsets, that.partitionOffsets) && + Objects.equals(lastWriteTime, that.lastWriteTime) && + Objects.equals(maxWriteTimeLag, that.maxWriteTimeLag) && + Objects.equals(bytesWritten, that.bytesWritten); + } + + @Override + public int hashCode() { + return Objects.hash( + partitionOffsets, + storeSizeBytes, + lastWriteTime, + maxWriteTimeLag, + bytesWritten, + partitionNodeId + ); + } } diff --git a/topic/src/main/java/tech/ydb/topic/description/SupportedCodecs.java b/topic/src/main/java/tech/ydb/topic/description/SupportedCodecs.java index 09a4b126b..2fa1d088c 100644 --- a/topic/src/main/java/tech/ydb/topic/description/SupportedCodecs.java +++ b/topic/src/main/java/tech/ydb/topic/description/SupportedCodecs.java @@ -2,6 +2,7 @@ import java.util.ArrayList; import java.util.List; +import java.util.Objects; import com.google.common.collect.ImmutableList; @@ -47,4 +48,18 @@ public SupportedCodecs build() { return new SupportedCodecs(this); } } + + @Override + public boolean equals(Object o) { + if (o == null || getClass() != o.getClass()) { + return false; + } + SupportedCodecs that = (SupportedCodecs) o; + return Objects.equals(codecs, that.codecs); + } + + @Override + public int hashCode() { + return Objects.hashCode(codecs); + } } diff --git a/topic/src/main/java/tech/ydb/topic/description/TopicDescription.java b/topic/src/main/java/tech/ydb/topic/description/TopicDescription.java index 3b228624d..024ccd709 100644 --- a/topic/src/main/java/tech/ydb/topic/description/TopicDescription.java +++ b/topic/src/main/java/tech/ydb/topic/description/TopicDescription.java @@ -4,6 +4,7 @@ import java.util.ArrayList; import java.util.List; import java.util.Map; +import java.util.Objects; import javax.annotation.Nonnull; import javax.annotation.Nullable; @@ -179,4 +180,40 @@ public TopicDescription build() { return new TopicDescription(this); } } + + @Override + public boolean equals(Object o) { + if (o == null || getClass() != o.getClass()) { + return false; + } + TopicDescription that = (TopicDescription) o; + return retentionStorageMb == that.retentionStorageMb && + partitionWriteSpeedBytesPerSecond == that.partitionWriteSpeedBytesPerSecond && + partitionWriteBurstBytes == that.partitionWriteBurstBytes && + Objects.equals(partitioningSettings, that.partitioningSettings) && + Objects.equals(partitions, that.partitions) && + Objects.equals(retentionPeriod, that.retentionPeriod) && + Objects.equals(supportedCodecs, that.supportedCodecs) && + Objects.equals(attributes, that.attributes) && + Objects.equals(consumers, that.consumers) && + meteringMode == that.meteringMode && + Objects.equals(topicStats, that.topicStats); + } + + @Override + public int hashCode() { + return Objects.hash( + partitioningSettings, + partitions, + retentionPeriod, + retentionStorageMb, + supportedCodecs, + partitionWriteSpeedBytesPerSecond, + partitionWriteBurstBytes, + attributes, + consumers, + meteringMode, + topicStats + ); + } } diff --git a/topic/src/main/java/tech/ydb/topic/description/TopicStats.java b/topic/src/main/java/tech/ydb/topic/description/TopicStats.java index f350660a1..5f7d77a2d 100644 --- a/topic/src/main/java/tech/ydb/topic/description/TopicStats.java +++ b/topic/src/main/java/tech/ydb/topic/description/TopicStats.java @@ -2,6 +2,7 @@ import java.time.Duration; import java.time.Instant; +import java.util.Objects; import javax.annotation.Nullable; @@ -76,4 +77,21 @@ public TopicStats build() { return new TopicStats(this); } } + + @Override + public boolean equals(Object o) { + if (o == null || getClass() != o.getClass()) { + return false; + } + TopicStats that = (TopicStats) o; + return storeSizeBytes == that.storeSizeBytes && + Objects.equals(minLastWriteTime, that.minLastWriteTime) && + Objects.equals(maxWriteTimeLag, that.maxWriteTimeLag) && + Objects.equals(bytesWritten, that.bytesWritten); + } + + @Override + public int hashCode() { + return Objects.hash(storeSizeBytes, minLastWriteTime, maxWriteTimeLag, bytesWritten); + } } diff --git a/topic/src/main/java/tech/ydb/topic/read/impl/OffsetsRangeImpl.java b/topic/src/main/java/tech/ydb/topic/read/impl/OffsetsRangeImpl.java index 6cf1165ca..e85cad1a1 100644 --- a/topic/src/main/java/tech/ydb/topic/read/impl/OffsetsRangeImpl.java +++ b/topic/src/main/java/tech/ydb/topic/read/impl/OffsetsRangeImpl.java @@ -1,5 +1,7 @@ package tech.ydb.topic.read.impl; +import java.util.Objects; + import tech.ydb.topic.description.OffsetsRange; /** @@ -36,4 +38,18 @@ public void setStart(long start) { public void setEnd(long end) { this.end = end; } + + @Override + public boolean equals(Object o) { + if (o == null || getClass() != o.getClass()) { + return false; + } + OffsetsRangeImpl that = (OffsetsRangeImpl) o; + return start == that.start && end == that.end; + } + + @Override + public int hashCode() { + return Objects.hash(start, end); + } } diff --git a/topic/src/main/java/tech/ydb/topic/settings/AutoPartitioningWriteStrategySettings.java b/topic/src/main/java/tech/ydb/topic/settings/AutoPartitioningWriteStrategySettings.java index 88db26fb1..c54ab0572 100644 --- a/topic/src/main/java/tech/ydb/topic/settings/AutoPartitioningWriteStrategySettings.java +++ b/topic/src/main/java/tech/ydb/topic/settings/AutoPartitioningWriteStrategySettings.java @@ -1,6 +1,7 @@ package tech.ydb.topic.settings; import java.time.Duration; +import java.util.Objects; public class AutoPartitioningWriteStrategySettings { private final Duration stabilizationWindow; @@ -69,4 +70,20 @@ public AutoPartitioningWriteStrategySettings build() { return new AutoPartitioningWriteStrategySettings(this); } } + + @Override + public boolean equals(Object o) { + if (o == null || getClass() != o.getClass()) { + return false; + } + AutoPartitioningWriteStrategySettings that = (AutoPartitioningWriteStrategySettings) o; + return upUtilizationPercent == that.upUtilizationPercent && + downUtilizationPercent == that.downUtilizationPercent && + Objects.equals(stabilizationWindow, that.stabilizationWindow); + } + + @Override + public int hashCode() { + return Objects.hash(stabilizationWindow, upUtilizationPercent, downUtilizationPercent); + } } diff --git a/topic/src/main/java/tech/ydb/topic/settings/PartitioningSettings.java b/topic/src/main/java/tech/ydb/topic/settings/PartitioningSettings.java index e963babc2..d19f361eb 100644 --- a/topic/src/main/java/tech/ydb/topic/settings/PartitioningSettings.java +++ b/topic/src/main/java/tech/ydb/topic/settings/PartitioningSettings.java @@ -1,5 +1,7 @@ package tech.ydb.topic.settings; +import java.util.Objects; + /** * @author Nikolay Perfilov */ @@ -107,4 +109,21 @@ public PartitioningSettings build() { return new PartitioningSettings(this); } } + + @Override + public boolean equals(Object o) { + if (o == null || getClass() != o.getClass()) { + return false; + } + PartitioningSettings that = (PartitioningSettings) o; + return minActivePartitions == that.minActivePartitions && + partitionCountLimit == that.partitionCountLimit && + autoPartitioningStrategy == that.autoPartitioningStrategy && + Objects.equals(writeStrategySettings, that.writeStrategySettings); + } + + @Override + public int hashCode() { + return Objects.hash(minActivePartitions, partitionCountLimit, autoPartitioningStrategy, writeStrategySettings); + } }