Source code
package io.netty.resolver.dns;
import io.netty.channel.AddressedEnvelope;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.handler.codec.dns.DefaultDnsQuery;
import io.netty.handler.codec.dns.DnsQuery;
import io.netty.handler.codec.dns.DnsQuestion;
import io.netty.handler.codec.dns.DnsRecord;
import io.netty.handler.codec.dns.DnsResponse;
import io.netty.util.concurrent.Future;
import io.netty.util.concurrent.Promise;
import java.net.InetSocketAddress;
final class TcpDnsQueryContext extends DnsQueryContext {
TcpDnsQueryContext(Channel channel,
InetSocketAddress nameServerAddr,
DnsQueryContextManager queryContextManager,
DnsQueryLifecycleObserver lifecycleObserver,
int maxPayLoadSize, boolean recursionDesired,
long queryTimeoutMillis,
DnsQuestion question, DnsRecord[] additionals,
Promise<AddressedEnvelope<DnsResponse, InetSocketAddress>> promise) {
super(channel, nameServerAddr, queryContextManager, lifecycleObserver, maxPayLoadSize, recursionDesired,
// No retry via TCP.
queryTimeoutMillis, question, additionals, promise, null, false);
}
@Override
protected DnsQuery newQuery(int id, InetSocketAddress nameServerAddr) {
return new DefaultDnsQuery(id);
}
@Override
protected String protocol() {
return "TCP";
}
}
Run 1
The code is well-structured and readable. It has a clear class hierarchy with a single inheritance from DnsQueryContext. The constructor is straightforward, with parameters clearly named and a concise super() call that uses a helpful comment to explain the null and false arguments. Methods are short and focused, each performing a single action. There is minimal nesting, with no conditional logic or loops. The code is concise and follows standard Java conventions. Minor deductions: the long constructor parameter list could be wrapped differently, and the 'protocol()' method is trivially simple. Overall, this code is easy to understand and maintain.
Run 2
The code is well-structured and highly readable. The class extends a clear base class, has a straightforward constructor that delegates to the parent with explicit parameters, and overrides two simple methods with clear purposes. The constructor is long but necessary due to the number of parameters, and the comment explaining why retry is disabled ('No retry via TCP') adds clarity. Nesting is minimal, action granularity is appropriate, and reading flow is logical. The only minor drawback is the long parameter list, but this is common in Netty-style code and not a readability issue given the context.
Run 3
The code is highly readable due to its clear structure and concise implementation. It follows a logical organization with a single class extending a base context, making the inheritance and purpose immediately evident. The nesting is minimal, with all logic contained within a few flat methods. The intent is unambiguous—configuring DNS queries over TCP without retries. The code length is appropriate for its responsibility, avoiding unnecessary boilerplate. Action granularity is well maintained, with each line performing a distinct operation. The reading flow is natural, progressing from constructor to query creation to protocol identification. Minor deductions: the super constructor call is long and could benefit from named constants or a builder, and the comment 'No retry via TCP' could be more descriptive about why retries are disabled.
Run 1
Code Structure: The class is logically organized into a constructor and two small overrides. Nesting: There is no nested control flow, making the code easy to scan. Clarity of intent: Class and method names clearly convey TCP DNS behavior, and the comment explains the retry policy; however, the long superclass argument list and literal null and false obscure some configuration details. Code length: The implementation is concise, though unused ChannelFuture and Future imports add clutter. Action granularity: Each method performs a single clear action, with no unrelated operations combined. Reading flow: The constructor-to-overrides sequence is natural, but the dense parameter list, mixed parameter wrapping, and lack of separation after the package declaration slightly reduce readability.
Run 2
Code Structure: A small, logically organized subclass with constructor setup followed by focused overrides. Nesting: Flat, with no conditional or loop nesting. Clarity of intent: Class and method names clearly identify TCP DNS query behavior, and the comment explains the lack of TCP retry. However, the long constructor signature and positional null/false arguments require superclass knowledge. Code length: Concise, with minimal implementation; two unused imports add minor clutter. Action granularity: Each statement performs one action, although some parameter declarations share lines. Reading flow: Natural and consistent, with readable indentation and straightforward method ordering; the lengthy superclass call slightly interrupts scanning.
Run 3
Code Structure: A focused class with a constructor and two clearly separated overrides provides logical organization. Nesting: No nested control flow makes the code easy to scan. Clarity of intent: Class and method names clearly identify TCP DNS query behavior, and the comment explains the absence of TCP retries; however, the long superclass call and positional null/false arguments obscure some configuration details. Code length: The implementation is concise, though two unused imports add minor clutter. Action granularity: Each statement performs one action, with the long constructor call appropriately split across lines. Reading flow: The constructor followed by simple overrides reads naturally, but the lengthy parameter list and densely packed forwarding call require extra attention.