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 due to its clean structure and minimal complexity. It consists of two small, well-named methods with clear purposes: creating an Authorizer plugin and checking for a cluster resource. Nesting is flat with no conditionals or loops, enhancing readability. Action granularity is good—each method performs a distinct action, and lines are not overloaded. The reading flow is natural, moving from object instantiation to configuration to plugin wrapping. Minor deductions include the long, single-line method signature in createAuthorizer and the lack of Javadoc for public methods, which would further clarify intent. Overall, the code is concise, unambiguous, and easy to follow.
Run 3
The code is highly readable. It has a logical two-method structure, minimal nesting, and clear purpose: creating an Authorizer plugin and checking for cluster resources. Each method is concise and performs one focused action per line. The wrapping of authorizer creation, configuration, and plugin wrapping is clear, although the multiple parameters and the string literal 'role' slightly reduce clarity. Overall, the flow is natural and straightforward, with only minor opportunities for added clarity through constants or documentation.
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 names and straightforward calls make their purposes clear, though generic parameter names such as key and role provide limited context. Code length: The implementation is concise without unnecessary logic; the long createAuthorizer signature slightly reduces scanability. Action granularity: Each statement performs one distinct step, clearly separating instantiation, configuration, and wrapping. Reading flow: Operations follow a natural sequence, and methods are visually separated. Blank lines between the package declaration, import groups, and class declaration would improve presentation.
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 clearly communicate authorizer creation and cluster-resource checking; the generic parameter name 'key' provides less context. Code length: The implementation is concise without unnecessary logic, though 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. Missing blank lines between the package declaration, imports, and class declaration slightly reduce visual readability.
Run 3
Code Structure: Two small utility methods are logically organized with focused responsibilities. Nesting: Both methods are flat, with no nested control flow. Clarity of intent: Descriptive method names and straightforward calls clearly convey authorizer creation and cluster-resource identification; the generic parameter name 'key' is slightly ambiguous. Code length: The implementation is concise without unnecessary statements. Action granularity: Each statement performs one clear action: instantiate, configure, wrap, or compare. Reading flow: Authorizer creation follows a natural sequence, and method separation is clear. Readability is slightly reduced by the long createAuthorizer signature and the lack of spacing between the package declaration, imports, and import groups.