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 with clear separation of methods and comprehensive Javadoc comments. It has minimal nesting (only one level in each method), making the logic easy to follow. The intent of each method is unambiguous, and the code is concise without unnecessary verbosity. Action granularity is good, with one primary operation per line. Reading flow is natural and logical. Minor deductions: the import section could be grouped more conventionally, and the if-else patterns in the last two methods could use ternary operators for slightly better conciseness, though the current form prioritizes clarity.
Run 2
The code is well-structured with clear separation of methods and good Javadoc documentation. It uses minimal nesting, with only one level in the exception check and simple if-else branches in the factory methods. Intent is explicit through descriptive method names and comments. Lines are concise and mostly perform one action, though a few string concatenations are slightly broken for line length. Reading flow is natural, starting with a utility check and moving to exception factories. Minor improvements could include extracting the repeated 'No controller appears to be active' message into a constant to reduce duplication, and simplifying the if-else in isTimeoutException to a more direct null-safe cause check. Overall, the code is highly readable and maintainable.
Run 3
The code is well-structured with a clear, single-purpose class and logically separated methods. Nesting is minimal, with only simple one-level conditionals. Each method has a clear intent and is documented with concise Javadoc. The code is concise without excess verbosity, and each action generally fits on a single line or a cleanly broken string concatenation. Reading flow is natural, from generic exception handling to controller-specific cases. Minor improvements could include using an early return to simplify the conditionals in newPreMigrationException and newWrongControllerException, but the current flat structure is already very readable.
Run 1
Code Structure: Three focused utility methods are logically organized and clearly separated. Nesting: Shallow conditionals and early returns keep control flow easy to follow. Clarity of intent: Descriptive method names, Javadoc, and explicit exception messages communicate each method's purpose; the pre-migration method's handling of an absent controller is slightly broader than its description. Code length: Implementation is concise, though repeated inactive-controller messages and unnecessary else blocks 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 branches provide a natural flow; import grouping and spacing after the package declaration could be improved.
Run 2
Code Structure: Three small, logically separated utility methods provide clear organization. Nesting: Shallow conditionals and early returns keep control flow easy to follow. Clarity of intent: Descriptive method names, Javadoc, and explicit exception messages communicate purpose well. Code length: Methods are concise, though repeated inactive-controller messages and unnecessary else blocks add minor redundancy. Action granularity: Statements generally perform one action each; inline null checks slightly compress condition and return onto one line. Reading flow: Methods read naturally from validation to result, with consistent formatting overall. Minor improvements include separating package and imports with whitespace, grouping imports consistently, and expanding inline conditionals for visual consistency.
Run 3
Code Structure: Three focused methods are logically organized in a small utility class. Nesting: Shallow conditionals and early returns keep complexity low. Clarity of intent: Descriptive method names, explicit exception messages, and Javadoc clearly explain each method's purpose. Code length: Methods are concise, though redundant else branches after returns and repeated inactive-controller messages 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 branching make execution easy to follow, although import grouping and spacing could be improved.