chore(updater): create resolver in provider updater

- Pass min servers to resolve call
- Set settings when constructing resolver
- Construct resolver in each provider updater
- No more common resolver for all providers

internal/provider/ipvanish/updater/resolve.go

@@ -1,14 +1,12 @@
 package ipvanish
 
 import (
-	"context"
-	"net"
 	"time"
 
 	"github.com/qdm12/gluetun/internal/updater/resolver"
 )
 
-func getResolveSettings(minServers int) (settings resolver.ParallelSettings) {
+func newParallelResolver() (parallelResolver resolver.Parallel) {
 	const (
 		maxFailRatio    = 0.1
 		maxDuration     = 20 * time.Second
@@ -16,9 +14,8 @@ func getResolveSettings(minServers int) (settings resolver.ParallelSettings) {
 		maxNoNew        = 2
 		maxFails        = 2
 	)
-	return resolver.ParallelSettings{
+	settings := resolver.ParallelSettings{
 		MaxFailRatio: maxFailRatio,
-		MinFound:     minServers,
 		Repeat: resolver.RepeatSettings{
 			MaxDuration:     maxDuration,
 			BetweenDuration: betweenDuration,
@@ -27,11 +24,5 @@ func getResolveSettings(minServers int) (settings resolver.ParallelSettings) {
 			SortIPs:         true,
 		},
 	}
-}
-
-func resolveHosts(ctx context.Context, presolver resolver.Parallel,
-	hosts []string, minServers int) (hostToIPs map[string][]net.IP,
-	warnings []string, err error) {
-	settings := getResolveSettings(minServers)
-	return presolver.Resolve(ctx, hosts, settings)
+	return resolver.NewParallelResolver(settings)
 }

internal/provider/ipvanish/updater/resolve_test.go

@@ -1,57 +0,0 @@
-package ipvanish
-
-import (
-	"context"
-	"errors"
-	"net"
-	"testing"
-	"time"
-
-	"github.com/golang/mock/gomock"
-	"github.com/qdm12/gluetun/internal/updater/resolver"
-	"github.com/qdm12/gluetun/internal/updater/resolver/mock_resolver"
-	"github.com/stretchr/testify/assert"
-)
-
-func Test_resolveHosts(t *testing.T) {
-	t.Parallel()
-	ctrl := gomock.NewController(t)
-
-	ctx := context.Background()
-	presolver := mock_resolver.NewMockParallel(ctrl)
-	hosts := []string{"host1", "host2"}
-	const minServers = 10
-
-	expectedHostToIPs := map[string][]net.IP{
-		"host1": {{1, 2, 3, 4}},
-		"host2": {{2, 3, 4, 5}},
-	}
-	expectedWarnings := []string{"warning1", "warning2"}
-	expectedErr := errors.New("dummy")
-
-	const (
-		maxFailRatio    = 0.1
-		maxDuration     = 20 * time.Second
-		betweenDuration = time.Second
-		maxNoNew        = 2
-		maxFails        = 2
-	)
-	expectedSettings := resolver.ParallelSettings{
-		MaxFailRatio: maxFailRatio,
-		MinFound:     minServers,
-		Repeat: resolver.RepeatSettings{
-			MaxDuration:     maxDuration,
-			BetweenDuration: betweenDuration,
-			MaxNoNew:        maxNoNew,
-			MaxFails:        maxFails,
-			SortIPs:         true,
-		},
-	}
-	presolver.EXPECT().Resolve(ctx, hosts, expectedSettings).
-		Return(expectedHostToIPs, expectedWarnings, expectedErr)
-
-	hostToIPs, warnings, err := resolveHosts(ctx, presolver, hosts, minServers)
-	assert.Equal(t, expectedHostToIPs, hostToIPs)
-	assert.Equal(t, expectedWarnings, warnings)
-	assert.Equal(t, expectedErr, err)
-}

internal/provider/ipvanish/updater/servers.go

@@ -67,7 +67,7 @@ func (u *Updater) FetchServers(ctx context.Context, minServers int) (
 	}
 
 	hosts := hts.toHostsSlice()
-	hostToIPs, warnings, err := resolveHosts(ctx, u.presolver, hosts, minServers)
+	hostToIPs, warnings, err := u.presolver.Resolve(ctx, hosts, minServers)
 	for _, warning := range warnings {
 		u.warner.Warn(warning)
 	}

internal/provider/ipvanish/updater/servers_test.go

@@ -9,7 +9,6 @@ import (
 	"github.com/golang/mock/gomock"
 	"github.com/qdm12/gluetun/internal/constants/vpn"
 	"github.com/qdm12/gluetun/internal/models"
-	"github.com/qdm12/gluetun/internal/updater/resolver"
 	"github.com/qdm12/gluetun/internal/updater/resolver/mock_resolver"
 	"github.com/qdm12/gluetun/internal/updater/unzip/mock_unzip"
 	"github.com/stretchr/testify/assert"
@@ -32,7 +31,6 @@ func Test_Updater_GetServers(t *testing.T) {
 		// Resolution
 		expectResolve   bool
 		hostsToResolve  []string
-		resolveSettings resolver.ParallelSettings
 		hostToIPs       map[string][]net.IP
 		resolveWarnings []string
 		resolveErr      error
@@ -88,10 +86,9 @@ func Test_Updater_GetServers(t *testing.T) {
 			unzipContents: map[string][]byte{
 				"ipvanish-CA-City-A-hosta.ovpn": []byte("remote hosta\nremote hostb"),
 			},
-			expectResolve:   true,
-			hostsToResolve:  []string{"hosta"},
-			resolveSettings: getResolveSettings(1),
-			err:             errors.New("not enough servers found: 0 and expected at least 1"),
+			expectResolve:  true,
+			hostsToResolve: []string{"hosta"},
+			err:            errors.New("not enough servers found: 0 and expected at least 1"),
 		},
 		"resolve error": {
 			warnerBuilder: func(ctrl *gomock.Controller) Warner {
@@ -104,7 +101,6 @@ func Test_Updater_GetServers(t *testing.T) {
 			},
 			expectResolve:   true,
 			hostsToResolve:  []string{"hosta"},
-			resolveSettings: getResolveSettings(0),
 			resolveWarnings: []string{"resolve warning"},
 			resolveErr:      errors.New("dummy"),
 			err:             errors.New("dummy"),
@@ -132,9 +128,8 @@ func Test_Updater_GetServers(t *testing.T) {
 				"ipvanish-CA-City-A-hosta.ovpn": []byte("remote hosta"),
 				"ipvanish-LU-City-B-hostb.ovpn": []byte("remote hostb"),
 			},
-			expectResolve:   true,
-			hostsToResolve:  []string{"hosta", "hostb"},
-			resolveSettings: getResolveSettings(1),
+			expectResolve:  true,
+			hostsToResolve: []string{"hosta", "hostb"},
 			hostToIPs: map[string][]net.IP{
 				"hosta": {{1, 1, 1, 1}, {2, 2, 2, 2}},
 				"hostb": {{3, 3, 3, 3}, {4, 4, 4, 4}},
@@ -175,13 +170,15 @@ func Test_Updater_GetServers(t *testing.T) {
 
 			presolver := mock_resolver.NewMockParallel(ctrl)
 			if testCase.expectResolve {
-				presolver.EXPECT().Resolve(ctx, testCase.hostsToResolve, testCase.resolveSettings).
+				presolver.EXPECT().Resolve(ctx, testCase.hostsToResolve, testCase.minServers).
 					Return(testCase.hostToIPs, testCase.resolveWarnings, testCase.resolveErr)
 			}
 
-			warner := testCase.warnerBuilder(ctrl)
-
-			updater := New(unzipper, presolver, warner)
+			updater := &Updater{
+				unzipper:  unzipper,
+				warner:    testCase.warnerBuilder(ctrl),
+				presolver: presolver,
+			}
 
 			servers, err := updater.FetchServers(ctx, testCase.minServers)
 

internal/provider/ipvanish/updater/updater.go

@@ -7,19 +7,18 @@ import (
 
 type Updater struct {
 	unzipper  unzip.Unzipper
-	presolver resolver.Parallel
 	warner    Warner
+	presolver resolver.Parallel
 }
 
 type Warner interface {
 	Warn(s string)
 }
 
-func New(unzipper unzip.Unzipper, presolver resolver.Parallel,
-	warner Warner) *Updater {
+func New(unzipper unzip.Unzipper, warner Warner) *Updater {
 	return &Updater{
 		unzipper:  unzipper,
-		presolver: presolver,
 		warner:    warner,
+		presolver: newParallelResolver(),
 	}
 }