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 with clear separation of concerns through static utility methods. It uses flat nesting with only single-level conditionals, making the logic easy to follow. Each method has a clear purpose, supported by concise Javadoc comments. The code is appropriately concise without unnecessary verbosity. Action granularity is generally good, though the reassignment of 'exception' in isTimeoutException combines multiple actions in one line. Reading flow is natural, with methods ordered logically and consistent error message patterns. Minor deductions for the null check style and slight repetition in error messages, but overall this is highly readable production-quality code.
Run 3
The code is well-structured with clear separation of methods, each handling one responsibility. Nesting is minimal, with early returns in the timeout check improving clarity. Javadocs adequately explain each method's purpose. The code is concise, avoiding unnecessary verbosity. Action granularity is good, though conditional returns put multiple logical actions on single lines, slightly reducing readability. Reading flow is natural, with logical method ordering. Minor deductions: the timeout method's variable reassignment could be clearer, and if-else branches duplicate the 'No controller' message, which could be extracted to a constant for better maintainability.
Run 1
Code Structure: Three small, logically separated utility methods make the class easy to navigate. Nesting: Shallow conditionals and early returns keep control flow simple; else blocks after returns are unnecessary but harmless. Clarity of intent: Descriptive method names, explicit exception messages, and Javadoc clearly explain each method's purpose. Code length: The implementation is concise, although documentation and repeated inactive-controller messages add minor redundancy. Action granularity: Statements generally perform one action each, but inline null checks combine a condition and return on one line. Reading flow: Consistent formatting and straightforward branching provide a natural flow; import grouping and a blank line after the package declaration would improve presentation.
Run 2
Code Structure: Three focused utility methods are logically organized and clearly separated. Nesting: Shallow conditionals and early returns keep complexity low. Clarity of intent: Descriptive method names, explicit exception messages, and Javadoc make each purpose easy to understand. Code length: Methods are concise, though redundant else branches after returns and repeated exception construction add minor verbosity. Action granularity: Statements generally perform one action each; inline null-check returns slightly compress condition and action. Reading flow: Consistent formatting and straightforward control flow support natural reading, although import grouping and a blank line after the package declaration could improve visual organization.
Run 3
Code Structure: Three focused utility methods are logically organized with clear documentation. Nesting: Control flow is shallow, using guard clauses and simple if/else branches. Clarity of intent: Descriptive method names, types, and exception messages make each method's purpose explicit. Code length: Methods are concise; repeated inactive-controller messages and unnecessary else branches add minor verbosity. Action granularity: Statements generally perform one action each, though inline null-check returns slightly compress the layout. Reading flow: Consistent formatting and straightforward branching support natural top-to-bottom reading; import grouping and spacing could be improved.