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

internal/provider/ivpn/updater/api.go

@@ -0,0 +1,64 @@
+package ivpn
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+)
+
+var (
+	errHTTPStatusCodeNotOK = errors.New("HTTP status code not OK")
+)
+
+type apiData struct {
+	Servers []apiServer `json:"servers"`
+}
+
+type apiServer struct {
+	Hostnames apiHostnames `json:"hostnames"`
+	IsActive  bool         `json:"is_active"`
+	Country   string       `json:"country"`
+	City      string       `json:"city"`
+	ISP       string       `json:"isp"`
+	WgPubKey  string       `json:"wg_public_key"`
+}
+
+type apiHostnames struct {
+	OpenVPN   string `json:"openvpn"`
+	Wireguard string `json:"wireguard"`
+}
+
+func fetchAPI(ctx context.Context, client *http.Client) (
+	data apiData, err error) {
+	const url = "https://api.ivpn.net/v4/servers/stats"
+
+	request, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
+	if err != nil {
+		return data, err
+	}
+
+	response, err := client.Do(request)
+	if err != nil {
+		return data, err
+	}
+
+	if response.StatusCode != http.StatusOK {
+		_ = response.Body.Close()
+		return data, fmt.Errorf("%w: %d %s",
+			errHTTPStatusCodeNotOK, response.StatusCode, response.Status)
+	}
+
+	decoder := json.NewDecoder(response.Body)
+	if err := decoder.Decode(&data); err != nil {
+		_ = response.Body.Close()
+		return data, fmt.Errorf("failed unmarshaling response body: %w", err)
+	}
+
+	if err := response.Body.Close(); err != nil {
+		return data, fmt.Errorf("cannot close response body: %w", err)
+	}
+
+	return data, nil
+}

internal/provider/ivpn/updater/api_test.go

@@ -0,0 +1,96 @@
+package ivpn
+
+import (
+	"context"
+	"errors"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func Test_fetchAPI(t *testing.T) {
+	t.Parallel()
+
+	testCases := map[string]struct {
+		responseStatus int
+		responseBody   io.ReadCloser
+		data           apiData
+		err            error
+	}{
+		"http response status not ok": {
+			responseStatus: http.StatusNoContent,
+			err:            errors.New("HTTP status code not OK: 204 No Content"),
+		},
+		"nil body": {
+			responseStatus: http.StatusOK,
+			err:            errors.New("failed unmarshaling response body: EOF"),
+		},
+		"no server": {
+			responseStatus: http.StatusOK,
+			responseBody:   ioutil.NopCloser(strings.NewReader(`{}`)),
+		},
+		"success": {
+			responseStatus: http.StatusOK,
+			responseBody: ioutil.NopCloser(strings.NewReader(`{"servers":[
+				{"country":"Country1","city":"City A","isp":"xyz","is_active":true,"hostnames":{"openvpn":"hosta"}},
+				{"country":"Country2","city":"City B","isp":"abc","is_active":false,"hostnames":{"openvpn":"hostb"}}
+			]}`)),
+			data: apiData{
+				Servers: []apiServer{
+					{
+						Country:  "Country1",
+						City:     "City A",
+						IsActive: true,
+						ISP:      "xyz",
+						Hostnames: apiHostnames{
+							OpenVPN: "hosta",
+						},
+					},
+					{
+						Country: "Country2",
+						City:    "City B",
+						ISP:     "abc",
+						Hostnames: apiHostnames{
+							OpenVPN: "hostb",
+						},
+					},
+				},
+			},
+		},
+	}
+	for name, testCase := range testCases {
+		testCase := testCase
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			ctx := context.Background()
+
+			client := &http.Client{
+				Transport: roundTripFunc(func(r *http.Request) (*http.Response, error) {
+					assert.Equal(t, http.MethodGet, r.Method)
+					assert.Equal(t, r.URL.String(), "https://api.ivpn.net/v4/servers/stats")
+					return &http.Response{
+						StatusCode: testCase.responseStatus,
+						Status:     http.StatusText(testCase.responseStatus),
+						Body:       testCase.responseBody,
+					}, nil
+				}),
+			}
+
+			data, err := fetchAPI(ctx, client)
+
+			assert.Equal(t, testCase.data, data)
+			if testCase.err != nil {
+				require.Error(t, err)
+				assert.Equal(t, testCase.err.Error(), err.Error())
+			} else {
+				assert.NoError(t, err)
+			}
+		})
+	}
+}

