proxy: imp code

Author: EugeneOne1

proxy/proxy.go

@@ -179,10 +179,11 @@ type Proxy struct {
 	udpOOBSize int
 
 	// bindRetryNum is the number of retries for binding to an address for
-	// listening.
+	// listening.  Zero means one attempt and no retries.
 	bindRetryNum uint
 
-	// bindRetryIvl is the interval between retries to bind to an address for
+	// bindRetryIvl is the interval between attempts to bind to an address for
+	// listening.
 	bindRetryIvl time.Duration
 
 	// counter counts message contexts created with [Proxy.newDNSContext].
@@ -279,7 +280,7 @@ func New(c *Config) (p *Proxy, err error) {
 	}
 
 	if bindRetries := c.BindRetryConfig; bindRetries != nil && bindRetries.Enabled {
-		p.bindRetryNum = bindRetries.Limit
+		p.bindRetryNum = bindRetries.Count
 		p.bindRetryIvl = bindRetries.Interval
 	}
 

proxy/retry.go

@@ -1,10 +1,10 @@
 package proxy
 
 import (
-	"fmt"
+	"context"
 	"time"
 
-	"github.com/AdguardTeam/golibs/errors"
+	"github.com/AdguardTeam/golibs/logutil/slogutil"
 )
 
 // BindRetryConfig contains configuration for the listeners binding retry
@@ -13,42 +13,35 @@ type BindRetryConfig struct {
 	// Enabled indicates whether the binding should be retried.
 	Enabled bool
 
-	// Limit is the maximum number of retries, which don't include the first
-	// attempt.
-	Limit uint
+	// Count is the maximum number of retries after the first attempt.
+	Count uint
 
-	// Interval is the minimum time to wait between retries.  It must not be
-	// negative if retrying is enabled.
+	// Interval is the minimum time to wait after the latest failure.  It must
+	// not be negative if Enabled is true.
 	Interval time.Duration
 }
 
-// withRetry calls f until it returns no error or the retries limit is reached,
-// sleeping for ivl between attempts.  retries is the number of attempts after
-// the first one.
-func withRetry[T any](
-	f func() (res T, err error),
-	ivl time.Duration,
-	retries uint,
-) (res T, err error) {
-	res, err = f()
+// bindWithRetry calls f until it returns no error or the retries limit is
+// reached, sleeping for configured interval between attempts.  bindFunc should
+// carry the result of the binding operation itself.
+func (p *Proxy) bindWithRetry(ctx context.Context, bindFunc func() (err error)) (err error) {
+	err = bindFunc()
 	if err == nil {
-		return res, nil
+		return nil
 	}
 
-	errs := []error{
-		fmt.Errorf("attempt 1: %w", err),
-	}
+	p.logger.WarnContext(ctx, "binding", "attempt", 1, slogutil.KeyError, err)
 
-	for attempt := uint(1); attempt <= retries; attempt++ {
-		time.Sleep(ivl)
+	for attempt := uint(1); attempt <= p.bindRetryNum; attempt++ {
+		time.Sleep(p.bindRetryIvl)
 
-		res, err = f()
-		if err == nil {
-			return res, nil
+		retryErr := bindFunc()
+		if retryErr == nil {
+			return nil
 		}
 
-		errs = append(errs, fmt.Errorf("attempt %d: %w", attempt+1, err))
+		p.logger.WarnContext(ctx, "binding", "attempt", attempt+1, slogutil.KeyError, retryErr)
 	}
 
-	return res, errors.Join(errs...)
+	return err
 }

proxy/retry_internal_test.go

@@ -4,71 +4,87 @@ import (
 	"testing"
 
 	"github.com/AdguardTeam/golibs/errors"
+	"github.com/AdguardTeam/golibs/logutil/slogutil"
 	"github.com/AdguardTeam/golibs/testutil"
 	"github.com/stretchr/testify/assert"
 )
 
 func TestWithRetry(t *testing.T) {
 	t.Parallel()
 
-	const goodRes = "good"
-
 	const (
 		errA errors.Error = "error about a"
 		errB errors.Error = "error about b"
 	)
 
 	var (
-		good = func() (res any, err error) {
-			return goodRes, nil
+		good = func() (err error) {
+			return nil
 		}
 
-		badOne = func() (res any, err error) {
-			return nil, errA
+		badOne = func() (err error) {
+			return errA
 		}
 
 		returnedA = false
-		badBoth   = func() (res any, err error) {
+		badBoth   = func() (err error) {
 			if !returnedA {
 				returnedA = true
-				return nil, errA
+
+				return errA
 			}
 
-			return nil, errB
+			return errB
+		}
+
+		returnedErr = false
+		badThenOk   = func() (err error) {
+			if !returnedErr {
+				returnedErr = true
+
+				return assert.AnError
+			}
+
+			return nil
 		}
 	)
 
 	testCases := []struct {
-		name       string
-		f          func() (res any, err error)
-		want       any
-		wantErrMsg string
+		f       func() (err error)
+		wantErr error
+		name    string
 	}{{
-		name:       "no_error",
-		f:          good,
-		want:       goodRes,
-		wantErrMsg: "",
+		f:       good,
+		wantErr: nil,
+		name:    "no_error",
+	}, {
+		f:       badOne,
+		wantErr: errA,
+		name:    "one_error",
 	}, {
-		name: "one_error",
-		f:    badOne,
-		want: nil,
-		wantErrMsg: "attempt 1: error about a\n" +
-			"attempt 2: error about a",
+		f:       badBoth,
+		wantErr: errA,
+		name:    "two_errors",
 	}, {
-		name: "two_errors",
-		f:    badBoth,
-		want: nil,
-		wantErrMsg: "attempt 1: error about a\n" +
-			"attempt 2: error about b",
+		f:       badThenOk,
+		wantErr: nil,
+		name:    "error_then_ok",
 	}}
 
+	p := &Proxy{
+		logger:       slogutil.NewDiscardLogger(),
+		bindRetryNum: 1,
+		bindRetryIvl: 0,
+	}
+
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
 
-			got, err := withRetry(tc.f, 0, 1)
-			assert.Equal(t, tc.want, got)
-			testutil.AssertErrorMsg(t, tc.wantErrMsg, err)
+			ctx := testutil.ContextWithTimeout(t, testTimeout)
+
+			err := p.bindWithRetry(ctx, tc.f)
+			assert.ErrorIs(t, err, tc.wantErr)
 		})
 	}
 }

proxy/server_dnscrypt.go

@@ -28,41 +28,79 @@ func (p *Proxy) initDNSCryptListeners(ctx context.Context) (err error) {
 		ProviderName: p.DNSCryptProviderName,
 		ResolverCert: p.DNSCryptResolverCert,
 		Handler: &dnsCryptHandler{
-			proxy: p,
-
+			proxy:   p,
 			reqSema: p.requestsSema,
 		},
 	}
 
-	for _, a := range p.DNSCryptUDPListenAddr {
-		p.logger.InfoContext(ctx, "creating dnscrypt udp listener")
-		udp, lErr := withRetry(func() (conn *net.UDPConn, err error) {
-			return net.ListenUDP(bootstrap.NetworkUDP, a)
-		}, p.bindRetryIvl, p.bindRetryNum)
+	for _, addr := range p.DNSCryptUDPListenAddr {
+		udp, lErr := p.listenDNSCryptUDP(ctx, addr)
 		if lErr != nil {
-			return fmt.Errorf("listening to dnscrypt udp socket: %w", lErr)
+			return fmt.Errorf("listening to dnscrypt udp on addr %s: %w", addr, lErr)
 		}
 
 		p.dnsCryptUDPListen = append(p.dnsCryptUDPListen, udp)
-		p.logger.InfoContext(ctx, "listening for dnscrypt messages on udp", "addr", udp.LocalAddr())
 	}
 
-	for _, a := range p.DNSCryptTCPListenAddr {
-		p.logger.InfoContext(ctx, "creating a dnscrypt tcp listener")
-		tcp, lErr := withRetry(func() (conn *net.TCPListener, err error) {
-			return net.ListenTCP(bootstrap.NetworkTCP, a)
-		}, p.bindRetryIvl, p.bindRetryNum)
+	for _, addr := range p.DNSCryptTCPListenAddr {
+		tcp, lErr := p.listenDNSCryptTCP(ctx, addr)
 		if lErr != nil {
-			return fmt.Errorf("listening to dnscrypt tcp socket: %w", lErr)
+			return fmt.Errorf("listening to dnscrypt tcp on addr %s: %w", addr, lErr)
 		}
 
 		p.dnsCryptTCPListen = append(p.dnsCryptTCPListen, tcp)
-		p.logger.InfoContext(ctx, "listening for dnscrypt messages on tcp", "addr", tcp.Addr())
 	}
 
 	return nil
 }
 
+// listenDNSCryptUDP returns a new UDP connection for DNSCrypt listening on
+// addr.
+func (p *Proxy) listenDNSCryptUDP(
+	ctx context.Context,
+	addr *net.UDPAddr,
+) (conn *net.UDPConn, err error) {
+	addrStr := addr.String()
+	p.logger.InfoContext(ctx, "creating dnscrypt udp server socket", "addr", addrStr)
+
+	var udp *net.UDPConn
+	lErr := p.bindWithRetry(ctx, func() (err error) {
+		udp, err = net.ListenUDP(bootstrap.NetworkUDP, addr)
+
+		return err
+	})
+	if lErr != nil {
+		return nil, fmt.Errorf("listening to udp socket: %w", lErr)
+	}
+
+	p.logger.InfoContext(ctx, "listening for dnscrypt messages on udp", "addr", udp.LocalAddr())
+
+	return udp, nil
+}
+
+// listenDNSCryptTCP returns a new TCP listener for DNSCrypt listening on addr.
+func (p *Proxy) listenDNSCryptTCP(
+	ctx context.Context,
+	addr *net.TCPAddr,
+) (conn *net.TCPListener, err error) {
+	addrStr := addr.String()
+	p.logger.InfoContext(ctx, "creating dnscrypt tcp server socket", "addr", addrStr)
+
+	var tcp *net.TCPListener
+	lErr := p.bindWithRetry(ctx, func() (err error) {
+		tcp, err = net.ListenTCP(bootstrap.NetworkTCP, addr)
+
+		return err
+	})
+	if lErr != nil {
+		return nil, fmt.Errorf("listening to tcp socket: %w", lErr)
+	}
+
+	p.logger.InfoContext(ctx, "listening for dnscrypt messages on tcp", "addr", tcp.Addr())
+
+	return tcp, nil
+}
+
 // dnsCryptHandler - dnscrypt.Handler implementation
 type dnsCryptHandler struct {
 	proxy *Proxy

proxy/server_https.go

@@ -29,9 +29,12 @@ func (p *Proxy) listenHTTP(
 	ctx context.Context,
 	addr *net.TCPAddr,
 ) (ln net.Listener, tcpAddr *net.TCPAddr, err error) {
-	tcpListen, err := withRetry(func() (conn *net.TCPListener, err error) {
-		return net.ListenTCP(bootstrap.NetworkTCP, addr)
-	}, p.bindRetryIvl, p.bindRetryNum)
+	var tcpListen *net.TCPListener
+	err = p.bindWithRetry(ctx, func() (listenErr error) {
+		tcpListen, listenErr = net.ListenTCP(bootstrap.NetworkTCP, addr)
+
+		return listenErr
+	})
 	if err != nil {
 		return nil, nil, fmt.Errorf("tcp listener: %w", err)
 	}

proxy/server_quic.go

@@ -89,9 +89,11 @@ func (p *Proxy) listenQUIC(
 ) (conn *net.UDPConn, l *quic.EarlyListener, tr *quic.Transport, err error) {
 	p.logger.InfoContext(ctx, "creating quic listener", "addr", addr)
 
-	conn, err = withRetry(func() (conn *net.UDPConn, err error) {
-		return net.ListenUDP(bootstrap.NetworkUDP, addr)
-	}, p.bindRetryIvl, p.bindRetryNum)
+	err = p.bindWithRetry(ctx, func() (listenErr error) {
+		conn, listenErr = net.ListenUDP(bootstrap.NetworkUDP, addr)
+
+		return listenErr
+	})
 	if err != nil {
 		return nil, nil, nil, fmt.Errorf("listening to udp socket: %w", err)
 	}

proxy/server_tcp.go

@@ -40,9 +40,12 @@ func (p *Proxy) listenTCP(ctx context.Context, addr *net.TCPAddr) (ln *net.TCPLi
 
 	conf := proxynetutil.ListenConfig(p.logger)
 
-	listener, err := withRetry(func() (conn net.Listener, err error) {
-		return conf.Listen(ctx, bootstrap.NetworkTCP, addrStr)
-	}, p.bindRetryIvl, p.bindRetryNum)
+	var listener net.Listener
+	err = p.bindWithRetry(ctx, func() (listenErr error) {
+		listener, listenErr = conf.Listen(ctx, bootstrap.NetworkTCP, addrStr)
+
+		return listenErr
+	})
 	if err != nil {
 		return nil, fmt.Errorf("listening to tcp socket: %w", err)
 	}
@@ -66,9 +69,11 @@ func (p *Proxy) initTLSListeners(ctx context.Context) (err error) {
 		p.logger.InfoContext(ctx, "creating tls server socket", "addr", addr)
 
 		var tcpListen *net.TCPListener
-		tcpListen, err = withRetry(func() (conn *net.TCPListener, err error) {
-			return net.ListenTCP("tcp", addr)
-		}, p.bindRetryIvl, p.bindRetryNum)
+		err = p.bindWithRetry(ctx, func() (listenErr error) {
+			tcpListen, listenErr = net.ListenTCP("tcp", addr)
+
+			return listenErr
+		})
 		if err != nil {
 			return fmt.Errorf("listening on tls addr %s: %w", addr, err)
 		}

proxy/server_udp.go

@@ -38,9 +38,12 @@ func (p *Proxy) listenUDP(ctx context.Context, addr *net.UDPAddr) (conn *net.UDP
 
 	conf := proxynetutil.ListenConfig(p.logger)
 
-	packetConn, err := withRetry(func() (conn net.PacketConn, err error) {
-		return conf.ListenPacket(ctx, bootstrap.NetworkUDP, addrStr)
-	}, p.bindRetryIvl, p.bindRetryNum)
+	var packetConn net.PacketConn
+	err = p.bindWithRetry(ctx, func() (listenErr error) {
+		packetConn, listenErr = conf.ListenPacket(ctx, bootstrap.NetworkUDP, addrStr)
+
+		return listenErr
+	})
 	if err != nil {
 		return nil, fmt.Errorf("listening to udp socket: %w", err)
 	}