tryToFinishResolve() — netty Function Reference

Source Code

resolver-dns/src/main/java/io/netty/resolver/dns/DnsResolveContext.java lines 1014–1079

    private void tryToFinishResolve(final DnsServerAddressStream nameServerAddrStream,
                                    final int nameServerAddrStreamIndex,
                                    final DnsQuestion question,
                                    final DnsQueryLifecycleObserver queryLifecycleObserver,
                                    final Promise<List<T>> promise,
                                    final Throwable cause) {

        // There are no queries left to try.
        if (!completeEarly && !queriesInProgress.isEmpty()) {
            queryLifecycleObserver.queryCancelled(allowedQueries);

            // There are still some queries in process, we will try to notify once the next one finishes until
            // all are finished.
            return;
        }

        // There are no queries left to try.
        if (finalResult == null) {
            if (nameServerAddrStreamIndex < nameServerAddrStream.size()) {
                if (queryLifecycleObserver == NoopDnsQueryLifecycleObserver.INSTANCE) {
                    // If the queryLifecycleObserver has already been terminated we should create a new one for this
                    // fresh query.
                    query(nameServerAddrStream, nameServerAddrStreamIndex + 1, question,
                          newDnsQueryLifecycleObserver(question), true, promise, cause);
                } else {
                    query(nameServerAddrStream, nameServerAddrStreamIndex + 1, question, queryLifecycleObserver,
                          true, promise, cause);
                }
                return;
            }

            queryLifecycleObserver.queryFailed(NAME_SERVERS_EXHAUSTED_EXCEPTION);

            // .. and we could not find any expected records.

            // The following is of questionable benefit, but has been around for a while that
            // it may be risky to remove. Reference https://datatracker.ietf.org/doc/html/rfc8020
            // - If we receive NXDOMAIN we know the domain doesn't exist, any other lookup type is meaningless.
            // - If we receive SERVFAIL, and we attempt a CNAME that returns NOERROR with 0 answers, it may lead the
            //   call-site to invalidate previously advertised addresses.
            // Having said that, there is the case of DNS services that don't respect the protocol either
            // - An A lookup could result in NXDOMAIN but a CNAME may succeed with answers.
            // It's an imperfect world. Accept it.
            // Guarding it with a system property, as an opt-in functionality.
            if (TRY_FINAL_CNAME_ON_ADDRESS_LOOKUPS) {
                // If cause != null we know this was caused by a timeout / cancel / transport exception. In this case we
                // won't try to resolve the CNAME as we only should do this if we could not get the expected records
                // because they do not exist and the DNS server did probably signal it.
                final boolean isValidResponse =
                        cause == NXDOMAIN_CAUSE_QUERY_FAILED_EXCEPTION || cause == SERVFAIL_QUERY_FAILED_EXCEPTION;
                if ((cause == null || isValidResponse) && !triedCNAME &&
                        (question.type() == DnsRecordType.A || question.type() == DnsRecordType.AAAA)) {
                    // As the last resort, try to query CNAME, just in case the name server has it.
                    triedCNAME = true;

                    query(hostname, DnsRecordType.CNAME, getNameServers(hostname), true, promise);
                    return;
                }
            }
        } else {
            queryLifecycleObserver.queryCancelled(allowedQueries);
        }

        // We have at least one resolved record or tried CNAME as the last resort.
        finishResolve(promise, cause);
    }