83440cf110
The legacy part for now is internal/errorsx. It will stay there until I figure out whether it also needs some extra bug fixing. The good part is now in internal/netxlite/errorsx and contains all the logic for mapping errors. We need to further improve upon this logic by writing more thorough integration tests for QUIC. We also need to copy the various dialer, conn, etc adapters that set errors. We will put them inside netxlite and we will generate errors in a way that is less crazy with respect to the major operation. (The idea is to always wrap, given that now we measure in an incremental way and we don't measure every operation together.) Part of https://github.com/ooni/probe/issues/1591
80 lines
2.0 KiB
Go
80 lines
2.0 KiB
Go
package errorsx
|
|
|
|
import (
|
|
"context"
|
|
"net"
|
|
|
|
"github.com/ooni/probe-cli/v3/internal/netxlite/errorsx"
|
|
)
|
|
|
|
// Dialer establishes network connections.
|
|
type Dialer interface {
|
|
// DialContext behaves like net.Dialer.DialContext.
|
|
DialContext(ctx context.Context, network, address string) (net.Conn, error)
|
|
}
|
|
|
|
// ErrorWrapperDialer is a dialer that performs error wrapping. The connection
|
|
// returned by the DialContext function will also perform error wrapping.
|
|
type ErrorWrapperDialer struct {
|
|
// Dialer is the underlying dialer.
|
|
Dialer
|
|
}
|
|
|
|
// DialContext implements Dialer.DialContext.
|
|
func (d *ErrorWrapperDialer) DialContext(ctx context.Context, network, address string) (net.Conn, error) {
|
|
conn, err := d.Dialer.DialContext(ctx, network, address)
|
|
if err != nil {
|
|
return nil, &errorsx.ErrWrapper{
|
|
Failure: errorsx.ClassifyGenericError(err),
|
|
Operation: errorsx.ConnectOperation,
|
|
WrappedErr: err,
|
|
}
|
|
}
|
|
return &errorWrapperConn{Conn: conn}, nil
|
|
}
|
|
|
|
// errorWrapperConn is a net.Conn that performs error wrapping.
|
|
type errorWrapperConn struct {
|
|
// Conn is the underlying connection.
|
|
net.Conn
|
|
}
|
|
|
|
// Read implements net.Conn.Read.
|
|
func (c *errorWrapperConn) Read(b []byte) (int, error) {
|
|
count, err := c.Conn.Read(b)
|
|
if err != nil {
|
|
return 0, &errorsx.ErrWrapper{
|
|
Failure: errorsx.ClassifyGenericError(err),
|
|
Operation: errorsx.ReadOperation,
|
|
WrappedErr: err,
|
|
}
|
|
}
|
|
return count, nil
|
|
}
|
|
|
|
// Write implements net.Conn.Write.
|
|
func (c *errorWrapperConn) Write(b []byte) (int, error) {
|
|
count, err := c.Conn.Write(b)
|
|
if err != nil {
|
|
return 0, &errorsx.ErrWrapper{
|
|
Failure: errorsx.ClassifyGenericError(err),
|
|
Operation: errorsx.WriteOperation,
|
|
WrappedErr: err,
|
|
}
|
|
}
|
|
return count, nil
|
|
}
|
|
|
|
// Close implements net.Conn.Close.
|
|
func (c *errorWrapperConn) Close() error {
|
|
err := c.Conn.Close()
|
|
if err != nil {
|
|
return &errorsx.ErrWrapper{
|
|
Failure: errorsx.ClassifyGenericError(err),
|
|
Operation: errorsx.CloseOperation,
|
|
WrappedErr: err,
|
|
}
|
|
}
|
|
return nil
|
|
}
|