chore(all): move sub-packages to internal/provider

internal/provider/mullvad/updater/api.go

@@ -0,0 +1,58 @@
+package mullvad
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+)
+
+var (
+	ErrHTTPStatusCodeNotOK   = errors.New("HTTP status code not OK")
+	ErrUnmarshalResponseBody = errors.New("failed unmarshaling response body")
+)
+
+type serverData struct {
+	Hostname string `json:"hostname"`
+	Country  string `json:"country_name"`
+	City     string `json:"city_name"`
+	Active   bool   `json:"active"`
+	Owned    bool   `json:"owned"`
+	Provider string `json:"provider"`
+	IPv4     string `json:"ipv4_addr_in"`
+	IPv6     string `json:"ipv6_addr_in"`
+	Type     string `json:"type"`
+	PubKey   string `json:"pubkey"` // Wireguard public key
+}
+
+func fetchAPI(ctx context.Context, client *http.Client) (data []serverData, err error) {
+	const url = "https://api.mullvad.net/www/relays/all/"
+
+	request, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	response, err := client.Do(request)
+	if err != nil {
+		return nil, err
+	}
+	defer response.Body.Close()
+
+	if response.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("%w: %d %s", ErrHTTPStatusCodeNotOK,
+			response.StatusCode, response.Status)
+	}
+
+	decoder := json.NewDecoder(response.Body)
+	if err := decoder.Decode(&data); err != nil {
+		return nil, fmt.Errorf("%w: %s", ErrUnmarshalResponseBody, err)
+	}
+
+	if err := response.Body.Close(); err != nil {
+		return nil, err
+	}
+
+	return data, nil
+}

internal/provider/mullvad/updater/hosttoserver.go

@@ -0,0 +1,86 @@
+package mullvad
+
+import (
+	"errors"
+	"fmt"
+	"net"
+	"strings"
+
+	"github.com/qdm12/gluetun/internal/constants/vpn"
+	"github.com/qdm12/gluetun/internal/models"
+)
+
+type hostToServer map[string]models.Server
+
+var (
+	ErrNoIP                = errors.New("no IP address for VPN server")
+	ErrParseIPv4           = errors.New("cannot parse IPv4 address")
+	ErrParseIPv6           = errors.New("cannot parse IPv6 address")
+	ErrVPNTypeNotSupported = errors.New("VPN type not supported")
+)
+
+func (hts hostToServer) add(data serverData) (err error) {
+	if !data.Active {
+		return
+	}
+
+	if data.IPv4 == "" && data.IPv6 == "" {
+		return ErrNoIP
+	}
+
+	server, ok := hts[data.Hostname]
+	if ok { // API returns a server per hostname at most
+		return nil
+	}
+
+	switch data.Type {
+	case "openvpn":
+		server.VPN = vpn.OpenVPN
+		server.UDP = true
+		server.TCP = true
+	case "wireguard":
+		server.VPN = vpn.Wireguard
+		server.UDP = true
+	case "bridge":
+		// ignore bridge servers
+		return nil
+	default:
+		return fmt.Errorf("%w: %s", ErrVPNTypeNotSupported, data.Type)
+	}
+
+	if data.IPv4 != "" {
+		ipv4 := net.ParseIP(data.IPv4)
+		if ipv4 == nil || ipv4.To4() == nil {
+			return fmt.Errorf("%w: %s", ErrParseIPv4, data.IPv4)
+		}
+		server.IPs = append(server.IPs, ipv4)
+	}
+
+	if data.IPv6 != "" {
+		ipv6 := net.ParseIP(data.IPv6)
+		if ipv6 == nil || ipv6.To4() != nil {
+			return fmt.Errorf("%w: %s", ErrParseIPv6, data.IPv6)
+		}
+		server.IPs = append(server.IPs, ipv6)
+	}
+
+	server.Country = data.Country
+	server.City = strings.ReplaceAll(data.City, ",", "")
+	server.Hostname = data.Hostname
+	server.ISP = data.Provider
+	server.Owned = data.Owned
+	server.WgPubKey = data.PubKey
+
+	hts[data.Hostname] = server
+
+	return nil
+}
+
+func (hts hostToServer) toServersSlice() (servers []models.Server) {
+	servers = make([]models.Server, 0, len(hts))
+	for _, server := range hts {
+		server.IPs = uniqueSortedIPs(server.IPs)
+		servers = append(servers, server)
+	}
+	return servers
+}

