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 clear naming conventions, demonstrates logical organization, and maintains flat nesting throughout. The constructor overloading with delegation reduces duplication effectively. The static helper method is concise and purpose-driven. While slightly verbose due to multiple constructors and a no-op lambda default, this is reasonable for the flexibility needed. The optional quota applier parameter is handled cleanly with default no-op implementations. Javadoc on the quota method clarifies intent. Overall, natural reading flow with one action per line.
Run 3
The code is well-structured with clear separation of concerns: static utility method, fields, constructors, and accessors. Nesting is minimal—only one chained builder in the AuthorizableRequestContext constructor. Intent is evident from descriptive names like 'partitionChangeQuotaApplier' and 'requestTimeoutMsToDeadlineNs'. Length is appropriate; the multiple constructors with delegation reduce duplication. Action granularity is good, with one operation per line in the builder and constructor assignments. Reading flow is natural: static method first, then fields, constructors, and methods. Minor deductions: the lambda parameter '__' is slightly unclear, and the static import of time constants could be marginally less readable than qualified names for some readers.
Run 1
Code Structure: Clearly organized around immutable fields, delegating constructors, accessors, and quota application, though placing the static utility before fields slightly interrupts conventional ordering. Nesting: Minimal nesting; constructor delegation and a fluent setter chain remain easy to follow. Clarity of intent: Descriptive names, explicit time units, and quota documentation communicate purpose well; the '__' lambda parameter and undocumented no-op default are minor ambiguities. Code length: Concise overall, with constructor overloads providing useful convenience rather than unnecessary duplication. Action granularity: Assignments and fluent setters occupy separate lines; the deadline calculation combines related operations in one understandable expression. Reading flow: Consistent formatting and straightforward delegation support natural reading, with minor friction from tightly grouped imports and the multiline header-building constructor call.
Run 2
Code Structure: Fields, delegating constructors, accessors, and quota handling are logically organized, though placing the static utility before fields slightly interrupts conventional ordering. Nesting: Minimal nesting keeps the code easy to scan. Clarity of intent: Descriptive names, explicit time units, and quota documentation clearly communicate purpose; the anonymous no-op lambdas could be more self-explanatory. Code length: Concise overall, with constructor overloads avoiding duplicated initialization. Action granularity: Assignments and builder calls each occupy separate lines; the deadline calculation combines related operations appropriately. Reading flow: Consistent formatting and straightforward delegation create a natural flow, with only minor friction from multiline constructor signatures and the chained header construction.
Run 3
Code Structure: Fields, delegating constructors, accessors, and quota application are logically organized, although placing the static helper before fields slightly interrupts conventional ordering. Nesting: Almost entirely flat, with no complex control flow. Clarity of intent: Descriptive names, explicit time units, and quota documentation communicate purpose well; the anonymous no-op lambdas are slightly less obvious. Code length: Concise overall, with constructor delegation avoiding duplicated initialization; overloads add some repetitive boilerplate. Action granularity: Assignments and chained header setters each occupy separate lines, making individual operations easy to follow. Reading flow: Consistent formatting and straightforward delegation create a natural progression, though tightly packed imports and the long deadline-conversion expression modestly reduce scanability.