Source code
package org.apache.kafka.security.authorizer;
import org.apache.kafka.common.internals.Plugin;
import org.apache.kafka.common.metrics.Metrics;
import org.apache.kafka.common.resource.Resource;
import org.apache.kafka.common.utils.Utils;
import org.apache.kafka.server.authorizer.Authorizer;
import java.util.Map;
public class AuthorizerUtils {
public static Plugin<Authorizer> createAuthorizer(String className, Map<String, Object> configs, Metrics metrics, String key, String role) throws ClassNotFoundException {
Authorizer authorizer = Utils.newInstance(className, Authorizer.class);
authorizer.configure(configs);
return Plugin.wrapInstance(authorizer, metrics, key, "role", role);
}
public static boolean isClusterResource(String name) {
return name.equals(Resource.CLUSTER_NAME);
}
}
Run 1
The code is highly readable and follows clean coding principles. It has a clear, logical structure with two concise methods that each serve a single purpose. Nesting is non-existent, and clarity of intent is strong: the method names clearly describe what each does. The code is concise without being overly compact, with one primary action per line. Reading flow is natural and straightforward. Minor improvements could include adding a private constructor to prevent instantiation of a utility class, which would slightly improve design, but this does not significantly affect readability.
Run 2
The code is highly readable with a clear, logical structure: methods are focused and follow a natural flow. Nesting is flat, with only a single conditional expression in isClusterResource. Intent is evident from method names and parameter names, though the 'key' and 'role' parameters in createAuthorizer could be clarified with documentation. Code length is concise, but the import of Resource is unnecessary for the shown logic (it's used only as a string constant), and the long parameter list affects readability slightly. Action granularity is good—each line performs one action. Reading flow is logical: instantiate, configure, wrap, return. Minor improvements would include removing unused imports, adding Javadoc to explain parameters, and perhaps simplifying the static method calls. Overall, the code is clean, maintainable, and easy to understand.
Run 3
The code is highly readable. It has a clear, logical structure with two distinct utility methods, minimal nesting, and concise length. Each method has a single, obvious purpose, with one action per line. The reading flow is natural and the imports are well-organized. Minor deductions: the isClusterResource method could be replaced with a simple direct call, and the 'role' string is slightly redundant as a parameter name, but overall clarity is excellent.
Run 1
Code Structure: Two small utility methods are logically organized and independent. Nesting: No nested control flow, making both methods easy to scan. Clarity of intent: Descriptive method names and straightforward calls clearly communicate authorizer creation and cluster-resource identification; generic parameters such as key and role provide slightly less context. Code length: Concise, with no unnecessary logic, though the long createAuthorizer signature reduces readability. Action granularity: Each statement performs one clear action. Reading flow: Instantiation, configuration, and wrapping follow a natural sequence. Missing spacing between the package declaration and imports slightly weakens visual organization.
Run 2
Code Structure: Two focused utility methods provide clear, logical organization. Nesting: Both methods are flat, with no nested control flow. Clarity of intent: Descriptive method names and straightforward calls make authorizer creation and cluster-resource checking easy to understand, though generic parameters such as key and role provide limited context. Code length: The implementation is concise without unnecessary logic, but the long createAuthorizer signature would benefit from wrapping. Action granularity: Each statement performs one distinct action. Reading flow: Instantiation, configuration, and wrapping follow a natural sequence; blank lines separating the package, imports, and class declaration would improve visual readability.
Run 3
Code Structure: Two focused utility methods provide clear, logical organization. Nesting: Both methods are flat, with no nested control flow. Clarity of intent: Descriptive method names and straightforward calls clearly communicate authorizer creation and cluster-resource checking, though key and role could use documentation. Code length: The implementation is concise without unnecessary statements; the long createAuthorizer signature would be easier to scan across multiple lines. Action granularity: Each statement performs one distinct action. Reading flow: Instantiation, configuration, and wrapping follow a natural sequence. Minor formatting issues, including the lack of blank lines between the package declaration and imports and between import groups, slightly reduce readability.