fix(privado): update servers data using JSON API

- Fixes #3159
- Fixes #2118
- Fixes #2657

internal/provider/privado/provider.go

@@ -2,6 +2,7 @@ package privado
 
 import (
 	"math/rand"
+	"net/http"
 
 	"github.com/qdm12/gluetun/internal/constants/providers"
 	"github.com/qdm12/gluetun/internal/provider/common"
@@ -15,14 +16,12 @@ type Provider struct {
 }
 
 func New(storage common.Storage, randSource rand.Source,
-	ipFetcher common.IPFetcher, unzipper common.Unzipper,
+	client *http.Client, updaterWarner common.Warner,
-	updaterWarner common.Warner,
-	parallelResolver common.ParallelResolver,
 ) *Provider {
 	return &Provider{
 		storage:    storage,
 		randSource: randSource,
-		Fetcher:    updater.New(ipFetcher, unzipper, updaterWarner, parallelResolver),
+		Fetcher:    updater.New(client, updaterWarner),
 	}
 }
 

internal/provider/privado/updater/hosttoserver.go

@@ -1,50 +0,0 @@
-package updater
-
-import (
-	"net/netip"
-
-	"github.com/qdm12/gluetun/internal/constants/vpn"
-	"github.com/qdm12/gluetun/internal/models"
-)
-
-type hostToServer map[string]models.Server
-
-func (hts hostToServer) add(host string) {
-	server, ok := hts[host]
-	if ok {
-		return
-	}
-	server.VPN = vpn.OpenVPN
-	server.Hostname = host
-	server.UDP = true
-	hts[host] = server
-}
-
-func (hts hostToServer) toHostsSlice() (hosts []string) {
-	hosts = make([]string, 0, len(hts))
-	for host := range hts {
-		hosts = append(hosts, host)
-	}
-	return hosts
-}
-
-func (hts hostToServer) adaptWithIPs(hostToIPs map[string][]netip.Addr) {
-	for host, IPs := range hostToIPs {
-		server := hts[host]
-		server.IPs = IPs
-		hts[host] = server
-	}
-	for host, server := range hts {
-		if len(server.IPs) == 0 {
-			delete(hts, host)
-		}
-	}
-}
-
-func (hts hostToServer) toServersSlice() (servers []models.Server) {
-	servers = make([]models.Server, 0, len(hts))
-	for _, server := range hts {
-		servers = append(servers, server)
-	}
-	return servers
-}

internal/provider/privado/updater/location.go

@@ -1,31 +0,0 @@
-package updater
-
-import (
-	"context"
-	"net/netip"
-
-	"github.com/qdm12/gluetun/internal/models"
-	"github.com/qdm12/gluetun/internal/provider/common"
-	"github.com/qdm12/gluetun/internal/publicip/api"
-)
-
-func setLocationInfo(ctx context.Context, fetcher common.IPFetcher, servers []models.Server) (err error) {
-	// Get public IP address information
-	ipsToGetInfo := make([]netip.Addr, 0, len(servers))
-	for _, server := range servers {
-		ipsToGetInfo = append(ipsToGetInfo, server.IPs...)
-	}
-	ipsInfo, err := api.FetchMultiInfo(ctx, fetcher, ipsToGetInfo)
-	if err != nil {
-		return err
-	}
-
-	for i := range servers {
-		ipInfo := ipsInfo[i]
-		servers[i].Country = ipInfo.Country
-		servers[i].Region = ipInfo.Region
-		servers[i].City = ipInfo.City
-	}
-
-	return nil
-}

internal/provider/privado/updater/resolve.go

@@ -1,26 +0,0 @@
-package updater
-
-import (
-	"time"
-
-	"github.com/qdm12/gluetun/internal/updater/resolver"
-)
-
-func parallelResolverSettings(hosts []string) (settings resolver.ParallelSettings) {
-	const (
-		maxFailRatio = 0.1
-		maxDuration  = 30 * time.Second
-		maxNoNew     = 2
-		maxFails     = 2
-	)
-	return resolver.ParallelSettings{
-		Hosts:        hosts,
-		MaxFailRatio: maxFailRatio,
-		Repeat: resolver.RepeatSettings{
-			MaxDuration: maxDuration,
-			MaxNoNew:    maxNoNew,
-			MaxFails:    maxFails,
-			SortIPs:     true,
-		},
-	}
-}

internal/provider/privado/updater/servers.go

@@ -2,77 +2,66 @@ package updater
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
+	"net/http"
+	"net/netip"
 	"sort"
-	"strings"
 
+	"github.com/qdm12/gluetun/internal/constants/vpn"
 	"github.com/qdm12/gluetun/internal/models"
 	"github.com/qdm12/gluetun/internal/provider/common"
-	"github.com/qdm12/gluetun/internal/updater/openvpn"
 )
 
 func (u *Updater) FetchServers(ctx context.Context, minServers int) (
 	servers []models.Server, err error,
 ) {
-	if !u.ipFetcher.CanFetchAnyIP() {
+	const url = "https://privadovpn.com/apps/servers_export.json"
-		return nil, fmt.Errorf("%w: %s", common.ErrIPFetcherUnsupported, u.ipFetcher.String())
+	request, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
-	}
-
-	const url = "https://privadovpn.com/apps/ovpn_configs.zip"
-	contents, err := u.unzipper.FetchAndExtract(ctx, url)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("creating request: %w", err)
-	} else if len(contents) < minServers {
-		return nil, fmt.Errorf("%w: %d and expected at least %d",
-			common.ErrNotEnoughServers, len(contents), minServers)
 	}
 
