DnsNameResolverBuilder copiedBuilder = new DnsNameResolverBuilder(); copiedBuilder.eventLoop(eventLoop); copiedBuilder.channelFactory(channelFactory); copiedBuilder.resolveCache(resolveCache); copiedBuilder.cnameCache(cnameCache); copiedBuilder.ttl(minTtl, maxTtl); copiedBuilder.negativeTtl(negativeTtl); copiedBuilder.authoritativeDnsServerCache(authoritativeDnsServerCache); copiedBuilder.dnsQueryLifecycleObserverFactory(dnsQueryLifecycleObserverFactory); copiedBuilder.queryTimeoutMillis(queryTimeoutMillis); copiedBuilder.resolvedAddressTypes(resolvedAddressTypes); copiedBuilder.recursionDesired(recursionDesired); copiedBuilder.maxQueriesPerResolve(maxQueriesPerResolve); copiedBuilder.traceEnabled(traceEnabled); copiedBuilder.maxPayloadSize(maxPayloadSize); copiedBuilder.optResourceEnabled(optResourceEnabled); copiedBuilder.hostsFileEntriesResolver(hostsFileEntriesResolver); copiedBuilder.nameServerProvider(dnsServerAddressStreamProvider);
public void start(String dnsServerIps, long requestTimeout) { LOG.debug("Attempting to start DNS client"); final List<InetSocketAddress> iNetDnsServerIps = parseServerIpAddresses(dnsServerIps); nettyEventLoop = new NioEventLoopGroup(); final DnsNameResolverBuilder dnsNameResolverBuilder = new DnsNameResolverBuilder(nettyEventLoop.next()); dnsNameResolverBuilder.channelType(NioDatagramChannel.class).queryTimeoutMillis(requestTimeout); // Specify custom DNS servers if provided. If not, use those specified in local network adapter settings. if (CollectionUtils.isNotEmpty(iNetDnsServerIps)) { LOG.debug("Attempting to start DNS client with server IPs [{}] on port [{}] with timeout [{}]", dnsServerIps, DEFAULT_DNS_PORT, requestTimeout); final DnsServerAddressStreamProvider dnsServer = new SequentialDnsServerAddressStreamProvider(iNetDnsServerIps); dnsNameResolverBuilder.nameServerProvider(dnsServer); } else { LOG.debug("Attempting to start DNS client with the local network adapter DNS server address on port [{}] with timeout [{}]", DEFAULT_DNS_PORT, requestTimeout); } resolver = dnsNameResolverBuilder.build(); LOG.debug("DNS client startup successful"); }
DnsCache resolveCache = this.resolveCache != null ? this.resolveCache : newCache(); DnsCnameCache cnameCache = this.cnameCache != null ? this.cnameCache : newCnameCache(); AuthoritativeDnsServerCache authoritativeDnsServerCache = this.authoritativeDnsServerCache != null ? this.authoritativeDnsServerCache : newAuthoritativeDnsServerCache(); return new DnsNameResolver( eventLoop,
public DnsAddressResolverGroup( ChannelFactory<? extends DatagramChannel> channelFactory, DnsServerAddressStreamProvider nameServerProvider) { this(new DnsNameResolverBuilder()); dnsResolverBuilder.channelFactory(channelFactory).nameServerProvider(nameServerProvider); }
public DnsAddressResolverGroup( Class<? extends DatagramChannel> channelType, DnsServerAddressStreamProvider nameServerProvider) { this(new DnsNameResolverBuilder()); dnsResolverBuilder.channelType(channelType).nameServerProvider(nameServerProvider); }
/** * Creates a new {@link NameResolver}. Override this method to create an alternative {@link NameResolver} * implementation or override the default configuration. */ protected NameResolver<InetAddress> newNameResolver(EventLoop eventLoop, ChannelFactory<? extends DatagramChannel> channelFactory, DnsServerAddressStreamProvider nameServerProvider) throws Exception { // once again, channelFactory and nameServerProvider are most probably set in builder already, // but I do reassign them again to avoid corner cases with override methods return dnsResolverBuilder.eventLoop(eventLoop) .channelFactory(channelFactory) .nameServerProvider(nameServerProvider) .build(); }
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(); }
this.dnsResolver = new DnsNameResolverBuilder(eventLoopGroup.next()).traceEnabled(true) .channelType(EventLoopUtil.getDatagramChannelClass(eventLoopGroup)).build();
@Override public AddressResolverGroup<InetSocketAddress> apply(EventLoopGroup eventLoopGroup) { final DnsNameResolverBuilder nameResolverBuilder = new DnsNameResolverBuilder(); nameResolverBuilder.nameServerProvider(DnsServerAddressStreamProviders.platformDefault()); nameResolverBuilder.traceEnabled(true); customizers.forEach(customizer -> customizer.accept(nameResolverBuilder)); nameResolverBuilder.channelType(TransportType.datagramChannelType(eventLoopGroup)); return new DnsAddressResolverGroup(nameResolverBuilder); } }
/** * Creates a new {@link NameResolver}. Override this method to create an alternative {@link NameResolver} * implementation or override the default configuration. */ protected NameResolver<InetAddress> newNameResolver(EventLoop eventLoop, ChannelFactory<? extends DatagramChannel> channelFactory, DnsServerAddresses nameServerAddresses) throws Exception { return new DnsNameResolverBuilder(eventLoop) .channelFactory(channelFactory) .nameServerAddresses(nameServerAddresses) .build(); } }
@SuppressWarnings("deprecation") @Override protected final AddressResolver<InetSocketAddress> newResolver(EventExecutor executor) throws Exception { if (!(executor instanceof EventLoop)) { throw new IllegalStateException( "unsupported executor type: " + StringUtil.simpleClassName(executor) + " (expected: " + StringUtil.simpleClassName(EventLoop.class)); } // we don't really need to pass channelFactory and nameServerProvider separately, // but still keep this to ensure backward compatibility with (potentially) override methods return newResolver((EventLoop) executor, dnsResolverBuilder.channelFactory(), dnsResolverBuilder.nameServerProvider()); }
/** * Sets the {@link ChannelFactory} as a {@link ReflectiveChannelFactory} of this type. * Use as an alternative to {@link #channelFactory(ChannelFactory)}. * * @param channelType the type * @return {@code this} */ public DnsNameResolverBuilder channelType(Class<? extends DatagramChannel> channelType) { return channelFactory(new ReflectiveChannelFactory<DatagramChannel>(channelType)); }
DnsCache resolveCache = this.resolveCache != null ? this.resolveCache : newCache(); AuthoritativeDnsServerCache authoritativeDnsServerCache = this.authoritativeDnsServerCache != null ? this.authoritativeDnsServerCache : newAuthoritativeDnsServerCache(); return new DnsNameResolver( eventLoop,
DnsAddressEndpointGroup(EventLoop eventLoop, int minTtl, int maxTtl, DnsServerAddressStreamProvider serverAddressStreamProvider, Backoff backoff, @Nullable ResolvedAddressTypes resolvedAddressTypes, String hostname, int port) { super(eventLoop, minTtl, maxTtl, serverAddressStreamProvider, backoff, newQuestions(hostname, resolvedAddressTypes), resolverBuilder -> { if (resolvedAddressTypes != null) { resolverBuilder.resolvedAddressTypes(resolvedAddressTypes); } }); this.hostname = hostname; this.port = port; start(); }
/** * Creates a new {@link NameResolver}. Override this method to create an alternative {@link NameResolver} * implementation or override the default configuration. */ protected NameResolver<InetAddress> newNameResolver(EventLoop eventLoop, ChannelFactory<? extends DatagramChannel> channelFactory, DnsServerAddressStreamProvider nameServerProvider) throws Exception { // once again, channelFactory and nameServerProvider are most probably set in builder already, // but I do reassign them again to avoid corner cases with override methods return dnsResolverBuilder.eventLoop(eventLoop) .channelFactory(channelFactory) .nameServerProvider(nameServerProvider) .build(); }
public DnsAddressResolverGroup( Class<? extends DatagramChannel> channelType, DnsServerAddressStreamProvider nameServerProvider) { this(new DnsNameResolverBuilder()); dnsResolverBuilder.channelType(channelType).nameServerProvider(nameServerProvider); }
this.dnsResolver = new DnsNameResolverBuilder(eventLoopGroup.next()).traceEnabled(true) .channelType(EventLoopUtil.getDatagramChannelClass(eventLoopGroup)).build();
public DnsAddressResolverGroup( ChannelFactory<? extends DatagramChannel> channelFactory, DnsServerAddressStreamProvider nameServerProvider) { this(new DnsNameResolverBuilder()); dnsResolverBuilder.channelFactory(channelFactory).nameServerProvider(nameServerProvider); }
@SuppressWarnings("deprecation") @Override protected final AddressResolver<InetSocketAddress> newResolver(EventExecutor executor) throws Exception { if (!(executor instanceof EventLoop)) { throw new IllegalStateException( "unsupported executor type: " + StringUtil.simpleClassName(executor) + " (expected: " + StringUtil.simpleClassName(EventLoop.class)); } // we don't really need to pass channelFactory and nameServerProvider separately, // but still keep this to ensure backward compatibility with (potentially) override methods return newResolver((EventLoop) executor, dnsResolverBuilder.channelFactory(), dnsResolverBuilder.nameServerProvider()); }