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 follows a clear, logical structure with fields, constructor, and accessors arranged conventionally. Nesting is minimal and flat. The intent is unambiguous, supported by thorough Javadoc comments that explain the purpose and nuance of each parameter. The code is concise, with no unnecessary repetition or dead code. Each action is on its own line, improving clarity. Reading flow is natural: fields, then constructor, then getters match typical Java style. Minor deductions: the verbose Javadoc slightly reduces skimmability, but overall the code is exemplary.
Run 3
The code is well-structured with clear separation of fields, constructor, and accessor methods. Nesting is minimal, as the class is flat and straightforward. Intent is explicit through thorough Javadoc comments, especially for the complex networkReceive parameter. Code length is appropriate for a simple data holder class, though the Javadocs are slightly verbose. Action granularity is good, with one assignment per line. Reading flow is natural: fields, constructor, then getters in logical order. Minor deductions for redundancy in Javadoc return descriptions and a missing blank line between the package and import statements.
Run 1
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 documentation clearly explain re-authentication state, nullability, and timestamp semantics. Code length: Implementation is concise, though repeated Javadoc descriptions make the overall class longer than necessary. Action granularity: Each statement performs one clear assignment, validation, or return. Reading flow: The conventional fields–constructor–accessors layout is easy to follow; minor field/constructor ordering differences and verbose comments slightly interrupt an otherwise natural flow.
Run 2
Code Structure: Fields, constructor, and accessors are logically organized in a simple context class. Nesting: No nested control flow; methods are flat and easy to scan. Clarity of intent: Descriptive names, final fields, null validation, and detailed documentation clearly communicate purpose and constraints. Code length: Implementation is concise, although repeated Javadoc descriptions make the class longer than necessary. Action granularity: Each assignment and return occupies its own line, with no bundled operations. Reading flow: The progression from state to initialization to accessors is natural. Minor distractions include the long constructor signature and lack of a blank line between the package declaration and import.
Run 3
Code Structure: Fields, constructor, and accessors are logically organized in a simple context class. Nesting: No nested control flow; all methods are flat and easy to follow. Clarity of intent: Descriptive names and documentation clearly explain re-authentication state, nullability, and timing semantics. Code length: Implementation is concise, although repeated, lengthy Javadoc adds unnecessary reading overhead. Action granularity: Each statement performs one clear action, including explicit validation of the previous authenticator. Reading flow: The progression from state declaration to initialization and accessors is natural. Minor formatting issues, such as the missing blank line after the package declaration and a long constructor signature, slightly reduce polish.