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

List of usage examples for io.netty.resolver.dns DnsNameResolverBuilder build

Introduction

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

Prototype

public DnsNameResolver build() 

Source Link

Document

Returns a new DnsNameResolver instance.

Usage

From source file:chat.viska.xmpp.Connection.java

License:Apache License

private static Single<List<DnsRecord>> lookupDnsUsingNetty(final String query, final DnsRecordType type,
        @Nullable final Iterable<String> dns) {
    final NioEventLoopGroup threadPool = new NioEventLoopGroup();
    final DnsNameResolverBuilder builder = new DnsNameResolverBuilder(threadPool.next());
    builder.channelFactory(new ReflectiveChannelFactory<>(NioDatagramChannel.class));
    builder.decodeIdn(true);/* w ww.j a  v  a 2 s  . co  m*/
    if (dns != null) {
        builder.searchDomains(dns);
    }
    return Single.fromFuture(builder.build().query(new DefaultDnsQuestion(query, type)))
            .map(AddressedEnvelope::content).map(message -> {
                final int recordsSize = message.count(DnsSection.ANSWER);
                final List<DnsRecord> records = new ArrayList<>(recordsSize);
                for (int it = 0; it < recordsSize; ++it) {
                    records.add(message.recordAt(DnsSection.ANSWER, it));
                }
                return records;
            }).doFinally(threadPool::shutdownGracefully);
}

From source file:com.linecorp.armeria.client.endpoint.dns.DnsEndpointGroup.java

License:Apache License

DnsEndpointGroup(EventLoop eventLoop, int minTtl, int maxTtl,
        DnsServerAddressStreamProvider serverAddressStreamProvider, Backoff backoff,
        Iterable<DnsQuestion> questions, Consumer<DnsNameResolverBuilder> resolverConfigurator) {

    this.eventLoop = eventLoop;
    this.minTtl = minTtl;
    this.maxTtl = maxTtl;
    this.backoff = backoff;
    this.questions = ImmutableList.copyOf(questions);
    assert !this.questions.isEmpty();
    logger = LoggerFactory.getLogger(getClass());
    logPrefix = this.questions.stream().map(DnsQuestion::name).distinct()
            .collect(Collectors.joining(", ", "[", "]"));

    final DnsNameResolverBuilder resolverBuilder = new DnsNameResolverBuilder(eventLoop)
            .channelType(TransportType.datagramChannelType(eventLoop.parent())).ttl(minTtl, maxTtl)
            .nameServerProvider(serverAddressStreamProvider);

    resolverConfigurator.accept(resolverBuilder);
    resolver = resolverBuilder.build();
}

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  w  w. j a v a  2  s.  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;//  www .  ja va2s .co m
            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;
        }
    };
}