internal/provider/mullvad/updater/ips.go

@@ -0,0 +1,30 @@
+package mullvad
+
+import (
+	"bytes"
+	"net"
+	"sort"
+)
+
+func uniqueSortedIPs(ips []net.IP) []net.IP {
+	uniqueIPs := make(map[string]struct{}, len(ips))
+	for _, ip := range ips {
+		key := ip.String()
+		uniqueIPs[key] = struct{}{}
+	}
+
+	ips = make([]net.IP, 0, len(uniqueIPs))
+	for key := range uniqueIPs {
+		ip := net.ParseIP(key)
+		if ipv4 := ip.To4(); ipv4 != nil {
+			ip = ipv4
+		}
+		ips = append(ips, ip)
+	}
+
+	sort.Slice(ips, func(i, j int) bool {
+		return bytes.Compare(ips[i], ips[j]) < 0
+	})
+
+	return ips
+}

internal/provider/mullvad/updater/ips_test.go

@@ -0,0 +1,41 @@
+package mullvad
+
+import (
+	"net"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_uniqueSortedIPs(t *testing.T) {
+	t.Parallel()
+	testCases := map[string]struct {
+		inputIPs  []net.IP
+		outputIPs []net.IP
+	}{
+		"nil": {
+			inputIPs:  nil,
+			outputIPs: []net.IP{},
+		},
+		"empty": {
+			inputIPs:  []net.IP{},
+			outputIPs: []net.IP{},
+		},
+		"single IPv4": {
+			inputIPs:  []net.IP{{1, 1, 1, 1}},
+			outputIPs: []net.IP{{1, 1, 1, 1}},
+		},
+		"two IPv4s": {
+			inputIPs:  []net.IP{{1, 1, 2, 1}, {1, 1, 1, 1}},
+			outputIPs: []net.IP{{1, 1, 1, 1}, {1, 1, 2, 1}},
+		},
+	}
+	for name, testCase := range testCases {
+		testCase := testCase
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+			outputIPs := uniqueSortedIPs(testCase.inputIPs)
+			assert.Equal(t, testCase.outputIPs, outputIPs)
+		})
+	}
+}

internal/provider/mullvad/updater/servers.go

@@ -0,0 +1,40 @@
+// Package mullvad contains code to obtain the server information
+// for the Mullvad provider.
+package mullvad
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+
+	"github.com/qdm12/gluetun/internal/models"
+)
+
+var ErrNotEnoughServers = errors.New("not enough servers found")
+
+func GetServers(ctx context.Context, client *http.Client, minServers int) (
+	servers []models.Server, err error) {
+	data, err := fetchAPI(ctx, client)
+	if err != nil {
+		return nil, err
+	}
+
+	hts := make(hostToServer)
+	for _, serverData := range data {
+		if err := hts.add(serverData); err != nil {
+			return nil, err
+		}
+	}
+
+	if len(hts) < minServers {
+		return nil, fmt.Errorf("%w: %d and expected at least %d",
+			ErrNotEnoughServers, len(hts), minServers)
+	}
+
+	servers = hts.toServersSlice()
+
+	sortServers(servers)
+
+	return servers, nil
+}

internal/provider/mullvad/updater/sort.go

@@ -0,0 +1,22 @@
+package mullvad
+
+import (
+	"sort"
+
+	"github.com/qdm12/gluetun/internal/models"
+)
+
+func sortServers(servers []models.Server) {
+	sort.Slice(servers, func(i, j int) bool {
+		if servers[i].Country == servers[j].Country {
+			if servers[i].City == servers[j].City {
+				if servers[i].Hostname == servers[j].Hostname {
+					return servers[i].ISP < servers[j].ISP
+				}
+				return servers[i].Hostname < servers[j].Hostname
+			}
+			return servers[i].City < servers[j].City
+		}
+		return servers[i].Country < servers[j].Country
+	})
+}