Pull request: all: upd go, simplify code

Merge in DNS/dnsproxy from upd to master

Squashed commit of the following:

commit 5495078
Author: Ainar Garipov <[email protected]>
Date:   Thu Dec 23 14:38:06 2021 +0300

    upstream: imp code

commit 0ddc631
Author: Ainar Garipov <[email protected]>
Date:   Wed Dec 22 21:08:13 2021 +0300

    all: upd more

commit cf987ed
Author: Ainar Garipov <[email protected]>
Date:   Wed Dec 22 20:50:01 2021 +0300

    proxy: fmt

commit 31821af
Author: Ainar Garipov <[email protected]>
Date:   Wed Dec 22 20:47:44 2021 +0300

    all: upd go, simplify code

.golangci.yml

@@ -62,7 +62,7 @@ issues:
     - G302
     # errcheck defer Close
     - error return value not checked \(defer .*\.Close()\)
-    # gosec: False positive is triggered by 'src, err := ioutil.ReadFile(filename)'
+    # gosec: False positive is triggered by 'src, err := os.ReadFile(filename)'
     - Potential file inclusion via variable
     # gosec: TLS InsecureSkipVerify may be true
     # We have a configuration option that allows to do this

bamboo-specs/bamboo.yaml

@@ -5,7 +5,7 @@ plan:
   key: DNSPROXYSPECS
   name: dnsproxy - Build and run tests
 variables:
-  dockerGo: adguard/golang-ubuntu:3.3
+  dockerGo: adguard/golang-ubuntu:4.0
 
 stages:
   - Tests:
@@ -29,16 +29,16 @@ Test:
         interpreter: SHELL
         scripts:
           - |-
-            set -x
-            set -e
+            set -e -f -u -x
+
             go version
             golangci-lint --version
 
-            # Run linter
+            # Run linter.
             golangci-lint run
 
-            # Run tests
-            go test -race -v -bench=. -coverprofile=coverage.txt ./...
+            # Run tests.
+            go test --bench . --coverprofile coverage.txt --race -v ./...
   final-tasks:
     - clean
   requirements:

go.mod

@@ -1,23 +1,41 @@
 module github.com/AdguardTeam/dnsproxy
 
-go 1.16
+go 1.17
 
 require (
 	github.com/AdguardTeam/golibs v0.10.3
-	github.com/ameshkov/dnscrypt/v2 v2.2.2
+	github.com/ameshkov/dnscrypt/v2 v2.2.3
 	github.com/ameshkov/dnsstamps v1.0.3
 	github.com/beefsack/go-rate v0.0.0-20200827232406-6cde80facd47
-	github.com/go-test/deep v1.0.5
-	github.com/jessevdk/go-flags v1.4.0
-	github.com/joomcode/errorx v1.0.3
-	github.com/kr/text v0.2.0 // indirect
-	github.com/lucas-clemente/quic-go v0.21.1
-	github.com/miekg/dns v1.1.40
-	github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e // indirect
+	github.com/jessevdk/go-flags v1.5.0
+	github.com/lucas-clemente/quic-go v0.24.0
+	github.com/miekg/dns v1.1.44
 	github.com/patrickmn/go-cache v2.1.0+incompatible
 	github.com/stretchr/testify v1.7.0
-	golang.org/x/crypto v0.0.0-20201208171446-5f87f3452ae9 // indirect
-	golang.org/x/net v0.0.0-20210929193557-e81a3d93ecf6
+	golang.org/x/net v0.0.0-20211216030914-fe4d6282115f
+	gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b
+)
+
+require (
+	github.com/aead/chacha20 v0.0.0-20180709150244-8b13a72661da // indirect
+	github.com/aead/poly1305 v0.0.0-20180717145839-3fee0db0b635 // indirect
+	github.com/cheekybits/genny v1.0.0 // indirect
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/fsnotify/fsnotify v1.5.1 // indirect
+	github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0 // indirect
+	github.com/kr/text v0.2.0 // indirect
+	github.com/marten-seemann/qtls-go1-16 v0.1.4 // indirect
+	github.com/marten-seemann/qtls-go1-17 v0.1.0 // indirect
+	github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e // indirect
+	github.com/nxadm/tail v1.4.8 // indirect
+	github.com/onsi/ginkgo v1.16.5 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	golang.org/x/crypto v0.0.0-20211215153901-e495a2d5b3d3 // indirect
+	golang.org/x/mod v0.5.1 // indirect
+	golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e // indirect
+	golang.org/x/text v0.3.7 // indirect
+	golang.org/x/tools v0.1.8 // indirect
+	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
 	gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f // indirect
-	gopkg.in/yaml.v3 v3.0.0-20200615113413-eeeca48fe776
+	gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 // indirect
 )

main.go

