@Override public DnsServerAddressStream nameServerAddressStream(String hostname) { return DEFAULT_NAME_SERVERS.stream(); }
/** * Sets the DNS server addresses to send queries to. Operating system default is used by default. */ public final B serverAddresses(Iterable<InetSocketAddress> serverAddresses) { requireNonNull(serverAddresses, "serverAddresses"); final DnsServerAddresses addrs = DnsServerAddresses.sequential(serverAddresses); serverAddressStreamProvider = hostname -> addrs.stream(); return self(); }
/** * Returns the {@link DnsServerAddresses} that yields the specified {@code addresses} in a rotational sequential * order. It is similar to {@link #sequential(Iterable)}, but each {@link DnsServerAddressStream} starts from * a different starting point. For example, the first {@link #stream()} will start from the first address, the * second one will start from the second address, and so on. */ public static DnsServerAddresses rotational(Iterable<? extends InetSocketAddress> addresses) { return rotational0(sanitize(addresses)); }
/** * Returns the {@link DnsServerAddresses} that yields the specified {@code addresses} sequentially. Once the * last address is yielded, it will start again from the first address. */ public static DnsServerAddresses sequential(Iterable<? extends InetSocketAddress> addresses) { return sequential0(sanitize(addresses)); }
/** * Create a new instance. * @param addresses The addresses which will be be returned in sequential order via * {@link #nameServerAddressStream(String)} */ public SequentialDnsServerAddressStreamProvider(Iterable<? extends InetSocketAddress> addresses) { super(sequential(addresses)); } }
/** * Create a new instance. * @param address The singleton address to use for every DNS resolution. */ public SingletonDnsServerAddressStreamProvider(final InetSocketAddress address) { super(DnsServerAddresses.singleton(address)); } }
DnsServerAddressStream stream = DefaultDnsServerAddressStreamProvider.defaultAddresses().stream(); Set<InetSocketAddress> all = new HashSet<>(); while (true) { DnsServerAddresses nameServerAddresses = options.isRotateServers() ? DnsServerAddresses.rotational(serverList) : DnsServerAddresses.sequential(serverList); DnsServerAddressStreamProvider nameServerAddressProvider = hostname -> nameServerAddresses.stream();
private void followCname(InetSocketAddress nameServerAddr, String name, String cname, Promise<T> promise) { if (traceEnabled) { if (trace == null) { trace = new StringBuilder(128); } trace.append(StringUtil.NEWLINE); trace.append("\tfrom "); trace.append(nameServerAddr); trace.append(": "); trace.append(name); trace.append(" CNAME "); trace.append(cname); } // Use the same server for both CNAME queries DnsServerAddressStream stream = DnsServerAddresses.singleton(getNameServers(cname).next()).stream(); if (parent.supportsARecords() && !query(hostname, DnsRecordType.A, stream, promise)) { return; } if (parent.supportsAAAARecords()) { query(hostname, DnsRecordType.AAAA, stream, promise); } }
/** * Returns the {@link DnsServerAddresses} that yields the specified {@code address} in a shuffled order. Once all * addresses are yielded, the addresses are shuffled again. */ public static DnsServerAddresses shuffled(Iterable<? extends InetSocketAddress> addresses) { return shuffled0(sanitize(addresses)); }
/** * Returns the {@link DnsServerAddresses} that yields the specified {@code addresses} sequentially. Once the * last address is yielded, it will start again from the first address. */ public static DnsServerAddresses sequential(InetSocketAddress... addresses) { return sequential0(sanitize(addresses)); }
/** * Create a new instance. * @param addresses The addresses which will be be returned in sequential order via * {@link #nameServerAddressStream(String)} */ public SequentialDnsServerAddressStreamProvider(InetSocketAddress... addresses) { super(sequential(addresses)); }
/** * Create a new instance. * @param address The singleton address to use for every DNS resolution. */ public SingletonDnsServerAddressStreamProvider(final InetSocketAddress address) { super(DnsServerAddresses.singleton(address)); } }
DnsServerAddressStream stream = DefaultDnsServerAddressStreamProvider.defaultAddresses().stream(); Set<InetSocketAddress> all = new HashSet<>(); while (true) { DnsServerAddresses nameServerAddresses = options.isRotateServers() ? DnsServerAddresses.rotational(serverList) : DnsServerAddresses.sequential(serverList); DnsServerAddressStreamProvider nameServerAddressProvider = hostname -> nameServerAddresses.stream();
@Override public final DnsServerAddressStream nameServerAddressStream(String hostname) { return addresses.stream(); } }
/** * Returns the {@link DnsServerAddresses} that yields the specified {@code addresses} sequentially. Once the * last address is yielded, it will start again from the first address. */ public static DnsServerAddresses sequential(InetSocketAddress... addresses) { return sequential0(sanitize(addresses)); }
/** * Returns the {@link DnsServerAddresses} that yields the specified {@code addresses} in a rotational sequential * order. It is similar to {@link #sequential(Iterable)}, but each {@link DnsServerAddressStream} starts from * a different starting point. For example, the first {@link #stream()} will start from the first address, the * second one will start from the second address, and so on. */ public static DnsServerAddresses rotational(InetSocketAddress... addresses) { return rotational0(sanitize(addresses)); }