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;
@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 well-structured with clear separation of concerns, minimal nesting, and obvious intent. It uses a simple delegate pattern for two configuration types, reads naturally, and keeps actions concise. Minor deductions for a few small style issues like inconsistent indentation and mixed brace usage, but overall highly readable.
Run 2
The code is generally clear and well-structured, with logical delegation and straightforward configuration. It maintains flat nesting and simple control flow. However, minor readability issues exist: the imports are somewhat verbose, there are many blank lines before the class, a multi-line conditional could use braces for consistent style, and the delegate field is package-private without clear documentation. Overall the code is concise, with one action per line and a natural top-to-bottom flow, but it would benefit from slightly tighter formatting and explicit documentation for the delegate pattern.
Run 3
The code is well-structured with a clear separation of concerns. The class acts as a factory-like delegator, with configure() choosing a delegate based on protocol and forwarding calls. Nesting is minimal, mostly a single if-else. Intent is clear: it provides a delegating JWT retriever with a null-check safeguard in retrieve(). Line length and method length are reasonable, and actions are generally one per line. The reading flow is natural, from configuration to retrieval to closing. Minor issues include the many blank lines in imports, the missing braces on the if/else, and some JavaDoc or parameter validation could clarify preconditions, but these are trivial.
Run 1
Code Structure: Well-organized class with separate configuration, retrieval, cleanup, and accessor methods; unused imports and excessive blank lines add clutter. Nesting: Minimal nesting and straightforward conditionals make the code easy to follow, although omitted braces slightly reduce visual clarity. Clarity of intent: Descriptive class and method names clearly communicate delegation based on the endpoint protocol; the abbreviated variable 'cu' is less descriptive. Code length: Implementation is concise, but unnecessary whitespace and imports detract from compactness. Action granularity: Each statement performs a distinct action, with no compressed multi-statement lines. Reading flow: Configuration naturally establishes the delegate, retrieval checks initialization, and cleanup closes it; the large gap before the class interrupts an otherwise coherent flow.
Run 2
Code Structure: A well-organized delegating class separates configuration, retrieval, cleanup, and delegate access into small methods. Nesting: Control flow is shallow, with simple conditionals and no nested blocks. Clarity of intent: Descriptive class and method names make the delegation strategy clear, and the exception explains the required configuration step. The abbreviated variable 'cu' and unused formatter imports slightly reduce clarity. Code length: The implementation is concise, but excessive blank lines before the class add distracting visual length. Action granularity: Each statement generally performs one action, making execution easy to follow. Reading flow: Methods follow a natural lifecycle order, from configuration to retrieval and cleanup. Missing braces around conditionals and inconsistent import organization modestly weaken visual consistency.
Run 3
Code Structure: Well-organized delegation with separate configuration, retrieval, cleanup, and accessor methods; unused formatter imports add clutter. Nesting: Very shallow, with simple conditionals and no nested blocks. Clarity of intent: Descriptive class and method names make the delegate-selection logic clear, though 'cu' is less descriptive and the accessor's purpose is not explained. Code length: Implementation is concise, but excessive blank lines before the class unnecessarily lengthen the presentation. Action granularity: Statements generally perform one action per line; chained calls remain easy to understand. Reading flow: Methods follow a natural configure-retrieve-close sequence, and the initialization guard is clear. Missing braces around conditionals and inconsistent import grouping slightly reduce scanability.