8a0beee808
What do I mean by pivoting? Netx is currently organized by row:
```
| dialer | quicdialer | resolver | ...
saving | | | | ...
errorwrapping | | | | ...
logging | | | | ...
mocking/sys | | | | ...
```
Every row needs to implement saving, errorwrapping, logging, mocking (or
adapting to the system or to some underlying library).
This causes cross package dependencies and, in turn, complexity. For
example, we need the `trace` package for supporting saving.
And `dialer`, `quickdialer`, et al. need to depend on such a package.
The same goes for errorwrapping.
This arrangement further complicates testing. For example, I am
currently working on https://github.com/ooni/probe/issues/1505 and
I realize it need to repeat integration tests in multiple places.
Let's say instead we pivot the above matrix as follows:
```
| saving | errorwrapping | logging | ...
dialer | | | | ...
quicdialer | | | | ...
logging | | | | ...
mocking/sys | | | | ...
...
```
In this way, now every row contains everything related to a specific
action to perform. We can now share code without relying on extra
support packages. What's more, we can write tests and, judding from
the way in which things are made, it seems we only need integration
testing in `errorwrapping` because it's where data quality matters
whereas, in all other cases, unit testing is fine.
I am going, therefore, to proceed with these changes and "pivot"
`netx`. Hopefully, it won't be too painful.
58 lines
1.5 KiB
Go
58 lines
1.5 KiB
Go
package quicdialer
|
|
|
|
import (
|
|
"context"
|
|
"crypto/tls"
|
|
"net"
|
|
|
|
"github.com/lucas-clemente/quic-go"
|
|
"github.com/ooni/probe-cli/v3/internal/netxlite"
|
|
)
|
|
|
|
// DNSDialer is a dialer that uses the configured Resolver to resolve a
|
|
// domain name to IP addresses
|
|
type DNSDialer struct {
|
|
Dialer ContextDialer
|
|
Resolver Resolver
|
|
}
|
|
|
|
// DialContext implements ContextDialer.DialContext
|
|
func (d DNSDialer) DialContext(
|
|
ctx context.Context, network, host string,
|
|
tlsCfg *tls.Config, cfg *quic.Config) (quic.EarlySession, error) {
|
|
onlyhost, onlyport, err := net.SplitHostPort(host)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
// TODO(kelmenhorst): Should this be somewhere else?
|
|
// failure if tlsCfg is nil but that should not happen
|
|
if tlsCfg.ServerName == "" {
|
|
tlsCfg.ServerName = onlyhost
|
|
}
|
|
var addrs []string
|
|
addrs, err = d.LookupHost(ctx, onlyhost)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var errorslist []error
|
|
for _, addr := range addrs {
|
|
target := net.JoinHostPort(addr, onlyport)
|
|
sess, err := d.Dialer.DialContext(
|
|
ctx, network, target, tlsCfg, cfg)
|
|
if err == nil {
|
|
return sess, nil
|
|
}
|
|
errorslist = append(errorslist, err)
|
|
}
|
|
// TODO(bassosimone): maybe ReduceErrors could be in netx/internal.
|
|
return nil, netxlite.ReduceErrors(errorslist)
|
|
}
|
|
|
|
// LookupHost implements Resolver.LookupHost
|
|
func (d DNSDialer) LookupHost(ctx context.Context, hostname string) ([]string, error) {
|
|
if net.ParseIP(hostname) != nil {
|
|
return []string{hostname}, nil
|
|
}
|
|
return d.Resolver.LookupHost(ctx, hostname)
|
|
}
|