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 with clear separation of concerns, minimal nesting, and concise methods. Constructor overloading and delegation are handled cleanly, avoiding duplication. Naming is descriptive and consistent, making intent clear. The helper method requestTimeoutMsToDeadlineNs is straightforward, though the conversion could be slightly more readable with TimeUnit.MILLISECONDS.toNanos(). The use of lambda placeholders (__ -> { }) slightly reduces readability but is acceptable. Overall, the code flows naturally and is easy to follow.
Run 3
The code is generally well-structured and readable. It uses clear naming conventions, separates methods logically, and keeps nesting flat. The purpose of each method is evident, and the use of overloaded constructors is clean. The `partitionChangeQuotaApplier` parameter uses a no-op lambda default, which is concise. However, there are minor readability issues: the static import of time units is used but not obvious at first glance, and the `requestTimeoutMsToDeadlineNs` method has a slightly long parameter list and expression that could be broken for clarity. Overall, the code is maintainable and easy to follow, with only small areas for improvement.
Run 1
Code Structure: Logically organized around a request-context class, with constructor delegation avoiding duplicated initialization. Nesting: Very shallow; no complex branches or loops. Clarity of intent: Descriptive field and method names, explicit time units, and quota-method documentation make the purpose clear. The no-op lambda parameter '__' and undocumented quota callback slightly reduce clarity. Code length: Concise overall; constructor overloads and simple accessors add justified boilerplate. Action granularity: Assignments and chained header setters occupy separate lines, making individual operations easy to identify. Reading flow: Constructors lead naturally into accessors and quota application. Minor distractions include the utility method preceding fields, tightly grouped imports, and the long deadline-conversion expression.
Run 2
Code Structure: Well-organized context class with immutable fields, delegating constructors, simple accessors, and a focused quota method; placing the static helper before fields slightly interrupts conventional ordering. Nesting: Very shallow, with no nested control flow. Clarity of intent: Descriptive names, explicit time units, and quota documentation make the purpose clear, though the no-op lambdas and '__' parameter are less self-explanatory. Code length: Concise overall; constructor overloads add length but avoid duplicated initialization. Action granularity: Assignments and chained header setters are clearly separated, with one meaningful action per line; the deadline calculation is compact but slightly long. Reading flow: Constructor delegation and consistent formatting support natural reading, although import grouping and the expanded constructor formatting could be polished.
Run 3
Code Structure: Fields, delegating constructors, accessors, and quota handling are logically organized, though placing the static utility before fields slightly interrupts the layout. Nesting: Very shallow, with no nested control flow. Clarity of intent: Descriptive names, explicit time units, and quota documentation make the purpose clear; the '__' lambda parameter and undocumented no-op defaults are minor weaknesses. Code length: Concise for the functionality, with constructor delegation avoiding duplicated initialization. Action granularity: Assignments and chained header setters generally occupy separate lines; the deadline calculation combines closely related operations clearly. Reading flow: Consistent formatting and straightforward delegation support natural reading, although multiple constructor overloads require some tracing.