internal/provider/ivpn/updater/resolve.go

@@ -0,0 +1,37 @@
+package ivpn
+
+import (
+	"context"
+	"net"
+	"time"
+
+	"github.com/qdm12/gluetun/internal/updater/resolver"
+)
+
+func getResolveSettings(minServers int) (settings resolver.ParallelSettings) {
+	const (
+		maxFailRatio    = 0.1
+		maxDuration     = 20 * time.Second
+		betweenDuration = time.Second
+		maxNoNew        = 2
+		maxFails        = 2
+	)
+	return resolver.ParallelSettings{
+		MaxFailRatio: maxFailRatio,
+		MinFound:     minServers,
+		Repeat: resolver.RepeatSettings{
+			MaxDuration:     maxDuration,
+			BetweenDuration: betweenDuration,
+			MaxNoNew:        maxNoNew,
+			MaxFails:        maxFails,
+			SortIPs:         true,
+		},
+	}
+}
+
+func resolveHosts(ctx context.Context, presolver resolver.Parallel,
+	hosts []string, minServers int) (hostToIPs map[string][]net.IP,
+	warnings []string, err error) {
+	settings := getResolveSettings(minServers)
+	return presolver.Resolve(ctx, hosts, settings)
+}

internal/provider/ivpn/updater/resolve_test.go

@@ -0,0 +1,57 @@
+package ivpn
+
+import (
+	"context"
+	"errors"
+	"net"
+	"testing"
+	"time"
+
+	"github.com/golang/mock/gomock"
+	"github.com/qdm12/gluetun/internal/updater/resolver"
+	"github.com/qdm12/gluetun/internal/updater/resolver/mock_resolver"
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_resolveHosts(t *testing.T) {
+	t.Parallel()
+	ctrl := gomock.NewController(t)
+
+	ctx := context.Background()
+	presolver := mock_resolver.NewMockParallel(ctrl)
+	hosts := []string{"host1", "host2"}
+	const minServers = 10
+
+	expectedHostToIPs := map[string][]net.IP{
+		"host1": {{1, 2, 3, 4}},
+		"host2": {{2, 3, 4, 5}},
+	}
+	expectedWarnings := []string{"warning1", "warning2"}
+	expectedErr := errors.New("dummy")
+
+	const (
+		maxFailRatio    = 0.1
+		maxDuration     = 20 * time.Second
+		betweenDuration = time.Second
+		maxNoNew        = 2
+		maxFails        = 2
+	)
+	expectedSettings := resolver.ParallelSettings{
+		MaxFailRatio: maxFailRatio,
+		MinFound:     minServers,
+		Repeat: resolver.RepeatSettings{
+			MaxDuration:     maxDuration,
+			BetweenDuration: betweenDuration,
+			MaxNoNew:        maxNoNew,
+			MaxFails:        maxFails,
+			SortIPs:         true,
+		},
+	}
+	presolver.EXPECT().Resolve(ctx, hosts, expectedSettings).
+		Return(expectedHostToIPs, expectedWarnings, expectedErr)
+
+	hostToIPs, warnings, err := resolveHosts(ctx, presolver, hosts, minServers)
+	assert.Equal(t, expectedHostToIPs, hostToIPs)
+	assert.Equal(t, expectedWarnings, warnings)
+	assert.Equal(t, expectedErr, err)
+}

internal/provider/ivpn/updater/roundtrip_test.go

@@ -0,0 +1,9 @@
+package ivpn
+
+import "net/http"
+
+type roundTripFunc func(r *http.Request) (*http.Response, error)
+
+func (f roundTripFunc) RoundTrip(r *http.Request) (*http.Response, error) {
+	return f(r)
+}

internal/provider/ivpn/updater/servers.go

@@ -0,0 +1,82 @@
+// Package ivpn contains code to obtain the server information
+// for the Surshark provider.
+package ivpn
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+
+	"github.com/qdm12/gluetun/internal/constants/vpn"
+	"github.com/qdm12/gluetun/internal/models"
+	"github.com/qdm12/gluetun/internal/updater/resolver"
+)
+
+var (
+	ErrNotEnoughServers = errors.New("not enough servers found")
+)
+
+func GetServers(ctx context.Context, client *http.Client,
+	presolver resolver.Parallel, minServers int) (
+	servers []models.Server, warnings []string, err error) {
+	data, err := fetchAPI(ctx, client)
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed fetching API: %w", err)
+	}
+
+	hosts := make([]string, 0, len(data.Servers))
+
+	for _, serverData := range data.Servers {
+		openVPNHost := serverData.Hostnames.OpenVPN
+		if openVPNHost != "" {
+			hosts = append(hosts, openVPNHost)
+		}
+
+		wireguardHost := serverData.Hostnames.Wireguard
+		if wireguardHost != "" {
+			hosts = append(hosts, wireguardHost)
+		}
+	}
+
+	if len(hosts) < minServers {
+		return nil, nil, fmt.Errorf("%w: %d and expected at least %d",
+			ErrNotEnoughServers, len(hosts), minServers)
+	}
+
+	hostToIPs, warnings, err := resolveHosts(ctx, presolver, hosts, minServers)
+	if err != nil {
+		return nil, warnings, err
+	}
+
+	servers = make([]models.Server, 0, len(hosts))
+	for _, serverData := range data.Servers {
+		vpnType := vpn.OpenVPN
+		hostname := serverData.Hostnames.OpenVPN
+		tcp := true
+		wgPubKey := ""
+		if hostname == "" {
+			vpnType = vpn.Wireguard
+			hostname = serverData.Hostnames.Wireguard
+			tcp = false
+			wgPubKey = serverData.WgPubKey
+		}
+
+		server := models.Server{
+			VPN:      vpnType,
+			Country:  serverData.Country,
+			City:     serverData.City,
+			ISP:      serverData.ISP,
+			Hostname: hostname,
+			WgPubKey: wgPubKey,
+			TCP:      tcp,
+			UDP:      true,
+			IPs:      hostToIPs[hostname],
+		}
+		servers = append(servers, server)
+	}
+
+	sortServers(servers)
+
+	return servers, warnings, nil
+}

