Filter resolvers to compatible address type instead of trying resolvers until a compatible address type comes out

[jcgruenhage]

Right now, when querying for a specific address family, this generates a stream of results that query any resolvers, and will potentially query an incompatible resolver, just to throw away the result because the result is incompatible. This potentially delays the result and causes unnecessary load on the backend providers side.

I'd be willing to implement this, but I'd like to wait for feedback here if this is wanted and whether you have any strong opinions on how this should be implemented.

[aWeinzierl]

Is this really the case?
The family is passed to the resolver, see:

rust-public-ip/src/lib.rs

Lines 195 to 201 in 675505f

	/// This function also protects against a resolver returning a IP address with a
	/// version that was not requested.
	pub fn resolve<'r>(resolver: impl Resolver<'r>, version: Version) -> Resolutions<'r> {
	let stream = resolver.resolve(version).and_then(move |(addr, details)| {
	// If a resolver returns a version not matching the one we requested
	// this is an error so it is skipped.
	let result = if version.matches(addr) {

It is not expected that a different family is returned, but checked still.

[jcgruenhage]

Yes, to my understanding of this crate, this is the case. The resolver does get the IP, but that doesn't mean that it only tries resolvers that are compatible. For example, the api.ipify.org http resolver doesn't support IPv6:

~ 
❯ dig +short A api.ipify.org
104.26.12.205
104.26.13.205
172.67.74.152

~ 
❯ dig +short AAAA api.ipify.org

~ 
❯ 

The resolver will still try to resolve a v6 address for api.ipify.org, fail, and return an error. For other resolvers that are dual-stack capable, they will successfully resolve a v6 address even when trying to get a v4 address, use that to obtain the public v6 address, only to throw it away afterwards.