Source code
package org.apache.kafka.controller.errors;
import org.apache.kafka.common.errors.NotControllerException;
import org.apache.kafka.common.errors.TimeoutException;
import java.util.OptionalInt;
import java.util.concurrent.ExecutionException;
public class ControllerExceptions {
/**
* Check if an exception is a normal timeout exception.
*
* @param exception The exception to check.
* @return True if the exception is a timeout exception.
*/
public static boolean isTimeoutException(Throwable exception) {
if (exception == null) return false;
if (exception instanceof ExecutionException) {
exception = exception.getCause();
if (exception == null) return false;
}
return exception instanceof TimeoutException;
}
/**
* Create a new exception indicating that the controller is in pre-migration mode, so the
* operation cannot be completed.
*
* @param controllerId The current controller.
* @return The new NotControllerException.
*/
public static NotControllerException newPreMigrationException(OptionalInt controllerId) {
if (controllerId.isPresent()) {
return new NotControllerException("The controller is in pre-migration mode.");
} else {
return new NotControllerException("No controller appears to be active.");
}
}
/**
* Create a new exception indicating that current node is not the controller.
*
* @param controllerId The current controller.
* @return The new NotControllerException.
*/
public static NotControllerException newWrongControllerException(OptionalInt controllerId) {
if (controllerId.isPresent()) {
return new NotControllerException("The active controller appears to be node " +
controllerId.getAsInt() + ".");
} else {
return new NotControllerException("No controller appears to be active.");
}
}
}
Run 1
The code is well-structured, using a clean utility class with three static methods, each serving a clear purpose. Nesting is minimal, limited to straightforward conditional checks. Variable and method names (e.g., `isTimeoutException`, `newPreMigrationException`) clearly communicate intent. The code is concise, with each method focused on a single task. The `isTimeoutException` method uses early returns for flat, readable logic. Action granularity is good, with one logical operation per line. Reading flow is natural, moving from exception checking to exception creation. Minor deductions: repeated 'No controller appears to be active.' string could be extracted for consistency, and some string concatenation in `newWrongControllerException` is slightly awkward but not unreadable.
Run 2
The code is well-structured and highly readable. Each method has a clear purpose, and Javadoc comments succinctly explain intent. The methods are concise, with minimal nesting and mostly one action per line. The reading flow is natural, and conditional logic is simple if-else branching. Minor deductions: the redundant else blocks slightly increase length, and isTimeoutException mutates the exception parameter, which could be slightly clearer with a local variable. Overall, very clean code.
Run 3
The code is well-structured with clear separation of concerns and consistent formatting. The class is logically organized with three methods, each with a single responsibility. Nesting is minimal - only one level in the helper methods with early returns, which improves readability. The intent is immediately clear from descriptive method names (isTimeoutException, newPreMigrationException, newWrongControllerException) and helpful Javadoc comments. The code is concise without being cryptic, with appropriate use of early returns to avoid unnecessary nesting. Each line performs a single logical action, and the reading flow is natural from top to bottom. The only minor deductions are for the slightly redundant if-else structures in the exception creation methods and the absence of a private constructor for what appears to be a utility class.
Run 1
Code Structure: Three focused utility methods are logically organized, with minor duplication in the inactive-controller message. Nesting: Shallow conditionals and early returns keep control flow simple. Clarity of intent: Descriptive method names, explicit exception types, and Javadoc clearly communicate purpose. Code length: The implementation is concise; else branches after returns and repetitive documentation add slight verbosity. Action granularity: Most lines perform one action, although inline null checks combine a condition and return on one line. Reading flow: Consistent formatting and straightforward branching make the code easy to follow; separating package and import sections and grouping imports consistently would improve presentation.
Run 2
Code Structure: Three focused utility methods are logically organized with helpful documentation. Nesting: Control flow is shallow, with guard clauses and simple if/else branches. Clarity of intent: Descriptive method names, explicit exception types, and clear messages make each purpose easy to understand. Code length: Methods are short and appropriately scoped, though else blocks after returns and repeated exception construction add minor redundancy. Action granularity: Each statement performs one action; inline null-check returns slightly compress the formatting without obscuring behavior. Reading flow: The code progresses naturally from validation to exception inspection or construction. Minor improvements include separating imports from the package declaration, grouping imports consistently, and using braces for inline conditionals.
Run 3
Code Structure: Three focused methods are logically organized within a cohesive exception utility class. Nesting: Shallow conditionals and early returns keep control flow easy to follow. Clarity of intent: Descriptive method names, JavaDoc, and explicit exception messages clearly communicate purpose. Code length: Methods are short and appropriately sized, although repeated inactive-controller messages and unnecessary else blocks add minor redundancy. Action granularity: Most lines perform one action; inline null checks combine a condition and return but remain understandable. Reading flow: Consistent formatting and straightforward branching support natural reading. Minor drawbacks include reassigning the exception parameter and limited spacing around the package and imports.