Source code
package org.apache.kafka.common.security.oauthbearer;
import org.apache.kafka.common.annotation.InterfaceAudience;
import org.apache.kafka.common.security.oauthbearer.internals.secured.ClientAssertionRequestFormatter;
import org.apache.kafka.common.security.oauthbearer.internals.secured.ClientSecretRequestFormatter;
import org.apache.kafka.common.security.oauthbearer.internals.secured.ConfigurationUtils;
import org.apache.kafka.common.utils.Utils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.net.URL;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import javax.security.auth.login.AppConfigurationEntry;
import static org.apache.kafka.common.config.SaslConfigs.SASL_OAUTHBEARER_TOKEN_ENDPOINT_URL;
/**
* {@code DefaultJwtRetriever} instantiates and delegates {@link JwtRetriever} API calls to an embedded implementation
* based on configuration:
*
* <ul>
* <li>
* If the value of <code>sasl.oauthbearer.token.endpoint.url</code> is set to a value that starts with the
* <code>file</code> protocol (e.g. <code>file:/tmp/path/to/a/static-jwt.json</code>), an instance of
* {@link FileJwtRetriever} will be used as the underlying {@link JwtRetriever}. Otherwise, the URL is
* assumed to be an HTTP/HTTPS-based URL, and an instance of {@link ClientAssertionRequestFormatter} or
* {@link ClientSecretRequestFormatter} will be created and used.
* </li>
* </ul>
*
* The configuration required by the individual {@code JwtRetriever} classes will likely differ. Please refer to the
* official Apache Kafka documentation for more information on these, and related configuration.
*/
@InterfaceAudience.Public
public class DefaultJwtRetriever implements JwtRetriever {
private static final Logger LOG = LoggerFactory.getLogger(DefaultJwtRetriever.class);
private JwtRetriever delegate;
@Override
public void configure(Map<String, ?> configs, String saslMechanism, List<AppConfigurationEntry> jaasConfigEntries) {
ConfigurationUtils cu = new ConfigurationUtils(configs, saslMechanism);
URL tokenEndpointUrl = cu.validateUrl(SASL_OAUTHBEARER_TOKEN_ENDPOINT_URL);
if (tokenEndpointUrl.getProtocol().toLowerCase(Locale.ROOT).equals("file"))
delegate = new FileJwtRetriever();
else
delegate = new ClientCredentialsJwtRetriever();
LOG.debug("Created instance of {} as delegate", delegate.getClass().getName());
delegate.configure(configs, saslMechanism, jaasConfigEntries);
}
@Override
public String retrieve() throws JwtRetrieverException {
if (delegate == null)
throw new IllegalStateException("JWT retriever delegate is null; please call configure() first");
return delegate.retrieve();
}
@Override
public void close() throws IOException {
Utils.closeQuietly(delegate, "JWT retriever delegate");
}
JwtRetriever delegate() {
return delegate;
}
}
Run 1
The code is highly readable and well-structured. It maintains a flat structure with minimal nesting (a simple if-else and a null check), making control flow easy to follow. Intent is clear: DefaultJwtRetriever acts as a delegating facade that selects an implementation based on the token endpoint URL protocol. Variable names are descriptive (e.g., delegate, tokenEndpointUrl), and logging improves observability. The configure method is concise, delegating URL validation and configuration to ConfigurationUtils. Each line performs one logical action, improving readability. The class is compact and avoids unnecessary verbosity. The helper method delegate() provides testability without clutter. Minor improvements could include adding braces to the single-line if/else statements to fully prevent possible ambiguity, but overall the code is exemplary.
Run 2
The code is generally well-structured, with clear class-level documentation explaining the delegation logic. Imports follow proper formatting. The class has a straightforward delegation pattern, with methods that are concise and focused. Nesting is minimal, and the action granularity is one action per line, which improves readability. However, there are a few areas where clarity could be improved: the conditional statement in `configure()` shows slightly inconsistent indentation, and the logic for deciding between `FileJwtRetriever` and `ClientCredentialsJwtRetriever` could be extracted into a helper method for better readability and maintainability. Additionally, the method `delegate()` at the bottom lacks an access modifier, which may be intentional for package-private access but is not immediately obvious. Overall, the code is readable and well-organized.
Run 3
The code is well-structured with a clear delegation pattern. It uses a flat, simple structure with minimal nesting (one if-else, one null check). Intent is clear from the class name, method names, and the descriptive Javadoc. Lines are reasonably concise, though some method signatures could be more compact. Each action is generally one line, and the reading flow is natural: configure, retrieve, close, accessor. Minor deductions: the if-else branch lacks braces, which some style guides discourage, and the Javadoc is somewhat lengthy relative to the simple logic. Overall, highly readable.
Run 1
Code Structure: Well-organized delegation class with distinct configuration, retrieval, cleanup, and accessor methods. Nesting: Minimal; simple conditional selection and a guard clause keep execution paths easy to follow. Clarity of intent: Descriptive class and method names make the delegation purpose clear, although the abbreviated variable 'cu' is less expressive and the Javadoc names request formatters rather than the actual HTTP retriever instantiated. Code length: Concise implementation with little unnecessary code; documentation is somewhat verbose relative to the logic. Action granularity: Statements generally perform one action per line, with only straightforward method chaining. Reading flow: Configuration naturally precedes retrieval and cleanup, supporting easy top-to-bottom reading. Missing braces on conditionals and tightly grouped imports slightly reduce visual clarity.
Run 2
Code Structure: The class is logically organized around configuration, retrieval, cleanup, and delegate access, with implementation details delegated appropriately. Nesting: Flat control flow and simple conditionals make execution easy to follow. Clarity of intent: Descriptive class and method names clearly communicate the delegation pattern; however, the abbreviated variable 'cu' is less informative, and the Javadoc references request formatters rather than the actual HTTP retriever instantiated. Code length: The implementation is concise, though the documentation is somewhat verbose for the simple selection logic. Action granularity: Statements generally perform one action per line, with no compressed multi-statement lines. Reading flow: Methods follow a natural lifecycle order, and the null guard makes the configuration requirement explicit. Missing braces around conditionals and tightly grouped imports slightly reduce visual clarity.
Run 3
Code Structure: Clearly organized into configuration, retrieval, cleanup, and delegate access methods. Nesting: Minimal, with a simple conditional and an early guard. Clarity of intent: Descriptive class and method names make delegation clear; however, the abbreviated variable 'cu' and documentation describing request formatters rather than the actual HTTP retriever slightly reduce clarity. Code length: Compact implementation, though the single-item documentation list is unnecessarily verbose. Action granularity: Statements generally perform one action per line, with no compressed multi-statement code. Reading flow: Natural progression from initialization to use and cleanup; omitted conditional braces and tightly grouped imports modestly weaken visual consistency.