cleanup: remove unnecessary legacy interfaces (#656)

This diff addresses another point of https://github.com/ooni/probe/issues/1956:

> - [ ] observe that we're still using a bunch of private interfaces for common interfaces such as the `Dialer`, so we can get rid of these private interfaces and always use the ones in `model`, which allows us to remove a bunch of legacy wrappers

Additional cleanups may still be possible. The more I cleanup, the more I see
there's extra legacy code we can dispose of (which seems good?).

internal/engine/netx/dialer/bytecounter.go

@@ -5,12 +5,13 @@ import (
 	"net"
 
 	"github.com/ooni/probe-cli/v3/internal/bytecounter"
+	"github.com/ooni/probe-cli/v3/internal/model"
 )
 
 // byteCounterDialer is a byte-counting-aware dialer. To perform byte counting, you
 // should make sure that you insert this dialer in the dialing chain.
 type byteCounterDialer struct {
-	Dialer
+	model.Dialer
 }
 
 // DialContext implements Dialer.DialContext

internal/engine/netx/dialer/bytecounter_test.go

@@ -16,7 +16,7 @@ import (
 func dorequest(ctx context.Context, url string) error {
 	txp := http.DefaultTransport.(*http.Transport).Clone()
 	defer txp.CloseIdleConnections()
-	dialer := &byteCounterDialer{Dialer: new(net.Dialer)}
+	dialer := &byteCounterDialer{Dialer: netxlite.DefaultDialer}
 	txp.DialContext = dialer.DialContext
 	client := &http.Client{Transport: txp}
 	req, err := http.NewRequestWithContext(ctx, "GET", "http://www.google.com", nil)

internal/engine/netx/dialer/dialer.go

@@ -1,8 +1,6 @@
 package dialer
 
 import (
-	"context"
-	"net"
 	"net/url"
 
 	"github.com/ooni/probe-cli/v3/internal/engine/netx/trace"
@@ -10,18 +8,6 @@ import (
 	"github.com/ooni/probe-cli/v3/internal/netxlite"
 )
 
-// Dialer establishes network connections.
-type Dialer interface {
-	// DialContext behaves like net.Dialer.DialContext.
-	DialContext(ctx context.Context, network, address string) (net.Conn, error)
-}
-
-// Resolver is the interface we expect from a DNS resolver.
-type Resolver interface {
-	// LookupHost behaves like net.Resolver.LookupHost.
-	LookupHost(ctx context.Context, hostname string) (addrs []string, err error)
-}
-
 // Config contains the settings for New.
 type Config struct {
 	// ContextByteCounting optionally configures context-based
@@ -59,11 +45,11 @@ type Config struct {
 }
 
 // New creates a new Dialer from the specified config and resolver.
-func New(config *Config, resolver Resolver) Dialer {
-	var d Dialer = &netxlite.ErrorWrapperDialer{Dialer: netxlite.DefaultDialer}
+func New(config *Config, resolver model.Resolver) model.Dialer {
+	var d model.Dialer = &netxlite.ErrorWrapperDialer{Dialer: netxlite.DefaultDialer}
 	if config.Logger != nil {
 		d = &netxlite.DialerLogger{
-			Dialer:      netxlite.NewDialerLegacyAdapter(d),
+			Dialer:      d,
 			DebugLogger: config.Logger,
 		}
 	}
@@ -74,8 +60,8 @@ func New(config *Config, resolver Resolver) Dialer {
 		d = &saverConnDialer{Dialer: d, Saver: config.ReadWriteSaver}
 	}
 	d = &netxlite.DialerResolver{
-		Resolver: netxlite.NewResolverLegacyAdapter(resolver),
-		Dialer:   netxlite.NewDialerLegacyAdapter(d),
+		Resolver: resolver,
+		Dialer:   d,
 	}
 	d = &proxyDialer{ProxyURL: config.ProxyURL, Dialer: d}
 	if config.ContextByteCounting {

internal/engine/netx/dialer/dialer_test.go

@@ -1,7 +1,6 @@
 package dialer
 
 import (
-	"net"
 	"net/url"
 	"testing"
 
@@ -18,7 +17,7 @@ func TestNewCreatesTheExpectedChain(t *testing.T) {
 		Logger:              log.Log,
 		ProxyURL:            &url.URL{},
 		ReadWriteSaver:      saver,
-	}, &net.Resolver{})
+	}, netxlite.DefaultResolver)
 	shd, ok := dlr.(*shapingDialer)
 	if !ok {
 		t.Fatal("not a shapingDialer")
@@ -35,11 +34,7 @@ func TestNewCreatesTheExpectedChain(t *testing.T) {
 	if !ok {
 		t.Fatal("not a dnsDialer")
 	}
-	dad, ok := dnsd.Dialer.(*netxlite.DialerLegacyAdapter)
-	if !ok {
-		t.Fatal("invalid type")
-	}
-	scd, ok := dad.DialerLegacy.(*saverConnDialer)
+	scd, ok := dnsd.Dialer.(*saverConnDialer)
 	if !ok {
 		t.Fatal("not a saverConnDialer")
 	}
@@ -51,11 +46,7 @@ func TestNewCreatesTheExpectedChain(t *testing.T) {
 	if !ok {
 		t.Fatal("not a loggingDialer")
 	}
-	dad, ok = ld.Dialer.(*netxlite.DialerLegacyAdapter)
-	if !ok {
-		t.Fatal("invalid type")
-	}
-	ewd, ok := dad.DialerLegacy.(*netxlite.ErrorWrapperDialer)
+	ewd, ok := ld.Dialer.(*netxlite.ErrorWrapperDialer)
 	if !ok {
 		t.Fatal("not an errorWrappingDialer")
 	}

internal/engine/netx/dialer/example_test.go

@@ -2,11 +2,11 @@ package dialer_test
 
 import (
 	"context"
-	"net"
 
 	"github.com/apex/log"
 	"github.com/ooni/probe-cli/v3/internal/engine/netx/dialer"
 	"github.com/ooni/probe-cli/v3/internal/engine/netx/trace"
+	"github.com/ooni/probe-cli/v3/internal/netxlite"
 )
 
 func Example() {
@@ -16,7 +16,7 @@ func Example() {
 		DialSaver:      saver,
 		Logger:         log.Log,
 		ReadWriteSaver: saver,
-	}, &net.Resolver{})
+	}, netxlite.DefaultResolver)
 
 	ctx := context.Background()
 	conn, err := dlr.DialContext(ctx, "tcp", "8.8.8.8:53")

internal/engine/netx/dialer/integration_test.go

@@ -1,12 +1,12 @@
 package dialer_test
 
 import (
-	"net"
 	"net/http"
 	"testing"
 
 	"github.com/apex/log"
 	"github.com/ooni/probe-cli/v3/internal/engine/netx/dialer"
+	"github.com/ooni/probe-cli/v3/internal/netxlite"
 )
 
 func TestDialerNewSuccess(t *testing.T) {
@@ -14,7 +14,7 @@ func TestDialerNewSuccess(t *testing.T) {
 		t.Skip("skip test in short mode")
 	}
 	log.SetLevel(log.DebugLevel)
-	d := dialer.New(&dialer.Config{Logger: log.Log}, &net.Resolver{})
+	d := dialer.New(&dialer.Config{Logger: log.Log}, netxlite.DefaultResolver)
 	txp := &http.Transport{DialContext: d.DialContext}
 	client := &http.Client{Transport: txp}
 	resp, err := client.Get("http://www.google.com")

internal/engine/netx/dialer/proxy.go

@@ -6,6 +6,7 @@ import (
 	"net"
 	"net/url"
 
+	"github.com/ooni/probe-cli/v3/internal/model"
 	"golang.org/x/net/proxy"
 )
 
@@ -13,7 +14,7 @@ import (
 // dialer is a passthrough for the next Dialer in chain. Otherwise, it will internally
 // create a SOCKS5 dialer that will connect to the proxy using the underlying Dialer.
 type proxyDialer struct {
-	Dialer
+	model.Dialer
 	ProxyURL *url.URL
 }
 
@@ -47,7 +48,7 @@ func (d *proxyDialer) dial(
 //
 // See https://git.io/JfJ4g.
 type proxyDialerWrapper struct {
-	Dialer
+	model.Dialer
 }
 
 func (d *proxyDialerWrapper) Dial(network, address string) (net.Conn, error) {

internal/engine/netx/dialer/saver.go

@@ -6,12 +6,13 @@ import (
 	"time"
 
 	"github.com/ooni/probe-cli/v3/internal/engine/netx/trace"
+	"github.com/ooni/probe-cli/v3/internal/model"
 	"github.com/ooni/probe-cli/v3/internal/netxlite"
 )
 
 // saverDialer saves events occurring during the dial
 type saverDialer struct {
-	Dialer
+	model.Dialer
 	Saver *trace.Saver
 }
 
@@ -34,7 +35,7 @@ func (d *saverDialer) DialContext(ctx context.Context, network, address string)
 // saverConnDialer wraps the returned connection such that we
 // collect all the read/write events that occur.
 type saverConnDialer struct {
-	Dialer
+	model.Dialer
 	Saver *trace.Saver
 }
 
@@ -82,6 +83,6 @@ func (c *saverConn) Write(p []byte) (int, error) {
 	return count, err
 }
 
-var _ Dialer = &saverDialer{}
-var _ Dialer = &saverConnDialer{}
+var _ model.Dialer = &saverDialer{}
+var _ model.Dialer = &saverConnDialer{}
 var _ net.Conn = &saverConn{}

internal/engine/netx/dialer/shaping_disabled.go

@@ -6,13 +6,15 @@ package dialer
 import (
 	"context"
 	"net"
+
+	"github.com/ooni/probe-cli/v3/internal/model"
 )
 
 // shapingDialer ensures we don't use too much bandwidth
 // when using integration tests at GitHub. To select
 // the implementation with shaping use `-tags shaping`.
 type shapingDialer struct {
-	Dialer
+	model.Dialer
 }
 
 // DialContext implements Dialer.DialContext

internal/engine/netx/dialer/shaping_enabled.go

@@ -7,13 +7,15 @@ import (
 	"context"
 	"net"
 	"time"
+
+	"github.com/ooni/probe-cli/v3/internal/model"
 )
 
 // shapingDialer ensures we don't use too much bandwidth
 // when using integration tests at GitHub. To select
 // the implementation with shaping use `-tags shaping`.
 type shapingDialer struct {
-	Dialer
+	model.Dialer
 }
 
 // DialContext implements Dialer.DialContext

internal/engine/netx/dialer/shaping_test.go

@@ -1,13 +1,14 @@
 package dialer
 
 import (
-	"net"
 	"net/http"
 	"testing"
+
+	"github.com/ooni/probe-cli/v3/internal/netxlite"
 )
 
 func TestShapingDialerGood(t *testing.T) {
-	d := &shapingDialer{Dialer: &net.Dialer{}}
+	d := &shapingDialer{Dialer: netxlite.DefaultDialer}
 	txp := &http.Transport{DialContext: d.DialContext}
 	client := &http.Client{Transport: txp}
 	resp, err := client.Get("https://www.google.com/")

internal/engine/netx/fake_test.go

@@ -19,6 +19,8 @@ func (d FakeDialer) DialContext(ctx context.Context, network, address string) (n
 	return d.Conn, d.Err
 }
 
+func (d FakeDialer) CloseIdleConnections() {}
+
 type FakeTransport struct {
 	Err  error
 	Func func(*http.Request) (*http.Response, error)

internal/engine/netx/httptransport/bytecounter.go

@@ -5,11 +5,12 @@ import (
 	"net/http"
 
 	"github.com/ooni/probe-cli/v3/internal/bytecounter"
+	"github.com/ooni/probe-cli/v3/internal/model"
 )
 
 // ByteCountingTransport is a RoundTripper that counts bytes.
 type ByteCountingTransport struct {
-	RoundTripper
+	model.HTTPTransport
 	Counter *bytecounter.Counter
 }
 
@@ -20,7 +21,7 @@ func (txp ByteCountingTransport) RoundTrip(req *http.Request) (*http.Response, e
 			ReadCloser: req.Body, Account: txp.Counter.CountBytesSent}
 	}
 	txp.estimateRequestMetadata(req)
-	resp, err := txp.RoundTripper.RoundTrip(req)
+	resp, err := txp.HTTPTransport.RoundTrip(req)
 	if err != nil {
 		return nil, err
 	}
@@ -70,4 +71,4 @@ func (r byteCountingBody) Read(p []byte) (int, error) {
 	return count, err
 }
 
-var _ RoundTripper = ByteCountingTransport{}
+var _ model.HTTPTransport = ByteCountingTransport{}

internal/engine/netx/httptransport/bytecounter_test.go

@@ -17,7 +17,7 @@ func TestByteCounterFailure(t *testing.T) {
 	counter := bytecounter.New()
 	txp := httptransport.ByteCountingTransport{
 		Counter: counter,
-		RoundTripper: httptransport.FakeTransport{
+		HTTPTransport: httptransport.FakeTransport{
 			Err: io.EOF,
 		},
 	}
@@ -47,7 +47,7 @@ func TestByteCounterSuccess(t *testing.T) {
 	counter := bytecounter.New()
 	txp := httptransport.ByteCountingTransport{
 		Counter: counter,
-		RoundTripper: httptransport.FakeTransport{
+		HTTPTransport: httptransport.FakeTransport{
 			Resp: &http.Response{
 				Body: io.NopCloser(strings.NewReader("1234567")),
 				Header: http.Header{
@@ -89,7 +89,7 @@ func TestByteCounterSuccessWithEOF(t *testing.T) {
 	counter := bytecounter.New()
 	txp := httptransport.ByteCountingTransport{
 		Counter: counter,
-		RoundTripper: httptransport.FakeTransport{
+		HTTPTransport: httptransport.FakeTransport{
 			Resp: &http.Response{
 				Body: bodyReaderWithEOF{},
 				Header: http.Header{

internal/engine/netx/httptransport/http3transport.go

@@ -1,6 +1,7 @@
 package httptransport
 
 import (
+	"github.com/ooni/probe-cli/v3/internal/model"
 	"github.com/ooni/probe-cli/v3/internal/netxlite"
 )
 
@@ -9,12 +10,11 @@ import (
 // Deprecation warning
 //
 // New code should use netxlite.NewHTTP3Transport instead.
-func NewHTTP3Transport(config Config) RoundTripper {
+func NewHTTP3Transport(config Config) model.HTTPTransport {
 	// Rationale for using NoLogger here: previously this code did
 	// not use a logger as well, so it's fine to keep it as is.
 	return netxlite.NewHTTP3Transport(&NoLogger{},
-		netxlite.NewQUICDialerFromContextDialerAdapter(config.QUICDialer),
-		config.TLSConfig)
+		config.QUICDialer, config.TLSConfig)
 }
 
 type NoLogger struct{}

internal/engine/netx/httptransport/httptransport.go

@@ -2,46 +2,15 @@
 package httptransport
 
 import (
-	"context"
 	"crypto/tls"
-	"net"
-	"net/http"
 
-	"github.com/lucas-clemente/quic-go"
+	"github.com/ooni/probe-cli/v3/internal/model"
 )
 
 // Config contains the configuration required for constructing an HTTP transport
 type Config struct {
-	Dialer     Dialer
-	QUICDialer QUICDialer
-	TLSDialer  TLSDialer
+	Dialer     model.Dialer
+	QUICDialer model.QUICDialer
+	TLSDialer  model.TLSDialer
 	TLSConfig  *tls.Config
 }
-
-// Dialer is the definition of dialer assumed by this package.
-type Dialer interface {
-	DialContext(ctx context.Context, network, address string) (net.Conn, error)
-}
-
-// TLSDialer is the definition of a TLS dialer assumed by this package.
-type TLSDialer interface {
-	DialTLSContext(ctx context.Context, network, address string) (net.Conn, error)
-}
-
-// QUICDialer is the definition of dialer for QUIC assumed by this package.
-type QUICDialer interface {
-	DialContext(ctx context.Context, network, addr string, tlsCfg *tls.Config, cfg *quic.Config) (quic.EarlySession, error)
-}
-
-// RoundTripper is the definition of http.RoundTripper used by this package.
-type RoundTripper interface {
-	RoundTrip(req *http.Request) (*http.Response, error)
-	CloseIdleConnections()
-}
-
-// Resolver is the interface we expect from a resolver
-type Resolver interface {
-	LookupHost(ctx context.Context, hostname string) (addrs []string, err error)
-	Network() string
-	Address() string
-}

internal/engine/netx/httptransport/saver.go

@@ -10,13 +10,14 @@ import (
 	"time"
 
 	"github.com/ooni/probe-cli/v3/internal/engine/netx/trace"
+	"github.com/ooni/probe-cli/v3/internal/model"
 	"github.com/ooni/probe-cli/v3/internal/netxlite"
 )
 
 // SaverPerformanceHTTPTransport is a RoundTripper that saves
 // performance events occurring during the round trip
 type SaverPerformanceHTTPTransport struct {
-	RoundTripper
+	model.HTTPTransport
 	Saver *trace.Saver
 }
 
@@ -38,13 +39,13 @@ func (txp SaverPerformanceHTTPTransport) RoundTrip(req *http.Request) (*http.Res
 		}
 		req = req.WithContext(httptrace.WithClientTrace(req.Context(), tracep))
 	}
-	return txp.RoundTripper.RoundTrip(req)
+	return txp.HTTPTransport.RoundTrip(req)
 }
 
 // SaverMetadataHTTPTransport is a RoundTripper that saves
 // events related to HTTP request and response metadata
 type SaverMetadataHTTPTransport struct {
-	RoundTripper
+	model.HTTPTransport
 	Saver     *trace.Saver
 	Transport string
 }
@@ -59,7 +60,7 @@ func (txp SaverMetadataHTTPTransport) RoundTrip(req *http.Request) (*http.Respon
 		Name:        "http_request_metadata",
 		Time:        time.Now(),
 	})
-	resp, err := txp.RoundTripper.RoundTrip(req)
+	resp, err := txp.HTTPTransport.RoundTrip(req)
 	if err != nil {
 		return nil, err
 	}
@@ -88,7 +89,7 @@ func (txp SaverMetadataHTTPTransport) CloneHeaders(req *http.Request) http.Heade
 // SaverTransactionHTTPTransport is a RoundTripper that saves
 // events related to the HTTP transaction
 type SaverTransactionHTTPTransport struct {
-	RoundTripper
+	model.HTTPTransport
 	Saver *trace.Saver
 }
 
@@ -98,7 +99,7 @@ func (txp SaverTransactionHTTPTransport) RoundTrip(req *http.Request) (*http.Res
 		Name: "http_transaction_start",
 		Time: time.Now(),
 	})
-	resp, err := txp.RoundTripper.RoundTrip(req)
+	resp, err := txp.HTTPTransport.RoundTrip(req)
 	txp.Saver.Write(trace.Event{
 		Err:  err,
 		Name: "http_transaction_done",
@@ -110,7 +111,7 @@ func (txp SaverTransactionHTTPTransport) RoundTrip(req *http.Request) (*http.Res
 // SaverBodyHTTPTransport is a RoundTripper that saves
 // body events occurring during the round trip
 type SaverBodyHTTPTransport struct {
-	RoundTripper
+	model.HTTPTransport
 	Saver        *trace.Saver
 	SnapshotSize int
 }
@@ -135,7 +136,7 @@ func (txp SaverBodyHTTPTransport) RoundTrip(req *http.Request) (*http.Response,
 			Time:            time.Now(),
 		})
 	}
-	resp, err := txp.RoundTripper.RoundTrip(req)
+	resp, err := txp.HTTPTransport.RoundTrip(req)
 	if err != nil {
 		return nil, err
 	}
@@ -184,7 +185,7 @@ type saverReadCloser struct {
 	io.Reader
 }
 
-var _ RoundTripper = SaverPerformanceHTTPTransport{}
-var _ RoundTripper = SaverMetadataHTTPTransport{}
-var _ RoundTripper = SaverBodyHTTPTransport{}
-var _ RoundTripper = SaverTransactionHTTPTransport{}
+var _ model.HTTPTransport = SaverPerformanceHTTPTransport{}
+var _ model.HTTPTransport = SaverMetadataHTTPTransport{}
+var _ model.HTTPTransport = SaverBodyHTTPTransport{}
+var _ model.HTTPTransport = SaverTransactionHTTPTransport{}

internal/engine/netx/httptransport/saver_test.go

@@ -22,12 +22,12 @@ func TestSaverPerformanceNoMultipleEvents(t *testing.T) {
 	saver := &trace.Saver{}
 	// register twice - do we see events twice?
 	txp := httptransport.SaverPerformanceHTTPTransport{
-		RoundTripper: http.DefaultTransport.(*http.Transport),
-		Saver:        saver,
+		HTTPTransport: http.DefaultTransport.(*http.Transport),
+		Saver:         saver,
 	}
 	txp = httptransport.SaverPerformanceHTTPTransport{
-		RoundTripper: txp,
-		Saver:        saver,
+		HTTPTransport: txp,
+		Saver:         saver,
 	}
 	req, err := http.NewRequest("GET", "https://www.google.com", nil)
 	if err != nil {
@@ -67,8 +67,8 @@ func TestSaverMetadataSuccess(t *testing.T) {
 	}
 	saver := &trace.Saver{}
 	txp := httptransport.SaverMetadataHTTPTransport{
-		RoundTripper: http.DefaultTransport.(*http.Transport),
-		Saver:        saver,
+		HTTPTransport: http.DefaultTransport.(*http.Transport),
+		Saver:         saver,
 	}
 	req, err := http.NewRequest("GET", "https://www.google.com", nil)
 	if err != nil {
@@ -121,7 +121,7 @@ func TestSaverMetadataFailure(t *testing.T) {
 	expected := errors.New("mocked error")
 	saver := &trace.Saver{}
 	txp := httptransport.SaverMetadataHTTPTransport{
-		RoundTripper: httptransport.FakeTransport{
+		HTTPTransport: httptransport.FakeTransport{
 			Err: expected,
 		},
 		Saver: saver,
@@ -165,8 +165,8 @@ func TestSaverTransactionSuccess(t *testing.T) {
 	}
 	saver := &trace.Saver{}
 	txp := httptransport.SaverTransactionHTTPTransport{
-		RoundTripper: http.DefaultTransport.(*http.Transport),
-		Saver:        saver,
+		HTTPTransport: http.DefaultTransport.(*http.Transport),
+		Saver:         saver,
 	}
 	req, err := http.NewRequest("GET", "https://www.google.com", nil)
 	if err != nil {
@@ -206,7 +206,7 @@ func TestSaverTransactionFailure(t *testing.T) {
 	expected := errors.New("mocked error")
 	saver := &trace.Saver{}
 	txp := httptransport.SaverTransactionHTTPTransport{
-		RoundTripper: httptransport.FakeTransport{
+		HTTPTransport: httptransport.FakeTransport{
 			Err: expected,
 		},
 		Saver: saver,
@@ -246,7 +246,7 @@ func TestSaverTransactionFailure(t *testing.T) {
 func TestSaverBodySuccess(t *testing.T) {
 	saver := new(trace.Saver)
 	txp := httptransport.SaverBodyHTTPTransport{
-		RoundTripper: httptransport.FakeTransport{
+		HTTPTransport: httptransport.FakeTransport{
 			Func: func(req *http.Request) (*http.Response, error) {
 				data, err := netxlite.ReadAllContext(context.Background(), req.Body)
 				if err != nil {
@@ -317,7 +317,7 @@ func TestSaverBodySuccess(t *testing.T) {
 func TestSaverBodyRequestReadError(t *testing.T) {
 	saver := new(trace.Saver)
 	txp := httptransport.SaverBodyHTTPTransport{
-		RoundTripper: httptransport.FakeTransport{
+		HTTPTransport: httptransport.FakeTransport{
 			Func: func(req *http.Request) (*http.Response, error) {
 				panic("should not be called")
 			},
@@ -348,7 +348,7 @@ func TestSaverBodyRoundTripError(t *testing.T) {
 	saver := new(trace.Saver)
 	expected := errors.New("mocked error")
 	txp := httptransport.SaverBodyHTTPTransport{
-		RoundTripper: httptransport.FakeTransport{
+		HTTPTransport: httptransport.FakeTransport{
 			Err: expected,
 		},
 		SnapshotSize: 4,
@@ -388,7 +388,7 @@ func TestSaverBodyResponseReadError(t *testing.T) {
 	saver := new(trace.Saver)
 	expected := errors.New("mocked error")
 	txp := httptransport.SaverBodyHTTPTransport{
-		RoundTripper: httptransport.FakeTransport{
+		HTTPTransport: httptransport.FakeTransport{
 			Func: func(req *http.Request) (*http.Response, error) {
 				return &http.Response{
 					StatusCode: 200,

internal/engine/netx/httptransport/system.go

@@ -2,6 +2,8 @@ package httptransport
 
 import (
 	"net/http"
+
+	"github.com/ooni/probe-cli/v3/internal/model"
 )
 
 // NewSystemTransport creates a new "system" HTTP transport. That is a transport
@@ -10,7 +12,7 @@ import (
 // Deprecation warning
 //
 // New code should use netxlite.NewHTTPTransport instead.
-func NewSystemTransport(config Config) RoundTripper {
+func NewSystemTransport(config Config) model.HTTPTransport {
 	txp := http.DefaultTransport.(*http.Transport).Clone()
 	txp.DialContext = config.Dialer.DialContext
 	txp.DialTLSContext = config.TLSDialer.DialTLSContext
@@ -25,4 +27,4 @@ func NewSystemTransport(config Config) RoundTripper {
 	return txp
 }
 
-var _ RoundTripper = &http.Transport{}
+var _ model.HTTPTransport = &http.Transport{}

internal/engine/netx/netx.go

@@ -30,7 +30,6 @@ import (
 	"net/http"
 	"net/url"
 
-	"github.com/lucas-clemente/quic-go"
 	"github.com/ooni/probe-cli/v3/internal/bytecounter"
 	"github.com/ooni/probe-cli/v3/internal/engine/netx/dialer"
 	"github.com/ooni/probe-cli/v3/internal/engine/netx/httptransport"
@@ -42,41 +41,13 @@ import (
 	"github.com/ooni/probe-cli/v3/internal/netxlite"
 )
 
-// Dialer is the definition of dialer assumed by this package.
-type Dialer interface {
-	DialContext(ctx context.Context, network, address string) (net.Conn, error)
-}
-
-// QUICDialer is the definition of a dialer for QUIC assumed by this package.
-type QUICDialer interface {
-	DialContext(ctx context.Context, network, addr string, tlsCfg *tls.Config, cfg *quic.Config) (quic.EarlySession, error)
-}
-
-// TLSDialer is the definition of a TLS dialer assumed by this package.
-type TLSDialer interface {
-	DialTLSContext(ctx context.Context, network, address string) (net.Conn, error)
-}
-
-// HTTPRoundTripper is the definition of http.HTTPRoundTripper used by this package.
-type HTTPRoundTripper interface {
-	RoundTrip(req *http.Request) (*http.Response, error)
-	CloseIdleConnections()
-}
-
-// Resolver is the interface we expect from a resolver
-type Resolver interface {
-	LookupHost(ctx context.Context, hostname string) (addrs []string, err error)
-	Network() string
-	Address() string
-}
-
 // Config contains configuration for creating a new transport. When any
 // field of Config is nil/empty, we will use a suitable default.
 //
 // We use different savers for different kind of events such that the
 // user of this library can choose what to save.
 type Config struct {
-	BaseResolver        Resolver             // default: system resolver
+	BaseResolver        model.Resolver       // default: system resolver
 	BogonIsError        bool                 // default: bogon is not error
 	ByteCounter         *bytecounter.Counter // default: no explicit byte counting
 	CacheResolutions    bool                 // default: no caching
@@ -84,9 +55,9 @@ type Config struct {
 	ContextByteCounting bool                 // default: no implicit byte counting
 	DNSCache            map[string][]string  // default: cache is empty
 	DialSaver           *trace.Saver         // default: not saving dials
-	Dialer              Dialer               // default: dialer.DNSDialer
-	FullResolver        Resolver             // default: base resolver + goodies
-	QUICDialer          QUICDialer           // default: quicdialer.DNSDialer
+	Dialer              model.Dialer         // default: dialer.DNSDialer
+	FullResolver        model.Resolver       // default: base resolver + goodies
+	QUICDialer          model.QUICDialer     // default: quicdialer.DNSDialer
 	HTTP3Enabled        bool                 // default: disabled
 	HTTPSaver           *trace.Saver         // default: not saving HTTP
 	Logger              model.DebugLogger    // default: no logging
@@ -95,7 +66,7 @@ type Config struct {
 	ReadWriteSaver      *trace.Saver         // default: not saving read/write
 	ResolveSaver        *trace.Saver         // default: not saving resolves
 	TLSConfig           *tls.Config          // default: attempt using h2
-	TLSDialer           TLSDialer            // default: dialer.TLSDialer
+	TLSDialer           model.TLSDialer      // default: dialer.TLSDialer
 	TLSSaver            *trace.Saver         // default: not saving TLS
 }
 
@@ -107,13 +78,13 @@ type tlsHandshaker interface {
 var defaultCertPool *x509.CertPool = netxlite.NewDefaultCertPool()
 
 // NewResolver creates a new resolver from the specified config
-func NewResolver(config Config) Resolver {
+func NewResolver(config Config) model.Resolver {
 	if config.BaseResolver == nil {
 		config.BaseResolver = &netxlite.ResolverSystem{}
 	}
-	var r Resolver = config.BaseResolver
-	r = &resolver.AddressResolver{
-		Resolver: netxlite.NewResolverLegacyAdapter(r),
+	var r model.Resolver = config.BaseResolver
+	r = &netxlite.AddressResolver{
+		Resolver: r,
 	}
 	if config.CacheResolutions {
 		r = &resolver.CacheResolver{Resolver: r}
@@ -128,21 +99,21 @@ func NewResolver(config Config) Resolver {
 	if config.BogonIsError {
 		r = resolver.BogonResolver{Resolver: r}
 	}
-	r = &netxlite.ErrorWrapperResolver{Resolver: netxlite.NewResolverLegacyAdapter(r)}
+	r = &netxlite.ErrorWrapperResolver{Resolver: r}
 	if config.Logger != nil {
 		r = &netxlite.ResolverLogger{
 			Logger:   config.Logger,
-			Resolver: netxlite.NewResolverLegacyAdapter(r),
+			Resolver: r,
 		}
 	}
 	if config.ResolveSaver != nil {
 		r = resolver.SaverResolver{Resolver: r, Saver: config.ResolveSaver}
 	}
-	return &resolver.IDNAResolver{Resolver: netxlite.NewResolverLegacyAdapter(r)}
+	return &netxlite.ResolverIDNA{Resolver: r}
 }
 
 // NewDialer creates a new Dialer from the specified config
-func NewDialer(config Config) Dialer {
+func NewDialer(config Config) model.Dialer {
 	if config.FullResolver == nil {
 		config.FullResolver = NewResolver(config)
 	}
@@ -156,11 +127,11 @@ func NewDialer(config Config) Dialer {
 }
 
 // NewQUICDialer creates a new DNS Dialer for QUIC, with the resolver from the specified config
-func NewQUICDialer(config Config) QUICDialer {
+func NewQUICDialer(config Config) model.QUICDialer {
 	if config.FullResolver == nil {
 		config.FullResolver = NewResolver(config)
 	}
-	var ql quicdialer.QUICListener = &netxlite.QUICListenerStdlib{}
+	var ql model.QUICListener = &netxlite.QUICListenerStdlib{}
 	ql = &netxlite.ErrorWrapperQUICListener{QUICListener: ql}
 	if config.ReadWriteSaver != nil {
 		ql = &quicdialer.QUICListenerSaver{
@@ -168,24 +139,24 @@ func NewQUICDialer(config Config) QUICDialer {
 			Saver:        config.ReadWriteSaver,
 		}
 	}
-	var d quicdialer.ContextDialer = &netxlite.QUICDialerQUICGo{
+	var d model.QUICDialer = &netxlite.QUICDialerQUICGo{
 		QUICListener: ql,
 	}
 	d = &netxlite.ErrorWrapperQUICDialer{
-		QUICDialer: netxlite.NewQUICDialerFromContextDialerAdapter(d),
+		QUICDialer: d,
 	}
 	if config.TLSSaver != nil {
-		d = quicdialer.HandshakeSaver{Saver: config.TLSSaver, Dialer: d}
+		d = quicdialer.HandshakeSaver{Saver: config.TLSSaver, QUICDialer: d}
 	}
 	d = &netxlite.QUICDialerResolver{
-		Resolver: netxlite.NewResolverLegacyAdapter(config.FullResolver),
-		Dialer:   netxlite.NewQUICDialerFromContextDialerAdapter(d),
+		Resolver: config.FullResolver,
+		Dialer:   d,
 	}
 	return d
 }
 
 // NewTLSDialer creates a new TLSDialer from the specified config
-func NewTLSDialer(config Config) TLSDialer {
+func NewTLSDialer(config Config) model.TLSDialer {
 	if config.Dialer == nil {
 		config.Dialer = NewDialer(config)
 	}
@@ -207,14 +178,14 @@ func NewTLSDialer(config Config) TLSDialer {
 	config.TLSConfig.InsecureSkipVerify = config.NoTLSVerify
 	return &netxlite.TLSDialerLegacy{
 		Config:        config.TLSConfig,
-		Dialer:        netxlite.NewDialerLegacyAdapter(config.Dialer),
+		Dialer:        config.Dialer,
 		TLSHandshaker: h,
 	}
 }
 
 // NewHTTPTransport creates a new HTTPRoundTripper. You can further extend the returned
 // HTTPRoundTripper before wrapping it into an http.Client.
-func NewHTTPTransport(config Config) HTTPRoundTripper {
+func NewHTTPTransport(config Config) model.HTTPTransport {
 	if config.Dialer == nil {
 		config.Dialer = NewDialer(config)
 	}
@@ -233,27 +204,27 @@ func NewHTTPTransport(config Config) HTTPRoundTripper {
 
 	if config.ByteCounter != nil {
 		txp = httptransport.ByteCountingTransport{
-			Counter: config.ByteCounter, RoundTripper: txp}
+			Counter: config.ByteCounter, HTTPTransport: txp}
 	}
 	if config.Logger != nil {
 		txp = &netxlite.HTTPTransportLogger{Logger: config.Logger, HTTPTransport: txp}
 	}
 	if config.HTTPSaver != nil {
 		txp = httptransport.SaverMetadataHTTPTransport{
-			RoundTripper: txp, Saver: config.HTTPSaver, Transport: transport}
+			HTTPTransport: txp, Saver: config.HTTPSaver, Transport: transport}
 		txp = httptransport.SaverBodyHTTPTransport{
-			RoundTripper: txp, Saver: config.HTTPSaver}
+			HTTPTransport: txp, Saver: config.HTTPSaver}
 		txp = httptransport.SaverPerformanceHTTPTransport{
-			RoundTripper: txp, Saver: config.HTTPSaver}
+			HTTPTransport: txp, Saver: config.HTTPSaver}
 		txp = httptransport.SaverTransactionHTTPTransport{
-			RoundTripper: txp, Saver: config.HTTPSaver}
+			HTTPTransport: txp, Saver: config.HTTPSaver}
 	}
 	return txp
 }
 
 // httpTransportInfo contains the constructing function as well as the transport name
 type httpTransportInfo struct {
-	Factory       func(httptransport.Config) httptransport.RoundTripper
+	Factory       func(httptransport.Config) model.HTTPTransport
 	TransportName string
 }
 
@@ -271,7 +242,7 @@ var allTransportsInfo = map[bool]httpTransportInfo{
 // DNSClient is a DNS client. It wraps a Resolver and it possibly
 // also wraps an HTTP client, but only when we're using DoH.
 type DNSClient struct {
-	Resolver
+	model.Resolver
 	httpClient *http.Client
 }
 
@@ -351,7 +322,7 @@ func NewDNSClientWithOverrides(config Config, URL, hostOverride, SNIOverride,
 			return c, err
 		}
 		var txp resolver.RoundTripper = resolver.NewDNSOverUDP(
-			netxlite.NewDialerLegacyAdapter(dialer), endpoint)
+			dialer, endpoint)
 		if config.ResolveSaver != nil {
 			txp = resolver.SaverDNSTransport{
 				RoundTripper: txp,

internal/engine/netx/netx_test.go

@@ -22,27 +22,19 @@ import (
 
 func TestNewResolverVanilla(t *testing.T) {
 	r := netx.NewResolver(netx.Config{})
-	ir, ok := r.(*resolver.IDNAResolver)
+	ir, ok := r.(*netxlite.ResolverIDNA)
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
-	rla, ok := ir.Resolver.(*netxlite.ResolverLegacyAdapter)
+	ewr, ok := ir.Resolver.(*netxlite.ErrorWrapperResolver)
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
-	ewr, ok := rla.ResolverLegacy.(*netxlite.ErrorWrapperResolver)
+	ar, ok := ewr.Resolver.(*netxlite.AddressResolver)
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
-	ar, ok := ewr.Resolver.(*netxlite.ResolverLegacyAdapter).ResolverLegacy.(*resolver.AddressResolver)
-	if !ok {
-		t.Fatal("not the resolver we expected")
-	}
-	arw, ok := ar.Resolver.(*netxlite.ResolverLegacyAdapter)
-	if !ok {
-		t.Fatal("not the resolver we expected")
-	}
-	_, ok = arw.ResolverLegacy.(*netxlite.ResolverSystem)
+	_, ok = ar.Resolver.(*netxlite.ResolverSystem)
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
@@ -54,27 +46,19 @@ func TestNewResolverSpecificResolver(t *testing.T) {
 			// not initialized because it doesn't matter in this context
 		},
 	})
-	ir, ok := r.(*resolver.IDNAResolver)
+	ir, ok := r.(*netxlite.ResolverIDNA)
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
-	rla, ok := ir.Resolver.(*netxlite.ResolverLegacyAdapter)
+	ewr, ok := ir.Resolver.(*netxlite.ErrorWrapperResolver)
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
-	ewr, ok := rla.ResolverLegacy.(*netxlite.ErrorWrapperResolver)
+	ar, ok := ewr.Resolver.(*netxlite.AddressResolver)
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
-	ar, ok := ewr.Resolver.(*netxlite.ResolverLegacyAdapter).ResolverLegacy.(*resolver.AddressResolver)
-	if !ok {
-		t.Fatal("not the resolver we expected")
-	}
-	arw, ok := ar.Resolver.(*netxlite.ResolverLegacyAdapter)
-	if !ok {
-		t.Fatal("not the resolver we expected")
-	}
-	_, ok = arw.ResolverLegacy.(resolver.BogonResolver)
+	_, ok = ar.Resolver.(resolver.BogonResolver)
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
@@ -84,31 +68,23 @@ func TestNewResolverWithBogonFilter(t *testing.T) {
 	r := netx.NewResolver(netx.Config{
 		BogonIsError: true,
 	})
-	ir, ok := r.(*resolver.IDNAResolver)
+	ir, ok := r.(*netxlite.ResolverIDNA)
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
-	rla, ok := ir.Resolver.(*netxlite.ResolverLegacyAdapter)
+	ewr, ok := ir.Resolver.(*netxlite.ErrorWrapperResolver)
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
-	ewr, ok := rla.ResolverLegacy.(*netxlite.ErrorWrapperResolver)
+	br, ok := ewr.Resolver.(resolver.BogonResolver)
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
-	br, ok := ewr.Resolver.(*netxlite.ResolverLegacyAdapter).ResolverLegacy.(resolver.BogonResolver)
+	ar, ok := br.Resolver.(*netxlite.AddressResolver)
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
-	ar, ok := br.Resolver.(*resolver.AddressResolver)
-	if !ok {
-		t.Fatal("not the resolver we expected")
-	}
-	arw, ok := ar.Resolver.(*netxlite.ResolverLegacyAdapter)
-	if !ok {
-		t.Fatal("not the resolver we expected")
-	}
-	_, ok = arw.ResolverLegacy.(*netxlite.ResolverSystem)
+	_, ok = ar.Resolver.(*netxlite.ResolverSystem)
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
@@ -118,46 +94,26 @@ func TestNewResolverWithLogging(t *testing.T) {
 	r := netx.NewResolver(netx.Config{
 		Logger: log.Log,
 	})
-	ir, ok := r.(*resolver.IDNAResolver)
+	ir, ok := r.(*netxlite.ResolverIDNA)
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
-	rla, ok := ir.Resolver.(*netxlite.ResolverLegacyAdapter)
-	if !ok {
-		t.Fatal("not the resolver we expected")
-	}
-	lr, ok := rla.ResolverLegacy.(*netxlite.ResolverLogger)
+	lr, ok := ir.Resolver.(*netxlite.ResolverLogger)
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
 	if lr.Logger != log.Log {
 		t.Fatal("not the logger we expected")
 	}
-	rla, ok = ir.Resolver.(*netxlite.ResolverLegacyAdapter)
+	ewr, ok := lr.Resolver.(*netxlite.ErrorWrapperResolver)
+	if !ok {
+		t.Fatalf("not the resolver we expected")
+	}
+	ar, ok := ewr.Resolver.(*netxlite.AddressResolver)
 	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.(*netxlite.ErrorWrapperResolver)
-	if !ok {
-		t.Fatalf("not the resolver we expected %T", rla.ResolverLegacy)
-	}
-	ar, ok := ewr.Resolver.(*netxlite.ResolverLegacyAdapter).ResolverLegacy.(*resolver.AddressResolver)
-	if !ok {
-		t.Fatal("not the resolver we expected")
-	}
-	arw, ok := ar.Resolver.(*netxlite.ResolverLegacyAdapter)
-	if !ok {
-		t.Fatal("not the resolver we expected")
-	}
-	_, ok = arw.ResolverLegacy.(*netxlite.ResolverSystem)
+	_, ok = ar.Resolver.(*netxlite.ResolverSystem)
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
@@ -168,15 +124,11 @@ func TestNewResolverWithSaver(t *testing.T) {
 	r := netx.NewResolver(netx.Config{
 		ResolveSaver: saver,
 	})
-	ir, ok := r.(*resolver.IDNAResolver)
+	ir, ok := r.(*netxlite.ResolverIDNA)
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
-	rla, ok := ir.Resolver.(*netxlite.ResolverLegacyAdapter)
-	if !ok {
-		t.Fatal("not the resolver we expected")
-	}
-	sr, ok := rla.ResolverLegacy.(resolver.SaverResolver)
+	sr, ok := ir.Resolver.(resolver.SaverResolver)
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
@@ -187,15 +139,11 @@ func TestNewResolverWithSaver(t *testing.T) {
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
-	ar, ok := ewr.Resolver.(*netxlite.ResolverLegacyAdapter).ResolverLegacy.(*resolver.AddressResolver)
+	ar, ok := ewr.Resolver.(*netxlite.AddressResolver)
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
-	arw, ok := ar.Resolver.(*netxlite.ResolverLegacyAdapter)
-	if !ok {
-		t.Fatal("not the resolver we expected")
-	}
-	_, ok = arw.ResolverLegacy.(*netxlite.ResolverSystem)
+	_, ok = ar.Resolver.(*netxlite.ResolverSystem)
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
@@ -205,34 +153,26 @@ func TestNewResolverWithReadWriteCache(t *testing.T) {
 	r := netx.NewResolver(netx.Config{
 		CacheResolutions: true,
 	})
-	ir, ok := r.(*resolver.IDNAResolver)
+	ir, ok := r.(*netxlite.ResolverIDNA)
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
-	rla, ok := ir.Resolver.(*netxlite.ResolverLegacyAdapter)
+	ewr, ok := ir.Resolver.(*netxlite.ErrorWrapperResolver)
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
-	ewr, ok := rla.ResolverLegacy.(*netxlite.ErrorWrapperResolver)
-	if !ok {
-		t.Fatal("not the resolver we expected")
-	}
-	cr, ok := ewr.Resolver.(*netxlite.ResolverLegacyAdapter).ResolverLegacy.(*resolver.CacheResolver)
+	cr, ok := ewr.Resolver.(*resolver.CacheResolver)
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
 	if cr.ReadOnly != false {
 		t.Fatal("expected readwrite cache here")
 	}
-	ar, ok := cr.Resolver.(*resolver.AddressResolver)
+	ar, ok := cr.Resolver.(*netxlite.AddressResolver)
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
-	arw, ok := ar.Resolver.(*netxlite.ResolverLegacyAdapter)
-	if !ok {
-		t.Fatal("not the resolver we expected")
-	}
-	_, ok = arw.ResolverLegacy.(*netxlite.ResolverSystem)
+	_, ok = ar.Resolver.(*netxlite.ResolverSystem)
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
@@ -244,19 +184,15 @@ func TestNewResolverWithPrefilledReadonlyCache(t *testing.T) {
 			"dns.google.com": {"8.8.8.8"},
 		},
 	})
-	ir, ok := r.(*resolver.IDNAResolver)
+	ir, ok := r.(*netxlite.ResolverIDNA)
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
-	rla, ok := ir.Resolver.(*netxlite.ResolverLegacyAdapter)
+	ewr, ok := ir.Resolver.(*netxlite.ErrorWrapperResolver)
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
-	ewr, ok := rla.ResolverLegacy.(*netxlite.ErrorWrapperResolver)
-	if !ok {
-		t.Fatal("not the resolver we expected")
-	}
-	cr, ok := ewr.Resolver.(*netxlite.ResolverLegacyAdapter).ResolverLegacy.(*resolver.CacheResolver)
+	cr, ok := ewr.Resolver.(*resolver.CacheResolver)
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
@@ -266,15 +202,11 @@ func TestNewResolverWithPrefilledReadonlyCache(t *testing.T) {
 	if cr.Get("dns.google.com")[0] != "8.8.8.8" {
 		t.Fatal("cache not correctly prefilled")
 	}
-	ar, ok := cr.Resolver.(*resolver.AddressResolver)
+	ar, ok := cr.Resolver.(*netxlite.AddressResolver)
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
-	arw, ok := ar.Resolver.(*netxlite.ResolverLegacyAdapter)
-	if !ok {
-		t.Fatal("not the resolver we expected")
-	}
-	_, ok = arw.ResolverLegacy.(*netxlite.ResolverSystem)
+	_, ok = ar.Resolver.(*netxlite.ResolverSystem)
 	if !ok {
 		t.Fatal("not the resolver we expected")
 	}
@@ -548,7 +480,7 @@ func TestNewWithByteCounter(t *testing.T) {
 	if bctxp.Counter != counter {
 		t.Fatal("not the byte counter we expected")
 	}
-	if _, ok := bctxp.RoundTripper.(*http.Transport); !ok {
+	if _, ok := bctxp.HTTPTransport.(*http.Transport); !ok {
 		t.Fatal("not the transport we expected")
 	}
 }
@@ -581,28 +513,28 @@ func TestNewWithSaver(t *testing.T) {
 	if stxptxp.Saver != saver {
 		t.Fatal("not the logger we expected")
 	}
-	sptxp, ok := stxptxp.RoundTripper.(httptransport.SaverPerformanceHTTPTransport)
+	sptxp, ok := stxptxp.HTTPTransport.(httptransport.SaverPerformanceHTTPTransport)
 	if !ok {
 		t.Fatal("not the transport we expected")
 	}
 	if sptxp.Saver != saver {
 		t.Fatal("not the logger we expected")
 	}
-	sbtxp, ok := sptxp.RoundTripper.(httptransport.SaverBodyHTTPTransport)
+	sbtxp, ok := sptxp.HTTPTransport.(httptransport.SaverBodyHTTPTransport)
 	if !ok {
 		t.Fatal("not the transport we expected")
 	}
 	if sbtxp.Saver != saver {
 		t.Fatal("not the logger we expected")
 	}
-	smtxp, ok := sbtxp.RoundTripper.(httptransport.SaverMetadataHTTPTransport)
+	smtxp, ok := sbtxp.HTTPTransport.(httptransport.SaverMetadataHTTPTransport)
 	if !ok {
 		t.Fatal("not the transport we expected")
 	}
 	if smtxp.Saver != saver {
 		t.Fatal("not the logger we expected")
 	}
-	if _, ok := smtxp.RoundTripper.(*http.Transport); !ok {
+	if _, ok := smtxp.HTTPTransport.(*http.Transport); !ok {
 		t.Fatal("not the transport we expected")
 	}
 }

internal/engine/netx/quicdialer/quicdialer.go

@@ -1,20 +0,0 @@
-package quicdialer
-
-import (
-	"context"
-	"crypto/tls"
-
-	"github.com/lucas-clemente/quic-go"
-)
-
-// ContextDialer is a dialer for QUIC using Context.
-type ContextDialer interface {
-	// Note: assumes that tlsCfg and cfg are not nil.
-	DialContext(ctx context.Context, network, host string,
-		tlsCfg *tls.Config, cfg *quic.Config) (quic.EarlySession, error)
-}
-
-// Resolver is the interface we expect from a resolver.
-type Resolver interface {
-	LookupHost(ctx context.Context, hostname string) (addrs []string, err error)
-}

internal/engine/netx/quicdialer/saver.go

@@ -7,13 +7,14 @@ import (
 
 	"github.com/lucas-clemente/quic-go"
 	"github.com/ooni/probe-cli/v3/internal/engine/netx/trace"
+	"github.com/ooni/probe-cli/v3/internal/model"
 	"github.com/ooni/probe-cli/v3/internal/netxlite"
 )
 
 // HandshakeSaver saves events occurring during the handshake
 type HandshakeSaver struct {
-	Saver  *trace.Saver
-	Dialer ContextDialer
+	Saver *trace.Saver
+	model.QUICDialer
 }
 
 // DialContext implements ContextDialer.DialContext
@@ -31,7 +32,7 @@ func (h HandshakeSaver) DialContext(ctx context.Context, network string,
 		TLSServerName: tlsCfg.ServerName,
 		Time:          start,
 	})
-	sess, err := h.Dialer.DialContext(ctx, network, host, tlsCfg, cfg)
+	sess, err := h.QUICDialer.DialContext(ctx, network, host, tlsCfg, cfg)
 	stop := time.Now()
 	if err != nil {
 		h.Saver.Write(trace.Event{

internal/engine/netx/quicdialer/saver_test.go

@@ -11,12 +11,13 @@ import (
 	"github.com/lucas-clemente/quic-go"
 	"github.com/ooni/probe-cli/v3/internal/engine/netx/quicdialer"
 	"github.com/ooni/probe-cli/v3/internal/engine/netx/trace"
+	"github.com/ooni/probe-cli/v3/internal/model"
 	"github.com/ooni/probe-cli/v3/internal/netxlite"
 	"github.com/ooni/probe-cli/v3/internal/netxlite/quictesting"
 )
 
 type MockDialer struct {
-	Dialer quicdialer.ContextDialer
+	Dialer model.QUICDialer
 	Sess   quic.EarlySession
 	Err    error
 }
@@ -38,7 +39,7 @@ func TestHandshakeSaverSuccess(t *testing.T) {
 	}
 	saver := &trace.Saver{}
 	dlr := quicdialer.HandshakeSaver{
-		Dialer: &netxlite.QUICDialerQUICGo{
+		QUICDialer: &netxlite.QUICDialerQUICGo{
 			QUICListener: &netxlite.QUICListenerStdlib{},
 		},
 		Saver: saver,
@@ -96,7 +97,7 @@ func TestHandshakeSaverHostNameError(t *testing.T) {
 	}
 	saver := &trace.Saver{}
 	dlr := quicdialer.HandshakeSaver{
-		Dialer: &netxlite.QUICDialerQUICGo{
+		QUICDialer: &netxlite.QUICDialerQUICGo{
 			QUICListener: &netxlite.QUICListenerStdlib{},
 		},
 		Saver: saver,

internal/engine/netx/quicdialer/system.go

@@ -9,16 +9,10 @@ import (
 	"github.com/ooni/probe-cli/v3/internal/netxlite"
 )
 
-// QUICListener listens for QUIC connections.
-type QUICListener interface {
-	// Listen creates a new listening UDPConn.
-	Listen(addr *net.UDPAddr) (model.UDPLikeConn, error)
-}
-
 // QUICListenerSaver is a QUICListener that also implements saving events.
 type QUICListenerSaver struct {
 	// QUICListener is the underlying QUICListener.
-	QUICListener QUICListener
+	model.QUICListener
 
 	// Saver is the underlying Saver.
 	Saver *trace.Saver

internal/engine/netx/resolver/address.go

@@ -1,9 +0,0 @@
-package resolver
-
-import (
-	"github.com/ooni/probe-cli/v3/internal/netxlite"
-)
-
-// AddressResolver is a resolver that knows how to correctly
-// resolve IP addresses to themselves.
-type AddressResolver = netxlite.AddressResolver

internal/engine/netx/resolver/bogon.go

@@ -3,6 +3,7 @@ package resolver
 import (
 	"context"
 
+	"github.com/ooni/probe-cli/v3/internal/model"
 	"github.com/ooni/probe-cli/v3/internal/netxlite"
 )
 
@@ -14,7 +15,7 @@ import (
 // This resolver is deprecated. The right thing to do would be to check
 // for bogons right after a domain name resolution in the nettest.
 type BogonResolver struct {
-	Resolver
+	model.Resolver
 }
 
 // LookupHost implements Resolver.LookupHost
@@ -28,4 +29,4 @@ func (r BogonResolver) LookupHost(ctx context.Context, hostname string) ([]strin
 	return addrs, err
 }
 
-var _ Resolver = BogonResolver{}
+var _ model.Resolver = BogonResolver{}

internal/engine/netx/resolver/cache.go

@@ -3,12 +3,14 @@ package resolver
 import (
 	"context"
 	"sync"
+
+	"github.com/ooni/probe-cli/v3/internal/model"
 )
 
 // CacheResolver is a resolver that caches successful replies.
 type CacheResolver struct {
 	ReadOnly bool
-	Resolver
+	model.Resolver
 	mu    sync.Mutex
 	cache map[string][]string
 }

internal/engine/netx/resolver/cache_test.go

@@ -6,11 +6,12 @@ import (
 	"testing"
 
 	"github.com/ooni/probe-cli/v3/internal/engine/netx/resolver"
+	"github.com/ooni/probe-cli/v3/internal/model"
 )
 
 func TestCacheFailure(t *testing.T) {
 	expected := errors.New("mocked error")
-	var r resolver.Resolver = resolver.FakeResolver{
+	var r model.Resolver = resolver.FakeResolver{
 		Err: expected,
 	}
 	cache := &resolver.CacheResolver{Resolver: r}
@@ -27,7 +28,7 @@ func TestCacheFailure(t *testing.T) {
 }
 
 func TestCacheHitSuccess(t *testing.T) {
-	var r resolver.Resolver = resolver.FakeResolver{
+	var r model.Resolver = resolver.FakeResolver{
 		Err: errors.New("mocked error"),
 	}
 	cache := &resolver.CacheResolver{Resolver: r}
@@ -42,7 +43,7 @@ func TestCacheHitSuccess(t *testing.T) {
 }
 
 func TestCacheMissSuccess(t *testing.T) {
-	var r resolver.Resolver = resolver.FakeResolver{
+	var r model.Resolver = resolver.FakeResolver{
 		Result: []string{"8.8.8.8"},
 	}
 	cache := &resolver.CacheResolver{Resolver: r}
@@ -59,7 +60,7 @@ func TestCacheMissSuccess(t *testing.T) {
 }
 
 func TestCacheReadonlySuccess(t *testing.T) {
-	var r resolver.Resolver = resolver.FakeResolver{
+	var r model.Resolver = resolver.FakeResolver{
 		Result: []string{"8.8.8.8"},
 	}
 	cache := &resolver.CacheResolver{Resolver: r, ReadOnly: true}

internal/engine/netx/resolver/chain.go

@@ -2,13 +2,15 @@ package resolver
 
 import (
 	"context"
+
+	"github.com/ooni/probe-cli/v3/internal/model"
 )
 
 // ChainResolver is a chain resolver. The primary resolver is used first and, if that
 // fails, we then attempt with the secondary resolver.
 type ChainResolver struct {
-	Primary   Resolver
-	Secondary Resolver
+	Primary   model.Resolver
+	Secondary model.Resolver
 }
 
 // LookupHost implements Resolver.LookupHost
@@ -30,4 +32,20 @@ func (c ChainResolver) Address() string {
 	return ""
 }
 
-var _ Resolver = ChainResolver{}
+// CloseIdleConnections implements Resolver.CloseIdleConnections.
+func (c ChainResolver) CloseIdleConnections() {
+	c.Primary.CloseIdleConnections()
+	c.Secondary.CloseIdleConnections()
+}
+
+// LookupHTTPS implements Resolver.LookupHTTPS
+func (c ChainResolver) LookupHTTPS(
+	ctx context.Context, domain string) (*model.HTTPSSvc, error) {
+	https, err := c.Primary.LookupHTTPS(ctx, domain)
+	if err != nil {
+		https, err = c.Secondary.LookupHTTPS(ctx, domain)
+	}
+	return https, err
+}
+
+var _ model.Resolver = ChainResolver{}

internal/engine/netx/resolver/fake_test.go

@@ -2,11 +2,13 @@ package resolver
 
 import (
 	"context"
+	"errors"
 	"io"
 	"net"
 	"time"
 
 	"github.com/ooni/probe-cli/v3/internal/atomicx"
+	"github.com/ooni/probe-cli/v3/internal/model"
 )
 
 type FakeDialer struct {
@@ -143,4 +145,11 @@ func (c FakeResolver) Address() string {
 	return ""
 }
 
-var _ Resolver = FakeResolver{}
+func (c FakeResolver) CloseIdleConnections() {}
+
+func (c FakeResolver) LookupHTTPS(
+	ctx context.Context, domain string) (*model.HTTPSSvc, error) {
+	return nil, errors.New("not implemented")
+}
+
+var _ model.Resolver = FakeResolver{}

internal/engine/netx/resolver/idna.go

@@ -1,11 +0,0 @@
-package resolver
-
-import (
-	"github.com/ooni/probe-cli/v3/internal/netxlite"
-)
-
-// IDNAResolver is to support resolving Internationalized Domain Names.
-// See RFC3492 for more information.
-type IDNAResolver = netxlite.ResolverIDNA
-
-var _ Resolver = &IDNAResolver{}

internal/engine/netx/resolver/integration_test.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/apex/log"
 	"github.com/ooni/probe-cli/v3/internal/engine/netx/resolver"
+	"github.com/ooni/probe-cli/v3/internal/model"
 	"github.com/ooni/probe-cli/v3/internal/netxlite"
 )
 
@@ -15,13 +16,13 @@ func init() {
 	log.SetLevel(log.DebugLevel)
 }
 
-func testresolverquick(t *testing.T, reso resolver.Resolver) {
+func testresolverquick(t *testing.T, reso model.Resolver) {
 	if testing.Short() {
 		t.Skip("skip test in short mode")
 	}
 	reso = &netxlite.ResolverLogger{
 		Logger:   log.Log,
-		Resolver: netxlite.NewResolverLegacyAdapter(reso),
+		Resolver: reso,
 	}
 	addrs, err := reso.LookupHost(context.Background(), "dns.google.com")
 	if err != nil {
@@ -43,14 +44,14 @@ func testresolverquick(t *testing.T, reso resolver.Resolver) {
 }
 
 // Ensuring we can handle Internationalized Domain Names (IDNs) without issues
-func testresolverquickidna(t *testing.T, reso resolver.Resolver) {
+func testresolverquickidna(t *testing.T, reso model.Resolver) {
 	if testing.Short() {
 		t.Skip("skip test in short mode")
 	}
-	reso = &resolver.IDNAResolver{
+	reso = &netxlite.ResolverIDNA{
 		Resolver: &netxlite.ResolverLogger{
 			Logger:   log.Log,
-			Resolver: netxlite.NewResolverLegacyAdapter(reso),
+			Resolver: reso,
 		},
 	}
 	addrs, err := reso.LookupHost(context.Background(), "яндекс.рф")
@@ -70,14 +71,14 @@ func TestNewResolverSystem(t *testing.T) {
 
 func TestNewResolverUDPAddress(t *testing.T) {
 	reso := resolver.NewSerialResolver(
-		resolver.NewDNSOverUDP(netxlite.NewDialerLegacyAdapter(&net.Dialer{}), "8.8.8.8:53"))
+		resolver.NewDNSOverUDP(netxlite.DefaultDialer, "8.8.8.8:53"))
 	testresolverquick(t, reso)
 	testresolverquickidna(t, reso)
 }
 
 func TestNewResolverUDPDomain(t *testing.T) {
 	reso := resolver.NewSerialResolver(
-		resolver.NewDNSOverUDP(netxlite.NewDialerLegacyAdapter(&net.Dialer{}), "dns.google.com:53"))
+		resolver.NewDNSOverUDP(netxlite.DefaultDialer, "dns.google.com:53"))
 	testresolverquick(t, reso)
 	testresolverquickidna(t, reso)
 }

internal/engine/netx/resolver/resolver.go

@@ -1,18 +0,0 @@
-package resolver
-
-import (
-	"context"
-)
-
-// Resolver is a DNS resolver. The *net.Resolver used by Go implements
-// this interface, but other implementations are possible.
-type Resolver interface {
-	// LookupHost resolves a hostname to a list of IP addresses.
-	LookupHost(ctx context.Context, hostname string) (addrs []string, err error)
-
-	// Network returns the network being used by the resolver
-	Network() string
-
-	// Address returns the address being used by the resolver
-	Address() string
-}

internal/engine/netx/resolver/saver.go

@@ -5,11 +5,12 @@ import (
 	"time"
 
 	"github.com/ooni/probe-cli/v3/internal/engine/netx/trace"
+	"github.com/ooni/probe-cli/v3/internal/model"
 )
 
 // SaverResolver is a resolver that saves events
 type SaverResolver struct {
-	Resolver
+	model.Resolver
 	Saver *trace.Saver
 }
 
@@ -69,5 +70,5 @@ func (txp SaverDNSTransport) RoundTrip(ctx context.Context, query []byte) ([]byt
 	return reply, err
 }
 
-var _ Resolver = SaverResolver{}
+var _ model.Resolver = SaverResolver{}
 var _ RoundTripper = SaverDNSTransport{}

internal/engine/netx/tlsdialer/saver.go

@@ -7,12 +7,13 @@ import (
 	"time"
 
 	"github.com/ooni/probe-cli/v3/internal/engine/netx/trace"
+	"github.com/ooni/probe-cli/v3/internal/model"
 	"github.com/ooni/probe-cli/v3/internal/netxlite"
 )
 
 // SaverTLSHandshaker saves events occurring during the handshake
 type SaverTLSHandshaker struct {
-	TLSHandshaker
+	model.TLSHandshaker
 	Saver *trace.Saver
 }
 
@@ -46,4 +47,4 @@ func (h SaverTLSHandshaker) Handshake(
 	return tlsconn, state, err
 }
 
-var _ TLSHandshaker = SaverTLSHandshaker{}
+var _ model.TLSHandshaker = SaverTLSHandshaker{}

internal/engine/netx/tlsdialer/saver_test.go

@@ -3,7 +3,6 @@ package tlsdialer_test
 import (
 	"context"
 	"crypto/tls"
-	"net"
 	"reflect"
 	"testing"
 	"time"
@@ -23,9 +22,7 @@ func TestSaverTLSHandshakerSuccessWithReadWrite(t *testing.T) {
 	saver := &trace.Saver{}
 	tlsdlr := &netxlite.TLSDialerLegacy{
 		Config: &tls.Config{NextProtos: nextprotos},
-		Dialer: netxlite.NewDialerLegacyAdapter(
-			dialer.New(&dialer.Config{ReadWriteSaver: saver}, &net.Resolver{}),
-		),
+		Dialer: dialer.New(&dialer.Config{ReadWriteSaver: saver}, netxlite.DefaultResolver),
 		TLSHandshaker: tlsdialer.SaverTLSHandshaker{
 			TLSHandshaker: &netxlite.TLSHandshakerConfigurable{},
 			Saver:         saver,

internal/engine/netx/tlsdialer/tls.go

@@ -1,19 +0,0 @@
-// Package tlsdialer contains code to establish TLS connections.
-package tlsdialer
-
-import (
-	"context"
-	"crypto/tls"
-	"net"
-)
-
-// UnderlyingDialer is the underlying dialer type.
-type UnderlyingDialer interface {
-	DialContext(ctx context.Context, network, address string) (net.Conn, error)
-}
-
-// TLSHandshaker is the generic TLS handshaker
-type TLSHandshaker interface {
-	Handshake(ctx context.Context, conn net.Conn, config *tls.Config) (
-		net.Conn, tls.ConnectionState, error)
-}