internal/provider/ivpn/updater/servers_test.go

@@ -0,0 +1,141 @@
+package ivpn
+
+import (
+	"context"
+	"errors"
+	"io/ioutil"
+	"net"
+	"net/http"
+	"strings"
+	"testing"
+
+	"github.com/golang/mock/gomock"
+	"github.com/qdm12/gluetun/internal/constants/vpn"
+	"github.com/qdm12/gluetun/internal/models"
+	"github.com/qdm12/gluetun/internal/updater/resolver"
+	"github.com/qdm12/gluetun/internal/updater/resolver/mock_resolver"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func Test_GetServers(t *testing.T) {
+	t.Parallel()
+
+	testCases := map[string]struct {
+		// Inputs
+		minServers int
+
+		// From API
+		responseBody   string
+		responseStatus int
+
+		// Resolution
+		expectResolve   bool
+		hostsToResolve  []string
+		resolveSettings resolver.ParallelSettings
+		hostToIPs       map[string][]net.IP
+		resolveWarnings []string
+		resolveErr      error
+
+		// Output
+		servers  []models.Server
+		warnings []string
+		err      error
+	}{
+		"http response error": {
+			responseStatus: http.StatusNoContent,
+			err:            errors.New("failed fetching API: HTTP status code not OK: 204 No Content"),
+		},
+		"resolve error": {
+			responseBody: `{"servers":[
+				{"hostnames":{"openvpn":"hosta"}}
+			]}`,
+			responseStatus:  http.StatusOK,
+			expectResolve:   true,
+			hostsToResolve:  []string{"hosta"},
+			resolveSettings: getResolveSettings(0),
+			resolveWarnings: []string{"resolve warning"},
+			resolveErr:      errors.New("dummy"),
+			warnings:        []string{"resolve warning"},
+			err:             errors.New("dummy"),
+		},
+		"not enough servers": {
+			minServers: 2,
+			responseBody: `{"servers":[
+				{"hostnames":{"openvpn":"hosta"}}
+			]}`,
+			responseStatus: http.StatusOK,
+			err:            errors.New("not enough servers found: 1 and expected at least 2"),
+		},
+		"success": {
+			minServers: 1,
+			responseBody: `{"servers":[
+				{"country":"Country1","city":"City A","hostnames":{"openvpn":"hosta"}},
+				{"country":"Country2","city":"City B","hostnames":{"openvpn":"hostb"},"wg_public_key":"xyz"},
+				{"country":"Country3","city":"City C","hostnames":{"wireguard":"hostc"},"wg_public_key":"xyz"}
+			]}`,
+			responseStatus:  http.StatusOK,
+			expectResolve:   true,
+			hostsToResolve:  []string{"hosta", "hostb", "hostc"},
+			resolveSettings: getResolveSettings(1),
+			hostToIPs: map[string][]net.IP{
+				"hosta": {{1, 1, 1, 1}, {2, 2, 2, 2}},
+				"hostb": {{3, 3, 3, 3}, {4, 4, 4, 4}},
+				"hostc": {{5, 5, 5, 5}, {6, 6, 6, 6}},
+			},
+			resolveWarnings: []string{"resolve warning"},
+			servers: []models.Server{
+				{VPN: vpn.OpenVPN, Country: "Country1",
+					City: "City A", Hostname: "hosta", TCP: true, UDP: true,
+					IPs: []net.IP{{1, 1, 1, 1}, {2, 2, 2, 2}}},
+				{VPN: vpn.OpenVPN, Country: "Country2",
+					City: "City B", Hostname: "hostb", TCP: true, UDP: true,
+					IPs: []net.IP{{3, 3, 3, 3}, {4, 4, 4, 4}}},
+				{VPN: vpn.Wireguard,
+					Country: "Country3", City: "City C",
+					Hostname: "hostc", UDP: true,
+					WgPubKey: "xyz",
+					IPs:      []net.IP{{5, 5, 5, 5}, {6, 6, 6, 6}}},
+			},
+			warnings: []string{"resolve warning"},
+		},
+	}
+	for name, testCase := range testCases {
+		testCase := testCase
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+			ctrl := gomock.NewController(t)
+
+			ctx := context.Background()
+
+			client := &http.Client{
+				Transport: roundTripFunc(func(r *http.Request) (*http.Response, error) {
+					assert.Equal(t, http.MethodGet, r.Method)
+					assert.Equal(t, r.URL.String(), "https://api.ivpn.net/v4/servers/stats")
+					return &http.Response{
+						StatusCode: testCase.responseStatus,
+						Status:     http.StatusText(testCase.responseStatus),
+						Body:       ioutil.NopCloser(strings.NewReader(testCase.responseBody)),
+					}, nil
+				}),
+			}
+
+			presolver := mock_resolver.NewMockParallel(ctrl)
+			if testCase.expectResolve {
+				presolver.EXPECT().Resolve(ctx, testCase.hostsToResolve, testCase.resolveSettings).
+					Return(testCase.hostToIPs, testCase.resolveWarnings, testCase.resolveErr)
+			}
+
+			servers, warnings, err := GetServers(ctx, client, presolver, testCase.minServers)
+
+			assert.Equal(t, testCase.servers, servers)
+			assert.Equal(t, testCase.warnings, warnings)
+			if testCase.err != nil {
+				require.Error(t, err)
+				assert.Equal(t, testCase.err.Error(), err.Error())
+			} else {
+				assert.NoError(t, err)
+			}
+		})
+	}
+}

