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 well-structured with a clear single responsibility: validating endpoint configurations. It uses early returns to avoid unnecessary nesting and keeps logic flat. Each action is on its own line, improving readability. The method names and flow are intuitive, and exception handling is concise without being cryptic. The only minor deductions are for casting and the slightly implicit contract of 'HostInfo.buildFromEndpoint,' but overall it is clean, maintainable, and easy to follow.
Run 2
The code is highly readable. It has a clear, logical structure with a single-purpose class implementing a config validator. Nesting is minimal with only one level of depth. The method name 'ensureValid' clearly expresses intent, and the toString method neatly documents the expected format. The method is concise, avoiding unnecessary length. Each action (type check, null/blank check, endpoint parsing, exception handling) is on its own line, improving clarity. Reading flow is natural: validate type, allow blank, attempt parsing, wrap errors. Minor deductions could be made for the multiple return/throw paths, but overall this is exemplary readable code.
Run 3
The code is well-structured and readable. It has a clear purpose: validating application server configuration. The class and method names are descriptive. Nesting is minimal, with early exit for non-string values and blank strings, reducing complexity. Each line performs a single logical action, and the reading flow is natural. Error handling is explicit and properly wraps the original ConfigException with context. The only minor deductions are for the lack of explanatory comments about valid formats (though the toString method partially compensates) and the unusual capitalization/spacing in the package name. Overall, the code is concise, clear, and maintainable.
Run 1
Code Structure: A focused validator class cleanly separates validation from its descriptive string. Nesting: Shallow conditionals and an early return keep the main path flat; exception handling is straightforward. Clarity of intent: Descriptive names and standard validation patterns make the purpose clear, though acceptance of blank strings is implicit rather than explained. Code length: Concise, with no unnecessary logic or duplication. Action granularity: Each statement performs one distinct action, making the checks and exception conversion easy to follow. Reading flow: Validation proceeds naturally from type checking to blank-value handling to endpoint parsing. Minor formatting improvements, such as separating the package declaration from imports, would improve readability.
Run 2
Code Structure: A focused validator class cleanly separates validation from its descriptive string. Nesting: Shallow conditionals and an early return keep the main path flat; the try/catch is straightforward. Clarity of intent: Descriptive names and explicit checks clearly convey string-type validation, blank-value acceptance, and endpoint validation. Code length: Concise, with no unnecessary logic or duplication. Action granularity: Each statement performs one clear action, and the cast is separated from subsequent checks. Reading flow: Validation proceeds naturally from type checking to blank handling to endpoint parsing, with contextual exception reporting. Minor formatting improvements, such as a blank line after the package declaration and before the try block, would improve visual separation.
Run 3
Code Structure: Validation is logically organized into type checking, blank-value handling, and endpoint parsing. Nesting: Guard clauses keep control flow flat, with only a simple try/catch. Clarity of intent: The class and method names clearly convey validation, and toString documents accepted formats; delegating endpoint parsing slightly hides the validation details. Code length: Compact without unnecessary statements. Action granularity: Each statement performs a single clear action. Reading flow: Execution progresses naturally from basic checks to parsing and contextual error reporting. Minor formatting improvements, such as separating the package declaration from imports and adding a blank line before try, would improve readability.