chore(deps): upgrade dns to v2.0.0-cr7

internal/dns/loop.go

@@ -6,8 +6,8 @@ import (
 	"net/http"
 	"time"
 
-	"github.com/qdm12/dns/v2/pkg/dot"
 	"github.com/qdm12/dns/v2/pkg/middlewares/filter/mapfilter"
+	"github.com/qdm12/dns/v2/pkg/server"
 	"github.com/qdm12/gluetun/internal/configuration/settings"
 	"github.com/qdm12/gluetun/internal/constants"
 	"github.com/qdm12/gluetun/internal/dns/state"
@@ -18,7 +18,7 @@ import (
 type Loop struct {
 	statusManager *loopstate.State
 	state         *state.State
-	server        *dot.Server
+	server        *server.Server
 	filter        *mapfilter.Filter
 	resolvConf    string
 	client        *http.Client

internal/dns/settings.go

@@ -10,6 +10,7 @@ import (
 	filtermiddleware "github.com/qdm12/dns/v2/pkg/middlewares/filter"
 	"github.com/qdm12/dns/v2/pkg/middlewares/filter/mapfilter"
 	"github.com/qdm12/dns/v2/pkg/provider"
+	"github.com/qdm12/dns/v2/pkg/server"
 	"github.com/qdm12/gluetun/internal/configuration/settings"
 )
 
@@ -23,53 +24,52 @@ func (l *Loop) SetSettings(ctx context.Context, settings settings.DNS) (
 
 func buildDoTSettings(settings settings.DNS,
 	filter *mapfilter.Filter, logger Logger) (
-	dotSettings dot.ServerSettings, err error,
+	serverSettings server.Settings, err error,
 ) {
-	var middlewares []dot.Middleware
+	serverSettings.Logger = logger
+
+	var dotSettings dot.Settings
+	dotSettings.Warner = logger
+	providersData := provider.NewProviders()
+	dotSettings.UpstreamResolvers = make([]provider.Provider, len(settings.DoT.Providers))
+	for i := range settings.DoT.Providers {
+		var err error
+		dotSettings.UpstreamResolvers[i], err = providersData.Get(settings.DoT.Providers[i])
+		if err != nil {
+			panic(err) // this should already had been checked
+		}
+	}
+	dotSettings.IPVersion = "ipv4"
+	if *settings.DoT.IPv6 {
+		dotSettings.IPVersion = "ipv6"
+	}
+
+	serverSettings.Dialer, err = dot.New(dotSettings)
+	if err != nil {
+		return server.Settings{}, fmt.Errorf("creating DNS over TLS dialer: %w", err)
+	}
 
 	if *settings.DoT.Caching {
 		lruCache, err := lru.New(lru.Settings{})
 		if err != nil {
-			return dot.ServerSettings{}, fmt.Errorf("creating LRU cache: %w", err)
+			return server.Settings{}, fmt.Errorf("creating LRU cache: %w", err)
 		}
 		cacheMiddleware, err := cachemiddleware.New(cachemiddleware.Settings{
 			Cache: lruCache,
 		})
 		if err != nil {
-			return dot.ServerSettings{}, fmt.Errorf("creating cache middleware: %w", err)
+			return server.Settings{}, fmt.Errorf("creating cache middleware: %w", err)
 		}
-		middlewares = append(middlewares, cacheMiddleware)
+		serverSettings.Middlewares = append(serverSettings.Middlewares, cacheMiddleware)
 	}
 
 	filterMiddleware, err := filtermiddleware.New(filtermiddleware.Settings{
 		Filter: filter,
 	})
 	if err != nil {
-		return dot.ServerSettings{}, fmt.Errorf("creating filter middleware: %w", err)
+		return server.Settings{}, fmt.Errorf("creating filter middleware: %w", err)
 	}
-	middlewares = append(middlewares, filterMiddleware)
+	serverSettings.Middlewares = append(serverSettings.Middlewares, filterMiddleware)
 
-	providersData := provider.NewProviders()
-	providers := make([]provider.Provider, len(settings.DoT.Providers))
-	for i := range settings.DoT.Providers {
-		var err error
-		providers[i], err = providersData.Get(settings.DoT.Providers[i])
-		if err != nil {
-			panic(err) // this should already had been checked
-		}
-	}
-
-	ipVersion := "ipv4"
-	if *settings.DoT.IPv6 {
-		ipVersion = "ipv6"
-	}
-	return dot.ServerSettings{
-		Resolver: dot.ResolverSettings{
-			UpstreamResolvers: providers,
-			IPVersion:         ipVersion,
-			Warner:            logger,
-		},
-		Middlewares: middlewares,
-		Logger:      logger,
-	}, nil
+	return serverSettings, nil
 }

internal/dns/setup.go

@@ -6,8 +6,8 @@ import (
 	"fmt"
 
 	"github.com/qdm12/dns/v2/pkg/check"
-	"github.com/qdm12/dns/v2/pkg/dot"
 	"github.com/qdm12/dns/v2/pkg/nameserver"
+	"github.com/qdm12/dns/v2/pkg/server"
 )
 
 var errUpdateBlockLists = errors.New("cannot update filter block lists")
@@ -25,12 +25,12 @@ func (l *Loop) setupServer(ctx context.Context) (runError <-chan error, err erro
 		return nil, fmt.Errorf("building DoT settings: %w", err)
 	}
 
-	server, err := dot.NewServer(dotSettings)
+	server, err := server.New(dotSettings)
 	if err != nil {
 		return nil, fmt.Errorf("creating DoT server: %w", err)
 	}
 
-	runError, err = server.Start()
+	runError, err = server.Start(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("starting server: %w", err)
 	}