Source code
package org.apache.kafka.streams.internals;
import org.apache.kafka.common.config.ConfigDef;
import org.apache.kafka.common.config.ConfigException;
import org.apache.kafka.common.utils.Utils;
import org.apache.kafka.streams.state.HostInfo;
public class ApplicationServerConfigValidator implements ConfigDef.Validator {
@Override
public void ensureValid(final String name, final Object value) {
if (!(value instanceof String)) {
throw new ConfigException(name + " must be a string");
}
final String endPoint = (String) value;
if (Utils.isBlank(endPoint)) {
return;
}
try {
HostInfo.buildFromEndpoint(endPoint);
} catch (final ConfigException e) {
throw new ConfigException(name, value, e.getMessage());
}
}
@Override
public String toString() {
return "A host:port pair, protocol://host:port, or an empty string";
}
}
Run 1
The code is highly readable. It follows a clear logical structure: type check, blank check, validation, and error wrapping. The method is flat with no deep nesting. Each action is on its own line, and the intent is straightforward. The toString method clearly documents acceptable formats. Minor improvements could include a more descriptive exception message, but overall the code is concise, well-organized, and easy to follow.
Run 2
The code is highly readable due to its clear logical structure, flat nesting, and explicit intent. The class has a single responsibility (validating application server config), and the ensureValid method follows a straightforward validation flow: type check, blank check, and endpoint validation. Each action is on its own line, and the exception handling wraps only the minimal code that can fail. Variable names are descriptive, and the error messages are clear. Minor improvements could include extracting the 'must be a string' message to a constant or adding comments for the blank-string short-circuit, but these are negligible.
Run 3
The code is well-structured with clear separation of concerns. The validator implements a single responsibility and follows a logical flow: type check, blank check, and endpoint parsing. Nesting is minimal with no deep indentation levels. Intent is clear - validate application server configuration strings. The code is concise with no unnecessary verbosity. Each line performs a single focused action. Reading flow is natural, progressing from validation to exception handling. Minor improvements could include extracting the error message or adding null check documentation, but overall this is highly readable code.
Run 1
Code Structure: A focused validator class cleanly separates validation from its descriptive string. Nesting: Guard clauses and an early return keep nesting shallow; the try/catch is straightforward. Clarity of intent: Descriptive names and explicit type, blank-value, and endpoint checks make the purpose clear, although accepted endpoint formats depend on HostInfo.buildFromEndpoint. Code length: Concise, with no unnecessary logic or repetition. Action granularity: Each statement performs a single clear action. Reading flow: Validation proceeds naturally from type checking to blank handling to endpoint parsing, with contextual exception wrapping. Minor formatting improvements, such as blank lines between the package and imports and before the try block, could improve readability.
Run 2
Code Structure: A focused validator class cleanly separates validation from its descriptive string. Nesting: Guard clauses keep control flow flat, with only a simple try/catch. Clarity of intent: Descriptive class and method names make the purpose clear; endpoint parsing is delegated to HostInfo. Code length: Concise, with no redundant logic. Action granularity: Each statement performs one action, and checks, conversion, parsing, and exception handling are separated. Reading flow: Validation proceeds naturally from type checking to blank handling to endpoint parsing. Minor readability limitations include the lack of spacing between the package and imports and the implicit decision to accept blank strings.
Run 3
Code Structure: Validation is logically organized into type checking, blank handling, and endpoint parsing. Nesting: Guard clauses keep the method flat, with only a simple try/catch. Clarity of intent: The class name, validator interface, and descriptive toString clearly convey its purpose; accepting blank values is evident, though not explained. Code length: Concise, with no unnecessary logic. Action granularity: Each statement performs one clear action. Reading flow: The sequence naturally progresses from basic checks to endpoint validation and error reporting. Minor formatting improvements, such as separating the package declaration from imports and adding a blank line before try, would improve readability.