refactor(netxlite): add more functions to resolver (#455)

We would like to refactor the code so that a DoH resolver owns the
connections of its underlying HTTP client.

To do that, we need first to incorporate CloseIdleConnections
into the Resolver model. Then, we need to add the same function
to all netxlite types that wrap a Resolver type.

At the same time, we want the rest of the code for now to continue
with the simpler definition of a Resolver, now called ResolverLegacy.

We will eventually propagate this change to the rest of the tree
and simplify the way in which we manage Resolvers.

To make this possible, we introduce a new factory function that
adapts a ResolverLegacy to become a Resolver.

See https://github.com/ooni/probe/issues/1591.

internal/netxlite/resolver.go

@@ -12,6 +12,31 @@ import (
 type Resolver interface {
 	// LookupHost behaves like net.Resolver.LookupHost.
 	LookupHost(ctx context.Context, hostname string) (addrs []string, err error)
+
+	// Network returns the resolver type (e.g., system, dot, doh).
+	Network() string
+
+	// Address returns the resolver address (e.g., 8.8.8.8:53).
+	Address() string
+
+	// CloseIdleConnections closes idle connections, if any.
+	CloseIdleConnections()
+}
+
+// ResolverConfig contains config for creating a resolver.
+type ResolverConfig struct {
+	// Logger is the MANDATORY logger to use.
+	Logger Logger
+}
+
+// NewResolver creates a new resolver.
+func NewResolver(config *ResolverConfig) Resolver {
+	return &resolverIDNA{
+		Resolver: &resolverLogger{
+			Resolver: &resolverSystem{},
+			Logger:   config.Logger,
+		},
+	}
 }
 
 // resolverSystem is the system resolver.
@@ -34,6 +59,11 @@ func (r *resolverSystem) Address() string {
 	return ""
 }
 
+// CloseIdleConnections implements Resolver.CloseIdleConnections.
+func (r *resolverSystem) CloseIdleConnections() {
+	// nothing
+}
+
 // DefaultResolver is the resolver we use by default.
 var DefaultResolver = &resolverSystem{}
 
@@ -59,30 +89,6 @@ func (r *resolverLogger) LookupHost(ctx context.Context, hostname string) ([]str
 	return addrs, nil
 }
 
-type resolverNetworker interface {
-	Network() string
-}
-
-// Network implements Resolver.Network.
-func (r *resolverLogger) Network() string {
-	if rn, ok := r.Resolver.(resolverNetworker); ok {
-		return rn.Network()
-	}
-	return "logger"
-}
-
-type resolverAddresser interface {
-	Address() string
-}
-
-// Address implements Resolver.Address.
-func (r *resolverLogger) Address() string {
-	if ra, ok := r.Resolver.(resolverAddresser); ok {
-		return ra.Address()
-	}
-	return ""
-}
-
 // resolverIDNA supports resolving Internationalized Domain Names.
 //
 // See RFC3492 for more information.
@@ -98,19 +104,3 @@ func (r *resolverIDNA) LookupHost(ctx context.Context, hostname string) ([]strin
 	}
 	return r.Resolver.LookupHost(ctx, host)
 }
-
-// Network implements Resolver.Network.
-func (r *resolverIDNA) Network() string {
-	if rn, ok := r.Resolver.(resolverNetworker); ok {
-		return rn.Network()
-	}
-	return "idna"
-}
-
-// Address implements Resolver.Address.
-func (r *resolverIDNA) Address() string {
-	if ra, ok := r.Resolver.(resolverAddresser); ok {
-		return ra.Address()
-	}
-	return ""
-}