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. It has a clear single responsibility (delegating JWT retrieval based on configuration), minimal nesting, and good use of descriptive names. Each method performs one logical action, and the flow is natural: configure, retrieve, close. The Javadoc is thorough and explains the delegation logic clearly. Minor deductions: the configure method could extract the protocol check into a helper for slightly better clarity, and the if/else without braces (though technically valid) reduces consistency. Overall, concise, maintainable, and easy to follow.
Run 3
The code is well-structured and readable. It has a clear class purpose, a single responsibility (delegation), and uses a simple flat if-else to choose the delegate implementation. Naming is descriptive, and comments provide useful contextual documentation. Each method is concise and lines express one logical action. The only minor deductions are for missing braces on the if-else statements (which slightly reduces clarity-to-intent for some readers) and the slightly dense Javadoc, though still informative. Overall, the code is highly readable and maintainable.
Run 1
Code Structure: Well-organized delegation class with separate configuration, retrieval, cleanup, and accessor methods. Nesting: Minimal; simple conditionals and a guard clause keep methods flat. Clarity of intent: Descriptive class and method names make the purpose clear, though 'cu' is terse and the Javadoc misleadingly describes request formatters rather than the actual HTTP delegate. Code length: Implementation is concise, with somewhat verbose documentation. Action granularity: Each statement performs a distinct action, with no compressed multi-statement lines. Reading flow: Methods follow a natural lifecycle, and delegation is easy to trace. Missing braces around conditionals and tightly packed imports slightly reduce visual readability.
Run 2
Code Structure: Well-organized class with distinct configuration, retrieval, cleanup, and accessor methods. Nesting: Minimal nesting and simple conditionals make execution paths easy to follow, though omitted braces slightly reduce robustness when editing. Clarity of intent: Descriptive class and method names clearly convey delegation; the abbreviated variable 'cu' is less explicit, and the documentation describes formatter creation rather than the actual ClientCredentialsJwtRetriever selection. Code length: Concise implementation with little redundancy, although the introductory documentation is somewhat verbose. Action granularity: Statements generally perform one action per line, with no compressed multi-statement lines. Reading flow: Methods follow a natural lifecycle from configuration to retrieval and cleanup; imports could be grouped more clearly. Overall, the code is highly readable with minor naming, documentation, and formatting weaknesses.
Run 3
Code Structure: Well-organized class with small, distinct configuration, retrieval, cleanup, and accessor methods. Nesting: Minimal; a simple conditional and a guard clause keep execution paths easy to follow. Clarity of intent: Descriptive class and method names make delegation clear, although 'cu' is abbreviated and the documentation misleadingly describes request formatters rather than the actual HTTP retriever instantiated. Code length: Concise implementation with somewhat verbose documentation. Action granularity: Statements generally perform one action per line, with no compressed multi-statement lines. Reading flow: Methods follow a natural lifecycle from configuration to retrieval and cleanup. Missing braces around conditionals and ungrouped imports slightly reduce visual consistency.