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 functional but suffers from poor formatting and structure. The entire first line is a single line containing all package and import declarations, which severely hurts readability. Multiple class-level and method-level comments are placed at the end of previous lines rather than on their own lines, disrupting visual scanning. Braces are inconsistently indented and sometimes on the same line as the closing statement, which obscures code blocks. The isTimeoutException method has moderate nesting and mutates a parameter, which reduces clarity. While variable names are reasonable and there is some Javadoc, the overall presentation makes the code appear tangled and unprofessionally organized. The logic itself is not deeply nested, but the formatting choices heavily undermine readability.
Run 2
The code has a clear purpose and reasonable method-level organization, but suffers from formatting issues and some awkward control flow. Method signatures are on one line and there are minor indentation inconsistencies (e.g., misplaced comment placement, inconsistent brace positioning). The isTimeoutException method has a slightly tangled control flow with nested conditionals and reassignment of the exception parameter, which reduces clarity. The two exception factory methods are repetitive and could be refactored, though they are straightforward. Action granularity is mostly acceptable, with one logical action per line. Overall, the code is understandable but would benefit from consistent formatting and a small refactor to reduce duplication.
Run 3
The code is generally readable but has formatting inconsistencies. The package/import lines are crammed together, reducing readability. Javadoc comments are present and clear, which helps intent. Nesting is mostly flat, except for some minor if-else blocks. Action granularity is adequate, though some lines combine multiple actions (e.g., the package and import statements). Reading flow is disrupted by inconsistent indentation and brace placement, especially around else blocks. The methods are concise and logically structured, but the overall presentation could be improved with consistent formatting and line breaks.
Run 1
Code Structure: Three focused utility methods provide logical organization, but compressed package declarations, imports, and class boundaries obscure it. Nesting: Shallow conditionals and early returns keep complexity low. Clarity of intent: Descriptive method names, explicit exception types, and Javadoc make each method’s purpose clear. Code length: The implementation is concise, although repeated exception construction and verbose documentation add some redundancy. Action granularity: Several lines combine declarations, conditionals, returns, or closing braces, making individual actions harder to scan. Reading flow: The methods follow a natural sequence, but inconsistent whitespace, inline statements, and awkward brace placement interrupt reading. Overall, straightforward logic and clear naming are weakened primarily by poor formatting.
Run 2
Code Structure: Three logically separated utility methods provide clear organization, but compressed package, imports, and class declarations weaken presentation. Nesting: Shallow conditionals and early returns keep complexity low. Clarity of intent: Descriptive method names, explicit exception messages, and Javadoc make each method's purpose clear. Code length: The implementation is concise, although documentation is relatively verbose and some else branches could be omitted after returns. Action granularity: Several declarations and conditional statements share lines, making individual actions harder to distinguish. Reading flow: Inconsistent line breaks, indentation, and closing-brace placement interrupt otherwise straightforward control flow. Overall, the logic is easy to understand, but formatting substantially reduces readability.
Run 3
Code Structure: Three logically separated utility methods provide good organization, but compressed package, imports, and class declaration obscure boundaries. Nesting: Shallow conditionals and early returns keep complexity low. Clarity of intent: Descriptive method names, explicit exception messages, and Javadoc make each method's purpose clear. Code length: The implementation is reasonably concise, although verbose documentation and unnecessary else branches add some length. Action granularity: Several declarations, checks, returns, and braces share lines, reducing scanability. Reading flow: Inconsistent indentation, inline method declarations, and irregular brace placement interrupt otherwise straightforward control flow. Overall, the logic is easy to understand, but formatting substantially weakens readability.