Feat: rework Surfshark servers data (#575)

- Feat: `MULTIHOP_ONLY` variable
- Feat: `COUNTRY` variable
- Feat: `CITY` variable
- Feat: `REGION` variable, with retro-compatibility
- Feat: merge servers from API, zip and hardcoded hostnames
- Fix: remove outdated and duplicate servers
- Maint: faster update with fully parallel DNS resolutions

internal/updater/providers/surfshark/servers.go

@@ -6,71 +6,36 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"strings"
+	"net/http"
 
 	"github.com/qdm12/gluetun/internal/models"
-	"github.com/qdm12/gluetun/internal/updater/openvpn"
 	"github.com/qdm12/gluetun/internal/updater/resolver"
 	"github.com/qdm12/gluetun/internal/updater/unzip"
 )
 
-var ErrNotEnoughServers = errors.New("not enough servers found")
+var (
+	ErrGetZip           = errors.New("cannot get OpenVPN ZIP file")
+	ErrGetAPI           = errors.New("cannot fetch server information from API")
+	ErrNotEnoughServers = errors.New("not enough servers found")
+)
 
 func GetServers(ctx context.Context, unzipper unzip.Unzipper,
-	presolver resolver.Parallel, minServers int) (
+	client *http.Client, presolver resolver.Parallel, minServers int) (
 	servers []models.SurfsharkServer, warnings []string, err error) {
-	const url = "https://my.surfshark.com/vpn/api/v1/server/configurations"
-	contents, err := unzipper.FetchAndExtract(ctx, url)
-	if err != nil {
-		return nil, nil, err
-	} else if len(contents) < minServers {
-		return nil, nil, fmt.Errorf("%w: %d and expected at least %d",
-			ErrNotEnoughServers, len(contents), minServers)
-	}
-
-	subdomainToRegion := subdomainToRegion()
 	hts := make(hostToServer)
 
-	for fileName, content := range contents {
-		if !strings.HasSuffix(fileName, ".ovpn") {
-			continue // not an OpenVPN file
-		}
-
-		tcp, udp, err := openvpn.ExtractProto(content)
-		if err != nil {
-			// treat error as warning and go to next file
-			warning := err.Error() + " in " + fileName
-			warnings = append(warnings, warning)
-			continue
-		}
-
-		host, warning, err := openvpn.ExtractHost(content)
-		if warning != "" {
-			warnings = append(warnings, warning)
-		}
-		if err != nil {
-			// treat error as warning and go to next file
-			warning := err.Error() + " in " + fileName
-			warnings = append(warnings, warning)
-			continue
-		}
-
-		region, err := parseHost(host, subdomainToRegion)
-		if err != nil {
-			// treat error as warning and go to next file
-			warning := err.Error()
-			warnings = append(warnings, warning)
-			continue
-		}
-
-		hts.add(host, region, tcp, udp)
+	err = addServersFromAPI(ctx, client, hts)
+	if err != nil {
+		return nil, nil, fmt.Errorf("%w: %s", ErrGetAPI, err)
 	}
 
-	if len(hts) < minServers {
-		return nil, warnings, fmt.Errorf("%w: %d and expected at least %d",
-			ErrNotEnoughServers, len(hts), minServers)
+	warnings, err = addOpenVPNServersFromZip(ctx, unzipper, hts)
+	if err != nil {
+		return nil, nil, fmt.Errorf("%w: %s", ErrGetZip, err)
 	}
 
+	getRemainingServers(hts)
+
 	hosts := hts.toHostsSlice()
 	hostToIPs, newWarnings, err := resolveHosts(ctx, presolver, hosts, minServers)
 	warnings = append(warnings, newWarnings...)
@@ -82,20 +47,6 @@ func GetServers(ctx context.Context, unzipper unzip.Unzipper,
 
 	servers = hts.toServersSlice()
 
-	// process subdomain entries in mapping that were not in the Zip file
-	subdomainsDone := hts.toSubdomainsSlice()
-	for _, subdomainDone := range subdomainsDone {
-		delete(subdomainToRegion, subdomainDone)
-	}
-	remainingServers, newWarnings, err := getRemainingServers(
-		ctx, subdomainToRegion, presolver)
-	warnings = append(warnings, newWarnings...)
-	if err != nil {
-		return nil, warnings, err
-	}
-
-	servers = append(servers, remainingServers...)
-
 	if len(servers) < minServers {
 		return nil, warnings, fmt.Errorf("%w: %d and expected at least %d",
 			ErrNotEnoughServers, len(servers), minServers)
@@ -105,39 +56,3 @@ func GetServers(ctx context.Context, unzipper unzip.Unzipper,
 
 	return servers, warnings, nil
 }
-
-func getRemainingServers(ctx context.Context,
-	subdomainToRegionLeft map[string]string, presolver resolver.Parallel) (
-	servers []models.SurfsharkServer, warnings []string, err error) {
-	hosts := make([]string, 0, len(subdomainToRegionLeft))
-	const suffix = ".prod.surfshark.com"
-	for subdomain := range subdomainToRegionLeft {
-		hosts = append(hosts, subdomain+suffix)
-	}
-
-	const minServers = 0
-	hostToIPs, warnings, err := resolveHosts(ctx, presolver, hosts, minServers)
-	if err != nil {
-		return nil, warnings, err
-	}
-
-	servers = make([]models.SurfsharkServer, 0, len(hostToIPs))
-	for host, IPs := range hostToIPs {
-		region, err := parseHost(host, subdomainToRegionLeft)
-		if err != nil {
-			return nil, warnings, err
-		}
-
-		// we assume the server supports TCP and UDP
-		server := models.SurfsharkServer{
-			Region:   region,
-			Hostname: host,
-			TCP:      true,
-			UDP:      true,
-			IPs:      IPs,
-		}
-		servers = append(servers, server)
-	}
-
-	return servers, warnings, nil
-}