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 highly readable with clear structure, minimal nesting, and explicit Javadoc explaining each method's purpose. Methods are concise and focused, with one primary operation per line, and the logic flows naturally. The helper methods use straightforward conditional checks, and variable handling (like unwrapping ExecutionException) is easy to follow. Only minor improvements could include reducing slight repetition in exception messages, but overall the code is well-organized and maintainable.
Run 3
The code is well-structured with a clear purpose: providing utility methods for controller exception handling. It is flat (no deep nesting), each method performs a single logical action, and reading flow is natural. Javadocs clarify intent, and null checks are handled explicitly. The main minor deductions are for slight verbosity—the if/else blocks in the two exception-creation methods could be replaced with ternary expressions to reduce length. Also, reassigning the method parameter in `isTimeoutException` slightly impacts clarity, though it remains understandable. Overall, the code is highly readable with only minor opportunities for conciseness.
Run 1
Code Structure: Three focused methods are logically organized in a small exception utility class. Nesting: Control flow is shallow, with early returns and simple conditionals. Clarity of intent: Descriptive method names, explicit exception messages, and Javadoc make each method's purpose clear. Code length: Implementation is concise, although the Javadoc is somewhat repetitive and else blocks after returns are unnecessary. Action granularity: Most lines perform one action; inline null-check returns slightly compress condition checking and branching. Reading flow: Methods read naturally from checks to results, with consistent formatting. Minor improvements include separating package and import sections with whitespace and using consistent braced conditionals.
Run 2
Code Structure: Three focused methods are logically organized in a single exception utility class. Nesting: Shallow conditionals and early returns keep control flow easy to follow. Clarity of intent: Descriptive method names, explicit exception messages, and Javadoc clearly communicate purpose. Code length: Methods are concise, although repeated inactive-controller messages and unnecessary else branches add minor redundancy. Action granularity: Statements generally perform one action; inline null-check returns slightly compress condition and action but remain readable. Reading flow: Each method progresses naturally from checking conditions to producing a result. Minor formatting issues, including ungrouped imports and missing braces around inline guards, slightly reduce consistency.
Run 3
Code Structure: Three focused utility methods provide clear logical organization. Nesting: Shallow conditionals and early returns keep complexity low. Clarity of intent: Descriptive method names, explicit exception messages, and Javadoc make each purpose clear. Code length: Methods are concise, although redundant else blocks after returns and repetitive documentation add minor verbosity. Action granularity: Most lines contain one action; inline null checks combine conditions and returns but remain easy to understand. Reading flow: Methods progress naturally from checks to results, with consistent formatting overall. Import grouping and braced null checks could slightly improve visual consistency.