Source code
package org.apache.kafka.common.network;
import java.util.Objects;
/**
* Defines the context in which an {@link Authenticator} is to be created during
* a re-authentication.
*/
public class ReauthenticationContext {
private final NetworkReceive networkReceive;
private final Authenticator previousAuthenticator;
private final long reauthenticationBeginNanos;
/**
* Constructor
*
* @param previousAuthenticator
* the mandatory {@link Authenticator} that was previously used to
* authenticate the channel
* @param networkReceive
* the applicable {@link NetworkReceive} instance, if any. For the
* client side this may be a response that has been partially read, a
* non-null instance that has had no data read into it yet, or null;
* if it is non-null then this is the instance that data should
* initially be read into during re-authentication. For the server
* side this is mandatory and it must contain the
* {@code SaslHandshakeRequest} that has been received on the server
* and that initiates re-authentication.
*
* @param nowNanos
* the current time. The value is in nanoseconds as per
* {@code System.nanoTime()} and is therefore only useful when
* compared to such a value -- it's absolute value is meaningless.
* This defines the moment when re-authentication begins.
*/
public ReauthenticationContext(Authenticator previousAuthenticator, NetworkReceive networkReceive, long nowNanos) {
this.previousAuthenticator = Objects.requireNonNull(previousAuthenticator);
this.networkReceive = networkReceive;
this.reauthenticationBeginNanos = nowNanos;
}
/**
* Return the applicable {@link NetworkReceive} instance, if any. For the client
* side this may be a response that has been partially read, a non-null instance
* that has had no data read into it yet, or null; if it is non-null then this
* is the instance that data should initially be read into during
* re-authentication. For the server side this is mandatory and it must contain
* the {@code SaslHandshakeRequest} that has been received on the server and
* that initiates re-authentication.
*
* @return the applicable {@link NetworkReceive} instance, if any
*/
public NetworkReceive networkReceive() {
return networkReceive;
}
/**
* Return the always non-null {@link Authenticator} that was previously used to
* authenticate the channel
*
* @return the always non-null {@link Authenticator} that was previously used to
* authenticate the channel
*/
public Authenticator previousAuthenticator() {
return previousAuthenticator;
}
/**
* Return the time when re-authentication began. The value is in nanoseconds as
* per {@code System.nanoTime()} and is therefore only useful when compared to
* such a value -- it's absolute value is meaningless.
*
* @return the time when re-authentication began
*/
public long reauthenticationBeginNanos() {
return reauthenticationBeginNanos;
}
}
Run 1
The code is well-structured with a clear class purpose and logical organization. It uses flat nesting, minimal lines, and one action per line. Javadoc comments thoroughly explain parameters and return values, making intent unambiguous. The constructor and getters follow natural reading flow, and the use of Objects.requireNonNull is concise and clear. Minor deductions for verbose comments slightly increasing length, but overall the code is highly readable.
Run 2
The code is highly readable. It has a clear, logical structure with a single purpose: defining a context object. The class is flat with no nested logic or control flow. Intent is explicit through descriptive names and thorough Javadoc. Code length is appropriate—three fields, one constructor, three getters—with no unnecessary code. Each action is on its own line, especially in the constructor. Reading flow is natural, moving from fields to constructor to accessors. Minor deductions: Javadoc is somewhat verbose in places, and the import of java.util.Objects is slightly separated from the package declaration by only a blank line, though this is typical. Overall, it is concise, well-documented, and easy to understand.
Run 3
The code is highly readable. It has a clean, logical structure with a single class containing three private final fields, a constructor, and three getter methods. Nesting is minimal—no conditional blocks or loops. The intent is clear, both from the class name and the comprehensive Javadoc, which explains the purpose of each parameter and return value. The code is concise, with no unnecessary methods or boilerplate. Each statement performs one action, and the constructor uses `Objects.requireNonNull` to make validation explicit. Reading flow is natural: fields, constructor, then getters in a consistent order. Minor room for improvement could be shortening repetitive Javadoc, but overall this is exemplary readability.
Run 1
Code Structure: A logically organized context class with final fields, a constructor, and straightforward accessors. Nesting: Flat, with no nested control flow. Clarity of intent: Descriptive names and detailed documentation clearly explain re-authentication state, nullability, and timing semantics. Code length: Implementation is concise, though documentation repeats substantial details between the constructor and accessors. Action granularity: Each statement performs one clear action, including explicit null validation. Reading flow: Conventional field–constructor–accessor ordering makes the class easy to follow; minor field-order differences and verbose comments slightly interrupt an otherwise natural flow.
Run 2
Code Structure: Logically organized as fields, constructor, and accessors, with a single clear responsibility. Nesting: Flat methods with no nested control flow. Clarity of intent: Descriptive names, final fields, explicit null validation, and documentation clearly explain the context and timing semantics. Code length: Implementation is concise, but lengthy, duplicated documentation adds avoidable reading overhead. Action granularity: Each statement performs one action, and each accessor returns one field. Reading flow: Conventional ordering and consistent formatting make the class easy to follow; the long constructor signature and repetitive comments slightly interrupt the flow.
Run 3
Code Structure: Logically organized into immutable fields, a constructor, and simple accessors. Nesting: Flat, with no nested control flow. Clarity of intent: Descriptive names and detailed documentation clearly explain re-authentication context, nullability, and timing semantics. Code length: Implementation is concise, though repeated Javadoc descriptions make the class longer than necessary. Action granularity: Each statement performs a single assignment, validation, or return. Reading flow: Natural progression from state to initialization to accessors; lengthy duplicated comments slightly interrupt scanning.