refactor(netxlite): allow easy dialer chain customization (#770)

This diff modifies the construction of a dialer to allow one
to insert custom dialer wrappers into the dialers chain.

The point of the chain in which we allow custom wrappers is the
optimal one for connect, read, and write measurements.

This new design is better than the previous netx design since
we don't need to construct the whole chain manually now.

The work in this diff is part of the effort to make engine/netx
just a tiny wrapper around netxlite.

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

internal/engine/netx/dialer/dialer.go

@@ -50,23 +50,25 @@ type Config struct {
 
 // New creates a new Dialer from the specified config and resolver.
 func New(config *Config, resolver model.Resolver) model.Dialer {
-	var d model.Dialer = &netxlite.ErrorWrapperDialer{Dialer: netxlite.DefaultDialer}
+	var logger model.DebugLogger = model.DiscardLogger
 	if config.Logger != nil {
-		d = &netxlite.DialerLogger{
-			Dialer:      d,
-			DebugLogger: config.Logger,
-		}
+		logger = config.Logger
 	}
-	if config.DialSaver != nil {
-		d = &saverDialer{Dialer: d, Saver: config.DialSaver}
-	}
-	if config.ReadWriteSaver != nil {
-		d = &saverConnDialer{Dialer: d, Saver: config.ReadWriteSaver}
-	}
-	d = &netxlite.DialerResolver{
-		Resolver: resolver,
-		Dialer:   d,
+	modifiers := []netxlite.DialerWrapper{
+		func(dialer model.Dialer) model.Dialer {
+			if config.DialSaver != nil {
+				dialer = &saverDialer{Dialer: dialer, Saver: config.DialSaver}
+			}
+			return dialer
+		},
+		func(dialer model.Dialer) model.Dialer {
+			if config.ReadWriteSaver != nil {
+				dialer = &saverConnDialer{Dialer: dialer, Saver: config.ReadWriteSaver}
+			}
+			return dialer
+		},
 	}
+	d := netxlite.NewDialerWithResolver(logger, resolver, modifiers...)
 	d = &netxlite.MaybeProxyDialer{ProxyURL: config.ProxyURL, Dialer: d}
 	if config.ContextByteCounting {
 		d = &bytecounter.ContextAwareDialer{Dialer: d}

internal/engine/netx/dialer/dialer_test.go

@@ -24,34 +24,12 @@ func TestNewCreatesTheExpectedChain(t *testing.T) {
 	if !ok {
 		t.Fatal("not a byteCounterDialer")
 	}
-	pd, ok := bcd.Dialer.(*netxlite.MaybeProxyDialer)
+	_, ok = bcd.Dialer.(*netxlite.MaybeProxyDialer)
 	if !ok {
 		t.Fatal("not a proxyDialer")
 	}
-	dnsd, ok := pd.Dialer.(*netxlite.DialerResolver)
-	if !ok {
-		t.Fatal("not a dnsDialer")
-	}
-	scd, ok := dnsd.Dialer.(*saverConnDialer)
-	if !ok {
-		t.Fatal("not a saverConnDialer")
-	}
-	sd, ok := scd.Dialer.(*saverDialer)
-	if !ok {
-		t.Fatal("not a saverDialer")
-	}
-	ld, ok := sd.Dialer.(*netxlite.DialerLogger)
-	if !ok {
-		t.Fatal("not a loggingDialer")
-	}
-	ewd, ok := ld.Dialer.(*netxlite.ErrorWrapperDialer)
-	if !ok {
-		t.Fatal("not an errorWrappingDialer")
-	}
-	_, ok = ewd.Dialer.(*netxlite.DialerSystem)
-	if !ok {
-		t.Fatal("not a DialerSystem")
-	}
+	// We can safely stop here: the rest is tested by
+	// the internal/netxlite package
 }
 
 func TestDialerNewSuccess(t *testing.T) {