@@ -3,7 +3,6 @@ package main
 import (
 	"crypto/tls"
 	"fmt"
-	"io/ioutil"
 	"net"
 	"os"
 	"os/signal"
@@ -188,7 +187,7 @@ func main() {
 		if len(arg) > 13 {
 			if arg[:13] == "--config-path" {
 				fmt.Printf("Path: %s\n", arg[14:])
-				b, err := ioutil.ReadFile(arg[14:])
+				b, err := os.ReadFile(arg[14:])
 				if err != nil {
 					log.Fatalf("failed to read the config file %s: %v", arg[14:], err)
 				}
@@ -378,7 +377,7 @@ func initDNSCryptConfig(config *proxy.Config, options *Options) {
 		return
 	}
 
-	b, err := ioutil.ReadFile(options.DNSCryptConfigPath)
+	b, err := os.ReadFile(options.DNSCryptConfigPath)
 	if err != nil {
 		log.Fatalf("failed to read DNSCrypt config %s: %v", options.DNSCryptConfigPath, err)
 	}
@@ -549,11 +548,11 @@ func newTLSConfig(options *Options) (*tls.Config, error) {
 // form a certificate chain. On successful return, Certificate.Leaf will
 // be nil because the parsed form of the certificate is not retained.
 func loadX509KeyPair(certFile, keyFile string) (tls.Certificate, error) {
-	certPEMBlock, err := ioutil.ReadFile(certFile)
+	certPEMBlock, err := os.ReadFile(certFile)
 	if err != nil {
 		return tls.Certificate{}, err
 	}
-	keyPEMBlock, err := ioutil.ReadFile(keyFile)
+	keyPEMBlock, err := os.ReadFile(keyFile)
 	if err != nil {
 		return tls.Certificate{}, err
 	}
@@ -568,7 +567,7 @@ func loadServersList(sources []string) []string {
 	var servers []string
 
 	for _, source := range sources {
-		data, err := ioutil.ReadFile(source)
+		data, err := os.ReadFile(source)
 		if err != nil {
 			// Ignore errors, just consider it a server address
 			// and not a file

proxy/errors.go

@@ -1,3 +1,4 @@
+//go:build !plan9
 // +build !plan9
 
 package proxy

proxy/exchange.go

@@ -5,8 +5,8 @@ import (
 	"time"
 
 	"github.com/AdguardTeam/dnsproxy/upstream"
+	"github.com/AdguardTeam/golibs/errors"
 	"github.com/AdguardTeam/golibs/log"
-	"github.com/joomcode/errorx"
 	"github.com/miekg/dns"
 )
 
@@ -44,7 +44,8 @@ func (p *Proxy) exchange(req *dns.Msg, upstreams []upstream.Upstream) (reply *dn
 		errs = append(errs, err)
 		p.updateRtt(dnsUpstream.Address(), int(defaultTimeout/time.Millisecond))
 	}
-	return nil, nil, errorx.DecorateMany("all upstreams failed to exchange request", errs...)
+
+	return nil, nil, errors.List("all upstreams failed to exchange request", errs...)
 }
 
 func (p *Proxy) getSortedUpstreams(u []upstream.Upstream) []upstream.Upstream {

proxy/lookup.go

@@ -44,23 +44,13 @@ func (p *Proxy) LookupIPAddr(host string) ([]net.IPAddr, error) {
 
 	var ipAddrs []net.IPAddr
 	var errs []error
-	n := 0
-wait:
-	for {
-		var result *lookupResult
-		select {
-		case result = <-ch:
-			if result.err != nil {
-				errs = append(errs, result.err)
-			} else {
-				// copy IP addresses from dns.RR to the resulting IPs array
-				proxyutil.AppendIPAddrs(&ipAddrs, result.resp.Answer)
-			}
-			n++
-			if n == 2 {
-				// Two parallel lookups are finished
-				break wait
-			}
+	for n := 0; n < 2; n++ {
+		result := <-ch
+		if result.err != nil {
+			errs = append(errs, result.err)
+		} else {
+			// Copy IP addresses from dns.RR to the resulting IP slice.
+			proxyutil.AppendIPAddrs(&ipAddrs, result.resp.Answer)
 		}
 	}
 

proxy/proxy.go

@@ -13,10 +13,10 @@ import (
 	"github.com/AdguardTeam/dnsproxy/fastip"
 	"github.com/AdguardTeam/dnsproxy/proxyutil"
 	"github.com/AdguardTeam/dnsproxy/upstream"
+	"github.com/AdguardTeam/golibs/errors"
 	"github.com/AdguardTeam/golibs/log"
 	"github.com/AdguardTeam/golibs/netutil"
 	"github.com/ameshkov/dnscrypt/v2"
-	"github.com/joomcode/errorx"
 	"github.com/lucas-clemente/quic-go"
 	"github.com/miekg/dns"
 	gocache "github.com/patrickmn/go-cache"
@@ -229,31 +229,31 @@ func (p *Proxy) Stop() error {
 	for _, l := range p.tcpListen {
 		err := l.Close()
 		if err != nil {
-			errs = append(errs, errorx.Decorate(err, "couldn't close TCP listening socket"))
+			errs = append(errs, fmt.Errorf("closing tcp listening socket: %w", err))
 		}
 	}
 	p.tcpListen = nil
 
 	for _, l := range p.udpListen {
 		err := l.Close()
 		if err != nil {
-			errs = append(errs, errorx.Decorate(err, "couldn't close UDP listening socket"))
+			errs = append(errs, fmt.Errorf("closing udp listening socket: %w", err))
 		}
 	}
 	p.udpListen = nil
 
 	for _, l := range p.tlsListen {
 		err := l.Close()
 		if err != nil {
-			errs = append(errs, errorx.Decorate(err, "couldn't close TLS listening socket"))
+			errs = append(errs, fmt.Errorf("closing tls listening socket: %w", err))
 		}
 	}
 	p.tlsListen = nil
 
 	for _, srv := range p.httpsServer {
 		err := srv.Close()
 		if err != nil {
-			errs = append(errs, errorx.Decorate(err, "couldn't close HTTPS server"))
+			errs = append(errs, fmt.Errorf("closing https server: %w", err))
 		}
 	}
 	p.httpsListen = nil
@@ -262,32 +262,33 @@ func (p *Proxy) Stop() error {
 	for _, l := range p.quicListen {
 		err := l.Close()
 		if err != nil {
-			errs = append(errs, errorx.Decorate(err, "couldn't close QUIC listener"))
+			errs = append(errs, fmt.Errorf("closing quic listener: %w", err))
 		}
 	}
 	p.quicListen = nil
 
 	for _, l := range p.dnsCryptUDPListen {
 		err := l.Close()
 		if err != nil {
-			errs = append(errs, errorx.Decorate(err, "couldn't close DNSCrypt UDP listening socket"))
+			errs = append(errs, fmt.Errorf("closing dnscrypt udp listening socket: %w", err))
 		}
 	}
 	p.dnsCryptUDPListen = nil
 
 	for _, l := range p.dnsCryptTCPListen {
 		err := l.Close()
 		if err != nil {
-			errs = append(errs, errorx.Decorate(err, "couldn't close DNCrypt TCP listening socket"))
+			errs = append(errs, fmt.Errorf("closing dnscrypt tcp listening socket: %w", err))
 		}
 	}
 	p.dnsCryptTCPListen = nil
 
 	p.started = false
 	log.Println("Stopped the DNS proxy server")
-	if len(errs) != 0 {
-		return errorx.DecorateMany("Failed to stop DNS proxy server", errs...)
+	if len(errs) > 0 {
+		return errors.List("stopping dns proxy server", errs...)
 	}
+
 	return nil
 }
 

proxy/proxy_test.go

@@ -1267,8 +1267,6 @@ func TestProxy_Resolve_withOptimisticResolver(t *testing.T) {
 	const (
 		host             = "some.domain.name."
 		nonOptimisticTTL = 3600
-
-		upsAddr = "https://upstream.address"
 	)
 
 	buildCtx := func() (dctx *DNSContext) {

proxy/server.go

@@ -1,13 +1,12 @@
 package proxy
 
 import (
-	"errors"
 	"fmt"
 	"net"
 	"time"
 
+	"github.com/AdguardTeam/golibs/errors"
 	"github.com/AdguardTeam/golibs/log"
-	"github.com/joomcode/errorx"
 	"github.com/miekg/dns"
 )
 
@@ -130,12 +129,13 @@ func (p *Proxy) handleDNSRequest(d *DNSContext) error {
 		}
 
 		if err != nil {
-			err = errorx.Decorate(err, "talking to dnsUpstream failed")
+			err = fmt.Errorf("talking to dns upstream: %w", err)
 		}
 	}
 
 	p.logDNSMessage(d.Res)
 	p.respond(d)
+
 	return err
 }
 

proxy/server_dnscrypt.go

@@ -1,11 +1,11 @@
 package proxy
 
 import (
+	"fmt"
 	"net"
 
 	"github.com/AdguardTeam/golibs/log"
 	"github.com/ameshkov/dnscrypt/v2"
-	"github.com/joomcode/errorx"
 	"github.com/miekg/dns"
 )
 
@@ -24,8 +24,9 @@ func (p *Proxy) createDNSCryptListeners() error {
 		log.Info("Creating a DNSCrypt TCP listener")
 		tcpListen, err := net.ListenTCP("tcp", a)
 		if err != nil {
-			return errorx.Decorate(err, "couldn't listen to TCP socket")
+			return fmt.Errorf("listening to dnscrypt tcp socket: %w", err)
 		}
+
 		p.dnsCryptTCPListen = append(p.dnsCryptTCPListen, tcpListen)
 		log.Info("Listening for DNSCrypt messages on tcp://%s", tcpListen.Addr())
 	}