Java 类org.xbill.DNS.ExtendedResolver 实例源码

/**
 * @param ip, like "192.168.1.1"
 * @return the complete DNS record for that IP.
 */
@Converter
public static Record toRecord(String ip) throws IOException {
    Resolver res = new ExtendedResolver();

    Name name = ReverseMap.fromAddress(ip);
    int type = Type.PTR;
    int dclass = DClass.IN;
    Record rec = Record.newRecord(name, type, dclass);
    Message query = Message.newQuery(rec);
    Message response = res.send(query);

    Record[] answers = response.getSectionArray(Section.ANSWER);
    if (answers.length == 0) {
        return null;
    } else {
        return answers[0];
    }
}

private void init() {
    if (mInitialized) return; else mInitialized = true;

    try {
        // configure the resolvers, starting with the default ones (based on the current network connection)
        Resolver defaultResolver = Lookup.getDefaultResolver();
        // use Google's public DNS services
        Resolver googleFirstResolver = new SimpleResolver("8.8.8.8");
        Resolver googleSecondResolver = new SimpleResolver("8.8.4.4");
        // also try using Amazon
        Resolver amazonResolver = new SimpleResolver("205.251.198.30");
        Lookup.setDefaultResolver(new ExtendedResolver(new Resolver[]{
                googleFirstResolver, googleSecondResolver, amazonResolver, defaultResolver }));
    } catch (UnknownHostException e) {
        Log.w(TAG, "Couldn't initialize custom resolvers");
    }
}

private Resolver createResolver(String[] targets) throws IOException {
    // Shuffle input targets so we don't query the same all the time
    ArrayList<String> targetsList = new ArrayList<String>();
    for (String target : targets)
        targetsList.add(target);
    Collections.shuffle(targetsList);

    Resolver resolver = new ExtendedResolver(targetsList.toArray(new String[targetsList.size()]));
    resolver.setTimeout(RECURSIVE_QUERY_TIMEOUT);
    if (port != null)
        resolver.setPort(port);
    if (tcp != null)
        resolver.setTCP(tcp);
    if (ignoreTruncation != null)
        resolver.setIgnoreTruncation(ignoreTruncation);
    if (ednsLevel != null) {
        if (ednsPayloadSize != null && ednsFlags != null && ednsOptions != null)
            resolver.setEDNS(ednsLevel, ednsPayloadSize, ednsFlags, ednsOptions);
        else
            resolver.setEDNS(ednsLevel);
    }
    if (key != null)
        resolver.setTSIGKey(key);
    return resolver;
}

/**
 * Sends DNS request via system or custom DNS resolver
 */
private InetAddress[] requestLookup(String host) throws UnknownHostException {
    InetAddress[] addresses = null;
    if (isCustomResolver() && ((ExtendedResolver) resolver).getResolvers().length > 0) {
        try {
            Lookup lookup = new Lookup(host, Type.A);
            lookup.setCache(lookupCache);
            if (timeoutMs > 0) {
                resolver.setTimeout(timeoutMs / 1000, timeoutMs % 1000);
            }
            lookup.setResolver(resolver);
            Record[] records = lookup.run();
            if (records == null || records.length == 0) {
                throw new UnknownHostException("Failed to resolve host name: " + host);
            }
            addresses = new InetAddress[records.length];
            for (int i = 0; i < records.length; i++) {
                addresses[i] = ((ARecord) records[i]).getAddress();
            }
        } catch (TextParseException tpe) {
            log.debug("Failed to create Lookup object: " + tpe);
        }
    } else {
        addresses = systemDefaultDnsResolver.resolve(host);
        if (log.isDebugEnabled()) {
            log.debug("Cache miss: " + host + " Thread #" + JMeterContextService.getContext().getThreadNum()
                    + ", resolved with system resolver into " + Arrays.toString(addresses));
        }
    }
    return addresses;
}

private Lookup buildLookup()
        throws TextParseException, UnknownHostException {

    ExtendedResolver resolver = new ExtendedResolver();
    resolver.setTimeout(serviceDnsTimeout);

    Lookup lookup = new Lookup(serviceDns, Type.SRV);
    lookup.setResolver(resolver);

    // Avoid caching temporary DNS lookup failures indefinitely in global cache
    lookup.setCache(null);

    return lookup;
}

@Override
public void afterPropertiesSet() {
    try {
        resolver = ( nameservers == null || nameservers.length == 0) ? 
                new ExtendedResolver() : new ExtendedResolver(nameservers);
        resolver.setTimeout(queryTimeout);
    } catch (UnknownHostException ex) {
        throw new RuntimeException("Invalid nameservers configuration.", ex);
    }
}

@Override
public void init(final ServiceFactory factory) throws UnknownHostException {
    _resolver = new ExtendedResolver();
}

@PostConstruct
public void init() throws Exception {
    logger.debug("DNSService init...");

    // If no DNS servers were configured, default to local host
    if (dnsServers.isEmpty()) {
        try {
            dnsServers.add(InetAddress.getLocalHost().getHostName());
        } catch (UnknownHostException ue) {
            dnsServers.add("127.0.0.1");
        }
    }

    // Create the extended resolver...
    final String[] serversArray = (String[]) dnsServers.toArray(new String[0]);

    if (logger.isInfoEnabled()) {
        for (int c = 0; c < serversArray.length; c++) {
            logger.info("DNS Server is: " + serversArray[c]);
        }
    }

    try {
        resolver = new ExtendedResolver(serversArray);
    } catch (UnknownHostException uhe) {
        logger.error("DNS service could not be initialized.  The DNS servers specified are not recognized hosts.", uhe);
        throw uhe;
    }

    cache = new Cache(DClass.IN);
    cache.setMaxEntries(maxCacheSize);

    if (setAsDNSJavaDefault) {
        Lookup.setDefaultResolver(resolver);
        Lookup.setDefaultCache(cache, DClass.IN);
        Lookup.setDefaultSearchPath(searchPaths);
        logger.info("Registered cache, resolver and search paths as DNSJava defaults");
    }

    // Cache the local hostname and local address. This is needed because
    // the following issues:
    // JAMES-787
    // JAMES-302
    InetAddress addr = getLocalHost();
    localCanonicalHostName = addr.getCanonicalHostName();
    localHostName = addr.getHostName();
    localAddress = addr.getHostAddress();

    logger.debug("DNSService ...init end");
}