You are viewing a plain text version of this content. The canonical link for it is here.
Posted to jira@kafka.apache.org by GitBox <gi...@apache.org> on 2021/06/30 18:10:23 UTC
[GitHub] [kafka] junrao commented on a change in pull request #10579: KAFKA-9555 Added default RLMM implementation based on internal topic storage.
junrao commented on a change in pull request #10579:
URL: https://github.com/apache/kafka/pull/10579#discussion_r660810740
##########
File path: storage/src/main/java/org/apache/kafka/server/log/remote/metadata/storage/ConsumerManager.java
##########
@@ -0,0 +1,130 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.kafka.server.log.remote.metadata.storage;
+
+import org.apache.kafka.clients.consumer.KafkaConsumer;
+import org.apache.kafka.clients.producer.RecordMetadata;
+import org.apache.kafka.common.KafkaException;
+import org.apache.kafka.common.TopicIdPartition;
+import org.apache.kafka.common.utils.KafkaThread;
+import org.apache.kafka.common.utils.Time;
+import org.apache.kafka.common.utils.Utils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.Optional;
+import java.util.Set;
+
+/**
+ * This class manages the consumer thread viz {@link ConsumerTask} that polls messages from the assigned metadata topic partitions.
+ * It also provides a way to wait until the given record is received by the consumer before it is timed out with an interval of
+ * {@link TopicBasedRemoteLogMetadataManagerConfig#consumeWaitMs()}.
+ */
+public class ConsumerManager implements Closeable {
+
+ private static final Logger log = LoggerFactory.getLogger(ConsumerManager.class);
+ private static final long CONSUME_RECHECK_INTERVAL_MS = 50L;
+
+ private final TopicBasedRemoteLogMetadataManagerConfig rlmmConfig;
+ private final Time time;
+ private final ConsumerTask consumerTask;
+ private final Thread consumerTaskThread;
+
+ public ConsumerManager(TopicBasedRemoteLogMetadataManagerConfig rlmmConfig,
+ RemotePartitionMetadataEventHandler remotePartitionMetadataEventHandler,
+ RemoteLogMetadataTopicPartitioner rlmmTopicPartitioner,
+ Time time) {
+ this.rlmmConfig = rlmmConfig;
+ this.time = time;
+
+ //Create a task to consume messages and submit the respective events to RemotePartitionMetadataEventHandler.
+ KafkaConsumer<byte[], byte[]> consumer = new KafkaConsumer<>(rlmmConfig.consumerProperties());
+ consumerTask = new ConsumerTask(consumer, remotePartitionMetadataEventHandler, rlmmTopicPartitioner);
+ consumerTaskThread = KafkaThread.daemon("RLMMConsumerTask", consumerTask);
+ }
+
+ public void startConsumerThread() {
+ try {
+ // Start a thread to continuously consume records from topic partitions.
+ consumerTaskThread.start();
+ } catch (Exception e) {
+ throw new KafkaException("Error encountered while initializing and scheduling ConsumerTask thread", e);
+ }
+ }
+
+ /**
+ * Wait until the consumption reaches the offset of the metadata partition for the given {@code recordMetadata}.
+ *
+ * @param recordMetadata record metadata to be checked for consumption.
+ */
+ public void waitTillConsumptionCatchesUp(RecordMetadata recordMetadata) {
+ final int partition = recordMetadata.partition();
+
+ // If the current assignment does not have the subscription for this partition then return immediately.
+ if (!consumerTask.isPartitionAssigned(partition)) {
+ log.warn("This consumer is not subscribed to the target partition [{}] on which message is produced.",
+ partition);
+ return;
Review comment:
Hmm, should we throw an exception in this case so that the caller knows the operation has failed?
##########
File path: storage/src/main/java/org/apache/kafka/server/log/remote/metadata/storage/TopicBasedRemoteLogMetadataManager.java
##########
@@ -0,0 +1,360 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.kafka.server.log.remote.metadata.storage;
+
+import org.apache.kafka.clients.producer.RecordMetadata;
+import org.apache.kafka.common.KafkaException;
+import org.apache.kafka.common.TopicIdPartition;
+import org.apache.kafka.common.errors.RetriableException;
+import org.apache.kafka.common.utils.KafkaThread;
+import org.apache.kafka.common.utils.Time;
+import org.apache.kafka.common.utils.Utils;
+import org.apache.kafka.server.log.remote.storage.RemoteLogMetadata;
+import org.apache.kafka.server.log.remote.storage.RemoteLogMetadataManager;
+import org.apache.kafka.server.log.remote.storage.RemoteLogSegmentMetadata;
+import org.apache.kafka.server.log.remote.storage.RemoteLogSegmentMetadataUpdate;
+import org.apache.kafka.server.log.remote.storage.RemoteLogSegmentState;
+import org.apache.kafka.server.log.remote.storage.RemotePartitionDeleteMetadata;
+import org.apache.kafka.server.log.remote.storage.RemoteStorageException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+/**
+ * This is the {@link RemoteLogMetadataManager} implementation with storage as an internal topic with name {@link TopicBasedRemoteLogMetadataManagerConfig#REMOTE_LOG_METADATA_TOPIC_NAME}.
+ * This is used to publish and fetch {@link RemoteLogMetadata} for the registered user topic partitions with
+ * {@link #onPartitionLeadershipChanges(Set, Set)}. Each broker will have an instance of this class and it subscribes
+ * to metadata updates for the registered user topic partitions.
+ */
+public class TopicBasedRemoteLogMetadataManager implements RemoteLogMetadataManager {
+ private static final Logger log = LoggerFactory.getLogger(TopicBasedRemoteLogMetadataManager.class);
+
+ private volatile boolean configured = false;
+
+ // It indicates whether the close process of this instance is started or not via #close() method.
+ // Using AtomicBoolean instead of volatile as it may encounter http://findbugs.sourceforge.net/bugDescriptions.html#SP_SPIN_ON_FIELD
+ // if the field is read but not updated in a spin loop like in #initializeResources() method.
+ private final AtomicBoolean closing = new AtomicBoolean(false);
Review comment:
Since we have a lock, could we just make closing a boolean?
##########
File path: storage/src/main/java/org/apache/kafka/server/log/remote/metadata/storage/TopicBasedRemoteLogMetadataManagerConfig.java
##########
@@ -0,0 +1,197 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.kafka.server.log.remote.metadata.storage;
+
+import org.apache.kafka.clients.CommonClientConfigs;
+import org.apache.kafka.clients.consumer.ConsumerConfig;
+import org.apache.kafka.clients.producer.ProducerConfig;
+import org.apache.kafka.common.config.ConfigDef;
+import org.apache.kafka.common.serialization.ByteArrayDeserializer;
+import org.apache.kafka.common.serialization.ByteArraySerializer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+import static org.apache.kafka.clients.CommonClientConfigs.BOOTSTRAP_SERVERS_CONFIG;
+import static org.apache.kafka.common.config.ConfigDef.Importance.LOW;
+import static org.apache.kafka.common.config.ConfigDef.Range.atLeast;
+import static org.apache.kafka.common.config.ConfigDef.Type.INT;
+import static org.apache.kafka.common.config.ConfigDef.Type.LONG;
+
+public final class TopicBasedRemoteLogMetadataManagerConfig {
+ private static final Logger log = LoggerFactory.getLogger(TopicBasedRemoteLogMetadataManagerConfig.class.getName());
+
+ public static final String REMOTE_LOG_METADATA_TOPIC_NAME = "__remote_log_metadata";
+
+ public static final String REMOTE_LOG_METADATA_TOPIC_REPLICATION_FACTOR_PROP = "remote.log.metadata.topic.replication.factor";
+ public static final String REMOTE_LOG_METADATA_TOPIC_PARTITIONS_PROP = "remote.log.metadata.topic.num.partitions";
+ public static final String REMOTE_LOG_METADATA_TOPIC_RETENTION_MILLIS_PROP = "remote.log.metadata.topic.retention.ms";
+ public static final String REMOTE_LOG_METADATA_CONSUME_WAIT_MS_PROP = "remote.log.metadata.publish.wait.ms";
+
+ public static final int DEFAULT_REMOTE_LOG_METADATA_TOPIC_PARTITIONS = 50;
+ public static final long DEFAULT_REMOTE_LOG_METADATA_TOPIC_RETENTION_MILLIS = -1L;
+ public static final int DEFAULT_REMOTE_LOG_METADATA_TOPIC_REPLICATION_FACTOR = 3;
+ public static final long DEFAULT_REMOTE_LOG_METADATA_CONSUME_WAIT_MS = 60 * 1000L;
+
+ public static final String REMOTE_LOG_METADATA_TOPIC_REPLICATION_FACTOR_DOC = "Replication factor of remote log metadata Topic.";
+ public static final String REMOTE_LOG_METADATA_TOPIC_PARTITIONS_DOC = "The number of partitions for remote log metadata Topic.";
+ public static final String REMOTE_LOG_METADATA_TOPIC_RETENTION_MILLIS_DOC = "Remote log metadata topic log retention in milli seconds." +
+ "Default: -1, that means unlimited. Users can configure this value based on their use cases. " +
+ "To avoid any data loss, this value should be more than the maximum retention period of any topic enabled with " +
+ "tiered storage in the cluster.";
+ public static final String REMOTE_LOG_METADATA_CONSUME_WAIT_MS_DOC = "The amount of time in milli seconds to wait for the local consumer to " +
+ "receive the published event.";
+
+ public static final String REMOTE_LOG_METADATA_COMMON_CLIENT_PREFIX = "remote.log.metadata.common.client.";
+ public static final String REMOTE_LOG_METADATA_PRODUCER_PREFIX = "remote.log.metadata.producer.";
+ public static final String REMOTE_LOG_METADATA_CONSUMER_PREFIX = "remote.log.metadata.consumer.";
+
+ private static final String REMOTE_LOG_METADATA_CLIENT_PREFIX = "__remote_log_metadata_client";
+ private static final String BROKER_ID = "broker.id";
+
+ private static final ConfigDef CONFIG = new ConfigDef();
+ static {
+ CONFIG.define(REMOTE_LOG_METADATA_TOPIC_REPLICATION_FACTOR_PROP, INT, DEFAULT_REMOTE_LOG_METADATA_TOPIC_REPLICATION_FACTOR, atLeast(1), LOW,
+ REMOTE_LOG_METADATA_TOPIC_REPLICATION_FACTOR_DOC)
+ .define(REMOTE_LOG_METADATA_TOPIC_PARTITIONS_PROP, INT, DEFAULT_REMOTE_LOG_METADATA_TOPIC_PARTITIONS, atLeast(1), LOW,
+ REMOTE_LOG_METADATA_TOPIC_PARTITIONS_DOC)
+ .define(REMOTE_LOG_METADATA_TOPIC_RETENTION_MILLIS_PROP, LONG, DEFAULT_REMOTE_LOG_METADATA_TOPIC_RETENTION_MILLIS, LOW,
+ REMOTE_LOG_METADATA_TOPIC_RETENTION_MILLIS_DOC)
+ .define(REMOTE_LOG_METADATA_CONSUME_WAIT_MS_PROP, LONG, DEFAULT_REMOTE_LOG_METADATA_CONSUME_WAIT_MS, atLeast(0), LOW,
+ REMOTE_LOG_METADATA_CONSUME_WAIT_MS_DOC);
+ }
+
+ private final String clientIdPrefix;
+ private final int metadataTopicPartitionsCount;
+ private final String bootstrapServers;
+ private final long consumeWaitMs;
+ private final long metadataTopicRetentionMillis;
+
+ private Map<String, Object> consumerProps;
+ private Map<String, Object> producerProps;
+
+ public TopicBasedRemoteLogMetadataManagerConfig(Map<String, ?> props) {
+ log.info("Received props: [{}]", props);
+ Objects.requireNonNull(props, "props can not be null");
+
+ Map<String, Object> parsedConfigs = CONFIG.parse(props);
+
+ bootstrapServers = (String) props.get(BOOTSTRAP_SERVERS_CONFIG);
Review comment:
Other plugins on the broker may also need a bootstrap_server config. To distinguish them, it would be useful to add a prefix that's specific to remote storage.
##########
File path: storage/src/main/java/org/apache/kafka/server/log/remote/metadata/storage/ConsumerManager.java
##########
@@ -0,0 +1,130 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.kafka.server.log.remote.metadata.storage;
+
+import org.apache.kafka.clients.consumer.KafkaConsumer;
+import org.apache.kafka.clients.producer.RecordMetadata;
+import org.apache.kafka.common.KafkaException;
+import org.apache.kafka.common.TopicIdPartition;
+import org.apache.kafka.common.utils.KafkaThread;
+import org.apache.kafka.common.utils.Time;
+import org.apache.kafka.common.utils.Utils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.Optional;
+import java.util.Set;
+
+/**
+ * This class manages the consumer thread viz {@link ConsumerTask} that polls messages from the assigned metadata topic partitions.
+ * It also provides a way to wait until the given record is received by the consumer before it is timed out with an interval of
+ * {@link TopicBasedRemoteLogMetadataManagerConfig#consumeWaitMs()}.
+ */
+public class ConsumerManager implements Closeable {
+
+ private static final Logger log = LoggerFactory.getLogger(ConsumerManager.class);
+ private static final long CONSUME_RECHECK_INTERVAL_MS = 50L;
+
+ private final TopicBasedRemoteLogMetadataManagerConfig rlmmConfig;
+ private final Time time;
+ private final ConsumerTask consumerTask;
+ private final Thread consumerTaskThread;
+
+ public ConsumerManager(TopicBasedRemoteLogMetadataManagerConfig rlmmConfig,
+ RemotePartitionMetadataEventHandler remotePartitionMetadataEventHandler,
+ RemoteLogMetadataTopicPartitioner rlmmTopicPartitioner,
+ Time time) {
+ this.rlmmConfig = rlmmConfig;
+ this.time = time;
+
+ //Create a task to consume messages and submit the respective events to RemotePartitionMetadataEventHandler.
+ KafkaConsumer<byte[], byte[]> consumer = new KafkaConsumer<>(rlmmConfig.consumerProperties());
+ consumerTask = new ConsumerTask(consumer, remotePartitionMetadataEventHandler, rlmmTopicPartitioner);
+ consumerTaskThread = KafkaThread.daemon("RLMMConsumerTask", consumerTask);
Review comment:
Hmm, why is this a daemon thread? It seems that we want to coordinate the shutdown of the thread.
##########
File path: storage/src/main/java/org/apache/kafka/server/log/remote/metadata/storage/ProducerManager.java
##########
@@ -0,0 +1,130 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.kafka.server.log.remote.metadata.storage;
+
+import org.apache.kafka.clients.producer.Callback;
+import org.apache.kafka.clients.producer.KafkaProducer;
+import org.apache.kafka.clients.producer.ProducerRecord;
+import org.apache.kafka.clients.producer.RecordMetadata;
+import org.apache.kafka.common.KafkaException;
+import org.apache.kafka.common.TopicIdPartition;
+import org.apache.kafka.server.log.remote.metadata.storage.serialization.RemoteLogMetadataSerde;
+import org.apache.kafka.server.log.remote.storage.RemoteLogMetadata;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.Closeable;
+import java.time.Duration;
+
+/**
+ * This class is responsible for publishing messages into the remote log metadata topic partitions.
+ */
+public class ProducerManager implements Closeable {
+ private static final Logger log = LoggerFactory.getLogger(ProducerManager.class);
+
+ private final RemoteLogMetadataSerde serde = new RemoteLogMetadataSerde();
+ private final KafkaProducer<byte[], byte[]> producer;
+ private final RemoteLogMetadataTopicPartitioner topicPartitioner;
+ private final TopicBasedRemoteLogMetadataManagerConfig rlmmConfig;
+
+ // It indicates whether closing process has been started or not. It will not accept any
+ // messages once it is set as true.
+ private volatile boolean close = false;
+
+ public ProducerManager(TopicBasedRemoteLogMetadataManagerConfig rlmmConfig,
+ RemoteLogMetadataTopicPartitioner rlmmTopicPartitioner) {
+ this.rlmmConfig = rlmmConfig;
+ this.producer = new KafkaProducer<>(rlmmConfig.producerProperties());
+ topicPartitioner = rlmmTopicPartitioner;
+ }
+
+ public RecordMetadata publishMessage(RemoteLogMetadata remoteLogMetadata) throws KafkaException {
+ ensureNotClosed();
Review comment:
Is this necessary? Once producer is closed, send() will throw an exception.
##########
File path: storage/src/test/java/org/apache/kafka/server/log/remote/metadata/storage/TopicBasedRemoteLogMetadataManagerHarness.java
##########
@@ -0,0 +1,123 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.kafka.server.log.remote.metadata.storage;
+
+import kafka.api.IntegrationTestHarness;
+import kafka.utils.TestUtils;
+import org.apache.kafka.clients.CommonClientConfigs;
+import org.apache.kafka.common.TopicIdPartition;
+import org.apache.kafka.common.config.TopicConfig;
+import org.apache.kafka.common.utils.MockTime;
+import org.apache.kafka.common.utils.Time;
+import org.apache.kafka.common.utils.Utils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Set;
+import java.util.concurrent.TimeoutException;
+
+import static org.apache.kafka.server.log.remote.metadata.storage.TopicBasedRemoteLogMetadataManagerConfig.REMOTE_LOG_METADATA_TOPIC_PARTITIONS_PROP;
+import static org.apache.kafka.server.log.remote.metadata.storage.TopicBasedRemoteLogMetadataManagerConfig.REMOTE_LOG_METADATA_TOPIC_REPLICATION_FACTOR_PROP;
+import static org.apache.kafka.server.log.remote.metadata.storage.TopicBasedRemoteLogMetadataManagerConfig.REMOTE_LOG_METADATA_TOPIC_RETENTION_MILLIS_PROP;
+
+public class TopicBasedRemoteLogMetadataManagerHarness extends IntegrationTestHarness {
+ private static final Logger log = LoggerFactory.getLogger(TopicBasedRemoteLogMetadataManagerHarness.class);
+
+ protected static final int METADATA_TOPIC_PARTITIONS_COUNT = 3;
+ protected static final int METADATA_TOPIC_REPLICATION_FACTOR = 2;
+ protected static final long METADATA_TOPIC_RETENTION_MS = 24 * 60 * 60 * 1000L;
+
+ private final Time time = new MockTime(1);
+ private TopicBasedRemoteLogMetadataManager topicBasedRemoteLogMetadataManager;
+
+ protected Map<String, Object> overrideRemoteLogMetadataManagerProps() {
+ return Collections.emptyMap();
+ }
+
+ public void initialize(Set<TopicIdPartition> topicIdPartitions) {
+ // Call setup to start the cluster.
+ super.setUp();
+
+ // Make sure the remote log metadata topic is created before it is used.
+ createMetadataTopic();
+
+ topicBasedRemoteLogMetadataManager = new TopicBasedRemoteLogMetadataManager(time);
+
+ // Initialize TopicBasedRemoteLogMetadataManager.
+ Map<String, Object> configs = new HashMap<>();
+ configs.put(CommonClientConfigs.BOOTSTRAP_SERVERS_CONFIG, brokerList());
+ configs.put("broker.id", 0);
+ configs.put(REMOTE_LOG_METADATA_TOPIC_PARTITIONS_PROP, METADATA_TOPIC_PARTITIONS_COUNT);
+ configs.put(REMOTE_LOG_METADATA_TOPIC_REPLICATION_FACTOR_PROP, METADATA_TOPIC_REPLICATION_FACTOR);
+ configs.put(REMOTE_LOG_METADATA_TOPIC_RETENTION_MILLIS_PROP, METADATA_TOPIC_RETENTION_MS);
+
+ log.debug("TopicBasedRemoteLogMetadataManager configs before adding overridden properties: {}", configs);
+ // Add override properties.
+ configs.putAll(overrideRemoteLogMetadataManagerProps());
+ log.debug("TopicBasedRemoteLogMetadataManager configs after adding overridden properties: {}", configs);
+
+ topicBasedRemoteLogMetadataManager.configure(configs);
+ try {
+ waitUntilInitialized(120_000);
+ } catch (TimeoutException e) {
+ throw new RuntimeException(e);
+ }
+
+ topicBasedRemoteLogMetadataManager.onPartitionLeadershipChanges(topicIdPartitions, Collections.emptySet());
+ }
+
+ // Visible for testing.
+ public void waitUntilInitialized(long waitTimeMs) throws TimeoutException {
+ long startMs = System.currentTimeMillis();
+ while (!topicBasedRemoteLogMetadataManager.isInitialized()) {
+ long currentTimeMs = System.currentTimeMillis();
+ if (currentTimeMs > startMs + waitTimeMs) {
+ throw new TimeoutException("Time out reached before it is initialized successfully");
+ }
+
+ Utils.sleep(1000);
+ }
+ }
+
+ @Override
+ public int brokerCount() {
+ return 3;
+ }
+
+ protected TopicBasedRemoteLogMetadataManager topicBasedRlmm() {
+ return topicBasedRemoteLogMetadataManager;
+ }
+
+ private void createMetadataTopic() {
Review comment:
It seems that we need to automatically create metadata topic in RLMM implementation, not just in tests.
##########
File path: storage/src/test/java/org/apache/kafka/server/log/remote/metadata/storage/RemoteLogSegmentLifecycleManager.java
##########
@@ -0,0 +1,60 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.kafka.server.log.remote.metadata.storage;
+
+import org.apache.kafka.common.TopicIdPartition;
+import org.apache.kafka.server.log.remote.storage.RemoteLogSegmentMetadata;
+import org.apache.kafka.server.log.remote.storage.RemoteLogSegmentMetadataUpdate;
+import org.apache.kafka.server.log.remote.storage.RemoteStorageException;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.Iterator;
+import java.util.Optional;
+
+/**
+ * This interface defines the lifecycle methods for {@code RemoteLogSegmentMetadata}. {@link RemoteLogSegmentLifecycleTest} tests
+ * different implementations of this interface. This is responsible for managing all the segments for a given {@code topicIdPartition}
+ * registered with {@link #initialize(TopicIdPartition)}.
+ */
+public interface RemoteLogSegmentLifecycleManager extends Closeable {
Review comment:
How is this different from RemoteLogMetadataCache? It seems that it's just a wrapper over RemoteLogMetadataCache?
##########
File path: storage/src/main/java/org/apache/kafka/server/log/remote/metadata/storage/ConsumerTask.java
##########
@@ -0,0 +1,235 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.kafka.server.log.remote.metadata.storage;
+
+import org.apache.kafka.clients.consumer.ConsumerRecord;
+import org.apache.kafka.clients.consumer.ConsumerRecords;
+import org.apache.kafka.clients.consumer.KafkaConsumer;
+import org.apache.kafka.common.KafkaException;
+import org.apache.kafka.common.TopicIdPartition;
+import org.apache.kafka.common.TopicPartition;
+import org.apache.kafka.server.log.remote.metadata.storage.serialization.RemoteLogMetadataSerde;
+import org.apache.kafka.server.log.remote.storage.RemoteLogMetadata;
+import org.apache.kafka.server.log.remote.storage.RemoteLogSegmentMetadata;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.Closeable;
+import java.time.Duration;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;
+
+import static org.apache.kafka.server.log.remote.metadata.storage.TopicBasedRemoteLogMetadataManagerConfig.REMOTE_LOG_METADATA_TOPIC_NAME;
+
+/**
+ * This class is responsible for consuming messages from remote log metadata topic ({@link TopicBasedRemoteLogMetadataManagerConfig#REMOTE_LOG_METADATA_TOPIC_NAME})
+ * partitions and maintain the state of the remote log segment metadata. It gives an API to add or remove
+ * for what topic partition's metadata should be consumed by this instance using
+ * {{@link #addAssignmentsForPartitions(Set)}} and {@link #removeAssignmentsForPartitions(Set)} respectively.
+ * <p>
+ * When a broker is started, controller sends topic partitions that this broker is leader or follower for and the
+ * partitions to be deleted. This class receives those notifications with
+ * {@link #addAssignmentsForPartitions(Set)} and {@link #removeAssignmentsForPartitions(Set)} assigns consumer for the
+ * respective remote log metadata partitions by using {@link RemoteLogMetadataTopicPartitioner#metadataPartition(TopicIdPartition)}.
+ * Any leadership changes later are called through the same API. We will remove the partitions that are deleted from
+ * this broker which are received through {@link #removeAssignmentsForPartitions(Set)}.
+ * <p>
+ * After receiving these events it invokes {@link RemotePartitionMetadataEventHandler#handleRemoteLogSegmentMetadata(RemoteLogSegmentMetadata)},
+ * which maintains in-memory representation of the state of {@link RemoteLogSegmentMetadata}.
+ */
+class ConsumerTask implements Runnable, Closeable {
+ private static final Logger log = LoggerFactory.getLogger(ConsumerTask.class);
+
+ private static final long POLL_INTERVAL_MS = 30L;
+
+ private final RemoteLogMetadataSerde serde = new RemoteLogMetadataSerde();
+ private final KafkaConsumer<byte[], byte[]> consumer;
+ private final RemotePartitionMetadataEventHandler remotePartitionMetadataEventHandler;
+ private final RemoteLogMetadataTopicPartitioner topicPartitioner;
+
+ // It indicates whether the closing process has been started or not. If it is set as true,
+ // consumer will stop consuming messages and it will not allow partition assignments to be updated.
+ private volatile boolean closing = false;
+ // It indicates whether the consumer needs to assign the partitions or not. This is set when it is
+ // determined that the consumer needs to be assigned with the updated partitions.
+ private volatile boolean assignPartitions = false;
+
+ private final Object assignPartitionsLock = new Object();
+
+ // Remote log metadata topic partitions that consumer is assigned to.
+ private volatile Set<Integer> assignedMetaPartitions = Collections.emptySet();
+
+ // User topic partitions that this broker is a leader/follower for.
+ private Set<TopicIdPartition> assignedTopicPartitions = Collections.emptySet();
+
+ // Map of remote log metadata topic partition to consumed offsets.
+ private final Map<Integer, Long> partitionToConsumedOffsets = new ConcurrentHashMap<>();
+
+ public ConsumerTask(KafkaConsumer<byte[], byte[]> consumer,
+ RemotePartitionMetadataEventHandler remotePartitionMetadataEventHandler,
+ RemoteLogMetadataTopicPartitioner topicPartitioner) {
+ Objects.requireNonNull(consumer);
+ Objects.requireNonNull(remotePartitionMetadataEventHandler);
+ Objects.requireNonNull(topicPartitioner);
+
+ this.consumer = consumer;
+ this.remotePartitionMetadataEventHandler = remotePartitionMetadataEventHandler;
+ this.topicPartitioner = topicPartitioner;
+ }
+
+ @Override
+ public void run() {
+ log.info("Started Consumer task thread.");
+ try {
+ while (!closing) {
+ Set<Integer> assignedMetaPartitionsSnapshot = maybeWaitForPartitionsAssignment();
+
+ if (!assignedMetaPartitionsSnapshot.isEmpty()) {
+ executeReassignment(assignedMetaPartitionsSnapshot);
+ }
+
+ log.info("Polling consumer to receive remote log metadata topic records");
+ ConsumerRecords<byte[], byte[]> consumerRecords
+ = consumer.poll(Duration.ofSeconds(POLL_INTERVAL_MS));
+ for (ConsumerRecord<byte[], byte[]> record : consumerRecords) {
+ handleRemoteLogMetadata(serde.deserialize(record.value()));
+ partitionToConsumedOffsets.put(record.partition(), record.offset());
+ }
+ }
+ } catch (Exception e) {
+ log.error("Error occurred in consumer task, close:[{}]", closing, e);
+ }
+
+ closeConsumer();
+ log.info("Exiting from consumer task thread");
+ }
+
+ private void closeConsumer() {
+ log.info("Closing the consumer instance");
+ try {
+ consumer.close(Duration.ofSeconds(30));
+ } catch (Exception e) {
+ log.error("Error encountered while closing the consumer", e);
+ }
+ }
+
+ private Set<Integer> maybeWaitForPartitionsAssignment() {
+ Set<Integer> assignedMetaPartitionsSnapshot = Collections.emptySet();
+ synchronized (assignPartitionsLock) {
+ while (assignedMetaPartitions.isEmpty()) {
+ // If no partitions are assigned, wait until they are assigned.
+ log.info("Waiting for assigned remote log metadata partitions..");
+ try {
+ assignPartitionsLock.wait();
+ } catch (InterruptedException e) {
+ throw new KafkaException(e);
+ }
+ }
+
+ if (assignPartitions) {
+ assignedMetaPartitionsSnapshot = new HashSet<>(assignedMetaPartitions);
+ assignPartitions = false;
+ }
+ }
+ return assignedMetaPartitionsSnapshot;
+ }
+
+ private void handleRemoteLogMetadata(RemoteLogMetadata remoteLogMetadata) {
+ if (assignedTopicPartitions.contains(remoteLogMetadata.topicIdPartition())) {
+ remotePartitionMetadataEventHandler.handleRemoteLogMetadata(remoteLogMetadata);
+ } else {
+ log.debug("This event {} is skipped as the topic partition is not assigned for this instance.", remoteLogMetadata);
+ }
+ }
+
+ private void executeReassignment(Set<Integer> assignedMetaPartitionsSnapshot) {
+ Set<TopicPartition> assignedMetaTopicPartitions = assignedMetaPartitionsSnapshot.stream()
+ .map(partitionNum -> new TopicPartition(REMOTE_LOG_METADATA_TOPIC_NAME, partitionNum))
+ .collect(Collectors.toSet());
+ log.info("Reassigning partitions to consumer task [{}]", assignedMetaTopicPartitions);
+ consumer.assign(assignedMetaTopicPartitions);
+ }
+
+ public void addAssignmentsForPartitions(Set<TopicIdPartition> partitions) {
+ updateAssignmentsForPartitions(partitions, Collections.emptySet());
+ }
+
+ public void removeAssignmentsForPartitions(Set<TopicIdPartition> partitions) {
+ updateAssignmentsForPartitions(Collections.emptySet(), partitions);
+ }
+
+ private void updateAssignmentsForPartitions(Set<TopicIdPartition> addedPartitions,
+ Set<TopicIdPartition> removedPartitions) {
+ log.info("Updating assignments for addedPartitions: {} and removedPartition: {}", addedPartitions, removedPartitions);
+ ensureNotClosed();
Review comment:
Is this necessary since immediately after this check, the consumer task could be closed. Ditto in other places.
##########
File path: storage/src/main/java/org/apache/kafka/server/log/remote/metadata/storage/RemotePartitionMetadataStore.java
##########
@@ -0,0 +1,140 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.kafka.server.log.remote.metadata.storage;
+
+import org.apache.kafka.common.TopicIdPartition;
+import org.apache.kafka.server.log.remote.storage.RemoteLogSegmentId;
+import org.apache.kafka.server.log.remote.storage.RemoteLogSegmentMetadata;
+import org.apache.kafka.server.log.remote.storage.RemoteLogSegmentMetadataUpdate;
+import org.apache.kafka.server.log.remote.storage.RemotePartitionDeleteMetadata;
+import org.apache.kafka.server.log.remote.storage.RemotePartitionDeleteState;
+import org.apache.kafka.server.log.remote.storage.RemoteResourceNotFoundException;
+import org.apache.kafka.server.log.remote.storage.RemoteStorageException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class RemotePartitionMetadataStore extends RemotePartitionMetadataEventHandler implements Closeable {
Review comment:
Could we add a comment for this class?
##########
File path: storage/src/main/java/org/apache/kafka/server/log/remote/metadata/storage/ConsumerTask.java
##########
@@ -0,0 +1,235 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.kafka.server.log.remote.metadata.storage;
+
+import org.apache.kafka.clients.consumer.ConsumerRecord;
+import org.apache.kafka.clients.consumer.ConsumerRecords;
+import org.apache.kafka.clients.consumer.KafkaConsumer;
+import org.apache.kafka.common.KafkaException;
+import org.apache.kafka.common.TopicIdPartition;
+import org.apache.kafka.common.TopicPartition;
+import org.apache.kafka.server.log.remote.metadata.storage.serialization.RemoteLogMetadataSerde;
+import org.apache.kafka.server.log.remote.storage.RemoteLogMetadata;
+import org.apache.kafka.server.log.remote.storage.RemoteLogSegmentMetadata;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.Closeable;
+import java.time.Duration;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;
+
+import static org.apache.kafka.server.log.remote.metadata.storage.TopicBasedRemoteLogMetadataManagerConfig.REMOTE_LOG_METADATA_TOPIC_NAME;
+
+/**
+ * This class is responsible for consuming messages from remote log metadata topic ({@link TopicBasedRemoteLogMetadataManagerConfig#REMOTE_LOG_METADATA_TOPIC_NAME})
+ * partitions and maintain the state of the remote log segment metadata. It gives an API to add or remove
+ * for what topic partition's metadata should be consumed by this instance using
+ * {{@link #addAssignmentsForPartitions(Set)}} and {@link #removeAssignmentsForPartitions(Set)} respectively.
+ * <p>
+ * When a broker is started, controller sends topic partitions that this broker is leader or follower for and the
+ * partitions to be deleted. This class receives those notifications with
+ * {@link #addAssignmentsForPartitions(Set)} and {@link #removeAssignmentsForPartitions(Set)} assigns consumer for the
+ * respective remote log metadata partitions by using {@link RemoteLogMetadataTopicPartitioner#metadataPartition(TopicIdPartition)}.
+ * Any leadership changes later are called through the same API. We will remove the partitions that are deleted from
+ * this broker which are received through {@link #removeAssignmentsForPartitions(Set)}.
+ * <p>
+ * After receiving these events it invokes {@link RemotePartitionMetadataEventHandler#handleRemoteLogSegmentMetadata(RemoteLogSegmentMetadata)},
+ * which maintains in-memory representation of the state of {@link RemoteLogSegmentMetadata}.
+ */
+class ConsumerTask implements Runnable, Closeable {
+ private static final Logger log = LoggerFactory.getLogger(ConsumerTask.class);
+
+ private static final long POLL_INTERVAL_MS = 30L;
+
+ private final RemoteLogMetadataSerde serde = new RemoteLogMetadataSerde();
+ private final KafkaConsumer<byte[], byte[]> consumer;
+ private final RemotePartitionMetadataEventHandler remotePartitionMetadataEventHandler;
+ private final RemoteLogMetadataTopicPartitioner topicPartitioner;
+
+ // It indicates whether the closing process has been started or not. If it is set as true,
+ // consumer will stop consuming messages and it will not allow partition assignments to be updated.
+ private volatile boolean closing = false;
+ // It indicates whether the consumer needs to assign the partitions or not. This is set when it is
+ // determined that the consumer needs to be assigned with the updated partitions.
+ private volatile boolean assignPartitions = false;
+
+ private final Object assignPartitionsLock = new Object();
+
+ // Remote log metadata topic partitions that consumer is assigned to.
+ private volatile Set<Integer> assignedMetaPartitions = Collections.emptySet();
+
+ // User topic partitions that this broker is a leader/follower for.
+ private Set<TopicIdPartition> assignedTopicPartitions = Collections.emptySet();
+
+ // Map of remote log metadata topic partition to consumed offsets.
+ private final Map<Integer, Long> partitionToConsumedOffsets = new ConcurrentHashMap<>();
+
+ public ConsumerTask(KafkaConsumer<byte[], byte[]> consumer,
+ RemotePartitionMetadataEventHandler remotePartitionMetadataEventHandler,
+ RemoteLogMetadataTopicPartitioner topicPartitioner) {
+ Objects.requireNonNull(consumer);
+ Objects.requireNonNull(remotePartitionMetadataEventHandler);
+ Objects.requireNonNull(topicPartitioner);
+
+ this.consumer = consumer;
+ this.remotePartitionMetadataEventHandler = remotePartitionMetadataEventHandler;
+ this.topicPartitioner = topicPartitioner;
+ }
+
+ @Override
+ public void run() {
+ log.info("Started Consumer task thread.");
+ try {
+ while (!closing) {
+ Set<Integer> assignedMetaPartitionsSnapshot = maybeWaitForPartitionsAssignment();
+
+ if (!assignedMetaPartitionsSnapshot.isEmpty()) {
+ executeReassignment(assignedMetaPartitionsSnapshot);
+ }
+
+ log.info("Polling consumer to receive remote log metadata topic records");
+ ConsumerRecords<byte[], byte[]> consumerRecords
+ = consumer.poll(Duration.ofSeconds(POLL_INTERVAL_MS));
+ for (ConsumerRecord<byte[], byte[]> record : consumerRecords) {
+ handleRemoteLogMetadata(serde.deserialize(record.value()));
+ partitionToConsumedOffsets.put(record.partition(), record.offset());
+ }
+ }
+ } catch (Exception e) {
+ log.error("Error occurred in consumer task, close:[{}]", closing, e);
+ }
+
+ closeConsumer();
+ log.info("Exiting from consumer task thread");
+ }
+
+ private void closeConsumer() {
+ log.info("Closing the consumer instance");
+ try {
+ consumer.close(Duration.ofSeconds(30));
+ } catch (Exception e) {
+ log.error("Error encountered while closing the consumer", e);
+ }
+ }
+
+ private Set<Integer> maybeWaitForPartitionsAssignment() {
+ Set<Integer> assignedMetaPartitionsSnapshot = Collections.emptySet();
+ synchronized (assignPartitionsLock) {
+ while (assignedMetaPartitions.isEmpty()) {
+ // If no partitions are assigned, wait until they are assigned.
+ log.info("Waiting for assigned remote log metadata partitions..");
+ try {
+ assignPartitionsLock.wait();
Review comment:
We need to unblock the wait if we are closing the consumer.
##########
File path: storage/src/main/java/org/apache/kafka/server/log/remote/metadata/storage/TopicBasedRemoteLogMetadataManagerConfig.java
##########
@@ -0,0 +1,200 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.kafka.server.log.remote.metadata.storage;
+
+import org.apache.kafka.clients.CommonClientConfigs;
+import org.apache.kafka.clients.consumer.ConsumerConfig;
+import org.apache.kafka.clients.producer.ProducerConfig;
+import org.apache.kafka.common.config.ConfigDef;
+import org.apache.kafka.common.serialization.ByteArrayDeserializer;
+import org.apache.kafka.common.serialization.ByteArraySerializer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+import static org.apache.kafka.clients.CommonClientConfigs.BOOTSTRAP_SERVERS_CONFIG;
+import static org.apache.kafka.common.config.ConfigDef.Importance.LOW;
+import static org.apache.kafka.common.config.ConfigDef.Range.atLeast;
+import static org.apache.kafka.common.config.ConfigDef.Type.INT;
+import static org.apache.kafka.common.config.ConfigDef.Type.LONG;
+
+/**
+ * This class defines the configuration of topic based {@link org.apache.kafka.server.log.remote.storage.RemoteLogMetadataManager} implementation.
+ */
+public final class TopicBasedRemoteLogMetadataManagerConfig {
+ private static final Logger log = LoggerFactory.getLogger(TopicBasedRemoteLogMetadataManagerConfig.class.getName());
+
+ public static final String REMOTE_LOG_METADATA_TOPIC_NAME = "__remote_log_metadata";
+
+ public static final String REMOTE_LOG_METADATA_TOPIC_REPLICATION_FACTOR_PROP = "remote.log.metadata.topic.replication.factor";
+ public static final String REMOTE_LOG_METADATA_TOPIC_PARTITIONS_PROP = "remote.log.metadata.topic.num.partitions";
+ public static final String REMOTE_LOG_METADATA_TOPIC_RETENTION_MILLIS_PROP = "remote.log.metadata.topic.retention.ms";
+ public static final String REMOTE_LOG_METADATA_CONSUME_WAIT_MS_PROP = "remote.log.metadata.publish.wait.ms";
+
+ public static final int DEFAULT_REMOTE_LOG_METADATA_TOPIC_PARTITIONS = 50;
+ public static final long DEFAULT_REMOTE_LOG_METADATA_TOPIC_RETENTION_MILLIS = -1L;
+ public static final int DEFAULT_REMOTE_LOG_METADATA_TOPIC_REPLICATION_FACTOR = 3;
+ public static final long DEFAULT_REMOTE_LOG_METADATA_CONSUME_WAIT_MS = 60 * 1000L;
+
+ public static final String REMOTE_LOG_METADATA_TOPIC_REPLICATION_FACTOR_DOC = "Replication factor of remote log metadata Topic.";
+ public static final String REMOTE_LOG_METADATA_TOPIC_PARTITIONS_DOC = "The number of partitions for remote log metadata Topic.";
+ public static final String REMOTE_LOG_METADATA_TOPIC_RETENTION_MILLIS_DOC = "Remote log metadata topic log retention in milli seconds." +
+ "Default: -1, that means unlimited. Users can configure this value based on their use cases. " +
+ "To avoid any data loss, this value should be more than the maximum retention period of any topic enabled with " +
+ "tiered storage in the cluster.";
+ public static final String REMOTE_LOG_METADATA_CONSUME_WAIT_MS_DOC = "The amount of time in milli seconds to wait for the local consumer to " +
+ "receive the published event.";
+
+ public static final String REMOTE_LOG_METADATA_COMMON_CLIENT_PREFIX = "remote.log.metadata.common.client.";
+ public static final String REMOTE_LOG_METADATA_PRODUCER_PREFIX = "remote.log.metadata.producer.";
+ public static final String REMOTE_LOG_METADATA_CONSUMER_PREFIX = "remote.log.metadata.consumer.";
+
+ private static final String REMOTE_LOG_METADATA_CLIENT_PREFIX = "__remote_log_metadata_client";
+ private static final String BROKER_ID = "broker.id";
+
+ private static final ConfigDef CONFIG = new ConfigDef();
+ static {
+ CONFIG.define(REMOTE_LOG_METADATA_TOPIC_REPLICATION_FACTOR_PROP, INT, DEFAULT_REMOTE_LOG_METADATA_TOPIC_REPLICATION_FACTOR, atLeast(1), LOW,
+ REMOTE_LOG_METADATA_TOPIC_REPLICATION_FACTOR_DOC)
+ .define(REMOTE_LOG_METADATA_TOPIC_PARTITIONS_PROP, INT, DEFAULT_REMOTE_LOG_METADATA_TOPIC_PARTITIONS, atLeast(1), LOW,
+ REMOTE_LOG_METADATA_TOPIC_PARTITIONS_DOC)
+ .define(REMOTE_LOG_METADATA_TOPIC_RETENTION_MILLIS_PROP, LONG, DEFAULT_REMOTE_LOG_METADATA_TOPIC_RETENTION_MILLIS, LOW,
+ REMOTE_LOG_METADATA_TOPIC_RETENTION_MILLIS_DOC)
+ .define(REMOTE_LOG_METADATA_CONSUME_WAIT_MS_PROP, LONG, DEFAULT_REMOTE_LOG_METADATA_CONSUME_WAIT_MS, atLeast(0), LOW,
+ REMOTE_LOG_METADATA_CONSUME_WAIT_MS_DOC);
+ }
+
+ private final String clientIdPrefix;
+ private final int metadataTopicPartitionsCount;
+ private final String bootstrapServers;
+ private final long consumeWaitMs;
+ private final long metadataTopicRetentionMs;
+
+ private Map<String, Object> consumerProps;
+ private Map<String, Object> producerProps;
+
+ public TopicBasedRemoteLogMetadataManagerConfig(Map<String, ?> props) {
+ log.info("Received props: [{}]", props);
Review comment:
Is this needed since we log all configs when creating KafkaConfig already?
##########
File path: storage/src/test/java/org/apache/kafka/server/log/remote/metadata/storage/RemoteLogSegmentLifecycleTest.java
##########
@@ -0,0 +1,516 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.kafka.server.log.remote.metadata.storage;
+
+import org.apache.kafka.common.TopicIdPartition;
+import org.apache.kafka.common.TopicPartition;
+import org.apache.kafka.common.Uuid;
+import org.apache.kafka.common.utils.MockTime;
+import org.apache.kafka.common.utils.Time;
+import org.apache.kafka.common.utils.Utils;
+import org.apache.kafka.server.log.remote.storage.RemoteLogSegmentId;
+import org.apache.kafka.server.log.remote.storage.RemoteLogSegmentMetadata;
+import org.apache.kafka.server.log.remote.storage.RemoteLogSegmentMetadataUpdate;
+import org.apache.kafka.server.log.remote.storage.RemoteLogSegmentState;
+import org.apache.kafka.server.log.remote.storage.RemoteResourceNotFoundException;
+import org.apache.kafka.server.log.remote.storage.RemoteStorageException;
+import org.apache.kafka.test.TestUtils;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Stream;
+
+public class RemoteLogSegmentLifecycleTest {
+ private static final Logger log = LoggerFactory.getLogger(RemoteLogSegmentLifecycleTest.class);
+
+ private static final int SEG_SIZE = 1024 * 1024;
+ private static final int BROKER_ID_0 = 0;
+ private static final int BROKER_ID_1 = 1;
+
+ private final TopicIdPartition topicIdPartition = new TopicIdPartition(Uuid.randomUuid(), new TopicPartition("foo", 0));
+ private final Time time = new MockTime(1);
+
+ @ParameterizedTest(name = "remoteLogSegmentLifecycleManager = {0}")
+ @MethodSource("remoteLogSegmentLifecycleManagers")
+ public void testRemoteLogSegmentLifeCycle(RemoteLogSegmentLifecycleManager remoteLogSegmentLifecycleManager) throws Exception {
+ try {
+ remoteLogSegmentLifecycleManager.initialize(topicIdPartition);
+
+ // segment 0
+ // offsets: [0-100]
+ // leader epochs (0,0), (1,20), (2,80)
+ Map<Integer, Long> segment0LeaderEpochs = new HashMap<>();
+ segment0LeaderEpochs.put(0, 0L);
+ segment0LeaderEpochs.put(1, 20L);
+ segment0LeaderEpochs.put(2, 80L);
+ RemoteLogSegmentId segment0Id = new RemoteLogSegmentId(topicIdPartition, Uuid.randomUuid());
+ RemoteLogSegmentMetadata segment0Metadata = new RemoteLogSegmentMetadata(segment0Id, 0L, 100L,
+ -1L, BROKER_ID_0, time.milliseconds(), SEG_SIZE,
+ segment0LeaderEpochs);
+ remoteLogSegmentLifecycleManager.addRemoteLogSegmentMetadata(segment0Metadata);
+
+ // We should not get this as the segment is still getting copied and it is not yet considered successful until
+ // it reaches RemoteLogSegmentState.COPY_SEGMENT_FINISHED.
+ Assertions.assertFalse(remoteLogSegmentLifecycleManager.remoteLogSegmentMetadata(40, 1).isPresent());
+
+ // Check that these leader epochs are to considered for highest offsets as they are still getting copied and
+ // they did nto reach COPY_SEGMENT_FINISHED state.
Review comment:
typo nto
##########
File path: storage/src/test/java/org/apache/kafka/server/log/remote/metadata/storage/TopicBasedRemoteLogMetadataManagerHarness.java
##########
@@ -0,0 +1,123 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.kafka.server.log.remote.metadata.storage;
+
+import kafka.api.IntegrationTestHarness;
+import kafka.utils.TestUtils;
+import org.apache.kafka.clients.CommonClientConfigs;
+import org.apache.kafka.common.TopicIdPartition;
+import org.apache.kafka.common.config.TopicConfig;
+import org.apache.kafka.common.utils.MockTime;
+import org.apache.kafka.common.utils.Time;
+import org.apache.kafka.common.utils.Utils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Set;
+import java.util.concurrent.TimeoutException;
+
+import static org.apache.kafka.server.log.remote.metadata.storage.TopicBasedRemoteLogMetadataManagerConfig.REMOTE_LOG_METADATA_TOPIC_PARTITIONS_PROP;
+import static org.apache.kafka.server.log.remote.metadata.storage.TopicBasedRemoteLogMetadataManagerConfig.REMOTE_LOG_METADATA_TOPIC_REPLICATION_FACTOR_PROP;
+import static org.apache.kafka.server.log.remote.metadata.storage.TopicBasedRemoteLogMetadataManagerConfig.REMOTE_LOG_METADATA_TOPIC_RETENTION_MILLIS_PROP;
+
+public class TopicBasedRemoteLogMetadataManagerHarness extends IntegrationTestHarness {
+ private static final Logger log = LoggerFactory.getLogger(TopicBasedRemoteLogMetadataManagerHarness.class);
+
+ protected static final int METADATA_TOPIC_PARTITIONS_COUNT = 3;
+ protected static final int METADATA_TOPIC_REPLICATION_FACTOR = 2;
+ protected static final long METADATA_TOPIC_RETENTION_MS = 24 * 60 * 60 * 1000L;
+
+ private final Time time = new MockTime(1);
+ private TopicBasedRemoteLogMetadataManager topicBasedRemoteLogMetadataManager;
+
+ protected Map<String, Object> overrideRemoteLogMetadataManagerProps() {
+ return Collections.emptyMap();
+ }
+
+ public void initialize(Set<TopicIdPartition> topicIdPartitions) {
+ // Call setup to start the cluster.
+ super.setUp();
+
+ // Make sure the remote log metadata topic is created before it is used.
+ createMetadataTopic();
+
+ topicBasedRemoteLogMetadataManager = new TopicBasedRemoteLogMetadataManager(time);
+
+ // Initialize TopicBasedRemoteLogMetadataManager.
+ Map<String, Object> configs = new HashMap<>();
+ configs.put(CommonClientConfigs.BOOTSTRAP_SERVERS_CONFIG, brokerList());
+ configs.put("broker.id", 0);
+ configs.put(REMOTE_LOG_METADATA_TOPIC_PARTITIONS_PROP, METADATA_TOPIC_PARTITIONS_COUNT);
+ configs.put(REMOTE_LOG_METADATA_TOPIC_REPLICATION_FACTOR_PROP, METADATA_TOPIC_REPLICATION_FACTOR);
+ configs.put(REMOTE_LOG_METADATA_TOPIC_RETENTION_MILLIS_PROP, METADATA_TOPIC_RETENTION_MS);
+
+ log.debug("TopicBasedRemoteLogMetadataManager configs before adding overridden properties: {}", configs);
+ // Add override properties.
+ configs.putAll(overrideRemoteLogMetadataManagerProps());
+ log.debug("TopicBasedRemoteLogMetadataManager configs after adding overridden properties: {}", configs);
+
+ topicBasedRemoteLogMetadataManager.configure(configs);
+ try {
+ waitUntilInitialized(120_000);
Review comment:
120s seems quite long. Do we need to wait that long?
##########
File path: storage/src/test/java/org/apache/kafka/server/log/remote/metadata/storage/TopicBasedRemoteLogMetadataManagerConfigTest.java
##########
@@ -0,0 +1,149 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.kafka.server.log.remote.metadata.storage;
+
+import org.apache.kafka.clients.CommonClientConfigs;
+import org.apache.kafka.clients.consumer.ConsumerConfig;
+import org.apache.kafka.clients.producer.ProducerConfig;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.AbstractMap;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.apache.kafka.server.log.remote.metadata.storage.TopicBasedRemoteLogMetadataManagerConfig.REMOTE_LOG_METADATA_COMMON_CLIENT_PREFIX;
+import static org.apache.kafka.server.log.remote.metadata.storage.TopicBasedRemoteLogMetadataManagerConfig.REMOTE_LOG_METADATA_CONSUMER_PREFIX;
+import static org.apache.kafka.server.log.remote.metadata.storage.TopicBasedRemoteLogMetadataManagerConfig.REMOTE_LOG_METADATA_PRODUCER_PREFIX;
+import static org.apache.kafka.server.log.remote.metadata.storage.TopicBasedRemoteLogMetadataManagerConfig.REMOTE_LOG_METADATA_TOPIC_PARTITIONS_PROP;
+import static org.apache.kafka.server.log.remote.metadata.storage.TopicBasedRemoteLogMetadataManagerConfig.REMOTE_LOG_METADATA_TOPIC_REPLICATION_FACTOR_PROP;
+import static org.apache.kafka.server.log.remote.metadata.storage.TopicBasedRemoteLogMetadataManagerConfig.REMOTE_LOG_METADATA_TOPIC_RETENTION_MILLIS_PROP;
+
+public class TopicBasedRemoteLogMetadataManagerConfigTest {
+ private static final Logger log = LoggerFactory.getLogger(TopicBasedRemoteLogMetadataManagerConfigTest.class);
+
+ private static final String BOOTSTRAP_SERVERS = "localhost:9091";
+
+ @Test
+ public void testEmptyConfig() throws Exception {
+ // "bootstrap.servers" config is required, it will throw IllegalArgumentException if it does not exist.
+ Assertions.assertThrows(IllegalArgumentException.class, () -> new TopicBasedRemoteLogMetadataManagerConfig(Collections.emptyMap()));
+ }
+
+ @Test
+ public void testValidConfig() {
+
+ Map<String, Object> commonClientConfig = new HashMap<>();
+ commonClientConfig.put(CommonClientConfigs.RETRIES_CONFIG, 10);
+ commonClientConfig.put(CommonClientConfigs.RETRY_BACKOFF_MS_CONFIG, 1000L);
+ commonClientConfig.put(CommonClientConfigs.METADATA_MAX_AGE_CONFIG, 60000L);
+
+ Map<String, Object> producerConfig = new HashMap<>();
+ producerConfig.put(ProducerConfig.ACKS_CONFIG, "all");
+
+ Map<String, Object> consumerConfig = new HashMap<>();
+ consumerConfig.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, false);
+
+ Map<String, Object> props = createValidConfigProps(commonClientConfig, producerConfig, consumerConfig);
+
+ // Check for topic properties
+ TopicBasedRemoteLogMetadataManagerConfig rlmmConfig = new TopicBasedRemoteLogMetadataManagerConfig(props);
+ Assertions.assertEquals(props.get(REMOTE_LOG_METADATA_TOPIC_PARTITIONS_PROP), rlmmConfig.metadataTopicPartitionsCount());
+
+ // Check for common client configs.
+ for (Map.Entry<String, Object> entry : commonClientConfig.entrySet()) {
+ log.info("Checking config: " + entry.getKey());
+ Assertions.assertEquals(entry.getValue(),
+ rlmmConfig.producerProperties().get(entry.getKey()));
+ Assertions.assertEquals(entry.getValue(),
+ rlmmConfig.producerProperties().get(entry.getKey()));
Review comment:
This should be for consumer?
##########
File path: storage/src/test/java/org/apache/kafka/server/log/remote/metadata/storage/RemoteLogSegmentLifecycleTest.java
##########
@@ -0,0 +1,516 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.kafka.server.log.remote.metadata.storage;
+
+import org.apache.kafka.common.TopicIdPartition;
+import org.apache.kafka.common.TopicPartition;
+import org.apache.kafka.common.Uuid;
+import org.apache.kafka.common.utils.MockTime;
+import org.apache.kafka.common.utils.Time;
+import org.apache.kafka.common.utils.Utils;
+import org.apache.kafka.server.log.remote.storage.RemoteLogSegmentId;
+import org.apache.kafka.server.log.remote.storage.RemoteLogSegmentMetadata;
+import org.apache.kafka.server.log.remote.storage.RemoteLogSegmentMetadataUpdate;
+import org.apache.kafka.server.log.remote.storage.RemoteLogSegmentState;
+import org.apache.kafka.server.log.remote.storage.RemoteResourceNotFoundException;
+import org.apache.kafka.server.log.remote.storage.RemoteStorageException;
+import org.apache.kafka.test.TestUtils;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Stream;
+
+public class RemoteLogSegmentLifecycleTest {
+ private static final Logger log = LoggerFactory.getLogger(RemoteLogSegmentLifecycleTest.class);
+
+ private static final int SEG_SIZE = 1024 * 1024;
+ private static final int BROKER_ID_0 = 0;
+ private static final int BROKER_ID_1 = 1;
+
+ private final TopicIdPartition topicIdPartition = new TopicIdPartition(Uuid.randomUuid(), new TopicPartition("foo", 0));
+ private final Time time = new MockTime(1);
+
+ @ParameterizedTest(name = "remoteLogSegmentLifecycleManager = {0}")
+ @MethodSource("remoteLogSegmentLifecycleManagers")
+ public void testRemoteLogSegmentLifeCycle(RemoteLogSegmentLifecycleManager remoteLogSegmentLifecycleManager) throws Exception {
+ try {
+ remoteLogSegmentLifecycleManager.initialize(topicIdPartition);
+
+ // segment 0
+ // offsets: [0-100]
+ // leader epochs (0,0), (1,20), (2,80)
+ Map<Integer, Long> segment0LeaderEpochs = new HashMap<>();
+ segment0LeaderEpochs.put(0, 0L);
+ segment0LeaderEpochs.put(1, 20L);
+ segment0LeaderEpochs.put(2, 80L);
+ RemoteLogSegmentId segment0Id = new RemoteLogSegmentId(topicIdPartition, Uuid.randomUuid());
+ RemoteLogSegmentMetadata segment0Metadata = new RemoteLogSegmentMetadata(segment0Id, 0L, 100L,
+ -1L, BROKER_ID_0, time.milliseconds(), SEG_SIZE,
+ segment0LeaderEpochs);
+ remoteLogSegmentLifecycleManager.addRemoteLogSegmentMetadata(segment0Metadata);
+
+ // We should not get this as the segment is still getting copied and it is not yet considered successful until
+ // it reaches RemoteLogSegmentState.COPY_SEGMENT_FINISHED.
+ Assertions.assertFalse(remoteLogSegmentLifecycleManager.remoteLogSegmentMetadata(40, 1).isPresent());
+
+ // Check that these leader epochs are to considered for highest offsets as they are still getting copied and
Review comment:
This sentence doesn't read well.
##########
File path: storage/src/main/java/org/apache/kafka/server/log/remote/metadata/storage/TopicBasedRemoteLogMetadataManagerConfig.java
##########
@@ -0,0 +1,200 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.kafka.server.log.remote.metadata.storage;
+
+import org.apache.kafka.clients.CommonClientConfigs;
+import org.apache.kafka.clients.consumer.ConsumerConfig;
+import org.apache.kafka.clients.producer.ProducerConfig;
+import org.apache.kafka.common.config.ConfigDef;
+import org.apache.kafka.common.serialization.ByteArrayDeserializer;
+import org.apache.kafka.common.serialization.ByteArraySerializer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+import static org.apache.kafka.clients.CommonClientConfigs.BOOTSTRAP_SERVERS_CONFIG;
+import static org.apache.kafka.common.config.ConfigDef.Importance.LOW;
+import static org.apache.kafka.common.config.ConfigDef.Range.atLeast;
+import static org.apache.kafka.common.config.ConfigDef.Type.INT;
+import static org.apache.kafka.common.config.ConfigDef.Type.LONG;
+
+/**
+ * This class defines the configuration of topic based {@link org.apache.kafka.server.log.remote.storage.RemoteLogMetadataManager} implementation.
+ */
+public final class TopicBasedRemoteLogMetadataManagerConfig {
+ private static final Logger log = LoggerFactory.getLogger(TopicBasedRemoteLogMetadataManagerConfig.class.getName());
+
+ public static final String REMOTE_LOG_METADATA_TOPIC_NAME = "__remote_log_metadata";
+
+ public static final String REMOTE_LOG_METADATA_TOPIC_REPLICATION_FACTOR_PROP = "remote.log.metadata.topic.replication.factor";
+ public static final String REMOTE_LOG_METADATA_TOPIC_PARTITIONS_PROP = "remote.log.metadata.topic.num.partitions";
+ public static final String REMOTE_LOG_METADATA_TOPIC_RETENTION_MILLIS_PROP = "remote.log.metadata.topic.retention.ms";
Review comment:
MILLIS => MS to be consistent with other places. Ditto in a few other places.
##########
File path: storage/src/main/java/org/apache/kafka/server/log/remote/metadata/storage/TopicBasedRemoteLogMetadataManager.java
##########
@@ -0,0 +1,360 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.kafka.server.log.remote.metadata.storage;
+
+import org.apache.kafka.clients.producer.RecordMetadata;
+import org.apache.kafka.common.KafkaException;
+import org.apache.kafka.common.TopicIdPartition;
+import org.apache.kafka.common.errors.RetriableException;
+import org.apache.kafka.common.utils.KafkaThread;
+import org.apache.kafka.common.utils.Time;
+import org.apache.kafka.common.utils.Utils;
+import org.apache.kafka.server.log.remote.storage.RemoteLogMetadata;
+import org.apache.kafka.server.log.remote.storage.RemoteLogMetadataManager;
+import org.apache.kafka.server.log.remote.storage.RemoteLogSegmentMetadata;
+import org.apache.kafka.server.log.remote.storage.RemoteLogSegmentMetadataUpdate;
+import org.apache.kafka.server.log.remote.storage.RemoteLogSegmentState;
+import org.apache.kafka.server.log.remote.storage.RemotePartitionDeleteMetadata;
+import org.apache.kafka.server.log.remote.storage.RemoteStorageException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+/**
+ * This is the {@link RemoteLogMetadataManager} implementation with storage as an internal topic with name {@link TopicBasedRemoteLogMetadataManagerConfig#REMOTE_LOG_METADATA_TOPIC_NAME}.
+ * This is used to publish and fetch {@link RemoteLogMetadata} for the registered user topic partitions with
+ * {@link #onPartitionLeadershipChanges(Set, Set)}. Each broker will have an instance of this class and it subscribes
+ * to metadata updates for the registered user topic partitions.
+ */
+public class TopicBasedRemoteLogMetadataManager implements RemoteLogMetadataManager {
+ private static final Logger log = LoggerFactory.getLogger(TopicBasedRemoteLogMetadataManager.class);
+
+ private volatile boolean configured = false;
+
+ // It indicates whether the close process of this instance is started or not via #close() method.
+ // Using AtomicBoolean instead of volatile as it may encounter http://findbugs.sourceforge.net/bugDescriptions.html#SP_SPIN_ON_FIELD
+ // if the field is read but not updated in a spin loop like in #initializeResources() method.
+ private final AtomicBoolean closing = new AtomicBoolean(false);
+ private final AtomicBoolean initialized = new AtomicBoolean(false);
+
+ private Thread initializationThread;
+ private Time time = Time.SYSTEM;
+ private volatile ProducerManager producerManager;
+ private volatile ConsumerManager consumerManager;
+
+ // This allows to gracefully close this instance using {@link #close()} method while there are some pending or new
+ // requests calling different methods which use the resources like producer/consumer managers.
+ private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+
+ private final RemotePartitionMetadataStore remotePartitionMetadataStore = new RemotePartitionMetadataStore();
+ private volatile TopicBasedRemoteLogMetadataManagerConfig rlmmConfig;
+ private RemoteLogMetadataTopicPartitioner rlmmTopicPartitioner;
+
+ public TopicBasedRemoteLogMetadataManager() {
+ }
+
+ // Visible for testing.
+ public TopicBasedRemoteLogMetadataManager(Time time) {
+ this.time = time;
+ }
+
+ @Override
+ public void addRemoteLogSegmentMetadata(RemoteLogSegmentMetadata remoteLogSegmentMetadata)
+ throws RemoteStorageException {
+ Objects.requireNonNull(remoteLogSegmentMetadata, "remoteLogSegmentMetadata can not be null");
+
+ // This allows gracefully rejecting the requests while closing of this instance is in progress, which triggers
+ // closing the producer/consumer manager instances.
+ lock.readLock().lock();
+ try {
+ ensureInitializedAndNotClosed();
+
+ // This method is allowed only to add remote log segment with the initial state(which is RemoteLogSegmentState.COPY_SEGMENT_STARTED)
+ // but not to update the existing remote log segment metadata.
+ if (remoteLogSegmentMetadata.state() != RemoteLogSegmentState.COPY_SEGMENT_STARTED) {
+ throw new IllegalArgumentException(
+ "Given remoteLogSegmentMetadata should have state as " + RemoteLogSegmentState.COPY_SEGMENT_STARTED
+ + " but it contains state as: " + remoteLogSegmentMetadata.state());
+ }
+
+ // Publish the message to the topic.
+ doPublishMetadata(remoteLogSegmentMetadata.remoteLogSegmentId().topicIdPartition(),
+ remoteLogSegmentMetadata);
+ } finally {
+ lock.readLock().unlock();
+ }
+ }
+
+ @Override
+ public void updateRemoteLogSegmentMetadata(RemoteLogSegmentMetadataUpdate segmentMetadataUpdate)
+ throws RemoteStorageException {
+ Objects.requireNonNull(segmentMetadataUpdate, "segmentMetadataUpdate can not be null");
+
+ lock.readLock().lock();
+ try {
+ ensureInitializedAndNotClosed();
+
+ // Callers should use addRemoteLogSegmentMetadata to add RemoteLogSegmentMetadata with state as
+ // RemoteLogSegmentState.COPY_SEGMENT_STARTED.
+ if (segmentMetadataUpdate.state() == RemoteLogSegmentState.COPY_SEGMENT_STARTED) {
+ throw new IllegalArgumentException("Given remoteLogSegmentMetadata should not have the state as: "
+ + RemoteLogSegmentState.COPY_SEGMENT_STARTED);
+ }
+
+ // Publish the message to the topic.
+ doPublishMetadata(segmentMetadataUpdate.remoteLogSegmentId().topicIdPartition(), segmentMetadataUpdate);
+ } finally {
+ lock.readLock().unlock();
+ }
+ }
+
+ @Override
+ public void putRemotePartitionDeleteMetadata(RemotePartitionDeleteMetadata remotePartitionDeleteMetadata)
+ throws RemoteStorageException {
+ Objects.requireNonNull(remotePartitionDeleteMetadata, "remotePartitionDeleteMetadata can not be null");
+
+ lock.readLock().lock();
+ try {
+ ensureInitializedAndNotClosed();
+
+ doPublishMetadata(remotePartitionDeleteMetadata.topicIdPartition(), remotePartitionDeleteMetadata);
+ } finally {
+ lock.readLock().unlock();
+ }
+ }
+
+ private void doPublishMetadata(TopicIdPartition topicIdPartition, RemoteLogMetadata remoteLogMetadata)
+ throws RemoteStorageException {
+ log.debug("Publishing metadata for partition: [{}] with context: [{}]", topicIdPartition, remoteLogMetadata);
+
+ try {
+ // Publish the message to the topic.
+ RecordMetadata recordMetadata = producerManager.publishMessage(
+ remoteLogMetadata);
+ // Wait until the consumer catches up with this offset. This will ensure read-after-write consistency
+ // semantics.
+ consumerManager.waitTillConsumptionCatchesUp(recordMetadata);
+ } catch (KafkaException e) {
+ if (e instanceof RetriableException) {
+ throw e;
+ } else {
+ throw new RemoteStorageException(e);
+ }
+ }
+ }
+
+ @Override
+ public Optional<RemoteLogSegmentMetadata> remoteLogSegmentMetadata(TopicIdPartition topicIdPartition,
+ int epochForOffset,
+ long offset)
+ throws RemoteStorageException {
+ lock.readLock().lock();
+ try {
+ ensureInitializedAndNotClosed();
+
+ return remotePartitionMetadataStore.remoteLogSegmentMetadata(topicIdPartition, offset, epochForOffset);
+ } finally {
+ lock.readLock().unlock();
+ }
+ }
+
+ @Override
+ public Optional<Long> highestOffsetForEpoch(TopicIdPartition topicIdPartition,
+ int leaderEpoch)
+ throws RemoteStorageException {
+ lock.readLock().lock();
+ try {
+
+ ensureInitializedAndNotClosed();
+
+ return remotePartitionMetadataStore.highestLogOffset(topicIdPartition, leaderEpoch);
+ } finally {
+ lock.readLock().unlock();
+ }
+
+ }
+
+ @Override
+ public Iterator<RemoteLogSegmentMetadata> listRemoteLogSegments(TopicIdPartition topicIdPartition)
+ throws RemoteStorageException {
+ Objects.requireNonNull(topicIdPartition, "topicIdPartition can not be null");
+
+ lock.readLock().lock();
+ try {
+ ensureInitializedAndNotClosed();
+
+ return remotePartitionMetadataStore.listRemoteLogSegments(topicIdPartition);
+ } finally {
+ lock.readLock().unlock();
+ }
+ }
+
+ @Override
+ public Iterator<RemoteLogSegmentMetadata> listRemoteLogSegments(TopicIdPartition topicIdPartition, int leaderEpoch)
+ throws RemoteStorageException {
+ Objects.requireNonNull(topicIdPartition, "topicIdPartition can not be null");
+
+ lock.readLock().lock();
+ try {
+ ensureInitializedAndNotClosed();
+
+ return remotePartitionMetadataStore.listRemoteLogSegments(topicIdPartition, leaderEpoch);
+ } finally {
+ lock.readLock().unlock();
+ }
+ }
+
+ public int metadataPartition(TopicIdPartition topicIdPartition) {
+ return rlmmTopicPartitioner.metadataPartition(topicIdPartition);
+ }
+
+ // Visible For Testing
+ public Optional<Long> receivedOffsetForPartition(int metadataPartition) {
+ return consumerManager.receivedOffsetForPartition(metadataPartition);
+ }
+
+ @Override
+ public void onPartitionLeadershipChanges(Set<TopicIdPartition> leaderPartitions,
+ Set<TopicIdPartition> followerPartitions) {
+ Objects.requireNonNull(leaderPartitions, "leaderPartitions can not be null");
+ Objects.requireNonNull(followerPartitions, "followerPartitions can not be null");
+
+ lock.readLock().lock();
+ try {
+ ensureInitializedAndNotClosed();
+
+ log.info("Received leadership notifications with leader partitions {} and follower partitions {}",
+ leaderPartitions, followerPartitions);
+
+ HashSet<TopicIdPartition> allPartitions = new HashSet<>(leaderPartitions);
+ allPartitions.addAll(followerPartitions);
+ consumerManager.addAssignmentsForPartitions(allPartitions);
+ } finally {
+ lock.readLock().unlock();
+ }
+ }
+
+ @Override
+ public void onStopPartitions(Set<TopicIdPartition> partitions) {
+ lock.readLock().lock();
+ try {
+ ensureInitializedAndNotClosed();
+ consumerManager.removeAssignmentsForPartitions(partitions);
+ } finally {
+ lock.readLock().unlock();
+ }
+ }
+
+ @Override
+ public void configure(Map<String, ?> configs) {
+ Objects.requireNonNull(configs, "configs can not be null.");
+
+ lock.writeLock().lock();
+ try {
+ if (configured) {
+ log.info("Skipping configure as it is already configured.");
+ return;
+ }
+
+ log.info("Started initializing with configs: {}", configs);
+
+ rlmmConfig = new TopicBasedRemoteLogMetadataManagerConfig(configs);
+ rlmmTopicPartitioner = new RemoteLogMetadataTopicPartitioner(rlmmConfig.metadataTopicPartitionsCount());
+ configured = true;
+ log.info("Successfully initialized with rlmmConfig: {}", rlmmConfig);
+
+ // Scheduling the initialization producer/consumer managers in a separate thread. Required resources may
+ // not yet be available now. This thread makes sure that it is retried at regular intervals until it is
+ // successful.
+ initializationThread = KafkaThread.daemon("RLMMInitializationThread", () -> initializeResources());
Review comment:
Why do we need to initialize in a separate thread?
##########
File path: storage/src/main/java/org/apache/kafka/server/log/remote/metadata/storage/ConsumerManager.java
##########
@@ -0,0 +1,130 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.kafka.server.log.remote.metadata.storage;
+
+import org.apache.kafka.clients.consumer.KafkaConsumer;
+import org.apache.kafka.clients.producer.RecordMetadata;
+import org.apache.kafka.common.KafkaException;
+import org.apache.kafka.common.TopicIdPartition;
+import org.apache.kafka.common.utils.KafkaThread;
+import org.apache.kafka.common.utils.Time;
+import org.apache.kafka.common.utils.Utils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.Optional;
+import java.util.Set;
+
+/**
+ * This class manages the consumer thread viz {@link ConsumerTask} that polls messages from the assigned metadata topic partitions.
+ * It also provides a way to wait until the given record is received by the consumer before it is timed out with an interval of
+ * {@link TopicBasedRemoteLogMetadataManagerConfig#consumeWaitMs()}.
+ */
+public class ConsumerManager implements Closeable {
+
+ private static final Logger log = LoggerFactory.getLogger(ConsumerManager.class);
+ private static final long CONSUME_RECHECK_INTERVAL_MS = 50L;
+
+ private final TopicBasedRemoteLogMetadataManagerConfig rlmmConfig;
+ private final Time time;
+ private final ConsumerTask consumerTask;
+ private final Thread consumerTaskThread;
+
+ public ConsumerManager(TopicBasedRemoteLogMetadataManagerConfig rlmmConfig,
+ RemotePartitionMetadataEventHandler remotePartitionMetadataEventHandler,
+ RemoteLogMetadataTopicPartitioner rlmmTopicPartitioner,
+ Time time) {
+ this.rlmmConfig = rlmmConfig;
+ this.time = time;
+
+ //Create a task to consume messages and submit the respective events to RemotePartitionMetadataEventHandler.
+ KafkaConsumer<byte[], byte[]> consumer = new KafkaConsumer<>(rlmmConfig.consumerProperties());
+ consumerTask = new ConsumerTask(consumer, remotePartitionMetadataEventHandler, rlmmTopicPartitioner);
+ consumerTaskThread = KafkaThread.daemon("RLMMConsumerTask", consumerTask);
+ }
+
+ public void startConsumerThread() {
+ try {
+ // Start a thread to continuously consume records from topic partitions.
+ consumerTaskThread.start();
+ } catch (Exception e) {
+ throw new KafkaException("Error encountered while initializing and scheduling ConsumerTask thread", e);
+ }
+ }
+
+ /**
+ * Wait until the consumption reaches the offset of the metadata partition for the given {@code recordMetadata}.
+ *
+ * @param recordMetadata record metadata to be checked for consumption.
+ */
+ public void waitTillConsumptionCatchesUp(RecordMetadata recordMetadata) {
+ final int partition = recordMetadata.partition();
+
+ // If the current assignment does not have the subscription for this partition then return immediately.
+ if (!consumerTask.isPartitionAssigned(partition)) {
+ log.warn("This consumer is not subscribed to the target partition [{}] on which message is produced.",
+ partition);
+ return;
+ }
+
+ final long offset = recordMetadata.offset();
+ long startTimeMs = time.milliseconds();
+ while (true) {
+ long committedOffset = consumerTask.receivedOffsetForPartition(partition).orElse(-1L);
+ if (committedOffset >= offset) {
+ break;
+ }
+
+ log.debug("Committed offset [{}] for partition [{}], but the target offset: [{}], Sleeping for [{}] to retry again",
+ offset, partition, committedOffset, CONSUME_RECHECK_INTERVAL_MS);
+
+ if (time.milliseconds() - startTimeMs > rlmmConfig.consumeWaitMs()) {
+ log.warn("Committed offset for partition:[{}] is : [{}], but the target offset: [{}] ",
Review comment:
Similar to the above, should we throw an exception in this case so that the caller knows the operation has failed?
##########
File path: storage/src/test/java/org/apache/kafka/server/log/remote/metadata/storage/TopicBasedRemoteLogMetadataManagerTest.java
##########
@@ -0,0 +1,132 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.kafka.server.log.remote.metadata.storage;
+
+import org.apache.kafka.common.TopicIdPartition;
+import org.apache.kafka.common.TopicPartition;
+import org.apache.kafka.common.Uuid;
+import org.apache.kafka.common.utils.MockTime;
+import org.apache.kafka.common.utils.Time;
+import org.apache.kafka.common.utils.Utils;
+import org.apache.kafka.server.log.remote.storage.RemoteLogSegmentId;
+import org.apache.kafka.server.log.remote.storage.RemoteLogSegmentMetadata;
+import org.apache.kafka.server.log.remote.storage.RemoteStorageException;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.Map;
+import java.util.concurrent.TimeoutException;
+
+import static org.apache.kafka.server.log.remote.metadata.storage.TopicBasedRemoteLogMetadataManagerConfig.REMOTE_LOG_METADATA_CONSUME_WAIT_MS_PROP;
+
+public class TopicBasedRemoteLogMetadataManagerTest {
+ private static final Logger log = LoggerFactory.getLogger(TopicBasedRemoteLogMetadataManagerTest.class);
+
+ private static final int SEG_SIZE = 1024 * 1024;
+
+ private final Time time = new MockTime(1);
+ private final TopicBasedRemoteLogMetadataManagerHarness remoteLogMetadataManagerHarness = new TopicBasedRemoteLogMetadataManagerHarness() {
+ @Override
+ protected Map<String, Object> overrideRemoteLogMetadataManagerProps() {
+ return Collections.singletonMap(REMOTE_LOG_METADATA_CONSUME_WAIT_MS_PROP, 5000L);
+ }
+ };
+
+ @BeforeEach
+ public void setup() {
+ // Start the cluster and initialize TopicBasedRemoteLogMetadataManager.
+ remoteLogMetadataManagerHarness.initialize(Collections.emptySet());
+ }
+
+ @AfterEach
+ public void teardown() throws IOException {
+ remoteLogMetadataManagerHarness.close();
+ }
+
+ public TopicBasedRemoteLogMetadataManager topicBasedRlmm() {
+ return remoteLogMetadataManagerHarness.topicBasedRlmm();
+ }
+
+ @Test
+ public void testNewPartitionUpdates() throws Exception {
+ final TopicIdPartition newLeaderTopicIdPartition = new TopicIdPartition(Uuid.randomUuid(), new TopicPartition("new-leader", 0));
+ final TopicIdPartition newFollowerTopicIdPartition = new TopicIdPartition(Uuid.randomUuid(), new TopicPartition("new-follower", 0));
+
+ // Add segments for these partitions but they are not available as they have not yet been subscribed.
+ RemoteLogSegmentMetadata leaderSegmentMetadata = new RemoteLogSegmentMetadata(new RemoteLogSegmentId(newLeaderTopicIdPartition, Uuid.randomUuid()),
+ 0, 100, -1L, 0,
+ time.milliseconds(), SEG_SIZE, Collections.singletonMap(0, 0L));
+ topicBasedRlmm().addRemoteLogSegmentMetadata(leaderSegmentMetadata);
+
+ RemoteLogSegmentMetadata followerSegmentMetadata = new RemoteLogSegmentMetadata(new RemoteLogSegmentId(newFollowerTopicIdPartition, Uuid.randomUuid()),
+ 0, 100, -1L, 0,
+ time.milliseconds(), SEG_SIZE, Collections.singletonMap(0, 0L));
+ topicBasedRlmm().addRemoteLogSegmentMetadata(followerSegmentMetadata);
+
+ // `listRemoteLogSegments` will receive an exception as these topic partitions are not yet registered.
+ Assertions.assertThrows(RemoteStorageException.class, () -> topicBasedRlmm().listRemoteLogSegments(newLeaderTopicIdPartition));
+ Assertions.assertThrows(RemoteStorageException.class, () -> topicBasedRlmm().listRemoteLogSegments(newFollowerTopicIdPartition));
+
+ topicBasedRlmm().onPartitionLeadershipChanges(Collections.singleton(newLeaderTopicIdPartition),
+ Collections.singleton(newFollowerTopicIdPartition));
+
+ waitUntilConsumerCatchesup(newLeaderTopicIdPartition, newFollowerTopicIdPartition, 30000L);
+
+ Assertions.assertTrue(topicBasedRlmm().listRemoteLogSegments(newLeaderTopicIdPartition).hasNext());
+ Assertions.assertTrue(topicBasedRlmm().listRemoteLogSegments(newFollowerTopicIdPartition).hasNext());
+ }
+
+ private void waitUntilConsumerCatchesup(TopicIdPartition newLeaderTopicIdPartition,
+ TopicIdPartition newFollowerTopicIdPartition,
+ long timeoutMs) throws TimeoutException {
+ int leaderMetadataPartition = topicBasedRlmm().metadataPartition(newLeaderTopicIdPartition);
+ int followerMetadataPartition = topicBasedRlmm().metadataPartition(newFollowerTopicIdPartition);
+
+ log.debug("Metadata partition for newLeaderTopicIdPartition: [{}], is: [{}]", newLeaderTopicIdPartition, leaderMetadataPartition);
+ log.debug("Metadata partition for newFollowerTopicIdPartition: [{}], is: [{}]", newFollowerTopicIdPartition, followerMetadataPartition);
+
+ long sleepMs = 100L;
+ long time = System.currentTimeMillis();
+
+ while (true) {
+ if (System.currentTimeMillis() - time > timeoutMs) {
+ throw new TimeoutException("Timed out after " + timeoutMs + "ms ");
+ }
+
+ if (leaderMetadataPartition == followerMetadataPartition) {
+ if (topicBasedRlmm().receivedOffsetForPartition(leaderMetadataPartition).orElse(-1L) > 0) {
+ break;
+ }
+ } else {
+ if (topicBasedRlmm().receivedOffsetForPartition(leaderMetadataPartition).orElse(-1L) > -1 ||
Review comment:
Why are we testing against -1 here but 0 above?
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: jira-unsubscribe@kafka.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org