refactor(netxlite): better integration with tracex (#774)

Rather than passing functions to construct complex objects such
as Dialer and QUICDialer, pass interface implementations.

Ensure that a nil implementation does not cause harm.

Make Saver implement the correct interface either directly or
indirectly. We need to implement the correct interface indirectly
for TCP conns (or connected UDP sockets) because we have two
distinct use cases inside netx: observing just the connect event
and observing just the I/O events.

With this change, the construction of composed Dialers and
QUICDialers is greatly simplified and more obvious.

Part of https://github.com/ooni/probe/issues/2121

internal/engine/netx/dialer/dialer.go

@@ -54,21 +54,10 @@ func New(config *Config, resolver model.Resolver) model.Dialer {
 	if config.Logger != nil {
 		logger = config.Logger
 	}
-	modifiers := []netxlite.DialerWrapper{
-		func(dialer model.Dialer) model.Dialer {
-			if config.DialSaver != nil {
-				dialer = &tracex.SaverDialer{Dialer: dialer, Saver: config.DialSaver}
-			}
-			return dialer
-		},
-		func(dialer model.Dialer) model.Dialer {
-			if config.ReadWriteSaver != nil {
-				dialer = &tracex.SaverConnDialer{Dialer: dialer, Saver: config.ReadWriteSaver}
-			}
-			return dialer
-		},
-	}
-	d := netxlite.NewDialerWithResolver(logger, resolver, modifiers...)
+	d := netxlite.NewDialerWithResolver(
+		logger, resolver, config.DialSaver.NewConnectObserver(),
+		config.ReadWriteSaver.NewReadWriteObserver(),
+	)
 	d = &netxlite.MaybeProxyDialer{ProxyURL: config.ProxyURL, Dialer: d}
 	if config.ContextByteCounting {
 		d = &bytecounter.ContextAwareDialer{Dialer: d}

internal/engine/netx/netx.go

@@ -132,12 +132,7 @@ func NewQUICDialer(config Config) model.QUICDialer {
 	if config.Logger != nil {
 		logger = config.Logger
 	}
-	extensions := []netxlite.QUICDialerWrapper{
-		func(dialer model.QUICDialer) model.QUICDialer {
-			return config.TLSSaver.WrapQUICDialer(dialer) // robust to nil TLSSaver
-		},
-	}
-	return netxlite.NewQUICDialerWithResolver(ql, logger, config.FullResolver, extensions...)
+	return netxlite.NewQUICDialerWithResolver(ql, logger, config.FullResolver, config.TLSSaver)
 }
 
 // NewTLSDialer creates a new TLSDialer from the specified config

internal/engine/netx/tracex/dialer.go

@@ -22,6 +22,31 @@ type SaverDialer struct {
 	Saver *Saver
 }
 
+// NewConnectObserver returns a DialerWrapper that observes the
+// connect event. This function will return nil, which is a valid
+// DialerWrapper for netxlite.WrapDialer, if Saver is nil.
+func (s *Saver) NewConnectObserver() model.DialerWrapper {
+	if s == nil {
+		return nil // valid DialerWrapper according to netxlite's docs
+	}
+	return &saverDialerWrapper{
+		saver: s,
+	}
+}
+
+type saverDialerWrapper struct {
+	saver *Saver
+}
+
+var _ model.DialerWrapper = &saverDialerWrapper{}
+
+func (w *saverDialerWrapper) WrapDialer(d model.Dialer) model.Dialer {
+	return &SaverDialer{
+		Dialer: d,
+		Saver:  w.saver,
+	}
+}
+
 // DialContext implements Dialer.DialContext
 func (d *SaverDialer) DialContext(ctx context.Context, network, address string) (net.Conn, error) {
 	start := time.Now()
@@ -52,6 +77,31 @@ type SaverConnDialer struct {
 	Saver *Saver
 }
 
+// NewReadWriteObserver returns a DialerWrapper that observes the
+// I/O events. This function will return nil, which is a valid
+// DialerWrapper for netxlite.WrapDialer, if Saver is nil.
+func (s *Saver) NewReadWriteObserver() model.DialerWrapper {
+	if s == nil {
+		return nil // valid DialerWrapper according to netxlite's docs
+	}
+	return &saverReadWriteWrapper{
+		saver: s,
+	}
+}
+
+type saverReadWriteWrapper struct {
+	saver *Saver
+}
+
+var _ model.DialerWrapper = &saverReadWriteWrapper{}
+
+func (w *saverReadWriteWrapper) WrapDialer(d model.Dialer) model.Dialer {
+	return &SaverConnDialer{
+		Dialer: d,
+		Saver:  w.saver,
+	}
+}
+
 // DialContext implements Dialer.DialContext
 func (d *SaverConnDialer) DialContext(ctx context.Context, network, address string) (net.Conn, error) {
 	conn, err := d.Dialer.DialContext(ctx, network, address)

internal/engine/netx/tracex/saver.go

@@ -7,7 +7,7 @@ package tracex
 import "sync"
 
 // The Saver saves a trace. The zero value of this type
-// is valid and can be used without initializtion.
+// is valid and can be used without initialization.
 type Saver struct {
 	// ops contains the saved events.
 	ops []Event

internal/engine/netx/tracex/tls_test.go

@@ -23,12 +23,7 @@ func TestSaverTLSHandshakerSuccessWithReadWrite(t *testing.T) {
 		Dialer: netxlite.NewDialerWithResolver(
 			model.DiscardLogger,
 			netxlite.NewResolverStdlib(model.DiscardLogger),
-			func(dialer model.Dialer) model.Dialer {
-				return &SaverConnDialer{
-					Dialer: dialer,
-					Saver:  saver,
-				}
-			},
+			saver.NewReadWriteObserver(),
 		),
 		TLSHandshaker: saver.WrapTLSHandshaker(&netxlite.TLSHandshakerConfigurable{}),
 	}