-	hts := make(hostToServer)
+	response, err := u.client.Do(request)
-
-	for fileName, content := range contents {
-		if !strings.HasSuffix(fileName, ".ovpn") {
-			continue // not an OpenVPN file
-		}
-
-		host, warning, err := openvpn.ExtractHost(content)
-		if warning != "" {
-			u.warner.Warn(warning)
-		}
-		if err != nil {
-			// treat error as warning and go to next file
-			u.warner.Warn(err.Error() + " in " + fileName)
-			continue
-		}
-
-		hts.add(host)
-	}
-
-	if len(hts) < minServers {
-		return nil, fmt.Errorf("%w: %d and expected at least %d",
-			common.ErrNotEnoughServers, len(hts), minServers)
-	}
-
-	hosts := hts.toHostsSlice()
-	resolveSettings := parallelResolverSettings(hosts)
-	hostToIPs, warnings, err := u.parallelResolver.Resolve(ctx, resolveSettings)
-	for _, warning := range warnings {
-		u.warner.Warn(warning)
-	}
 	if err != nil {
 		return nil, err
 	}
 
-	if len(hostToIPs) < minServers {
+	var data struct {
-		return nil, fmt.Errorf("%w: %d and expected at least %d",
+		Servers []struct {
-			common.ErrNotEnoughServers, len(servers), minServers)
+			Country  string     `json:"country"`
+			City     string     `json:"city"`
+			Hostname string     `json:"hostname"`
+			IP       netip.Addr `json:"ip"`
+		} `json:"servers"`
+	}
+	decoder := json.NewDecoder(response.Body)
+	err = decoder.Decode(&data)
+	if err != nil {
+		_ = response.Body.Close()
+		return nil, fmt.Errorf("decoding JSON response: %w", err)
 	}
 
-	hts.adaptWithIPs(hostToIPs)
+	err = response.Body.Close()
+	if err != nil {
+		return nil, fmt.Errorf("closing response body: %w", err)
+	}
 
-	servers = hts.toServersSlice()
+	if len(data.Servers) < minServers {
+		return nil, fmt.Errorf("%w: %d and expected at least %d",
+			common.ErrNotEnoughServers, len(data.Servers), minServers)
+	}
 
-	if err := setLocationInfo(ctx, u.ipFetcher, servers); err != nil {
+	servers = make([]models.Server, len(data.Servers))
-		return nil, err
+	for i, server := range data.Servers {
+		servers[i] = models.Server{
+			VPN:      vpn.OpenVPN,
+			Country:  server.Country,
+			City:     server.City,
+			Hostname: server.Hostname,
+			IPs:      []netip.Addr{server.IP},
+			UDP:      true,
+		}
 	}
 
 	sort.Sort(models.SortableServers(servers))

internal/provider/privado/updater/updater.go

@@ -1,23 +1,19 @@
 package updater
 
 import (
+	"net/http"
+
 	"github.com/qdm12/gluetun/internal/provider/common"
 )
 
 type Updater struct {
-	ipFetcher        common.IPFetcher
+	client *http.Client
-	unzipper         common.Unzipper
-	parallelResolver common.ParallelResolver
 	warner common.Warner
 }
 
-func New(ipFetcher common.IPFetcher, unzipper common.Unzipper,
+func New(client *http.Client, warner common.Warner) *Updater {
-	warner common.Warner, parallelResolver common.ParallelResolver,
-) *Updater {
 	return &Updater{
-		ipFetcher:        ipFetcher,
+		client: client,
-		unzipper:         unzipper,
-		parallelResolver: parallelResolver,
 		warner: warner,
 	}
 }

internal/provider/providers.go

@@ -71,7 +71,7 @@ func NewProviders(storage Storage, timeNow func() time.Time,
 		providers.Mullvad:               mullvad.New(storage, randSource, client),
 		providers.Nordvpn:               nordvpn.New(storage, randSource, client, updaterWarner),
 		providers.Perfectprivacy:        perfectprivacy.New(storage, randSource, unzipper, updaterWarner),
-		providers.Privado:               privado.New(storage, randSource, ipFetcher, unzipper, updaterWarner, parallelResolver),
+		providers.Privado:               privado.New(storage, randSource, client, updaterWarner),
 		providers.PrivateInternetAccess: privateinternetaccess.New(storage, randSource, timeNow, client),
 		providers.Privatevpn:            privatevpn.New(storage, randSource, unzipper, updaterWarner, parallelResolver),
 		providers.Protonvpn:             protonvpn.New(storage, randSource, client, updaterWarner, *credentials.ProtonEmail, *credentials.ProtonPassword),