Source code
package org.apache.kafka.controller;
import org.apache.kafka.common.errors.ThrottlingQuotaExceededException;
import org.apache.kafka.common.message.RequestHeaderData;
import org.apache.kafka.common.security.auth.KafkaPrincipal;
import org.apache.kafka.common.utils.Time;
import org.apache.kafka.server.authorizer.AuthorizableRequestContext;
import java.util.OptionalLong;
import java.util.function.Consumer;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static java.util.concurrent.TimeUnit.NANOSECONDS;
public class ControllerRequestContext {
public static OptionalLong requestTimeoutMsToDeadlineNs(
Time time,
int millisecondsOffset
) {
return OptionalLong.of(time.nanoseconds() + NANOSECONDS.convert(millisecondsOffset, MILLISECONDS));
}
private final KafkaPrincipal principal;
private final OptionalLong deadlineNs;
private final RequestHeaderData requestHeader;
private final Consumer<Integer> partitionChangeQuotaApplier;
public ControllerRequestContext(
RequestHeaderData requestHeader,
KafkaPrincipal principal,
OptionalLong deadlineNs
) {
this(requestHeader, principal, deadlineNs, __ -> { });
}
public ControllerRequestContext(
RequestHeaderData requestHeader,
KafkaPrincipal principal,
OptionalLong deadlineNs,
Consumer<Integer> partitionChangeQuotaApplier
) {
this.requestHeader = requestHeader;
this.principal = principal;
this.deadlineNs = deadlineNs;
this.partitionChangeQuotaApplier = partitionChangeQuotaApplier;
}
public ControllerRequestContext(
AuthorizableRequestContext requestContext,
OptionalLong deadlineNs
) {
this(requestContext, deadlineNs, __ -> { });
}
public ControllerRequestContext(
AuthorizableRequestContext requestContext,
OptionalLong deadlineNs,
Consumer<Integer> partitionChangeQuotaApplier
) {
this(
new RequestHeaderData()
.setRequestApiKey((short) requestContext.requestType())
.setRequestApiVersion((short) requestContext.requestVersion())
.setCorrelationId(requestContext.correlationId())
.setClientId(requestContext.clientId()),
requestContext.principal(),
deadlineNs,
partitionChangeQuotaApplier
);
}
public RequestHeaderData requestHeader() {
return requestHeader;
}
public KafkaPrincipal principal() {
return principal;
}
public OptionalLong deadlineNs() {
return deadlineNs;
}
/**
* Apply the partition change quota.
*
* @param requestedPartitionCount The value to apply.
* @throws ThrottlingQuotaExceededException If recording this value moves a metric beyond its configured
* maximum or minimum bound
*/
public void applyPartitionChangeQuota(int requestedPartitionCount) {
partitionChangeQuotaApplier.accept(requestedPartitionCount);
}
}
Run 1
The code is well-structured and readable. It uses a clean class layout with clear separation of constructors, static helpers, and instance methods. Nesting is minimal, with no deep conditional or logical blocks. The intent is mostly clear: representing a controller request context, converting timeouts to deadlines, and delegating quota application. Constructor overloads are concise and delegation via `this(...)` avoids duplication. Action granularity is mostly one action per line, though constructor chaining for `RequestHeaderData` is slightly dense but still readable. Naming is descriptive (`deadlineNs`, `partitionChangeQuotaApplier`) and the use of `OptionalLong` is appropriate. The static helper `requestTimeoutMsToDeadlineNs` is clear and concise. Minor reductions in readability come from the `__ -> { }` lambda (intent could be clearer with a named no-op) and the multiple delegating constructors, which may require a brief scan to understand. Overall, the code is maintainable and straightforward.
Run 2
The code is well-structured and readable. It uses constructor chaining effectively to avoid duplication, has clear method names, and maintains a flat structure with minimal nesting. Each action is generally on its own line, especially in the builder-style header construction. The static helper method is concise and the Javadoc explains the quota behavior. The only minor deductions are the use of lambda parameter __ (intentionally ignored) which slightly reduces clarity, and the mixed formatting of the method signature for requestTimeoutMsToDeadlineNs, though this is minor. Overall, the code is clean, purposeful, and easy to follow.
Run 3
The code is generally well-structured with clear intent, reasonable method lengths, and flat nesting. It uses constructor overloading effectively and has a simple static utility method. However, readability is slightly reduced by the use of lambda parameters named '__' for no-op consumers, which may be unclear to some readers, and the chained builder pattern in the RequestHeaderData construction is dense. The class is concise, methods perform single actions, and the flow is natural.
Run 1
Code Structure: Clearly organized context class with constructor delegation, accessors, and quota handling; placing the static helper before fields slightly interrupts conventional organization. Nesting: Very shallow, with no complex control flow. Clarity of intent: Descriptive names, explicit time units, and quota documentation communicate purpose well, though the '__' lambda parameter and implicit no-op quota behavior are less self-explanatory. Code length: Appropriately concise; constructor overloads add repetition but support distinct initialization paths. Action granularity: Assignments and chained header setters generally occupy separate lines, making individual actions easy to follow. Reading flow: Consistent formatting and straightforward delegation make the class easy to scan, although the multiline constructor invocation requires modest attention.
Run 2
Code Structure: Clearly organized around immutable fields, delegating constructors, accessors, and quota application, though placing the static helper before fields slightly interrupts conventional organization. Nesting: Minimal nesting; constructor delegation and a fluent builder keep control flow flat. Clarity of intent: Descriptive class, method, and parameter names make the purpose clear, with useful quota documentation. The no-op lambdas and double-underscore parameters are slightly less explicit. Code length: Concise overall; constructor overloads add some repetition but support distinct initialization paths. Action granularity: Assignments and fluent setter calls occupy separate lines; the timeout conversion combines straightforward operations in one expression. Reading flow: Consistent formatting and predictable delegation make the code easy to follow, although import grouping and the long timeout expression could be improved.
Run 3
Code Structure: Clearly organized into a deadline utility, immutable fields, delegating constructors, accessors, and quota application; placing the utility before fields slightly interrupts conventional organization. Nesting: Very shallow, with no nested control flow. Clarity of intent: Descriptive names, explicit time units, and quota documentation communicate purpose well, though the empty lambdas and '__' parameter are less self-explanatory. Code length: Concise for its responsibilities; constructor overloads add some repetition but reuse initialization effectively. Action granularity: Assignments and accessor returns each perform one action per line; the request-header builder chain separates each setter clearly. Reading flow: Consistent formatting and constructor delegation make the class easy to follow, with minor friction from densely grouped imports and the long deadline-conversion expression.