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 highly readable. The class has a clear single responsibility pattern using delegation. The configure() method validates configuration and selects the appropriate delegate via a flat if/else (no deep nesting). Naming is clear, and Javadoc explains the delegation behavior. Lines are concise, with one action per line. The only minor deductions are: the lack of braces on the if/else blocks slightly hurts consistency/readability under some style guides, and the import list is a bit long but normal for Java. Overall, the reading flow is natural and the intent is unambiguous.
Run 3
The code is highly readable with clear structure: a single public class with a focused delegation pattern. Imports are organized and the Javadoc provides useful context. Nesting is minimal—only one if/else block exists in configure(). Intent is unambiguous: DefaultJwtRetriever selects and delegates to an appropriate JwtRetriever implementation based on URL protocol. Method names (configure, retrieve, close) clearly convey actions. Code length is concise, avoiding unnecessary boilerplate. Action granularity is excellent: each line performs one logical operation. Reading flow is natural: configure validates, selects, logs, and delegates; retrieve checks state and delegates; close cleans up. The only minor improvement would be adding braces to the if/else branches for style consistency, but overall this is professional, maintainable code.
Run 1
Code Structure: Clearly organized delegation class with distinct configuration, retrieval, cleanup, and accessor methods. Nesting: Minimal nesting; simple branching and a guard clause keep control flow flat. Clarity of intent: Descriptive class and method names make the delegation purpose clear, although 'cu' is abbreviated and the Javadoc describes request formatters rather than the actual ClientCredentialsJwtRetriever instantiated. Code length: Implementation is concise with little unnecessary code; documentation is somewhat verbose. Action granularity: Statements generally perform one action per line, making operations easy to follow. Reading flow: Methods follow a natural lifecycle from configuration to retrieval and cleanup. Missing braces around conditionals and tightly grouped imports slightly reduce visual clarity.
Run 2
Code Structure: Well-organized class with distinct configuration, retrieval, cleanup, and delegate-access methods. Nesting: Minimal, with a simple if/else and a guard clause. Clarity of intent: Descriptive class and method names make delegation clear; however, the abbreviated variable 'cu' and documentation describing formatter creation rather than the actual ClientCredentialsJwtRetriever slightly reduce clarity. Code length: Concise implementation with little redundancy, though the documentation is somewhat verbose. Action granularity: Each statement performs a single clear action. Reading flow: Configuration naturally precedes retrieval and cleanup, and spacing separates logical steps. Missing braces around conditionals and tightly grouped imports modestly reduce visual consistency.
Run 3
Code Structure: Clearly organized around configuration, retrieval, cleanup, and delegate access, with responsibilities separated into small methods. Nesting: Minimal; a simple if/else and a guard clause keep control flow flat. Clarity of intent: Descriptive class and method names make delegation easy to understand, although the abbreviation 'cu' is less clear and the documentation describes request formatters rather than the actual HTTP delegate instantiated. Code length: Implementation is concise, though the documentation is relatively verbose for its purpose. Action granularity: Statements generally perform one action per line, making operations easy to follow. Reading flow: Configuration naturally precedes retrieval and cleanup; consistent formatting supports scanning. Missing braces around conditionals and tightly packed imports slightly reduce readability.