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. It has a single, focused utility class containing two concise static methods. Nesting is completely flat, with no conditional blocks or loops. Intent is unambiguous: one method creates and configures an Authorizer plugin, while the other checks if a resource name is the cluster resource. Code length is minimal and appropriate for the functionality. Each method performs one clear action sequence — instantiate, configure, wrap, return — with clean separation of concerns. The import list is tidy and limited to what is needed. Reading flow is natural: the class name, method names, and parameters clearly convey purpose. Minor deductions: a missing blank line after the package/import block, and hardcoded string "role" could be a constant, but these are trivial style preferences that do not impact overall comprehension.
Run 3
The code is a small utility class with two methods that are logically organized and easy to follow. The createAuthorizer method clearly instantiates and configures an Authorizer, then wraps it in a Plugin. It is flat with no nesting and each action is broken into distinct lines, aiding readability. The isClusterResource method is concise and expresses its intent explicitly. Minor weaknesses: the parameter 'role' is passed as a string literal in Plugin.wrapInstance, which might be intentional but slightly obscures intent; also, the import of Resource could be more specific. Overall, the code is readable, concise, and well-structured with clear intent, natural reading flow, and appropriate granularity.
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 operations make the purpose clear, although generic parameter names such as key and role provide limited context. Code length: The implementation is concise without unnecessary logic; the long createAuthorizer signature could be wrapped for readability. Action granularity: Each statement performs one clear action. Reading flow: Authorizer instantiation, configuration, and wrapping follow a natural sequence. Minor formatting improvements, including spacing between the package declaration and imports and grouping imports, would improve scanning.
Run 2
Code Structure: Two small, logically separated utility methods keep organization clear. Nesting: Both methods are flat, with no nested control flow. Clarity of intent: Descriptive method names and straightforward operations make the purpose apparent, though generic parameters such as key and the literal "role" provide limited context. Code length: The implementation is concise without unnecessary abstraction or repetition. Action granularity: Each statement performs one main action, clearly separating instantiation, configuration, and wrapping. Reading flow: Operations follow a natural sequence, but the long createAuthorizer signature and lack of spacing between the package declaration, imports, and class slightly reduce scanability.
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 make authorizer creation and cluster-resource checking easy to understand, although key and role lack explanatory context. Code length: The implementation is concise without unnecessary logic, but the long createAuthorizer signature could be wrapped for readability. Action granularity: Each statement performs a distinct action on its own line. Reading flow: Instantiation, configuration, and wrapping follow a natural sequence; separating the package declaration from imports and grouping imports consistently would improve presentation.