Example usage for io.netty.resolver.dns DnsNameResolverBuilder ttl

Introduction

In this page you can find the example usage for io.netty.resolver.dns DnsNameResolverBuilder ttl.

Prototype

public DnsNameResolverBuilder ttl(int minTtl, int maxTtl) 

Source Link

Document

Sets the minimum and maximum TTL of the cached DNS resource records (in seconds).

Usage

From source file:io.vertx.core.impl.HostnameResolver.java

License:Open Source License

public HostnameResolver(VertxImpl vertx, HostnameResolverOptions options) {
    DnsNameResolverBuilder builder = new DnsNameResolverBuilder(vertx.createEventLoopContext(null, null,
            new JsonObject(), Thread.currentThread().getContextClassLoader()).nettyEventLoop());
    builder.channelFactory(NioDatagramChannel::new);
    if (options != null) {
        List<String> dnsServers = options.getServers();
        if (dnsServers != null && dnsServers.size() > 0) {
            List<InetSocketAddress> serverList = new ArrayList<>();
            for (String dnsServer : dnsServers) {
                int sep = dnsServer.indexOf(':');
                String ipAddress;
                int port;
                if (sep != -1) {
                    ipAddress = dnsServer.substring(0, sep);
                    port = Integer.parseInt(dnsServer.substring(sep + 1));
                } else {
                    ipAddress = dnsServer;
                    port = 53;//from  w  ww.java  2s.c o  m
                }
                try {
                    serverList.add(new InetSocketAddress(
                            InetAddress.getByAddress(NetUtil.createByteArrayFromIpAddressString(ipAddress)),
                            port));
                } catch (UnknownHostException e) {
                    throw new VertxException(e);
                }
            }
            DnsServerAddresses nameServerAddresses = DnsServerAddresses.sequential(serverList);
            builder.nameServerAddresses(nameServerAddresses);
        }
        builder.optResourceEnabled(options.isOptResourceEnabled());
        builder.ttl(options.getCacheMinTimeToLive(), options.getCacheMaxTimeToLive());
        builder.negativeTtl(options.getCacheNegativeTimeToLive());
        builder.queryTimeoutMillis(options.getQueryTimeout());
        builder.maxQueriesPerResolve(options.getMaxQueries());
        builder.recursionDesired(options.getRdFlag());
    }
    this.resolver = builder.build();
    this.vertx = vertx;
}

---

From source file:io.vertx.core.impl.resolver.DnsResolverProvider.java

License:Open Source License

public DnsResolverProvider(VertxImpl vertx, AddressResolverOptions options) {
    List<String> dnsServers = options.getServers();
    List<InetSocketAddress> serverList = new ArrayList<>();
    if (dnsServers != null && dnsServers.size() > 0) {
        for (String dnsServer : dnsServers) {
            int sep = dnsServer.indexOf(':');
            String ipAddress;//from   w  w w .j  a  va 2  s  . com
            int port;
            if (sep != -1) {
                ipAddress = dnsServer.substring(0, sep);
                port = Integer.parseInt(dnsServer.substring(sep + 1));
            } else {
                ipAddress = dnsServer;
                port = 53;
            }
            try {
                serverList.add(new InetSocketAddress(
                        InetAddress.getByAddress(NetUtil.createByteArrayFromIpAddressString(ipAddress)), port));
            } catch (UnknownHostException e) {
                throw new VertxException(e);
            }
        }
    } else {
        DnsServerAddressStream stream = DnsServerAddresses.defaultAddresses().stream();
        Set<InetSocketAddress> all = new HashSet<>();
        while (true) {
            InetSocketAddress address = stream.next();
            if (all.contains(address)) {
                break;
            }
            serverList.add(address);
            all.add(address);
        }
    }
    DnsServerAddresses nameServerAddresses = options.isRotateServers()
            ? DnsServerAddresses.rotational(serverList)
            : DnsServerAddresses.sequential(serverList);

    Map<String, InetAddress> entries;
    if (options.getHostsPath() != null) {
        File file = vertx.resolveFile(options.getHostsPath()).getAbsoluteFile();
        try {
            if (!file.exists() || !file.isFile()) {
                throw new IOException();
            }
            entries = HostsFileParser.parse(file);
        } catch (IOException e) {
            throw new VertxException("Cannot read hosts file " + file.getAbsolutePath());
        }
    } else if (options.getHostsValue() != null) {
        try {
            entries = HostsFileParser.parse(new StringReader(options.getHostsValue().toString()));
        } catch (IOException e) {
            throw new VertxException("Cannot read hosts config ", e);
        }
    } else {
        entries = HostsFileParser.parseSilently();
    }

    this.vertx = vertx;
    this.resolverGroup = new AddressResolverGroup<InetSocketAddress>() {

        @Override
        protected io.netty.resolver.AddressResolver<InetSocketAddress> newResolver(EventExecutor executor)
                throws Exception {

            DnsAddressResolverGroup group = new DnsAddressResolverGroup(NioDatagramChannel.class,
                    nameServerAddresses) {
                @Override
                protected NameResolver<InetAddress> newNameResolver(EventLoop eventLoop,
                        ChannelFactory<? extends DatagramChannel> channelFactory,
                        DnsServerAddresses nameServerAddresses) throws Exception {
                    DnsNameResolverBuilder builder = new DnsNameResolverBuilder((EventLoop) executor);
                    builder.hostsFileEntriesResolver(inetHost -> {
                        InetAddress addr = entries.get(inetHost);
                        if (addr == null) {
                            addr = entries.get(inetHost.toLowerCase(Locale.ENGLISH));
                        }
                        return addr;
                    });
                    builder.channelType(NioDatagramChannel.class);
                    builder.nameServerAddresses(nameServerAddresses);
                    builder.optResourceEnabled(options.isOptResourceEnabled());
                    builder.ttl(options.getCacheMinTimeToLive(), options.getCacheMaxTimeToLive());
                    builder.negativeTtl(options.getCacheNegativeTimeToLive());
                    builder.queryTimeoutMillis(options.getQueryTimeout());
                    builder.maxQueriesPerResolve(options.getMaxQueries());
                    builder.recursionDesired(options.getRdFlag());
                    if (options.getSearchDomains() != null) {
                        builder.searchDomains(options.getSearchDomains());
                        int ndots = options.getNdots();
                        if (ndots == -1) {
                            ndots = AddressResolver.DEFAULT_NDOTS_RESOLV_OPTION;
                        }
                        builder.ndots(ndots);
                    }
                    return builder.build();
                }
            };

            io.netty.resolver.AddressResolver<InetSocketAddress> resolver = group.getResolver(executor);
            resolvers.add(new ResolverRegistration(resolver, (EventLoop) executor));

            return resolver;
        }
    };
}

---