internal/provider/ivpn/updater/sort.go

@@ -0,0 +1,22 @@
+package ivpn
+
+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].VPN < servers[j].VPN
+				}
+				return servers[i].Hostname < servers[j].Hostname
+			}
+			return servers[i].City < servers[j].City
+		}
+		return servers[i].Country < servers[j].Country
+	})
+}

internal/provider/ivpn/updater/sort_test.go

@@ -0,0 +1,40 @@
+package ivpn
+
+import (
+	"testing"
+
+	"github.com/qdm12/gluetun/internal/models"
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_sortServers(t *testing.T) {
+	t.Parallel()
+	testCases := map[string]struct {
+		initialServers []models.Server
+		sortedServers  []models.Server
+	}{
+		"no server": {},
+		"sorted servers": {
+			initialServers: []models.Server{
+				{Country: "B", City: "A", Hostname: "A"},
+				{Country: "A", City: "A", Hostname: "B"},
+				{Country: "A", City: "A", Hostname: "A"},
+				{Country: "A", City: "B", Hostname: "A"},
+			},
+			sortedServers: []models.Server{
+				{Country: "A", City: "A", Hostname: "A"},
+				{Country: "A", City: "A", Hostname: "B"},
+				{Country: "A", City: "B", Hostname: "A"},
+				{Country: "B", City: "A", Hostname: "A"},
+			},
+		},
+	}
+	for name, testCase := range testCases {
+		testCase := testCase
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+			sortServers(testCase.initialServers)
+			assert.Equal(t, testCase.sortedServers, testCase.initialServers)
+		})
+	}
+}