You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@kafka.apache.org by bo...@apache.org on 2021/01/16 04:37:41 UTC
[kafka] branch trunk updated: KAFKA-10674: Controller API version
bond with forwardable APIs (#9600)
This is an automated email from the ASF dual-hosted git repository.
boyang pushed a commit to branch trunk
in repository https://gitbox.apache.org/repos/asf/kafka.git
The following commit(s) were added to refs/heads/trunk by this push:
new bfc96ef KAFKA-10674: Controller API version bond with forwardable APIs (#9600)
bfc96ef is described below
commit bfc96efa3a9a004f963cd4913fb2875c84bc9cb8
Author: Boyang Chen <bo...@confluent.io>
AuthorDate: Fri Jan 15 20:36:25 2021 -0800
KAFKA-10674: Controller API version bond with forwardable APIs (#9600)
Get controller api version intersection setup for client queries. When the unsupported exception was hit in the EnvelopeResponse, close the client connection to let it rediscover the api version.
Reviewers: Jason Gustafson <ja...@confluent.io>
---
.../org/apache/kafka/clients/NodeApiVersions.java | 26 ++++----
.../kafka/clients/consumer/internals/Fetcher.java | 2 +-
.../producer/internals/TransactionManager.java | 2 +-
.../{clients => common/protocol}/ApiVersion.java | 15 ++++-
.../kafka/common/requests/ApiVersionsResponse.java | 43 +++++++++++++
.../apache/kafka/clients/NodeApiVersionsTest.java | 1 +
.../kafka/clients/admin/KafkaAdminClientTest.java | 2 +-
.../producer/internals/TransactionManagerTest.java | 2 +-
.../common/requests/ApiVersionsResponseTest.java | 38 +++++++++++
core/src/main/scala/kafka/api/ApiVersion.scala | 44 +++++++------
.../server/BrokerToControllerChannelManager.scala | 60 +++++++++++------
.../scala/kafka/server/ForwardingManager.scala | 49 ++++++++++----
core/src/main/scala/kafka/server/KafkaApis.scala | 54 +++++++++++-----
.../kafka/admin/BrokerApiVersionsCommandTest.scala | 16 +++--
.../BrokerToControllerRequestThreadTest.scala | 14 +++-
.../test/scala/unit/kafka/api/ApiVersionTest.scala | 12 ++--
.../unit/kafka/raft/KafkaNetworkChannelTest.scala | 4 +-
.../server/AbstractApiVersionsRequestTest.scala | 22 ++++++-
.../unit/kafka/server/ApiVersionsRequestTest.scala | 21 +++++-
.../unit/kafka/server/ForwardingManagerTest.scala | 48 +++++++++++++-
.../scala/unit/kafka/server/KafkaApisTest.scala | 75 +++++++++++++++++++++-
21 files changed, 444 insertions(+), 106 deletions(-)
diff --git a/clients/src/main/java/org/apache/kafka/clients/NodeApiVersions.java b/clients/src/main/java/org/apache/kafka/clients/NodeApiVersions.java
index e2727f5..30351c6 100644
--- a/clients/src/main/java/org/apache/kafka/clients/NodeApiVersions.java
+++ b/clients/src/main/java/org/apache/kafka/clients/NodeApiVersions.java
@@ -23,12 +23,14 @@ import org.apache.kafka.common.errors.UnsupportedVersionException;
import org.apache.kafka.common.message.ApiVersionsResponseData.ApiVersionsResponseKey;
import org.apache.kafka.common.message.ApiVersionsResponseData.ApiVersionsResponseKeyCollection;
import org.apache.kafka.common.protocol.ApiKeys;
+import org.apache.kafka.common.protocol.ApiVersion;
import org.apache.kafka.common.utils.Utils;
import java.util.ArrayList;
import java.util.EnumMap;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.TreeMap;
/**
@@ -123,21 +125,18 @@ public class NodeApiVersions {
* Get the latest version supported by the broker within an allowed range of versions
*/
public short latestUsableVersion(ApiKeys apiKey, short oldestAllowedVersion, short latestAllowedVersion) {
- ApiVersion usableVersion = supportedVersions.get(apiKey);
- if (usableVersion == null)
+ if (!supportedVersions.containsKey(apiKey))
throw new UnsupportedVersionException("The broker does not support " + apiKey);
- return latestUsableVersion(apiKey, usableVersion, oldestAllowedVersion, latestAllowedVersion);
- }
+ ApiVersion supportedVersion = supportedVersions.get(apiKey);
+ Optional<ApiVersion> intersectVersion = supportedVersion.intersect(
+ new ApiVersion(apiKey.id, oldestAllowedVersion, latestAllowedVersion));
- private short latestUsableVersion(ApiKeys apiKey, ApiVersion supportedVersions,
- short minAllowedVersion, short maxAllowedVersion) {
- short minVersion = (short) Math.max(minAllowedVersion, supportedVersions.minVersion);
- short maxVersion = (short) Math.min(maxAllowedVersion, supportedVersions.maxVersion);
- if (minVersion > maxVersion)
+ if (intersectVersion.isPresent())
+ return intersectVersion.get().maxVersion;
+ else
throw new UnsupportedVersionException("The broker does not support " + apiKey +
- " with version in range [" + minAllowedVersion + "," + maxAllowedVersion + "]. The supported" +
- " range is [" + supportedVersions.minVersion + "," + supportedVersions.maxVersion + "].");
- return maxVersion;
+ " with version in range [" + oldestAllowedVersion + "," + latestAllowedVersion + "]. The supported" +
+ " range is [" + supportedVersion.minVersion + "," + supportedVersion.maxVersion + "].");
}
/**
@@ -227,4 +226,7 @@ public class NodeApiVersions {
return supportedVersions.get(apiKey);
}
+ public Map<ApiKeys, ApiVersion> allSupportedApiVersions() {
+ return supportedVersions;
+ }
}
diff --git a/clients/src/main/java/org/apache/kafka/clients/consumer/internals/Fetcher.java b/clients/src/main/java/org/apache/kafka/clients/consumer/internals/Fetcher.java
index d5dbf22..14615cb 100644
--- a/clients/src/main/java/org/apache/kafka/clients/consumer/internals/Fetcher.java
+++ b/clients/src/main/java/org/apache/kafka/clients/consumer/internals/Fetcher.java
@@ -16,7 +16,7 @@
*/
package org.apache.kafka.clients.consumer.internals;
-import org.apache.kafka.clients.ApiVersion;
+import org.apache.kafka.common.protocol.ApiVersion;
import org.apache.kafka.clients.ApiVersions;
import org.apache.kafka.clients.ClientResponse;
import org.apache.kafka.clients.FetchSessionHandler;
diff --git a/clients/src/main/java/org/apache/kafka/clients/producer/internals/TransactionManager.java b/clients/src/main/java/org/apache/kafka/clients/producer/internals/TransactionManager.java
index e58469b..7f9b5a9 100644
--- a/clients/src/main/java/org/apache/kafka/clients/producer/internals/TransactionManager.java
+++ b/clients/src/main/java/org/apache/kafka/clients/producer/internals/TransactionManager.java
@@ -16,7 +16,7 @@
*/
package org.apache.kafka.clients.producer.internals;
-import org.apache.kafka.clients.ApiVersion;
+import org.apache.kafka.common.protocol.ApiVersion;
import org.apache.kafka.clients.ApiVersions;
import org.apache.kafka.clients.ClientResponse;
import org.apache.kafka.clients.NodeApiVersions;
diff --git a/clients/src/main/java/org/apache/kafka/clients/ApiVersion.java b/clients/src/main/java/org/apache/kafka/common/protocol/ApiVersion.java
similarity index 79%
rename from clients/src/main/java/org/apache/kafka/clients/ApiVersion.java
rename to clients/src/main/java/org/apache/kafka/common/protocol/ApiVersion.java
index 9d606bb..b1e557b 100644
--- a/clients/src/main/java/org/apache/kafka/clients/ApiVersion.java
+++ b/clients/src/main/java/org/apache/kafka/common/protocol/ApiVersion.java
@@ -14,10 +14,11 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.apache.kafka.clients;
+package org.apache.kafka.common.protocol;
import org.apache.kafka.common.message.ApiVersionsResponseData.ApiVersionsResponseKey;
-import org.apache.kafka.common.protocol.ApiKeys;
+
+import java.util.Optional;
/**
* Represents the min version and max version of an api key.
@@ -53,4 +54,14 @@ public class ApiVersion {
", maxVersion= " + maxVersion +
")";
}
+
+ public Optional<ApiVersion> intersect(ApiVersion other) {
+ if (other == null) {
+ return Optional.empty();
+ }
+ short minVersion = (short) Math.max(this.minVersion, other.minVersion);
+ short maxVersion = (short) Math.min(this.maxVersion, other.maxVersion);
+ return minVersion > maxVersion ? Optional.empty() :
+ Optional.of(new ApiVersion(apiKey, minVersion, maxVersion));
+ }
}
diff --git a/clients/src/main/java/org/apache/kafka/common/requests/ApiVersionsResponse.java b/clients/src/main/java/org/apache/kafka/common/requests/ApiVersionsResponse.java
index 4d7397a..1261c52 100644
--- a/clients/src/main/java/org/apache/kafka/common/requests/ApiVersionsResponse.java
+++ b/clients/src/main/java/org/apache/kafka/common/requests/ApiVersionsResponse.java
@@ -16,6 +16,7 @@
*/
package org.apache.kafka.common.requests;
+import org.apache.kafka.common.protocol.ApiVersion;
import org.apache.kafka.common.feature.Features;
import org.apache.kafka.common.feature.FinalizedVersionRange;
import org.apache.kafka.common.feature.SupportedVersionRange;
@@ -33,6 +34,7 @@ import org.apache.kafka.common.record.RecordBatch;
import java.nio.ByteBuffer;
import java.util.Map;
+import java.util.Optional;
/**
* Possible error codes:
@@ -129,6 +131,47 @@ public class ApiVersionsResponse extends AbstractResponse {
return apiKeys;
}
+ /**
+ * Find the commonly agreed ApiVersions between local software and the controller.
+ *
+ * @param minMagic min inter broker magic
+ * @param activeControllerApiVersions controller ApiVersions
+ * @return commonly agreed ApiVersion collection
+ */
+ public static ApiVersionsResponseKeyCollection intersectControllerApiVersions(final byte minMagic,
+ final Map<ApiKeys, ApiVersion> activeControllerApiVersions) {
+ ApiVersionsResponseKeyCollection apiKeys = new ApiVersionsResponseKeyCollection();
+ for (ApiKeys apiKey : ApiKeys.enabledApis()) {
+ if (apiKey.minRequiredInterBrokerMagic <= minMagic) {
+ ApiVersion brokerApiVersion = new ApiVersion(
+ apiKey.id,
+ apiKey.oldestVersion(),
+ apiKey.latestVersion()
+ );
+
+ final ApiVersion finalApiVersion;
+ if (!apiKey.forwardable) {
+ finalApiVersion = brokerApiVersion;
+ } else {
+ Optional<ApiVersion> intersectVersion = brokerApiVersion.intersect(
+ activeControllerApiVersions.getOrDefault(apiKey, null));
+ if (intersectVersion.isPresent()) {
+ finalApiVersion = intersectVersion.get();
+ } else {
+ // Controller doesn't support this API key, or there is no intersection.
+ continue;
+ }
+ }
+
+ apiKeys.add(new ApiVersionsResponseKey()
+ .setApiKey(finalApiVersion.apiKey)
+ .setMinVersion(finalApiVersion.minVersion)
+ .setMaxVersion(finalApiVersion.maxVersion));
+ }
+ }
+ return apiKeys;
+ }
+
public static ApiVersionsResponseData createApiVersionsResponseData(
final int throttleTimeMs,
final Errors error,
diff --git a/clients/src/test/java/org/apache/kafka/clients/NodeApiVersionsTest.java b/clients/src/test/java/org/apache/kafka/clients/NodeApiVersionsTest.java
index dc26d5a..1a44bad 100644
--- a/clients/src/test/java/org/apache/kafka/clients/NodeApiVersionsTest.java
+++ b/clients/src/test/java/org/apache/kafka/clients/NodeApiVersionsTest.java
@@ -23,6 +23,7 @@ import org.apache.kafka.common.errors.UnsupportedVersionException;
import org.apache.kafka.common.message.ApiVersionsResponseData.ApiVersionsResponseKey;
import org.apache.kafka.common.message.ApiVersionsResponseData.ApiVersionsResponseKeyCollection;
import org.apache.kafka.common.protocol.ApiKeys;
+import org.apache.kafka.common.protocol.ApiVersion;
import org.apache.kafka.common.requests.ApiVersionsResponse;
import org.junit.jupiter.api.Test;
diff --git a/clients/src/test/java/org/apache/kafka/clients/admin/KafkaAdminClientTest.java b/clients/src/test/java/org/apache/kafka/clients/admin/KafkaAdminClientTest.java
index b7cc9f1..a9dd171 100644
--- a/clients/src/test/java/org/apache/kafka/clients/admin/KafkaAdminClientTest.java
+++ b/clients/src/test/java/org/apache/kafka/clients/admin/KafkaAdminClientTest.java
@@ -16,7 +16,7 @@
*/
package org.apache.kafka.clients.admin;
-import org.apache.kafka.clients.ApiVersion;
+import org.apache.kafka.common.protocol.ApiVersion;
import org.apache.kafka.clients.ClientDnsLookup;
import org.apache.kafka.clients.ClientUtils;
import org.apache.kafka.clients.MockClient;
diff --git a/clients/src/test/java/org/apache/kafka/clients/producer/internals/TransactionManagerTest.java b/clients/src/test/java/org/apache/kafka/clients/producer/internals/TransactionManagerTest.java
index 2ec2561..edfb374 100644
--- a/clients/src/test/java/org/apache/kafka/clients/producer/internals/TransactionManagerTest.java
+++ b/clients/src/test/java/org/apache/kafka/clients/producer/internals/TransactionManagerTest.java
@@ -16,7 +16,7 @@
*/
package org.apache.kafka.clients.producer.internals;
-import org.apache.kafka.clients.ApiVersion;
+import org.apache.kafka.common.protocol.ApiVersion;
import org.apache.kafka.clients.ApiVersions;
import org.apache.kafka.clients.MockClient;
import org.apache.kafka.clients.consumer.CommitFailedException;
diff --git a/clients/src/test/java/org/apache/kafka/common/requests/ApiVersionsResponseTest.java b/clients/src/test/java/org/apache/kafka/common/requests/ApiVersionsResponseTest.java
index 419cbc2..1a3f450 100644
--- a/clients/src/test/java/org/apache/kafka/common/requests/ApiVersionsResponseTest.java
+++ b/clients/src/test/java/org/apache/kafka/common/requests/ApiVersionsResponseTest.java
@@ -17,12 +17,17 @@
package org.apache.kafka.common.requests;
+import org.apache.kafka.common.protocol.ApiVersion;
import org.apache.kafka.common.message.ApiVersionsResponseData.ApiVersionsResponseKey;
+import org.apache.kafka.common.message.ApiVersionsResponseData.ApiVersionsResponseKeyCollection;
import org.apache.kafka.common.protocol.ApiKeys;
+import org.apache.kafka.common.record.RecordBatch;
+import org.apache.kafka.common.utils.Utils;
import org.junit.jupiter.api.Test;
import java.util.Collection;
import java.util.HashSet;
+import java.util.Map;
import java.util.Set;
import static org.junit.jupiter.api.Assertions.assertEquals;
@@ -73,6 +78,39 @@ public class ApiVersionsResponseTest {
assertEquals(ApiVersionsResponse.UNKNOWN_FINALIZED_FEATURES_EPOCH, ApiVersionsResponse.DEFAULT_API_VERSIONS_RESPONSE.data().finalizedFeaturesEpoch());
}
+ @Test
+ public void shouldHaveCommonlyAgreedApiVersionResponseWithControllerOnForwardableAPIs() {
+ final ApiKeys forwardableAPIKey = ApiKeys.CREATE_ACLS;
+ final ApiKeys nonForwardableAPIKey = ApiKeys.JOIN_GROUP;
+ final short minVersion = 0;
+ final short maxVersion = 1;
+ Map<ApiKeys, ApiVersion> activeControllerApiVersions = Utils.mkMap(
+ Utils.mkEntry(forwardableAPIKey, new ApiVersion(forwardableAPIKey.id, minVersion, maxVersion)),
+ Utils.mkEntry(nonForwardableAPIKey, new ApiVersion(nonForwardableAPIKey.id, minVersion, maxVersion))
+ );
+
+ ApiVersionsResponseKeyCollection commonResponse = ApiVersionsResponse.intersectControllerApiVersions(
+ RecordBatch.CURRENT_MAGIC_VALUE,
+ activeControllerApiVersions);
+
+ verifyVersions(forwardableAPIKey.id, minVersion, maxVersion, commonResponse);
+
+ verifyVersions(nonForwardableAPIKey.id, ApiKeys.JOIN_GROUP.oldestVersion(),
+ ApiKeys.JOIN_GROUP.latestVersion(), commonResponse);
+ }
+
+ private void verifyVersions(short forwardableAPIKey,
+ short minVersion,
+ short maxVersion,
+ ApiVersionsResponseKeyCollection commonResponse) {
+ ApiVersionsResponseKey expectedVersionsForForwardableAPI =
+ new ApiVersionsResponseKey()
+ .setApiKey(forwardableAPIKey)
+ .setMinVersion(minVersion)
+ .setMaxVersion(maxVersion);
+ assertEquals(expectedVersionsForForwardableAPI, commonResponse.find(forwardableAPIKey));
+ }
+
private Set<ApiKeys> apiKeysInResponse(final ApiVersionsResponse apiVersions) {
final Set<ApiKeys> apiKeys = new HashSet<>();
for (final ApiVersionsResponseKey version : apiVersions.data().apiKeys()) {
diff --git a/core/src/main/scala/kafka/api/ApiVersion.scala b/core/src/main/scala/kafka/api/ApiVersion.scala
index c859f8d..2d6e515 100644
--- a/core/src/main/scala/kafka/api/ApiVersion.scala
+++ b/core/src/main/scala/kafka/api/ApiVersion.scala
@@ -17,6 +17,7 @@
package kafka.api
+import org.apache.kafka.clients.NodeApiVersions
import org.apache.kafka.common.config.ConfigDef.Validator
import org.apache.kafka.common.config.ConfigException
import org.apache.kafka.common.feature.{Features, FinalizedVersionRange, SupportedVersionRange}
@@ -148,13 +149,15 @@ object ApiVersion {
def apiVersionsResponse(throttleTimeMs: Int,
maxMagic: Byte,
- latestSupportedFeatures: Features[SupportedVersionRange]): ApiVersionsResponse = {
+ latestSupportedFeatures: Features[SupportedVersionRange],
+ controllerApiVersions: Option[NodeApiVersions]): ApiVersionsResponse = {
apiVersionsResponse(
throttleTimeMs,
maxMagic,
latestSupportedFeatures,
Features.emptyFinalizedFeatures,
- ApiVersionsResponse.UNKNOWN_FINALIZED_FEATURES_EPOCH
+ ApiVersionsResponse.UNKNOWN_FINALIZED_FEATURES_EPOCH,
+ controllerApiVersions
)
}
@@ -162,29 +165,34 @@ object ApiVersion {
maxMagic: Byte,
latestSupportedFeatures: Features[SupportedVersionRange],
finalizedFeatures: Features[FinalizedVersionRange],
- finalizedFeaturesEpoch: Long): ApiVersionsResponse = {
- val apiKeys = ApiVersionsResponse.defaultApiKeys(maxMagic)
+ finalizedFeaturesEpoch: Long,
+ controllerApiVersions: Option[NodeApiVersions]): ApiVersionsResponse = {
+ val apiKeys = controllerApiVersions match {
+ case None => ApiVersionsResponse.defaultApiKeys(maxMagic)
+ case Some(controllerApiVersion) => ApiVersionsResponse.intersectControllerApiVersions(
+ maxMagic, controllerApiVersion.allSupportedApiVersions())
+ }
+
if (maxMagic == RecordBatch.CURRENT_MAGIC_VALUE &&
- throttleTimeMs == AbstractResponse.DEFAULT_THROTTLE_TIME)
- return new ApiVersionsResponse(
+ throttleTimeMs == AbstractResponse.DEFAULT_THROTTLE_TIME) {
+ new ApiVersionsResponse(
ApiVersionsResponse.createApiVersionsResponseData(
DEFAULT_API_VERSIONS_RESPONSE.throttleTimeMs,
Errors.forCode(DEFAULT_API_VERSIONS_RESPONSE.data.errorCode),
apiKeys,
latestSupportedFeatures,
finalizedFeatures,
- finalizedFeaturesEpoch)
- )
-
- new ApiVersionsResponse(
- ApiVersionsResponse.createApiVersionsResponseData(
- throttleTimeMs,
- Errors.NONE,
- apiKeys,
- latestSupportedFeatures,
- finalizedFeatures,
- finalizedFeaturesEpoch)
- )
+ finalizedFeaturesEpoch))
+ } else {
+ new ApiVersionsResponse(
+ ApiVersionsResponse.createApiVersionsResponseData(
+ throttleTimeMs,
+ Errors.NONE,
+ apiKeys,
+ latestSupportedFeatures,
+ finalizedFeatures,
+ finalizedFeaturesEpoch))
+ }
}
}
diff --git a/core/src/main/scala/kafka/server/BrokerToControllerChannelManager.scala b/core/src/main/scala/kafka/server/BrokerToControllerChannelManager.scala
index dac882e..43434ee 100644
--- a/core/src/main/scala/kafka/server/BrokerToControllerChannelManager.scala
+++ b/core/src/main/scala/kafka/server/BrokerToControllerChannelManager.scala
@@ -18,6 +18,7 @@
package kafka.server
import java.util.concurrent.LinkedBlockingDeque
+import java.util.concurrent.atomic.AtomicReference
import kafka.common.{InterBrokerSendThread, RequestAndCompletionHandler}
import kafka.utils.Logging
@@ -50,6 +51,8 @@ class BrokerToControllerChannelManager(
) extends Logging {
private val logContext = new LogContext(s"[broker-${config.brokerId}-to-controller] ")
private val manualMetadataUpdater = new ManualMetadataUpdater()
+ private val apiVersions = new ApiVersions()
+ private val currentNodeApiVersions = NodeApiVersions.create()
private val requestThread = newRequestThread
def start(): Unit = {
@@ -102,8 +105,8 @@ class BrokerToControllerChannelManager(
config.connectionSetupTimeoutMaxMs,
ClientDnsLookup.USE_ALL_DNS_IPS,
time,
- false,
- new ApiVersions,
+ true,
+ apiVersions,
logContext
)
}
@@ -140,6 +143,14 @@ class BrokerToControllerChannelManager(
callback
))
}
+
+ def controllerApiVersions(): Option[NodeApiVersions] =
+ requestThread.activeControllerAddress().flatMap(
+ activeController => if (activeController.id() == config.brokerId)
+ Some(currentNodeApiVersions)
+ else
+ Option(apiVersions.get(activeController.idString()))
+ )
}
abstract class ControllerRequestCompletionHandler extends RequestCompletionHandler {
@@ -169,11 +180,19 @@ class BrokerToControllerRequestThread(
) extends InterBrokerSendThread(threadName, networkClient, config.controllerSocketTimeoutMs, time, isInterruptible = false) {
private val requestQueue = new LinkedBlockingDeque[BrokerToControllerQueueItem]()
- private var activeController: Option[Node] = None
+ private val activeController = new AtomicReference[Node](null)
+
+ def activeControllerAddress(): Option[Node] = {
+ Option(activeController.get())
+ }
+
+ private def updateControllerAddress(newActiveController: Node): Unit = {
+ activeController.set(newActiveController)
+ }
def enqueue(request: BrokerToControllerQueueItem): Unit = {
requestQueue.add(request)
- if (activeController.isDefined) {
+ if (activeControllerAddress().isDefined) {
wakeup()
}
}
@@ -190,14 +209,17 @@ class BrokerToControllerRequestThread(
if (currentTimeMs - request.createdTimeMs >= retryTimeoutMs) {
requestIter.remove()
request.callback.onTimeout()
- } else if (activeController.isDefined) {
- requestIter.remove()
- return Some(RequestAndCompletionHandler(
- time.milliseconds(),
- activeController.get,
- request.request,
- handleResponse(request)
- ))
+ } else {
+ val controllerAddress = activeControllerAddress()
+ if (controllerAddress.isDefined) {
+ requestIter.remove()
+ return Some(RequestAndCompletionHandler(
+ time.milliseconds(),
+ controllerAddress.get,
+ request.request,
+ handleResponse(request)
+ ))
+ }
}
}
None
@@ -205,12 +227,15 @@ class BrokerToControllerRequestThread(
private[server] def handleResponse(request: BrokerToControllerQueueItem)(response: ClientResponse): Unit = {
if (response.wasDisconnected()) {
- activeController = None
+ updateControllerAddress(null)
requestQueue.putFirst(request)
} else if (response.responseBody().errorCounts().containsKey(Errors.NOT_CONTROLLER)) {
// just close the controller connection and wait for metadata cache update in doWork
- networkClient.disconnect(activeController.get.idString)
- activeController = None
+ activeControllerAddress().foreach { controllerAddress => {
+ networkClient.disconnect(controllerAddress.idString)
+ updateControllerAddress(null)
+ }}
+
requestQueue.putFirst(request)
} else {
request.callback.onComplete(response)
@@ -218,7 +243,7 @@ class BrokerToControllerRequestThread(
}
override def doWork(): Unit = {
- if (activeController.isDefined) {
+ if (activeControllerAddress().isDefined) {
super.pollOnce(Long.MaxValue)
} else {
debug("Controller isn't cached, looking for local metadata changes")
@@ -227,9 +252,8 @@ class BrokerToControllerRequestThread(
case Some(controller) =>
info(s"Recorded new controller, from now on will use broker $controller")
val controllerNode = controller.node(listenerName)
- activeController = Some(controllerNode)
+ updateControllerAddress(controllerNode)
metadataUpdater.setNodes(Seq(controllerNode).asJava)
-
case None =>
// need to backoff to avoid tight loops
debug("No controller defined in metadata cache, retrying after backoff")
diff --git a/core/src/main/scala/kafka/server/ForwardingManager.scala b/core/src/main/scala/kafka/server/ForwardingManager.scala
index e4261a7..8d285e8 100644
--- a/core/src/main/scala/kafka/server/ForwardingManager.scala
+++ b/core/src/main/scala/kafka/server/ForwardingManager.scala
@@ -21,7 +21,7 @@ import java.nio.ByteBuffer
import kafka.network.RequestChannel
import kafka.utils.Logging
-import org.apache.kafka.clients.ClientResponse
+import org.apache.kafka.clients.{ClientResponse, NodeApiVersions}
import org.apache.kafka.common.metrics.Metrics
import org.apache.kafka.common.protocol.Errors
import org.apache.kafka.common.requests.{AbstractRequest, AbstractResponse, EnvelopeRequest, EnvelopeResponse, RequestHeader}
@@ -33,9 +33,11 @@ import scala.concurrent.TimeoutException
trait ForwardingManager {
def forwardRequest(
request: RequestChannel.Request,
- responseCallback: AbstractResponse => Unit
+ responseCallback: Option[AbstractResponse] => Unit
): Unit
+ def controllerApiVersions(): Option[NodeApiVersions]
+
def start(): Unit = {}
def shutdown(): Unit = {}
@@ -75,9 +77,17 @@ class ForwardingManagerImpl(
channelManager.shutdown()
}
+ /**
+ * Forward given request to the active controller.
+ *
+ * @param request request to be forwarded
+ * @param responseCallback callback which takes in an `Option[AbstractResponse]`, where
+ * None is indicating that controller doesn't support the request
+ * version.
+ */
override def forwardRequest(
request: RequestChannel.Request,
- responseCallback: AbstractResponse => Unit
+ responseCallback: Option[AbstractResponse] => Unit
): Unit = {
val principalSerde = request.context.principalSerde.asScala.getOrElse(
throw new IllegalArgumentException(s"Cannot deserialize principal from request $request " +
@@ -98,30 +108,41 @@ class ForwardingManagerImpl(
val envelopeError = envelopeResponse.error()
val requestBody = request.body[AbstractRequest]
- val response = if (envelopeError != Errors.NONE) {
- // An envelope error indicates broker misconfiguration (e.g. the principal serde
- // might not be defined on the receiving broker). In this case, we do not return
- // the error directly to the client since it would not be expected. Instead we
- // return `UNKNOWN_SERVER_ERROR` so that the user knows that there is a problem
- // on the broker.
- debug(s"Forwarded request $request failed with an error in the envelope response $envelopeError")
- requestBody.getErrorResponse(Errors.UNKNOWN_SERVER_ERROR.exception)
+ // Unsupported version indicates an incompatibility between controller and client API versions. This
+ // could happen when the controller changed after the connection was established. The forwarding broker
+ // should close the connection with the client and let it reinitialize the connection and refresh
+ // the controller API versions.
+ if (envelopeError == Errors.UNSUPPORTED_VERSION) {
+ responseCallback(None)
} else {
- parseResponse(envelopeResponse.responseData, requestBody, request.header)
+ val response = if (envelopeError != Errors.NONE) {
+ // A general envelope error indicates broker misconfiguration (e.g. the principal serde
+ // might not be defined on the receiving broker). In this case, we do not return
+ // the error directly to the client since it would not be expected. Instead we
+ // return `UNKNOWN_SERVER_ERROR` so that the user knows that there is a problem
+ // on the broker.
+ debug(s"Forwarded request $request failed with an error in the envelope response $envelopeError")
+ requestBody.getErrorResponse(Errors.UNKNOWN_SERVER_ERROR.exception)
+ } else {
+ parseResponse(envelopeResponse.responseData, requestBody, request.header)
+ }
+ responseCallback(Option(response))
}
- responseCallback(response)
}
override def onTimeout(): Unit = {
debug(s"Forwarding of the request $request failed due to timeout exception")
val response = request.body[AbstractRequest].getErrorResponse(new TimeoutException)
- responseCallback(response)
+ responseCallback(Option(response))
}
}
channelManager.sendRequest(envelopeRequest, new ForwardingResponseHandler)
}
+ override def controllerApiVersions(): Option[NodeApiVersions] =
+ channelManager.controllerApiVersions()
+
private def parseResponse(
buffer: ByteBuffer,
request: AbstractRequest,
diff --git a/core/src/main/scala/kafka/server/KafkaApis.scala b/core/src/main/scala/kafka/server/KafkaApis.scala
index b06969c..1b5c4d0 100644
--- a/core/src/main/scala/kafka/server/KafkaApis.scala
+++ b/core/src/main/scala/kafka/server/KafkaApis.scala
@@ -49,7 +49,7 @@ import org.apache.kafka.common.internals.{FatalExitError, Topic}
import org.apache.kafka.common.internals.Topic.{GROUP_METADATA_TOPIC_NAME, TRANSACTION_STATE_TOPIC_NAME, isInternal}
import org.apache.kafka.common.message.CreateTopicsRequestData.CreatableTopic
import org.apache.kafka.common.message.CreatePartitionsResponseData.CreatePartitionsTopicResult
-import org.apache.kafka.common.message.{AddOffsetsToTxnResponseData, AlterClientQuotasResponseData, AlterConfigsResponseData, AlterPartitionReassignmentsResponseData, AlterReplicaLogDirsResponseData, CreateAclsResponseData, CreatePartitionsResponseData, CreateTopicsResponseData, DeleteAclsResponseData, DeleteGroupsResponseData, DeleteRecordsResponseData, DeleteTopicsResponseData, DescribeAclsResponseData, DescribeClientQuotasResponseData, DescribeConfigsResponseData, DescribeGroupsRespon [...]
+import org.apache.kafka.common.message.{AddOffsetsToTxnResponseData, AlterClientQuotasResponseData, AlterConfigsResponseData, AlterPartitionReassignmentsResponseData, AlterReplicaLogDirsResponseData, ApiVersionsResponseData, CreateAclsResponseData, CreatePartitionsResponseData, CreateTopicsResponseData, DeleteAclsResponseData, DeleteGroupsResponseData, DeleteRecordsResponseData, DeleteTopicsResponseData, DescribeAclsResponseData, DescribeClientQuotasResponseData, DescribeConfigsResponseD [...]
import org.apache.kafka.common.message.CreateTopicsResponseData.{CreatableTopicResult, CreatableTopicResultCollection}
import org.apache.kafka.common.message.DeleteGroupsResponseData.{DeletableGroupResult, DeletableGroupResultCollection}
import org.apache.kafka.common.message.AlterPartitionReassignmentsResponseData.{ReassignablePartitionResponse, ReassignableTopicResponse}
@@ -62,7 +62,6 @@ import org.apache.kafka.common.message.LeaveGroupResponseData.MemberResponse
import org.apache.kafka.common.message.ListOffsetsRequestData.ListOffsetsPartition
import org.apache.kafka.common.message.ListOffsetsResponseData.{ListOffsetsPartitionResponse, ListOffsetsTopicResponse}
import org.apache.kafka.common.message.OffsetForLeaderEpochRequestData.OffsetForLeaderTopic
-import org.apache.kafka.common.message.OffsetForLeaderEpochResponseData
import org.apache.kafka.common.message.OffsetForLeaderEpochResponseData.{EpochEndOffset, OffsetForLeaderTopicResult, OffsetForLeaderTopicResultCollection}
import org.apache.kafka.common.metrics.Metrics
import org.apache.kafka.common.network.{ClientInformation, ListenerName, Send}
@@ -139,8 +138,15 @@ class KafkaApis(val requestChannel: RequestChannel,
request: RequestChannel.Request,
handler: RequestChannel.Request => Unit
): Unit = {
- def responseCallback(response: AbstractResponse): Unit = {
- requestHelper.sendForwardedResponse(request, response)
+ def responseCallback(responseOpt: Option[AbstractResponse]): Unit = {
+ responseOpt match {
+ case Some(response) => requestHelper.sendForwardedResponse(request, response)
+ case None =>
+ info(s"The client connection will be closed due to controller responded " +
+ s"unsupported version exception during $request forwarding. " +
+ s"This could happen when the controller changed after the connection was established.")
+ requestHelper.closeConnection(request, Collections.emptyMap())
+ }
}
if (!request.isForwarded && !controller.isActive && isForwardingEnabled(request)) {
@@ -1753,18 +1759,36 @@ class KafkaApis(val requestChannel: RequestChannel,
else {
val supportedFeatures = brokerFeatures.supportedFeatures
val finalizedFeaturesOpt = finalizedFeatureCache.get
- finalizedFeaturesOpt match {
- case Some(finalizedFeatures) => ApiVersion.apiVersionsResponse(
- requestThrottleMs,
- config.interBrokerProtocolVersion.recordVersion.value,
- supportedFeatures,
- finalizedFeatures.features,
- finalizedFeatures.epoch)
- case None => ApiVersion.apiVersionsResponse(
- requestThrottleMs,
- config.interBrokerProtocolVersion.recordVersion.value,
- supportedFeatures)
+ val controllerApiVersions = if (isForwardingEnabled(request)) {
+ forwardingManager.controllerApiVersions()
+ } else {
+ None
+ }
+
+ val apiVersionsResponse =
+ finalizedFeaturesOpt match {
+ case Some(finalizedFeatures) => ApiVersion.apiVersionsResponse(
+ requestThrottleMs,
+ config.interBrokerProtocolVersion.recordVersion.value,
+ supportedFeatures,
+ finalizedFeatures.features,
+ finalizedFeatures.epoch,
+ controllerApiVersions)
+ case None => ApiVersion.apiVersionsResponse(
+ requestThrottleMs,
+ config.interBrokerProtocolVersion.recordVersion.value,
+ supportedFeatures,
+ controllerApiVersions)
+ }
+ if (request.context.fromPrivilegedListener) {
+ apiVersionsResponse.data.apiKeys().add(
+ new ApiVersionsResponseData.ApiVersionsResponseKey()
+ .setApiKey(ApiKeys.ENVELOPE.id)
+ .setMinVersion(ApiKeys.ENVELOPE.oldestVersion())
+ .setMaxVersion(ApiKeys.ENVELOPE.latestVersion())
+ )
}
+ apiVersionsResponse
}
}
requestHelper.sendResponseMaybeThrottle(request, createResponseCallback)
diff --git a/core/src/test/scala/integration/kafka/admin/BrokerApiVersionsCommandTest.scala b/core/src/test/scala/integration/kafka/admin/BrokerApiVersionsCommandTest.scala
index 5792c9c..81991bf 100644
--- a/core/src/test/scala/integration/kafka/admin/BrokerApiVersionsCommandTest.scala
+++ b/core/src/test/scala/integration/kafka/admin/BrokerApiVersionsCommandTest.scala
@@ -34,7 +34,16 @@ import scala.jdk.CollectionConverters._
class BrokerApiVersionsCommandTest extends KafkaServerTestHarness {
- def generateConfigs: Seq[KafkaConfig] = TestUtils.createBrokerConfigs(1, zkConnect).map(KafkaConfig.fromProps)
+ def generateConfigs: Seq[KafkaConfig] =
+ TestUtils.createBrokerConfigs(1, zkConnect).map(props => {
+ // Configure control plane listener to make sure we have separate listeners from client,
+ // in order to avoid returning Envelope API version.
+ props.setProperty(KafkaConfig.ControlPlaneListenerNameProp, "CONTROLLER")
+ props.setProperty(KafkaConfig.ListenerSecurityProtocolMapProp, "CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT")
+ props.setProperty("listeners", "PLAINTEXT://localhost:0,CONTROLLER://localhost:0")
+ props.setProperty(KafkaConfig.AdvertisedListenersProp, "PLAINTEXT://localhost:0,CONTROLLER://localhost:0")
+ props
+ }).map(KafkaConfig.fromProps)
@Test(timeout=120000)
def checkBrokerApiVersionCommandOutput(): Unit = {
@@ -55,13 +64,10 @@ class BrokerApiVersionsCommandTest extends KafkaServerTestHarness {
if (apiVersion.minVersion == apiVersion.maxVersion) apiVersion.minVersion.toString
else s"${apiVersion.minVersion} to ${apiVersion.maxVersion}"
val usableVersion = nodeApiVersions.latestUsableVersion(apiKey)
- // Admin client should not see ENVELOPE supported versions as its a broker-internal API.
- val usableVersionInfo = if (apiKey == ApiKeys.ENVELOPE) "UNSUPPORTED" else
- s"$versionRangeStr [usable: $usableVersion]"
val terminator = if (apiKey == enabledApis.last) "" else ","
- val line = s"\t${apiKey.name}(${apiKey.id}): $usableVersionInfo$terminator"
+ val line = s"\t${apiKey.name}(${apiKey.id}): $versionRangeStr [usable: $usableVersion]$terminator"
assertTrue(lineIter.hasNext)
assertEquals(line, lineIter.next())
}
diff --git a/core/src/test/scala/kafka/server/BrokerToControllerRequestThreadTest.scala b/core/src/test/scala/kafka/server/BrokerToControllerRequestThreadTest.scala
index 7b65bea..8f1f287 100644
--- a/core/src/test/scala/kafka/server/BrokerToControllerRequestThreadTest.scala
+++ b/core/src/test/scala/kafka/server/BrokerToControllerRequestThreadTest.scala
@@ -23,6 +23,7 @@ import java.util.concurrent.atomic.AtomicBoolean
import kafka.cluster.{Broker, EndPoint}
import kafka.utils.TestUtils
import org.apache.kafka.clients.{ClientResponse, ManualMetadataUpdater, Metadata, MockClient}
+import org.apache.kafka.common.Node
import org.apache.kafka.common.feature.Features
import org.apache.kafka.common.feature.Features.emptySupportedFeatures
import org.apache.kafka.common.message.MetadataRequestData
@@ -177,10 +178,11 @@ class BrokerToControllerRequestThreadTest {
val metadataCache = mock(classOf[MetadataCache])
val listenerName = ListenerName.forSecurityProtocol(SecurityProtocol.PLAINTEXT)
+ val port = 1234
val oldController = new Broker(oldControllerId,
- Seq(new EndPoint("host1", 1234, listenerName, SecurityProtocol.PLAINTEXT)), None, Features.emptySupportedFeatures)
+ Seq(new EndPoint("host1", port, listenerName, SecurityProtocol.PLAINTEXT)), None, Features.emptySupportedFeatures)
val newController = new Broker(2,
- Seq(new EndPoint("host2", 1234, listenerName, SecurityProtocol.PLAINTEXT)), None, Features.emptySupportedFeatures)
+ Seq(new EndPoint("host2", port, listenerName, SecurityProtocol.PLAINTEXT)), None, Features.emptySupportedFeatures)
when(metadataCache.getControllerId).thenReturn(Some(oldControllerId), Some(newControllerId))
when(metadataCache.getAliveBrokers).thenReturn(Seq(oldController, newController))
@@ -204,18 +206,26 @@ class BrokerToControllerRequestThreadTest {
testRequestThread.enqueue(queueItem)
// initialize to the controller
testRequestThread.doWork()
+
+ val oldBrokerNode = new Node(oldControllerId, "host1", port)
+ assertEquals(Some(oldBrokerNode), testRequestThread.activeControllerAddress())
+
// send and process the request
mockClient.prepareResponse((body: AbstractRequest) => {
body.isInstanceOf[MetadataRequest] &&
body.asInstanceOf[MetadataRequest].allowAutoTopicCreation()
}, responseWithNotControllerError)
testRequestThread.doWork()
+ assertEquals(None, testRequestThread.activeControllerAddress())
// reinitialize the controller to a different node
testRequestThread.doWork()
// process the request again
mockClient.prepareResponse(expectedResponse)
testRequestThread.doWork()
+ val newControllerNode = new Node(newControllerId, "host2", port)
+ assertEquals(Some(newControllerNode), testRequestThread.activeControllerAddress())
+
assertTrue(completionHandler.completed.get())
}
diff --git a/core/src/test/scala/unit/kafka/api/ApiVersionTest.scala b/core/src/test/scala/unit/kafka/api/ApiVersionTest.scala
index d0a4216..363a3eb 100644
--- a/core/src/test/scala/unit/kafka/api/ApiVersionTest.scala
+++ b/core/src/test/scala/unit/kafka/api/ApiVersionTest.scala
@@ -180,7 +180,8 @@ class ApiVersionTest {
val response = ApiVersion.apiVersionsResponse(
10,
RecordBatch.MAGIC_VALUE_V1,
- Features.emptySupportedFeatures
+ Features.emptySupportedFeatures,
+ None
)
verifyApiKeysForMagic(response, RecordBatch.MAGIC_VALUE_V1)
assertEquals(10, response.throttleTimeMs)
@@ -198,7 +199,8 @@ class ApiVersionTest {
Utils.mkMap(Utils.mkEntry("feature", new SupportedVersionRange(1.toShort, 4.toShort)))),
Features.finalizedFeatures(
Utils.mkMap(Utils.mkEntry("feature", new FinalizedVersionRange(2.toShort, 3.toShort)))),
- 10
+ 10,
+ None
)
verifyApiKeysForMagic(response, RecordBatch.MAGIC_VALUE_V1)
@@ -227,7 +229,8 @@ class ApiVersionTest {
val response = ApiVersion.apiVersionsResponse(
AbstractResponse.DEFAULT_THROTTLE_TIME,
RecordBatch.CURRENT_MAGIC_VALUE,
- Features.emptySupportedFeatures
+ Features.emptySupportedFeatures,
+ None
)
assertEquals(new util.HashSet[ApiKeys](ApiKeys.enabledApis), apiKeysInResponse(response))
assertEquals(AbstractResponse.DEFAULT_THROTTLE_TIME, response.throttleTimeMs)
@@ -241,7 +244,8 @@ class ApiVersionTest {
val response = ApiVersion.apiVersionsResponse(
AbstractResponse.DEFAULT_THROTTLE_TIME,
RecordBatch.CURRENT_MAGIC_VALUE,
- Features.emptySupportedFeatures
+ Features.emptySupportedFeatures,
+ None
)
// Ensure that APIs needed for the internal metadata quorum (KIP-500)
diff --git a/core/src/test/scala/unit/kafka/raft/KafkaNetworkChannelTest.scala b/core/src/test/scala/unit/kafka/raft/KafkaNetworkChannelTest.scala
index b699da6..3f38eb2 100644
--- a/core/src/test/scala/unit/kafka/raft/KafkaNetworkChannelTest.scala
+++ b/core/src/test/scala/unit/kafka/raft/KafkaNetworkChannelTest.scala
@@ -21,9 +21,9 @@ import java.util
import java.util.Collections
import org.apache.kafka.clients.MockClient.MockMetadataUpdater
-import org.apache.kafka.clients.{ApiVersion, MockClient, NodeApiVersions}
+import org.apache.kafka.clients.{MockClient, NodeApiVersions}
import org.apache.kafka.common.message.{BeginQuorumEpochResponseData, EndQuorumEpochResponseData, FetchResponseData, VoteResponseData}
-import org.apache.kafka.common.protocol.{ApiKeys, ApiMessage, Errors}
+import org.apache.kafka.common.protocol.{ApiKeys, ApiMessage, ApiVersion, Errors}
import org.apache.kafka.common.requests.{AbstractResponse, BeginQuorumEpochRequest, BeginQuorumEpochResponse, EndQuorumEpochRequest, EndQuorumEpochResponse, FetchResponse, VoteRequest, VoteResponse}
import org.apache.kafka.common.utils.{MockTime, Time}
import org.apache.kafka.common.{Node, TopicPartition}
diff --git a/core/src/test/scala/unit/kafka/server/AbstractApiVersionsRequestTest.scala b/core/src/test/scala/unit/kafka/server/AbstractApiVersionsRequestTest.scala
index 48d7e21..fc97406 100644
--- a/core/src/test/scala/unit/kafka/server/AbstractApiVersionsRequestTest.scala
+++ b/core/src/test/scala/unit/kafka/server/AbstractApiVersionsRequestTest.scala
@@ -16,7 +16,10 @@
*/
package kafka.server
+import java.util.Properties
+
import org.apache.kafka.common.message.ApiVersionsResponseData.ApiVersionsResponseKey
+import org.apache.kafka.common.network.ListenerName
import org.apache.kafka.common.protocol.ApiKeys
import org.apache.kafka.common.requests.{ApiVersionsRequest, ApiVersionsResponse}
import org.junit.Assert._
@@ -25,6 +28,16 @@ import scala.jdk.CollectionConverters._
abstract class AbstractApiVersionsRequestTest extends BaseRequestTest {
+ def controlPlaneListenerName = new ListenerName("CONTROLLER")
+
+ // Configure control plane listener to make sure we have separate listeners for testing.
+ override def brokerPropertyOverrides(properties: Properties): Unit = {
+ properties.setProperty(KafkaConfig.ControlPlaneListenerNameProp, controlPlaneListenerName.value())
+ properties.setProperty(KafkaConfig.ListenerSecurityProtocolMapProp, s"${controlPlaneListenerName.value()}:$securityProtocol,$securityProtocol:$securityProtocol")
+ properties.setProperty("listeners", s"$securityProtocol://localhost:0,${controlPlaneListenerName.value()}://localhost:0")
+ properties.setProperty(KafkaConfig.AdvertisedListenersProp, s"$securityProtocol://localhost:0,${controlPlaneListenerName.value()}://localhost:0")
+ }
+
def sendUnsupportedApiVersionRequest(request: ApiVersionsRequest): ApiVersionsResponse = {
val overrideHeader = nextRequestHeader(ApiKeys.API_VERSIONS, Short.MaxValue)
val socket = connect(anySocketServer)
@@ -34,10 +47,13 @@ abstract class AbstractApiVersionsRequestTest extends BaseRequestTest {
} finally socket.close()
}
- def validateApiVersionsResponse(apiVersionsResponse: ApiVersionsResponse): Unit = {
- val enabledPublicApis = ApiKeys.enabledApis()
+ def validateApiVersionsResponse(apiVersionsResponse: ApiVersionsResponse, listenerName: ListenerName = interBrokerListenerName): Unit = {
+ val expectedApis = ApiKeys.enabledApis()
+ if (listenerName == controlPlaneListenerName) {
+ expectedApis.add(ApiKeys.ENVELOPE)
+ }
assertEquals("API keys in ApiVersionsResponse must match API keys supported by broker.",
- enabledPublicApis.size(), apiVersionsResponse.data.apiKeys().size())
+ expectedApis.size(), apiVersionsResponse.data.apiKeys().size())
for (expectedApiVersion: ApiVersionsResponseKey <- ApiVersionsResponse.DEFAULT_API_VERSIONS_RESPONSE.data.apiKeys().asScala) {
val actualApiVersion = apiVersionsResponse.apiVersion(expectedApiVersion.apiKey)
assertNotNull(s"API key ${actualApiVersion.apiKey} is supported by broker, but not received in ApiVersionsResponse.", actualApiVersion)
diff --git a/core/src/test/scala/unit/kafka/server/ApiVersionsRequestTest.scala b/core/src/test/scala/unit/kafka/server/ApiVersionsRequestTest.scala
index 916535b..f63601d 100644
--- a/core/src/test/scala/unit/kafka/server/ApiVersionsRequestTest.scala
+++ b/core/src/test/scala/unit/kafka/server/ApiVersionsRequestTest.scala
@@ -18,6 +18,7 @@
package kafka.server
import org.apache.kafka.common.message.ApiVersionsRequestData
+import org.apache.kafka.common.network.ListenerName
import org.apache.kafka.common.protocol.{ApiKeys, Errors}
import org.apache.kafka.common.requests.{ApiVersionsRequest, ApiVersionsResponse}
import org.junit.Assert._
@@ -35,6 +36,13 @@ class ApiVersionsRequestTest extends AbstractApiVersionsRequestTest {
}
@Test
+ def testApiVersionsRequestThroughControlPlaneListener(): Unit = {
+ val request = new ApiVersionsRequest.Builder().build()
+ val apiVersionsResponse = sendApiVersionsRequest(request, super.controlPlaneListenerName)
+ validateApiVersionsResponse(apiVersionsResponse, super.controlPlaneListenerName)
+ }
+
+ @Test
def testApiVersionsRequestWithUnsupportedVersion(): Unit = {
val apiVersionsRequest = new ApiVersionsRequest.Builder().build()
val apiVersionsResponse = sendUnsupportedApiVersionRequest(apiVersionsRequest)
@@ -54,6 +62,13 @@ class ApiVersionsRequestTest extends AbstractApiVersionsRequestTest {
}
@Test
+ def testApiVersionsRequestValidationV0ThroughControlPlaneListener(): Unit = {
+ val apiVersionsRequest = new ApiVersionsRequest.Builder().build(0.asInstanceOf[Short])
+ val apiVersionsResponse = sendApiVersionsRequest(apiVersionsRequest, super.controlPlaneListenerName)
+ validateApiVersionsResponse(apiVersionsResponse, super.controlPlaneListenerName)
+ }
+
+ @Test
def testApiVersionsRequestValidationV3(): Unit = {
// Invalid request because Name and Version are empty by default
val apiVersionsRequest = new ApiVersionsRequest(new ApiVersionsRequestData(), 3.asInstanceOf[Short])
@@ -61,8 +76,8 @@ class ApiVersionsRequestTest extends AbstractApiVersionsRequestTest {
assertEquals(Errors.INVALID_REQUEST.code(), apiVersionsResponse.data.errorCode())
}
- private def sendApiVersionsRequest(request: ApiVersionsRequest): ApiVersionsResponse = {
- connectAndReceive[ApiVersionsResponse](request)
+ private def sendApiVersionsRequest(request: ApiVersionsRequest,
+ listenerName: ListenerName = super.listenerName): ApiVersionsResponse = {
+ connectAndReceive[ApiVersionsResponse](request, listenerName = listenerName)
}
-
}
diff --git a/core/src/test/scala/unit/kafka/server/ForwardingManagerTest.scala b/core/src/test/scala/unit/kafka/server/ForwardingManagerTest.scala
index ca03359..7ef7919 100644
--- a/core/src/test/scala/unit/kafka/server/ForwardingManagerTest.scala
+++ b/core/src/test/scala/unit/kafka/server/ForwardingManagerTest.scala
@@ -19,6 +19,7 @@ package kafka.server
import java.net.InetAddress
import java.nio.ByteBuffer
import java.util.Optional
+import java.util.concurrent.atomic.AtomicBoolean
import kafka.network
import kafka.network.RequestChannel
@@ -73,16 +74,57 @@ class ForwardingManagerTest {
})
var response: AbstractResponse = null
- forwardingManager.forwardRequest(request, res => response = res)
+ forwardingManager.forwardRequest(request, result => response = result.orNull)
assertNotNull(response)
assertEquals(Map(Errors.UNKNOWN_SERVER_ERROR -> 1).asJava, response.errorCounts())
}
+ @Test
+ def testUnsupportedVersions(): Unit = {
+ val forwardingManager = new ForwardingManagerImpl(brokerToController)
+ val requestCorrelationId = 27
+ val clientPrincipal = new KafkaPrincipal(KafkaPrincipal.USER_TYPE, "client")
+
+ val configResource = new ConfigResource(ConfigResource.Type.TOPIC, "foo")
+ val configs = List(new AlterConfigsRequest.ConfigEntry(TopicConfig.MIN_IN_SYNC_REPLICAS_CONFIG, "1")).asJava
+ val requestBody = new AlterConfigsRequest.Builder(Map(
+ configResource -> new AlterConfigsRequest.Config(configs)
+ ).asJava, false).build()
+ val (requestHeader, requestBuffer) = buildRequest(requestBody, requestCorrelationId)
+ val request = buildRequest(requestHeader, requestBuffer, clientPrincipal)
+
+ val responseBody = new AlterConfigsResponse(new AlterConfigsResponseData())
+
+ val responseBuffer = RequestTestUtils.serializeResponseWithHeader(responseBody,
+ requestHeader.apiVersion, requestCorrelationId)
+
+ Mockito.when(brokerToController.sendRequest(
+ any(classOf[EnvelopeRequest.Builder]),
+ any(classOf[ControllerRequestCompletionHandler])
+ )).thenAnswer(invocation => {
+ val completionHandler = invocation.getArgument[RequestCompletionHandler](1)
+ val response = buildEnvelopeResponse(responseBuffer, 30,
+ completionHandler, Errors.UNSUPPORTED_VERSION)
+ response.onComplete()
+ })
+
+ var response: AbstractResponse = null
+ val connectionClosed = new AtomicBoolean(false)
+ forwardingManager.forwardRequest(request, res => {
+ response = res.orNull
+ connectionClosed.set(true)
+ })
+
+ assertTrue(connectionClosed.get())
+ assertNull(response)
+ }
+
private def buildEnvelopeResponse(
responseBuffer: ByteBuffer,
correlationId: Int,
- completionHandler: RequestCompletionHandler
+ completionHandler: RequestCompletionHandler,
+ error: Errors = Errors.NONE
): ClientResponse = {
val envelopeRequestHeader = new RequestHeader(
ApiKeys.ENVELOPE,
@@ -92,7 +134,7 @@ class ForwardingManagerTest {
)
val envelopeResponse = new EnvelopeResponse(
responseBuffer,
- Errors.NONE
+ error
)
new ClientResponse(
diff --git a/core/src/test/scala/unit/kafka/server/KafkaApisTest.scala b/core/src/test/scala/unit/kafka/server/KafkaApisTest.scala
index 62d050c..5bad37e 100644
--- a/core/src/test/scala/unit/kafka/server/KafkaApisTest.scala
+++ b/core/src/test/scala/unit/kafka/server/KafkaApisTest.scala
@@ -36,6 +36,7 @@ import kafka.network.RequestChannel.{CloseConnectionResponse, SendResponse}
import kafka.server.QuotaFactory.QuotaManagers
import kafka.utils.{MockTime, TestUtils}
import kafka.zk.KafkaZkClient
+import org.apache.kafka.clients.NodeApiVersions
import org.apache.kafka.clients.admin.AlterConfigOp.OpType
import org.apache.kafka.clients.admin.{AlterConfigOp, ConfigEntry}
import org.apache.kafka.common.acl.AclOperation
@@ -519,7 +520,7 @@ class KafkaApisTest {
EasyMock.expect(forwardingManager.forwardRequest(
EasyMock.eq(request),
- anyObject[AbstractResponse => Unit]()
+ anyObject[Option[AbstractResponse] => Unit]()
)).once()
EasyMock.replay(replicaManager, clientRequestQuotaManager, requestChannel, controller, forwardingManager)
@@ -691,6 +692,78 @@ class KafkaApisTest {
}
@Test
+ def testHandleApiVersionsWithControllerApiVersions(): Unit = {
+ val authorizer: Authorizer = EasyMock.niceMock(classOf[Authorizer])
+
+ val requestHeader = new RequestHeader(ApiKeys.API_VERSIONS, ApiKeys.API_VERSIONS.latestVersion, clientId, 0)
+
+ val permittedVersion: Short = 0
+ EasyMock.expect(forwardingManager.controllerApiVersions()).andReturn(
+ Some(NodeApiVersions.create(ApiKeys.ALTER_CONFIGS.id, permittedVersion, permittedVersion)))
+
+ val capturedResponse = expectNoThrottling()
+
+ val apiVersionsRequest = new ApiVersionsRequest.Builder()
+ .build(requestHeader.apiVersion)
+ val request = buildRequest(apiVersionsRequest,
+ fromPrivilegedListener = true, requestHeader = Option(requestHeader))
+
+ EasyMock.replay(replicaManager, clientRequestQuotaManager, forwardingManager,
+ requestChannel, authorizer, adminManager, controller)
+
+ createKafkaApis(authorizer = Some(authorizer), enableForwarding = true).handleApiVersionsRequest(request)
+
+ val expectedVersions = new ApiVersionsResponseData.ApiVersionsResponseKey()
+ .setApiKey(ApiKeys.ALTER_CONFIGS.id)
+ .setMaxVersion(permittedVersion)
+ .setMinVersion(permittedVersion)
+
+ val response = readResponse(apiVersionsRequest, capturedResponse)
+ .asInstanceOf[ApiVersionsResponse]
+ assertEquals(Errors.NONE, Errors.forCode(response.data().errorCode()))
+
+ val alterConfigVersions = response.data().apiKeys().find(ApiKeys.ALTER_CONFIGS.id)
+ assertEquals(expectedVersions, alterConfigVersions)
+
+ verify(authorizer, adminManager, forwardingManager)
+ }
+
+ @Test
+ def testGetUnsupportedVersionsWhenControllerApiVersionsNotAvailable(): Unit = {
+ val authorizer: Authorizer = EasyMock.niceMock(classOf[Authorizer])
+
+ val requestHeader = new RequestHeader(ApiKeys.API_VERSIONS, ApiKeys.API_VERSIONS.latestVersion, clientId, 0)
+
+ EasyMock.expect(forwardingManager.controllerApiVersions()).andReturn(None)
+
+ val capturedResponse = expectNoThrottling()
+
+ val apiVersionsRequest = new ApiVersionsRequest.Builder()
+ .build(requestHeader.apiVersion)
+ val request = buildRequest(apiVersionsRequest,
+ fromPrivilegedListener = true, requestHeader = Option(requestHeader))
+
+ EasyMock.replay(replicaManager, clientRequestQuotaManager, forwardingManager,
+ requestChannel, authorizer, adminManager, controller)
+
+ createKafkaApis(authorizer = Some(authorizer), enableForwarding = true).handleApiVersionsRequest(request)
+
+ val response = readResponse(apiVersionsRequest, capturedResponse)
+ .asInstanceOf[ApiVersionsResponse]
+ assertEquals(Errors.NONE, Errors.forCode(response.data().errorCode()))
+
+ val expectedVersions = new ApiVersionsResponseData.ApiVersionsResponseKey()
+ .setApiKey(ApiKeys.ALTER_CONFIGS.id)
+ .setMaxVersion(ApiKeys.ALTER_CONFIGS.latestVersion())
+ .setMinVersion(ApiKeys.ALTER_CONFIGS.oldestVersion())
+
+ val alterConfigVersions = response.data().apiKeys().find(ApiKeys.ALTER_CONFIGS.id)
+ assertEquals(expectedVersions, alterConfigVersions)
+
+ verify(authorizer, adminManager, forwardingManager)
+ }
+
+ @Test
def testCreateTopicsWithAuthorizer(): Unit = {
val authorizer: Authorizer = EasyMock.niceMock(classOf[Authorizer])