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/cyberghost/updater/resolve.go

@@ -1,16 +1,12 @@
 package cyberghost
 
 import (
-	"context"
-	"net"
 	"time"
 
 	"github.com/qdm12/gluetun/internal/updater/resolver"
 )
 
-func resolveHosts(ctx context.Context, presolver resolver.Parallel,
-	possibleHosts []string, minServers int) (
-	hostToIPs map[string][]net.IP, err error) {
+func newParallelResolver() (parallelResolver resolver.Parallel) {
 	const (
 		maxFailRatio    = 1
 		maxDuration     = 20 * time.Second
@@ -20,7 +16,6 @@ func resolveHosts(ctx context.Context, presolver resolver.Parallel,
 	)
 	settings := resolver.ParallelSettings{
 		MaxFailRatio: maxFailRatio,
-		MinFound:     minServers,
 		Repeat: resolver.RepeatSettings{
 			MaxDuration:     maxDuration,
 			BetweenDuration: betweenDuration,
@@ -29,10 +24,5 @@ func resolveHosts(ctx context.Context, presolver resolver.Parallel,
 			SortIPs:         true,
 		},
 	}
-	hostToIPs, _, err = presolver.Resolve(ctx, possibleHosts, settings)
-	if err != nil {
-		return nil, err
-	}
-
-	return hostToIPs, nil
+	return resolver.NewParallelResolver(settings)
 }

internal/provider/cyberghost/updater/servers.go

@@ -14,7 +14,7 @@ func (u *Updater) FetchServers(ctx context.Context, minServers int) (
 	possibleServers := getPossibleServers()
 
 	possibleHosts := possibleServers.hostsSlice()
-	hostToIPs, err := resolveHosts(ctx, u.presolver, possibleHosts, minServers)
+	hostToIPs, _, err := u.presolver.Resolve(ctx, possibleHosts, minServers)
 	if err != nil {
 		return nil, err
 	}

internal/provider/cyberghost/updater/updater.go

@@ -6,8 +6,8 @@ type Updater struct {
 	presolver resolver.Parallel
 }
 
-func New(presolver resolver.Parallel) *Updater {
+func New() *Updater {
 	return &Updater{
-		presolver: presolver,
+		presolver: newParallelResolver(),
 	}
 }

internal/provider/expressvpn/updater/resolve.go

@@ -1,16 +1,12 @@
 package expressvpn
 
 import (
-	"context"
-	"net"
 	"time"
 
 	"github.com/qdm12/gluetun/internal/updater/resolver"
 )
 
-func resolveHosts(ctx context.Context, presolver resolver.Parallel,
-	hosts []string, minServers int) (hostToIPs map[string][]net.IP,
-	warnings []string, err error) {
+func newParallelResolver() resolver.Parallel {
 	const (
 		maxFailRatio = 0.1
 		maxNoNew     = 1
@@ -18,7 +14,6 @@ func resolveHosts(ctx context.Context, presolver resolver.Parallel,
 	)
 	settings := resolver.ParallelSettings{
 		MaxFailRatio: maxFailRatio,
-		MinFound:     minServers,
 		Repeat: resolver.RepeatSettings{
 			MaxDuration: time.Second,
 			MaxNoNew:    maxNoNew,
@@ -26,5 +21,5 @@ func resolveHosts(ctx context.Context, presolver resolver.Parallel,
 			SortIPs:     true,
 		},
 	}
-	return presolver.Resolve(ctx, hosts, settings)
+	return resolver.NewParallelResolver(settings)
 }

internal/provider/expressvpn/updater/servers.go

@@ -21,7 +21,7 @@ func (u *Updater) FetchServers(ctx context.Context, minServers int) (
 		hosts[i] = servers[i].Hostname
 	}
 
-	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/expressvpn/updater/updater.go

@@ -15,11 +15,10 @@ 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,
+		presolver: newParallelResolver(),
 		warner:    warner,
 	}
 }

internal/provider/fastestvpn/updater/resolve.go

@@ -1,16 +1,12 @@
 package fastestvpn
 
 import (
-	"context"
-	"net"
 	"time"
 
 	"github.com/qdm12/gluetun/internal/updater/resolver"
 )
 
-func resolveHosts(ctx context.Context, presolver resolver.Parallel,
-	hosts []string, minServers int) (hostToIPs map[string][]net.IP,
-	warnings []string, err error) {
+func newParallelResolver() resolver.Parallel {
 	const (
 		maxFailRatio = 0.1
 		maxNoNew     = 1
@@ -18,7 +14,6 @@ func resolveHosts(ctx context.Context, presolver resolver.Parallel,
 	)
 	settings := resolver.ParallelSettings{
 		MaxFailRatio: maxFailRatio,
-		MinFound:     minServers,
 		Repeat: resolver.RepeatSettings{
 			MaxDuration: time.Second,
 			MaxNoNew:    maxNoNew,
@@ -26,5 +21,5 @@ func resolveHosts(ctx context.Context, presolver resolver.Parallel,
 			SortIPs:     true,
 		},
 	}
-	return presolver.Resolve(ctx, hosts, settings)
+	return resolver.NewParallelResolver(settings)
 }

internal/provider/fastestvpn/updater/servers.go

@@ -56,7 +56,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/fastestvpn/updater/updater.go

@@ -15,11 +15,10 @@ 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,
+		presolver: newParallelResolver(),
 		warner:    warner,
 	}
 }

internal/provider/hidemyass/updater/resolve.go

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

internal/provider/hidemyass/updater/servers.go

@@ -26,7 +26,7 @@ func (u *Updater) FetchServers(ctx context.Context, minServers int) (
 			common.ErrNotEnoughServers, len(hosts), minServers)
 	}
 
-	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/hidemyass/updater/updater.go

@@ -16,11 +16,10 @@ type Warner interface {
 	Warn(s string)
 }
 
-func New(client *http.Client, presolver resolver.Parallel,
-	warner Warner) *Updater {
+func New(client *http.Client, warner Warner) *Updater {
 	return &Updater{
 		client:    client,
-		presolver: presolver,
+		presolver: newParallelResolver(),
 		warner:    warner,
 	}
 }

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(),
 	}
 }

internal/provider/ivpn/updater/resolve.go

@@ -1,14 +1,12 @@
 package ivpn
 
 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/ivpn/updater/resolve_test.go

@@ -1,57 +0,0 @@
-package ivpn
-
-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/ivpn/updater/servers.go

@@ -38,7 +38,7 @@ func (u *Updater) FetchServers(ctx context.Context, minServers int) (
 			common.ErrNotEnoughServers, len(hosts), minServers)
 	}
 
-	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/ivpn/updater/servers_test.go

@@ -12,7 +12,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/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -35,7 +34,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
@@ -61,7 +59,6 @@ func Test_Updater_GetServers(t *testing.T) {
 			responseStatus:  http.StatusOK,
 			expectResolve:   true,
 			hostsToResolve:  []string{"hosta"},
-			resolveSettings: getResolveSettings(0),
 			resolveWarnings: []string{"resolve warning"},
 			resolveErr:      errors.New("dummy"),
 			err:             errors.New("dummy"),
@@ -87,10 +84,9 @@ func Test_Updater_GetServers(t *testing.T) {
 				{"country":"Country2","city":"City B","hostnames":{"openvpn":"hostb"},"wg_public_key":"xyz"},
 				{"country":"Country3","city":"City C","hostnames":{"wireguard":"hostc"},"wg_public_key":"xyz"}
 			]}`,
-			responseStatus:  http.StatusOK,
-			expectResolve:   true,
-			hostsToResolve:  []string{"hosta", "hostb", "hostc"},
-			resolveSettings: getResolveSettings(1),
+			responseStatus: http.StatusOK,
+			expectResolve:  true,
+			hostsToResolve: []string{"hosta", "hostb", "hostc"},
 			hostToIPs: map[string][]net.IP{
 				"hosta": {{1, 1, 1, 1}, {2, 2, 2, 2}},
 				"hostb": {{3, 3, 3, 3}, {4, 4, 4, 4}},
@@ -134,13 +130,17 @@ 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(client, presolver, warner)
+			updater := &Updater{
+				client:    client,
+				presolver: presolver,
+				warner:    warner,
+			}
 
 			servers, err := updater.FetchServers(ctx, testCase.minServers)
 

internal/provider/ivpn/updater/updater.go

@@ -16,11 +16,10 @@ type Warner interface {
 	Warn(s string)
 }
 
-func New(client *http.Client, presolver resolver.Parallel,
-	warner Warner) *Updater {
+func New(client *http.Client, warner Warner) *Updater {
 	return &Updater{
 		client:    client,
-		presolver: presolver,
+		presolver: newParallelResolver(),
 		warner:    warner,
 	}
 }

internal/provider/privado/updater/resolve.go

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

internal/provider/privado/updater/servers.go

@@ -50,7 +50,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/privado/updater/updater.go

@@ -19,11 +19,11 @@ type Warner interface {
 }
 
 func New(client *http.Client, unzipper unzip.Unzipper,
-	presolver resolver.Parallel, warner Warner) *Updater {
+	warner Warner) *Updater {
 	return &Updater{
 		client:    client,
 		unzipper:  unzipper,
-		presolver: presolver,
+		presolver: newParallelResolver(),
 		warner:    warner,
 	}
 }

internal/provider/privatevpn/updater/resolve.go

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

internal/provider/privatevpn/updater/servers.go

@@ -82,7 +82,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/privatevpn/updater/updater.go

@@ -15,11 +15,10 @@ 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,
+		presolver: newParallelResolver(),
 		warner:    warner,
 	}
 }

internal/provider/purevpn/updater/resolve.go

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

internal/provider/purevpn/updater/servers.go

@@ -60,7 +60,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/purevpn/updater/updater.go

@@ -19,11 +19,11 @@ type Warner interface {
 }
 
 func New(client *http.Client, unzipper unzip.Unzipper,
-	presolver resolver.Parallel, warner Warner) *Updater {
+	warner Warner) *Updater {
 	return &Updater{
 		client:    client,
 		unzipper:  unzipper,
-		presolver: presolver,
+		presolver: newParallelResolver(),
 		warner:    warner,
 	}
 }

internal/provider/surfshark/updater/resolve.go

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

internal/provider/surfshark/updater/resolve_test.go

@@ -1,57 +0,0 @@
-package surfshark
-
-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/surfshark/updater/servers.go

@@ -31,7 +31,7 @@ func (u *Updater) FetchServers(ctx context.Context, minServers int) (
 	getRemainingServers(hts)
 
 	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/surfshark/updater/updater.go

@@ -19,11 +19,11 @@ type Warner interface {
 }
 
 func New(client *http.Client, unzipper unzip.Unzipper,
-	presolver resolver.Parallel, warner Warner) *Updater {
+	warner Warner) *Updater {
 	return &Updater{
 		client:    client,
 		unzipper:  unzipper,
-		presolver: presolver,
+		presolver: newParallelResolver(),
 		warner:    warner,
 	}
 }

internal/provider/torguard/updater/resolve.go

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

internal/provider/torguard/updater/servers.go

@@ -50,7 +50,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)
 	u.warnWarnings(warnings)
 	if err != nil {
 		return nil, err

internal/provider/torguard/updater/updater.go

@@ -15,11 +15,10 @@ 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,
+		presolver: newParallelResolver(),
 		warner:    warner,
 	}
 }

internal/provider/vpnunlimited/updater/resolve.go

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

internal/provider/vpnunlimited/updater/servers.go

@@ -20,7 +20,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/vpnunlimited/updater/updater.go

@@ -15,11 +15,10 @@ 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,
+		presolver: newParallelResolver(),
 		warner:    warner,
 	}
 }

internal/provider/vyprvpn/updater/resolve.go

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

internal/provider/vyprvpn/updater/servers.go

@@ -64,7 +64,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/vyprvpn/updater/updater.go

@@ -15,11 +15,10 @@ 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,
+		presolver: newParallelResolver(),
 		warner:    warner,
 	}
 }

internal/provider/wevpn/updater/resolve.go

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

internal/provider/wevpn/updater/resolve_test.go

@@ -1,57 +0,0 @@
-package wevpn
-
-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/wevpn/updater/servers.go

@@ -31,7 +31,7 @@ func (u *Updater) FetchServers(ctx context.Context, minServers int) (
 		hostnameToCity[hostname] = city
 	}
 
-	hostnameToIPs, warnings, err := resolveHosts(ctx, u.presolver, hostnames, minServers)
+	hostnameToIPs, warnings, err := u.presolver.Resolve(ctx, hostnames, minServers)
 	for _, warning := range warnings {
 		u.warner.Warn(warning)
 	}

internal/provider/wevpn/updater/updater.go

@@ -13,9 +13,9 @@ type Warner interface {
 	Warn(s string)
 }
 
-func New(presolver resolver.Parallel, warner Warner) *Updater {
+func New(warner Warner) *Updater {
 	return &Updater{
-		presolver: presolver,
+		presolver: newParallelResolver(),
 		warner:    warner,
 	}
 }