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 concise, well-structured, and follows clean coding principles. It avoids unnecessary nesting and keeps methods short with clear, single-purpose actions. Each line generally performs one logical action, improving readability. The method names clearly convey their intent, such as 'createAuthorizer' and 'isClusterResource'. Imports are organized, and the overall flow is natural. Minor deductions for slightly dense argument lists and a hard-coded string 'role' that could be a constant, but overall the code is highly readable.
Run 3
The code is concise and clear, with a logical structure and minimal nesting. The createAuthorizer method performs a chain of well-named operations, each on its own line, enhancing readability. The isClusterResource method is a simple one-liner with a clear purpose. However, minor issues reduce clarity: the string literal "role" in the Plugin.wrapInstance call is a magic value while the parameter 'role' is used for the value, which may confuse intent; also, the class lacks a Javadoc comment explaining its utility purpose. Overall, the code is easy to read and maintain.
Run 1
Code Structure: A small utility class cleanly separates authorizer creation from resource identification. Nesting: Both methods are flat, with no nested control flow. Clarity of intent: Descriptive method and variable names make their purposes clear, although the generic parameter name 'key' and literal 'role' provide limited context. Code length: The implementation is concise without unnecessary statements, but the long createAuthorizer signature would benefit from line wrapping. Action granularity: Each statement performs one primary action, making initialization, configuration, and wrapping easy to distinguish. Reading flow: Operations follow a natural sequence, and the second method is immediately understandable. Missing spacing between the package declaration and imports, along with ungrouped imports, slightly reduces visual readability.
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 operations make authorizer creation and cluster-resource identification easy to understand, though generic parameters such as key and role provide limited context. Code length: The implementation is concise without unnecessary complexity, 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. Minor formatting issues, including no blank line after the package declaration and inconsistent import grouping, slightly reduce 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: Method names and straightforward operations make their purposes clear, though the generic parameter name 'key' offers limited context. Code length: The implementation is concise without unnecessary statements; the long createAuthorizer signature could be wrapped for easier scanning. Action granularity: Each statement performs one distinct action. Reading flow: Authorizer creation, configuration, and wrapping follow a natural sequence. Minor formatting improvements, such as separating the package declaration from imports and grouping imports consistently, would improve readability.