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 concise and structurally sound, with clear separation of concerns between authorizer creation and cluster resource checking. The createAuthorizer method has a natural reading flow, instantiating, configuring, and wrapping the authorizer as distinct logical steps. Nesting is flat, and each method performs a single action or a clear sequence of related actions. Variable and method names are descriptive, though the parameter 'key' and hardcoded "role" string are slightly ambiguous. Overall, the implementation is straightforward, easily scannable, and demonstrates good readability practices for utility code.
Run 2
The code is compact and generally understandable, but it suffers from a long single-line method call with multiple arguments, reducing readability. The class structure is simple and flat, with clear method separation. However, the intent of 'createAuthorizer' is partially obscured by the overloaded parameters and the hardcoded 'role' string. The method name 'isClusterResource' is clear, but the implementation does not handle null input, which may be ambiguous. The code lacks comments or documentation, which would aid clarity, especially for the plugin wrapping and configuration steps. The import list is slightly redundant due to unused imports (e.g., 'Resource' is used, but 'Utils' and 'Metrics' are necessary; no unused imports detected). Overall, the code is readable for experienced developers but not exemplary.
Run 3
The code is concise and well-structured with a clear purpose: creating and configuring an Authorizer plugin, plus a helper method for cluster resource detection. It maintains a flat structure with no nested logic, uses one action per line, and follows a natural reading flow. Imports are organized, and method names are descriptive. Minor deductions for the slightly misleading parameter name `key` and the hardcoded string "role" in the Plugin.wrapInstance call, which could obscure intent, and for the unused `role` parameter in the method signature.
Run 1
Code Structure: A small utility class with two clearly separated methods and focused responsibilities. Nesting: No nested control flow, making both methods easy to follow. Clarity of intent: Descriptive method names and straightforward operations convey purpose; the generic parameter name 'key' and literal 'role' provide slightly less context. Code length: Concise, with no unnecessary statements, although the createAuthorizer signature is long and would benefit from line wrapping. Action granularity: Each statement performs one clear action: instantiate, configure, wrap, or compare. Reading flow: The authorizer setup follows a natural sequence, and the resource check is immediately understandable. Missing blank lines between the package declaration and import groups slightly reduce visual organization.
Run 2
Code Structure: Two small, focused utility methods provide logical organization. Nesting: No branching or nested blocks makes the code easy to scan. Clarity of intent: Descriptive method names and straightforward calls clearly convey authorizer creation and cluster-resource checking, though key and role could use contextual documentation. Code length: Concise, with no unnecessary logic; the long createAuthorizer signature would benefit from wrapping. Action granularity: Each statement performs one clear action. Reading flow: Instantiation, configuration, and wrapping follow a natural sequence. Minor formatting issues, including no separation between the package declaration and imports and no grouping of Java imports, slightly reduce readability.
Run 3
Code Structure: Two small 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 their purposes clear, though parameters such as key and role could use documentation. Code length: The implementation is concise without unnecessary logic, but the long createAuthorizer signature reduces scanability. Action granularity: Each statement performs one distinct step: instantiate, configure, or wrap. Reading flow: Authorizer creation follows a natural sequence, and resource checking is immediately understandable. Separating the package declaration from imports and grouping Java imports consistently would improve presentation.