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 well-structured and readable. Imports are organized, the class has a clear purpose, and the Javadoc provides helpful context. The configure() method is concise and the conditional logic for choosing the delegate is flat (one if/else) and easy to follow. Each line typically performs one action, and variable names are descriptive. The retrieve() method clearly guards against misuse. Minor deductions: the if/else could use braces for consistency, and the line creating ClientCredentialsJwtRetriever relies on knowledge that it internally handles client assertion vs secret formatting, which may be slightly non-obvious. Overall, the flow is natural and the code requires little effort to understand.
Run 3
The code is well-structured and readable. It uses a clear delegation pattern, with a single purpose per method and minimal nesting (only one level in configure and retrieve). The class names and method names clearly express intent. The javadoc explains the configuration-based selection logic. The code is concise, with each line performing a distinct action, and the reading flow follows a natural order: validate config, select delegate, configure delegate. Minor areas for improvement include the lack of braces on the one-line if/else in configure (which can reduce readability and introduce risk during maintenance) and the use of an abbreviation 'cu' for ConfigurationUtils, which slightly reduces immediate clarity. Overall, this is highly readable and maintainable code.
Run 1
Code Structure: Clearly organized around configuration, retrieval, cleanup, and delegate access, with focused methods. Nesting: Minimal nesting; simple conditionals and a guard clause keep execution easy to follow. Clarity of intent: Descriptive class and method names explain the delegation pattern, although the abbreviated variable 'cu' and documentation naming request formatters rather than the actual HTTP retriever slightly weaken clarity. Code length: The implementation is concise without unnecessary logic; the documentation is somewhat verbose. Action granularity: Each statement performs a distinct action, with no compressed multi-statement lines. Reading flow: Methods follow a natural lifecycle from configure to retrieve to close. Missing braces around conditionals and tightly packed imports slightly reduce visual consistency.
Run 2
1. Code Structure: Well-organized class with configuration, retrieval, cleanup, and delegate access separated into focused methods. 2. Nesting: Minimal nesting; a simple conditional selects the implementation, and a guard checks initialization. 3. Clarity of intent: Descriptive class and method names make delegation clear. However, the abbreviated variable 'cu' is less expressive, and the documentation names request formatters rather than the actual HTTP delegate, which may confuse readers. 4. Code length: Implementation is concise without unnecessary abstraction; the documentation is somewhat verbose. 5. Action granularity: Each statement performs a distinct action, with no crowded multi-statement lines. 6. Reading flow: Configuration followed by retrieval and cleanup provides a natural lifecycle progression. Ungrouped imports and omitted conditional braces slightly reduce visual readability.
Run 3
Code Structure: The class cleanly separates configuration, retrieval, cleanup, and delegate access. Nesting: Minimal nesting and straightforward conditionals make execution easy to follow, though omitted braces slightly reduce robustness when editing. Clarity of intent: Descriptive class and method names clearly express the delegation pattern, and the exception explains the configuration prerequisite. However, the abbreviated variable 'cu' and documentation referring to request formatters rather than the actual HTTP retriever weaken precision. Code length: The implementation is concise, with little redundancy; the documentation is comparatively verbose. Action granularity: Each statement performs a distinct action, with no crowded multi-statement lines. Reading flow: Methods follow a natural lifecycle order, and delegation is consistent. Import grouping and spacing could be improved for easier scanning.