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. The class has a clear single responsibility: delegating JwtRetriever operations based on configuration. Imports are organized, and the Javadoc provides helpful context. The configure method is logically sequenced: validate URL, determine protocol, instantiate delegate, log, and delegate configuration. Nesting is minimal with only a single if-else branch. The retrieve method has a simple guard clause. Action granularity is appropriate—one logical action per line. The reading flow is natural, with the delegation pattern clearly visible. Minor deductions: the if-else could use braces for consistency, and the delegate() method has package-private visibility without an obvious reason, slightly obscuring intent. Overall, the code is concise, maintains flat nesting, and clearly communicates its purpose.
Run 3
The code is generally clear and well-structured. It uses a straightforward delegation pattern, with a single if/else block in configure() that has low nesting. Intent is evident from the naming and concise Javadoc. Most lines perform one action, and the reading flow follows a logical sequence (validate config, select delegate, delegate the call). The main readability drawbacks are minor: the if/else in configure() lacks braces, which can be fragile but is still compact; the condition compares the lowercased protocol against a literal string, which is clear but slightly verbose. The class is concise, delegates responsibility appropriately, and avoids deep nesting. Additional points could be gained by using braces consistently, perhaps extracting delegate selection into a helper, or improving the Javadoc example formatting, but these are relatively small issues. Overall, the code is readable and maintainable.
Run 1
Code Structure: Well-organized delegation class with clearly separated configuration, retrieval, and cleanup methods. Nesting: Minimal; simple conditionals and an early validation guard keep control flow flat. Clarity of intent: Descriptive class and method names make the purpose clear, although 'cu' is abbreviated and the Javadoc misleadingly describes request formatters rather than the actual HTTP retriever instantiated. Code length: Implementation is concise with little unnecessary code; documentation is somewhat verbose. Action granularity: Each statement performs a distinct action, with no crowded multi-statement lines. Reading flow: Methods follow a natural lifecycle order, and delegate selection is easy to trace. Missing braces around conditionals and tightly packed imports slightly reduce visual consistency.
Run 2
Code Structure: Well-organized class with distinct configuration, retrieval, cleanup, and accessor methods. Nesting: Minimal; simple conditionals keep execution paths easy to follow, although braces would improve consistency. Clarity of intent: Descriptive class and method names make delegation clear. However, the abbreviated variable 'cu' and documentation describing request formatters rather than the instantiated ClientCredentialsJwtRetriever slightly reduce clarity. Code length: Implementation is concise, though the documentation is comparatively verbose. Action granularity: Each statement performs a focused action, with no crowded multi-statement lines. Reading flow: Configuration naturally precedes retrieval and cleanup, and the null guard clearly communicates the initialization requirement. Tightly packed imports and omitted conditional braces are minor presentation weaknesses.
Run 3
Code Structure: Clearly organized around configuration, retrieval, cleanup, and delegate access, with a straightforward delegation pattern. Nesting: Minimal; only simple conditionals, although omitted braces slightly reduce visual clarity. Clarity of intent: Descriptive class and method names make the purpose clear, but the abbreviated variable 'cu' is less expressive, and the Javadoc describes request formatters rather than the actual HTTP delegate instantiated. Code length: Implementation is concise, though the documentation is somewhat verbose for a simple selection rule. Action granularity: Each statement performs a distinct action, with no crowded multi-statement lines. Reading flow: Methods follow a natural lifecycle order, and configuration reads sequentially from validation to delegate selection and initialization. Import grouping and spacing could be improved.