chore(updater): move updater packages to pkg/updaters/<name>

2026-06-21 03:14:10 +02:00 · 2026-04-23 03:47:57 +00:00
parent 628b0a22e2
commit d96752c734
164 changed files with 732 additions and 343 deletions
@@ -0,0 +1,150 @@
+package nordvpn
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sort"
+
+	"github.com/qdm12/gluetun/internal/constants/vpn"
+	"github.com/qdm12/gluetun/internal/models"
+	"github.com/qdm12/gluetun/internal/provider/common"
+)
+
+var ErrNotIPv4 = errors.New("IP address is not IPv4")
+
+func (u *Updater) FetchServers(ctx context.Context, minServers int) (
+	servers []models.Server, err error,
+) {
+	const limit = 0
+	data, err := fetchAPI(ctx, u.client, limit)
+	if err != nil {
+		return nil, err
+	}
+
+	servers = make([]models.Server, 0, len(data.Servers))
+	groups, services, locations, technologies := data.idToData()
+
+	for _, jsonServer := range data.Servers {
+		newServers, warnings := extractServers(jsonServer, groups, services, locations, technologies)
+		for _, warning := range warnings {
+			u.warner.Warn(warning)
+		}
+		servers = append(servers, newServers...)
+	}
+
+	if len(servers) < minServers {
+		return nil, fmt.Errorf("%w: %d and expected at least %d",
+			common.ErrNotEnoughServers, len(servers), minServers)
+	}
+
+	sort.Sort(models.SortableServers(servers))
+
+	return servers, nil
+}
+
+func extractServers(jsonServer serverData, groups map[uint32]groupData,
+	services map[uint32]serviceData, locations map[uint32]locationData,
+	technologies map[uint32]technologyData) (servers []models.Server,
+	warnings []string,
+) {
+	ignoreReason := ""
+	switch {
+	case jsonServer.Status != "online":
+		ignoreReason = "status is " + jsonServer.Status
+	case len(jsonServer.LocationIDs) == 0:
+		ignoreReason = "no location"
+	case len(jsonServer.IPs) == 0:
+		ignoreReason = "no IP address"
+	case !jsonServer.hasVPNService(services):
+		ignoreReason = "no VPN service"
+	}
+	if ignoreReason != "" {
+		warning := fmt.Sprintf("ignoring server %s: %s", jsonServer.Name, ignoreReason)
+		return nil, []string{warning}
+	}
+
+	location, ok := locations[jsonServer.LocationIDs[0]]
+	if !ok {
+		warning := fmt.Sprintf("location with id %d not found in %v",
+			jsonServer.LocationIDs[0], locations)
+		return nil, []string{warning}
+	}
+
+	region := jsonServer.region(groups)
+	if region == "" {
+		warning := fmt.Sprintf("no region found for server %s", jsonServer.Name)
+		return nil, []string{warning}
+	}
+
+	server := models.Server{
+		Country:    location.Country.Name,
+		Region:     region,
+		City:       location.Country.City.Name,
+		Categories: jsonServer.categories(groups),
+		Hostname:   jsonServer.Hostname,
+		IPs:        jsonServer.ips(),
+	}
+
+	number, err := parseServerName(jsonServer.Name)
+	switch {
+	case errors.Is(err, ErrNoIDInServerName):
+		warning := fmt.Sprintf("%s - leaving server number as 0", err)
+		warnings = append(warnings, warning)
+	case err != nil:
+		warning := fmt.Sprintf("failed parsing server name: %s", err)
+		return nil, []string{warning}
+	default: // no error
+		server.Number = number
+	}
+
+	var wireguardFound, openvpnFound bool
+	wireguardServer := server
+	wireguardServer.VPN = vpn.Wireguard
+	openVPNServer := server // accumulate UDP+TCP technologies
+	openVPNServer.VPN = vpn.OpenVPN
+
+	for _, technology := range jsonServer.Technologies {
+		if technology.Status != "online" {
+			continue
+		}
+		technologyData, ok := technologies[technology.ID]
+		if !ok {
+			warning := fmt.Sprintf("technology with id %d not found in %v",
+				technology.ID, technologies)
+			warnings = append(warnings, warning)
+			continue
+		}
+
+		switch technologyData.Identifier {
+		case "openvpn_udp", "openvpn_dedicated_udp":
+			openvpnFound = true
+			openVPNServer.UDP = true
+		case "openvpn_tcp", "openvpn_dedicated_tcp":
+			openvpnFound = true
+			openVPNServer.TCP = true
+		case "wireguard_udp":
+			wireguardFound = true
+			wireguardServer.WgPubKey, err = jsonServer.wireguardPublicKey(technologies)
+			if err != nil {
+				warning := fmt.Sprintf("ignoring Wireguard server %s: %s", jsonServer.Name, err)
+				warnings = append(warnings, warning)
+				wireguardFound = false
+				continue
+			}
+		default: // Ignore other technologies
+			continue
+		}
+	}
+
+	const maxServers = 2
+	servers = make([]models.Server, 0, maxServers)
+	if openvpnFound {
+		servers = append(servers, openVPNServer)
+	}
+	if wireguardFound {
+		servers = append(servers, wireguardServer)
+	}
+
+	return servers, warnings
+}