You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@kafka.apache.org by li...@apache.org on 2026/09/09 17:09:38 UTC
(kafka) branch 4.4 updated: KAFKA-21010 Another busy loop happens if the member is in JOINING state and bootstrap DNS resolution is not finished (#23348)
This is an automated email from the ASF dual-hosted git repository.
lianetm pushed a commit to branch 4.4
in repository https://gitbox.apache.org/repos/asf/kafka.git
The following commit(s) were added to refs/heads/4.4 by this push:
new d12e95da902 KAFKA-21010 Another busy loop happens if the member is in JOINING state and bootstrap DNS resolution is not finished (#23348)
d12e95da902 is described below
commit d12e95da90259dd063cd736d9a9d579c54bf182e
Author: Ken Huang <s7...@gmail.com>
AuthorDate: Thu Sep 10 00:58:31 2026 +0800
KAFKA-21010 Another busy loop happens if the member is in JOINING state and bootstrap DNS resolution is not finished (#23348)
Follow-up to (#23227).
Before bootstrap DNS resolution completes,
`coordinatorRequestManager.coordinator()` is empty, causing the
coordinator-unknown path in `maximumTimeToWait()` to return
`heartbeatRequestState.heartbeatIntervalMs()`. However, the heartbeat
interval is initialized to 0 and is not updated until the first
heartbeat response is received. As a result, a member in the JOINING
state reports `maximumTimeToWait() == 0`.
Since the application thread's poll timeout is bounded by this value,
both the application and network threads can busy-spin until the
coordinator is discovered.
Returning `retryBackoffMs` aligns with the behavior discussed in #23227.
Until the coordinator is discovered, no heartbeat can be sent, making
this equivalent to the "nothing to send right now, wait for a backoff"
case for which `FetchRequestManager#maximumTimeToWait()` already returns
the retry backoff. Coordinator discovery itself is also paced by the
coordinator manager's backoff.
Reviewers: Lianet Magrans <lm...@confluent.io>
---
checkstyle/suppressions.xml | 2 +-
.../internals/AbstractHeartbeatRequestManager.java | 30 +++--
.../consumer/internals/CommitRequestManager.java | 9 +-
.../consumer/internals/HeartbeatRequestState.java | 4 +
.../StreamsGroupHeartbeatRequestManager.java | 4 +-
.../AbstractHeartbeatRequestManagerTest.java | 2 +-
.../internals/CommitRequestManagerTest.java | 12 +-
.../ConsumerHeartbeatRequestManagerTest.java | 122 ++++++++++++++++++++-
.../ShareHeartbeatRequestManagerTest.java | 35 +++++-
.../StreamsGroupHeartbeatRequestManagerTest.java | 8 +-
10 files changed, 199 insertions(+), 29 deletions(-)
diff --git a/checkstyle/suppressions.xml b/checkstyle/suppressions.xml
index d003eca5c93..b3fd9b27ade 100644
--- a/checkstyle/suppressions.xml
+++ b/checkstyle/suppressions.xml
@@ -86,7 +86,7 @@
<!-- Clients tests -->
<suppress checks="ClassDataAbstractionCoupling"
- files="(Sender|Fetcher|FetchRequestManager|OffsetFetcher|KafkaConsumer|Metrics|RequestResponse|TransactionManager|KafkaAdminClient|Message|KafkaProducer|CommitRequestManager)Test.java"/>
+ files="(Sender|Fetcher|FetchRequestManager|OffsetFetcher|KafkaConsumer|Metrics|RequestResponse|TransactionManager|KafkaAdminClient|Message|KafkaProducer|CommitRequestManager|ConsumerHeartbeatRequestManager)Test.java"/>
<suppress checks="ClassFanOutComplexity"
files="(ConsumerCoordinator|KafkaConsumer|RequestResponse|Fetcher|FetchRequestManager|KafkaAdminClient|Message|KafkaProducer|NetworkClient|StreamsGroupHeartbeatRequestManager|CommitRequestManager)Test.java"/>
diff --git a/clients/src/main/java/org/apache/kafka/clients/consumer/internals/AbstractHeartbeatRequestManager.java b/clients/src/main/java/org/apache/kafka/clients/consumer/internals/AbstractHeartbeatRequestManager.java
index 8226d39535a..ef00f1d82e5 100644
--- a/clients/src/main/java/org/apache/kafka/clients/consumer/internals/AbstractHeartbeatRequestManager.java
+++ b/clients/src/main/java/org/apache/kafka/clients/consumer/internals/AbstractHeartbeatRequestManager.java
@@ -245,27 +245,35 @@ public abstract class AbstractHeartbeatRequestManager<R extends AbstractResponse
* <p>Similarly, we may have to unblock the application thread to send a {@link AsyncPollEvent} to make sure
* our poll timer will not expire while we are polling.
*
- * <p>When the member is {@link MemberState#UNSUBSCRIBED} (for example, with manual assignment),
- * this returns {@code Long.MAX_VALUE} to indicate there is no next heartbeat to wait for,
- * allowing the application thread to block for the full user-specified poll timeout rather than
- * spinning in a busy loop.
+ * <p>When the member is {@link MemberState#UNSUBSCRIBED} or in the terminal {@link MemberState#FATAL} state,
+ * this returns {@code Long.MAX_VALUE} to indicate there is no next heartbeat to wait for, allowing the application
+ * thread to block for the full user-specified poll timeout rather than spinning in a busy loop.
*/
@Override
public long maximumTimeToWait(long currentTimeMs) {
pollTimer.update(currentTimeMs);
- if (membershipManager().state() == MemberState.UNSUBSCRIBED) {
+ MemberState state = membershipManager().state();
+ // No heartbeat can be sent in these states: UNSUBSCRIBED has nothing to heartbeat for,
+ // and FATAL is terminal. The fatal error has already been propagated to the
+ // application thread, so there is no need to wake it before its poll timeout expires.
+ if (state == MemberState.UNSUBSCRIBED || state == MemberState.FATAL) {
return Long.MAX_VALUE;
}
+ // Unblock the application thread so STALE/FENCED members can run
+ // assignment-release callbacks and rejoin during the next poll.
if (pollTimer.isExpired()) {
return 0L;
}
- // KAFKA-20253: mirror the guard in poll(). A heartbeat is only sent when the coordinator is known
- // and the member is in a state that heartbeats. When the coordinator is unavailable (e.g. after a
- // re-authentication failure) or the member should skip heartbeats (FATAL/FENCED/STALE/UNSUBSCRIBED),
- // poll() returns EMPTY, so falling through to the timer-based branches below would return 0 (the
- // heartbeat timer is left permanently expired) and busy-spin both the application and network threads.
+ // Mirror the guard in poll(). A heartbeat is only sent when the coordinator is known and the
+ // member is in a state that can send heartbeats. This covers cases such as:
+ // - The coordinator is unavailable (for example, during bootstrap DNS resolution or after a
+ // re-authentication failure).
+ // - The member is FENCED (or STALE with the poll timer already reset) and waiting for the
+ // application thread to run assignment-release callbacks before rejoining.
+ // Return retryBackoffMs rather than the heartbeat interval, since the interval remains 0 until
+ // the first heartbeat response is received, which would also lead to busy-spinning.
if (coordinatorRequestManager.coordinator().isEmpty() || membershipManager().shouldSkipHeartbeat()) {
- return heartbeatRequestState.heartbeatIntervalMs();
+ return heartbeatRequestState.retryBackoffMs();
}
if (membershipManager().shouldHeartbeatNow() && !heartbeatRequestState.requestInFlight()) {
return 0L;
diff --git a/clients/src/main/java/org/apache/kafka/clients/consumer/internals/CommitRequestManager.java b/clients/src/main/java/org/apache/kafka/clients/consumer/internals/CommitRequestManager.java
index 1324ece542f..8360c746bfc 100644
--- a/clients/src/main/java/org/apache/kafka/clients/consumer/internals/CommitRequestManager.java
+++ b/clients/src/main/java/org/apache/kafka/clients/consumer/internals/CommitRequestManager.java
@@ -229,9 +229,10 @@ public class CommitRequestManager implements RequestManager, MemberStateListener
// If the coordinator is unavailable (e.g. bootstrap DNS resolution is still in progress),
// falling through to the timer-based remainingMs() would return 0 once the auto-commit interval
// elapses, since the auto-commit timer remains permanently expired. This would cause both the
- // application and network threads to busy-spin.
+ // application and network threads to busy-spin. Wait a retry backoff instead of the auto-commit
+ // interval, which may be configured to zero and is consistent with the other request managers.
if (coordinatorRequestManager.coordinator().isEmpty()) {
- return autoCommit.autoCommitIntervalMs();
+ return retryBackoffMs;
}
return autoCommit.remainingMs(currentTimeMs);
}
@@ -1576,10 +1577,6 @@ public class CommitRequestManager implements RequestManager, MemberStateListener
public void setInflightCommitStatus(final boolean inflightCommitStatus) {
this.hasInflightCommit = inflightCommitStatus;
}
-
- public long autoCommitIntervalMs() {
- return autoCommitInterval;
- }
}
static class MemberInfo {
diff --git a/clients/src/main/java/org/apache/kafka/clients/consumer/internals/HeartbeatRequestState.java b/clients/src/main/java/org/apache/kafka/clients/consumer/internals/HeartbeatRequestState.java
index bdb66c4a10d..d43e956ddb9 100644
--- a/clients/src/main/java/org/apache/kafka/clients/consumer/internals/HeartbeatRequestState.java
+++ b/clients/src/main/java/org/apache/kafka/clients/consumer/internals/HeartbeatRequestState.java
@@ -60,6 +60,10 @@ public class HeartbeatRequestState extends RequestState {
return heartbeatIntervalMs;
}
+ public long retryBackoffMs() {
+ return exponentialBackoff.initialInterval();
+ }
+
public void resetTimer() {
this.heartbeatTimer.reset(heartbeatIntervalMs);
}
diff --git a/clients/src/main/java/org/apache/kafka/clients/consumer/internals/StreamsGroupHeartbeatRequestManager.java b/clients/src/main/java/org/apache/kafka/clients/consumer/internals/StreamsGroupHeartbeatRequestManager.java
index 580cd9289e9..857c86eba1a 100644
--- a/clients/src/main/java/org/apache/kafka/clients/consumer/internals/StreamsGroupHeartbeatRequestManager.java
+++ b/clients/src/main/java/org/apache/kafka/clients/consumer/internals/StreamsGroupHeartbeatRequestManager.java
@@ -539,8 +539,10 @@ public class StreamsGroupHeartbeatRequestManager implements RequestManager {
// shouldNotWaitForHeartbeatInterval() check would return 0 whenever the member wants to
// (re)join. Because no heartbeat can be sent until the coordinator is discovered, the
// condition remains true and both the application and network threads end up busy-spinning.
+ // Wait a retry backoff rather than the heartbeat interval, because the interval is zero
+ // until the first heartbeat response is received, which would also busy-spin.
if (coordinatorRequestManager.coordinator().isEmpty() || membershipManager.shouldSkipHeartbeat()) {
- return heartbeatRequestState.heartbeatIntervalMs();
+ return heartbeatRequestState.retryBackoffMs();
}
if (membershipManager.shouldNotWaitForHeartbeatInterval() && !heartbeatRequestState.requestInFlight()) {
return 0L;
diff --git a/clients/src/test/java/org/apache/kafka/clients/consumer/internals/AbstractHeartbeatRequestManagerTest.java b/clients/src/test/java/org/apache/kafka/clients/consumer/internals/AbstractHeartbeatRequestManagerTest.java
index a572ac2d2f8..122fa7c020c 100644
--- a/clients/src/test/java/org/apache/kafka/clients/consumer/internals/AbstractHeartbeatRequestManagerTest.java
+++ b/clients/src/test/java/org/apache/kafka/clients/consumer/internals/AbstractHeartbeatRequestManagerTest.java
@@ -118,7 +118,7 @@ abstract class AbstractHeartbeatRequestManagerTest<R extends AbstractResponse> {
NetworkClientDelegate.PollResult result = heartbeatRequestManager.poll(time.milliseconds());
assertEquals(Long.MAX_VALUE, result.timeUntilNextPollMs);
- assertEquals(DEFAULT_HEARTBEAT_INTERVAL_MS, heartbeatRequestManager.maximumTimeToWait(time.milliseconds()));
+ assertEquals(DEFAULT_RETRY_BACKOFF_MS, heartbeatRequestManager.maximumTimeToWait(time.milliseconds()));
assertEquals(0, result.unsentRequests.size());
}
diff --git a/clients/src/test/java/org/apache/kafka/clients/consumer/internals/CommitRequestManagerTest.java b/clients/src/test/java/org/apache/kafka/clients/consumer/internals/CommitRequestManagerTest.java
index 33863fcd765..1099b12f2a4 100644
--- a/clients/src/test/java/org/apache/kafka/clients/consumer/internals/CommitRequestManagerTest.java
+++ b/clients/src/test/java/org/apache/kafka/clients/consumer/internals/CommitRequestManagerTest.java
@@ -67,6 +67,7 @@ import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.ValueSource;
import org.mockito.Mockito;
import java.util.ArrayList;
@@ -741,9 +742,12 @@ public class CommitRequestManagerTest {
assertPoll(1, commitRequestManager);
}
- @Test
- public void testMaximumTimeToWaitWhenCoordinatorUnknownDoesNotSpin() {
- CommitRequestManager commitRequestManager = create(true, 100);
+ // The auto-commit interval may be configured to zero, so a retry backoff is used while the
+ // coordinator is unknown, consistently with the fetch and heartbeat request managers.
+ @ParameterizedTest
+ @ValueSource(longs = {0, 5000})
+ public void testMaximumTimeToWaitWhenCoordinatorUnknownDoesNotSpin(long autoCommitInterval) {
+ CommitRequestManager commitRequestManager = create(true, autoCommitInterval);
when(coordinatorRequestManager.coordinator()).thenReturn(Optional.empty());
time.sleep(100);
@@ -751,7 +755,7 @@ public class CommitRequestManagerTest {
assertTrue(result > 0,
"maximumTimeToWait must be > 0 when the coordinator is unknown to avoid a busy-spin; got " + result);
- assertEquals(100, result);
+ assertEquals(retryBackoffMs, result);
}
@Test
diff --git a/clients/src/test/java/org/apache/kafka/clients/consumer/internals/ConsumerHeartbeatRequestManagerTest.java b/clients/src/test/java/org/apache/kafka/clients/consumer/internals/ConsumerHeartbeatRequestManagerTest.java
index 5d3f6a7b285..27929bbd847 100644
--- a/clients/src/test/java/org/apache/kafka/clients/consumer/internals/ConsumerHeartbeatRequestManagerTest.java
+++ b/clients/src/test/java/org/apache/kafka/clients/consumer/internals/ConsumerHeartbeatRequestManagerTest.java
@@ -16,8 +16,13 @@
*/
package org.apache.kafka.clients.consumer.internals;
+import org.apache.kafka.clients.ApiVersions;
+import org.apache.kafka.clients.BootstrapConfiguration;
+import org.apache.kafka.clients.ClientDnsLookup;
import org.apache.kafka.clients.ClientResponse;
import org.apache.kafka.clients.Metadata;
+import org.apache.kafka.clients.MetadataRecoveryStrategy;
+import org.apache.kafka.clients.NetworkClient;
import org.apache.kafka.clients.consumer.CloseOptions;
import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.consumer.SubscriptionPattern;
@@ -25,13 +30,16 @@ import org.apache.kafka.clients.consumer.internals.AbstractMembershipManager.Loc
import org.apache.kafka.clients.consumer.internals.ConsumerHeartbeatRequestManager.HeartbeatState;
import org.apache.kafka.clients.consumer.internals.events.BackgroundEventHandler;
import org.apache.kafka.clients.consumer.internals.events.ErrorEvent;
+import org.apache.kafka.clients.consumer.internals.metrics.AsyncConsumerMetrics;
import org.apache.kafka.common.KafkaException;
import org.apache.kafka.common.Node;
import org.apache.kafka.common.Uuid;
import org.apache.kafka.common.errors.AuthenticationException;
+import org.apache.kafka.common.errors.BootstrapResolutionException;
import org.apache.kafka.common.errors.DisconnectException;
import org.apache.kafka.common.errors.TimeoutException;
import org.apache.kafka.common.errors.UnsupportedVersionException;
+import org.apache.kafka.common.internals.ClusterResourceListeners;
import org.apache.kafka.common.internals.UnsupportedProtocolFieldException;
import org.apache.kafka.common.message.ConsumerGroupHeartbeatRequestData;
import org.apache.kafka.common.message.ConsumerGroupHeartbeatResponseData;
@@ -46,6 +54,7 @@ import org.apache.kafka.common.serialization.StringDeserializer;
import org.apache.kafka.common.utils.MockTime;
import org.apache.kafka.common.utils.annotation.ApiKeyVersionsSource;
import org.apache.kafka.common.utils.internals.LogContext;
+import org.apache.kafka.test.MockSelector;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@@ -57,6 +66,7 @@ import org.mockito.ArgumentCaptor;
import org.mockito.InOrder;
import java.util.Collections;
+import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Properties;
@@ -323,7 +333,117 @@ public class ConsumerHeartbeatRequestManagerTest
assertTrue(result > 0,
"maximumTimeToWait must be > 0 when the coordinator is unavailable to avoid a busy-spin; got " + result);
- assertEquals(DEFAULT_HEARTBEAT_INTERVAL_MS, result);
+ assertEquals(DEFAULT_RETRY_BACKOFF_MS, result);
+ }
+
+ /**
+ * While bootstrap DNS resolution is still in progress the coordinator is unknown,
+ * and a member that wants to join has a zero heartbeat interval, since the interval is only
+ * learned from the first heartbeat response. maximumTimeToWait() must wait a retry backoff
+ * rather than the (zero) heartbeat interval; returning 0 busy-spins the application and
+ * network threads.
+ */
+ @Test
+ public void testMaximumTimeToWaitWhenJoiningAndCoordinatorUnknownDoesNotSpin() {
+ createHeartbeatRequestStateWithZeroHeartbeatInterval();
+ when(coordinatorRequestManager.coordinator()).thenReturn(Optional.empty());
+ when(membershipManager.state()).thenReturn(MemberState.JOINING);
+ when(membershipManager.shouldHeartbeatNow()).thenReturn(true);
+
+ long result = heartbeatRequestManager.maximumTimeToWait(time.milliseconds());
+
+ assertTrue(result > 0, "maximumTimeToWait must be > 0 while the member is joining and the coordinator is unknown to avoid a busy-spin; got " + result);
+ assertEquals(DEFAULT_RETRY_BACKOFF_MS, result);
+ }
+
+ @Test
+ public void testMaximumTimeToWaitWhenFatalReturnsMaxValue() {
+ createHeartbeatRequestStateWithZeroHeartbeatInterval();
+ when(membershipManager.state()).thenReturn(MemberState.FATAL);
+
+ assertEquals(Long.MAX_VALUE, heartbeatRequestManager.maximumTimeToWait(time.milliseconds()),
+ "maximumTimeToWait should return Long.MAX_VALUE in the terminal FATAL state");
+ }
+
+ @Test
+ public void testMaximumTimeToWaitWhenFencedWaitsRetryBackoff() {
+ createHeartbeatRequestStateWithZeroHeartbeatInterval();
+ when(membershipManager.state()).thenReturn(MemberState.FENCED);
+ when(membershipManager.shouldSkipHeartbeat()).thenReturn(true);
+
+ long result = heartbeatRequestManager.maximumTimeToWait(time.milliseconds());
+
+ assertTrue(result > 0, "maximumTimeToWait must be > 0 while the member is fenced to avoid a busy-spin; got " + result);
+ assertEquals(DEFAULT_RETRY_BACKOFF_MS, result);
+ }
+
+ @Test
+ public void testMaximumTimeToWaitDoesNotSpinDuringRealBootstrapDnsResolution() throws Exception {
+ long bootstrapResolveTimeoutMs = 1000;
+
+ BootstrapConfiguration bootstrapConfiguration = BootstrapConfiguration.enabled(
+ List.of("unresolvable.invalid:9092"),
+ ClientDnsLookup.USE_ALL_DNS_IPS,
+ bootstrapResolveTimeoutMs,
+ DEFAULT_RETRY_BACKOFF_MS
+ );
+
+ ConsumerConfig config = new ConsumerConfig(Map.of(
+ ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class,
+ ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class,
+ ConsumerConfig.GROUP_ID_CONFIG, DEFAULT_GROUP_ID,
+ ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "unresolvable.invalid:9092",
+ ConsumerConfig.MAX_POLL_INTERVAL_MS_CONFIG, String.valueOf(DEFAULT_MAX_POLL_INTERVAL_MS),
+ ConsumerConfig.RETRY_BACKOFF_MS_CONFIG, String.valueOf(DEFAULT_RETRY_BACKOFF_MS),
+ ConsumerConfig.RETRY_BACKOFF_MAX_MS_CONFIG, String.valueOf(DEFAULT_RETRY_BACKOFF_MAX_MS)
+ ));
+
+ ConsumerMetadata consumerMetadata = new ConsumerMetadata(config, subscriptions, logContext, new ClusterResourceListeners());
+
+ MockSelector selector = new MockSelector(time);
+ NetworkClient networkClient = new NetworkClient(selector, consumerMetadata, "test-client",
+ Integer.MAX_VALUE, 50, 1000, 64 * 1024, 64 * 1024, 1000, 5000, 30000,
+ time, false, new ApiVersions(), logContext,
+ MetadataRecoveryStrategy.NONE, bootstrapConfiguration, false);
+
+ CoordinatorRequestManager realCoordinatorRequestManager = new CoordinatorRequestManager(
+ logContext, DEFAULT_RETRY_BACKOFF_MS, DEFAULT_RETRY_BACKOFF_MAX_MS, DEFAULT_GROUP_ID);
+
+ // The member wants to join, but its heartbeat interval is still zero (unknown until the
+ // first heartbeat response).
+ createHeartbeatRequestStateWithZeroHeartbeatInterval();
+ when(membershipManager.state()).thenReturn(MemberState.JOINING);
+ when(membershipManager.shouldHeartbeatNow()).thenReturn(true);
+ ConsumerHeartbeatRequestManager realHeartbeatRequestManager = createHeartbeatRequestManager(
+ realCoordinatorRequestManager,
+ membershipManager,
+ heartbeatState,
+ heartbeatRequestState,
+ backgroundEventHandler);
+
+ try (NetworkClientDelegate networkClientDelegate = new NetworkClientDelegate(time, config, logContext, networkClient,
+ consumerMetadata, mock(BackgroundEventHandler.class), false, mock(AsyncConsumerMetrics.class))
+ ) {
+ long deadline = time.milliseconds() + bootstrapResolveTimeoutMs + 3000;
+ boolean sawBootstrapException = false;
+
+ while (time.milliseconds() < deadline) {
+ // Drives the real NetworkClient's ensureBootstrapped()/async DNS resolution forward;
+ // the coordinator never becomes known since there is no real broker to respond.
+ networkClientDelegate.poll(50, time.milliseconds());
+
+ long waitMs = realHeartbeatRequestManager.maximumTimeToWait(time.milliseconds());
+ assertTrue(waitMs > 0, "maximumTimeToWait must be > 0 while real bootstrap DNS resolution is pending; got " + waitMs);
+
+ Optional<Exception> metadataError = networkClientDelegate.getAndClearMetadataError();
+ if (metadataError.isPresent()) {
+ assertInstanceOf(BootstrapResolutionException.class, metadataError.get());
+ sawBootstrapException = true;
+ break;
+ }
+ }
+ assertTrue(sawBootstrapException, "Expected a real BootstrapResolutionException within " + (bootstrapResolveTimeoutMs + 3000) + "ms");
+ }
}
@Test
diff --git a/clients/src/test/java/org/apache/kafka/clients/consumer/internals/ShareHeartbeatRequestManagerTest.java b/clients/src/test/java/org/apache/kafka/clients/consumer/internals/ShareHeartbeatRequestManagerTest.java
index 0f125f09dfb..b9ef2091652 100644
--- a/clients/src/test/java/org/apache/kafka/clients/consumer/internals/ShareHeartbeatRequestManagerTest.java
+++ b/clients/src/test/java/org/apache/kafka/clients/consumer/internals/ShareHeartbeatRequestManagerTest.java
@@ -164,7 +164,7 @@ public class ShareHeartbeatRequestManagerTest
@Test
public void testMaximumTimeToWaitWhenHeartbeatShouldBeSkippedDoesNotSpin() {
when(coordinatorRequestManager.coordinator()).thenReturn(Optional.of(new Node(1, "localhost", 9999)));
- when(membershipManager.state()).thenReturn(MemberState.FATAL);
+ when(membershipManager.state()).thenReturn(MemberState.FENCED);
when(membershipManager.shouldSkipHeartbeat()).thenReturn(true);
when(heartbeatRequestState.timeToNextHeartbeatMs(anyLong())).thenReturn(0L);
@@ -172,7 +172,38 @@ public class ShareHeartbeatRequestManagerTest
assertTrue(result > 0,
"maximumTimeToWait must be > 0 while heartbeats are skipped to avoid a busy-spin; got " + result);
- assertEquals(DEFAULT_HEARTBEAT_INTERVAL_MS, result);
+ assertEquals(DEFAULT_RETRY_BACKOFF_MS, result);
+ }
+
+ @Test
+ public void testMaximumTimeToWaitWhenFatalReturnsMaxValue() {
+ when(coordinatorRequestManager.coordinator()).thenReturn(Optional.of(new Node(1, "localhost", 9999)));
+ when(membershipManager.state()).thenReturn(MemberState.FATAL);
+
+ assertEquals(Long.MAX_VALUE, heartbeatRequestManager.maximumTimeToWait(time.milliseconds()),
+ "maximumTimeToWait should return Long.MAX_VALUE in the terminal FATAL state");
+ }
+
+ /**
+ * While bootstrap DNS resolution is still in progress the coordinator is unknown,
+ * and a member that wants to join has a zero heartbeat interval, since the interval is only
+ * learned from the first heartbeat response. maximumTimeToWait() must wait a retry backoff
+ * rather than the (zero) heartbeat interval; returning 0 busy-spins the application and
+ * network threads.
+ */
+ @Test
+ public void testMaximumTimeToWaitWhenJoiningAndCoordinatorUnknownDoesNotSpin() {
+ createHeartbeatRequestStateWithZeroHeartbeatInterval();
+ when(coordinatorRequestManager.coordinator()).thenReturn(Optional.empty());
+ when(membershipManager.state()).thenReturn(MemberState.JOINING);
+ when(membershipManager.shouldHeartbeatNow()).thenReturn(true);
+
+ long result = heartbeatRequestManager.maximumTimeToWait(time.milliseconds());
+
+ assertTrue(result > 0,
+ "maximumTimeToWait must be > 0 while the member is joining and the coordinator is unknown " +
+ "to avoid a busy-spin; got " + result);
+ assertEquals(DEFAULT_RETRY_BACKOFF_MS, result);
}
@Test
diff --git a/clients/src/test/java/org/apache/kafka/clients/consumer/internals/StreamsGroupHeartbeatRequestManagerTest.java b/clients/src/test/java/org/apache/kafka/clients/consumer/internals/StreamsGroupHeartbeatRequestManagerTest.java
index 28f4df825ac..049d5ed0bc1 100644
--- a/clients/src/test/java/org/apache/kafka/clients/consumer/internals/StreamsGroupHeartbeatRequestManagerTest.java
+++ b/clients/src/test/java/org/apache/kafka/clients/consumer/internals/StreamsGroupHeartbeatRequestManagerTest.java
@@ -2577,11 +2577,15 @@ class StreamsGroupHeartbeatRequestManagerTest {
@Test
public void testMaximumTimeToWaitWhenCoordinatorUnknownDoesNotSpin() {
+ final long retryBackoffMs = 100L;
try (
final MockedConstruction<Timer> timerMockedConstruction = mockConstruction(Timer.class);
final MockedConstruction<HeartbeatRequestState> heartbeatRequestStateMockedConstruction = mockConstruction(
HeartbeatRequestState.class,
- (mock, context) -> when(mock.heartbeatIntervalMs()).thenReturn(6000L))
+ (mock, context) -> {
+ when(mock.heartbeatIntervalMs()).thenReturn(0L);
+ when(mock.retryBackoffMs()).thenReturn(retryBackoffMs);
+ })
) {
final StreamsGroupHeartbeatRequestManager heartbeatRequestManager = createStreamsGroupHeartbeatRequestManager();
when(coordinatorRequestManager.coordinator()).thenReturn(Optional.empty());
@@ -2589,7 +2593,7 @@ class StreamsGroupHeartbeatRequestManagerTest {
final long maximumTimeToWait = heartbeatRequestManager.maximumTimeToWait(time.milliseconds());
- assertEquals(6000L, maximumTimeToWait);
+ assertEquals(retryBackoffMs, maximumTimeToWait);
}
}