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 highly readable. It has a clear, logical structure with a single class, well-named fields, and a straightforward constructor. Nesting is minimal (only the class and methods), and there is no complex control flow. The intent is clearly documented with thorough Javadoc comments that explain the purpose of each parameter and method. The code is concise yet sufficiently detailed, avoiding unnecessary verbosity in the implementation while maintaining clarity in documentation. Each action is on its own line, and the reading flow is natural: fields, constructor, then getters. Minor deductions are for the somewhat long Javadoc comments, but these enhance understanding without harming readability.
Run 2
The code is well-structured as a simple immutable data holder with clear field grouping, constructor, and accessor methods. It has a flat structure with no nesting or control flow. Intent is clear from class and method names, and Javadoc is thorough. Code length is concise. Each statement is on its own line with good action granularity. Reading flow is natural, moving from context fields to constructor to getters. Minor deductions: Javadoc is somewhat verbose for trivial accessors, and constructor parameter order differs from field declaration order, slightly disrupting readability.
Run 3
The code is highly readable due to its logical structure, flat nesting, clear documentation, and concise implementation. It defines a simple immutable data class with three private final fields, a single constructor with validation, and straightforward getter methods. Javadoc comments provide thorough context for non-obvious parameters like networkReceive and nowNanos. Naming is descriptive and consistent. The constructor validates inputs using Objects.requireNonNull, enhancing robustness without clutter. Each getter is a single action with no complex logic. The only minor deductions are for slightly verbose Javadoc (some repetition between field and method docs) and the import placement style. Overall, it exemplifies clean, maintainable Java code with excellent reading flow.
Run 1
Code Structure: Clearly organized into immutable fields, a constructor, and simple accessors. Nesting: Flat methods with no nested control flow. Clarity of intent: Descriptive names and detailed documentation explain re-authentication context, nullability, and timing semantics. Code length: Implementation is concise, but repeated Javadoc descriptions add unnecessary length. Action granularity: Each statement performs one clear action, including explicit non-null validation. Reading flow: Conventional Java organization makes the class easy to follow; minor inconsistencies between field order and constructor parameter order, along with verbose comments, slightly interrupt the flow.
Run 2
Code Structure: A logically organized context class with private final fields, a constructor, and straightforward accessors. Nesting: Flat methods with no nested control flow. Clarity of intent: Descriptive names and detailed Javadoc clearly explain re-authentication state, nullability, and timing semantics. Code length: Implementation is concise, though repeated documentation about networkReceive and timing adds unnecessary length. Action granularity: Each assignment and return occupies its own line, making operations easy to scan. Reading flow: Fields, initialization, and accessors follow a natural sequence; verbose comments and the long constructor signature slightly interrupt the otherwise smooth 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 the re-authentication context, nullability, and timing semantics. Code length: Implementation is concise, although repeated documentation about networkReceive and timing adds unnecessary length. Action granularity: Each statement performs one clear action. Reading flow: The fields-to-constructor-to-accessors sequence is natural and easy to follow; lengthy comments slightly interrupt scanning.