expressvpn wip

internal/provider/expressvpn/updater/servers.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"sort"
 
-	"github.com/qdm12/gluetun/internal/constants/vpn"
 	"github.com/qdm12/gluetun/internal/models"
 	"github.com/qdm12/gluetun/internal/provider/common"
 )
@@ -13,35 +12,66 @@ import (
 func (u *Updater) FetchServers(ctx context.Context, minServers int) (
 	servers []models.Server, err error,
 ) {
-	servers = hardcodedServers()
-
-	hosts := make([]string, len(servers))
-	for i := range servers {
-		hosts[i] = servers[i].Hostname
-	}
-
-	resolveSettings := parallelResolverSettings(hosts)
-	hostToIPs, warnings, err := u.parallelResolver.Resolve(ctx, resolveSettings)
+	servers, warnings, err := fetchServersFromWebsite(ctx, u.httpClient)
 	for _, warning := range warnings {
 		u.warner.Warn(warning)
 	}
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("fetching servers: %w", err)
 	}
 
-	i := 0
+	// Generate candidate hostnames for each location
+	serverToCandidateHostnames := make(map[*models.Server][]string, len(servers))
+	var allCandidateHostnames []string
 	for _, server := range servers {
-		hostname := server.Hostname
-		server.IPs = hostToIPs[hostname]
-		if len(server.IPs) == 0 {
+		candidateHostnames, err := generateCandidateHostnames(server)
+		if err != nil {
+			u.warner.Warn(fmt.Sprintf("generating candidate hostnames for %s - %s: %s",
+				server.Country, server.City, err))
 			continue
 		}
-		server.VPN = vpn.OpenVPN
-		server.UDP = true // no TCP support
-		servers[i] = server
-		i++
+		serverToCandidateHostnames[&server] = candidateHostnames
+		allCandidateHostnames = append(allCandidateHostnames, candidateHostnames...)
 	}
-	servers = servers[:i]
+
+	// Resolve all candidate hostnames in parallel
+	resolveSettings := parallelResolverSettings(allCandidateHostnames)
+	hostToIPs, _, err := u.parallelResolver.Resolve(ctx, resolveSettings)
+	// Ignore resolution warnings since we are mostly bruteforcing DNS records
+	// so most candidate hostnames will fail resolving.
+	if err != nil {
+		return nil, fmt.Errorf("resolving hostnames: %w", err)
+	}
+
+	foundServers := make([]models.Server, 0, len(servers))
+	for server, candidateHostnames := range serverToCandidateHostnames {
+		success := false
+		for _, candidate := range candidateHostnames {
+			ips := hostToIPs[candidate]
+			if len(ips) > 0 {
+				success = true
+				workingServer := *server
+				workingServer.Hostname = candidate
+				workingServer.IPs = ips
+				foundServers = append(foundServers, workingServer)
+			}
+		}
+		if success {
+			continue
+		}
+
+		// Log a warning on the bad server location that did not resolve any IPs
+		serverName := server.Country
+		if server.City != "" {
+			serverName += " - " + server.City
+		}
+		if server.Number > 0 {
+			serverName += fmt.Sprintf(" (%d)", server.Number)
+		}
+		u.warner.Warn(fmt.Sprintf("no IPs resolved for %s (tried %v)", serverName, candidateHostnames))
+	}
+
+	servers = foundServers
 
 	if len(servers) < minServers {
 		return nil, fmt.Errorf("%w: %d and expected at least %d",