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/engine/experiment/ndt7/dial.go

@@ -35,7 +35,10 @@ func newDialManager(ndt7URL string, logger model.Logger, userAgent string) dialM
 
 func (mgr dialManager) dialWithTestName(ctx context.Context, testName string) (*websocket.Conn, error) {
 	var reso resolver.Resolver = &netxlite.ResolverSystem{}
-	reso = &netxlite.ResolverLogger{Resolver: reso, Logger: mgr.logger}
+	reso = &netxlite.ResolverLogger{
+		Resolver: netxlite.NewResolverLegacyAdapter(reso),
+		Logger:   mgr.logger,
+	}
 	dlr := dialer.New(&dialer.Config{
 		ContextByteCounting: true,
 		Logger:              mgr.logger,

internal/engine/experiment/websteps/dns.go

@@ -11,7 +11,7 @@ import (
 
 type DNSConfig struct {
 	Domain   string
-	Resolver netxlite.Resolver
+	Resolver netxlite.ResolverLegacy
 }
 
 // DNSDo performs the DNS check.
@@ -21,7 +21,9 @@ func DNSDo(ctx context.Context, config DNSConfig) ([]string, error) {
 		childResolver, err := netx.NewDNSClient(netx.Config{Logger: log.Log}, "doh://google")
 		runtimex.PanicOnError(err, "NewDNSClient failed")
 		resolver = childResolver
-		resolver = &netxlite.ResolverIDNA{Resolver: resolver}
+		resolver = &netxlite.ResolverIDNA{
+			Resolver: netxlite.NewResolverLegacyAdapter(resolver),
+		}
 	}
 	return resolver.LookupHost(ctx, config.Domain)
 }

internal/engine/experiment/websteps/factory.go

@@ -33,23 +33,29 @@ func NewRequest(ctx context.Context, URL *url.URL, headers http.Header) *http.Re
 
 // NewDialerResolver contructs a new dialer for TCP connections,
 // with default, errorwrapping and resolve functionalities
-func NewDialerResolver(resolver netxlite.Resolver) netxlite.Dialer {
+func NewDialerResolver(resolver netxlite.ResolverLegacy) netxlite.Dialer {
 	var d netxlite.Dialer = netxlite.DefaultDialer
 	d = &errorsx.ErrorWrapperDialer{Dialer: d}
-	d = &netxlite.DialerResolver{Resolver: resolver, Dialer: d}
+	d = &netxlite.DialerResolver{
+		Resolver: netxlite.NewResolverLegacyAdapter(resolver),
+		Dialer:   d,
+	}
 	return d
 }
 
 // NewQUICDialerResolver creates a new QUICDialerResolver
 // with default, errorwrapping and resolve functionalities
-func NewQUICDialerResolver(resolver netxlite.Resolver) netxlite.QUICContextDialer {
+func NewQUICDialerResolver(resolver netxlite.ResolverLegacy) netxlite.QUICContextDialer {
 	var ql quicdialer.QUICListener = &netxlite.QUICListenerStdlib{}
 	ql = &errorsx.ErrorWrapperQUICListener{QUICListener: ql}
 	var dialer netxlite.QUICContextDialer = &netxlite.QUICDialerQUICGo{
 		QUICListener: ql,
 	}
 	dialer = &errorsx.ErrorWrapperQUICDialer{Dialer: dialer}
-	dialer = &netxlite.QUICDialerResolver{Resolver: resolver, Dialer: dialer}
+	dialer = &netxlite.QUICDialerResolver{
+		Resolver: netxlite.NewResolverLegacyAdapter(resolver),
+		Dialer:   dialer,
+	}
 	return dialer
 }
 

internal/engine/experiment/websteps/quic.go

@@ -11,7 +11,7 @@ import (
 type QUICConfig struct {
 	Endpoint   string
 	QUICDialer netxlite.QUICContextDialer
-	Resolver   netxlite.Resolver
+	Resolver   netxlite.ResolverLegacy
 	TLSConf    *tls.Config
 }
 

internal/engine/experiment/websteps/tcp.go

@@ -10,7 +10,7 @@ import (
 type TCPConfig struct {
 	Dialer   netxlite.Dialer
 	Endpoint string
-	Resolver netxlite.Resolver
+	Resolver netxlite.ResolverLegacy
 }
 
 // TCPDo performs the TCP check.