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/netx/dialer/dialer.go

@@ -80,7 +80,10 @@ func New(config *Config, resolver Resolver) Dialer {
 	if config.ReadWriteSaver != nil {
 		d = &saverConnDialer{Dialer: d, Saver: config.ReadWriteSaver}
 	}
-	d = &netxlite.DialerResolver{Resolver: resolver, Dialer: d}
+	d = &netxlite.DialerResolver{
+		Resolver: netxlite.NewResolverLegacyAdapter(resolver),
+		Dialer:   d,
+	}
 	d = &proxyDialer{ProxyURL: config.ProxyURL, Dialer: d}
 	if config.ContextByteCounting {
 		d = &byteCounterDialer{Dialer: d}

internal/engine/netx/netx.go

@@ -134,12 +134,15 @@ func NewResolver(config Config) Resolver {
 	}
 	r = &errorsx.ErrorWrapperResolver{Resolver: r}
 	if config.Logger != nil {
-		r = &netxlite.ResolverLogger{Logger: config.Logger, Resolver: r}
+		r = &netxlite.ResolverLogger{
+			Logger:   config.Logger,
+			Resolver: netxlite.NewResolverLegacyAdapter(r),
+		}
 	}
 	if config.ResolveSaver != nil {
 		r = resolver.SaverResolver{Resolver: r, Saver: config.ResolveSaver}
 	}
-	return &resolver.IDNAResolver{Resolver: r}
+	return &resolver.IDNAResolver{Resolver: netxlite.NewResolverLegacyAdapter(r)}
 }
 
 // NewDialer creates a new Dialer from the specified config
@@ -176,7 +179,10 @@ func NewQUICDialer(config Config) QUICDialer {
 	if config.TLSSaver != nil {
 		d = quicdialer.HandshakeSaver{Saver: config.TLSSaver, Dialer: d}
 	}
-	d = &netxlite.QUICDialerResolver{Resolver: config.FullResolver, Dialer: d}
+	d = &netxlite.QUICDialerResolver{
+		Resolver: netxlite.NewResolverLegacyAdapter(config.FullResolver),
+		Dialer:   d,
+	}
 	return d
 }
 

internal/engine/netx/netx_test.go

@@ -24,7 +24,11 @@ func TestNewResolverVanilla(t *testing.T) {
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
-	ewr, ok := ir.Resolver.(*errorsx.ErrorWrapperResolver)
+	rla, ok := ir.Resolver.(*netxlite.ResolverLegacyAdapter)
+	if !ok {
+		t.Fatal("not the resolver we expected")
+	}
+	ewr, ok := rla.ResolverLegacy.(*errorsx.ErrorWrapperResolver)
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
@@ -48,7 +52,11 @@ func TestNewResolverSpecificResolver(t *testing.T) {
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
-	ewr, ok := ir.Resolver.(*errorsx.ErrorWrapperResolver)
+	rla, ok := ir.Resolver.(*netxlite.ResolverLegacyAdapter)
+	if !ok {
+		t.Fatal("not the resolver we expected")
+	}
+	ewr, ok := rla.ResolverLegacy.(*errorsx.ErrorWrapperResolver)
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
@@ -70,7 +78,11 @@ func TestNewResolverWithBogonFilter(t *testing.T) {
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
-	ewr, ok := ir.Resolver.(*errorsx.ErrorWrapperResolver)
+	rla, ok := ir.Resolver.(*netxlite.ResolverLegacyAdapter)
+	if !ok {
+		t.Fatal("not the resolver we expected")
+	}
+	ewr, ok := rla.ResolverLegacy.(*errorsx.ErrorWrapperResolver)
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
@@ -96,17 +108,33 @@ func TestNewResolverWithLogging(t *testing.T) {
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
-	lr, ok := ir.Resolver.(*netxlite.ResolverLogger)
+	rla, ok := ir.Resolver.(*netxlite.ResolverLegacyAdapter)
+	if !ok {
+		t.Fatal("not the resolver we expected")
+	}
+	lr, ok := rla.ResolverLegacy.(*netxlite.ResolverLogger)
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
 	if lr.Logger != log.Log {
 		t.Fatal("not the logger we expected")
 	}
-	ewr, ok := lr.Resolver.(*errorsx.ErrorWrapperResolver)
+	rla, ok = ir.Resolver.(*netxlite.ResolverLegacyAdapter)
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
+	lr, ok = rla.ResolverLegacy.(*netxlite.ResolverLogger)
+	if !ok {
+		t.Fatal("not the resolver we expected")
+	}
+	rla, ok = lr.Resolver.(*netxlite.ResolverLegacyAdapter)
+	if !ok {
+		t.Fatal("not the resolver we expected")
+	}
+	ewr, ok := rla.ResolverLegacy.(*errorsx.ErrorWrapperResolver)
+	if !ok {
+		t.Fatalf("not the resolver we expected %T", rla.ResolverLegacy)
+	}
 	ar, ok := ewr.Resolver.(resolver.AddressResolver)
 	if !ok {
 		t.Fatal("not the resolver we expected")
@@ -126,7 +154,11 @@ func TestNewResolverWithSaver(t *testing.T) {
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
-	sr, ok := ir.Resolver.(resolver.SaverResolver)
+	rla, ok := ir.Resolver.(*netxlite.ResolverLegacyAdapter)
+	if !ok {
+		t.Fatal("not the resolver we expected")
+	}
+	sr, ok := rla.ResolverLegacy.(resolver.SaverResolver)
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
@@ -155,7 +187,11 @@ func TestNewResolverWithReadWriteCache(t *testing.T) {
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
-	ewr, ok := ir.Resolver.(*errorsx.ErrorWrapperResolver)
+	rla, ok := ir.Resolver.(*netxlite.ResolverLegacyAdapter)
+	if !ok {
+		t.Fatal("not the resolver we expected")
+	}
+	ewr, ok := rla.ResolverLegacy.(*errorsx.ErrorWrapperResolver)
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
@@ -186,7 +222,11 @@ func TestNewResolverWithPrefilledReadonlyCache(t *testing.T) {
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
-	ewr, ok := ir.Resolver.(*errorsx.ErrorWrapperResolver)
+	rla, ok := ir.Resolver.(*netxlite.ResolverLegacyAdapter)
+	if !ok {
+		t.Fatal("not the resolver we expected")
+	}
+	ewr, ok := rla.ResolverLegacy.(*errorsx.ErrorWrapperResolver)
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}

internal/engine/netx/resolver/integration_test.go

@@ -19,7 +19,10 @@ func testresolverquick(t *testing.T, reso resolver.Resolver) {
 	if testing.Short() {
 		t.Skip("skip test in short mode")
 	}
-	reso = &netxlite.ResolverLogger{Logger: log.Log, Resolver: reso}
+	reso = &netxlite.ResolverLogger{
+		Logger:   log.Log,
+		Resolver: netxlite.NewResolverLegacyAdapter(reso),
+	}
 	addrs, err := reso.LookupHost(context.Background(), "dns.google.com")
 	if err != nil {
 		t.Fatal(err)
@@ -45,7 +48,10 @@ func testresolverquickidna(t *testing.T, reso resolver.Resolver) {
 		t.Skip("skip test in short mode")
 	}
 	reso = &resolver.IDNAResolver{
-		Resolver: &netxlite.ResolverLogger{Logger: log.Log, Resolver: reso},
+		Resolver: &netxlite.ResolverLogger{
+			Logger:   log.Log,
+			Resolver: netxlite.NewResolverLegacyAdapter(reso),
+		},
 	}
 	addrs, err := reso.LookupHost(context.Background(), "яндекс.рф")
 	if err != nil {