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. It is a short utility class with a clear purpose: creating an Authorizer and checking for a cluster resource. The structure is logical, grouping related imports and methods. Nesting is nonexistent, keeping the flow flat and easy to follow. Each method performs a single, well-defined action with a clear name, resulting in one action per line. The parameter list in `createAuthorizer` is a bit long but acceptable for a factory-style method. The reading flow is natural: instantiate, configure, wrap, return. Overall, this is an example of clean, concise, and maintainable code.
Run 2
The code is exceptionally readable. It has a clear, logical structure with a single utility class containing two concise methods. Nesting is completely flat. Intent is obvious from method names and parameters. Code length is minimal, avoiding unnecessary complexity. Each method performs one focused action (creation/configuration/wrapping and resource name check). Reading flow is natural, with imports organized and methods ordered logically.
Run 3
The code is highly readable. It has a clear, logical structure with a single utility class containing two focused methods. Nesting is flat with no conditional or loop blocks. Intent is immediately apparent: create an authorizer and check for cluster resource. The code is concise, avoiding unnecessary boilerplate. Each method performs one clear action per line, maintaining good action granularity. Reading flow is natural, with the more complex creation method first and the simple check method second. Potential minor improvements include breaking the long method signature across multiple lines and adding brief Javadoc, but these are style preferences rather than readability issues. Overall, the naming, imports, and method organization support excellent comprehension.
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 the purpose clear, though the literal "role" and plugin-wrapping behavior require some API context. Code length: Concise, with no redundant logic; the long createAuthorizer signature would benefit from wrapping. Action granularity: Each statement performs one distinct operation. Reading flow: Authorizer creation, configuration, and wrapping follow a natural sequence. Minor formatting improvements, such as separating the package declaration and import groups with blank lines, would improve scanning.
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; spacing between the package declaration, imports, and class would improve visual readability.
Run 3
Code Structure: Two focused utility methods provide clear logical organization. Nesting: No nested control flow makes both methods easy to scan. Clarity of intent: Descriptive method names and straightforward calls clearly convey authorizer creation and cluster-resource identification, though generic parameters such as key and role lack 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; import grouping and a blank line after the package declaration would improve visual organization.